@tangle-network/agent-eval 0.44.0 → 0.45.0

package/dist/adapters/http.d.ts

@@ -0,0 +1,138 @@
+import { S as Scenario, D as DispatchFn, g as DispatchContext } from '../types-BURGZ8Ug.js';
+
+/**
+ * # `@tangle-network/agent-eval/adapters/http` — distributed Dispatch over HTTP.
+ *
+ * Decouples driver and worker. The driver (running `runImprovementLoop` or
+ * `runCampaign`) can live anywhere — your VPC, a dev laptop, a cron VM. The
+ * workers (running the actual agent) can live anywhere else — different
+ * regions, different clouds, different boxes — as long as they speak HTTP.
+ *
+ * Both sides:
+ *
+ *   - **`httpDispatch({ url | resolveUrl, ... })`** — client. Returns a
+ *     `Dispatch` that POSTs `{ scenario, ctx }` to a worker URL and parses
+ *     the artifact back. AbortSignal-aware, retries on idempotent errors,
+ *     bounded timeout per call.
+ *   - **`runDispatchServer({ dispatch, port, ... })`** — server. Wraps your
+ *     local `Dispatch` as an HTTP endpoint. Handles auth, JSON parsing,
+ *     error mapping, and cancellation when the client aborts.
+ *
+ * # Topology examples
+ *
+ * **Single-worker:** driver on box A, worker on box B. Set
+ * `httpDispatch({ url: 'https://box-b/dispatch' })`.
+ *
+ * **Multi-region:** N workers across regions. Use `httpDispatch({ resolveUrl })`
+ * with a function that picks the URL per cell from `ctx.placement`. Combined
+ * with `cellPlacement` on `RunCampaignOptions`, the substrate fans cells
+ * across geographies in parallel.
+ *
+ * **Driver-as-a-service:** driver runs as a long-lived process or service
+ * (holds optimization state across generations); workers are stateless
+ * HTTP services that can scale horizontally per cell.
+ */
+
+interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
+    /** Static endpoint URL. Mutually exclusive with `resolveUrl`. */
+    url?: string;
+    /**
+     * Dynamic per-cell URL resolver. Receives the scenario + the substrate
+     * placement key (from `RunCampaignOptions.cellPlacement`) and returns the
+     * worker URL to invoke. Mutually exclusive with `url`.
+     */
+    resolveUrl?: (input: {
+        scenario: TScenario;
+        placement?: string;
+        cellId: string;
+    }) => string;
+    /** Bearer token or static auth string set as `Authorization`. */
+    auth?: string | (() => string | Promise<string>);
+    /** Extra headers merged into every request. */
+    headers?: Record<string, string>;
+    /** Per-call timeout in ms. Default 5 minutes. */
+    timeoutMs?: number;
+    /** How many idempotent retries on 5xx / network errors. Default 2. */
+    retries?: number;
+    /** Optional fetch override (auth wrappers, custom agent, mocks). */
+    fetchImpl?: typeof fetch;
+}
+interface HttpDispatchRequestBody<TScenario extends Scenario> {
+    scenario: TScenario;
+    cellId: string;
+    rep: number;
+    generation?: number;
+    seed: number;
+    placement?: string;
+    cycleId?: string;
+}
+interface HttpDispatchResponseBody<TArtifact> {
+    artifact: TArtifact;
+}
+/**
+ * Wrap a remote HTTP endpoint as a `Dispatch`. The remote side should run
+ * `runDispatchServer` (or any service that speaks the same wire shape).
+ *
+ * Cancellation: the substrate's per-cell `AbortSignal` is forwarded; the
+ * server's `runDispatchServer` translates the resulting `AbortError` into
+ * a 499 (client-closed) so the client doesn't retry.
+ */
+declare function httpDispatch<TScenario extends Scenario, TArtifact>(opts: HttpDispatchOptions<TScenario, TArtifact>): DispatchFn<TScenario, TArtifact>;
+interface RunDispatchServerOptions<TScenario extends Scenario, TArtifact> {
+    /** The Dispatch this server exposes — what runs when a request lands. */
+    dispatch: DispatchFn<TScenario, TArtifact>;
+    /** TCP port to bind. */
+    port: number;
+    /** Optional bind host; defaults to 0.0.0.0. */
+    host?: string;
+    /** Required for any non-test deployment: the bearer token clients must
+     *  send. The substrate refuses to start without auth unless `auth: false`
+     *  is set explicitly (intended ONLY for closed-network/internal testing). */
+    auth: string | false;
+    /** Path the server listens on. Default `/dispatch`. */
+    path?: string;
+    /**
+     * Per-request handler that wraps `dispatch` with whatever context the
+     * worker side needs to construct a `DispatchContext` — typically the
+     * trace writer, artifact writer, and cost meter. The substrate provides
+     * synthetic-but-typed defaults if not supplied; production deployments
+     * should wire real ones (e.g. ship traces to your OTel collector).
+     */
+    contextFactory?: (req: HttpDispatchRequestBody<TScenario>, signal: AbortSignal) => Promise<DispatchContext>;
+    /** Optional max payload size for the request body (bytes). Default 10 MB. */
+    maxBodyBytes?: number;
+    /** Hook for observability — called on every successful or failed turn. */
+    onRequest?: (event: {
+        cellId: string;
+        durationMs: number;
+        success: boolean;
+        error?: unknown;
+    }) => void;
+}
+interface DispatchServerHandle {
+    /** The actual bound port (useful when `port: 0` requests an ephemeral port). */
+    port: number;
+    /** Stop accepting new connections and drain existing ones. */
+    close: () => Promise<void>;
+}
+/**
+ * Start an HTTP server exposing a local `Dispatch` over the wire. Pair with
+ * `httpDispatch` on the driver side.
+ *
+ * Wire shape:
+ *
+ *   POST /dispatch
+ *   Authorization: Bearer <token>
+ *   Body: HttpDispatchRequestBody
+ *   200 OK: HttpDispatchResponseBody
+ *   401: missing/invalid auth
+ *   408: per-request timeout exceeded
+ *   499: client aborted before completion
+ *   500: dispatch threw
+ *
+ * The server is `node:http`-based to keep the runtime dependency surface
+ * minimal — works in plain Node, sandbox, or any container.
+ */
+declare function runDispatchServer<TScenario extends Scenario, TArtifact>(opts: RunDispatchServerOptions<TScenario, TArtifact>): Promise<DispatchServerHandle>;
+
+export { type DispatchServerHandle, type HttpDispatchOptions, type HttpDispatchRequestBody, type HttpDispatchResponseBody, type RunDispatchServerOptions, httpDispatch, runDispatchServer };

