Metadata-Version: 2.4
Name: agent-eval-rpc
Version: 0.144.9
Summary: Python RPC client, official optimizer bridge, and DSPy metric adapter for @tangle-network/agent-eval.
Project-URL: Homepage, https://github.com/tangle-network/agent-eval
Project-URL: Issues, https://github.com/tangle-network/agent-eval/issues
Project-URL: Documentation, https://github.com/tangle-network/agent-eval/blob/main/clients/python/README.md
Author: Tangle Network
License: MIT
Keywords: agent,evaluation,judge,llm,rubric
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Quality Assurance
Requires-Python: >=3.10
Requires-Dist: filelock>=3.16
Requires-Dist: httpx>=0.27
Requires-Dist: pydantic>=2.6
Provides-Extra: dev
Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
Requires-Dist: pytest>=8.0; extra == 'dev'
Requires-Dist: ruff>=0.6; extra == 'dev'
Provides-Extra: dspy
Requires-Dist: deno==2.7.14; extra == 'dspy'
Requires-Dist: dspy==3.2.1; extra == 'dspy'
Description-Content-Type: text/markdown

# `agent-eval-rpc` Python Client

`agent-eval-rpc` lets Python programs call the judging and ingestion APIs implemented by `@tangle-network/agent-eval`.
The Python package validates requests and responses with Pydantic.
The Node package owns rubric execution, model calls, and scoring.

## Install

Python 3.10 or newer and Node.js 20 or newer are required.
Install matching package versions:

```sh
pip install agent-eval-rpc
npm install --global @tangle-network/agent-eval
```

Configure an OpenAI-compatible model endpoint for judge calls:

```sh
export AGENT_EVAL_LLM_BASE_URL=https://api.openai.com/v1
export AGENT_EVAL_LLM_API_KEY="$YOUR_API_KEY"
export AGENT_EVAL_LLM_MODEL=gpt-4.1-mini
```

`OPENAI_BASE_URL`, `OPENAI_API_KEY`, and `OPENAI_MODEL` are also accepted.
The endpoint receives the content, rubric, and context passed to `client.judge()`.

## Judge Content

```python
from agent_eval_rpc import Client

client = Client()
result = client.judge(
    content="The retry budget is checked before each provider call.",
    rubric_name="anti-slop",
)

print(result.composite)
print(result.dimensions)
print(result.failure_modes)
print(result.rationale)
```

`Client()` first checks for an HTTP server at `http://127.0.0.1:5005`.
If none is running, it invokes `agent-eval rpc` as a subprocess.
Inspect `client.transport` to see which path was selected.

For repeated or concurrent calls, start the server once:

```sh
agent-eval serve --port 5005
```

Then force HTTP from Python when desired:

```python
client = Client(transport="http", base_url="http://127.0.0.1:5005")
```

## Define A Rubric

Use a built-in rubric by name or pass an inline rubric.
Exactly one is required.

```python
from agent_eval_rpc import Client, FailureMode, Rubric, RubricDimension

rubric = Rubric(
    name="commit-message",
    description="Checks whether a commit message explains why the change exists.",
    systemPrompt="Score the commit message using the supplied response schema.",
    dimensions=[
        RubricDimension(
            id="explains_why",
            description="The message states the reason for the change.",
            weight=1.0,
        ),
    ],
    failureModes=[
        FailureMode(
            id="what-only",
            description="The message states the edit without its reason.",
        ),
    ],
)

result = Client().judge(content="fix retry accounting", rubric=rubric)
```

List the built-in rubrics and their version hashes:

```python
for rubric in Client().list_rubrics().rubrics:
    print(rubric.name, rubric.rubric_version)
```

## Client Options

```python
Client(
    base_url: str | None = None,
    cli_path: str | None = None,
    transport: "auto" | "http" | "subprocess" = "auto",
    timeout_s: float = 200.0,
)
```

`client.judge()` returns:

| Field | Meaning |
|---|---|
| `composite` | Weighted score from `0` to `1` |
| `dimensions` | Score for each rubric dimension |
| `failure_modes` | Detected negative-pattern IDs |
| `wins` | Detected positive-pattern IDs |
| `rationale` | Model explanation |
| `rubric_version` | Stable rubric hash used for comparison |
| `model` | Model reported by the provider |
| `duration_ms` | Total call duration |

