@tangle-network/agent-eval 0.44.1 → 0.46.0

package/docs/distributed-driver.md

@@ -0,0 +1,173 @@
+# Distributed driver — driver-on-A, workers-on-B (and C, D, E…)
+
+The driver (running `runCampaign` / `runImprovementLoop` / `gepaDriver`)
+and the worker (running your actual agent) **do not have to live in the
+same process, machine, region, or cloud.** `Dispatch` is just a
+function: scenario in, artifact out. Whatever returns the artifact is
+the worker — local, remote, sandboxed, or fanned out across a fleet.
+
+## Why you'd want this
+
+| Pattern | Reason |
+|---|---|
+| **Driver on your VPC, workers on our sandbox fleet** | Driver holds secrets, training data, prompt corpus; workers stay stateless and scale horizontally |
+| **Multi-region campaigns** | Each cell runs in the region closest to its target API (latency, compliance, data residency) |
+| **Driver-as-a-service** | Long-running optimization process; reuses across many short-lived worker invocations |
+| **Heterogeneous workers** | One cell on a CPU container, another on a GPU box, another against a third-party API — same Dispatch shape, different placement |
+| **Budget-isolated workers** | Worker boxes get scoped, time-bounded credentials; driver never holds production keys |
+
+## Two new pieces in 0.45.0
+
+| Where | What |
+|---|---|
+| **`DispatchContext.placement?: string`** | Opaque placement key the substrate forwards to the Dispatch. |
+| **`RunCampaignOptions.cellPlacement?(input) → string \| undefined`** | Strategy function the substrate calls per cell to compute the placement key. |
+| **`@tangle-network/agent-eval/adapters/http`** | `httpDispatch` (client) + `runDispatchServer` (server) — wire shape for HTTP-based remote workers. |
+
+Both ends of the wire are in the same package; no peer dep, no separate
+install. The substrate doesn't strategy-pick; you provide the
+`cellPlacement` function, the substrate forwards its result, the
+Dispatch reads it. Clean seam, no policy baked in.
+
+## The three reference topologies
+
+### 1. In-process (the default — what you already have)
+
+```ts
+await runCampaign({
+  scenarios,
+  dispatch,            // runs in-process
+  judges: [judge],
+  storage,
+  runDir,
+})
+```
+
+`ctx.placement` is `undefined`; nothing changes for existing consumers.
+This shipped in 0.40.
+
+### 2. Single remote worker
+
+Driver-on-A talks to one worker-on-B over HTTP.
+
+**Driver side (machine A):**
+
+```ts
+import { httpDispatch } from '@tangle-network/agent-eval/adapters/http'
+
+const dispatch = httpDispatch<MyScenario, MyArtifact>({
+  url: 'https://worker.your-infra.com/dispatch',
+  auth: process.env.WORKER_TOKEN,
+  timeoutMs: 5 * 60 * 1000,
+  retries: 2,
+})
+
+await runImprovementLoop({ scenarios, baselineSurface, dispatchWithSurface: (surface, s, ctx) =>
+  dispatch(s, { ...ctx, /* pass the surface through your own protocol */ }),
+  /* ... */ })
+```
+
+**Worker side (machine B):**
+
+```ts
+import { runDispatchServer } from '@tangle-network/agent-eval/adapters/http'
+
+const handle = await runDispatchServer<MyScenario, MyArtifact>({
+  dispatch: async (scenario, ctx) => {
+    // your agent — call OpenAI, LangChain, your sandbox, anything.
+    const artifact = await runMyAgent(scenario, ctx.signal)
+    return artifact
+  },
+  port: 8080,
+  auth: process.env.WORKER_TOKEN,  // required; `false` only for closed networks
+})
+console.log(`worker listening on ${handle.port}`)
+```
+
+Cancellation, retries on 5xx / 408 / 429, bounded timeouts, optional
+custom auth headers, optional `fetchImpl` override — all there.
+
+### 3. Multi-region fan-out
+
+Driver picks a region per cell; the same `httpDispatch` routes to
+different worker URLs based on placement.
+
+```ts
+import { httpDispatch } from '@tangle-network/agent-eval/adapters/http'
+
+const REGION_URLS: Record<string, string> = {
+  'us-east': 'https://worker-use1.your-infra.com/dispatch',
+  'eu-west': 'https://worker-euw1.your-infra.com/dispatch',
+  'ap-south': 'https://worker-aps1.your-infra.com/dispatch',
+}
+
+const dispatch = httpDispatch<MyScenario, MyArtifact>({
+  resolveUrl: ({ placement }) => REGION_URLS[placement ?? 'us-east'],
+  auth: process.env.WORKER_TOKEN,
+})
+
+await runCampaign({
+  scenarios,
+  dispatch,
+  judges: [judge],
+  storage,
+  runDir,
+  cellPlacement: ({ scenario }) => {
+    if (scenario.tags?.includes('eu')) return 'eu-west'
+    if (scenario.tags?.includes('ap')) return 'ap-south'
+    return 'us-east'
+  },
+  maxConcurrency: 8,  // 8 cells fan across regions in parallel
+})
+```
+
+`cellPlacement` is a pure function the substrate calls per cell — no
+state. Use whatever signal you want (tags, hash of scenario id,
+round-robin, region-affinity from a previous run, scheduling table).
+
+## What's preserved across the wire
+
+| Concern | How |
+|---|---|
+| **Cancellation** | Driver's `AbortSignal` forwards into the HTTP request; server translates `AbortError` → `499` so client doesn't retry. |
+| **Timeouts** | Per-call `timeoutMs` on the client; server can layer its own. |
+| **Retries** | Idempotent retries on 5xx / 408 / 429 with exponential backoff + jitter. Driver-aborts never retry. |
+| **Auth** | Bearer token on `Authorization`; pluggable via `auth: string \| () => string \| Promise<string>` for rotation/refresh. |
+| **Payload size** | Server enforces `maxBodyBytes` (default 10 MB). |
+| **Traces** | Both ends emit OTel — if both point at the same OTLP collector, you get a unified trace per cell. See `docs/adapters-observability.md`. |
+| **Cost** | Worker's `ctx.cost.observe(usd, source)` is local to the worker process. Roll up server-side and attach to your worker-side telemetry; we don't (yet) forward cost back to the driver. Tracked as follow-up. |
+
+## Running the reference example
+
+See `examples/distributed-driver/`:
+
+```sh
+# Terminal 1 — worker
+pnpm tsx examples/distributed-driver/worker.ts
+
+# Terminal 2 — driver
+WORKER_URL=http://localhost:8080/dispatch \
+WORKER_TOKEN=dev-token \
+pnpm tsx examples/distributed-driver/driver.ts
+```
+
+Two processes, one local TCP loopback, full self-improvement loop end
+to end. Scaling out is dropping `WORKER_URL` to a non-loopback hostname
+and using `cellPlacement` to fan across many of them.
+
+## Known gaps + follow-ups
+
+- **Cost roll-up across the wire** — worker-side `ctx.cost` observations
+  stay on the worker. We need to forward them in the response body so
+  `defaultProductionGate`'s `budgetUsd` ceiling reflects total spend, not
+  driver-side spend. Tracked as a 0.45.x follow-up.
+- **Per-cell artifact streaming** — when the worker writes intermediate
+  artifacts via `ctx.artifacts.write`, those land on the worker's
+  storage. For multi-worker campaigns you'll want a shared object store
+  (S3/GCS) reachable from both sides; today consumers wire that as a
+  `CampaignStorage` impl. A reference S3-backed storage is on the
+  roadmap.
+- **gRPC / NATS / Temporal transports** — the wire is HTTP today by
+  default because everything speaks HTTP. Other transports can ship as
+  additional adapters; the `Dispatch` interface itself is
+  transport-agnostic.

