@tangle-network/agent-runtime 0.43.0 → 0.45.0

package/dist/chunk-EKBSQYZE.js

@@ -1,813 +0,0 @@
-import {
-  PlannerError,
-  ValidationError
-} from "./chunk-SQSCRJ7U.js";
-
-// src/loops/drivers/dynamic.ts
-function createDynamicDriver(options) {
-  if (typeof options.planner !== "function") {
-    throw new ValidationError("createDynamicDriver: planner must be a function");
-  }
-  const maxIterations = options.maxIterations ?? 8;
-  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
-    throw new ValidationError("createDynamicDriver: maxIterations must be > 0");
-  }
-  const maxFanout = options.maxFanout ?? 4;
-  if (!Number.isFinite(maxFanout) || maxFanout < 1) {
-    throw new ValidationError("createDynamicDriver: maxFanout must be >= 1");
-  }
-  let pending;
-  return {
-    name: options.name ?? "dynamic",
-    async plan(task, history) {
-      if (history.length >= maxIterations) {
-        pending = { kind: "stop", rationale: `maxIterations (${maxIterations}) reached` };
-        return [];
-      }
-      const move = await options.planner({
-        task,
-        history,
-        iterationsSpent: history.length,
-        iterationsRemaining: maxIterations - history.length
-      });
-      pending = validateMove(move, maxFanout);
-      switch (pending.kind) {
-        case "refine":
-          return [pending.task];
-        case "fanout":
-          return pending.tasks;
-        case "stop":
-          return [];
-      }
-    },
-    decide() {
-      return pending?.kind === "stop" ? "done" : "continue";
-    },
-    describePlan() {
-      if (!pending) return void 0;
-      const out = { kind: pending.kind };
-      if (pending.rationale !== void 0) out.rationale = pending.rationale;
-      if (pending.kind !== "stop" && pending.parentIndex !== void 0) {
-        out.parentIndex = pending.parentIndex;
-      }
-      return out;
-    }
-  };
-}
-function validateMove(move, maxFanout) {
-  if (!move || typeof move !== "object" || typeof move.kind !== "string") {
-    throw new PlannerError(`dynamic planner returned a non-move value: ${describe(move)}`);
-  }
-  switch (move.kind) {
-    case "refine":
-      return move;
-    case "stop":
-      return move;
-    case "fanout": {
-      if (!Array.isArray(move.tasks) || move.tasks.length === 0) {
-        throw new PlannerError("dynamic planner fanout move must carry a non-empty tasks[]");
-      }
-      if (move.tasks.length <= maxFanout) return move;
-      return {
-        kind: "fanout",
-        tasks: move.tasks.slice(0, maxFanout),
-        rationale: `${move.rationale ?? ""} [clamped ${move.tasks.length}\u2192${maxFanout}]`.trim()
-      };
-    }
-    default:
-      throw new PlannerError(
-        `dynamic planner returned unknown move kind: ${describe(move.kind)}`
-      );
-  }
-}
-function describe(value) {
-  try {
-    return JSON.stringify(value) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function summarizeHistory(history, opts = {}) {
-  const maxOutputChars = opts.maxOutputChars ?? 600;
-  return history.map((iter) => {
-    const row = { index: iter.index, agentRunName: iter.agentRunName };
-    if (iter.verdict) {
-      row.valid = iter.verdict.valid;
-      if (typeof iter.verdict.score === "number") row.score = iter.verdict.score;
-    }
-    if (iter.error) row.error = iter.error.message;
-    if (iter.output !== void 0) {
-      const serialized = describe(iter.output);
-      row.output = serialized.length > maxOutputChars ? `${serialized.slice(0, maxOutputChars)}\u2026` : serialized;
-    }
-    return row;
-  });
-}
-
-// src/loops/drivers/refine.ts
-function createRefineDriver(options = {}) {
-  const maxIterations = options.maxIterations ?? 5;
-  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
-    throw new ValidationError("createRefineDriver: maxIterations must be > 0");
-  }
-  const refineTask = options.refineTask;
-  return {
-    name: options.name ?? "refine",
-    async plan(task, history) {
-      if (history.length >= maxIterations) return [];
-      if (history.length === 0) return [task];
-      const prior = history.at(-1);
-      if (!prior) return [task];
-      if (prior.verdict?.valid === true) return [];
-      if (!refineTask || !prior.verdict) return [prior.task];
-      return [refineTask(prior.task, prior.verdict)];
-    },
-    decide(history) {
-      const last = history.at(-1);
-      if (!last) return "continue";
-      if (last.verdict?.valid === true) return "stop";
-      if (history.length >= maxIterations) return "stop";
-      return "continue";
-    }
-  };
-}
-function refineWinnerIndex(iterations) {
-  for (let i = iterations.length - 1; i >= 0; i -= 1) {
-    if (iterations[i]?.verdict?.valid) return i;
-  }
-  return iterations.length > 0 ? iterations.length - 1 : void 0;
-}
-
-// src/loops/drivers/sandbox-planner.ts
-function createSandboxPlanner(opts) {
-  if (!opts.client || typeof opts.client.create !== "function") {
-    throw new ValidationError("createSandboxPlanner: client.create is required");
-  }
-  if (typeof opts.decodeTask !== "function") {
-    throw new ValidationError("createSandboxPlanner: decodeTask is required");
-  }
-  const buildPrompt = opts.buildPrompt ?? defaultBuildPrompt;
-  const parseEnvelope = opts.parseEnvelope ?? defaultParseEnvelope;
-  return async (ctx) => {
-    const box = await opts.client.create(buildSandboxOptions(opts.profile, opts.sandboxOverrides));
-    const events = [];
-    for await (const event of box.streamPrompt(buildPrompt(ctx), { signal: opts.signal })) {
-      events.push(event);
-    }
-    const envelope = parseEnvelope(events);
-    if (!envelope) {
-      throw new PlannerError("sandbox planner emitted no parseable topology-move envelope");
-    }
-    return envelopeToMove(envelope, ctx, opts.decodeTask);
-  };
-}
-function envelopeToMove(envelope, ctx, decodeTask) {
-  const kind = String(envelope.kind ?? "").toLowerCase();
-  const rationale = typeof envelope.rationale === "string" ? envelope.rationale : void 0;
-  if (kind === "stop") {
-    return { kind: "stop", rationale };
-  }
-  if (kind === "refine") {
-    const raw = Array.isArray(envelope.tasks) ? envelope.tasks[0] : void 0;
-    const task = raw === void 0 ? ctx.task : decodeTaskGuarded(decodeTask, raw, ctx);
-    return { kind: "refine", task, rationale };
-  }
-  if (kind === "fanout") {
-    const tasks = resolveFanoutTasks(envelope, ctx, decodeTask);
-    return { kind: "fanout", tasks, rationale };
-  }
-  throw new PlannerError(
-    `sandbox planner emitted unknown move kind: ${JSON.stringify(envelope.kind)}`
-  );
-}
-function resolveFanoutTasks(envelope, ctx, decodeTask) {
-  if (Array.isArray(envelope.tasks) && envelope.tasks.length > 0) {
-    return envelope.tasks.map((raw) => decodeTaskGuarded(decodeTask, raw, ctx));
-  }
-  if (typeof envelope.n === "number" && Number.isFinite(envelope.n) && envelope.n >= 1) {
-    return Array.from({ length: Math.floor(envelope.n) }, () => ctx.task);
-  }
-  throw new PlannerError("sandbox planner fanout envelope needs a non-empty tasks[] or n >= 1");
-}
-function decodeTaskGuarded(decodeTask, raw, ctx) {
-  try {
-    return decodeTask(raw, ctx);
-  } catch (err) {
-    throw new PlannerError(`sandbox planner decodeTask rejected ${JSON.stringify(raw)}`, {
-      cause: err
-    });
-  }
-}
-function buildSandboxOptions(profile, overrides) {
-  const base = overrides ?? {};
-  const overrideBackend = base.backend;
-  const explicitType = profile.metadata?.backendType;
-  return {
-    ...base,
-    backend: {
-      type: overrideBackend?.type ?? explicitType ?? "opencode",
-      profile,
-      ...overrideBackend?.model ? { model: overrideBackend.model } : {},
-      ...overrideBackend?.server ? { server: overrideBackend.server } : {}
-    }
-  };
-}
-function defaultBuildPrompt(ctx) {
-  const summary = summarizeHistory(ctx.history);
-  return [
-    "You are the loop planner. You do not do the work \u2014 you decide the topology of the next round.",
-    "",
-    `Root task:
-${safeJson(ctx.task)}`,
-    "",
-    `Iterations spent: ${ctx.iterationsSpent}. Remaining before the hard cap: ${ctx.iterationsRemaining}.`,
-    "",
-    ctx.history.length === 0 ? "No attempts yet." : `Attempts so far (index, agent, verdict, output):
-${safeJson(summary)}`,
-    "",
-    "Choose ONE move and emit it as a fenced JSON block:",
-    '  - {"kind":"refine","tasks":[<task>],"rationale":"..."} \u2014 one more attempt; omit tasks to replay the root task.',
-    '  - {"kind":"fanout","tasks":[<task>,<task>],"rationale":"..."} \u2014 N parallel branches (or "n": N for N copies of the root task).',
-    '  - {"kind":"stop","rationale":"..."} \u2014 a valid result exists or further attempts will not help.',
-    "",
-    "Stop as soon as an attempt is valid. Prefer refine when an attempt is close; fan out when attempts disagree or the approach is uncertain.",
-    "Emit ONLY the JSON block."
-  ].join("\n");
-}
-function defaultParseEnvelope(events) {
-  for (let i = events.length - 1; i >= 0; i -= 1) {
-    const event = events[i];
-    if (!event) continue;
-    const type = String(event.type ?? "");
-    const data = isRecord(event.data) ? event.data : void 0;
-    if (!data) continue;
-    if (type === "result" || type === "final" || type === "planner.move") {
-      const direct = coerceEnvelope(data.result ?? data.output ?? data);
-      if (direct) return direct;
-    }
-  }
-  for (let i = events.length - 1; i >= 0; i -= 1) {
-    const event = events[i];
-    if (!event) continue;
-    const data = isRecord(event.data) ? event.data : void 0;
-    if (!data) continue;
-    const text = pickString(data.text) ?? pickString(data.delta) ?? pickString(data.content);
-    if (!text) continue;
-    const fenced = extractFencedJson(text);
-    const coerced = coerceEnvelope(fenced);
-    if (coerced) return coerced;
-  }
-  return void 0;
-}
-function coerceEnvelope(value) {
-  if (!isRecord(value)) return void 0;
-  if (typeof value.kind !== "string" || value.kind.length === 0) return void 0;
-  const out = { kind: value.kind };
-  if (Array.isArray(value.tasks)) out.tasks = value.tasks;
-  if (typeof value.n === "number") out.n = value.n;
-  if (typeof value.rationale === "string") out.rationale = value.rationale;
-  return out;
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function pickString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function extractFencedJson(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  const body = (match?.[1] ?? text).trim();
-  if (!body) return void 0;
-  try {
-    return JSON.parse(body);
-  } catch {
-    return void 0;
-  }
-}
-function safeJson(value) {
-  try {
-    return JSON.stringify(value, null, 2) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-
-// src/loops/report-usage.ts
-function reportLoopUsage(cost, result, source = "loop") {
-  cost.observe(result.costUsd, source);
-  cost.observeTokens({ input: result.tokenUsage.input, output: result.tokenUsage.output });
-}
-
-// src/loops/sandbox-events.ts
-function extractLlmCallEvent(event, agentRunName) {
-  if (!event || typeof event !== "object") return void 0;
-  const type = String(event.type ?? "");
-  const data = event.data && typeof event.data === "object" ? event.data : {};
-  if (type === "llm_call" || type === "cost.usage" || type === "usage") {
-    return buildLlmCall(data, agentRunName);
-  }
-  if (type === "message.completed" || type === "result" || type === "final") {
-    const usage = data.usage;
-    if (!usage || typeof usage !== "object") return void 0;
-    return buildLlmCall({ ...usage, model: data.model ?? usage.model }, agentRunName);
-  }
-  if (type === "done") {
-    const usage = data.tokenUsage;
-    if (!usage || typeof usage !== "object") return void 0;
-    const out = pickFiniteNumber(usage, ["outputTokens", "completion_tokens", "tokensOut"]);
-    const reasoning = pickFiniteNumber(usage, ["reasoningTokens"]);
-    const mergedOut = out !== void 0 || reasoning !== void 0 ? (out ?? 0) + (reasoning ?? 0) : void 0;
-    return buildLlmCall(
-      {
-        inputTokens: usage.inputTokens,
-        outputTokens: mergedOut,
-        totalCostUsd: data.totalCostUsd,
-        model: data.model ?? usage.model
-      },
-      agentRunName
-    );
-  }
-  return void 0;
-}
-function buildLlmCall(data, agentRunName) {
-  const tokensIn = pickFiniteNumber(data, ["tokensIn", "inputTokens", "prompt_tokens"]);
-  const tokensOut = pickFiniteNumber(data, ["tokensOut", "outputTokens", "completion_tokens"]);
-  const costUsd = pickFiniteNumber(data, ["costUsd", "totalCostUsd", "cost_usd", "cost"]);
-  if (tokensIn === void 0 && tokensOut === void 0 && costUsd === void 0) {
-    return void 0;
-  }
-  const model = typeof data.model === "string" && data.model.length > 0 ? data.model : agentRunName;
-  const event = {
-    type: "llm_call",
-    model
-  };
-  if (tokensIn !== void 0) event.tokensIn = tokensIn;
-  if (tokensOut !== void 0) event.tokensOut = tokensOut;
-  if (costUsd !== void 0) event.costUsd = costUsd;
-  return event;
-}
-function pickFiniteNumber(data, keys) {
-  for (const key of keys) {
-    const value = data[key];
-    if (typeof value === "number" && Number.isFinite(value)) return value;
-  }
-  return void 0;
-}
-function mapSandboxEvent(event, opts = {}) {
-  if (!event || typeof event !== "object") return void 0;
-  const type = String(event.type ?? "");
-  const data = event.data && typeof event.data === "object" ? event.data : {};
-  if (type === "message.part.updated") {
-    const part = data.part && typeof data.part === "object" ? data.part : {};
-    const partType = String(part.type ?? "");
-    const delta = typeof data.delta === "string" ? data.delta : void 0;
-    const text = delta ?? (typeof part.text === "string" ? part.text : void 0);
-    if (text === void 0) return void 0;
-    if (partType === "text") return { type: "text_delta", text };
-    if (partType === "reasoning" || partType === "thinking")
-      return { type: "reasoning_delta", text };
-    return void 0;
-  }
-  return extractLlmCallEvent(event, opts.agentRunName ?? "agent");
-}
-
-// src/loops/run-loop.ts
-var DEFAULT_MAX_ITERATIONS = 10;
-var DEFAULT_MAX_CONCURRENCY = 4;
-async function runLoop(options) {
-  const specs = resolveAgentRuns(options);
-  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
-    throw new ValidationError("runLoop: maxIterations must be > 0");
-  }
-  const maxConcurrency = options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY;
-  if (!Number.isFinite(maxConcurrency) || maxConcurrency <= 0) {
-    throw new ValidationError("runLoop: maxConcurrency must be > 0");
-  }
-  if (!options.ctx?.sandboxClient || typeof options.ctx.sandboxClient.create !== "function") {
-    throw new ValidationError("runLoop: ctx.sandboxClient.create is required");
-  }
-  const now = options.now ?? Date.now;
-  const runId = options.runId ?? `loop-${randomSuffix()}`;
-  const loopStart = now();
-  const driverName = options.driver.name ?? "driver";
-  const iterations = [];
-  let round = 0;
-  await emitTrace(options.ctx.traceEmitter, {
-    kind: "loop.started",
-    runId,
-    timestamp: now(),
-    payload: {
-      driver: driverName,
-      agentRunNames: specs.map((spec) => spec.name ?? spec.profile.name ?? "agent"),
-      maxIterations,
-      maxConcurrency
-    }
-  });
-  const controller = new AbortController();
-  const onOuterAbort = () => controller.abort();
-  if (options.ctx.signal) {
-    if (options.ctx.signal.aborted) controller.abort();
-    else options.ctx.signal.addEventListener("abort", onOuterAbort, { once: true });
-  }
-  try {
-    while (iterations.length < maxIterations) {
-      if (controller.signal.aborted) throwAbort();
-      const planned = await options.driver.plan(options.task, iterations);
-      const planDesc = options.driver.describePlan?.();
-      const roundIndex = round;
-      const baseIndex = iterations.length;
-      const remaining = maxIterations - iterations.length;
-      const slice = planned.slice(0, remaining);
-      const parentIndex = planDesc?.parentIndex ?? (roundIndex === 0 ? void 0 : branchPoint(iterations));
-      const childIndices = slice.map((_, i) => baseIndex + i);
-      await emitTrace(options.ctx.traceEmitter, {
-        kind: "loop.plan",
-        runId,
-        timestamp: now(),
-        payload: {
-          roundIndex,
-          plannedCount: planned.length,
-          moveKind: planDesc?.kind ?? (planned.length === 0 ? "stop" : planned.length === 1 ? "refine" : "fanout"),
-          rationale: planDesc?.rationale,
-          parentIndex,
-          childIndices
-        }
-      });
-      round += 1;
-      if (planned.length === 0) break;
-      for (let i = 0; i < slice.length; i += 1) {
-        const spec = specs[(baseIndex + i) % specs.length];
-        iterations.push({
-          index: baseIndex + i,
-          task: slice[i],
-          agentRunName: spec.name ?? spec.profile.name ?? "agent",
-          events: [],
-          startedAt: now(),
-          endedAt: 0,
-          costUsd: 0,
-          tokenUsage: { input: 0, output: 0 }
-        });
-      }
-      await runBatch({
-        slice,
-        baseIndex,
-        iterations,
-        specs,
-        output: options.output,
-        validator: options.validator,
-        maxConcurrency,
-        signal: controller.signal,
-        ctx: options.ctx,
-        runId,
-        now,
-        roundIndex,
-        parentIndex
-      });
-      if (controller.signal.aborted) throwAbort();
-      const decision2 = await options.driver.decide(iterations);
-      await emitTrace(options.ctx.traceEmitter, {
-        kind: "loop.decision",
-        runId,
-        timestamp: now(),
-        payload: { decision: serializeDecision(decision2), historyLength: iterations.length }
-      });
-      if (isTerminalDecision(decision2)) {
-        return finalize({
-          options,
-          decision: decision2,
-          iterations,
-          startMs: loopStart,
-          now,
-          runId
-        });
-      }
-    }
-    if (iterations.length >= maxIterations) {
-      const decision2 = await options.driver.decide(iterations);
-      await emitTrace(options.ctx.traceEmitter, {
-        kind: "loop.decision",
-        runId,
-        timestamp: now(),
-        payload: { decision: serializeDecision(decision2), historyLength: iterations.length }
-      });
-      return finalize({ options, decision: decision2, iterations, startMs: loopStart, now, runId });
-    }
-    const decision = await options.driver.decide(iterations);
-    await emitTrace(options.ctx.traceEmitter, {
-      kind: "loop.decision",
-      runId,
-      timestamp: now(),
-      payload: { decision: serializeDecision(decision), historyLength: iterations.length }
-    });
-    return finalize({ options, decision, iterations, startMs: loopStart, now, runId });
-  } finally {
-    if (options.ctx.signal) options.ctx.signal.removeEventListener("abort", onOuterAbort);
-  }
-}
-async function runBatch(args) {
-  const queue = args.slice.map((task, offset) => ({ task, index: args.baseIndex + offset }));
-  const inflight = /* @__PURE__ */ new Set();
-  while (queue.length > 0 || inflight.size > 0) {
-    while (inflight.size < args.maxConcurrency && queue.length > 0) {
-      const item = queue.shift();
-      const p = executeIteration({ ...args, item }).finally(() => inflight.delete(p));
-      inflight.add(p);
-    }
-    if (inflight.size === 0) break;
-    await Promise.race(inflight);
-  }
-}
-async function executeIteration(args) {
-  const slot = args.iterations[args.item.index];
-  if (!slot)
-    throw new ValidationError(`runLoop: missing iteration slot at index ${args.item.index}`);
-  const spec = args.specs[args.item.index % args.specs.length];
-  if (!spec) throw new ValidationError("runLoop: no AgentRunSpec available for iteration");
-  slot.startedAt = args.now();
-  slot.agentRunName = spec.name ?? spec.profile.name ?? "agent";
-  await emitTrace(args.ctx.traceEmitter, {
-    kind: "loop.iteration.started",
-    runId: args.runId,
-    timestamp: args.now(),
-    payload: {
-      iterationIndex: args.item.index,
-      agentRunName: slot.agentRunName,
-      taskHash: hashJson(args.item.task),
-      groupId: args.roundIndex,
-      parentIndex: args.parentIndex
-    }
-  });
-  try {
-    const box = await createSandboxForSpec(args.ctx.sandboxClient, spec, args.signal);
-    const placement = describePlacementSafe(args.ctx.sandboxClient, box);
-    await emitTrace(args.ctx.traceEmitter, {
-      kind: "loop.iteration.dispatch",
-      runId: args.runId,
-      timestamp: args.now(),
-      payload: {
-        iterationIndex: args.item.index,
-        agentRunName: slot.agentRunName,
-        placement: placement.kind,
-        sandboxId: placement.sandboxId,
-        fleetId: placement.fleetId,
-        machineId: placement.machineId,
-        groupId: args.roundIndex,
-        parentIndex: args.parentIndex
-      }
-    });
-    const message = spec.taskToPrompt(args.item.task);
-    const events = [];
-    for await (const event of box.streamPrompt(message, { signal: args.signal })) {
-      events.push(event);
-      const llmCall = extractLlmCallEvent(event, slot.agentRunName);
-      if (llmCall) {
-        slot.costUsd += llmCall.costUsd ?? 0;
-        slot.tokenUsage.input += llmCall.tokensIn ?? 0;
-        slot.tokenUsage.output += llmCall.tokensOut ?? 0;
-        args.ctx.runHandle?.observe(llmCall);
-      }
-    }
-    slot.events = events;
-    slot.output = args.output.parse(events);
-    if (args.validator) {
-      slot.verdict = await args.validator.validate(slot.output, {
-        iteration: args.item.index,
-        signal: args.signal,
-        traceEmitter: args.ctx.traceEmitter
-      });
-    }
-  } catch (err) {
-    slot.error = err instanceof Error ? err : new Error(String(err));
-  } finally {
-    slot.endedAt = args.now();
-    await emitTrace(args.ctx.traceEmitter, {
-      kind: "loop.iteration.ended",
-      runId: args.runId,
-      timestamp: args.now(),
-      payload: {
-        iterationIndex: args.item.index,
-        agentRunName: slot.agentRunName,
-        outputHash: slot.output !== void 0 ? hashJson(slot.output) : void 0,
-        verdict: slot.verdict,
-        error: slot.error?.message,
-        costUsd: slot.costUsd,
-        durationMs: slot.endedAt - slot.startedAt,
-        tokenUsage: slot.tokenUsage.input || slot.tokenUsage.output ? { ...slot.tokenUsage } : void 0,
-        groupId: args.roundIndex,
-        parentIndex: args.parentIndex,
-        outputPreview: slot.output !== void 0 ? previewOutput(slot.output) : void 0
-      }
-    });
-  }
-}
-function branchPoint(iterations) {
-  if (iterations.length === 0) return void 0;
-  let best = iterations.length - 1;
-  let bestScore = -Infinity;
-  for (const iter of iterations) {
-    if (iter.verdict?.valid !== true) continue;
-    const score = iter.verdict.score ?? 0;
-    if (score > bestScore) {
-      bestScore = score;
-      best = iter.index;
-    }
-  }
-  return best;
-}
-function previewOutput(output) {
-  let s;
-  try {
-    s = typeof output === "string" ? output : JSON.stringify(output) ?? String(output);
-  } catch {
-    s = String(output);
-  }
-  return s.length > 280 ? `${s.slice(0, 280)}\u2026` : s;
-}
-function describePlacementSafe(client, box) {
-  if (typeof client.describePlacement === "function") {
-    try {
-      const result = client.describePlacement(box);
-      if (result && typeof result === "object" && (result.kind === "sibling" || result.kind === "fleet")) {
-        return {
-          kind: result.kind,
-          sandboxId: result.sandboxId ?? readSandboxId(box),
-          fleetId: result.fleetId,
-          machineId: result.machineId
-        };
-      }
-    } catch {
-    }
-  }
-  return { kind: "sibling", sandboxId: readSandboxId(box) };
-}
-function readSandboxId(box) {
-  const raw = box.id;
-  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
-}
-async function createSandboxForSpec(client, spec, signal) {
-  const overrides = spec.sandboxOverrides ?? {};
-  const overrideBackend = overrides.backend;
-  const opts = {
-    ...overrides,
-    backend: {
-      type: overrideBackend?.type ?? inferBackendType(spec.profile),
-      profile: spec.profile,
-      ...overrideBackend?.model ? { model: overrideBackend.model } : {},
-      ...overrideBackend?.server ? { server: overrideBackend.server } : {}
-    }
-  };
-  if (signal.aborted) throwAbort();
-  return client.create(opts);
-}
-function inferBackendType(profile) {
-  const explicit = profile.metadata?.backendType;
-  if (typeof explicit === "string") return explicit;
-  return "opencode";
-}
-function finalize(args) {
-  const winner = (args.options.selectWinner ?? defaultSelectWinner)(args.iterations);
-  const costUsd = args.iterations.reduce((sum, iter) => sum + (iter.costUsd || 0), 0);
-  const tokenUsage = args.iterations.reduce(
-    (acc, iter) => {
-      acc.input += iter.tokenUsage?.input ?? 0;
-      acc.output += iter.tokenUsage?.output ?? 0;
-      return acc;
-    },
-    { input: 0, output: 0 }
-  );
-  const result = {
-    decision: args.decision,
-    iterations: args.iterations,
-    winner,
-    durationMs: args.now() - args.startMs,
-    costUsd,
-    tokenUsage
-  };
-  void emitTrace(args.options.ctx.traceEmitter, {
-    kind: "loop.ended",
-    runId: args.runId,
-    timestamp: args.now(),
-    payload: {
-      winnerIterationIndex: winner?.iterationIndex,
-      totalCostUsd: costUsd,
-      durationMs: result.durationMs,
-      iterations: args.iterations.length
-    }
-  });
-  return result;
-}
-function defaultSelectWinner(iterations) {
-  const candidates = iterations.filter((iter) => iter.output !== void 0 && !iter.error);
-  if (candidates.length === 0) return void 0;
-  const valid = candidates.filter((iter) => iter.verdict?.valid === true);
-  const pool = valid.length > 0 ? valid : candidates;
-  const sorted = [...pool].sort(
-    (a, b) => (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.index - b.index
-  );
-  const top = sorted[0];
-  if (!top || top.output === void 0) return void 0;
-  return {
-    task: top.task,
-    output: top.output,
-    verdict: top.verdict,
-    iterationIndex: top.index,
-    agentRunName: top.agentRunName
-  };
-}
-function resolveAgentRuns(options) {
-  if (options.agentRun && options.agentRuns) {
-    throw new ValidationError("runLoop: pass exactly one of `agentRun` or `agentRuns`");
-  }
-  if (options.agentRun) return [options.agentRun];
-  if (options.agentRuns && options.agentRuns.length > 0) return options.agentRuns;
-  throw new ValidationError("runLoop: `agentRun` or non-empty `agentRuns` is required");
-}
-function isTerminalDecision(decision) {
-  return decision === "stop" || decision === "pick-winner" || decision === "fail" || decision === "done";
-}
-function serializeDecision(decision) {
-  if (typeof decision === "string") return decision;
-  if (decision === null || decision === void 0) return "null";
-  try {
-    return JSON.stringify(decision);
-  } catch {
-    return String(decision);
-  }
-}
-async function emitTrace(emitter, event) {
-  if (!emitter) return;
-  await emitter.emit(event);
-}
-function randomSuffix(len = 8) {
-  return Math.random().toString(36).slice(2, 2 + len);
-}
-function throwAbort() {
-  const err = new Error("aborted");
-  err.name = "AbortError";
-  throw err;
-}
-function hashJson(value) {
-  let str;
-  try {
-    str = JSON.stringify(value) ?? String(value);
-  } catch {
-    str = String(value);
-  }
-  let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return (h >>> 0).toString(16).padStart(8, "0");
-}
-
-// src/loops/loop-dispatch.ts
-function campaignTraceToLoopEmitter(trace) {
-  return {
-    emit(event) {
-      trace.span(event.kind, { runId: event.runId, timestamp: event.timestamp, ...event.payload }).end();
-    }
-  };
-}
-async function runLoopForCell(opts, scenario, profile, ctx) {
-  const loopOptions = opts.toLoopOptions(scenario, profile);
-  const result = await runLoop({
-    ...loopOptions,
-    ctx: {
-      sandboxClient: opts.sandboxClient,
-      signal: ctx.signal,
-      traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
-    }
-  });
-  reportLoopUsage(ctx.cost, result, opts.costSource ?? "loop");
-  const toArtifact = opts.toArtifact ?? ((r) => r.winner?.output);
-  return toArtifact(result);
-}
-function loopDispatch(opts) {
-  return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
-}
-function loopCampaignDispatch(opts) {
-  const profileSentinel = { id: "loop-campaign", model: "n/a@loop-campaign" };
-  const profiled = {
-    ...opts,
-    toLoopOptions: (scenario) => opts.toLoopOptions(scenario)
-  };
-  return (scenario, ctx) => runLoopForCell(profiled, scenario, profileSentinel, ctx);
-}
-
-export {
-  createDynamicDriver,
-  summarizeHistory,
-  createRefineDriver,
-  refineWinnerIndex,
-  createSandboxPlanner,
-  reportLoopUsage,
-  extractLlmCallEvent,
-  mapSandboxEvent,
-  runLoop,
-  createSandboxForSpec,
-  loopDispatch,
-  loopCampaignDispatch
-};
-//# sourceMappingURL=chunk-EKBSQYZE.js.map