## Hosted Event Ingestion

`HostedClient` sends evaluation events and trace spans to a server that implements the hosted ingest format.
This is separate from `Client`, which calls the local judging API.

```python
from agent_eval_rpc import HostedClient

with HostedClient(
    endpoint="https://your-ingest.example",
    api_key="tenant-token",
    tenant_id="acme",
) as client:
    response = client.ingest_eval_run(event)
    assert response.accepted == 1
```

Review [`hosted.py`](./src/agent_eval_rpc/hosted.py) for the typed event fields and retry behavior.
The event payload can include run paths, scenario IDs, candidate values, scores, errors, costs, summaries, and trace attributes.

## Official Optimizer Bridges

The TypeScript campaign API can run official GEPA and SkillOpt through this package.
The Python client does not reimplement either algorithm.

### GEPA

Install the client and published GEPA package for the standard engine:

```sh
python -m pip install agent-eval-rpc
python -m pip install "gepa[full]==0.1.4"
```

The published package runs direct recipes with the standard `gepa` engine.
Sequential, adaptive, best-of, vote, Omni, AutoResearch, Meta Harness, and Best-of-N currently require this tested official source revision:

```sh
python -m pip install \
  "gepa[full] @ git+https://github.com/gepa-ai/gepa.git@f919db0a622e2e9f9204779b81fe00cc1b2d808f"
```

From an Agent Eval source checkout:

```sh
uv sync --frozen --group gepa-release
uv sync --frozen --group gepa-source
```

The bridge calls GEPA's official engine and composition functions.
It supports direct engine, sequential, adaptive sequential, best-of, vote, and Omni recipes.
GEPA receives only the serialized train and selection cases supplied by the caller.
`compareOptimizationMethods()` keeps final cases in TypeScript and evaluates them only after GEPA exits.

Every engine run requires an evaluation limit and an optimizer-model dollar limit.
Agent Eval enforces callback counts before executing an agent or judge.
For standard GEPA engines, the TypeScript `optimizer` option routes reflection through Agent Eval's local model proxy.
The proxy enforces whole-run request and dollar limits, keeps the provider key out of Python, and records exact provider usage in the shared cost log.
Other official GEPA engines can still receive their native configuration.
Their external model spend remains incomplete unless that engine reports it.

### SkillOpt

Install the client and the exact SkillOpt source revision tested by Agent Eval:

```sh
python -m pip install agent-eval-rpc
python -m pip install \
  "skillopt @ git+https://github.com/microsoft/SkillOpt.git@61735e3922efc2b90c6d6cab561e62e98452ca90"
```

From an Agent Eval source checkout, install the locked package with:

```sh
uv sync --frozen --group skillopt-source
```

The published `skillopt==0.2.0` wheel omits the 21 prompt files required by `ReflACTTrainer`.
The source revision contains those files and is checked before each release.

`skillOptOptimizationMethod()` runs SkillOpt's `ReflACTTrainer` with an Agent Eval environment adapter.
The adapter sends candidate and case pairs back to the TypeScript process for execution and scoring.
It disables SkillOpt's test split because final cases remain private to `compareOptimizationMethods()`.

The TypeScript method requires:

- an OpenAI-compatible endpoint and key in the TypeScript method's `optimizer` option,
- exact input and output rates,
- maximum model dollars, requests, request bytes, response bytes, and output tokens,
- a maximum candidate evaluation count.

Agent Eval starts a local proxy, gives SkillOpt only the proxy credential, checks every request before forwarding it, and records provider token usage in the shared cost log.
Before optimization starts, it records and hashes the installed optimizer source, bridge source, Python runtime, runner settings, endpoint settings, data, and evaluation ID into one run ID.
The Python process checks that identity again before it restores any state.
Missing provider usage fails the run instead of assuming zero cost.

### DSPy

Install DSPy 3.2.1 and the Agent Eval adapters with:

```sh
python -m pip install "agent-eval-rpc[dspy]"
```