package/dist/adapters/http.js

@@ -0,0 +1,196 @@
+import "../chunk-NSBPE2FW.js";
+
+// src/adapters/http.ts
+function resolveAuth(auth) {
+  if (!auth) return Promise.resolve(null);
+  if (typeof auth === "string") return Promise.resolve(auth);
+  return Promise.resolve(auth());
+}
+function httpDispatch(opts) {
+  if (!opts.url && !opts.resolveUrl) {
+    throw new Error("httpDispatch: pass exactly one of `url` or `resolveUrl`.");
+  }
+  if (opts.url && opts.resolveUrl) {
+    throw new Error("httpDispatch: pass exactly one of `url` or `resolveUrl`, not both.");
+  }
+  const timeoutMs = opts.timeoutMs ?? 5 * 60 * 1e3;
+  const maxRetries = opts.retries ?? 2;
+  const f = opts.fetchImpl ?? ((...args) => fetch(...args));
+  return async (scenario, ctx) => {
+    const url = opts.url ?? opts.resolveUrl({ scenario, placement: ctx.placement, cellId: ctx.cellId });
+    const authValue = await resolveAuth(opts.auth);
+    const body = {
+      scenario,
+      cellId: ctx.cellId,
+      rep: ctx.rep,
+      generation: ctx.generation,
+      seed: ctx.seed,
+      placement: ctx.placement,
+      cycleId: ctx.cycleId
+    };
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const ourTimeout = AbortSignal.timeout(timeoutMs);
+      const combinedSignal = AbortSignal.any([ctx.signal, ourTimeout]);
+      try {
+        const res = await f(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...authValue ? { Authorization: authValue.startsWith("Bearer ") ? authValue : `Bearer ${authValue}` } : {},
+            ...opts.headers
+          },
+          body: JSON.stringify(body),
+          signal: combinedSignal
+        });
+        if (!res.ok) {
+          const retryable = res.status >= 500 || res.status === 408 || res.status === 429;
+          if (!retryable || attempt === maxRetries) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`httpDispatch ${url} failed (${res.status}): ${text.slice(0, 500)}`);
+          }
+          await sleep(2 ** attempt * 200 + Math.random() * 200);
+          continue;
+        }
+        const parsed = await res.json();
+        return parsed.artifact;
+      } catch (err) {
+        if (ctx.signal.aborted) throw err;
+        lastError = err;
+        if (attempt === maxRetries) throw err;
+        await sleep(2 ** attempt * 200 + Math.random() * 200);
+      }
+    }
+    throw lastError ?? new Error("httpDispatch exhausted retries");
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    if (typeof t.unref === "function") t.unref();
+  });
+}
+async function runDispatchServer(opts) {
+  if (opts.auth === void 0) {
+    throw new Error("runDispatchServer: 'auth' is required (pass a bearer-token string, or `auth: false` explicitly for a closed-network test deployment).");
+  }
+  const path = opts.path ?? "/dispatch";
+  const maxBytes = opts.maxBodyBytes ?? 10 * 1024 * 1024;
+  const expectedAuth = typeof opts.auth === "string" ? `Bearer ${opts.auth.replace(/^Bearer\s+/, "")}` : null;
+  const { createServer } = await import("http");
+  const server = createServer(async (req, res) => {
+    const start = Date.now();
+    let cellId = "unknown";
+    let success = false;
+    let errCaught;
+    try {
+      if (req.method !== "POST" || req.url?.split("?")[0] !== path) {
+        res.statusCode = 404;
+        res.end("not found");
+        return;
+      }
+      if (expectedAuth) {
+        const got = req.headers["authorization"];
+        if (got !== expectedAuth) {
+          res.statusCode = 401;
+          res.end("unauthorized");
+          return;
+        }
+      }
+      const chunks = [];
+      let totalBytes = 0;
+      const aborter = new AbortController();
+      req.on("close", () => {
+        if (!res.writableEnded) aborter.abort();
+      });
+      for await (const chunk of req) {
+        const buf = chunk;
+        totalBytes += buf.length;
+        if (totalBytes > maxBytes) {
+          res.statusCode = 413;
+          res.end("payload too large");
+          return;
+        }
+        chunks.push(buf);
+      }
+      const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      cellId = body.cellId;
+      const ctx = opts.contextFactory ? await opts.contextFactory(body, aborter.signal) : {
+        cellId: body.cellId,
+        rep: body.rep,
+        generation: body.generation,
+        seed: body.seed,
+        signal: aborter.signal,
+        placement: body.placement,
+        cycleId: body.cycleId,
+        trace: NOOP_TRACE,
+        artifacts: NOOP_ARTIFACTS,
+        cost: NOOP_COST
+      };
+      const artifact = await opts.dispatch(body.scenario, ctx);
+      const responseBody = { artifact };
+      res.statusCode = 200;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify(responseBody));
+      success = true;
+    } catch (err) {
+      errCaught = err;
+      if (err?.name === "AbortError") {
+        res.statusCode = 499;
+        res.end("client aborted");
+        return;
+      }
+      res.statusCode = 500;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+    } finally {
+      opts.onRequest?.({
+        cellId,
+        durationMs: Date.now() - start,
+        success,
+        error: errCaught
+      });
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port, opts.host ?? "0.0.0.0", () => resolve());
+  });
+  const addr = server.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
+  return {
+    port: boundPort,
+    close: () => new Promise((resolve, reject) => {
+      server.close((err) => err ? reject(err) : resolve());
+    })
+  };
+}
+var NOOP_TRACE = {
+  span: () => ({
+    end: () => {
+    },
+    setAttribute: () => {
+    },
+    setStatus: () => {
+    },
+    recordException: () => {
+    },
+    addEvent: () => {
+    }
+  })
+};
+var NOOP_ARTIFACTS = {
+  write: async () => void 0,
+  read: async () => void 0,
+  list: async () => []
+};
+var NOOP_COST = {
+  record: () => {
+  },
+  total: () => 0
+};
+export {
+  httpDispatch,
+  runDispatchServer
+};
+//# sourceMappingURL=http.js.map

