agentbox-sdk 0.1.301 → 0.1.303

package/dist/{chunk-4MBB6QHD.js → chunk-GBM7LKZF.js}

@@ -2,7 +2,7 @@ import {
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKStream
-} from "./chunk-ZOWBRUQR.js";
+} from "./chunk-NWAXQ7UD.js";
 import {
   AgentBoxError,
   AsyncQueue,
@@ -19,7 +19,7 @@ import {
   sleep,
   time,
   waitFor
-} from "./chunk-INMA52FV.js";
+} from "./chunk-AVXJMCBC.js";
 import {
   shellQuote
 } from "./chunk-NSJM57Z4.js";
@@ -998,6 +998,28 @@ var HostSetupTarget = class {
       }
     );
   }
+  async probe(command, extraEnv) {
+    return time(
+      debugRuntime,
+      `host probe ${shortLabel(command)}`,
+      async () => {
+        const handle = spawnCommand({
+          command: process.env.SHELL || "sh",
+          args: ["-c", command],
+          cwd: this.cwd,
+          env: {
+            ...process.env,
+            ...this.baseEnv,
+            ...this.env,
+            ...extraEnv ?? {}
+          }
+        });
+        const exitCode = await handle.wait();
+        return exitCode === 0;
+      },
+      (ok) => ({ ok })
+    );
+  }
   async cleanup() {
     await rm(this.layout.rootDir, { recursive: true, force: true });
   }
@@ -1052,13 +1074,34 @@ var SandboxSetupTarget = class {
           }
         });
         if (result && result.exitCode !== 0) {
+          const output = result.combinedOutput?.trim();
+          const detail = output ? `
+${output}` : "";
           throw new Error(
-            `Sandbox setup command failed (${result.exitCode}): ${command}`
+            `Sandbox setup command failed (${result.exitCode}): ${command}${detail}`
           );
         }
       }
     );
   }
+  async probe(command, extraEnv) {
+    return time(
+      debugRuntime,
+      `sandbox probe ${shortLabel(command)}`,
+      async () => {
+        const result = await this.options.sandbox?.run(command, {
+          cwd: this.options.cwd,
+          env: {
+            ...this.options.env ?? {},
+            ...this.env,
+            ...extraEnv ?? {}
+          }
+        });
+        return Boolean(result && result.exitCode === 0);
+      },
+      (ok) => ({ ok })
+    );
+  }
   async cleanup() {
   }
 };
@@ -1092,6 +1135,7 @@ import path5 from "path";
 var MANIFEST_FILENAME = "setup-manifest.json";
 var TARGET_MANIFEST_FILENAME = "setup-target.json";
 var INSTALL_SCRIPT_FILENAME = "install.sh";
+var SETUP_ID_FILENAME = "setup.id";
 var MANIFEST_VERSION = 1;
 function hashArtifact(artifact) {
   const hasher = createHash("sha256");
@@ -1110,6 +1154,74 @@ function computeTargetArtifacts(artifacts) {
   }
   return result;
 }
