agentbox-sdk 0.1.0 → 0.1.1

package/dist/{chunk-BW43ESRM.js → chunk-G27423WX.js}

@@ -4,6 +4,7 @@ import {
   toAISDKStream
 } from "./chunk-7FLLQJ6J.js";
 import {
+  AGENT_RESERVED_PORTS,
   AgentBoxError,
   AsyncQueue,
   UnsupportedProviderError,
@@ -12,10 +13,14 @@ import {
   linesFromTextChunks,
   sleep,
   waitFor
-} from "./chunk-HMBWQSVN.js";
+} from "./chunk-O7HCJXKW.js";
 import {
   shellQuote
-} from "./chunk-JFDP556Q.js";
+} from "./chunk-NSJM57Z4.js";
+import {
+  AgentProvider,
+  SandboxProvider
+} from "./chunk-2NKMDGYH.js";
 
 // src/agents/Agent.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -87,7 +92,7 @@ async function resolveUserInputParts(input) {
 }
 async function validateProviderUserInput(provider, input) {
   const parts = await resolveUserInputParts(input);
-  if (provider === "codex") {
+  if (provider === AgentProvider.Codex) {
     const unsupportedPart = parts.find((part) => part.type === "file");
     if (unsupportedPart) {
       throw new AgentBoxError(
@@ -103,7 +108,7 @@ async function validateProviderUserInput(provider, input) {
     }
     return parts;
   }
-  if (provider === "claude-code") {
+  if (provider === AgentProvider.ClaudeCode) {
     for (const part of parts) {
       if (part.type === "image") {
         if (!CLAUDE_IMAGE_MEDIA_TYPES.has(part.mediaType)) {
@@ -514,7 +519,7 @@ function assertCommandsSupported(provider, commands) {
   if (!commands || commands.length === 0) {
     return;
   }
-  if (provider === "codex") {
+  if (provider === AgentProvider.Codex) {
     throw new Error(
       "Custom commands are not supported for Codex in this package yet."
     );
@@ -550,10 +555,10 @@ function readProviderPlugins(options) {
   return options.provider?.plugins;
 }
 function legacySharedHooksError(provider) {
-  return provider === "opencode" ? "OpenCode hook plugins must be configured on options.provider.plugins. The shared options.hooks field was removed because hook semantics differ by provider." : `${provider === "claude-code" ? "Claude Code" : "Codex"} hooks must be configured on options.provider.hooks. The shared options.hooks field was removed because hook semantics differ by provider.`;
+  return provider === AgentProvider.OpenCode ? "OpenCode hook plugins must be configured on options.provider.plugins. The shared options.hooks field was removed because hook semantics differ by provider." : `${provider === AgentProvider.ClaudeCode ? "Claude Code" : "Codex"} hooks must be configured on options.provider.hooks. The shared options.hooks field was removed because hook semantics differ by provider.`;
 }
 function invalidGroupedHooksShapeError(provider) {
-  return `${provider === "claude-code" ? "Claude Code" : "Codex"} hooks must use the native grouped hooks object shape under options.provider.hooks, with each event mapped to an array of matcher groups.`;
+  return `${provider === AgentProvider.ClaudeCode ? "Claude Code" : "Codex"} hooks must use the native grouped hooks object shape under options.provider.hooks, with each event mapped to an array of matcher groups.`;
 }
 function hasMalformedGroupedHookEntries(hooks) {
   return Object.values(hooks).some(
@@ -644,7 +649,7 @@ function assertHooksSupported(provider, options) {
   }
   const providerHooks = readProviderHooks(options);
   const providerPlugins = readProviderPlugins(options);
-  if (provider === "opencode") {
+  if (provider === AgentProvider.OpenCode) {
     if (providerHooks !== void 0) {
       throw new Error(opencodeHooksFieldError());
     }
@@ -1033,18 +1038,17 @@ async function createRuntimeTarget(provider, runId, options) {
 import path6 from "path";
 function getSkillTargetDir(provider, layout, skillName) {
   switch (provider) {
-    case "claude-code":
+    case AgentProvider.ClaudeCode:
       return path6.join(layout.claudeDir, "skills", skillName);
-    case "opencode":
+    case AgentProvider.OpenCode:
       return path6.join(layout.opencodeDir, "skills", skillName);
-    case "codex":
+    case AgentProvider.Codex:
       return path6.join(layout.agentsDir, "skills", skillName);
   }
 }
 function buildSkillsInstallerCommand(provider, skill) {
   const repo = skill.repo ?? "https://github.com/anthropics/skills";
-  const agent = provider === "claude-code" ? "claude-code" : provider;
-  return `npx skills add ${shellQuote(repo)} -g --skill ${shellQuote(skill.name)} --agent ${shellQuote(agent)} -y`;
+  return `npx skills add ${shellQuote(repo)} -g --skill ${shellQuote(skill.name)} --agent ${shellQuote(provider)} -y`;
 }
 async function prepareSkillArtifacts(provider, skills, layout) {
   const artifacts = [];
@@ -1369,10 +1373,12 @@ var SharedSdkWsChannel = class {
 };
 var MAX_PENDING_MESSAGES_PER_RUN = 1e3;
 var SharedSdkWsConnection = class {
-  constructor(url) {
+  constructor(url, headers = {}) {
     this.url = url;
+    this.headers = headers;
   }
   url;
+  headers;
   socket;
   channels = /* @__PURE__ */ new Map();
   pendingMessages = /* @__PURE__ */ new Map();
@@ -1380,7 +1386,7 @@ var SharedSdkWsConnection = class {
     if (this.socket?.readyState === WebSocket.OPEN) {
       return;
     }
-    const socket = new WebSocket(this.url);
+    const socket = new WebSocket(this.url, { headers: this.headers });
     this.socket = socket;
     socket.on("message", (data) => {
       const lines = data.toString().split("\n").map((line) => line.trim()).filter(Boolean);
@@ -1512,7 +1518,7 @@ var REMOTE_SDK_RELAY_PATH = "/tmp/agentbox/claude-code/relay.mjs";
 var sharedRemoteConnectionBySandbox = /* @__PURE__ */ new WeakMap();
 function toRawEvent(runId, payload, type) {
   return {
-    provider: "claude-code",
+    provider: AgentProvider.ClaudeCode,
     runId,
     type,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1990,16 +1996,16 @@ function toClaudeRelayUrl(port, runId) {
   return parsed.toString();
 }
 function buildLocalSdkUrl(server, sandboxProvider) {
-  if (sandboxProvider === "local-docker") {
+  if (sandboxProvider === SandboxProvider.LocalDocker) {
     return server.url.replace("127.0.0.1", "host.docker.internal").replace("0.0.0.0", "host.docker.internal");
   }
   return server.url;
 }
-async function connectRemoteTransport(url) {
+async function connectRemoteTransport(url, headers = {}) {
   const startedAt = Date.now();
   let lastError;
   while (Date.now() - startedAt < 3e4) {
-    const client = new SharedSdkWsConnection(url);
+    const client = new SharedSdkWsConnection(url, headers);
     try {
       await Promise.race([
         client.start(),
@@ -2018,11 +2024,11 @@ async function connectRemoteTransport(url) {
   }
   throw lastError ?? new Error(`Could not connect to remote SDK bridge at ${url}.`);
 }
-async function canConnectToRemoteRelay(previewUrl) {
+async function canConnectToRemoteRelay(previewUrl, headers = {}) {
   const parsed = new URL(toWebSocketUrl(previewUrl));
   parsed.searchParams.set("role", "claude");
   parsed.searchParams.set("runId", "__probe__");
-  const client = new SharedSdkWsConnection(parsed.toString());
+  const client = new SharedSdkWsConnection(parsed.toString(), headers);
   try {
     await Promise.race([
       client.start(),
@@ -2056,7 +2062,7 @@ async function ensureSharedRemoteConnection(sandbox, previewUrl) {
   }
   const created = (async () => {
     const url = toSharedHostWebSocketUrl(previewUrl);
-    const connection = await connectRemoteTransport(url);
+    const connection = await connectRemoteTransport(url, sandbox.previewHeaders);
     return { previewUrl, connection };
   })();
   sharedRemoteConnectionBySandbox.set(key, created);
@@ -2071,7 +2077,8 @@ async function ensureRemoteRelay(request, prepared) {
   const sandbox = request.options.sandbox;
   await sandbox.openPort(REMOTE_SDK_RELAY_PORT);
   const previewUrl = await sandbox.getPreviewLink(REMOTE_SDK_RELAY_PORT);
-  if (await canConnectToRemoteRelay(previewUrl)) {
+  const previewHeaders = sandbox.previewHeaders;
+  if (await canConnectToRemoteRelay(previewUrl, previewHeaders)) {
     return {
       relayPort: REMOTE_SDK_RELAY_PORT,
       relayPath: REMOTE_SDK_RELAY_PATH,
@@ -2102,7 +2109,7 @@ async function ensureRemoteRelay(request, prepared) {
   });
   const startedAt = Date.now();
   while (Date.now() - startedAt < 3e4) {
-    if (await canConnectToRemoteRelay(previewUrl)) {
+    if (await canConnectToRemoteRelay(previewUrl, previewHeaders)) {
       return {
         relayPort: REMOTE_SDK_RELAY_PORT,
         relayPath: REMOTE_SDK_RELAY_PATH,
@@ -2121,7 +2128,7 @@ async function ensureRemoteRelay(request, prepared) {
 async function createLocalRuntime(request, prepared) {
   const sandboxProvider = request.options.sandbox?.provider;
   const transport = new SdkWsServer({
-    host: sandboxProvider === "local-docker" ? "0.0.0.0" : "127.0.0.1"
+    host: sandboxProvider === SandboxProvider.LocalDocker ? "0.0.0.0" : "127.0.0.1"
   });
   await transport.start();
   const args = prepared.buildArgs(buildLocalSdkUrl(transport, sandboxProvider));
@@ -2198,7 +2205,7 @@ async function createRemoteSandboxRuntime(request, prepared) {
   };
 }
 async function createRuntime(request) {
-  if (request.options.sandbox && request.options.sandbox.provider !== "local-docker") {
+  if (request.options.sandbox && request.options.sandbox.provider !== SandboxProvider.LocalDocker) {
     await request.options.sandbox.openPort(REMOTE_SDK_RELAY_PORT);
     const prepared2 = await prepareClaudeRuntime(request);
     return createRemoteSandboxRuntime(request, prepared2);
@@ -2206,36 +2213,6 @@ async function createRuntime(request) {
   const prepared = await prepareClaudeRuntime(request);
   return createLocalRuntime(request, prepared);
 }
-function buildDirectClaudeArgs(buildArgs, prompt) {
-  const args = buildArgs("ws://127.0.0.1:9/");
-  const directArgs = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const current = args[index];
-    if (current === void 0) {
-      continue;
-    }
-    if (current === "--sdk-url" || current === "--input-format") {
-      index += 1;
-      continue;
-    }
-    directArgs.push(current);
-  }
-  if (!directArgs.includes("--verbose")) {
-    const printIndex = directArgs.indexOf("--print");
-    if (printIndex === -1) {
-      directArgs.unshift("--verbose");
-    } else {
-      directArgs.splice(printIndex + 1, 0, "--verbose");
-    }
-  }
-  const promptIndex = directArgs.lastIndexOf("-p");
-  if (promptIndex !== -1 && promptIndex + 1 < directArgs.length) {
-    directArgs[promptIndex + 1] = prompt;
-  } else {
-    directArgs.push("-p", prompt);
-  }
-  return directArgs;
-}
 var ClaudeCodeAgentAdapter = class {
   async execute(request, sink) {
     const inputParts = await validateProviderUserInput(
@@ -2243,203 +2220,42 @@ var ClaudeCodeAgentAdapter = class {
       request.run.input
     );
     const userContent = mapToClaudeUserContent(inputParts);
-    if (request.options.sandbox?.provider === "e2b" && typeof userContent === "string" && !request.run.systemPrompt && !request.options.subAgents?.length) {
-      const prepared = await prepareClaudeRuntime(request);
-      const args = buildDirectClaudeArgs(prepared.buildArgs, userContent);
-      const handle = await request.options.sandbox.runAsync(
-        [request.options.provider?.binary ?? "claude", ...args],
-        {
-          cwd: request.options.cwd,
-          env: {
-            ...prepared.env,
-            IS_SANDBOX: "1"
-          },
-          timeoutMs: 0
-        }
-      );
-      sink.setRaw({
-        handle,
-        layout: prepared.target.layout,
-        mode: "e2b-direct"
-      });
-      sink.setAbort(async () => {
-        await handle.kill().catch(() => void 0);
-        await handle.wait().catch(() => void 0);
-        await prepared.target.cleanup().catch(() => void 0);
-      });
-      sink.emitEvent(
-        createNormalizedEvent("run.started", {
-          provider: request.provider,
-          runId: request.runId
-        })
-      );
-      const completion2 = new Promise((resolve, reject) => {
-        let accumulatedText2 = "";
-        async function* stdoutChunks() {
-          for await (const event of handle) {
-            if (event.type === "stdout" && event.chunk) {
-              yield event.chunk;
-            }
-          }
-        }
-        void (async () => {
-          for await (const line of linesFromTextChunks(stdoutChunks())) {
-            const trimmed = line.trim();
-            if (!trimmed) {
-              continue;
-            }
-            let message;
-            try {
-              message = JSON.parse(trimmed);
-            } catch {
-              continue;
-            }
-            sink.emitRaw(toRawEvent(request.runId, message, message.type));
-            if (message.type === "system" && message.subtype === "init") {
-              const sessionId2 = String(message.session_id ?? "");
-              if (sessionId2) {
-                sink.setSessionId(sessionId2);
-              }
-              sink.emitEvent(
-                createNormalizedEvent("message.started", {
-                  provider: request.provider,
-                  runId: request.runId
-                })
-              );
-              continue;
-            }
-            if (message.type === "stream_event") {
-              const delta = extractStreamDelta(message);
-              if (delta) {
-                accumulatedText2 += delta;
-                sink.emitEvent(
-                  createNormalizedEvent(
-                    "text.delta",
-                    {
-                      provider: request.provider,
-                      runId: request.runId
-                    },
-                    { delta }
-                  )
-                );
-              }
-              continue;
-            }
-            if (message.type === "assistant") {
-              const text = extractAssistantText(message);
-              if (text) {
-                accumulatedText2 = text;
-                sink.emitEvent(
-                  createNormalizedEvent(
-                    "text.delta",
-                    {
-                      provider: request.provider,
-                      runId: request.runId
-                    },
-                    { delta: text }
-                  )
-                );
-              }
-              sink.emitEvent(
-                createNormalizedEvent(
-                  "message.completed",
-                  {
-                    provider: request.provider,
-                    runId: request.runId
-                  },
-                  { text }
-                )
-              );
-              continue;
-            }
-            if (message.type === "result") {
-              if (String(message.subtype ?? "success") === "success") {
-                resolve({ text: accumulatedText2 });
-              } else {
-                reject(
-                  new Error(
-                    String(
-                      message.result ?? message.error ?? "Claude Code run failed."
-                    )
-                  )
-                );
-              }
-              return;
-            }
-            if (message.type === "auth_status" && message.authenticated === false) {
-              reject(
-                new Error("Claude Code reported an authentication failure.")
-              );
-              return;
-            }
-            if (message.type === "control_request") {
-              reject(
-                new Error(
-                  "Claude Code direct E2B mode does not yet support interactive control requests."
-                )
-              );
-              return;
-            }
-          }
-          const result = await handle.wait().catch((error) => error);
-          reject(
-            new Error(
-              result instanceof Error ? String(result) : "Claude Code direct E2B mode ended before returning a result."
-            )
-          );
-        })().catch(reject);
-      });
-      try {
-        const { text } = await completion2;
-        await handle.wait().catch(() => void 0);
-        sink.emitEvent(
-          createNormalizedEvent(
-            "run.completed",
-            { provider: request.provider, runId: request.runId },
-            { text }
-          )
-        );
-        sink.complete({ text });
-      } catch (error) {
-        await handle.kill().catch(() => void 0);
-        await handle.wait().catch(() => void 0);
-        sink.fail(error);
-      } finally {
-        await prepared.target.cleanup().catch(() => void 0);
-      }
-      return async () => {
-        await handle.kill().catch(() => void 0);
-        await handle.wait().catch(() => void 0);
-      };
-    }
-    const runtime = await createRuntime(request);
-    sink.setRaw(runtime.raw);
-    sink.setAbort(runtime.cleanup);
-    sink.emitEvent(
-      createNormalizedEvent("run.started", {
-        provider: request.provider,
-        runId: request.runId
-      })
-    );
     let sessionId = "";
     let accumulatedText = "";
     let usedStreaming = false;
     let pendingMessages = 1;
     const autoApproveTools = shouldAutoApproveClaudeTools(request.options);
+    const transportRef = {};
+    const queuedSends = [];
     sink.onMessage(async (content) => {
       pendingMessages++;
       const parts = await validateProviderUserInput(request.provider, content);
       const mapped = mapToClaudeUserContent(parts);
       accumulatedText = "";
       usedStreaming = false;
-      await runtime.transport.send({
+      const payload = {
         type: "user",
         message: { role: "user", content: mapped },
         parent_tool_use_id: null,
         session_id: sessionId || request.run.resumeSessionId || "",
         uuid: randomUUID2()
-      });
+      };
+      if (transportRef.current) {
+        await transportRef.current.send(payload);
+      } else {
+        queuedSends.push(payload);
+      }
     });
+    const runtime = await createRuntime(request);
+    transportRef.current = runtime.transport;
+    sink.setRaw(runtime.raw);
+    sink.setAbort(runtime.cleanup);
+    sink.emitEvent(
+      createNormalizedEvent("run.started", {
+        provider: request.provider,
+        runId: request.runId
+      })
+    );
     const completion = new Promise((resolve, reject) => {
       void (async () => {
         for await (const message of runtime.transport.messages()) {
@@ -2599,6 +2415,9 @@ var ClaudeCodeAgentAdapter = class {
           runId: request.runId
         })
       );
+      for (const queued of queuedSends.splice(0)) {
+        await runtime.transport.send(queued);
+      }
       const { text } = await completion;
       sink.emitEvent(
         createNormalizedEvent(
@@ -2631,7 +2450,21 @@ async function fetchJson(url, init) {
   if (!response.ok) {
     throw new Error(`Request to ${url} failed with ${response.status}.`);
   }
-  return await response.json();
+  const text = await response.text();
+  if (text.length === 0) {
+    throw new Error(
+      `Request to ${url} returned status ${response.status} with an empty body.`
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    const preview = text.length > 200 ? `${text.slice(0, 200)}\u2026` : text;
+    const cause = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Could not parse JSON response from ${url} (status ${response.status}): ${cause}. Body: ${preview}`
+    );
+  }
 }
 async function* streamSse(url, init) {
   const response = await fetch(url, init);
@@ -2672,9 +2505,9 @@ async function* streamSse(url, init) {
   })();
   yield* queue;
 }
-async function connectJsonRpcWebSocket(url) {
+async function connectJsonRpcWebSocket(url, options) {
   const notifications = new AsyncQueue();
-  const socket = new WebSocket2(url);
+  const socket = new WebSocket2(url, { headers: options?.headers });
   await new Promise((resolve, reject) => {
     const cleanup = () => {
       socket.off("open", handleOpen);
@@ -2817,7 +2650,9 @@ function buildThreadParams(cwd, options, request) {
     approvalPolicy: isInteractiveApproval(options) ? "untrusted" : "never",
     sandbox: buildCodexSandboxMode(options),
     serviceName: "agentbox",
-    ephemeral: true,
+    // 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
   };
 }
@@ -2834,7 +2669,7 @@ function buildTurnSandboxPolicy(options) {
   if (!options.sandbox) {
     return void 0;
   }
-  if (options.sandbox.provider === "local-docker") {
+  if (options.sandbox.provider === SandboxProvider.LocalDocker) {
     return {
       type: "workspaceWrite",
       networkAccess: true
@@ -2858,7 +2693,7 @@ function buildTurnCollaborationMode(request) {
 }
 function toRawEvent2(runId, payload, type) {
   return {
-    provider: "codex",
+    provider: AgentProvider.Codex,
     runId,
     type,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2876,7 +2711,7 @@ function buildCodexCommandArgs(binary, args) {
 }
 function toNormalizedCodexEvents(runId, notification) {
   const base = {
-    provider: "codex",
+    provider: AgentProvider.Codex,
     runId,
     raw: toRawEvent2(runId, notification, notification.method)
   };
@@ -3070,16 +2905,22 @@ async function materializeCodexImage(target, part, index) {
   );
   return imagePath;
 }
+function resolveCodexOpenAiBaseUrl(request) {
+  return request.options.env?.OPENAI_BASE_URL ?? request.options.provider?.env?.OPENAI_BASE_URL;
+}
 async function ensureCodexLogin(request, target) {
-  const openAiApiKey = request.options.env?.OPENAI_API_KEY;
-  if (!openAiApiKey) {
-    return;
+  const openAiApiKey = request.options.env?.OPENAI_API_KEY ?? request.options.provider?.env?.OPENAI_API_KEY;
+  const openAiBaseUrl = resolveCodexOpenAiBaseUrl(request);
+  const extraEnv = {};
+  if (openAiApiKey) {
+    extraEnv.OPENAI_API_KEY = openAiApiKey;
+  }
+  if (openAiBaseUrl) {
+    extraEnv.OPENAI_BASE_URL = openAiBaseUrl;
   }
   await target.runCommand(
-    'if [ -z "$OPENAI_API_KEY" ]; then exit 1; fi; printenv OPENAI_API_KEY | env -u CODEX_HOME -u XDG_CONFIG_HOME codex login --with-api-key >/dev/null 2>&1',
-    {
-      OPENAI_API_KEY: openAiApiKey
-    }
+    'if [ -z "${OPENAI_API_KEY:-}" ]; then exit 0; fi; printenv OPENAI_API_KEY | env -u CODEX_HOME -u XDG_CONFIG_HOME codex login --with-api-key >/dev/null 2>&1',
+    Object.keys(extraEnv).length > 0 ? extraEnv : void 0
   );
 }
 function toRemoteCodexWebSocketUrl(url) {
@@ -3087,12 +2928,12 @@ function toRemoteCodexWebSocketUrl(url) {
   parsed.protocol = parsed.protocol === "https:" ? "wss:" : "ws:";
   return parsed.toString();
 }
-async function connectRemoteCodexAppServer(url) {
+async function connectRemoteCodexAppServer(url, headers = {}) {
   const startedAt = Date.now();
   let lastError;
   while (Date.now() - startedAt < 3e4) {
     try {
-      return await connectJsonRpcWebSocket(url);
+      return await connectJsonRpcWebSocket(url, { headers });
     } catch (error) {
       lastError = error;
       await sleep(250);
@@ -3117,7 +2958,7 @@ async function waitForInternalCodexReady(sandbox, port, cwd, env) {
 }
 async function createRuntime2(request, inputParts) {
   const options = request.options;
-  const usesRemoteWebSocket = options.sandbox && options.sandbox.provider !== "local-docker";
+  const usesRemoteWebSocket = options.sandbox && options.sandbox.provider !== SandboxProvider.LocalDocker;
   const hooks = assertHooksSupported(request.provider, options);
   assertCommandsSupported(request.provider, options.commands);
   if (usesRemoteWebSocket && options.sandbox) {
@@ -3167,6 +3008,10 @@ async function createRuntime2(request, inputParts) {
     }
     const configArgs2 = [];
     configArgs2.push("-c", `features.multi_agent=${enableMultiAgent2}`);
+    const openAiBaseUrl2 = resolveCodexOpenAiBaseUrl(request);
+    if (openAiBaseUrl2) {
+      configArgs2.push("-c", `openai_base_url=${JSON.stringify(openAiBaseUrl2)}`);
+    }
     const binary = options.provider?.binary ?? "codex";
     const pidFilePath = path9.posix.join(
       sharedTarget.layout.rootDir,
@@ -3251,7 +3096,8 @@ async function createRuntime2(request, inputParts) {
       );
       inputItems2.push(...buildCodexSkillInputItems(preparedSkills2));
       const transport = await connectRemoteCodexAppServer(
-        toRemoteCodexWebSocketUrl(previewUrl)
+        toRemoteCodexWebSocketUrl(previewUrl),
+        sandbox.previewHeaders
       );
       return {
         source: transport.source,
@@ -3349,6 +3195,10 @@ async function createRuntime2(request, inputParts) {
     );
   }
   configArgs.push("-c", `features.multi_agent=${enableMultiAgent}`);
+  const openAiBaseUrl = resolveCodexOpenAiBaseUrl(request);
+  if (openAiBaseUrl) {
+    configArgs.push("-c", `openai_base_url=${JSON.stringify(openAiBaseUrl)}`);
+  }
   const textPrompt = joinTextParts(
     inputParts.filter(
       (part) => part.type === "text"
@@ -3447,7 +3297,6 @@ var CodexAgentAdapter = class {
     );
     const runtime = await createRuntime2(request, inputParts);
     sink.setRaw(runtime.raw);
-    sink.setAbort(runtime.cleanup);
     sink.emitEvent(
       createNormalizedEvent("run.started", {
         provider: request.provider,
@@ -3462,6 +3311,28 @@ var CodexAgentAdapter = class {
     let rootThreadId;
     let turnId;
     let pendingTurns = 1;
+    sink.setAbort(async () => {
+      const threadIdAtAbort = rootThreadId;
+      const turnIdAtAbort = turnId;
+      if (threadIdAtAbort && turnIdAtAbort) {
+        try {
+          await Promise.race([
+            client.request("turn/interrupt", {
+              threadId: threadIdAtAbort,
+              turnId: turnIdAtAbort
+            }),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new Error("codex turn/interrupt timed out")),
+                3e3
+              )
+            )
+          ]);
+        } catch {
+        }
+      }
+      await runtime.cleanup().catch(() => void 0);
+    });
     const sendTurn = async (content) => {
       if (!rootThreadId) {
         throw new Error("Cannot send message before thread is started.");
@@ -3598,7 +3469,7 @@ var SANDBOX_OPENCODE_READY_TIMEOUT_MS = 9e4;
 var SHARED_OPENCODE_TARGET_ID = "shared-opencode-server";
 function toRawEvent3(runId, payload, type) {
   return {
-    provider: "opencode",
+    provider: AgentProvider.OpenCode,
     runId,
     type,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3725,6 +3596,7 @@ async function ensureSandboxOpenCodeServer(request) {
   const options = request.options;
   const port = SANDBOX_OPENCODE_PORT;
   await sandbox.openPort(port);
+  const previewHeaders = sandbox.previewHeaders;
   const healthCheck = await sandbox.run(
     `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
     { cwd: options.cwd, timeoutMs: 5e3 }
@@ -3733,6 +3605,7 @@ async function ensureSandboxOpenCodeServer(request) {
     const baseUrl2 = (await sandbox.getPreviewLink(port)).replace(/\/$/, "");
     return {
       baseUrl: baseUrl2,
+      previewHeaders,
       cleanup: async () => {
       },
       raw: { baseUrl: baseUrl2, port, reused: true }
@@ -3806,12 +3679,29 @@ async function ensureSandboxOpenCodeServer(request) {
       `Could not start OpenCode server: ${launchResult.combinedOutput || launchResult.stderr}`
     );
   }
+  const readyDeadline = Date.now() + SANDBOX_OPENCODE_READY_TIMEOUT_MS;
+  let ready = false;
+  while (Date.now() < readyDeadline) {
+    const probe = await sandbox.run(
+      `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
+      { cwd: options.cwd, timeoutMs: 5e3 }
+    );
+    if (probe.exitCode === 0) {
+      ready = true;
+      break;
+    }
+    await sleep(500);
+  }
+  if (!ready) {
+    await target.cleanup().catch(() => void 0);
+    throw new Error(
+      `OpenCode server did not become ready within ${SANDBOX_OPENCODE_READY_TIMEOUT_MS}ms.`
+    );
+  }
   const baseUrl = (await sandbox.getPreviewLink(port)).replace(/\/$/, "");
-  await waitForHttpReady(`${baseUrl}/global/health`, {
-    timeoutMs: SANDBOX_OPENCODE_READY_TIMEOUT_MS
-  });
   return {
     baseUrl,
+    previewHeaders,
     cleanup: async () => {
       await target.cleanup().catch(() => void 0);
     },
@@ -3874,6 +3764,7 @@ async function createLocalRuntime2(request) {
   await waitForHttpReady(`${baseUrl}/global/health`, { timeoutMs: 2e4 });
   return {
     baseUrl,
+    previewHeaders: {},
     cleanup: async () => {
       await processHandle.kill();
       await target.cleanup();
@@ -3893,9 +3784,41 @@ var OpenCodeAgentAdapter = class {
       request.provider,
       request.run.input
     );
+    let pendingMessages = 0;
+    let finalText = "";
+    let dispatchError;
+    let resolveAllDone;
+    const allDone = new Promise((resolve) => {
+      resolveAllDone = resolve;
+    });
+    const checkDone = () => {
+      if (pendingMessages === 0) {
+        resolveAllDone();
+      }
+    };
+    let sendToSession;
+    const queuedParts = [];
+    sink.onMessage(async (content) => {
+      pendingMessages++;
+      try {
+        const parts = await validateProviderUserInput(request.provider, content);
+        const mapped = mapToOpenCodeParts(parts);
+        if (sendToSession) {
+          sendToSession(mapped);
+        } else {
+          queuedParts.push(mapped);
+        }
+      } catch (error) {
+        pendingMessages--;
+        if (!dispatchError) {
+          dispatchError = error;
+        }
+        checkDone();
+        throw error;
+      }
+    });
     const runtime = await createRuntime3(request);
     sink.setRaw(runtime.raw);
-    sink.setAbort(runtime.cleanup);
     sink.emitEvent(
       createNormalizedEvent("run.started", {
         provider: request.provider,
@@ -3904,13 +3827,47 @@ var OpenCodeAgentAdapter = class {
     );
     const sseAbort = new AbortController();
     let sseTask;
+    const dispatchAbort = new AbortController();
+    let capturedSessionId;
+    sink.setAbort(async () => {
+      const sessionIdAtAbort = capturedSessionId;
+      if (sessionIdAtAbort) {
+        try {
+          await Promise.race([
+            fetchJson(
+              `${runtime.baseUrl}/session/${sessionIdAtAbort}/abort`,
+              {
+                method: "POST",
+                headers: {
+                  "content-type": "application/json",
+                  ...runtime.previewHeaders
+                }
+              }
+            ),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(
+                  new Error("opencode POST /session/abort timed out")
+                ),
+                3e3
+              )
+            )
+          ]);
+        } catch {
+        }
+      }
+      dispatchAbort.abort();
+    });
     try {
       const interactiveApproval = isInteractiveApproval(request.options);
       const createdSession = request.run.resumeSessionId ? null : await fetchJson(
         `${runtime.baseUrl}/session`,
         {
           method: "POST",
-          headers: { "content-type": "application/json" },
+          headers: {
+            "content-type": "application/json",
+            ...runtime.previewHeaders
+          },
           body: JSON.stringify({
             title: `AgentBox ${request.runId}`
           })
@@ -3923,6 +3880,7 @@ var OpenCodeAgentAdapter = class {
       sseTask = (async () => {
         try {
           for await (const event of streamSse(`${runtime.baseUrl}/event`, {
+            headers: runtime.previewHeaders,
             signal: sseAbort.signal
           })) {
             let payload = event.data;
@@ -3945,7 +3903,7 @@ var OpenCodeAgentAdapter = class {
                   raw,
                   payload
                 );
-                const response2 = interactiveApproval ? await sink.requestPermission(permissionEvent) : {
+                const response = interactiveApproval ? await sink.requestPermission(permissionEvent) : {
                   requestId: permissionEvent.requestId,
                   decision: "allow"
                 };
@@ -3953,9 +3911,12 @@ var OpenCodeAgentAdapter = class {
                   `${runtime.baseUrl}/session/${sessionId}/permissions/${permissionEvent.requestId}`,
                   {
                     method: "POST",
-                    headers: { "content-type": "application/json" },
+                    headers: {
+                      "content-type": "application/json",
+                      ...runtime.previewHeaders
+                    },
                     body: JSON.stringify({
-                      response: response2.decision === "allow" ? response2.remember ? "always" : "once" : "reject"
+                      response: response.decision === "allow" ? response.remember ? "always" : "once" : "reject"
                     })
                   }
                 );
@@ -3969,11 +3930,7 @@ var OpenCodeAgentAdapter = class {
         } catch {
         }
       })();
-      sink.onMessage(async () => {
-        console.warn(
-          "[agentbox] sendMessage is not yet supported for the opencode provider. Use resumeSessionId for follow-ups instead."
-        );
-      });
+      capturedSessionId = sessionId;
       sink.setSessionId(sessionId);
       sink.emitRaw(
         toRawEvent3(
@@ -3988,39 +3945,67 @@ var OpenCodeAgentAdapter = class {
           runId: request.runId
         })
       );
-      const response = await fetchJson(
-        `${runtime.baseUrl}/session/${sessionId}/message`,
-        {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            ...request.run.model ? { model: toOpenCodeModel(request.run.model) } : {},
-            agent: "agentbox",
-            parts: mapToOpenCodeParts(inputParts)
-          })
+      const dispatchMessage = async (parts) => {
+        try {
+          const response = await fetchJson(
+            `${runtime.baseUrl}/session/${sessionId}/message`,
+            {
+              method: "POST",
+              signal: dispatchAbort.signal,
+              headers: {
+                "content-type": "application/json",
+                ...runtime.previewHeaders
+              },
+              body: JSON.stringify({
+                ...request.run.model ? { model: toOpenCodeModel(request.run.model) } : {},
+                agent: "agentbox",
+                parts
+              })
+            }
+          );
+          const rawResponse = toRawEvent3(
+            request.runId,
+            response,
+            "message.response"
+          );
+          sink.emitRaw(rawResponse);
+          for (const event of normalizeRawAgentEvent(rawResponse)) {
+            sink.emitEvent(event);
+          }
+          const text = extractText(response);
+          if (text) {
+            finalText = text;
+            sink.emitEvent(
+              createNormalizedEvent(
+                "text.delta",
+                {
+                  provider: request.provider,
+                  runId: request.runId
+                },
+                { delta: text }
+              )
+            );
+          }
+        } catch (error) {
+          if (!dispatchError) {
+            dispatchError = error;
+          }
+        } finally {
+          pendingMessages--;
+          checkDone();
         }
-      );
-      const rawResponse = toRawEvent3(
-        request.runId,
-        response,
-        "message.response"
-      );
-      sink.emitRaw(rawResponse);
-      for (const event of normalizeRawAgentEvent(rawResponse)) {
-        sink.emitEvent(event);
+      };
+      sendToSession = (parts) => {
+        void dispatchMessage(parts);
+      };
+      for (const queued of queuedParts.splice(0)) {
+        sendToSession(queued);
       }
-      const text = extractText(response);
-      if (text) {
-        sink.emitEvent(
-          createNormalizedEvent(
-            "text.delta",
-            {
-              provider: request.provider,
-              runId: request.runId
-            },
-            { delta: text }
-          )
-        );
+      pendingMessages++;
+      void dispatchMessage(mapToOpenCodeParts(inputParts));
+      await allDone;
+      if (dispatchError) {
+        throw dispatchError;
       }
       sink.emitEvent(
         createNormalizedEvent(
@@ -4029,12 +4014,12 @@ var OpenCodeAgentAdapter = class {
             provider: request.provider,
             runId: request.runId
           },
-          { text }
+          { text: finalText }
         )
       );
       sseAbort.abort();
       await sseTask;
-      sink.complete({ text });
+      sink.complete({ text: finalText });
     } finally {
       sseAbort.abort();
       if (sseTask) {
@@ -4097,21 +4082,20 @@ function buildRunConfig(options, runConfig) {
 }
 function createAdapter(provider) {
   switch (provider) {
-    case "codex":
+    case AgentProvider.Codex:
       return new CodexAgentAdapter();
-    case "opencode":
+    case AgentProvider.OpenCode:
       return new OpenCodeAgentAdapter();
-    case "claude-code":
+    case AgentProvider.ClaudeCode:
       return new ClaudeCodeAgentAdapter();
     default:
       throw new UnsupportedProviderError("agent", provider);
   }
 }
 function prepareAgentOptions(provider, options) {
-  if (provider === "opencode") {
-    const openCodeOptions = options;
-    const port = 4096;
-    openCodeOptions.sandbox?.openPort(port);
+  const ports = AGENT_RESERVED_PORTS[provider] ?? [];
+  for (const port of ports) {
+    void options.sandbox?.openPort(port);
   }
   return options;
 }