package/dist/adapters/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/http.ts"],"sourcesContent":["/**\n * # `@tangle-network/agent-eval/adapters/http` — distributed Dispatch over HTTP.\n *\n * Decouples driver and worker. The driver (running `runImprovementLoop` or\n * `runCampaign`) can live anywhere — your VPC, a dev laptop, a cron VM. The\n * workers (running the actual agent) can live anywhere else — different\n * regions, different clouds, different boxes — as long as they speak HTTP.\n *\n * Both sides:\n *\n *   - **`httpDispatch({ url | resolveUrl, ... })`** — client. Returns a\n *     `Dispatch` that POSTs `{ scenario, ctx }` to a worker URL and parses\n *     the artifact back. AbortSignal-aware, retries on idempotent errors,\n *     bounded timeout per call.\n *   - **`runDispatchServer({ dispatch, port, ... })`** — server. Wraps your\n *     local `Dispatch` as an HTTP endpoint. Handles auth, JSON parsing,\n *     error mapping, and cancellation when the client aborts.\n *\n * # Topology examples\n *\n * **Single-worker:** driver on box A, worker on box B. Set\n * `httpDispatch({ url: 'https://box-b/dispatch' })`.\n *\n * **Multi-region:** N workers across regions. Use `httpDispatch({ resolveUrl })`\n * with a function that picks the URL per cell from `ctx.placement`. Combined\n * with `cellPlacement` on `RunCampaignOptions`, the substrate fans cells\n * across geographies in parallel.\n *\n * **Driver-as-a-service:** driver runs as a long-lived process or service\n * (holds optimization state across generations); workers are stateless\n * HTTP services that can scale horizontally per cell.\n */\n\nimport type { Dispatch, DispatchContext, Scenario } from '../contract'\n\n// ── Client ───────────────────────────────────────────────────────────\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- TArtifact is unused\n//  in this options interface but kept as a parameter so callers can write\n//  `HttpDispatchOptions<MyScenario, MyArtifact>` symmetrically with\n//  `Dispatch<MyScenario, MyArtifact>`. Marking it unused at the position\n//  where it bites.\nexport interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {\n  /** Static endpoint URL. Mutually exclusive with `resolveUrl`. */\n  url?: string\n  /**\n   * Dynamic per-cell URL resolver. Receives the scenario + the substrate\n   * placement key (from `RunCampaignOptions.cellPlacement`) and returns the\n   * worker URL to invoke. Mutually exclusive with `url`.\n   */\n  resolveUrl?: (input: { scenario: TScenario; placement?: string; cellId: string }) => string\n  /** Bearer token or static auth string set as `Authorization`. */\n  auth?: string | (() => string | Promise<string>)\n  /** Extra headers merged into every request. */\n  headers?: Record<string, string>\n  /** Per-call timeout in ms. Default 5 minutes. */\n  timeoutMs?: number\n  /** How many idempotent retries on 5xx / network errors. Default 2. */\n  retries?: number\n  /** Optional fetch override (auth wrappers, custom agent, mocks). */\n  fetchImpl?: typeof fetch\n}\n\nexport interface HttpDispatchRequestBody<TScenario extends Scenario> {\n  scenario: TScenario\n  cellId: string\n  rep: number\n  generation?: number\n  seed: number\n  placement?: string\n  cycleId?: string\n}\n\nexport interface HttpDispatchResponseBody<TArtifact> {\n  artifact: TArtifact\n}\n\nfunction resolveAuth(auth: HttpDispatchOptions<Scenario, unknown>['auth']): Promise<string | null> {\n  if (!auth) return Promise.resolve(null)\n  if (typeof auth === 'string') return Promise.resolve(auth)\n  return Promise.resolve(auth())\n}\n\n/**\n * Wrap a remote HTTP endpoint as a `Dispatch`. The remote side should run\n * `runDispatchServer` (or any service that speaks the same wire shape).\n *\n * Cancellation: the substrate's per-cell `AbortSignal` is forwarded; the\n * server's `runDispatchServer` translates the resulting `AbortError` into\n * a 499 (client-closed) so the client doesn't retry.\n */\nexport function httpDispatch<TScenario extends Scenario, TArtifact>(\n  opts: HttpDispatchOptions<TScenario, TArtifact>,\n): Dispatch<TScenario, TArtifact> {\n  if (!opts.url && !opts.resolveUrl) {\n    throw new Error('httpDispatch: pass exactly one of `url` or `resolveUrl`.')\n  }\n  if (opts.url && opts.resolveUrl) {\n    throw new Error('httpDispatch: pass exactly one of `url` or `resolveUrl`, not both.')\n  }\n  const timeoutMs = opts.timeoutMs ?? 5 * 60 * 1000\n  const maxRetries = opts.retries ?? 2\n  const f: typeof fetch = opts.fetchImpl ?? ((...args) => fetch(...args))\n\n  return async (scenario, ctx) => {\n    const url = opts.url ?? opts.resolveUrl!({ scenario, placement: ctx.placement, cellId: ctx.cellId })\n    const authValue = await resolveAuth(opts.auth)\n    const body: HttpDispatchRequestBody<TScenario> = {\n      scenario,\n      cellId: ctx.cellId,\n      rep: ctx.rep,\n      generation: ctx.generation,\n      seed: ctx.seed,\n      placement: ctx.placement,\n      cycleId: ctx.cycleId,\n    }\n\n    let lastError: unknown\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      // Compose the request signal: caller's signal OR our timeout.\n      const ourTimeout = AbortSignal.timeout(timeoutMs)\n      const combinedSignal = AbortSignal.any([ctx.signal, ourTimeout])\n      try {\n        const res = await f(url, {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n            ...(authValue ? { Authorization: authValue.startsWith('Bearer ') ? authValue : `Bearer ${authValue}` } : {}),\n            ...opts.headers,\n          },\n          body: JSON.stringify(body),\n          signal: combinedSignal,\n        })\n        if (!res.ok) {\n          // 4xx is non-retryable (caller error, auth, bad scenario shape).\n          // 5xx / 408 / 429 / 502 / 503 / 504 are retryable.\n          const retryable = res.status >= 500 || res.status === 408 || res.status === 429\n          if (!retryable || attempt === maxRetries) {\n            const text = await res.text().catch(() => '')\n            throw new Error(`httpDispatch ${url} failed (${res.status}): ${text.slice(0, 500)}`)\n          }\n          // exponential backoff with jitter\n          await sleep(2 ** attempt * 200 + Math.random() * 200)\n          continue\n        }\n        const parsed = (await res.json()) as HttpDispatchResponseBody<TArtifact>\n        return parsed.artifact\n      } catch (err) {\n        // Caller-driven abort is terminal — never retry.\n        if (ctx.signal.aborted) throw err\n        lastError = err\n        if (attempt === maxRetries) throw err\n        await sleep(2 ** attempt * 200 + Math.random() * 200)\n      }\n    }\n    throw lastError ?? new Error('httpDispatch exhausted retries')\n  }\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    const t = setTimeout(resolve, ms)\n    // Don't keep node process alive purely for backoff sleeps.\n    if (typeof (t as { unref?: () => void }).unref === 'function') (t as { unref: () => void }).unref()\n  })\n}\n\n// ── Server ───────────────────────────────────────────────────────────\n\nexport interface RunDispatchServerOptions<TScenario extends Scenario, TArtifact> {\n  /** The Dispatch this server exposes — what runs when a request lands. */\n  dispatch: Dispatch<TScenario, TArtifact>\n  /** TCP port to bind. */\n  port: number\n  /** Optional bind host; defaults to 0.0.0.0. */\n  host?: string\n  /** Required for any non-test deployment: the bearer token clients must\n   *  send. The substrate refuses to start without auth unless `auth: false`\n   *  is set explicitly (intended ONLY for closed-network/internal testing). */\n  auth: string | false\n  /** Path the server listens on. Default `/dispatch`. */\n  path?: string\n  /**\n   * Per-request handler that wraps `dispatch` with whatever context the\n   * worker side needs to construct a `DispatchContext` — typically the\n   * trace writer, artifact writer, and cost meter. The substrate provides\n   * synthetic-but-typed defaults if not supplied; production deployments\n   * should wire real ones (e.g. ship traces to your OTel collector).\n   */\n  contextFactory?: (req: HttpDispatchRequestBody<TScenario>, signal: AbortSignal) => Promise<DispatchContext>\n  /** Optional max payload size for the request body (bytes). Default 10 MB. */\n  maxBodyBytes?: number\n  /** Hook for observability — called on every successful or failed turn. */\n  onRequest?: (event: {\n    cellId: string\n    durationMs: number\n    success: boolean\n    error?: unknown\n  }) => void\n}\n\nexport interface DispatchServerHandle {\n  /** The actual bound port (useful when `port: 0` requests an ephemeral port). */\n  port: number\n  /** Stop accepting new connections and drain existing ones. */\n  close: () => Promise<void>\n}\n\n/**\n * Start an HTTP server exposing a local `Dispatch` over the wire. Pair with\n * `httpDispatch` on the driver side.\n *\n * Wire shape:\n *\n *   POST /dispatch\n *   Authorization: Bearer <token>\n *   Body: HttpDispatchRequestBody\n *   200 OK: HttpDispatchResponseBody\n *   401: missing/invalid auth\n *   408: per-request timeout exceeded\n *   499: client aborted before completion\n *   500: dispatch threw\n *\n * The server is `node:http`-based to keep the runtime dependency surface\n * minimal — works in plain Node, sandbox, or any container.\n */\nexport async function runDispatchServer<TScenario extends Scenario, TArtifact>(\n  opts: RunDispatchServerOptions<TScenario, TArtifact>,\n): Promise<DispatchServerHandle> {\n  if (opts.auth === undefined) {\n    throw new Error(\"runDispatchServer: 'auth' is required (pass a bearer-token string, or `auth: false` explicitly for a closed-network test deployment).\")\n  }\n  const path = opts.path ?? '/dispatch'\n  const maxBytes = opts.maxBodyBytes ?? 10 * 1024 * 1024\n  const expectedAuth = typeof opts.auth === 'string' ? `Bearer ${opts.auth.replace(/^Bearer\\s+/, '')}` : null\n\n  // Lazy-import node:http so the file is usable from non-Node bundlers\n  // that import the client side only (e.g. an edge driver shipping\n  // httpDispatch alone). Server side is opt-in by calling this function.\n  const { createServer } = await import('node:http')\n\n  const server = createServer(async (req, res) => {\n    const start = Date.now()\n    let cellId = 'unknown'\n    let success = false\n    let errCaught: unknown\n\n    try {\n      if (req.method !== 'POST' || req.url?.split('?')[0] !== path) {\n        res.statusCode = 404\n        res.end('not found')\n        return\n      }\n      if (expectedAuth) {\n        const got = req.headers['authorization']\n        if (got !== expectedAuth) {\n          res.statusCode = 401\n          res.end('unauthorized')\n          return\n        }\n      }\n\n      // Read body up to maxBytes\n      const chunks: Buffer[] = []\n      let totalBytes = 0\n      const aborter = new AbortController()\n      req.on('close', () => {\n        if (!res.writableEnded) aborter.abort()\n      })\n\n      for await (const chunk of req) {\n        const buf = chunk as Buffer\n        totalBytes += buf.length\n        if (totalBytes > maxBytes) {\n          res.statusCode = 413\n          res.end('payload too large')\n          return\n        }\n        chunks.push(buf)\n      }\n\n      const body = JSON.parse(Buffer.concat(chunks).toString('utf8')) as HttpDispatchRequestBody<TScenario>\n      cellId = body.cellId\n\n      const ctx: DispatchContext = opts.contextFactory\n        ? await opts.contextFactory(body, aborter.signal)\n        : {\n            cellId: body.cellId,\n            rep: body.rep,\n            generation: body.generation,\n            seed: body.seed,\n            signal: aborter.signal,\n            placement: body.placement,\n            cycleId: body.cycleId,\n            trace: NOOP_TRACE,\n            artifacts: NOOP_ARTIFACTS,\n            cost: NOOP_COST,\n          }\n\n      const artifact = await opts.dispatch(body.scenario, ctx)\n      const responseBody: HttpDispatchResponseBody<TArtifact> = { artifact }\n\n      res.statusCode = 200\n      res.setHeader('content-type', 'application/json')\n      res.end(JSON.stringify(responseBody))\n      success = true\n    } catch (err) {\n      errCaught = err\n      // Client-cancelled — they don't care about the result.\n      if ((err as Error)?.name === 'AbortError') {\n        res.statusCode = 499\n        res.end('client aborted')\n        return\n      }\n      res.statusCode = 500\n      res.setHeader('content-type', 'application/json')\n      res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))\n    } finally {\n      opts.onRequest?.({\n        cellId,\n        durationMs: Date.now() - start,\n        success,\n        error: errCaught,\n      })\n    }\n  })\n\n  await new Promise<void>((resolve, reject) => {\n    server.once('error', reject)\n    server.listen(opts.port, opts.host ?? '0.0.0.0', () => resolve())\n  })\n\n  const addr = server.address()\n  const boundPort = typeof addr === 'object' && addr ? addr.port : opts.port\n\n  return {\n    port: boundPort,\n    close: () =>\n      new Promise<void>((resolve, reject) => {\n        server.close((err) => (err ? reject(err) : resolve()))\n      }),\n  }\n}\n\n// ── No-op default ctx machinery (worker can replace via contextFactory) ──\n\nconst NOOP_TRACE = {\n  span: () => ({\n    end: () => {},\n    setAttribute: () => {},\n    setStatus: () => {},\n    recordException: () => {},\n    addEvent: () => {},\n  }),\n} as unknown as DispatchContext['trace']\n\nconst NOOP_ARTIFACTS = {\n  write: async () => undefined,\n  read: async () => undefined,\n  list: async () => [],\n} as unknown as DispatchContext['artifacts']\n\nconst NOOP_COST = {\n  record: () => {},\n  total: () => 0,\n} as unknown as DispatchContext['cost']\n"],"mappings":"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","names":[]}

