agentbox-sdk 0.1.302 → 0.1.304

package/dist/{chunk-YAMFJAU6.js → chunk-T7C77LCW.js}

@@ -2,7 +2,7 @@ import {
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKStream
-} from "./chunk-NWAXQ7UD.js";
+} from "./chunk-EK6GC6YA.js";
 import {
   AgentBoxError,
   AsyncQueue,
@@ -998,6 +998,28 @@ var HostSetupTarget = class {
       }
     );
   }
+  async probe(command, extraEnv) {
+    return time(
+      debugRuntime,
+      `host probe ${shortLabel(command)}`,
+      async () => {
+        const handle = spawnCommand({
+          command: process.env.SHELL || "sh",
+          args: ["-c", command],
+          cwd: this.cwd,
+          env: {
+            ...process.env,
+            ...this.baseEnv,
+            ...this.env,
+            ...extraEnv ?? {}
+          }
+        });
+        const exitCode = await handle.wait();
+        return exitCode === 0;
+      },
+      (ok) => ({ ok })
+    );
+  }
   async cleanup() {
     await rm(this.layout.rootDir, { recursive: true, force: true });
   }
@@ -1052,13 +1074,34 @@ var SandboxSetupTarget = class {
           }
         });
         if (result && result.exitCode !== 0) {
+          const output = result.combinedOutput?.trim();
+          const detail = output ? `
+${output}` : "";
           throw new Error(
-            `Sandbox setup command failed (${result.exitCode}): ${command}`
+            `Sandbox setup command failed (${result.exitCode}): ${command}${detail}`
           );
         }
       }
     );
   }
+  async probe(command, extraEnv) {
+    return time(
+      debugRuntime,
+      `sandbox probe ${shortLabel(command)}`,
+      async () => {
+        const result = await this.options.sandbox?.run(command, {
+          cwd: this.options.cwd,
+          env: {
+            ...this.options.env ?? {},
+            ...this.env,
+            ...extraEnv ?? {}
+          }
+        });
+        return Boolean(result && result.exitCode === 0);
+      },
+      (ok) => ({ ok })
+    );
+  }
   async cleanup() {
   }
 };
@@ -1092,6 +1135,7 @@ import path5 from "path";
 var MANIFEST_FILENAME = "setup-manifest.json";
 var TARGET_MANIFEST_FILENAME = "setup-target.json";
 var INSTALL_SCRIPT_FILENAME = "install.sh";
+var SETUP_ID_FILENAME = "setup.id";
 var MANIFEST_VERSION = 1;
 function hashArtifact(artifact) {
   const hasher = createHash("sha256");
@@ -1110,6 +1154,74 @@ function computeTargetArtifacts(artifacts) {
   }
   return result;
 }