package/docs/phase-b-pairing-kit.md

@@ -0,0 +1,188 @@
+# Phase-B partner pairing kit
+
+Everything we hand a design partner — the pitch, the discovery doc,
+the judge worksheet, the 4-hour pairing agenda, the success criteria.
+
+> This file is **partner-facing**. The internal driving runbook is in
+> [`phase-b-runbook.md`](./phase-b-runbook.md).
+
+---
+
+## The pitch (one-pager)
+
+You have a working agent. You don't have evals. You don't have a
+self-improvement loop. You don't know which prompt change actually
+made the agent better last week.
+
+We have all of that on a shelf — same engine our six internal product
+agents use in production. It's open source, free at the LAND tier, and
+sandbox-free if you don't want our sandbox.
+
+**The Phase-B offer:** in one 4-hour pairing, we wrap your agent
+behind our `Dispatch`, author your domain-specific judge with you,
+and run one real campaign + improvement loop on **your actual use
+case**. You walk away with:
+
+- A reproducible eval harness against scenarios you control.
+- A judge that scores your outputs on dimensions you defined.
+- One measurable lift on your real product, with a held-out gate.
+- Trace artifacts you own (locally on disk; nothing leaves your
+  network unless you point at our hosted tier).
+
+What we get: design-partner evidence the substrate works on a foreign
+agent we did not build. That validates the wedge for us. Nothing else
+changes hands.
+
+**Cost to you:** 4 hours of pairing + your LLM bill for the campaign
+run (typically $5-$50 depending on model + scenario count). No
+commitment, no contract, no exclusivity. We don't take your code, your
+data, or your secrets.
+
+---
+
+## Discovery questions (15 min, before the pairing)
+
+Send these to the partner ahead of the pairing so they walk in with
+their answers.
+
+### About the agent
+
+1. What does your agent **do** — one paragraph, end-user perspective?
+2. What's the **input** it accepts and the **output** it produces?
+   (Schemas help; English is fine.)
+3. What framework / stack? (LangChain / Mastra / OpenAI Agents SDK /
+   bespoke / something else.)
+4. Where does it run? (Local node / serverless / your sandbox /
+   browser / mobile / other.)
+5. What model(s) does it use today? Any model-routing layer
+   (OpenRouter, Portkey, your own)?
+
+### About quality
+
+6. How do you currently know your agent is good? (Eyeballing /
+   user feedback / metrics / nothing yet — all fine answers.)
+7. What does a **bad** output look like for you? Give 2-3 concrete
+   examples. Be specific.
+8. What does a **good** output look like? Same.
+9. Are there outputs that are *technically correct but feel wrong*?
+   What's the signal?
+10. How would a senior person on your team **score** an output, if
+    they had to give it a 1-10? Walk us through the rubric they'd
+    use, even informally.
+
+### About the loop
+
+11. If we could improve one thing about the agent in 4 hours, what
+    would move the needle the most for you?
+12. Are there *prompt* changes you've wanted to try but haven't had
+    the loop to validate?
+13. Anything you've explicitly tried that **didn't** work? (Saves us
+    suggesting it.)
+
+---
+
+## Judge-design worksheet (45 min into the pairing)
+
+The judge is the most under-discussed piece of an eval system. Most
+projects fail at the judge, not the agent.
+
+We start with a **strawman** — the 6 dimensions in our canonical
+marketing-quality judge:
+
+| Dim | What it measures |
+|---|---|
+| hook_strength | Opens with concrete user outcome, not category |
+| voice_match | Reads human-written; no AI slop |
+| cta_clarity | Next step unambiguous for the audience |
+| factual_grounding | Only claims things the brief supports |
+| surface_fit | Length + register correct for medium |
+| audience_specificity | Vocabulary the audience actually responds to |
+
+**Your job in this 45 min:** rip this apart. We expect:
+
+- **2-3 of these are wrong for you.** Replace them.
+- **2-3 dimensions are missing.** Add them. (E.g., "tone matches our
+  brand book" or "safety-critical claim has a citation" or "answer is
+  decisive — no hedging when the user wants a recommendation".)
+- **Weights are wrong.** For your use case some dims matter 5x more.
+
+The deliverable: a judge with 4-8 dimensions, each scored 0.0 - 1.0,
+each unambiguous enough that two independent humans would score the
+same artifact within 0.1.
+
+If a dimension is squishy, throw it out. A noisy judge poisons the
+loop.
+
+---
+
+## The 4-hour pairing agenda
+
+### Hour 1 — Discovery + Dispatch wiring
+
+| Time | What | Deliverable |
+|---|---|---|
+| 0:00 - 0:15 | Review discovery answers, align on scope | Shared doc with goals + constraints |
+| 0:15 - 0:45 | Wire `Dispatch` around their agent — typically 1 function | Working `Dispatch<TScenario, TArtifact>` |
+| 0:45 - 1:00 | Run 1-2 scenarios through `Dispatch` manually; see real artifacts | Confirmed wire shape |
+
+### Hour 2 — Judge calibration
+
+| Time | What | Deliverable |
+|---|---|---|
+| 1:00 - 1:45 | Walk through the strawman judge; redesign dimensions with the partner | Final `JudgeConfig` for their domain |
+| 1:45 - 2:00 | Calibrate judge against the 2 manual outputs from Hour 1 | Confirmed judge gives same scores a human would |
+
+### Hour 3 — First campaign + tuning
+
+| Time | What | Deliverable |
+|---|---|---|
+| 2:00 - 2:30 | Define 8-15 scenarios with the partner (or use ours as a template) | Scenario set with train + holdout split |
+| 2:30 - 3:00 | Run `runEval` for baseline; review per-scenario scores | Baseline score + identified failure modes |
+
+### Hour 4 — Improvement loop + go/no-go
+
+| Time | What | Deliverable |
+|---|---|---|
+| 3:00 - 3:30 | Configure `runImprovementLoop` with `gepaDriver` (3 generations, population 2) + `defaultProductionGate` | Improvement run completes |
+| 3:30 - 3:50 | Walk the partner through the gate decision + lift per scenario | Report artifact |
+| 3:50 - 4:00 | Capture: was the lift real? Would they ship the winner? Will they keep using the lib? | **Go/no-go signal for Phase D** |
+
+If we're tracking ahead at any hour, use the slack to deepen — add a
+red-team battery, swap the judge model, run more generations. If we're
+behind, cut the scenario set to 6 and ship.
+
+---
+
+## Success criteria — what counts as Phase B passed
+
+For us to greenlight Phase D (hosted orchestrator + metered billing),
+we need ALL of:
+
+1. **Real lift.** Held-out winner score > baseline by ≥ 0.05 composite
+   points (or the partner's chosen threshold). Not just train; held-out.
+2. **Partner-validated lift.** The partner reads the winner output on
+   3+ held-out scenarios and confirms it's actually better.
+3. **Integration time ≤ 1 day.** Discovery + wiring + judge took ≤ 4
+   hours for the pairing; partner could reach the same point solo in
+   ≤ 1 day from the quickstart doc.
+4. **Public commitment.** Partner agrees to a public reference (case
+   study / quote / logo) OR commits to running the LAND tier in their
+   own product within 2 weeks.
+
+3-of-4 = soft pass (revisit Phase D scope but proceed). 4-of-4 = hard
+pass (build Phase D). ≤ 2 = fail (back to substrate iteration).
+
+---
+
+## What we don't ask for
+
+- Your code. Wire `Dispatch` around your existing API; we never see the
+  source.
+- Your customer data. Use synthetic scenarios or anonymized real ones —
+  whichever you prefer.
+- Your model keys. You bring your own; if you want, route through Tangle
+  Router and we never see the prompts either.
+- Exclusivity, commitment, or contract. Walk away whenever.
+
+The point is to learn if the substrate works for someone we didn't
+build it for. That's it.

package/docs/phase-b-runbook.md

@@ -0,0 +1,176 @@
+# Phase-B runbook (internal)
+
+How we drive a design-partner pairing. Goes alongside
+[`phase-b-pairing-kit.md`](./phase-b-pairing-kit.md) (the partner-facing
+materials) — this file is for us.
+
+---
+
+## Before the pairing
+
+- **24-48h prior:** send discovery questions from
+  [`phase-b-pairing-kit.md`](./phase-b-pairing-kit.md). Don't run the
+  pairing without answers in hand. The pairing fails when we discover
+  the partner's quality bar live; we don't have time to interview AND
+  build in 4 hours.
+- **48h prior:** run the canonical demo (`pnpm tsx
+  examples/marketing-agent-canonical/index.ts`) end-to-end against the
+  partner's preferred model. Confirms the substrate + their LLM tier
+  compose. If it errors, fix the substrate before the pairing.
+- **24h prior:** mirror the partner's stack locally. If they're on
+  Cloudflare Workers, run a Worker. On LangChain, install `@langchain/*`.
+  Don't debug their tooling on the call.
+- **1h prior:** open the pairing kit, the agent-eval repo, the partner's
+  agent code/endpoint, a shared doc, and a screenshare ready.
+
+## During the pairing
+
+### Driving principles
+
+- **Talk less, ship more.** The partner is paying with their time and
+  attention; every minute we talk we aren't shipping their lift.
+- **They write the judge.** We start with our strawman so they have
+  something to react to, but the judge that ends up running is theirs.
+  This is the most-discussed seam — they should own it.
+- **No invented features.** Don't promise capabilities that don't exist
+  ("we have a hosted ingest for this") unless they actually exist.
+  Phase B is honesty's purest test.
+- **Capture verbatim.** Write down their exact words on what's broken /
+  what would change their mind. The wedge-gate evidence is qualitative
+  too.
+
+### When to escalate to Drew
+
+- Partner wants something Phase D would have (hosted dashboard, multi-
+  tenant, billing). **Escalate same day** — this is the GTM signal we're
+  hunting for; Drew should hear it directly.
+- Partner is the wrong fit (technical or business) and the pairing
+  would burn both sides' time. **Pause the pairing**, debrief with Drew,
+  reschedule with a better-fit partner.
+- Substrate breaks in a way that requires a published bump. **Pause
+  the pairing**, ship the fix in a focused PR, resume.
+
+### What to capture for the wedge gate
+
+Per [`docs/design/external-agent-wedge.md`](./design/external-agent-wedge.md),
+the gate decision hinges on Phase B evidence. We capture:
+
+1. **Quantitative lift** — held-out winner composite vs baseline, per
+   scenario + overall. Auto-generated in the report artifact by the
+   canonical demo (`.phase-b-runs/<ts>/phase-b-report.md`).
+2. **Qualitative partner-validation** — partner read 3+ winner outputs
+   and confirmed they're better. Capture as a 1-paragraph quote.
+3. **Integration friction** — minutes spent on each pairing phase. Were
+   any > 2x estimated? What broke?
+4. **Judge-design surprise** — which dimensions the partner added or
+   killed vs our strawman. Strong signal about what the substrate's
+   default judge templates are missing for adjacent domains.
+5. **Soft commitments** — would they reference us? Would they
+   self-serve from the quickstart doc? Would they pay for hosted?
+
+Capture into a single `phase-b-debrief.md` per partner. We don't
+publish these; they feed the next substrate iteration + the wedge
+go/no-go.
+
+---
+
+## Failure modes — what we do NOT do
+
+### "We'll just optimize on the train set"
+
+Hard no. The held-out gate is the entire point. A win that doesn't
+generalize is worse than no win — it's evidence that the substrate
+overfits, which is the failure mode the wedge tier rewards.
+
+If the holdout lift is < threshold but train looks great:
+
+1. Show the partner the gap. Explain what overfitting means here.
+2. Try raising `maxGenerations` to 5 (gives gepa more search budget).
+3. Try widening `populationSize` to 3 (more diverse mutations per gen).
+4. If still no lift on holdout: **report the result honestly**. A
+   negative finding is real evidence for us too — tells us this surface
+   isn't amenable to prompt-only mutation, and the partner needs Phase
+   C (code-tier optimization) or a different approach.
+
+### "The judge is too noisy"
+
+A judge whose two-run variance > 0.1 on the same artifact is broken.
+Fixes, in order:
+
+1. Lower temperature to 0.0 (the canonical judge uses 0.2, which is
+   already low).
+2. Use a stronger model than the agent (default: same model. Bump the
+   judge to GPT-5.5 / Claude Opus.)
+3. Add anchors to each dimension ("0.0 = X, 0.5 = Y, 1.0 = Z").
+4. If still noisy: collapse to fewer, simpler dimensions. 3 unambiguous
+   dimensions beat 6 squishy ones.
+
+### "We can't decide what the partner's judge should be"
+
+Then we don't have Phase B. The judge IS the partner's quality bar.
+If they can't articulate it in 45 minutes of pairing, we're in the
+wrong pairing — they need to do the interview-themselves work first.
+
+**Pause the pairing, send the discovery doc again, regroup in a week.**
+
+### "Their agent is slow / expensive"
+
+`maxConcurrency: 1` and reduce scenarios to 6. Cost scales linearly;
+time scales as `(scenarios × reps × generations × population) /
+concurrency`. Tune until the loop completes in ≤ 30 min.
+
+If the per-call cost is > $1, talk to Drew before the pairing — we
+might want to subsidize the partner's first run.
+
+### "They want to share their secrets through Tangle Router"
+
+Fine — `OPENAI_BASE_URL=https://router.tangle.tools/v1` works. Make
+sure they understand: every call routes through us; the prompts and
+responses are visible to whatever observability we have on the router.
+If they want zero data leaving their network, point at their own
+endpoint, not Tangle Router.
+
+---
+
+## After the pairing
+
+### Same day
+
+- Save the `phase-b-report.md` artifact + the partner's debrief notes
+  to `~/company/design-partners/<partner>/<date>/`.
+- Send the partner a thank-you with the winner artifact + the next-
+  steps doc. Whether or not we proceed to Phase D, leave them with
+  something concrete they can ship in their product.
+- Slack Drew the verdict against the [success criteria](./phase-b-pairing-kit.md#success-criteria--what-counts-as-phase-b-passed).
+
+### Within a week
+
+- If Phase B passed: open the Phase D RFC. Reuse the partner-validated
+  judge dimensions + scenarios as the spec for what the hosted tier
+  needs to support out of the box.
+- If Phase B failed: substrate iteration ticket(s). Specific gaps the
+  pairing surfaced (judge dim defaults, doc clarity, missing helper).
+- Either way: update the wedge doc (`docs/design/external-agent-wedge.md`)
+  with the partner-name redacted + the qualitative signal.
+
+### Within a month (regardless of go/no-go)
+
+- Followup with the partner. If they're still using the lib, capture a
+  metric. If they stopped, find out why. Both data points feed product.
+
+---
+
+## The canonical demo as a forcing function
+
+`examples/marketing-agent-canonical/` is the demo we open the pairing
+with. It does three things at once:
+
+1. **Proves the substrate works** — they see a real lift on a real-
+   feeling agent before we touch their code.
+2. **Sets the bar for the judge conversation** — they react to concrete
+   dimensions, not abstract questions.
+3. **Trains us** — running the canonical demo before the pairing
+   surfaces substrate bugs on the partner's preferred model BEFORE the
+   partner is watching. We hit those bugs first.
+
+Run the canonical demo before every Phase-B pairing. It's not optional.

package/docs/quickstart-external.md

@@ -13,12 +13,51 @@ Tangle sandbox, no Tangle account, and no hosted infrastructure.
 ## Install
 
 ```sh
-npm i @tangle-network/agent-eval@^0.44.0
+npm i @tangle-network/agent-eval@^0.46.0
 ```
 
-The package's `@tangle-network/sandbox` peer is `optional` (as of
-0.44.0). Foreign consumers can install agent-eval and run the full LAND
-tier without our sandbox or its dependencies.
+The package's `@tangle-network/sandbox` peer is `optional`. Foreign
+consumers install agent-eval and run the full LAND tier without our
+sandbox or its dependencies.
+
+## The one-shot happy path
+
+If you don't want to learn the substrate, the entire LAND tier reduces
+to one function call:
+
+```ts
+import { selfImprove } from '@tangle-network/agent-eval/contract'
+
+const result = await selfImprove({
+  agent: (surface, scenario, ctx) =>
+    runYourAgent({ systemPrompt: surface as string, scenario, signal: ctx.signal }),
+  scenarios,
+  judge,
+  baselineSurface: 'You are a senior copywriter…',
+  budget: { dollars: 10, generations: 3 },
+})
+
+console.log(`lift: ${result.lift.toFixed(3)} (${result.gateDecision})`)
+if (result.gateDecision === 'ship') {
+  // result.winner.surface is the optimized prompt
+}
+```
+
+That's the LAND happy path. Smart defaults pick: in-memory storage,
+`gepaDriver` with copywriting-flavored mutation primitives,
+`defaultProductionGate` with `deltaThreshold: 0.05`, 25% deterministic
+train/holdout split.
+
+Every escape hatch the substrate exposes is reachable from
+`selfImprove` — custom `driver`, custom `gate`, distributed-driver
+`cellPlacement`, `onProgress` streaming callback, `autoOnPromote: 'pr'`
+to open a GitHub PR with the winner. See the type signatures in
+[`src/contract/self-improve.ts`](../src/contract/self-improve.ts) for
+the full surface.
+
+The sections below are the lower-level path — useful when you want
+fine-grained control over each piece. Read those next if `selfImprove`
+isn't enough.
 
 ## Five types, four functions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.44.1",
+  "version": "0.46.0",
   "description": "Substrate for self-improving agents: traces, verifiable rewards, preferences, GEPA / reflective mutation, auto-research, replay, sequential anytime-valid stats, and release gates.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {
@@ -114,6 +114,11 @@
       "import": "./dist/adapters/langchain.js",
       "default": "./dist/adapters/langchain.js"
     },
+    "./adapters/http": {
+      "types": "./dist/adapters/http.d.ts",
+      "import": "./dist/adapters/http.js",
+      "default": "./dist/adapters/http.js"
+    },
     "./openapi.json": {
       "default": "./dist/openapi.json"
     }