package/dist/adapters/langchain.d.ts

@@ -0,0 +1,91 @@
+import { S as Scenario, n as JudgeScore, D as DispatchFn, J as JudgeConfig } from '../types-BURGZ8Ug.js';
+
+/**
+ * # `@tangle-network/agent-eval/adapters/langchain` — wrap any LangChain
+ * Runnable as a `Dispatch` (or `JudgeConfig`).
+ *
+ * **Why structural, not pinned**: we don't depend on `@langchain/core` at
+ * install time. The adapter accepts anything with the canonical LangChain
+ * Runnable shape (`invoke(input, config?)`), so it works with their
+ * `Runnable`, `RunnableSequence`, `RunnableMap`, `RunnablePassthrough`,
+ * and any custom Runnable-shaped object. No version pin, no peer dep,
+ * no bundle-bloat risk.
+ *
+ * **Why this exists**: the most-asked question from foreign agent
+ * builders is "I'm already on LangChain — how do I plug in?". The answer
+ * is one function. Wrap your existing Runnable, pass the Dispatch into
+ * `runEval` / `runImprovementLoop`, ship.
+ */
+
+interface RunnableLike<TInput, TOutput> {
+    invoke(input: TInput, config?: {
+        signal?: AbortSignal;
+        [key: string]: unknown;
+    }): Promise<TOutput>;
+}
+interface LangchainDispatchOptions<TScenario extends Scenario, TArtifact> {
+    /** The Runnable (or RunnableSequence, or anything `.invoke`able). */
+    runnable: RunnableLike<TScenario, TArtifact>;
+    /**
+     * Optional config merged into every `invoke` call — tags, metadata,
+     * callbacks, runName. The substrate's per-cell `AbortSignal` is
+     * always merged in last (and so wins).
+     */
+    config?: Record<string, unknown>;
+}
+/**
+ * Wrap a LangChain Runnable as a `Dispatch`. The Runnable's input must
+ * accept the scenario (typically you'll shape it via
+ * `RunnableMap`/`RunnableLambda` upstream); its output is the artifact
+ * the engine + judges see.
+ *
+ * @example
+ *   const chain = prompt.pipe(model).pipe(parser)
+ *   const dispatch = langchainDispatch({ runnable: chain })
+ *   await runEval({ scenarios, dispatch, judges: [...], storage, runDir })
+ */
+declare function langchainDispatch<TScenario extends Scenario, TArtifact>(opts: LangchainDispatchOptions<TScenario, TArtifact>): DispatchFn<TScenario, TArtifact>;
+interface LangchainJudgeOptions<TArtifact, TScenario extends Scenario> {
+    /** Judge name; appears in `CampaignResult.aggregates.byJudge`. */
+    name: string;
+    /**
+     * Dimensions the judge scores. Used both for the judge's own prompt
+     * (if it reads them) and for the aggregator's `byJudge` rollup.
+     */
+    dimensions: {
+        key: string;
+        description: string;
+    }[];
+    /**
+     * A Runnable that takes `{ artifact, scenario }` and returns a
+     * partial `JudgeScore` — the dimensions map at minimum. `composite`
+     * is computed by averaging `dimensions` when the Runnable doesn't
+     * provide it; `notes` defaults to an empty string.
+     */
+    runnable: RunnableLike<{
+        artifact: TArtifact;
+        scenario: TScenario;
+    }, Partial<JudgeScore>>;
+    appliesTo?: (scenario: TScenario) => boolean;
+}
+/**
+ * Wrap a LangChain Runnable as a `JudgeConfig`. The Runnable can be any
+ * structured-output chain (e.g. `prompt.pipe(model).pipe(StructuredOutputParser)`)
+ * that returns a `Partial<JudgeScore>`.
+ *
+ * The substrate's invariant — throw on judge failure, never silently
+ * fold errors into a zero — is preserved: any error from the Runnable
+ * propagates and the substrate records a failed cell.
+ *
+ * @example
+ *   const scorePrompt = ChatPromptTemplate.fromTemplate(`...`)
+ *   const judgeChain = scorePrompt.pipe(judgeModel).pipe(jsonParser)
+ *   const judge = langchainJudge({
+ *     name: 'marketing-quality',
+ *     dimensions: [{ key: 'hook_strength', description: '...' }, ...],
+ *     runnable: judgeChain,
+ *   })
+ */
+declare function langchainJudge<TArtifact, TScenario extends Scenario>(opts: LangchainJudgeOptions<TArtifact, TScenario>): JudgeConfig<TArtifact, TScenario>;
+
+export { type LangchainDispatchOptions, type LangchainJudgeOptions, type RunnableLike, langchainDispatch, langchainJudge };

