agentbox-sdk 0.1.3 → 0.1.302

package/dist/agents/index.d.ts

@@ -1,5 +1,5 @@
-import { o as AgentProviderName, h as AgentOptions, v as AgentSetupConfig, t as AgentRunConfig, s as AgentRun, r as AgentResult, a3 as RawAgentEvent, b as AgentAttachRequest, z as AttachedRun } from '../types-B3N-Qo2q.js';
-export { a as AgentApprovalMode, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, u as AgentRunSink, w as AgentSetupRequest, x as AgentSkillConfig, y as AgentSubAgentConfig, C as ClaudeCodeAgentOptions, B as ClaudeCodeHookConfig, D as ClaudeCodeHookEvent, E as ClaudeCodeHookHandler, F as ClaudeCodeHookMatcherGroup, G as ClaudeCodeHooksConfig, H as ClaudeCodeProviderOptions, I as CodexAgentOptions, J as CodexCommandHook, K as CodexHookEvent, L as CodexHookMatcherGroup, M as CodexHooksConfig, N as CodexProviderOptions, O as DataContent, P as EmbeddedSkillConfig, Q as FilePart, R as ImagePart, Y as OpenCodeAgentOptions, Z as OpenCodePluginConfig, _ as OpenCodePluginEvent, $ as OpenCodePluginHookConfig, a0 as OpenCodeProviderOptions, a5 as RepoSkillConfig, aa as TextPart, ae as UserContent, af as UserContentPart } from '../types-B3N-Qo2q.js';
+import { o as AgentProviderName, h as AgentOptions, v as AgentSetupConfig, t as AgentRunConfig, s as AgentRun, r as AgentResult, a3 as RawAgentEvent, b as AgentAttachRequest, z as AttachedRun } from '../types-Dj_HCr6Q.js';
+export { a as AgentApprovalMode, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, u as AgentRunSink, w as AgentSetupRequest, x as AgentSkillConfig, y as AgentSubAgentConfig, C as ClaudeCodeAgentOptions, B as ClaudeCodeHookConfig, D as ClaudeCodeHookEvent, E as ClaudeCodeHookHandler, F as ClaudeCodeHookMatcherGroup, G as ClaudeCodeHooksConfig, H as ClaudeCodeProviderOptions, I as CodexAgentOptions, J as CodexCommandHook, K as CodexHookEvent, L as CodexHookMatcherGroup, M as CodexHooksConfig, N as CodexProviderOptions, O as DataContent, P as EmbeddedSkillConfig, Q as FilePart, R as ImagePart, Y as OpenCodeAgentOptions, Z as OpenCodePluginConfig, _ as OpenCodePluginEvent, $ as OpenCodePluginHookConfig, a0 as OpenCodeProviderOptions, a5 as RepoSkillConfig, ab as TextPart, af as UserContent, ag as UserContentPart } from '../types-Dj_HCr6Q.js';
 import { S as Sandbox } from '../Sandbox-CByFJI8X.js';
 export { AgentProvider } from '../enums.js';
 import 'e2b';

package/dist/agents/index.js