```python
import dspy

from agent_eval_rpc import DspyJudgeMetric

dspy.configure_cache(restrict_pickle=True)
metric = DspyJudgeMetric(rubric_name="answer-quality")

gepa = dspy.GEPA(
    metric=metric.feedback,
    reflection_lm=dspy.LM("openai/gpt-4.1-mini"),
    max_metric_calls=100,
)
optimized = gepa.compile(program, trainset=train, valset=selection)

mipro = dspy.MIPROv2(metric=metric, auto="light")
```

Use `metric.feedback` for `dspy.GEPA`.
It returns `dspy.Prediction(score=..., feedback=...)` with dimension scores, failure modes, wins, and rationale.
Use the metric object directly for MIPROv2, SIMBA, bootstrap, and evaluation APIs that expect a number.
Identical calls share one judge result, including concurrent calls.
`DspyJudgeMetric` rejects DSPy's default unrestricted disk-cache pickle handling.
Configure the official restricted cache as shown above, or call `dspy.configure_cache(enable_disk_cache=False)` before creating the metric.

DSPy programs should use DSPy's official optimizers directly.
Agent Eval also runs the official `dspy.RLM` for recursive trace analysis.
The TypeScript API starts the Python bridge, provides authenticated trace tools, calls a caller-owned model execution path, enforces model and trace-read limits, and validates cited findings.
The Python bridge owns no trace storage or model credentials.

```ts
import {
  createDspyRlmTraceEngine,
  type DspyRlmTraceEngineOptions,
} from '@tangle-network/agent-eval/analyst'
import { analyzeTraces } from '@tangle-network/agent-eval/traces'

type ModelOwner = Pick<
  DspyRlmTraceEngineOptions,
  'call' | 'callRef' | 'recordExecution'
>

export async function analyzeRun(modelOwner: ModelOwner) {
  const engine = createDspyRlmTraceEngine({
    ...modelOwner,
    model: 'deepseek-v4-flash',
    pricing: {
      inputUsdPerMillion: 3,
      outputUsdPerMillion: 15,
    },
    runner: { command: '.venv/bin/python' },
  })

  return analyzeTraces(
    { question: 'What first caused this run to fail?' },
    { source: 'run.otlp.jsonl', engine, toolGroup: 'singleTrace' },
  )
}
```

See [Trace Analysis](../../docs/trace-analysis.md) for custom definitions, limits, result fields, and the public quality benchmark.

DSPy 3.2.1 pins GEPA 0.0.27.
The general Optimize Anything bridge uses GEPA 0.1.4, so repository checks install them in separate environments:

```sh
uv sync --frozen --extra dev --group gepa-release
AGENT_EVAL_EXPECT_GEPA_RELEASE=1 \
  uv run --frozen --extra dev --group gepa-release \
  pytest tests/test_gepa_release_compatibility.py tests/test_gepa_bridge.py

uv sync --frozen --extra dev --group skillopt-source --group gepa-source
uv run --frozen pytest

uv sync --frozen --extra dev --extra dspy
uv run --frozen pytest tests/test_dspy_metric.py
```

The bridge records the installed upstream package version and source revision with each run.
SkillOpt and a direct GEPA engine can restore official state only when the package revision, settings, starting candidate, described data, evaluation ID, and seed match.
Direct GEPA resume also requires `trustResumeState: true` because its upstream checkpoint uses Python pickle.
Enable it only for a checkpoint created locally in a directory you control.
Composed GEPA recipes restart and never claim that upstream state was restored.

The official optimizer subprocess requires POSIX process-group cleanup.
Use Linux or WSL rather than native Windows so a timeout can terminate the complete Python process tree.

## Errors

| Exception | Meaning |
|---|---|
| `ValidationError` | The request does not match the Python or server schema |
| `RubricNotFoundError` | The named built-in rubric does not exist |
| `TransportError` | The HTTP server or subprocess could not be reached |
| `AgentEvalError` | Base class for client errors |

Errors include `.code` and `.details` when the server returned structured error data.

## Versions

The Python and npm packages are released with the same version.
Use `client.version()` to check the running Node package and wire-format version:

```python
version = Client().version()
print(version.version, version.wire_version)
```

## Development

```sh
cd clients/python
pip install -e ".[dev]"
pytest
```

Run the cross-language tests after building the Node package:

```sh
cd ../..
pnpm build
cd clients/python
pytest
```

The runnable Python example is [`examples/judge_anti_slop.py`](./examples/judge_anti_slop.py).