package/dist/adapters/langchain.js

@@ -0,0 +1,34 @@
+import "../chunk-NSBPE2FW.js";
+
+// src/adapters/langchain.ts
+function langchainDispatch(opts) {
+  return async (scenario, ctx) => {
+    return opts.runnable.invoke(scenario, {
+      ...opts.config,
+      signal: ctx.signal
+    });
+  };
+}
+function langchainJudge(opts) {
+  return {
+    name: opts.name,
+    dimensions: opts.dimensions,
+    appliesTo: opts.appliesTo,
+    async score({ artifact, scenario, signal }) {
+      const result = await opts.runnable.invoke({ artifact, scenario }, { signal });
+      const dims = result.dimensions ?? {};
+      const dimValues = Object.values(dims);
+      const composite = result.composite ?? (dimValues.length > 0 ? dimValues.reduce((a, b) => a + b, 0) / dimValues.length : 0);
+      return {
+        dimensions: dims,
+        composite,
+        notes: result.notes ?? ""
+      };
+    }
+  };
+}
+export {
+  langchainDispatch,
+  langchainJudge
+};
+//# sourceMappingURL=langchain.js.map

package/dist/adapters/langchain.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/langchain.ts"],"sourcesContent":["/**\n * # `@tangle-network/agent-eval/adapters/langchain` — wrap any LangChain\n * Runnable as a `Dispatch` (or `JudgeConfig`).\n *\n * **Why structural, not pinned**: we don't depend on `@langchain/core` at\n * install time. The adapter accepts anything with the canonical LangChain\n * Runnable shape (`invoke(input, config?)`), so it works with their\n * `Runnable`, `RunnableSequence`, `RunnableMap`, `RunnablePassthrough`,\n * and any custom Runnable-shaped object. No version pin, no peer dep,\n * no bundle-bloat risk.\n *\n * **Why this exists**: the most-asked question from foreign agent\n * builders is \"I'm already on LangChain — how do I plug in?\". The answer\n * is one function. Wrap your existing Runnable, pass the Dispatch into\n * `runEval` / `runImprovementLoop`, ship.\n */\n\nimport type { Dispatch, JudgeConfig, JudgeScore, Scenario } from '../contract'\n\n// ── Minimal structural type ──────────────────────────────────────────\n//\n// Whatever has `invoke(input, config?)` qualifies. We accept any\n// config shape (LangChain's RunnableConfig has many optional fields)\n// — the only thing we need is the AbortSignal seam, which LangChain's\n// RunnableConfig already supports as `signal?: AbortSignal`.\n\nexport interface RunnableLike<TInput, TOutput> {\n  invoke(input: TInput, config?: { signal?: AbortSignal; [key: string]: unknown }): Promise<TOutput>\n}\n\n// ── Dispatch wrapper ────────────────────────────────────────────────\n\nexport interface LangchainDispatchOptions<TScenario extends Scenario, TArtifact> {\n  /** The Runnable (or RunnableSequence, or anything `.invoke`able). */\n  runnable: RunnableLike<TScenario, TArtifact>\n  /**\n   * Optional config merged into every `invoke` call — tags, metadata,\n   * callbacks, runName. The substrate's per-cell `AbortSignal` is\n   * always merged in last (and so wins).\n   */\n  config?: Record<string, unknown>\n}\n\n/**\n * Wrap a LangChain Runnable as a `Dispatch`. The Runnable's input must\n * accept the scenario (typically you'll shape it via\n * `RunnableMap`/`RunnableLambda` upstream); its output is the artifact\n * the engine + judges see.\n *\n * @example\n *   const chain = prompt.pipe(model).pipe(parser)\n *   const dispatch = langchainDispatch({ runnable: chain })\n *   await runEval({ scenarios, dispatch, judges: [...], storage, runDir })\n */\nexport function langchainDispatch<TScenario extends Scenario, TArtifact>(\n  opts: LangchainDispatchOptions<TScenario, TArtifact>,\n): Dispatch<TScenario, TArtifact> {\n  return async (scenario, ctx) => {\n    return opts.runnable.invoke(scenario, {\n      ...opts.config,\n      signal: ctx.signal,\n    })\n  }\n}\n\n// ── Judge wrapper ───────────────────────────────────────────────────\n\nexport interface LangchainJudgeOptions<TArtifact, TScenario extends Scenario> {\n  /** Judge name; appears in `CampaignResult.aggregates.byJudge`. */\n  name: string\n  /**\n   * Dimensions the judge scores. Used both for the judge's own prompt\n   * (if it reads them) and for the aggregator's `byJudge` rollup.\n   */\n  dimensions: { key: string; description: string }[]\n  /**\n   * A Runnable that takes `{ artifact, scenario }` and returns a\n   * partial `JudgeScore` — the dimensions map at minimum. `composite`\n   * is computed by averaging `dimensions` when the Runnable doesn't\n   * provide it; `notes` defaults to an empty string.\n   */\n  runnable: RunnableLike<{ artifact: TArtifact; scenario: TScenario }, Partial<JudgeScore>>\n  appliesTo?: (scenario: TScenario) => boolean\n}\n\n/**\n * Wrap a LangChain Runnable as a `JudgeConfig`. The Runnable can be any\n * structured-output chain (e.g. `prompt.pipe(model).pipe(StructuredOutputParser)`)\n * that returns a `Partial<JudgeScore>`.\n *\n * The substrate's invariant — throw on judge failure, never silently\n * fold errors into a zero — is preserved: any error from the Runnable\n * propagates and the substrate records a failed cell.\n *\n * @example\n *   const scorePrompt = ChatPromptTemplate.fromTemplate(`...`)\n *   const judgeChain = scorePrompt.pipe(judgeModel).pipe(jsonParser)\n *   const judge = langchainJudge({\n *     name: 'marketing-quality',\n *     dimensions: [{ key: 'hook_strength', description: '...' }, ...],\n *     runnable: judgeChain,\n *   })\n */\nexport function langchainJudge<TArtifact, TScenario extends Scenario>(\n  opts: LangchainJudgeOptions<TArtifact, TScenario>,\n): JudgeConfig<TArtifact, TScenario> {\n  return {\n    name: opts.name,\n    dimensions: opts.dimensions,\n    appliesTo: opts.appliesTo,\n    async score({ artifact, scenario, signal }) {\n      const result = await opts.runnable.invoke({ artifact, scenario }, { signal })\n      const dims = (result.dimensions ?? {}) as Record<string, number>\n      const dimValues = Object.values(dims)\n      const composite =\n        result.composite ??\n        (dimValues.length > 0 ? dimValues.reduce((a, b) => a + b, 0) / dimValues.length : 0)\n      return {\n        dimensions: dims,\n        composite,\n        notes: result.notes ?? '',\n      }\n    },\n  }\n}\n"],"mappings":";;;AAsDO,SAAS,kBACd,MACgC;AAChC,SAAO,OAAO,UAAU,QAAQ;AAC9B,WAAO,KAAK,SAAS,OAAO,UAAU;AAAA,MACpC,GAAG,KAAK;AAAA,MACR,QAAQ,IAAI;AAAA,IACd,CAAC;AAAA,EACH;AACF;AAwCO,SAAS,eACd,MACmC;AACnC,SAAO;AAAA,IACL,MAAM,KAAK;AAAA,IACX,YAAY,KAAK;AAAA,IACjB,WAAW,KAAK;AAAA,IAChB,MAAM,MAAM,EAAE,UAAU,UAAU,OAAO,GAAG;AAC1C,YAAM,SAAS,MAAM,KAAK,SAAS,OAAO,EAAE,UAAU,SAAS,GAAG,EAAE,OAAO,CAAC;AAC5E,YAAM,OAAQ,OAAO,cAAc,CAAC;AACpC,YAAM,YAAY,OAAO,OAAO,IAAI;AACpC,YAAM,YACJ,OAAO,cACN,UAAU,SAAS,IAAI,UAAU,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI,UAAU,SAAS;AACpF,aAAO;AAAA,QACL,YAAY;AAAA,QACZ;AAAA,QACA,OAAO,OAAO,SAAS;AAAA,MACzB;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/campaign/index.d.ts