+function computeSetupId(parts) {
+  const hasher = createHash("sha256");
+  hasher.update(`v${MANIFEST_VERSION}
+`);
+  for (const a of [...parts.artifacts ?? []].sort(
+    (x, y) => x.path.localeCompare(y.path)
+  )) {
+    hasher.update(`a:${a.path}:${hashArtifact(a)}
+`);
+  }
+  for (const cmd of parts.installCommands ?? []) {
+    hasher.update(`c:${hashCommand(cmd)}
+`);
+  }
+  if (parts.daemon) {
+    hasher.update(
+      `d:${parts.daemon.port}:${parts.daemon.healthPath}:${parts.daemon.expectedVersionMatch ?? ""}
+`
+    );
+  }
+  for (const extra of parts.extras ?? []) {
+    hasher.update(`x:${extra}
+`);
+  }
+  return hasher.digest("hex");
+}
+async function preflightSetup(target, setupId, daemon) {
+  return time(
+    debugSetup,
+    `preflightSetup ${target.provider}`,
+    async () => {
+      const setupIdFile = path5.posix.join(
+        target.layout.rootDir,
+        SETUP_ID_FILENAME
+      );
+      const checks = [
+        `[ -f ${shellQuote(setupIdFile)} ]`,
+        `[ "$(cat ${shellQuote(setupIdFile)} 2>/dev/null)" = ${shellQuote(setupId)} ]`
+      ];
+      if (daemon) {
+        const url = `http://127.0.0.1:${daemon.port}${daemon.healthPath}`;
+        if (daemon.expectedVersionMatch) {
+          checks.push(
+            `curl -fsS --max-time 2 ${shellQuote(url)} 2>/dev/null | grep -q ${shellQuote(daemon.expectedVersionMatch)}`
+          );
+        } else {
+          checks.push(
+            `curl -fsS --max-time 2 ${shellQuote(url)} >/dev/null 2>&1`
+          );
+        }
+      }
+      return target.probe(checks.join(" && "));
+    },
+    (ok) => ({ ok })
+  );
+}
+async function markSetupComplete(target, setupId) {
+  await time(
+    debugSetup,
+    `markSetupComplete ${target.provider}`,
+    () => target.runCommand(
+      [
+        `mkdir -p ${shellQuote(target.layout.rootDir)}`,
+        `printf '%s' ${shellQuote(setupId)} > ${shellQuote(path5.posix.join(target.layout.rootDir, SETUP_ID_FILENAME))}`
+      ].join(" && ")
+    )
+  );
+}
 function buildInstallScript(rootDir, installCommandsByKey) {
   const commandsB64 = Buffer.from(
     JSON.stringify(installCommandsByKey),
@@ -1935,6 +2047,11 @@ var ClaudeCodeAgentAdapter = class {
   /**
    * Sandbox-side preparation. Uploads `.claude/` artifacts and ensures
    * the daemon is running. `execute()` then dials the daemon directly.
+   *
+   * Warm-path short-circuit: a single no-upload `preflightSetup` probes
+   * the `setup.id` marker + daemon `/__version` on loopback. If both
+   * match what we'd produce, we skip the artifact upload AND the daemon
+   * boot entirely.
    */
   async setup(request) {
     await time(debugClaude, "claude-code setup()", async () => {
@@ -1968,6 +2085,20 @@ var ClaudeCodeAgentAdapter = class {
         { path: settingsPath, content: JSON.stringify(hookSettings, null, 2) },
         { path: mcpConfigPath, content: mcpConfigJson }
       ];
+      const daemonInfo = {
+        port: DAEMON_PORT,
+        healthPath: "/__version",
+        expectedVersionMatch: DAEMON_PROTOCOL_VERSION
+      };
+      const setupId = computeSetupId({
+        artifacts,
+        installCommands,
+        daemon: daemonInfo
+      });
+      if (await preflightSetup(target, setupId, daemonInfo)) {
+        debugClaude("claude-code setup() preflight hit \u2014 skipping");
+        return;
+      }
       const env = { ...options.env ?? {}, ...target.env };
       await Promise.all([
         time(
@@ -1977,6 +2108,7 @@ var ClaudeCodeAgentAdapter = class {
         ),
         ensureClaudeCodeDaemon(options, env)
       ]);
+      await markSetupComplete(target, setupId);
     });
   }
   async execute(request, sink) {
@@ -2372,6 +2504,31 @@ async function* streamSse(url, init) {
   })();
   yield* queue;
 }
+async function* streamSseResilient(url, init) {
+  let lastEventId;
+  let attempt = 0;
+  const signal = init?.signal;
+  while (true) {
+    try {
+      const headers = {
+        ...init?.headers ?? {},
+        ...lastEventId ? { "Last-Event-ID": lastEventId } : {}
+      };
+      for await (const ev of streamSse(url, { ...init, headers })) {
+        attempt = 0;
+        if (ev.id) lastEventId = ev.id;
+        yield ev;
+      }
+      return;
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      const delay = Math.min(500 * Math.pow(2, attempt), 5e3);
+      attempt++;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (signal?.aborted) throw err;
+    }
+  }
+}
 async function connectJsonRpcWebSocket(url, options) {
   const notifications = new AsyncQueue();
   const socket = new WebSocket(url, { headers: options?.headers });
@@ -2819,7 +2976,12 @@ async function ensureCodexLoginViaConfig(request, target) {
     [
       'if [ -z "${OPENAI_API_KEY:-}" ]; then exit 0; fi',
       'mkdir -p "${CODEX_HOME:-$HOME/.codex}"',
-      "printenv OPENAI_API_KEY | env -u XDG_CONFIG_HOME codex login --with-api-key"
+      // Merge stderr into stdout so providers that don't surface stderr
+      // (e.g. Daytona's `executeCommand`, which collapses to a single
+      // `result` field) still propagate the underlying error message
+      // back to the caller — otherwise a failed login leaves us with a
+      // bare "exit 1" and no diagnostic.
+      "printenv OPENAI_API_KEY | env -u XDG_CONFIG_HOME codex login --with-api-key 2>&1"
     ].join("; "),
     Object.keys(extraEnv).length > 0 ? extraEnv : void 0
   );
@@ -2925,12 +3087,26 @@ async function setupCodex(request) {
       ...sharedTarget.env,
       ...options.provider?.env ?? {}
     });
+    const { artifacts: serverArtifacts } = buildArtifactsFor(sharedTarget);
+    const { artifacts: skillArtifacts2, installCommands: installCommands2 } = await prepareSkillArtifacts(provider, options.skills, target2.layout);
+    const daemonInfo = {
+      port: REMOTE_CODEX_APP_SERVER_PORT,
+      healthPath: "/readyz"
+    };
+    const setupId2 = computeSetupId({
+      artifacts: [...serverArtifacts, ...skillArtifacts2],
+      installCommands: installCommands2,
+      daemon: daemonInfo
+    });
+    if (await preflightSetup(sharedTarget, setupId2, daemonInfo)) {
+      debugCodex("codex remote setup() preflight hit \u2014 skipping");
+      return;
+    }
     await time(
       debugCodex,
       "ensureCodexLogin",
       () => ensureCodexLoginViaConfig(request, sharedTarget)
     );
-    const { artifacts: serverArtifacts } = buildArtifactsFor(sharedTarget);
     await applyDifferentialSetup(sharedTarget, serverArtifacts, []);
     const binary = options.provider?.binary ?? "codex";
     const pidFilePath = path9.posix.join(
@@ -2978,28 +3154,34 @@ async function setupCodex(request) {
       );
     }
     try {
-      const { artifacts: skillArtifacts2, installCommands: installCommands2 } = await prepareSkillArtifacts(provider, options.skills, target2.layout);
       await applyDifferentialSetup(target2, skillArtifacts2, installCommands2);
     } catch (error) {
       await target2.cleanup().catch(() => void 0);
       throw error;
     }
+    await markSetupComplete(sharedTarget, setupId2);
     return;
   }
   const target = await createSetupTarget(provider, "shared-setup", options);
+  const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(provider, options.skills, target.layout);
+  const { artifacts: configArtifacts } = buildArtifactsFor(target);
+  const allArtifacts = [...skillArtifacts, ...configArtifacts];
+  const setupId = computeSetupId({
+    artifacts: allArtifacts,
+    installCommands
+  });
+  if (await preflightSetup(target, setupId)) {
+    debugCodex("codex local setup() preflight hit \u2014 skipping");
+    return;
+  }
   try {
     await ensureCodexLoginViaConfig(request, target);
   } catch (error) {
     await target.cleanup().catch(() => void 0);
     throw error;
   }
-  const { artifacts: skillArtifacts, installCommands } = await prepareSkillArtifacts(provider, options.skills, target.layout);
-  const { artifacts: configArtifacts } = buildArtifactsFor(target);
-  await applyDifferentialSetup(
-    target,
-    [...skillArtifacts, ...configArtifacts],
-    installCommands
-  );
+  await applyDifferentialSetup(target, allArtifacts, installCommands);
+  await markSetupComplete(target, setupId);
 }
 async function createRuntime(request, inputParts) {
   const options = request.options;
@@ -3383,7 +3565,7 @@ var CodexAgentAdapter = class {
             Date.now() - executeStartedAt,
             text?.length ?? 0
           );
-          sink.complete({ text, costData: extractCodexCostData(rawPayloads) });
+          sink.complete({ costData: extractCodexCostData(rawPayloads) });
         }
       }
     } finally {
@@ -3481,73 +3663,6 @@ function toRawEvent3(runId, payload, type) {
     payload
   };
 }
