@tangle-network/agent-runtime 0.53.0 → 0.54.0

package/dist/chunk-AYRQZRDV.js

@@ -1,623 +0,0 @@
-import {
-  coderProfile,
-  multiHarnessCoderFanout
-} from "./chunk-KADIJAD4.js";
-import {
-  buildLoopSpanNodes
-} from "./chunk-G3RGMA7C.js";
-import {
-  createSandboxForSpec,
-  deleteBoxSafe,
-  runLoop,
-  sleep,
-  throwAbort,
-  throwIfAborted
-} from "./chunk-K6WP7PYW.js";
-import {
-  ValidationError
-} from "./chunk-GSUO5QS6.js";
-
-// 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 {
-  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-AYRQZRDV.js.map