@@ -1,6 +1,6 @@
-export { C as CampaignStorage, D as DefaultProductionGateOptions, E as EvolutionaryDriverOptions, G as GepaDriverOptions, H as HeldOutGateOptions, O as OpenAutoPrOptions, m as OpenAutoPrResult, R as RunCampaignOptions, a as RunEvalOptions, b as RunImprovementLoopOptions, c as RunImprovementLoopResult, n as RunOptimizationOptions, o as RunOptimizationResult, d as composeGate, e as defaultProductionGate, f as evolutionaryDriver, g as fsCampaignStorage, h as gepaDriver, i as heldOutGate, j as inMemoryCampaignStorage, p as openAutoPr, r as runCampaign, k as runEval, l as runImprovementLoop, q as runOptimization, s as surfaceHash } from '../run-improvement-loop-CbilHQAb.js';
-import { L as LabeledScenarioStore, q as LabeledScenarioWrite, r as LabeledScenarioSampleArgs, s as LabeledScenarioRecord, f as CodeSurface } from '../types-DToGONFA.js';
-export { C as CampaignAggregates, a as CampaignArtifactWriter, b as CampaignCellResult, c as CampaignCostMeter, d as CampaignResult, e as CampaignTraceWriter, g as DispatchContext, D as DispatchFn, G as Gate, h as GateContext, i as GateDecision, j as GateResult, k as GenerationCandidate, l as GenerationRecord, I as ImprovementDriver, t as JudgeAggregate, J as JudgeConfig, m as JudgeDimension, n as JudgeScore, u as LabeledScenarioSource, M as MutableSurface, o as Mutator, O as OptimizerConfig, P as ProposeContext, R as RedactionStatus, S as Scenario, v as ScenarioAggregate, p as SessionScript, T as TraceSpan } from '../types-DToGONFA.js';
+export { C as CampaignStorage, D as DefaultProductionGateOptions, E as EvolutionaryDriverOptions, G as GepaDriverOptions, H as HeldOutGateOptions, O as OpenAutoPrOptions, m as OpenAutoPrResult, R as RunCampaignOptions, a as RunEvalOptions, b as RunImprovementLoopOptions, c as RunImprovementLoopResult, n as RunOptimizationOptions, o as RunOptimizationResult, d as composeGate, e as defaultProductionGate, f as evolutionaryDriver, g as fsCampaignStorage, h as gepaDriver, i as heldOutGate, j as inMemoryCampaignStorage, p as openAutoPr, r as runCampaign, k as runEval, l as runImprovementLoop, q as runOptimization, s as surfaceHash } from '../run-improvement-loop-pJ4yrx4X.js';
+import { L as LabeledScenarioStore, q as LabeledScenarioWrite, r as LabeledScenarioSampleArgs, s as LabeledScenarioRecord, f as CodeSurface } from '../types-BURGZ8Ug.js';
+export { C as CampaignAggregates, a as CampaignArtifactWriter, b as CampaignCellResult, c as CampaignCostMeter, d as CampaignResult, e as CampaignTraceWriter, g as DispatchContext, D as DispatchFn, G as Gate, h as GateContext, i as GateDecision, j as GateResult, k as GenerationCandidate, l as GenerationRecord, I as ImprovementDriver, t as JudgeAggregate, J as JudgeConfig, m as JudgeDimension, n as JudgeScore, u as LabeledScenarioSource, M as MutableSurface, o as Mutator, O as OptimizerConfig, P as ProposeContext, R as RedactionStatus, S as Scenario, v as ScenarioAggregate, p as SessionScript, T as TraceSpan } from '../types-BURGZ8Ug.js';
 import '../llm-client-BXVRUZyX.js';
 import '../errors-mje_cKOs.js';
 import '../raw-provider-sink-C46HDghv.js';