@@ -1,11 +1,11 @@
 import {
   Agent
-} from "../chunk-4MBB6QHD.js";
-import "../chunk-ZOWBRUQR.js";
+} from "../chunk-YAMFJAU6.js";
+import "../chunk-NWAXQ7UD.js";
 import {
   AGENT_RESERVED_PORTS,
   collectAllAgentReservedPorts
-} from "../chunk-INMA52FV.js";
+} from "../chunk-AVXJMCBC.js";
 import "../chunk-NSJM57Z4.js";
 import {
   AgentProvider

package/dist/{chunk-INMA52FV.js → chunk-AVXJMCBC.js}

@@ -188,6 +188,22 @@ async function readStreamAsText(stream) {
   result += decoder.decode();
   return result;
 }
+async function readStreamAsBytes(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      chunks.push(Buffer.isBuffer(value) ? value : Buffer.from(value));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks);
+}
 async function pipeReadableStream(stream, onChunk) {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
@@ -256,6 +272,7 @@ export {
   sleep,
   waitFor,
   readStreamAsText,
+  readStreamAsBytes,
   pipeReadableStream,
   readNodeStream,
   linesFromTextChunks,

package/dist/{chunk-LPKKT6YT.js → chunk-DDGBIACF.js}

@@ -5,11 +5,12 @@ import {
   debugSandbox,
   pipeReadableStream,
   readNodeStream,
+  readStreamAsBytes,
   readStreamAsText,
   sleep,
   suppressUnhandledRejection,
   time
-} from "./chunk-INMA52FV.js";
+} from "./chunk-AVXJMCBC.js";
 import {
   shellQuote,
   toShellCommand
@@ -1284,6 +1285,7 @@ var LocalDockerSandboxAdapter = class extends SandboxAdapter {
 };
 
 // src/sandboxes/providers/modal.ts
+import path from "path";
 import { ModalClient } from "modal";
 
 // src/sandboxes/tarball.ts
@@ -1535,6 +1537,74 @@ ${command}`;
       raw: process2
     };
   }
+  /**
+   * Upload `content` to `targetPath` inside the Modal sandbox.
+   *
+   * Modal's TS SDK only exposes a `Sandbox.open()` FileIO handle for direct
+   * filesystem access, which is deprecated and capped at 100 MiB per
+   * operation. To match the cross-provider semantics (works for arbitrarily
+   * large artifacts, parent dirs are created on demand), we instead pipe
+   * raw bytes through stdin into a single `mkdir -p … && cat > …` shell —
+   * the same single-exec pattern `uploadAndRun` uses.
+   */
+  async uploadFile(content, targetPath) {
+    this.requireProvisioned();
+    const sandbox = this.requireSandbox();
+    const data = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+    const dir = path.posix.dirname(targetPath);
+    const wrapped = dir && dir !== "." && dir !== "/" ? `set -e; mkdir -p ${shellQuote(dir)}; cat > ${shellQuote(targetPath)}` : `set -e; cat > ${shellQuote(targetPath)}`;
+    const proc = await sandbox.exec(["/bin/sh", "-c", wrapped], {
+      mode: "binary"
+    });
+    const writer = proc.stdin.getWriter();
+    try {
+      await writer.write(data);
+      await writer.close();
+    } finally {
+      try {
+        writer.releaseLock();
+      } catch {
+      }
+    }
+    const [stderrBytes, exitCode] = await Promise.all([
+      readStreamAsBytes(proc.stderr),
+      proc.wait()
+    ]);
+    if (exitCode !== 0) {
+      const stderr = stderrBytes.toString("utf8").trim();
+      throw new Error(
+        `Failed to upload file to Modal sandbox at ${targetPath} (exit ${exitCode})${stderr ? `: ${stderr}` : ""}`
+      );
+    }
+  }
+  /**
+   * Download a file from the Modal sandbox as raw bytes.
+   *
+   * Implemented by `cat`-ing the file in a binary-mode `exec` and
+   * collecting stdout. This matches the cross-provider contract (returns a
+   * Node `Buffer` of the file's exact bytes) and avoids the deprecated
+   * 100 MiB FileIO cap on `Sandbox.open()`.
+   */
+  async downloadFile(sourcePath) {
+    this.requireProvisioned();
+    const sandbox = this.requireSandbox();
+    const proc = await sandbox.exec(
+      ["/bin/sh", "-c", `cat -- ${shellQuote(sourcePath)}`],
+      { mode: "binary" }
+    );
+    const [stdoutBytes, stderrBytes, exitCode] = await Promise.all([
+      readStreamAsBytes(proc.stdout),
+      readStreamAsBytes(proc.stderr),
+      proc.wait()
+    ]);
+    if (exitCode !== 0) {
+      const stderr = stderrBytes.toString("utf8").trim();
+      throw new Error(
+        `Failed to download file from Modal sandbox at ${sourcePath} (exit ${exitCode})${stderr ? `: ${stderr}` : ""}`
+      );
+    }
+    return stdoutBytes;
+  }
   async list(options) {
     const sandboxes = [];
     for await (const sandbox of this.client.sandboxes.list({

package/dist/{chunk-ZOWBRUQR.js → chunk-NWAXQ7UD.js}

@@ -155,6 +155,7 @@ function toAISDKEvent(event) {
       };
     case "message.completed":
     case "run.completed":
+    case "run.cancelled":
       return {
         type: "response-finish",
         id: event.runId,
@@ -376,9 +377,130 @@ var OpenCodeLogAssembler = class {
     return clone(next);
   }
 };
+var ClaudeCodeLogAssembler = class {
+  currentMessageId = null;
+  textByMessageId = /* @__PURE__ */ new Map();
+  thinkingByMessageId = /* @__PURE__ */ new Map();
+  byMessageId = /* @__PURE__ */ new Map();
+  process(event) {
+    if (!isRecord(event)) return [];
+    const type = typeof event.type === "string" ? event.type : "";
+    if (type === "stream_event") {
+      const stream = isRecord(event.event) ? event.event : null;
+      if (!stream) return [];
+      const streamType = typeof stream.type === "string" ? stream.type : "";
+      if (streamType === "message_start") {
+        const message = isRecord(stream.message) ? stream.message : null;
+        const id = message && typeof message.id === "string" ? message.id : null;
+        if (!id) return [];
+        this.currentMessageId = id;
+        if (!this.textByMessageId.has(id)) this.textByMessageId.set(id, "");
+        if (!this.thinkingByMessageId.has(id))
+          this.thinkingByMessageId.set(id, "");
+        return [this.upsertMessage(id)];
+      }
+      if (streamType === "content_block_delta") {
+        const id = this.currentMessageId;
+        if (!id) return [];
+        const delta = isRecord(stream.delta) ? stream.delta : null;
+        if (!delta) return [];
+        if (delta.type === "text_delta" && typeof delta.text === "string" && delta.text) {
+          const text = (this.textByMessageId.get(id) ?? "") + delta.text;
+          this.textByMessageId.set(id, text);
+          return [this.upsertMessage(id)];
+        }
+        if (delta.type === "thinking_delta" && typeof delta.thinking === "string" && delta.thinking) {
+          const thinking = (this.thinkingByMessageId.get(id) ?? "") + delta.thinking;
+          this.thinkingByMessageId.set(id, thinking);
+          return [this.upsertMessage(id)];
+        }
+        return [];
+      }
+      return [];
+    }
+    if (type === "assistant") {
+      const message = isRecord(event.message) ? event.message : null;
+      const id = message && typeof message.id === "string" ? message.id : null;
+      if (!id || !message) {
+        return [clone(event)];
+      }
+      const final = extractClaudeAssistantContent(message);
+      this.textByMessageId.set(id, final.text);
+      this.thinkingByMessageId.set(id, final.thinking);
+      const snapshot = this.upsertMessage(id, final.extraBlocks);
+      this.currentMessageId = null;
+      return [snapshot];
+    }
+    return [clone(event)];
+  }
+  seed(snapshots) {
+    this.currentMessageId = null;
+    this.textByMessageId.clear();
+    this.thinkingByMessageId.clear();
+    this.byMessageId.clear();
+    for (const snapshot of snapshots) {
+      if (!isRecord(snapshot)) continue;
+      if (snapshot.type !== "message.updated") continue;
+      const messageId = typeof snapshot.messageId === "string" ? snapshot.messageId : null;
+      if (!messageId) continue;
+      this.byMessageId.set(messageId, clone(snapshot));
+      const message = isRecord(snapshot.message) ? snapshot.message : null;
+      const content = message && Array.isArray(message.content) ? message.content : [];
+      let text = "";
+      let thinking = "";
+      for (const block of content) {
+        if (!isRecord(block)) continue;
+        if (block.type === "text" && typeof block.text === "string") {
+          text += block.text;
+        } else if (block.type === "thinking" && typeof block.thinking === "string") {
+          thinking += block.thinking;
+        }
+      }
+      this.textByMessageId.set(messageId, text);
+      this.thinkingByMessageId.set(messageId, thinking);
+    }
+  }
+  upsertMessage(messageId, extraBlocks = []) {
+    const text = this.textByMessageId.get(messageId) ?? "";
+    const thinking = this.thinkingByMessageId.get(messageId) ?? "";
+    const content = [];
+    if (text) content.push({ type: "text", text });
+    if (thinking) content.push({ type: "thinking", thinking });
+    for (const block of extraBlocks) content.push(clone(block));
+    const next = {
+      type: "message.updated",
+      messageId,
+      message: {
+        id: messageId,
+        role: "assistant",
+        content
+      }
+    };
+    this.byMessageId.set(messageId, next);
+    return clone(next);
+  }
+};
+function extractClaudeAssistantContent(message) {
+  const content = Array.isArray(message.content) ? message.content : [];
+  let text = "";
+  let thinking = "";
+  const extraBlocks = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      text += block.text;
+    } else if (block.type === "thinking" && typeof block.thinking === "string") {
+      thinking += block.thinking;
+    } else {
+      extraBlocks.push(clone(block));
+    }
+  }
+  return { text, thinking, extraBlocks };
+}
 var ProviderLogAssembler = class {
   codex = new CodexLogAssembler();
   openCode = new OpenCodeLogAssembler();
+  claudeCode = new ClaudeCodeLogAssembler();
   /**
    * Process a raw provider event and return any newly-produced assembled
    * snapshots. May return an empty array when the event is non-stateful (e.g.
@@ -391,6 +513,9 @@ var ProviderLogAssembler = class {
     if (provider === AgentProvider.OpenCode || provider === "opencode") {
       return this.openCode.process(event);
     }
+    if (provider === AgentProvider.ClaudeCode || provider === "claude-code") {
+      return this.claudeCode.process(event);
+    }
     if (isRecord(event)) {
       return [clone(event)];
     }
@@ -411,14 +536,17 @@ var ProviderLogAssembler = class {
       this.openCode.seed(snapshots);
       return;
     }
+    if (provider === AgentProvider.ClaudeCode || provider === "claude-code") {
+      this.claudeCode.seed(snapshots);
+      return;
+    }
   }
   /**
    * Given a sequence of assembled snapshots (typically the persisted history
    * for a run), return one entry per item / part with the latest snapshot
    * winning, preserving first-seen order.
    *
-   * For providers that don't have a stateful item model (Claude Code), or
-   * for unrecognized snapshot shapes, entries are returned in original order
+   * For unrecognized snapshot shapes, entries are returned in original order
    * with no dedup.
    */
   static dedupeSnapshots(provider, snapshots) {
@@ -429,6 +557,12 @@ var ProviderLogAssembler = class {
         return item && typeof item.id === "string" ? `item:${item.id}` : null;
       });
     }
+    if (provider === AgentProvider.ClaudeCode || provider === "claude-code") {
+      return dedupeByKey(snapshots, (snapshot) => {
+        const messageId = typeof snapshot.messageId === "string" ? snapshot.messageId : null;
+        return messageId ? `message:${messageId}` : null;
+      });
+    }
     if (provider === AgentProvider.OpenCode || provider === "opencode") {
       return dedupeByKey(snapshots, (snapshot) => {
         const properties = isRecord(snapshot.properties) ? snapshot.properties : null;

package/dist/{chunk-4MBB6QHD.js → chunk-YAMFJAU6.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";
@@ -1445,7 +1445,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 +1516,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) {
@@ -2092,6 +2106,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 +2195,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 +2207,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 +2526,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 +2536,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 +2565,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
@@ -2998,8 +3036,7 @@ async function createRuntime(request, inputParts) {
         port: REMOTE_CODEX_APP_SERVER_PORT,
         codexDir
       },
-      inputItems,
-      turnStartOverrides: buildTurnCollaborationMode(request)
+      inputItems
     };
   }
   const codexArgs = buildCodexCommandArgs(
@@ -3037,8 +3074,7 @@ async function createRuntime(request, inputParts) {
         await handle.kill();
       },
       raw: { handle, codexDir },
-      inputItems,
-      turnStartOverrides: buildTurnCollaborationMode(request)
+      inputItems
     };
   }
   const processHandle = spawnCommand({
@@ -3060,8 +3096,7 @@ async function createRuntime(request, inputParts) {
       await processHandle.kill();
     },
     raw: { processHandle, codexDir },
-    inputItems,
-    turnStartOverrides: buildTurnCollaborationMode(request)
+    inputItems
   };
 }
 async function buildCodexInputItems(options, inputParts) {
@@ -3118,7 +3153,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 +3201,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 +3239,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 +3251,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 +3285,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 +3313,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);
     }
@@ -3521,10 +3630,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,
@@ -3820,7 +3934,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 +3967,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 +3996,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 +4086,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,
@@ -4121,30 +4264,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 +4469,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 +4484,6 @@ var AgentRunController = class {
     });
     void this.sessionIdReady.catch(() => void 0);
     this.resolveFinished = resolveFinished;
-    this.rejectFinished = rejectFinished;
     this.resolveSessionIdReady = resolveSessionIdReady;
     this.rejectSessionIdReady = rejectSessionIdReady;
   }
@@ -4462,11 +4619,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 +4641,42 @@ 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 +4703,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;
@@ -4585,6 +4795,21 @@ 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);

package/dist/events/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AISDKEvent, S as MessageCompletedEvent, T as MessageInjectedEvent, U as MessageStartedEvent, V as NormalizedAgentEvent, W as NormalizedAgentEventBase, X as NormalizedAgentEventType, a1 as PermissionRequestedEvent, a2 as PermissionResolvedEvent, a3 as RawAgentEvent, a4 as ReasoningDeltaEvent, a6 as RunCompletedEvent, a7 as RunErrorEvent, a8 as RunStartedEvent, a9 as TextDeltaEvent, ab as ToolCallCompletedEvent, ac as ToolCallDeltaEvent, ad as ToolCallStartedEvent, ag as createNormalizedEvent, ah as normalizeRawAgentEvent, ai as toAISDKEvent, aj as toAISDKStream } from '../types-B3N-Qo2q.js';
+export { A as AISDKEvent, S as MessageCompletedEvent, T as MessageInjectedEvent, U as MessageStartedEvent, V as NormalizedAgentEvent, W as NormalizedAgentEventBase, X as NormalizedAgentEventType, a1 as PermissionRequestedEvent, a2 as PermissionResolvedEvent, a3 as RawAgentEvent, a4 as ReasoningDeltaEvent, a6 as RunCancelledEvent, a7 as RunCompletedEvent, a8 as RunErrorEvent, a9 as RunStartedEvent, aa as TextDeltaEvent, ac as ToolCallCompletedEvent, ad as ToolCallDeltaEvent, ae as ToolCallStartedEvent, ah as createNormalizedEvent, ai as normalizeRawAgentEvent, aj as toAISDKEvent, ak as toAISDKStream } from '../types-Dj_HCr6Q.js';
 import { AgentProvider } from '../enums.js';
 import '../Sandbox-CByFJI8X.js';
 import 'e2b';
@@ -62,6 +62,7 @@ type JsonRecord = Record<string, unknown>;
 declare class ProviderLogAssembler {
     private readonly codex;
     private readonly openCode;
+    private readonly claudeCode;
     /**
      * Process a raw provider event and return any newly-produced assembled
      * snapshots. May return an empty array when the event is non-stateful (e.g.
@@ -80,8 +81,7 @@ declare class ProviderLogAssembler {
      * for a run), return one entry per item / part with the latest snapshot
      * winning, preserving first-seen order.
      *
-     * For providers that don't have a stateful item model (Claude Code), or
-     * for unrecognized snapshot shapes, entries are returned in original order
+     * For unrecognized snapshot shapes, entries are returned in original order
      * with no dedup.
      */
     static dedupeSnapshots(provider: AgentProvider | string | null | undefined, snapshots: JsonRecord[]): JsonRecord[];

package/dist/events/index.js

@@ -4,7 +4,7 @@ import {
   normalizeRawAgentEvent,
   toAISDKEvent,
   toAISDKStream
-} from "../chunk-ZOWBRUQR.js";
+} from "../chunk-NWAXQ7UD.js";
 import "../chunk-GOFJNFAD.js";
 export {
   ProviderLogAssembler,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AISDKEvent, a as AgentApprovalMode, b as AgentAttachRequest, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, h as AgentOptions, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, o as AgentProviderName, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, r as AgentResult, s as AgentRun, t as AgentRunConfig, u as AgentRunSink, v as AgentSetupConfig, w as AgentSetupRequest, x as AgentSkillConfig, y as AgentSubAgentConfig, z as AttachedRun, C as ClaudeCodeAgentOptions, B as ClaudeCodeHookConfig, D as ClaudeCodeHookEvent, E as ClaudeCodeHookHandler, F as ClaudeCodeHookMatcherGroup, G as ClaudeCodeHooksConfig, H as ClaudeCodeProviderOptions, I as CodexAgentOptions, J as CodexCommandHook, K as CodexHookEvent, L as CodexHookMatcherGroup, M as CodexHooksConfig, N as CodexProviderOptions, O as DataContent, P as EmbeddedSkillConfig, Q as FilePart, R as ImagePart, S as MessageCompletedEvent, T as MessageInjectedEvent, U as MessageStartedEvent, V as NormalizedAgentEvent, W as NormalizedAgentEventBase, X as NormalizedAgentEventType, Y as OpenCodeAgentOptions, Z as OpenCodePluginConfig, _ as OpenCodePluginEvent, $ as OpenCodePluginHookConfig, a0 as OpenCodeProviderOptions, a1 as PermissionRequestedEvent, a2 as PermissionResolvedEvent, a3 as RawAgentEvent, a4 as ReasoningDeltaEvent, a5 as RepoSkillConfig, a6 as RunCompletedEvent, a7 as RunErrorEvent, a8 as RunStartedEvent, a9 as TextDeltaEvent, aa as TextPart, ab as ToolCallCompletedEvent, ac as ToolCallDeltaEvent, ad as ToolCallStartedEvent, ae as UserContent, af as UserContentPart, ag as createNormalizedEvent, ah as normalizeRawAgentEvent, ai as toAISDKEvent, aj as toAISDKStream } from './types-B3N-Qo2q.js';
+export { A as AISDKEvent, a as AgentApprovalMode, b as AgentAttachRequest, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, h as AgentOptions, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, o as AgentProviderName, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, r as AgentResult, s as AgentRun, t as AgentRunConfig, u as AgentRunSink, v as AgentSetupConfig, w as AgentSetupRequest, x as AgentSkillConfig, y as AgentSubAgentConfig, z as AttachedRun, C as ClaudeCodeAgentOptions, B as ClaudeCodeHookConfig, D as ClaudeCodeHookEvent, E as ClaudeCodeHookHandler, F as ClaudeCodeHookMatcherGroup, G as ClaudeCodeHooksConfig, H as ClaudeCodeProviderOptions, I as CodexAgentOptions, J as CodexCommandHook, K as CodexHookEvent, L as CodexHookMatcherGroup, M as CodexHooksConfig, N as CodexProviderOptions, O as DataContent, P as EmbeddedSkillConfig, Q as FilePart, R as ImagePart, S as MessageCompletedEvent, T as MessageInjectedEvent, U as MessageStartedEvent, V as NormalizedAgentEvent, W as NormalizedAgentEventBase, X as NormalizedAgentEventType, Y as OpenCodeAgentOptions, Z as OpenCodePluginConfig, _ as OpenCodePluginEvent, $ as OpenCodePluginHookConfig, a0 as OpenCodeProviderOptions, a1 as PermissionRequestedEvent, a2 as PermissionResolvedEvent, a3 as RawAgentEvent, a4 as ReasoningDeltaEvent, a5 as RepoSkillConfig, a6 as RunCancelledEvent, a7 as RunCompletedEvent, a8 as RunErrorEvent, a9 as RunStartedEvent, aa as TextDeltaEvent, ab as TextPart, ac as ToolCallCompletedEvent, ad as ToolCallDeltaEvent, ae as ToolCallStartedEvent, af as UserContent, ag as UserContentPart, ah as createNormalizedEvent, ai as normalizeRawAgentEvent, aj as toAISDKEvent, ak as toAISDKStream } from './types-Dj_HCr6Q.js';
 export { AGENT_RESERVED_PORTS, Agent, collectAllAgentReservedPorts } from './agents/index.js';
 export { A as AsyncCommandHandle, C as CommandEvent, a as CommandOptions, b as CommandResult, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, G as GitCloneOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, g as SandboxDescriptor, h as SandboxListOptions, i as SandboxOptions, j as SandboxOptionsBase, k as SandboxOptionsMap, l as SandboxProviderName, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec, T as TarballEntry, V as VercelGitSource, p as VercelProviderOptions, q as VercelSandboxOptions } from './Sandbox-CByFJI8X.js';
 export { SandboxAdapter, buildGitCloneCommand } from './sandboxes/index.js';

package/dist/index.js

@@ -1,22 +1,22 @@
 import {
   Agent
-} from "./chunk-4MBB6QHD.js";
+} from "./chunk-YAMFJAU6.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKEvent,
   toAISDKStream
-} from "./chunk-ZOWBRUQR.js";
+} from "./chunk-NWAXQ7UD.js";
 import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "./chunk-LPKKT6YT.js";
+} from "./chunk-DDGBIACF.js";
 import {
   AGENT_RESERVED_PORTS,
   collectAllAgentReservedPorts
-} from "./chunk-INMA52FV.js";
+} from "./chunk-AVXJMCBC.js";
 import "./chunk-NSJM57Z4.js";
 import {
   AgentProvider,

package/dist/sandboxes/index.js

@@ -2,8 +2,8 @@ import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "../chunk-LPKKT6YT.js";
-import "../chunk-INMA52FV.js";
+} from "../chunk-DDGBIACF.js";
+import "../chunk-AVXJMCBC.js";
 import "../chunk-NSJM57Z4.js";
 import {
   SandboxProvider

package/dist/{types-B3N-Qo2q.d.ts → types-Dj_HCr6Q.d.ts}

@@ -9,7 +9,7 @@ interface RawAgentEvent<TPayload = unknown> {
     payload: TPayload;
 }
 
-type NormalizedAgentEventType = "run.started" | "message.started" | "message.injected" | "text.delta" | "reasoning.delta" | "tool.call.started" | "tool.call.delta" | "tool.call.completed" | "permission.requested" | "permission.resolved" | "message.completed" | "run.completed" | "run.error";
+type NormalizedAgentEventType = "run.started" | "message.started" | "message.injected" | "text.delta" | "reasoning.delta" | "tool.call.started" | "tool.call.delta" | "tool.call.completed" | "permission.requested" | "permission.resolved" | "message.completed" | "run.completed" | "run.cancelled" | "run.error";
 interface NormalizedAgentEventBase {
     provider: string;
     runId: string;
@@ -97,11 +97,15 @@ interface RunCompletedEvent extends NormalizedAgentEventBase {
     type: "run.completed";
     text?: string;
 }
+interface RunCancelledEvent extends NormalizedAgentEventBase {
+    type: "run.cancelled";
+    text?: string;
+}
 interface RunErrorEvent extends NormalizedAgentEventBase {
     type: "run.error";
     error: string;
 }
-type NormalizedAgentEvent = RunStartedEvent | MessageStartedEvent | MessageInjectedEvent | TextDeltaEvent | ReasoningDeltaEvent | ToolCallStartedEvent | ToolCallDeltaEvent | ToolCallCompletedEvent | PermissionRequestedEvent | PermissionResolvedEvent | MessageCompletedEvent | RunCompletedEvent | RunErrorEvent;
+type NormalizedAgentEvent = RunStartedEvent | MessageStartedEvent | MessageInjectedEvent | TextDeltaEvent | ReasoningDeltaEvent | ToolCallStartedEvent | ToolCallDeltaEvent | ToolCallCompletedEvent | PermissionRequestedEvent | PermissionResolvedEvent | MessageCompletedEvent | RunCompletedEvent | RunCancelledEvent | RunErrorEvent;
 declare function createNormalizedEvent<TType extends NormalizedAgentEventType>(type: TType, base: Omit<NormalizedAgentEventBase, "type" | "timestamp"> & {
     timestamp?: string;
 }, extra?: Record<string, unknown>): NormalizedAgentEvent;
@@ -307,6 +311,26 @@ interface AgentRunConfig {
     model?: string;
     systemPrompt?: string;
     resumeSessionId?: string;
+    /**
+     * Source session/thread to fork from. The new run begins in a *new*
+     * session whose history is the prefix of the source up to and including
+     * {@link forkAtMessageId}. Mutually exclusive with {@link resumeSessionId}.
+     * Requires {@link forkAtMessageId}.
+     *
+     * Provider mapping:
+     * - claude-code: `query({ resume, resumeSessionAt, forkSession: true })`
+     * - opencode: `POST /session/:forkSessionId/fork { messageID }`
+     * - codex: emulated via `thread/fork` + `thread/rollback` (no native
+     *   message-level fork in the codex app-server)
+     */
+    forkSessionId?: string;
+    /**
+     * Provider-native message id (claude-code: assistant message UUID;
+     * opencode: message info id; codex: turn id) to fork at — inclusive.
+     * The unified `messageId` field on `message.started` events carries the
+     * value to feed back here. Required when {@link forkSessionId} is set.
+     */
+    forkAtMessageId?: string;
     reasoning?: AgentReasoningEffort;
 }
 /**
@@ -396,6 +420,8 @@ interface AgentResult {
     provider: AgentProviderName;
     sessionId: string;
     text: string;
+    isCancelled: boolean;
+    error?: string;
     rawEvents: RawAgentEvent[];
     events: NormalizedAgentEvent[];
     costData?: AgentCostData | null;
@@ -427,6 +453,10 @@ interface AgentRunSink {
         text?: string;
         costData?: AgentCostData | null;
     }): void;
+    cancel(result?: {
+        text?: string;
+        costData?: AgentCostData | null;
+    }): void;
     fail(error: unknown): void;
 }
 interface AgentSetupRequest<P extends AgentProviderName = AgentProviderName> {
@@ -524,4 +554,4 @@ interface AgentProviderAdapter<P extends AgentProviderName = AgentProviderName>
     attachSendMessage(request: AgentAttachRequest<P>, content: UserContent): Promise<void>;
 }
 
-export { type OpenCodePluginHookConfig as $, type AISDKEvent as A, type ClaudeCodeHookConfig as B, type ClaudeCodeAgentOptions as C, type ClaudeCodeHookEvent as D, type ClaudeCodeHookHandler as E, type ClaudeCodeHookMatcherGroup as F, type ClaudeCodeHooksConfig as G, type ClaudeCodeProviderOptions as H, type CodexAgentOptions as I, type CodexCommandHook as J, type CodexHookEvent as K, type CodexHookMatcherGroup as L, type CodexHooksConfig as M, type CodexProviderOptions as N, type DataContent as O, type EmbeddedSkillConfig as P, type FilePart as Q, type ImagePart as R, type MessageCompletedEvent as S, type MessageInjectedEvent as T, type MessageStartedEvent as U, type NormalizedAgentEvent as V, type NormalizedAgentEventBase as W, type NormalizedAgentEventType as X, type OpenCodeAgentOptions as Y, type OpenCodePluginConfig as Z, type OpenCodePluginEvent as _, type AgentApprovalMode as a, type OpenCodeProviderOptions as a0, type PermissionRequestedEvent as a1, type PermissionResolvedEvent as a2, type RawAgentEvent as a3, type ReasoningDeltaEvent as a4, type RepoSkillConfig as a5, type RunCompletedEvent as a6, type RunErrorEvent as a7, type RunStartedEvent as a8, type TextDeltaEvent as a9, type TextPart as aa, type ToolCallCompletedEvent as ab, type ToolCallDeltaEvent as ac, type ToolCallStartedEvent as ad, type UserContent as ae, type UserContentPart as af, createNormalizedEvent as ag, normalizeRawAgentEvent as ah, toAISDKEvent as ai, toAISDKStream as aj, type AgentAttachRequest as b, type AgentCommandConfig as c, type AgentCostData as d, type AgentExecutionRequest as e, type AgentLocalMcpConfig as f, type AgentMcpConfig as g, type AgentOptions as h, type AgentOptionsBase as i, type AgentOptionsMap as j, type AgentPermissionDecision as k, type AgentPermissionKind as l, type AgentPermissionResponse as m, type AgentProviderAdapter as n, type AgentProviderName as o, type AgentReasoningEffort as p, type AgentRemoteMcpConfig as q, type AgentResult as r, type AgentRun as s, type AgentRunConfig as t, type AgentRunSink as u, type AgentSetupConfig as v, type AgentSetupRequest as w, type AgentSkillConfig as x, type AgentSubAgentConfig as y, type AttachedRun as z };
+export { type OpenCodePluginHookConfig as $, type AISDKEvent as A, type ClaudeCodeHookConfig as B, type ClaudeCodeAgentOptions as C, type ClaudeCodeHookEvent as D, type ClaudeCodeHookHandler as E, type ClaudeCodeHookMatcherGroup as F, type ClaudeCodeHooksConfig as G, type ClaudeCodeProviderOptions as H, type CodexAgentOptions as I, type CodexCommandHook as J, type CodexHookEvent as K, type CodexHookMatcherGroup as L, type CodexHooksConfig as M, type CodexProviderOptions as N, type DataContent as O, type EmbeddedSkillConfig as P, type FilePart as Q, type ImagePart as R, type MessageCompletedEvent as S, type MessageInjectedEvent as T, type MessageStartedEvent as U, type NormalizedAgentEvent as V, type NormalizedAgentEventBase as W, type NormalizedAgentEventType as X, type OpenCodeAgentOptions as Y, type OpenCodePluginConfig as Z, type OpenCodePluginEvent as _, type AgentApprovalMode as a, type OpenCodeProviderOptions as a0, type PermissionRequestedEvent as a1, type PermissionResolvedEvent as a2, type RawAgentEvent as a3, type ReasoningDeltaEvent as a4, type RepoSkillConfig as a5, type RunCancelledEvent as a6, type RunCompletedEvent as a7, type RunErrorEvent as a8, type RunStartedEvent as a9, type TextDeltaEvent as aa, type TextPart as ab, type ToolCallCompletedEvent as ac, type ToolCallDeltaEvent as ad, type ToolCallStartedEvent as ae, type UserContent as af, type UserContentPart as ag, createNormalizedEvent as ah, normalizeRawAgentEvent as ai, toAISDKEvent as aj, toAISDKStream as ak, type AgentAttachRequest as b, type AgentCommandConfig as c, type AgentCostData as d, type AgentExecutionRequest as e, type AgentLocalMcpConfig as f, type AgentMcpConfig as g, type AgentOptions as h, type AgentOptionsBase as i, type AgentOptionsMap as j, type AgentPermissionDecision as k, type AgentPermissionKind as l, type AgentPermissionResponse as m, type AgentProviderAdapter as n, type AgentProviderName as o, type AgentReasoningEffort as p, type AgentRemoteMcpConfig as q, type AgentResult as r, type AgentRun as s, type AgentRunConfig as t, type AgentRunSink as u, type AgentSetupConfig as v, type AgentSetupRequest as w, type AgentSkillConfig as x, type AgentSubAgentConfig as y, type AttachedRun as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.3",
+  "version": "0.1.302",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {
@@ -58,7 +58,6 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.123",
     "@daytonaio/sdk": "^0.161.0",
     "@types/debug": "^4.1.13",
     "@vercel/sandbox": "2.0.0-beta.13",
@@ -71,6 +70,7 @@
     "ws": "^8.20.0"
   },
   "devDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.123",
     "@eslint/js": "^10.0.1",
     "@types/dockerode": "^3.3.42",
     "@types/node": "^25.5.2",