+function computeSetupId(parts) {
+  const hasher = createHash("sha256");
+  hasher.update(`v${MANIFEST_VERSION}
+`);
+  for (const a of [...parts.artifacts ?? []].sort(
+    (x, y) => x.path.localeCompare(y.path)
+  )) {
+    hasher.update(`a:${a.path}:${hashArtifact(a)}
+`);
+  }
+  for (const cmd of parts.installCommands ?? []) {
+    hasher.update(`c:${hashCommand(cmd)}
+`);
+  }
+  if (parts.daemon) {
+    hasher.update(
+      `d:${parts.daemon.port}:${parts.daemon.healthPath}:${parts.daemon.expectedVersionMatch ?? ""}
+`
+    );
+  }
+  for (const extra of parts.extras ?? []) {
+    hasher.update(`x:${extra}
+`);
+  }
+  return hasher.digest("hex");
+}
+async function preflightSetup(target, setupId, daemon) {
+  return time(
+    debugSetup,
+    `preflightSetup ${target.provider}`,
+    async () => {
+      const setupIdFile = path5.posix.join(
+        target.layout.rootDir,
+        SETUP_ID_FILENAME
+      );
+      const checks = [
+        `[ -f ${shellQuote(setupIdFile)} ]`,
+        `[ "$(cat ${shellQuote(setupIdFile)} 2>/dev/null)" = ${shellQuote(setupId)} ]`
+      ];
+      if (daemon) {
+        const url = `http://127.0.0.1:${daemon.port}${daemon.healthPath}`;
+        if (daemon.expectedVersionMatch) {
+          checks.push(
+            `curl -fsS --max-time 2 ${shellQuote(url)} 2>/dev/null | grep -q ${shellQuote(daemon.expectedVersionMatch)}`
+          );
+        } else {
+          checks.push(
+            `curl -fsS --max-time 2 ${shellQuote(url)} >/dev/null 2>&1`
+          );
+        }
+      }
+      return target.probe(checks.join(" && "));
+    },
+    (ok) => ({ ok })
+  );
+}
+async function markSetupComplete(target, setupId) {
+  await time(
+    debugSetup,
+    `markSetupComplete ${target.provider}`,
+    () => target.runCommand(
+      [
+        `mkdir -p ${shellQuote(target.layout.rootDir)}`,
+        `printf '%s' ${shellQuote(setupId)} > ${shellQuote(path5.posix.join(target.layout.rootDir, SETUP_ID_FILENAME))}`
+      ].join(" && ")
+    )
+  );
+}
 function buildInstallScript(rootDir, installCommandsByKey) {
   const commandsB64 = Buffer.from(
     JSON.stringify(installCommandsByKey),
@@ -1445,7 +1557,10 @@ function extractCodexCostData(events) {
   let sawUsage = false;
   for (const event of events) {
     const params = asRecord(event.params);
-    const usageCandidate = asRecord(event.usage) ?? asRecord(params?.usage) ?? asRecord(params?.tokenUsage) ?? asRecord(asRecord(params?.turn)?.usage) ?? asRecord(asRecord(params?.turn)?.tokenUsage);
+    const tokenUsage = asRecord(params?.tokenUsage);
+    const turn = asRecord(params?.turn);
+    const turnTokenUsage = asRecord(turn?.tokenUsage);
+    const usageCandidate = asRecord(event.usage) ?? asRecord(params?.usage) ?? asRecord(tokenUsage?.last) ?? asRecord(tokenUsage?.total) ?? tokenUsage ?? asRecord(turn?.usage) ?? asRecord(turnTokenUsage?.last) ?? asRecord(turnTokenUsage?.total) ?? turnTokenUsage;
     if (usageCandidate) {
       sawUsage = true;
       mergeUsage(usage, usageCandidate);
@@ -1513,12 +1628,23 @@ function buildClaudeQueryOptions(params) {
     settings: params.settingsPath,
     extraArgs,
     includePartialMessages: true,
+    thinking: { type: "adaptive", display: "summarized" },
     ...run.model ? { model: run.model } : {},
     ...run.reasoning ? { effort: run.reasoning } : {},
     ...provider?.permissionMode ? { permissionMode: provider.permissionMode } : {},
     ...provider?.permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {},
     ...provider?.allowedTools?.length ? { allowedTools: provider.allowedTools } : {},
-    ...run.resumeSessionId ? { resume: run.resumeSessionId } : {}
+    ...run.resumeSessionId ? { resume: run.resumeSessionId } : {},
+    // Fork-at-message: claude-agent-sdk natively supports slicing a
+    // resumed transcript at a message UUID and writing the continuation
+    // under a new session id when `forkSession: true` is set. The
+    // captured message UUID comes from `SDKAssistantMessage.uuid`,
+    // surfaced on normalized `message.started` events.
+    ...run.forkSessionId ? {
+      resume: run.forkSessionId,
+      resumeSessionAt: run.forkAtMessageId,
+      forkSession: true
+    } : {}
   };
 }
 function toRawEvent(runId, payload, type) {
@@ -1921,6 +2047,11 @@ var ClaudeCodeAgentAdapter = class {
   /**
    * Sandbox-side preparation. Uploads `.claude/` artifacts and ensures
    * the daemon is running. `execute()` then dials the daemon directly.
+   *
+   * Warm-path short-circuit: a single no-upload `preflightSetup` probes
+   * the `setup.id` marker + daemon `/__version` on loopback. If both
+   * match what we'd produce, we skip the artifact upload AND the daemon
+   * boot entirely.
    */
   async setup(request) {
     await time(debugClaude, "claude-code setup()", async () => {
@@ -1954,6 +2085,20 @@ var ClaudeCodeAgentAdapter = class {
         { path: settingsPath, content: JSON.stringify(hookSettings, null, 2) },
         { path: mcpConfigPath, content: mcpConfigJson }
       ];
+      const daemonInfo = {
+        port: DAEMON_PORT,
+        healthPath: "/__version",
+        expectedVersionMatch: DAEMON_PROTOCOL_VERSION
+      };
+      const setupId = computeSetupId({
+        artifacts,
+        installCommands,
+        daemon: daemonInfo
+      });
+      if (await preflightSetup(target, setupId, daemonInfo)) {
+        debugClaude("claude-code setup() preflight hit \u2014 skipping");
+        return;
+      }
       const env = { ...options.env ?? {}, ...target.env };
       await Promise.all([
         time(
@@ -1963,6 +2108,7 @@ var ClaudeCodeAgentAdapter = class {
         ),
         ensureClaudeCodeDaemon(options, env)
       ]);
+      await markSetupComplete(target, setupId);
     });
   }
   async execute(request, sink) {
@@ -2092,6 +2238,8 @@ var ClaudeCodeAgentAdapter = class {
     let pendingMessages = 1;
     let firstStreamEventLogged = false;
     let firstTextDeltaLogged = false;
+    let lastTerminalReason;
+    let lastIsError = false;
     const rawPayloads = [];
     try {
       for await (const item of parseNdjsonStream(response.body)) {
@@ -2179,6 +2327,8 @@ var ClaudeCodeAgentAdapter = class {
         }
         if (message.type === "result") {
           const result = message;
+          lastTerminalReason = result.terminal_reason;
+          lastIsError = result.is_error;
           const resultText = result.subtype === "success" ? result.result : accumulatedText;
           if (resultText && resultText !== accumulatedText) {
             accumulatedText = resultText;
@@ -2189,22 +2339,43 @@ var ClaudeCodeAgentAdapter = class {
         }
       }
       const finalText = accumulatedText;
-      debugClaude(
-        "\u2605 run.completed (%dms since execute start) chars=%d",
-        Date.now() - executeStartedAt,
-        finalText.length
-      );
-      sink.emitEvent(
-        createNormalizedEvent(
-          "run.completed",
-          { provider: request.provider, runId: request.runId },
-          { text: finalText }
-        )
-      );
-      sink.complete({
-        text: finalText,
-        costData: extractClaudeCostData(rawPayloads)
-      });
+      const isCancelled = lastTerminalReason === "aborted_streaming" || lastTerminalReason === "aborted_tools";
+      const isError = !isCancelled && lastIsError;
+      if (isCancelled) {
+        debugClaude(
+          "\u2605 run.cancelled (%dms since execute start) reason=%s",
+          Date.now() - executeStartedAt,
+          lastTerminalReason
+        );
+        sink.cancel({
+          text: finalText,
+          costData: extractClaudeCostData(rawPayloads)
+        });
+      } else if (isError) {
+        debugClaude(
+          "\u2605 run.error (%dms since execute start) reason=%s",
+          Date.now() - executeStartedAt,
+          lastTerminalReason
+        );
+        sink.fail(new Error(finalText || `claude-code run failed (terminal_reason: ${lastTerminalReason})`));
+      } else {
+        debugClaude(
+          "\u2605 run.completed (%dms since execute start) chars=%d",
+          Date.now() - executeStartedAt,
+          finalText.length
+        );
+        sink.emitEvent(
+          createNormalizedEvent(
+            "run.completed",
+            { provider: request.provider, runId: request.runId },
+            { text: finalText }
+          )
+        );
+        sink.complete({
+          text: finalText,
+          costData: extractClaudeCostData(rawPayloads)
+        });
+      }
     } finally {
       fetchAbort.abort();
     }
@@ -2487,7 +2658,8 @@ function buildThreadParams(cwd, options, request) {
     // Persist the rollout on disk so follow-up runs can call `thread/resume`.
     // `ephemeral: true` threads have no rollout file and resume fails with
     // "no rollout found for thread id ...".
-    experimentalRawEvents: true
+    experimentalRawEvents: true,
+    developerInstructions: request.run.systemPrompt ?? null
   };
 }
 function buildResumeParams(cwd, options, request) {
@@ -2496,7 +2668,18 @@ function buildResumeParams(cwd, options, request) {
     cwd,
     model: request.run.model ?? null,
     approvalPolicy: isInteractiveApproval(options) ? "untrusted" : "never",
-    sandbox: buildCodexSandboxMode(options)
+    sandbox: buildCodexSandboxMode(options),
+    developerInstructions: request.run.systemPrompt ?? null
+  };
+}
+function buildForkParams(cwd, options, request) {
+  return {
+    threadId: request.run.forkSessionId,
+    cwd,
+    model: request.run.model ?? null,
+    approvalPolicy: isInteractiveApproval(options) ? "untrusted" : "never",
+    sandbox: buildCodexSandboxMode(options),
+    developerInstructions: request.run.systemPrompt ?? null
   };
 }
 function buildTurnSandboxPolicy(options) {
@@ -2514,27 +2697,14 @@ function buildTurnSandboxPolicy(options) {
     networkAccess: "enabled"
   };
 }
-function buildTurnCollaborationMode(request) {
-  const systemPrompt = request.run.systemPrompt;
-  if (!systemPrompt) {
-    return void 0;
-  }
-  return {
-    mode: "custom",
-    settings: {
-      developer_instructions: systemPrompt
-    }
-  };
-}
 function buildCodexTurnStartParams(params) {
-  const { threadId, inputItems, request, turnStartOverrides } = params;
+  const { threadId, inputItems, request } = params;
   const sandboxPolicy = buildTurnSandboxPolicy(request.options);
   return {
     threadId,
     input: inputItems,
     approvalPolicy: isInteractiveApproval(request.options) ? "untrusted" : "never",
     ...sandboxPolicy ? { sandboxPolicy } : {},
-    ...turnStartOverrides ?? {},
     model: request.run.model ?? null,
     effort: request.run.reasoning ?? null,
     outputSchema: null
@@ -2781,7 +2951,12 @@ async function ensureCodexLoginViaConfig(request, target) {
     [
       'if [ -z "${OPENAI_API_KEY:-}" ]; then exit 0; fi',
       'mkdir -p "${CODEX_HOME:-$HOME/.codex}"',
-      "printenv OPENAI_API_KEY | env -u XDG_CONFIG_HOME codex login --with-api-key"
+      // Merge stderr into stdout so providers that don't surface stderr
+      // (e.g. Daytona's `executeCommand`, which collapses to a single
+      // `result` field) still propagate the underlying error message
+      // back to the caller — otherwise a failed login leaves us with a
+      // bare "exit 1" and no diagnostic.
+      "printenv OPENAI_API_KEY | env -u XDG_CONFIG_HOME codex login --with-api-key 2>&1"
     ].join("; "),
     Object.keys(extraEnv).length > 0 ? extraEnv : void 0
   );
@@ -2887,12 +3062,26 @@ async function setupCodex(request) {
       ...sharedTarget.env,
       ...options.provider?.env ?? {}
     });
+    const { artifacts: serverArtifacts } = buildArtifactsFor(sharedTarget);
+    const { artifacts: skillArtifacts2, installCommands: installCommands2 } = await prepareSkillArtifacts(provider, options.skills, target2.layout);
+    const daemonInfo = {
+      port: REMOTE_CODEX_APP_SERVER_PORT,
+      healthPath: "/readyz"
+    };
+    const setupId2 = computeSetupId({
+      artifacts: [...serverArtifacts, ...skillArtifacts2],
+      installCommands: installCommands2,
+      daemon: daemonInfo
+    });
+    if (await preflightSetup(sharedTarget, setupId2, daemonInfo)) {
+      debugCodex("codex remote setup() preflight hit \u2014 skipping");
+      return;
+    }
     await time(
       debugCodex,
       "ensureCodexLogin",
       () => ensureCodexLoginViaConfig(request, sharedTarget)
     );
-    const { artifacts: serverArtifacts } = buildArtifactsFor(sharedTarget);
     await applyDifferentialSetup(sharedTarget, serverArtifacts, []);
     const binary = options.provider?.binary ?? "codex";
     const pidFilePath = path9.posix.join(
@@ -2940,28 +3129,34 @@ async function setupCodex(request) {
       );
     }
     try {
-      const { artifacts: skillArtifacts2, installCommands: installCommands2 } = await prepareSkillArtifacts(provider, options.skills, target2.layout);
       await applyDifferentialSetup(target2, skillArtifacts2, installCommands2);
     } catch (error) {
       await target2.cleanup().catch(() => void 0);
       throw error;
     }
+    await markSetupComplete(sharedTarget, setupId2);
     return;
   }
   const target = await createSetupTarget(provider, "shared-setup", options);
+  const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(provider, options.skills, target.layout);
+  const { artifacts: configArtifacts } = buildArtifactsFor(target);
+  const allArtifacts = [...skillArtifacts, ...configArtifacts];
+  const setupId = computeSetupId({
+    artifacts: allArtifacts,
+    installCommands
+  });
+  if (await preflightSetup(target, setupId)) {
+    debugCodex("codex local setup() preflight hit \u2014 skipping");
+    return;
+  }
   try {
     await ensureCodexLoginViaConfig(request, target);
   } catch (error) {
     await target.cleanup().catch(() => void 0);
     throw error;
   }
-  const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(provider, options.skills, target.layout);
-  const { artifacts: configArtifacts } = buildArtifactsFor(target);
-  await applyDifferentialSetup(
-    target,
-    [...skillArtifacts, ...configArtifacts],
-    installCommands
-  );
+  await applyDifferentialSetup(target, allArtifacts, installCommands);
+  await markSetupComplete(target, setupId);
 }
 async function createRuntime(request, inputParts) {
   const options = request.options;
@@ -2998,8 +3193,7 @@ async function createRuntime(request, inputParts) {
         port: REMOTE_CODEX_APP_SERVER_PORT,
         codexDir
       },
-      inputItems,
-      turnStartOverrides: buildTurnCollaborationMode(request)
+      inputItems
     };
   }
   const codexArgs = buildCodexCommandArgs(
@@ -3037,8 +3231,7 @@ async function createRuntime(request, inputParts) {
         await handle.kill();
       },
       raw: { handle, codexDir },
-      inputItems,
-      turnStartOverrides: buildTurnCollaborationMode(request)
+      inputItems
     };
   }
   const processHandle = spawnCommand({
@@ -3060,8 +3253,7 @@ async function createRuntime(request, inputParts) {
       await processHandle.kill();
     },
     raw: { processHandle, codexDir },
-    inputItems,
-    turnStartOverrides: buildTurnCollaborationMode(request)
+    inputItems
   };
 }
 async function buildCodexInputItems(options, inputParts) {
@@ -3118,7 +3310,9 @@ var CodexAgentAdapter = class {
     let rootThreadId;
     let turnId;
     let pendingTurns = 1;
+    let abortInvoked = false;
     sink.setAbort(async () => {
+      abortInvoked = true;
       const threadIdAtAbort = rootThreadId;
       const turnIdAtAbort = turnId;
       if (threadIdAtAbort && turnIdAtAbort) {
@@ -3164,8 +3358,8 @@ var CodexAgentAdapter = class {
     };
     sink.onMessage(sendTurn);
     const rawPayloads = [];
+    let streamedText = "";
     const completion = new Promise((resolve, reject) => {
-      let finalText = "";
       void (async () => {
         let firstClientMessageLogged = false;
         for await (const message of client.messages()) {
@@ -3202,7 +3396,7 @@ var CodexAgentAdapter = class {
           for (const event of toNormalizedCodexEvents(request.runId, message)) {
             sink.emitEvent(event);
             if (event.type === "text.delta") {
-              finalText += event.delta;
+              streamedText += event.delta;
             }
           }
           if (message.method === "thread/started" && !rootThreadId) {
@@ -3214,7 +3408,14 @@ var CodexAgentAdapter = class {
           if (message.method === "turn/completed" && (!message.params?.threadId || message.params.threadId === rootThreadId)) {
             pendingTurns--;
             if (pendingTurns <= 0) {
-              resolve({ text: finalText, turnId, threadId: rootThreadId });
+              const turn = message.params?.turn;
+              const interrupted = turn?.status === "interrupted";
+              resolve({
+                text: streamedText,
+                turnId,
+                threadId: rootThreadId,
+                interrupted
+              });
               return;
             }
           }
@@ -3241,13 +3442,27 @@ var CodexAgentAdapter = class {
         await client.notify("initialized", {});
       }
       const cwd = request.options.cwd ?? process.cwd();
-      const threadResponse = request.run.resumeSessionId ? await client.request(
-        "thread/resume",
-        buildResumeParams(cwd, request.options, request)
-      ) : await client.request(
-        "thread/start",
-        buildThreadParams(cwd, request.options, request)
-      );
+      let threadResponse;
+      let threadResultEventName;
+      if (request.run.forkSessionId) {
+        threadResponse = await client.request(
+          "thread/fork",
+          buildForkParams(cwd, request.options, request)
+        );
+        threadResultEventName = "thread/fork:result";
+      } else if (request.run.resumeSessionId) {
+        threadResponse = await client.request(
+          "thread/resume",
+          buildResumeParams(cwd, request.options, request)
+        );
+        threadResultEventName = "thread/resume:result";
+      } else {
+        threadResponse = await client.request(
+          "thread/start",
+          buildThreadParams(cwd, request.options, request)
+        );
+        threadResultEventName = "thread/start:result";
+      }
       rootThreadId = threadResponse.thread.id;
       if ("bindThread" in client && typeof client.bindThread === "function") {
         client.bindThread(threadResponse.thread.id);
@@ -3255,28 +3470,79 @@ var CodexAgentAdapter = class {
       sink.setSessionId(threadResponse.thread.id);
       rawPayloads.push(threadResponse);
       sink.emitRaw(
-        toRawEvent2(
-          request.runId,
-          threadResponse,
-          request.run.resumeSessionId ? "thread/resume:result" : "thread/start:result"
-        )
+        toRawEvent2(request.runId, threadResponse, threadResultEventName)
       );
+      if (request.run.forkSessionId) {
+        const targetTurnId = request.run.forkAtMessageId;
+        const turns = threadResponse.thread.turns ?? [];
+        const targetIndex = turns.findIndex((turn) => turn.id === targetTurnId);
+        if (targetIndex < 0) {
+          throw new Error(
+            `Codex fork: turn id ${String(targetTurnId)} not found in source thread ${request.run.forkSessionId}.`
+          );
+        }
+        const numTurns = turns.length - 1 - targetIndex;
+        if (numTurns > 0) {
+          const rollbackResponse = await client.request(
+            "thread/rollback",
+            { threadId: rootThreadId, numTurns }
+          );
+          rawPayloads.push(rollbackResponse);
+          sink.emitRaw(
+            toRawEvent2(
+              request.runId,
+              rollbackResponse,
+              "thread/rollback:result"
+            )
+          );
+        }
+      }
       await client.request(
         "turn/start",
         buildCodexTurnStartParams({
           threadId: threadResponse.thread.id,
           inputItems: runtime.inputItems,
-          request,
-          turnStartOverrides: runtime.turnStartOverrides
+          request
         })
       );
-      const { text } = await completion;
-      debugCodex(
-        "\u2605 run.completed (%dms since execute start) chars=%d",
-        Date.now() - executeStartedAt,
-        text?.length ?? 0
-      );
-      sink.complete({ text, costData: extractCodexCostData(rawPayloads) });
+      let completionResult;
+      let completionError;
+      try {
+        completionResult = await completion;
+      } catch (err) {
+        completionError = err;
+      }
+      if (completionError !== void 0) {
+        if (abortInvoked) {
+          debugCodex(
+            "\u2605 run.cancelled (%dms since execute start)",
+            Date.now() - executeStartedAt
+          );
+          sink.cancel({
+            text: streamedText || void 0,
+            costData: extractCodexCostData(rawPayloads)
+          });
+        } else {
+          sink.fail(completionError);
+        }
+      } else {
+        const { text, interrupted } = completionResult;
+        if (abortInvoked || interrupted) {
+          debugCodex(
+            "\u2605 run.cancelled (%dms since execute start) interrupted=%s",
+            Date.now() - executeStartedAt,
+            interrupted
+          );
+          sink.cancel({ text, costData: extractCodexCostData(rawPayloads) });
+        } else {
+          debugCodex(
+            "\u2605 run.completed (%dms since execute start) chars=%d",
+            Date.now() - executeStartedAt,
+            text?.length ?? 0
+          );
+          sink.complete({ text, costData: extractCodexCostData(rawPayloads) });
+        }
+      }
     } finally {
       await runtime.cleanup().catch(() => void 0);
     }
@@ -3500,12 +3766,11 @@ var OPEN_CODE_REASONING_LEVELS = ["low", "medium", "high", "xhigh"];
 function openCodeAgentSlug(reasoning) {
   return reasoning ? `agentbox-${reasoning}` : "agentbox";
 }
-function buildOpenCodeConfig(options, systemPrompt, interactiveApproval) {
+function buildOpenCodeConfig(options, interactiveApproval) {
   const mcpConfig = buildOpenCodeMcpConfig(options.mcps);
   const commandsConfig = buildOpenCodeCommandsConfig(options.commands);
   const baseAgent = {
     mode: "primary",
-    prompt: systemPrompt,
     permission: buildOpenCodePermissionConfig(interactiveApproval),
     tools: {
       write: true,
@@ -3521,10 +3786,15 @@ function buildOpenCodeConfig(options, systemPrompt, interactiveApproval) {
       { ...baseAgent, reasoningEffort: level }
     ])
   );
+  const googleBaseUrl = options.env?.GOOGLE_BASE_URL;
   return {
     $schema: "https://opencode.ai/config.json",
     ...mcpConfig ? { mcp: mcpConfig } : {},
     ...commandsConfig ? { command: commandsConfig } : {},
+    provider: {
+      openrouter: { options: { baseURL: "https://openrouter.ai/api/v1" } },
+      ...googleBaseUrl ? { google: { options: { baseURL: googleBaseUrl } } } : {}
+    },
     agent: {
       agentbox: baseAgent,
       ...reasoningVariants,
@@ -3537,19 +3807,6 @@ async function ensureSandboxOpenCodeServer(request) {
     const sandbox = request.options.sandbox;
     const options = request.options;
     const port = SANDBOX_OPENCODE_PORT;
-    const healthCheck = await time(
-      debugOpencode,
-      "health probe (warm path)",
-      () => sandbox.run(
-        `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
-        { cwd: options.cwd, timeoutMs: 5e3 }
-      )
-    );
-    if (healthCheck.exitCode === 0) {
-      debugOpencode("opencode server already running \u2014 reusing");
-      return;
-    }
-    debugOpencode("opencode server not running \u2014 cold-spawning");
     const plugins = assertHooksSupported(request.provider, options);
     assertCommandsSupported(request.provider, options.commands);
     const interactiveApproval = isInteractiveApproval(options);
@@ -3570,26 +3827,32 @@ async function ensureSandboxOpenCodeServer(request) {
     const configPath = path10.join(target.layout.opencodeDir, "agentbox.json");
     const openCodeConfig = buildOpenCodeConfig(
       options,
-      request.config.systemPrompt ?? "",
       interactiveApproval
     );
+    const allArtifacts = [
+      ...skillArtifacts,
+      ...pluginArtifacts,
+      {
+        path: configPath,
+        content: JSON.stringify(openCodeConfig, null, 2)
+      }
+    ];
+    const daemonInfo = { port, healthPath: "/global/health" };
+    const setupId = computeSetupId({
+      artifacts: allArtifacts,
+      installCommands,
+      daemon: daemonInfo
+    });
+    if (await preflightSetup(target, setupId, daemonInfo)) {
+      debugOpencode("opencode setup() preflight hit \u2014 skipping");
+      return;
+    }
     const commonEnv = {
       OPENCODE_CONFIG: configPath,
       OPENCODE_CONFIG_DIR: target.layout.opencodeDir,
       OPENCODE_DISABLE_DEFAULT_PLUGINS: "true"
     };
-    await applyDifferentialSetup(
-      target,
-      [
-        ...skillArtifacts,
-        ...pluginArtifacts,
-        {
-          path: configPath,
-          content: JSON.stringify(openCodeConfig, null, 2)
-        }
-      ],
-      installCommands
-    );
+    await applyDifferentialSetup(target, allArtifacts, installCommands);
     const binary = options.provider?.binary ?? "opencode";
     const pidFilePath = path10.posix.join(
       target.layout.rootDir,
@@ -3652,6 +3915,7 @@ async function ensureSandboxOpenCodeServer(request) {
         `OpenCode server did not become ready within ${SANDBOX_OPENCODE_READY_TIMEOUT_MS}ms.`
       );
     });
+    await markSetupComplete(target, setupId);
   });
 }
 async function ensureLocalOpenCodeServer(request) {
@@ -3684,28 +3948,28 @@ async function ensureLocalOpenCodeServer(request) {
     target.layout.opencodeDir
   );
   const configPath = path10.join(target.layout.opencodeDir, "agentbox.json");
-  const openCodeConfig = buildOpenCodeConfig(
-    options,
-    request.config.systemPrompt ?? "",
-    interactiveApproval
-  );
+  const openCodeConfig = buildOpenCodeConfig(options, interactiveApproval);
   const commonEnv = {
     OPENCODE_CONFIG: configPath,
     OPENCODE_CONFIG_DIR: target.layout.opencodeDir,
     OPENCODE_DISABLE_DEFAULT_PLUGINS: "true"
   };
-  await applyDifferentialSetup(
-    target,
-    [
-      ...skillArtifacts,
-      ...pluginArtifacts,
-      {
-        path: configPath,
-        content: JSON.stringify(openCodeConfig, null, 2)
-      }
-    ],
+  const allArtifacts = [
+    ...skillArtifacts,
+    ...pluginArtifacts,
+    {
+      path: configPath,
+      content: JSON.stringify(openCodeConfig, null, 2)
+    }
+  ];
+  const setupId = computeSetupId({
+    artifacts: allArtifacts,
     installCommands
-  );
+  });
+  const preflightHit = await preflightSetup(target, setupId);
+  if (!preflightHit) {
+    await applyDifferentialSetup(target, allArtifacts, installCommands);
+  }
   spawnCommand({
     command: options.provider?.binary ?? "opencode",
     args: [
@@ -3727,6 +3991,7 @@ async function ensureLocalOpenCodeServer(request) {
     `http://127.0.0.1:${LOCAL_OPENCODE_PORT}/global/health`,
     { timeoutMs: LOCAL_OPENCODE_READY_TIMEOUT_MS }
   );
+  await markSetupComplete(target, setupId);
 }
 async function setupOpenCode(request) {
   if (request.options.sandbox) {
@@ -3820,7 +4085,11 @@ var OpenCodeAgentAdapter = class {
     let sseTask;
     const dispatchAbort = new AbortController();
     let capturedSessionId;
+    let sessionErrorFromSse;
+    let sessionAbortedFromSse = false;
+    let userAbortRequested = false;
     sink.setAbort(async () => {
+      userAbortRequested = true;
       const sessionIdAtAbort = capturedSessionId;
       if (sessionIdAtAbort) {
         try {
@@ -3849,7 +4118,23 @@ var OpenCodeAgentAdapter = class {
     });
     try {
       const interactiveApproval = isInteractiveApproval(request.options);
-      const createdSession = request.run.resumeSessionId ? null : await fetchJson(
+      let forkedSession = null;
+      if (request.run.forkSessionId) {
+        forkedSession = await fetchJson(
+          `${runtime.baseUrl}/session/${encodeURIComponent(request.run.forkSessionId)}/fork`,
+          {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              ...runtime.previewHeaders
+            },
+            body: JSON.stringify({
+              messageID: request.run.forkAtMessageId
+            })
+          }
+        );
+      }
+      const createdSession = request.run.resumeSessionId || forkedSession ? null : await fetchJson(
         `${runtime.baseUrl}/session`,
         {
           method: "POST",
@@ -3862,7 +4147,7 @@ var OpenCodeAgentAdapter = class {
           })
         }
       );
-      const sessionId = request.run.resumeSessionId ?? createdSession?.id ?? createdSession?.sessionId;
+      const sessionId = request.run.resumeSessionId ?? forkedSession?.id ?? forkedSession?.sessionId ?? createdSession?.id ?? createdSession?.sessionId;
       if (!sessionId) {
         throw new Error("OpenCode did not return a session id.");
       }
@@ -3952,6 +4237,15 @@ var OpenCodeAgentAdapter = class {
               const properties = payloadRecord.properties;
               const eventSessionId = typeof properties?.sessionID === "string" ? properties.sessionID : void 0;
               if (!eventSessionId || eventSessionId === sessionId) {
+                if (payloadRecord.type === "session.error") {
+                  const errData = properties?.error;
+                  if (errData?.name === "MessageAbortedError") {
+                    sessionAbortedFromSse = true;
+                  } else {
+                    const errMsg = typeof errData?.data?.message === "string" ? errData.data.message : typeof errData?.message === "string" ? errData.message : "OpenCode session error";
+                    sessionErrorFromSse = new Error(errMsg);
+                  }
+                }
                 debugOpencode(
                   "\u2605 %s for session=%s \u2014 aborting in-flight dispatch",
                   payloadRecord.type,
@@ -4040,6 +4334,11 @@ var OpenCodeAgentAdapter = class {
               },
               body: JSON.stringify({
                 ...request.run.model ? { model: toOpenCodeModel(request.run.model) } : {},
+                // Per-message system prompt — keeps systemPrompt out of
+                // the on-disk agent config so changing it doesn't
+                // invalidate setupId. Sent on every dispatch (the field
+                // is per-message, not session-sticky).
+                ...request.run.systemPrompt ? { system: request.run.systemPrompt } : {},
                 agent: agentSlug,
                 parts
               })
@@ -4121,30 +4420,48 @@ var OpenCodeAgentAdapter = class {
       pendingMessages++;
       void dispatchMessage(mapToOpenCodeParts(inputParts));
       await allDone;
-      if (dispatchError && !dispatchAbort.signal.aborted) {
-        throw dispatchError;
+      if (userAbortRequested || sessionAbortedFromSse) {
+        debugOpencode(
+          "\u2605 run.cancelled (%dms since execute start)",
+          Date.now() - executeStartedAt
+        );
+        sseAbort.abort();
+        await sseTask;
+        sink.cancel({
+          text: streamedTextFromSse || void 0,
+          costData: extractOpenCodeCostData(rawPayloads)
+        });
+      } else if (sessionErrorFromSse) {
+        sseAbort.abort();
+        await sseTask;
+        sink.fail(sessionErrorFromSse);
+      } else if (dispatchError && !(dispatchAbort.signal.aborted && dispatchError?.name === "AbortError")) {
+        sseAbort.abort();
+        await sseTask;
+        sink.fail(dispatchError);
+      } else {
+        debugOpencode(
+          "\u2605 run.completed (%dms since execute start) chars=%d",
+          Date.now() - executeStartedAt,
+          finalText.length
+        );
+        sink.emitEvent(
+          createNormalizedEvent(
+            "run.completed",
+            {
+              provider: request.provider,
+              runId: request.runId
+            },
+            { text: finalText }
+          )
+        );
+        sseAbort.abort();
+        await sseTask;
+        sink.complete({
+          text: finalText,
+          costData: extractOpenCodeCostData(rawPayloads)
+        });
       }
-      debugOpencode(
-        "\u2605 run.completed (%dms since execute start) chars=%d",
-        Date.now() - executeStartedAt,
-        finalText.length
-      );
-      sink.emitEvent(
-        createNormalizedEvent(
-          "run.completed",
-          {
-            provider: request.provider,
-            runId: request.runId
-          },
-          { text: finalText }
-        )
-      );
-      sseAbort.abort();
-      await sseTask;
-      sink.complete({
-        text: finalText,
-        costData: extractOpenCodeCostData(rawPayloads)
-      });
     } finally {
       sseAbort.abort();
       if (sseTask) {
@@ -4308,17 +4625,14 @@ var AgentRunController = class {
   resolveSessionIdReady;
   rejectSessionIdReady;
   resolveFinished;
-  rejectFinished;
   constructor(provider, id) {
     this.provider = provider;
     this.id = id;
     let resolveFinished;
-    let rejectFinished;
     let resolveSessionIdReady;
     let rejectSessionIdReady;
-    this.finished = new Promise((resolve, reject) => {
+    this.finished = new Promise((resolve) => {
       resolveFinished = resolve;
-      rejectFinished = reject;
     });
     this.sessionIdReady = new Promise((resolve, reject) => {
       resolveSessionIdReady = resolve;
@@ -4326,7 +4640,6 @@ var AgentRunController = class {
     });
     void this.sessionIdReady.catch(() => void 0);
     this.resolveFinished = resolveFinished;
-    this.rejectFinished = rejectFinished;
     this.resolveSessionIdReady = resolveSessionIdReady;
     this.rejectSessionIdReady = rejectSessionIdReady;
   }
@@ -4462,11 +4775,19 @@ var AgentRunController = class {
     this.eventQueue.finish();
     this.rawQueue.finish();
     if (!this.sessionId) {
-      const error = new Error(
-        "Agent run completed before a provider session id was set."
-      );
-      this.rejectSessionIdReady(error);
-      this.rejectFinished(error);
+      const errorMsg = "Agent run completed before a provider session id was set.";
+      this.rejectSessionIdReady(new Error(errorMsg));
+      this.resolveFinished({
+        id: this.id,
+        provider: this.provider,
+        sessionId: "",
+        text: this.text,
+        rawEvents: [...this.rawEventsList],
+        events: [...this.events],
+        costData: this.costData,
+        isCancelled: false,
+        error: errorMsg
+      });
       return;
     }
     this.resolveFinished({
@@ -4476,7 +4797,44 @@ var AgentRunController = class {
       text: this.text,
       rawEvents: [...this.rawEventsList],
       events: [...this.events],
-      costData: this.costData
+      costData: this.costData,
+      isCancelled: false
+    });
+  }
+  cancel(result) {
+    if (this.settled) {
+      return;
+    }
+    this.settled = true;
+    this.clearPendingPermissions(
+      new Error(
+        "Agent run was cancelled before pending permission requests resolved."
+      )
+    );
+    if (result?.text) {
+      this.text = result.text;
+    }
+    if (result && "costData" in result) {
+      this.costData = result.costData ?? null;
+    }
+    this.emitEvent(
+      createNormalizedEvent(
+        "run.cancelled",
+        { provider: this.provider, runId: this.id },
+        { text: this.text || void 0 }
+      )
+    );
+    this.eventQueue.finish();
+    this.rawQueue.finish();
+    this.resolveFinished({
+      id: this.id,
+      provider: this.provider,
+      sessionId: this.sessionId ?? "",
+      text: this.text,
+      rawEvents: [...this.rawEventsList],
+      events: [...this.events],
+      costData: this.costData,
+      isCancelled: true
     });
   }
   fail(error) {
@@ -4503,7 +4861,17 @@ var AgentRunController = class {
     if (!this.sessionId) {
       this.rejectSessionIdReady(normalizedError);
     }
-    this.rejectFinished(normalizedError);
+    this.resolveFinished({
+      id: this.id,
+      provider: this.provider,
+      sessionId: this.sessionId ?? "",
+      text: this.text,
+      rawEvents: [...this.rawEventsList],
+      events: [...this.events],
+      costData: this.costData,
+      isCancelled: false,
+      error: normalizedError.message
+    });
   }
   async abort() {
     this.abortRequested = true;
@@ -4558,7 +4926,7 @@ var Agent = class {
    * second `setup()` against the same sandbox does ~one round-trip of
    * work.
    */
-  async setup(config = {}) {
+  async setup() {
     if (this.setupPromise) {
       await this.setupPromise;
       return;
@@ -4568,8 +4936,7 @@ var Agent = class {
     this.setupPromise = (async () => {
       await this.adapter.setup({
         provider: this.provider,
-        options: this.options,
-        config
+        options: this.options
       });
       debugAgent(
         "setup() returned provider=%s after %dms",
@@ -4585,6 +4952,17 @@ var Agent = class {
     }
   }
   stream(runConfig) {
+    if (runConfig.resumeSessionId && runConfig.forkSessionId) {
+      throw new Error(
+        "AgentRunConfig.resumeSessionId and forkSessionId are mutually exclusive."
+      );
+    }
+    if (runConfig.forkSessionId && !runConfig.forkAtMessageId) {
+      throw new Error("AgentRunConfig.forkSessionId requires forkAtMessageId.");
+    }
+    if (runConfig.forkAtMessageId && !runConfig.forkSessionId) {
+      throw new Error("AgentRunConfig.forkAtMessageId requires forkSessionId.");
+    }
     const runId = runConfig.runId ?? randomUUID2();
     const streamCalledAt = Date.now();
     debugAgent("stream() provider=%s runId=%s", this.provider, runId);