package/dist/campaign/index.js

@@ -9,12 +9,12 @@ import {
   runImprovementLoop,
   runOptimization,
   surfaceHash
-} from "../chunk-H5BGRSN4.js";
+} from "../chunk-HRKOCLQA.js";
 import {
   fsCampaignStorage,
   inMemoryCampaignStorage,
   runCampaign
-} from "../chunk-RXK7FXLV.js";
+} from "../chunk-J3EIOI3O.js";
 import "../chunk-N4SBKEPJ.js";
 import "../chunk-YV7J7X5N.js";
 import "../chunk-WP7SY7AI.js";

package/dist/{chunk-H5BGRSN4.js → chunk-HRKOCLQA.js}

@@ -1,6 +1,6 @@
 import {
   runCampaign
-} from "./chunk-RXK7FXLV.js";
+} from "./chunk-J3EIOI3O.js";
 import {
   buildReflectionPrompt,
   parseReflectionResponse,
@@ -553,7 +553,7 @@ async function runImprovementLoop(opts) {
     throw new Error("runImprovementLoop: autoOnPromote='pr' requires ghOwner + ghRepo.");
   }
   const optimization = await runOptimization(opts);
-  const { runCampaign: runCampaign2 } = await import("./run-campaign-GNDO66B4.js");
+  const { runCampaign: runCampaign2 } = await import("./run-campaign-6UEVBPP3.js");
   const baselineOnHoldout = await runCampaign2({
     ...opts,
     scenarios: opts.holdoutScenarios,
@@ -639,4 +639,4 @@ export {
   surfaceHash,
   runImprovementLoop
 };
-//# sourceMappingURL=chunk-H5BGRSN4.js.map
+//# sourceMappingURL=chunk-HRKOCLQA.js.map

package/dist/{chunk-RXK7FXLV.js → chunk-J3EIOI3O.js}

@@ -195,6 +195,10 @@ async function executeCell(args) {
       return costSoFar;
     }
   };
+  const placement = args.opts.cellPlacement?.({
+    scenario: args.slot.scenario,
+    rep: args.slot.rep
+  });
   const ctx = {
     cellId: args.slot.cellId,
     rep: args.slot.rep,
@@ -202,7 +206,8 @@ async function executeCell(args) {
     signal: args.signal,
     trace,
     artifacts,
-    cost
+    cost,
+    placement
   };
   let artifact;
   let errorMessage;
@@ -357,4 +362,4 @@ export {
   inMemoryCampaignStorage,
   runCampaign
 };
-//# sourceMappingURL=chunk-RXK7FXLV.js.map
+//# sourceMappingURL=chunk-J3EIOI3O.js.map