-function extractText(value) {
-  if (!value) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(extractText).filter(Boolean).join("");
-  }
-  if (typeof value === "object") {
-    const record = value;
-    if (record.type === "text" && typeof record.text === "string") {
-      return record.text;
-    }
-    if (record.type === "reasoning") {
-      return "";
-    }
-    if (record.message) {
-      return extractText(record.message);
-    }
-    if (record.content) {
-      return extractText(record.content);
-    }
-    if (record.parts) {
-      return extractText(record.parts);
-    }
-    if (record.text) {
-      return extractText(record.text);
-    }
-  }
-  return "";
-}
-function extractAssistantMessageId(response) {
-  if (!response || typeof response !== "object") {
-    return void 0;
-  }
-  const record = response;
-  const info = record.info && typeof record.info === "object" ? record.info : record.message && typeof record.message === "object" ? record.message : void 0;
-  const id = info?.id ?? record.id;
-  return typeof id === "string" ? id : void 0;
-}
-function extractReasoning(value) {
-  if (!value) {
-    return "";
-  }
-  if (Array.isArray(value)) {
-    return value.map(extractReasoning).filter(Boolean).join("");
-  }
-  if (typeof value === "object") {
-    const record = value;
-    if (record.type === "reasoning") {
-      if (typeof record.text === "string") {
-        return record.text;
-      }
-      if (typeof record.reasoning === "string") {
-        return record.reasoning;
-      }
-    }
-    return [
-      extractReasoning(record.message),
-      extractReasoning(record.content),
-      extractReasoning(record.parts)
-    ].filter(Boolean).join("");
-  }
-  return "";
-}
 function toOpenCodeModel(model) {
   if (!model) {
     return void 0;
@@ -3609,12 +3724,19 @@ var OPEN_CODE_REASONING_LEVELS = ["low", "medium", "high", "xhigh"];
 function openCodeAgentSlug(reasoning) {
   return reasoning ? `agentbox-${reasoning}` : "agentbox";
 }
-function buildOpenCodeConfig(options, systemPrompt, interactiveApproval) {
+function buildOpenCodeConfig(options, interactiveApproval) {
   const mcpConfig = buildOpenCodeMcpConfig(options.mcps);
   const commandsConfig = buildOpenCodeCommandsConfig(options.commands);
   const baseAgent = {
     mode: "primary",
-    prompt: systemPrompt,
+    // Suppress opencode's default provider system prompt (e.g.
+    // PROMPT_ANTHROPIC's "You are OpenCode...") so request.run.systemPrompt
+    // is the dominant identity statement the model sees. opencode's
+    // session/llm.ts uses agent.prompt instead of SystemPrompt.provider(model)
+    // when this field is truthy — codex already takes that branch via a
+    // separate options.instructions channel, so this brings anthropic et al.
+    // in line. Constant value, so setupId stays stable.
+    prompt: "You are an AI coding assistant. Follow the user's instructions.",
     permission: buildOpenCodePermissionConfig(interactiveApproval),
     tools: {
       write: true,
@@ -3651,19 +3773,6 @@ async function ensureSandboxOpenCodeServer(request) {
     const sandbox = request.options.sandbox;
     const options = request.options;
     const port = SANDBOX_OPENCODE_PORT;
-    const healthCheck = await time(
-      debugOpencode,
-      "health probe (warm path)",
-      () => sandbox.run(
-        `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
-        { cwd: options.cwd, timeoutMs: 5e3 }
-      )
-    );
-    if (healthCheck.exitCode === 0) {
-      debugOpencode("opencode server already running \u2014 reusing");
-      return;
-    }
-    debugOpencode("opencode server not running \u2014 cold-spawning");
     const plugins = assertHooksSupported(request.provider, options);
     assertCommandsSupported(request.provider, options.commands);
     const interactiveApproval = isInteractiveApproval(options);
@@ -3684,26 +3793,32 @@ async function ensureSandboxOpenCodeServer(request) {
     const configPath = path10.join(target.layout.opencodeDir, "agentbox.json");
     const openCodeConfig = buildOpenCodeConfig(
       options,
-      request.config.systemPrompt ?? "",
       interactiveApproval
     );
+    const allArtifacts = [
+      ...skillArtifacts,
+      ...pluginArtifacts,
+      {
+        path: configPath,
+        content: JSON.stringify(openCodeConfig, null, 2)
+      }
+    ];
+    const daemonInfo = { port, healthPath: "/global/health" };
+    const setupId = computeSetupId({
+      artifacts: allArtifacts,
+      installCommands,
+      daemon: daemonInfo
+    });
+    if (await preflightSetup(target, setupId, daemonInfo)) {
+      debugOpencode("opencode setup() preflight hit \u2014 skipping");
+      return;
+    }
     const commonEnv = {
       OPENCODE_CONFIG: configPath,
       OPENCODE_CONFIG_DIR: target.layout.opencodeDir,
       OPENCODE_DISABLE_DEFAULT_PLUGINS: "true"
     };
-    await applyDifferentialSetup(
-      target,
-      [
-        ...skillArtifacts,
-        ...pluginArtifacts,
-        {
-          path: configPath,
-          content: JSON.stringify(openCodeConfig, null, 2)
-        }
-      ],
-      installCommands
-    );
+    await applyDifferentialSetup(target, allArtifacts, installCommands);
     const binary = options.provider?.binary ?? "opencode";
     const pidFilePath = path10.posix.join(
       target.layout.rootDir,
@@ -3766,6 +3881,7 @@ async function ensureSandboxOpenCodeServer(request) {
         `OpenCode server did not become ready within ${SANDBOX_OPENCODE_READY_TIMEOUT_MS}ms.`
       );
     });
+    await markSetupComplete(target, setupId);
   });
 }
 async function ensureLocalOpenCodeServer(request) {
@@ -3798,28 +3914,28 @@ async function ensureLocalOpenCodeServer(request) {
     target.layout.opencodeDir
   );
   const configPath = path10.join(target.layout.opencodeDir, "agentbox.json");
-  const openCodeConfig = buildOpenCodeConfig(
-    options,
-    request.config.systemPrompt ?? "",
-    interactiveApproval
-  );
+  const openCodeConfig = buildOpenCodeConfig(options, interactiveApproval);
   const commonEnv = {
     OPENCODE_CONFIG: configPath,
     OPENCODE_CONFIG_DIR: target.layout.opencodeDir,
     OPENCODE_DISABLE_DEFAULT_PLUGINS: "true"
   };
-  await applyDifferentialSetup(
-    target,
-    [
-      ...skillArtifacts,
-      ...pluginArtifacts,
-      {
-        path: configPath,
-        content: JSON.stringify(openCodeConfig, null, 2)
-      }
-    ],
+  const allArtifacts = [
+    ...skillArtifacts,
+    ...pluginArtifacts,
+    {
+      path: configPath,
+      content: JSON.stringify(openCodeConfig, null, 2)
+    }
+  ];
+  const setupId = computeSetupId({
+    artifacts: allArtifacts,
     installCommands
-  );
+  });
+  const preflightHit = await preflightSetup(target, setupId);
+  if (!preflightHit) {
+    await applyDifferentialSetup(target, allArtifacts, installCommands);
+  }
   spawnCommand({
     command: options.provider?.binary ?? "opencode",
     args: [
@@ -3841,6 +3957,7 @@ async function ensureLocalOpenCodeServer(request) {
     `http://127.0.0.1:${LOCAL_OPENCODE_PORT}/global/health`,
     { timeoutMs: LOCAL_OPENCODE_READY_TIMEOUT_MS }
   );
+  await markSetupComplete(target, setupId);
 }
 async function setupOpenCode(request) {
   if (request.options.sandbox) {
@@ -3878,25 +3995,14 @@ var OpenCodeAgentAdapter = class {
       "validateProviderUserInput",
       () => validateProviderUserInput(request.provider, request.run.input)
     );
-    let pendingMessages = 0;
-    let finalText = "";
     let streamedTextFromSse = "";
-    const settledMessageIds = /* @__PURE__ */ new Set();
+    const assistantTextByMessageId = /* @__PURE__ */ new Map();
+    const announcedAssistantCompletions = /* @__PURE__ */ new Set();
     let dispatchError;
     let firstSseEventLogged = false;
-    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,
@@ -3909,11 +4015,10 @@ var OpenCodeAgentAdapter = class {
           queuedParts.push(mapped);
         }
       } catch (error) {
-        pendingMessages--;
         if (!dispatchError) {
           dispatchError = error;
         }
-        checkDone();
+        resolveSessionTerminal();
         throw error;
       }
     });
@@ -3932,10 +4037,15 @@ var OpenCodeAgentAdapter = class {
     const rawPayloads = [];
     const sseAbort = new AbortController();
     let sseTask;
-    const dispatchAbort = new AbortController();
     let capturedSessionId;
     let sessionErrorFromSse;
     let sessionAbortedFromSse = false;
+    let sessionIdleFromSse = false;
+    let resolveSessionTerminal;
+    const sessionTerminal = new Promise((resolve) => {
+      resolveSessionTerminal = resolve;
+    });
+    let lastSseActivityAt = Date.now();
     let userAbortRequested = false;
     sink.setAbort(async () => {
       userAbortRequested = true;
@@ -3963,7 +4073,7 @@ var OpenCodeAgentAdapter = class {
         } catch {
         }
       }
-      dispatchAbort.abort();
+      resolveSessionTerminal();
     });
     try {
       const interactiveApproval = isInteractiveApproval(request.options);
@@ -4004,10 +4114,14 @@ var OpenCodeAgentAdapter = class {
       const foreignMessageIds = /* @__PURE__ */ new Set();
       sseTask = (async () => {
         try {
-          for await (const event of streamSse(`${runtime.baseUrl}/event`, {
-            headers: runtime.previewHeaders,
-            signal: sseAbort.signal
-          })) {
+          for await (const event of streamSseResilient(
+            `${runtime.baseUrl}/event`,
+            {
+              headers: runtime.previewHeaders,
+              signal: sseAbort.signal
+            }
+          )) {
+            lastSseActivityAt = Date.now();
             if (!firstSseEventLogged) {
               firstSseEventLogged = true;
               debugOpencode(
@@ -4050,6 +4164,22 @@ var OpenCodeAgentAdapter = class {
                       { messageId: info.id }
                     )
                   );
+                } else if (info.role === "assistant" && !announcedAssistantCompletions.has(info.id)) {
+                  const time2 = info.time;
+                  if (typeof time2?.completed === "number") {
+                    announcedAssistantCompletions.add(info.id);
+                    sink.emitEvent(
+                      createNormalizedEvent(
+                        "message.completed",
+                        {
+                          provider: request.provider,
+                          runId: request.runId,
+                          raw
+                        },
+                        { text: assistantTextByMessageId.get(info.id) ?? "" }
+                      )
+                    );
+                  }
                 }
               }
             }
@@ -4082,7 +4212,7 @@ var OpenCodeAgentAdapter = class {
               continue;
             }
             const payloadRecord = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
-            if ((payloadRecord?.type === "session.idle" || payloadRecord?.type === "session.error") && !dispatchAbort.signal.aborted) {
+            if (payloadRecord?.type === "session.idle" || payloadRecord?.type === "session.error") {
               const properties = payloadRecord.properties;
               const eventSessionId = typeof properties?.sessionID === "string" ? properties.sessionID : void 0;
               if (!eventSessionId || eventSessionId === sessionId) {
@@ -4094,13 +4224,28 @@ var OpenCodeAgentAdapter = class {
                     const errMsg = typeof errData?.data?.message === "string" ? errData.data.message : typeof errData?.message === "string" ? errData.message : "OpenCode session error";
                     sessionErrorFromSse = new Error(errMsg);
                   }
+                } else {
+                  sessionIdleFromSse = true;
                 }
                 debugOpencode(
-                  "\u2605 %s for session=%s \u2014 aborting in-flight dispatch",
+                  "\u2605 %s for session=%s",
                   payloadRecord.type,
                   sessionId
                 );
-                dispatchAbort.abort();
+                resolveSessionTerminal();
+              }
+            }
+            if (payloadRecord?.type === "session.status") {
+              const properties = payloadRecord.properties;
+              const status = properties?.status;
+              const eventSessionId = typeof properties?.sessionID === "string" ? properties.sessionID : void 0;
+              if ((!eventSessionId || eventSessionId === sessionId) && status?.type === "idle") {
+                sessionIdleFromSse = true;
+                debugOpencode(
+                  "\u2605 session.status{idle} for session=%s",
+                  sessionId
+                );
+                resolveSessionTerminal();
               }
             }
             if (payloadRecord?.type === "message.part.delta") {
@@ -4111,12 +4256,15 @@ var OpenCodeAgentAdapter = class {
               if (isForeignSession) {
                 continue;
               }
-              if (eventMessageId !== void 0 && settledMessageIds.has(eventMessageId)) {
-                continue;
-              }
               const delta = typeof properties?.delta === "string" ? properties.delta : "";
               if (delta && properties?.field === "text") {
                 streamedTextFromSse += delta;
+                if (eventMessageId) {
+                  assistantTextByMessageId.set(
+                    eventMessageId,
+                    (assistantTextByMessageId.get(eventMessageId) ?? "") + delta
+                  );
+                }
                 sink.emitEvent(
                   createNormalizedEvent(
                     "text.delta",
@@ -4169,126 +4317,131 @@ var OpenCodeAgentAdapter = class {
         })
       );
       const agentSlug = openCodeAgentSlug(request.run.reasoning);
-      const dispatchMessage = async (parts) => {
-        const sseTextLengthBeforeDispatch = streamedTextFromSse.length;
-        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: agentSlug,
-                parts
-              })
+      const dispatchPrompt = async (parts) => {
+        const body = JSON.stringify({
+          ...request.run.model ? { model: toOpenCodeModel(request.run.model) } : {},
+          // Per-message system prompt — keeps systemPrompt out of
+          // the on-disk agent config so changing it doesn't
+          // invalidate setupId. Sent on every dispatch (the field
+          // is per-message, not session-sticky).
+          ...request.run.systemPrompt ? { system: request.run.systemPrompt } : {},
+          agent: agentSlug,
+          parts
+        });
+        const url = `${runtime.baseUrl}/session/${sessionId}/prompt_async`;
+        const attempt = async () => {
+          return fetch(url, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              ...runtime.previewHeaders
+            },
+            body
+          });
+        };
+        let lastError;
+        for (let i = 0; i < 2; i++) {
+          try {
+            const response = await attempt();
+            if (response.ok || response.status === 204) {
+              return;
             }
-          );
-          const rawResponse = toRawEvent3(
-            request.runId,
-            response,
-            "message.response"
-          );
-          if (response && typeof response === "object" && !Array.isArray(response)) {
-            rawPayloads.push(response);
-          }
-          sink.emitRaw(rawResponse);
-          for (const event of normalizeRawAgentEvent(rawResponse)) {
-            sink.emitEvent(event);
-          }
-          const reasoning = extractReasoning(response);
-          if (reasoning) {
-            sink.emitEvent(
-              createNormalizedEvent(
-                "reasoning.delta",
-                {
-                  provider: request.provider,
-                  runId: request.runId,
-                  raw: rawResponse
-                },
-                { delta: reasoning }
-              )
+            lastError = new Error(
+              `POST ${url} returned ${response.status}`
             );
+          } catch (error) {
+            lastError = error;
           }
-          const text = extractText(response);
-          if (text) {
-            finalText = text;
-            const sseTextForThisDispatch = streamedTextFromSse.slice(
-              sseTextLengthBeforeDispatch
+          if (i === 0) {
+            debugOpencode(
+              "prompt_async dispatch attempt %d failed (%s); retrying once",
+              i + 1,
+              lastError?.message ?? String(lastError)
             );
-            let missing;
-            if (text.startsWith(sseTextForThisDispatch)) {
-              missing = text.slice(sseTextForThisDispatch.length);
-            } else if (sseTextForThisDispatch.length === 0) {
-              missing = text;
-            } else {
-              missing = "";
-            }
-            if (missing.length > 0) {
-              streamedTextFromSse += missing;
-              sink.emitEvent(
-                createNormalizedEvent(
-                  "text.delta",
-                  {
-                    provider: request.provider,
-                    runId: request.runId
-                  },
-                  { delta: missing }
-                )
-              );
-            }
-            const assistantMessageId = extractAssistantMessageId(response);
-            if (assistantMessageId) {
-              settledMessageIds.add(assistantMessageId);
-            }
+            await sleep(500);
           }
-        } catch (error) {
-          if (!dispatchError) {
-            dispatchError = error;
-          }
-        } finally {
-          pendingMessages--;
-          checkDone();
         }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
       };
       sendToSession = (parts) => {
-        void dispatchMessage(parts);
+        void (async () => {
+          try {
+            await dispatchPrompt(parts);
+          } catch (error) {
+            if (!dispatchError) {
+              dispatchError = error;
+            }
+            resolveSessionTerminal();
+          }
+        })();
       };
       for (const queued of queuedParts.splice(0)) {
         sendToSession(queued);
       }
-      pendingMessages++;
-      void dispatchMessage(mapToOpenCodeParts(inputParts));
-      await allDone;
+      try {
+        await dispatchPrompt(mapToOpenCodeParts(inputParts));
+      } catch (error) {
+        if (!dispatchError) {
+          dispatchError = error;
+        }
+        resolveSessionTerminal();
+      }
+      const SSE_SILENCE_THRESHOLD_MS = 18e4;
+      const SSE_POLL_INTERVAL_MS = 5e3;
+      lastSseActivityAt = Date.now();
+      let sseSilent = false;
+      while (!sessionIdleFromSse && !sessionErrorFromSse && !sessionAbortedFromSse && !userAbortRequested && !dispatchError) {
+        const silence = Date.now() - lastSseActivityAt;
+        if (silence > SSE_SILENCE_THRESHOLD_MS) {
+          sseSilent = true;
+          debugOpencode("SSE went silent (%dms) \u2014 giving up", silence);
+          break;
+        }
+        await Promise.race([
+          sessionTerminal,
+          new Promise(
+            (resolve) => setTimeout(resolve, SSE_POLL_INTERVAL_MS)
+          )
+        ]);
+      }
+      sseAbort.abort();
+      await sseTask;
       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;
+      } else if (dispatchError) {
         sink.fail(dispatchError);
-      } else {
+      } else if (sessionIdleFromSse) {
         debugOpencode(
           "\u2605 run.completed (%dms since execute start) chars=%d",
           Date.now() - executeStartedAt,
-          finalText.length
+          streamedTextFromSse.length
         );
+        let lastAssistantText = "";
+        for (const [messageId, text] of assistantTextByMessageId) {
+          lastAssistantText = text;
+          if (!announcedAssistantCompletions.has(messageId)) {
+            announcedAssistantCompletions.add(messageId);
+            sink.emitEvent(
+              createNormalizedEvent(
+                "message.completed",
+                {
+                  provider: request.provider,
+                  runId: request.runId
+                },
+                { text }
+              )
+            );
+          }
+        }
         sink.emitEvent(
           createNormalizedEvent(
             "run.completed",
@@ -4296,15 +4449,23 @@ var OpenCodeAgentAdapter = class {
               provider: request.provider,
               runId: request.runId
             },
-            { text: finalText }
+            { text: lastAssistantText }
           )
         );
-        sseAbort.abort();
-        await sseTask;
         sink.complete({
-          text: finalText,
+          text: lastAssistantText,
           costData: extractOpenCodeCostData(rawPayloads)
         });
+      } else if (sseSilent) {
+        sink.fail(
+          new Error(
+            "opencode SSE went silent before the session reached idle"
+          )
+        );
+      } else {
+        sink.fail(
+          new Error("opencode run ended without a terminal signal")
+        );
       }
     } finally {
       sseAbort.abort();
@@ -4350,10 +4511,10 @@ var OpenCodeAgentAdapter = class {
     }
   }
   /**
-   * Stateless message injection. POST a fresh user message to
-   * `/session/:id/message` with `agent` defaulting to the build agent
-   * — opencode appends it to the running session and the originating
-   * instance picks up the new turn through its existing SSE stream.
+   * Stateless message injection. Fire-and-forget POST to
+   * `/session/:id/prompt_async` (returns 204) — opencode appends the
+   * message to the running session and the originating instance picks
+   * up the new turn through its existing SSE stream.
    */
   async attachSendMessage(request, content) {
     if (!request.sessionId) {
@@ -4367,20 +4528,21 @@ var OpenCodeAgentAdapter = class {
       content
     );
     const parts = mapToOpenCodeParts(inputParts);
-    await fetchJson(
-      `${baseUrl}/session/${request.sessionId}/message`,
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          ...request.sandbox.previewHeaders
-        },
-        body: JSON.stringify({
-          agent: openCodeAgentSlug(void 0),
-          parts
-        })
-      }
-    );
+    const url = `${baseUrl}/session/${request.sessionId}/prompt_async`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...request.sandbox.previewHeaders
+      },
+      body: JSON.stringify({
+        agent: openCodeAgentSlug(void 0),
+        parts
+      })
+    });
+    if (!response.ok && response.status !== 204) {
+      throw new Error(`POST ${url} returned ${response.status}`);
+    }
   }
 };
 
@@ -4463,6 +4625,7 @@ var AgentRunController = class {
   pendingPermissions = /* @__PURE__ */ new Map();
   messageHandler;
   text = "";
+  observedMessageCompleted = false;
   costData = null;
   settled = false;
   finished;
@@ -4513,6 +4676,9 @@ var AgentRunController = class {
       this.text += event.delta;
     } else if ((event.type === "message.completed" || event.type === "run.completed") && event.text) {
       this.text = event.text;
+      if (event.type === "message.completed") {
+        this.observedMessageCompleted = true;
+      }
     }
     this.eventQueue.push(event);
   }
@@ -4610,7 +4776,7 @@ var AgentRunController = class {
         "Agent run completed before pending permission requests resolved."
       )
     );
-    if (result?.text) {
+    if (result?.text && !this.observedMessageCompleted) {
       this.text = result.text;
     }
     if (result && "costData" in result) {
@@ -4651,9 +4817,11 @@ var AgentRunController = class {
     }
     this.settled = true;
     this.clearPendingPermissions(
-      new Error("Agent run was cancelled before pending permission requests resolved.")
+      new Error(
+        "Agent run was cancelled before pending permission requests resolved."
+      )
     );
-    if (result?.text) {
+    if (result?.text && !this.observedMessageCompleted) {
       this.text = result.text;
     }
     if (result && "costData" in result) {
@@ -4768,7 +4936,7 @@ var Agent = class {
    * second `setup()` against the same sandbox does ~one round-trip of
    * work.
    */
-  async setup(config = {}) {
+  async setup() {
     if (this.setupPromise) {
       await this.setupPromise;
       return;
@@ -4778,8 +4946,7 @@ var Agent = class {
     this.setupPromise = (async () => {
       await this.adapter.setup({
         provider: this.provider,
-        options: this.options,
-        config
+        options: this.options
       });
       debugAgent(
         "setup() returned provider=%s after %dms",
@@ -4801,14 +4968,10 @@ var Agent = class {
       );
     }
     if (runConfig.forkSessionId && !runConfig.forkAtMessageId) {
-      throw new Error(
-        "AgentRunConfig.forkSessionId requires forkAtMessageId."
-      );
+      throw new Error("AgentRunConfig.forkSessionId requires forkAtMessageId.");
     }
     if (runConfig.forkAtMessageId && !runConfig.forkSessionId) {
-      throw new Error(
-        "AgentRunConfig.forkAtMessageId requires forkSessionId."
-      );
+      throw new Error("AgentRunConfig.forkAtMessageId requires forkSessionId.");
     }
     const runId = runConfig.runId ?? randomUUID2();
     const streamCalledAt = Date.now();