@tangle-network/agent-runtime 0.48.0 → 0.50.0

package/dist/chunk-OM3YNZIW.js

@@ -0,0 +1,978 @@
+import {
+  coderProfile,
+  multiHarnessCoderFanout
+} from "./chunk-KADIJAD4.js";
+import {
+  createSandboxForSpec,
+  deleteBoxSafe,
+  runLoop,
+  sleep,
+  throwAbort,
+  throwIfAborted
+} from "./chunk-CM2IK7VS.js";
+import {
+  ValidationError
+} from "./chunk-GSUO5QS6.js";
+
+// src/otel-export.ts
+var SCOPE = { name: "@tangle-network/agent-runtime", version: "0.33.0" };
+var GEN_AI = {
+  operation: "gen_ai.operation.name",
+  agentName: "gen_ai.agent.name",
+  conversationId: "gen_ai.conversation.id",
+  inputTokens: "gen_ai.usage.input_tokens",
+  outputTokens: "gen_ai.usage.output_tokens"
+};
+function createOtelExporter(config) {
+  const resolvedEndpoint = config?.endpoint ?? (typeof process !== "undefined" ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT : void 0);
+  if (!resolvedEndpoint) return void 0;
+  const endpoint = resolvedEndpoint;
+  const headers = config?.headers ?? parseHeadersFromEnv();
+  const batchSize = config?.batchSize ?? 64;
+  const flushIntervalMs = config?.flushIntervalMs ?? 5e3;
+  const serviceName = config?.serviceName ?? "agent-runtime";
+  const resourceAttrs = config?.resourceAttributes ?? {};
+  const pending = [];
+  let timer;
+  let stopped = false;
+  const exporter = {
+    exportSpan(span) {
+      if (stopped) return;
+      pending.push(span);
+      if (pending.length >= batchSize) {
+        void doFlush();
+      }
+    },
+    async flush() {
+      await doFlush();
+    },
+    async shutdown() {
+      stopped = true;
+      if (timer !== void 0) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      await doFlush();
+    }
+  };
+  timer = setInterval(() => {
+    if (pending.length > 0) void doFlush();
+  }, flushIntervalMs);
+  if (typeof timer === "object" && "unref" in timer) {
+    ;
+    timer.unref();
+  }
+  async function doFlush() {
+    if (pending.length === 0) return;
+    const batch = pending.splice(0);
+    const body = {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: toAttributes({
+              "service.name": serviceName,
+              ...resourceAttrs
+            })
+          },
+          scopeSpans: [{ scope: SCOPE, spans: batch }]
+        }
+      ]
+    };
+    const url = `${endpoint.replace(/\/+$/, "")}/v1/traces`;
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...headers },
+        body: JSON.stringify(body)
+      });
+    } catch {
+    }
+  }
+  return exporter;
+}
+function loopEventToOtelSpan(event, traceId, parentSpanId) {
+  const spanId = generateSpanId();
+  const attrs = {
+    "loop.event_kind": event.kind,
+    "loop.run_id": event.runId
+  };
+  for (const [k, v] of Object.entries(event.payload)) {
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      attrs[`loop.${k}`] = v;
+    }
+  }
+  const ts = msToNs(event.timestamp);
+  return {
+    traceId: padTraceId(traceId),
+    spanId,
+    parentSpanId: parentSpanId ? padSpanId(parentSpanId) : void 0,
+    name: event.kind,
+    kind: 1,
+    startTimeUnixNano: ts,
+    endTimeUnixNano: ts,
+    attributes: toAttributes(attrs),
+    status: { code: 1 }
+  };
+}
+function buildLoopOtelSpans(events, traceId, rootParentSpanId) {
+  const tid = padTraceId(traceId);
+  return buildLoopSpanNodes(events).map((node) => ({
+    traceId: tid,
+    spanId: node.spanId,
+    parentSpanId: node.parentSpanId ? padSpanId(node.parentSpanId) : rootParentSpanId ? padSpanId(rootParentSpanId) : void 0,
+    name: node.name,
+    kind: 1,
+    startTimeUnixNano: msToNs(node.startMs),
+    endTimeUnixNano: msToNs(node.endMs),
+    attributes: toAttributes(node.attrs),
+    status: { code: node.error ? 2 : 1 }
+  }));
+}
+function buildLoopSpanNodes(events) {
+  if (events.length === 0) return [];
+  const out = [];
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  const str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
+  const rec = (v) => v && typeof v === "object" ? v : {};
+  const started = events.find((e) => e.kind === "loop.started");
+  const ended = events.find((e) => e.kind === "loop.ended");
+  const runId = events[0]?.runId ?? "";
+  const rootStart = started?.timestamp ?? events[0].timestamp;
+  const rootEnd = ended?.timestamp ?? events[events.length - 1].timestamp;
+  const rootId = generateSpanId();
+  const make = (spanId, parentSpanId, name, kind, startMs, endMs, attrs, error = false) => ({
+    spanId,
+    parentSpanId,
+    name,
+    kind,
+    startMs,
+    endMs,
+    attrs,
+    error
+  });
+  const sp = rec(started?.payload);
+  const rootAttrs = {
+    [GEN_AI.operation]: "invoke_workflow",
+    [GEN_AI.conversationId]: runId,
+    "tangle.loop.driver": str(sp.driver) ?? "driver"
+  };
+  if (Array.isArray(sp.agentRunNames) && sp.agentRunNames.length > 0) {
+    rootAttrs["tangle.loop.agents"] = sp.agentRunNames.map(String).join(",");
+  }
+  if (ended) {
+    const ep = rec(ended.payload);
+    const win = num(ep.winnerIterationIndex);
+    if (win !== void 0) rootAttrs["tangle.loop.winner.iteration_index"] = win;
+    const cost = num(ep.totalCostUsd);
+    if (cost !== void 0) rootAttrs["tangle.cost.usd"] = cost;
+    const dur = num(ep.durationMs);
+    if (dur !== void 0) rootAttrs["tangle.loop.duration_ms"] = dur;
+    const iters = num(ep.iterations);
+    if (iters !== void 0) rootAttrs["tangle.loop.iterations"] = iters;
+  }
+  out.push(make(rootId, void 0, "loop", "loop", rootStart, rootEnd, rootAttrs));
+  const iterStartTs = /* @__PURE__ */ new Map();
+  const placementByIdx = /* @__PURE__ */ new Map();
+  let currentRoundId;
+  let pendingRound;
+  const flushRound = (endMs) => {
+    if (!pendingRound) return;
+    out.push(
+      make(
+        pendingRound.id,
+        rootId,
+        "loop.round",
+        "round",
+        pendingRound.start,
+        endMs,
+        pendingRound.attrs
+      )
+    );
+    pendingRound = void 0;
+  };
+  for (const e of events) {
+    const p = rec(e.payload);
+    switch (e.kind) {
+      case "loop.plan": {
+        flushRound(e.timestamp);
+        const id = generateSpanId();
+        const roundIdx = num(p.roundIndex) ?? 0;
+        const attrs = {
+          [GEN_AI.operation]: "invoke_workflow",
+          "tangle.loop.round.index": roundIdx,
+          "tangle.loop.move.kind": str(p.moveKind) ?? "unknown",
+          "tangle.loop.move.round": roundIdx,
+          "tangle.loop.move.width": num(p.plannedCount) ?? 0
+        };
+        const r = str(p.rationale);
+        if (r) attrs["tangle.loop.move.rationale"] = r;
+        const parent = num(p.parentIndex);
+        if (parent !== void 0) attrs["tangle.loop.move.parent_index"] = parent;
+        if (Array.isArray(p.childIndices) && p.childIndices.length > 0) {
+          attrs["tangle.loop.move.child_indices"] = p.childIndices.map(String).join(",");
+        }
+        pendingRound = { id, start: e.timestamp, attrs };
+        currentRoundId = id;
+        break;
+      }
+      case "loop.iteration.started": {
+        const idx = num(p.iterationIndex);
+        if (idx !== void 0) iterStartTs.set(idx, e.timestamp);
+        break;
+      }
+      case "loop.iteration.dispatch": {
+        const idx = num(p.iterationIndex);
+        if (idx === void 0) break;
+        const place = {};
+        const kind = str(p.placement);
+        if (kind) place["tangle.loop.placement.kind"] = kind;
+        const sid = str(p.sandboxId);
+        if (sid) place["tangle.sandbox.id"] = sid;
+        const fid = str(p.fleetId);
+        if (fid) place["tangle.fleet.id"] = fid;
+        const mid = str(p.machineId);
+        if (mid) place["tangle.machine.id"] = mid;
+        placementByIdx.set(idx, place);
+        break;
+      }
+      case "loop.iteration.ended": {
+        const idx = num(p.iterationIndex) ?? 0;
+        const start = iterStartTs.get(idx) ?? e.timestamp;
+        const err = str(p.error);
+        const attrs = {
+          [GEN_AI.operation]: "invoke_agent",
+          "tangle.loop.iteration.index": idx
+        };
+        const agent = str(p.agentRunName);
+        if (agent) attrs[GEN_AI.agentName] = agent;
+        const tu = rec(p.tokenUsage);
+        const inTok = num(tu.input);
+        if (inTok !== void 0) attrs[GEN_AI.inputTokens] = inTok;
+        const outTok = num(tu.output);
+        if (outTok !== void 0) attrs[GEN_AI.outputTokens] = outTok;
+        const cost = num(p.costUsd);
+        if (cost !== void 0) attrs["tangle.cost.usd"] = cost;
+        const verdict = rec(p.verdict);
+        if (typeof verdict.valid === "boolean") attrs["tangle.loop.verdict.valid"] = verdict.valid;
+        const score = num(verdict.score);
+        if (score !== void 0) attrs["tangle.loop.verdict.score"] = score;
+        if (err) attrs["tangle.loop.error"] = err;
+        const gid = num(p.groupId);
+        if (gid !== void 0) attrs["tangle.loop.iteration.group_id"] = gid;
+        const par = num(p.parentIndex);
+        if (par !== void 0) attrs["tangle.loop.iteration.parent_index"] = par;
+        const dur = num(p.durationMs);
+        if (dur !== void 0) attrs["tangle.loop.iteration.duration_ms"] = dur;
+        const preview = str(p.outputPreview);
+        if (preview) attrs["tangle.loop.iteration.output_preview"] = preview;
+        Object.assign(attrs, placementByIdx.get(idx) ?? {});
+        out.push(
+          make(
+            generateSpanId(),
+            currentRoundId ?? rootId,
+            "loop.iteration",
+            "branch",
+            start,
+            e.timestamp,
+            attrs,
+            err !== void 0
+          )
+        );
+        break;
+      }
+      case "loop.decision": {
+        if (pendingRound) {
+          const dec = str(p.decision);
+          if (dec) pendingRound.attrs["tangle.loop.decision"] = dec;
+          flushRound(e.timestamp);
+        }
+        currentRoundId = void 0;
+        break;
+      }
+    }
+  }
+  flushRound(rootEnd);
+  return out;
+}
+function parseHeadersFromEnv() {
+  if (typeof process === "undefined") return {};
+  const raw = process.env.OTEL_EXPORTER_OTLP_HEADERS;
+  if (!raw) return {};
+  const out = {};
+  for (const pair of raw.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq < 0) continue;
+    const key = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1).trim();
+    if (key) out[key] = value;
+  }
+  return out;
+}
+function toAttributes(record) {
+  return Object.entries(record).map(([key, value]) => ({
+    key,
+    value: typeof value === "number" ? Number.isInteger(value) ? { intValue: value.toString() } : { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
+  }));
+}
+function msToNs(ms) {
+  return (BigInt(Math.floor(ms)) * 1000000n).toString();
+}
+function padSpanId(id) {
+  const cleaned = id.replace(/-/g, "");
+  return cleaned.slice(0, 16).padEnd(16, "0");
+}
+function padTraceId(id) {
+  const cleaned = id.replace(/-/g, "");
+  return cleaned.slice(0, 32).padEnd(32, "0");
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 8; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
+var DEFAULT_INTELLIGENCE_BASE = "https://intelligence.tangle.tools";
+async function exportEvalRuns(events, config) {
+  if (events.length === 0) return { ok: true, status: 0, accepted: 0, rejected: [] };
+  const apiKey = config?.apiKey ?? (typeof process !== "undefined" ? process.env.TANGLE_API_KEY : void 0);
+  if (!apiKey)
+    throw new Error("exportEvalRuns: apiKey required (pass config.apiKey or set TANGLE_API_KEY)");
+  const base = config?.base ?? (typeof process !== "undefined" ? process.env.INTELLIGENCE_BASE : void 0) ?? DEFAULT_INTELLIGENCE_BASE;
+  const url = `${base.replace(/\/+$/, "")}/v1/ingest/eval-runs`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`,
+      "X-Tangle-Wire-Version": INTELLIGENCE_WIRE_VERSION,
+      ...config?.idempotencyKey ? { "Idempotency-Key": config.idempotencyKey } : {}
+    },
+    body: JSON.stringify({ wireVersion: INTELLIGENCE_WIRE_VERSION, events })
+  });
+  let parsed = {};
+  try {
+    parsed = await res.json();
+  } catch {
+  }
+  return {
+    ok: res.ok,
+    status: res.status,
+    accepted: parsed.accepted ?? (res.ok ? events.length : 0),
+    rejected: parsed.rejected ?? []
+  };
+}
+
+// src/mcp/delegation-trace.ts
+var DELEGATION_TRACE_MAX_SPANS = 512;
+var DELEGATION_TRACE_MAX_BYTES = 256 * 1024;
+function buildDelegationTraceSpans(events) {
+  return buildLoopSpanNodes(events).map((node) => ({
+    spanId: node.spanId,
+    ...node.parentSpanId !== void 0 ? { parentSpanId: node.parentSpanId } : {},
+    name: node.name,
+    kind: node.kind,
+    startMs: node.startMs,
+    endMs: node.endMs,
+    ...Object.keys(node.attrs).length > 0 ? { meta: node.attrs } : {}
+  }));
+}
+function capDelegationTrace(spans, caps) {
+  const maxSpans = caps?.maxSpans ?? DELEGATION_TRACE_MAX_SPANS;
+  const maxBytes = caps?.maxBytes ?? DELEGATION_TRACE_MAX_BYTES;
+  let start = Math.max(0, spans.length - maxSpans);
+  const sizes = spans.map((span) => JSON.stringify(span).length + 1);
+  let total = 0;
+  for (let i = start; i < sizes.length; i += 1) total += sizes[i];
+  while (start < spans.length - 1 && total > maxBytes) {
+    total -= sizes[start];
+    start += 1;
+  }
+  return { trace: spans.slice(start), truncated: start > 0 };
+}
+function createDelegationTraceCollector(onSpans) {
+  const buffers = /* @__PURE__ */ new Map();
+  const flush = (events) => {
+    const spans = buildDelegationTraceSpans(events);
+    if (spans.length > 0) onSpans(spans);
+  };
+  return {
+    emitter: {
+      emit(event) {
+        const buf = buffers.get(event.runId);
+        if (buf) buf.push(event);
+        else buffers.set(event.runId, [event]);
+        if (event.kind === "loop.ended") {
+          const events = buffers.get(event.runId) ?? [event];
+          buffers.delete(event.runId);
+          flush(events);
+        }
+      }
+    },
+    settle() {
+      for (const events of buffers.values()) flush(events);
+      buffers.clear();
+    }
+  };
+}
+function generateDelegationSpanId() {
+  const bytes = new Uint8Array(8);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 8; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function composeLoopTraceEmitters(...emitters) {
+  const live = emitters.filter((e) => e !== void 0);
+  if (live.length === 0) return void 0;
+  if (live.length === 1) return live[0];
+  return {
+    emit(event) {
+      const pending = [];
+      for (const emitter of live) {
+        const result = emitter.emit(event);
+        if (result) pending.push(result);
+      }
+      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
+    }
+  };
+}
+
+// src/mcp/detached-turn.ts
+var DEFAULT_TICK_INTERVAL_MS = 5e3;
+function formatDetachedSessionRef(parts) {
+  assertRefComponent("sessionId", parts.sessionId);
+  if (parts.sandboxId === void 0) return `session=${parts.sessionId}`;
+  assertRefComponent("sandboxId", parts.sandboxId);
+  return `sandbox=${parts.sandboxId};session=${parts.sessionId}`;
+}
+function parseDetachedSessionRef(raw) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const pair of raw.split(";")) {
+    const eq = pair.indexOf("=");
+    const key = eq === -1 ? "" : pair.slice(0, eq);
+    const value = eq === -1 ? "" : pair.slice(eq + 1);
+    if (key !== "session" && key !== "sandbox" || value.length === 0 || fields.has(key)) {
+      throw new ValidationError(
+        `parseDetachedSessionRef: malformed detachedSessionRef ${JSON.stringify(raw)} \u2014 expected "session=<id>" or "sandbox=<id>;session=<id>"`
+      );
+    }
+    fields.set(key, value);
+  }
+  const sessionId = fields.get("session");
+  if (!sessionId) {
+    throw new ValidationError(
+      `parseDetachedSessionRef: detachedSessionRef ${JSON.stringify(raw)} carries no session id`
+    );
+  }
+  const sandboxId = fields.get("sandbox");
+  return { sessionId, ...sandboxId !== void 0 ? { sandboxId } : {} };
+}
+function assertRefComponent(name, value) {
+  if (value.length === 0 || value.includes(";") || value.includes("=")) {
+    throw new ValidationError(
+      `formatDetachedSessionRef: ${name} ${JSON.stringify(value)} must be non-empty and free of ";" / "="`
+    );
+  }
+}
+function detachedTurnEvents(sessionId, turn) {
+  return [
+    {
+      type: "result",
+      id: sessionId,
+      data: {
+        text: turn.text,
+        finalText: turn.text,
+        success: true,
+        result: turn.result
+      }
+    }
+  ];
+}
+async function runDetachedTurn(options) {
+  const intervalMs = options.tickIntervalMs ?? DEFAULT_TICK_INTERVAL_MS;
+  const trace = createDetachedTurnTrace(options);
+  trace.started();
+  const box = await createSandboxForSpec(options.client, options.spec, options.signal).catch(
+    (err) => {
+      trace.ended(err instanceof Error ? err.message : String(err));
+      throw err;
+    }
+  );
+  const drive = box;
+  const onAbort = () => {
+    void drive._sessionCancel?.(options.sessionId).catch(() => {
+    });
+  };
+  try {
+    if (typeof drive.driveTurn !== "function") {
+      throw new ValidationError(
+        "runDetachedTurn: the acquired sandbox exposes no driveTurn(message, { sessionId }) \u2014 detached dispatch requires @tangle-network/sandbox >= 0.6 and a session-backed placement (sibling/fleet); disable detached dispatch for this executor."
+      );
+    }
+    const sandboxId = box.id;
+    if (typeof sandboxId !== "string" || sandboxId.length === 0) {
+      throw new ValidationError(
+        "runDetachedTurn: the acquired sandbox carries no id \u2014 without it the detached run cannot be resumed after a restart, so refusing to dispatch detached."
+      );
+    }
+    options.bindSandbox(sandboxId);
+    trace.dispatched(sandboxId);
+    options.signal.addEventListener("abort", onAbort, { once: true });
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      const tick = await drive.driveTurn(options.prompt, {
+        sessionId: options.sessionId,
+        turnId: options.sessionId,
+        ...options.wallCapMs !== void 0 ? { wallCapMs: options.wallCapMs } : {}
+      });
+      throwIfAborted(options.signal);
+      if (tick.state === "completed") {
+        trace.ended();
+        return { text: tick.text, result: tick.result };
+      }
+      if (tick.state === "failed") {
+        throw new Error(`detached turn ${options.sessionId} failed: ${tick.error}`);
+      }
+      options.report({ iteration: 0, phase: detachedRunningPhase(tick.elapsedMs) });
+      await sleep(intervalMs, options.signal);
+    }
+  } catch (err) {
+    trace.ended(err instanceof Error ? err.message : String(err));
+    throw err;
+  } finally {
+    options.signal.removeEventListener("abort", onAbort);
+    if (options.signal.aborted) onAbort();
+    await deleteBoxSafe(box);
+  }
+}
+function createDetachedTurnTrace(options) {
+  const emitter = options.traceEmitter;
+  if (!emitter) {
+    return { started() {
+    }, dispatched() {
+    }, ended() {
+    } };
+  }
+  const runId = options.sessionId;
+  const agentRunName = options.spec.name ?? options.spec.profile.name ?? "detached-turn";
+  const startMs = Date.now();
+  let done = false;
+  const emit = (event) => {
+    void emitter.emit(event);
+  };
+  return {
+    started() {
+      emit({
+        kind: "loop.started",
+        runId,
+        timestamp: startMs,
+        payload: {
+          driver: "detached-turn",
+          agentRunNames: [agentRunName],
+          maxIterations: 1,
+          maxConcurrency: 1
+        }
+      });
+      emit({
+        kind: "loop.iteration.started",
+        runId,
+        timestamp: startMs,
+        payload: { iterationIndex: 0, agentRunName, taskHash: options.sessionId }
+      });
+    },
+    dispatched(sandboxId) {
+      emit({
+        kind: "loop.iteration.dispatch",
+        runId,
+        timestamp: Date.now(),
+        payload: {
+          iterationIndex: 0,
+          agentRunName,
+          placement: options.placement ?? "sibling",
+          sandboxId
+        }
+      });
+    },
+    ended(error) {
+      if (done) return;
+      done = true;
+      const endMs = Date.now();
+      emit({
+        kind: "loop.iteration.ended",
+        runId,
+        timestamp: endMs,
+        payload: {
+          iterationIndex: 0,
+          agentRunName,
+          costUsd: 0,
+          durationMs: endMs - startMs,
+          ...error !== void 0 ? { error } : {}
+        }
+      });
+      emit({
+        kind: "loop.ended",
+        runId,
+        timestamp: endMs,
+        payload: {
+          ...error === void 0 ? { winnerIterationIndex: 0 } : {},
+          totalCostUsd: 0,
+          durationMs: endMs - startMs,
+          iterations: 1
+        }
+      });
+    }
+  };
+}
+function detachedRunningPhase(elapsedMs) {
+  return elapsedMs === void 0 ? "detached-running" : `detached-running ${Math.round(elapsedMs / 1e3)}s`;
+}
+function createDriveTurnResumeDriver(options) {
+  const cancelHooked = /* @__PURE__ */ new Set();
+  return {
+    intervalMs: options.intervalMs ?? DEFAULT_TICK_INTERVAL_MS,
+    async tick({ record, detachedSessionRef }, ctx) {
+      const ref = parseDetachedSessionRef(detachedSessionRef);
+      if (ref.sandboxId === void 0) {
+        return {
+          state: "failed",
+          error: {
+            message: `detached session "${ref.sessionId}" was never bound to a sandbox \u2014 the previous process died before the box was acquired, so the turn was never dispatched and cannot be resumed`,
+            kind: "DetachedSessionUnboundError"
+          }
+        };
+      }
+      const box = await options.resolveSandbox(ref.sandboxId);
+      if (!cancelHooked.has(record.taskId)) {
+        cancelHooked.add(record.taskId);
+        ctx.signal.addEventListener(
+          "abort",
+          () => {
+            void box._sessionCancel?.(ref.sessionId).catch(() => {
+            });
+          },
+          { once: true }
+        );
+      }
+      if (ctx.signal.aborted) throwAbort();
+      const tick = await box.driveTurn(options.buildMessage(record), {
+        sessionId: ref.sessionId,
+        turnId: ref.sessionId,
+        ...options.wallCapMs !== void 0 ? { wallCapMs: options.wallCapMs } : {}
+      });
+      if (tick.state === "completed") {
+        const output = await options.settleOutput(
+          { text: tick.text, result: tick.result },
+          record,
+          {
+            signal: ctx.signal
+          }
+        );
+        return { state: "completed", output };
+      }
+      if (tick.state === "failed") {
+        return {
+          state: "failed",
+          error: {
+            message: `detached turn ${ref.sessionId} failed: ${tick.error}`,
+            kind: "DetachedTurnFailedError"
+          }
+        };
+      }
+      ctx.report({ iteration: 0, phase: detachedRunningPhase(tick.elapsedMs) });
+      return { state: "running" };
+    }
+  };
+}
+
+// src/mcp/executor.ts
+function createSiblingSandboxExecutor(options) {
+  const underlying = options.client;
+  const client = {
+    create(opts) {
+      return underlying.create(opts);
+    },
+    describePlacement(box) {
+      return { kind: "sibling", sandboxId: readId(box) };
+    }
+  };
+  return {
+    client,
+    placement: "sibling",
+    describe() {
+      return "sibling-sandbox (each delegation = fresh sandbox via client.create)";
+    }
+  };
+}
+function createFleetWorkspaceExecutor(options) {
+  const fleet = options.fleet;
+  const exclude = new Set(options.excludeMachineIds ?? []);
+  let callIndex = 0;
+  const placementBySandboxId = /* @__PURE__ */ new Map();
+  const client = {
+    async create() {
+      const ids = fleet.ids.filter((id) => !exclude.has(id));
+      if (ids.length === 0) {
+        throw new Error(
+          `agent-runtime: fleet ${fleet.fleetId} has no eligible worker machines (ids=[${fleet.ids.join(",")}], excluded=[${[...exclude].join(",")}])`
+        );
+      }
+      const selector = options.selectMachine;
+      const machineId = selector ? selector({ callIndex, ids }) : ids[callIndex % ids.length];
+      callIndex += 1;
+      if (typeof machineId !== "string" || machineId.length === 0) {
+        throw new Error("agent-runtime: fleet executor selectMachine returned an empty machine id");
+      }
+      const box = await fleet.sandbox(machineId);
+      const sandboxId = readId(box);
+      if (sandboxId) placementBySandboxId.set(sandboxId, { machineId });
+      return box;
+    },
+    describePlacement(box) {
+      const sandboxId = readId(box);
+      const recorded = sandboxId ? placementBySandboxId.get(sandboxId) : void 0;
+      return {
+        kind: "fleet",
+        sandboxId,
+        fleetId: fleet.fleetId,
+        machineId: recorded?.machineId
+      };
+    }
+  };
+  return {
+    client,
+    placement: "fleet",
+    describe() {
+      const excluded = exclude.size > 0 ? ` (excluded=[${[...exclude].join(",")}])` : "";
+      return `fleet-workspace (fleetId=${fleet.fleetId}, machines=[${fleet.ids.join(",")}]${excluded})`;
+    }
+  };
+}
+function readId(box) {
+  const raw = box.id;
+  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+
+// src/mcp/delegates.ts
+function createDefaultCoderDelegate(options) {
+  const executor = resolveExecutor(options);
+  const sandboxClient = executor.client;
+  const fanoutHarnesses = options.fanoutHarnesses;
+  const maxConcurrency = options.maxConcurrency ?? 4;
+  const traceEmitter = options.traceEmitter;
+  return async (args, ctx) => {
+    const task = coderTaskFromArgs(args);
+    const variants = Math.max(1, Math.trunc(args.variants ?? 1));
+    const loopEmitter = composeLoopTraceEmitters(traceEmitter, ctx.traceEmitter);
+    ctx.report({ iteration: 0, phase: "starting" });
+    if (variants <= 1) {
+      const { agentRunSpec, output, validator } = coderProfile({
+        task,
+        ...options.harness ? { harness: options.harness } : {},
+        ...options.model ? { model: options.model } : {}
+      });
+      if (ctx.detachedSessionRef !== void 0 && ctx.updateDetachedSessionRef) {
+        const { sessionId } = parseDetachedSessionRef(ctx.detachedSessionRef);
+        const rebind = ctx.updateDetachedSessionRef;
+        const turn = await runDetachedTurn({
+          client: sandboxClient,
+          spec: agentRunSpec,
+          prompt: agentRunSpec.taskToPrompt(task),
+          sessionId,
+          bindSandbox: (sandboxId) => rebind(formatDetachedSessionRef({ sandboxId, sessionId })),
+          signal: ctx.signal,
+          report: ctx.report,
+          ...loopEmitter ? { traceEmitter: loopEmitter } : {},
+          ...executor.placement === "fleet" ? { placement: "fleet" } : {},
+          ...options.detachedTickIntervalMs !== void 0 ? { tickIntervalMs: options.detachedTickIntervalMs } : {},
+          ...options.detachedWallCapMs !== void 0 ? { wallCapMs: options.detachedWallCapMs } : {}
+        });
+        const chosen3 = await settleDetachedCoderTurn(turn, {
+          task,
+          sessionId,
+          signal: ctx.signal,
+          ...options.harness ? { harness: options.harness } : {},
+          ...options.model ? { model: options.model } : {},
+          ...options.reviewer ? { reviewer: options.reviewer } : {}
+        });
+        ctx.report({ iteration: 1, phase: "completed" });
+        return chosen3;
+      }
+      const result2 = await runLoop({
+        driver: singleShotDriver,
+        agentRun: agentRunSpec,
+        output,
+        validator,
+        task,
+        ctx: {
+          sandboxClient,
+          signal: ctx.signal,
+          ...loopEmitter ? { traceEmitter: loopEmitter } : {}
+        },
+        maxIterations: 1,
+        maxConcurrency
+      });
+      const chosen2 = await pickCoderWinner({
+        iterations: result2.iterations,
+        reviewer: options.reviewer,
+        selection: options.winnerSelection ?? "highest-score",
+        task,
+        signal: ctx.signal
+      });
+      if (!chosen2) throw new Error(noWinnerMessage(options.reviewer));
+      ctx.report({ iteration: 1, phase: "completed" });
+      return chosen2;
+    }
+    const fanout = multiHarnessCoderFanout({
+      ...fanoutHarnesses && fanoutHarnesses.length > 0 ? { harnesses: fanoutHarnesses.slice(0, variants) } : {},
+      ...options.fanoutModels ? { models: options.fanoutModels.slice(0, variants) } : {}
+    });
+    const agentRuns = fanout.agentRuns.slice(0, variants);
+    const result = await runLoop({
+      driver: fanout.driver,
+      agentRuns,
+      output: fanout.output,
+      validator: fanout.validator,
+      task,
+      ctx: {
+        sandboxClient,
+        signal: ctx.signal,
+        ...loopEmitter ? { traceEmitter: loopEmitter } : {}
+      },
+      maxIterations: variants,
+      maxConcurrency: Math.min(maxConcurrency, variants)
+    });
+    const chosen = await pickCoderWinner({
+      iterations: result.iterations,
+      reviewer: options.reviewer,
+      selection: options.winnerSelection ?? "highest-score",
+      task,
+      signal: ctx.signal
+    });
+    if (!chosen) throw new Error(noWinnerMessage(options.reviewer));
+    ctx.report({ iteration: agentRuns.length, phase: "completed" });
+    return chosen;
+  };
+}
+async function pickCoderWinner(args) {
+  const valid = [];
+  for (const iter of args.iterations) {
+    if (iter.output === void 0 || iter.error || iter.verdict?.valid !== true) continue;
+    valid.push({
+      index: iter.index,
+      output: iter.output,
+      score: iter.verdict.score ?? 0,
+      readiness: iter.verdict.score ?? 0
+    });
+  }
+  if (valid.length === 0) return void 0;
+  let eligible = valid;
+  if (args.reviewer) {
+    eligible = [];
+    for (const c of valid) {
+      const review = await args.reviewer(c.output, args.task, { signal: args.signal });
+      if (review.approved) eligible.push({ ...c, readiness: review.readiness });
+    }
+    if (eligible.length === 0) return void 0;
+  }
+  return selectCoderCandidate(eligible, args.selection).output;
+}
+function selectCoderCandidate(candidates, selection) {
+  const diffLines = (c) => c.output.diffStats.insertions + c.output.diffStats.deletions;
+  const sorted = [...candidates].sort((a, b) => {
+    switch (selection) {
+      case "smallest-diff":
+        return diffLines(a) - diffLines(b) || a.index - b.index;
+      case "highest-readiness":
+        return b.readiness - a.readiness || a.index - b.index;
+      case "first-approved":
+        return a.index - b.index;
+      default:
+        return b.score - a.score || a.index - b.index;
+    }
+  });
+  return sorted[0];
+}
+function noWinnerMessage(reviewer) {
+  return reviewer ? "coder delegate: no candidate passed validation + review" : "coder delegate: no candidate passed validation";
+}
+function coderTaskFromArgs(args) {
+  return {
+    goal: buildCoderGoal(args),
+    repoRoot: args.repoRoot,
+    testCmd: args.config?.testCmd,
+    typecheckCmd: args.config?.typecheckCmd,
+    forbiddenPaths: args.config?.forbiddenPaths,
+    maxDiffLines: args.config?.maxDiffLines
+  };
+}
+async function settleDetachedCoderTurn(turn, options) {
+  const { output, validator } = coderProfile({
+    task: options.task,
+    ...options.harness ? { harness: options.harness } : {},
+    ...options.model ? { model: options.model } : {}
+  });
+  const parsed = output.parse(detachedTurnEvents(options.sessionId, turn));
+  const verdict = await validator.validate(parsed, { iteration: 0, signal: options.signal });
+  if (verdict.valid !== true) throw new Error(noWinnerMessage(options.reviewer));
+  if (options.reviewer) {
+    const review = await options.reviewer(parsed, options.task, { signal: options.signal });
+    if (!review.approved) throw new Error(noWinnerMessage(options.reviewer));
+  }
+  return parsed;
+}
+function buildCoderGoal(args) {
+  if (!args.contextHint) return args.goal;
+  return [args.goal, "", "## Context", args.contextHint].join("\n");
+}
+function resolveExecutor(options) {
+  if (options.executor && options.sandboxClient) {
+    throw new Error("createDefaultCoderDelegate: pass exactly one of `executor` or `sandboxClient`");
+  }
+  if (options.executor) return options.executor;
+  if (options.sandboxClient) {
+    return createSiblingSandboxExecutor({ client: options.sandboxClient });
+  }
+  throw new Error("createDefaultCoderDelegate: `executor` or `sandboxClient` is required");
+}
+var singleShotDriver = {
+  name: "mcp-single-shot",
+  async plan(task, history) {
+    return history.length === 0 ? [task] : [];
+  },
+  decide(history) {
+    return history.length > 0 ? "pick-winner" : "fail";
+  }
+};
+
+export {
+  createOtelExporter,
+  loopEventToOtelSpan,
+  buildLoopOtelSpans,
+  buildLoopSpanNodes,
+  INTELLIGENCE_WIRE_VERSION,
+  exportEvalRuns,
+  DELEGATION_TRACE_MAX_SPANS,
+  DELEGATION_TRACE_MAX_BYTES,
+  buildDelegationTraceSpans,
+  capDelegationTrace,
+  createDelegationTraceCollector,
+  generateDelegationSpanId,
+  composeLoopTraceEmitters,
+  formatDetachedSessionRef,
+  parseDetachedSessionRef,
+  detachedTurnEvents,
+  runDetachedTurn,
+  createDriveTurnResumeDriver,
+  createSiblingSandboxExecutor,
+  createFleetWorkspaceExecutor,
+  createDefaultCoderDelegate,
+  coderTaskFromArgs,
+  settleDetachedCoderTurn
+};
+//# sourceMappingURL=chunk-OM3YNZIW.js.map