@aiden-ade/sandbox-agent 0.1.43 → 0.1.44

package/dist/index.cjs

@@ -15296,6 +15296,8 @@ var import_path5 = require("path");
 var import_fs6 = require("fs");
 var import_os6 = require("os");
 var import_path6 = require("path");
+var import_readline2 = require("readline");
+var import_url2 = require("url");
 var import_fs7 = require("fs");
 var import_os7 = require("os");
 var import_path7 = require("path");
@@ -19157,7 +19159,7 @@ function createGrokAcpDriver(imageFiles) {
     }
     newSession(context);
   }
-  function sendPrompt(context, state) {
+  function sendPrompt2(context, state) {
     const text = buildPromptWithImagePathReferences(context, imageFiles);
     isPromptActive = true;
     promptId = request("session/prompt", {
@@ -19200,7 +19202,7 @@ function createGrokAcpDriver(imageFiles) {
       const sessionId = asString(result?.sessionId);
       if (sessionId) state.runtimeSessionId = sessionId;
       state.iterations = Math.max(state.iterations, 1);
-      sendPrompt(context, state);
+      sendPrompt2(context, state);
       return;
     }
     if (message.id === promptId) {
@@ -19546,23 +19548,59 @@ function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
     }
   };
 }
+var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
+  $schema: "https://opencode.ai/config.json",
+  permission: "allow"
+});
+function buildAutonomousOpenCodeConfigContent(existing) {
+  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+  try {
+    const parsed = JSON.parse(existing);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return JSON.stringify({
+        ...parsed,
+        permission: "allow"
+      });
+    }
+  } catch {
+  }
+  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+}
+function withAutonomousOpenCodePermissions(context) {
+  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
+  return {
+    ...context,
+    env: {
+      ...context.env,
+      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
+        context.env.OPENCODE_CONFIG_CONTENT
+      )
+    }
+  };
+}
 function getRecord(value2) {
   return typeof value2 === "object" && value2 !== null ? value2 : null;
 }
 function getString(value2) {
   return typeof value2 === "string" ? value2.trim() : "";
 }
-function getOpenCodeToolError(parsed, part) {
-  const state = getRecord(part?.state) ?? getRecord(parsed.state);
-  const error = getRecord(part?.error) ?? getRecord(parsed.error) ?? getRecord(state?.error);
-  return getString(part?.error) || getString(state?.error) || getString(error?.message) || getString(parsed.error);
+function getOpenCodeToolError(part) {
+  const state = getRecord(part.state);
+  const error = getRecord(part.error) ?? getRecord(state?.error);
+  return getString(part.error) || getString(state?.error) || getString(error?.message);
 }
-function isOpenCodeToolError(parsed, part) {
-  const state = getRecord(part?.state) ?? getRecord(parsed.state);
-  return part?.is_error === true || part?.isError === true || state?.status === "error" || Boolean(getOpenCodeToolError(parsed, part));
+function isOpenCodeToolError(part) {
+  const state = getRecord(part.state);
+  return part.is_error === true || part.isError === true || state?.status === "error" || Boolean(getOpenCodeToolError(part));
 }
-function getOpenCodePartId(parsed, part) {
-  return getString(part?.id) || getString(parsed.id) || getString(parsed.partID);
+function getOpenCodePartId(part) {
+  return getString(part.id) || getString(part.partID);
+}
+function getOpenCodeToolId(part) {
+  return getString(part.callID) || getString(part.id) || `opencode-tool-${Date.now()}`;
+}
+function getOpenCodeToolName(part) {
+  return getString(part.tool) || (typeof part.name === "string" ? part.name.trim() : "") || "Tool";
 }
 function resolveOpenCodePartSnapshotDelta(text, partId, snapshots) {
   if (!partId) return text;
@@ -19579,93 +19617,92 @@ function resolveOpenCodeReasoningDelta(text, partId, state) {
   state.opencodeReasoningByPartId ??= /* @__PURE__ */ new Map();
   return resolveOpenCodePartSnapshotDelta(text, partId, state.opencodeReasoningByPartId);
 }
-function handleOpencodeStructuredEvent(parsed, context, state) {
+var TASK_TOOL_NAME = "task";
+var TASK_RESULT_TAG_PATTERN = /<task_result>\n?([\s\S]*?)\n?<\/task_result>/;
+var TASK_ERROR_TAG_PATTERN = /<task_error>\n?([\s\S]*?)\n?<\/task_error>/;
+function unwrapOpenCodeTaskOutput(output) {
+  const result = output.match(TASK_RESULT_TAG_PATTERN);
+  if (result?.[1] !== void 0) return result[1].trim();
+  const error = output.match(TASK_ERROR_TAG_PATTERN);
+  if (error?.[1] !== void 0) return error[1].trim();
+  return output;
+}
+function emitOpenCodeToolPart(presenter, state, part, opts) {
+  const stateRecord = getRecord(part.state);
+  const status = getString(stateRecord?.status);
+  if (status === "pending") return;
+  const toolName = getOpenCodeToolName(part);
+  const toolId = getOpenCodeToolId(part);
+  const isTask = toolName.toLowerCase() === TASK_TOOL_NAME;
+  const parentToolUseId = opts.parentToolUseId ?? void 0;
+  state.opencodeToolUseIds ??= /* @__PURE__ */ new Set();
+  if (!state.opencodeToolUseIds.has(toolId)) {
+    state.opencodeToolUseIds.add(toolId);
+    void presenter.onToolUse(toolName, stateRecord?.input ?? part, toolId, parentToolUseId);
+    if (isTask) registerBackgroundLauncher(state, toolId);
+  }
+  if (status !== "completed" && status !== "error") return;
+  const toolError = isOpenCodeToolError(part);
+  const rawOutput = getString(stateRecord?.output) || getString(stateRecord?.error) || JSON.stringify(stateRecord ?? part);
+  const output = isTask ? unwrapOpenCodeTaskOutput(rawOutput) : rawOutput;
+  void presenter.onToolResult?.(toolId, output, toolError, parentToolUseId);
+  if (isTask) clearBackgroundTaskIds(state, [toolId]);
+  if (toolError && !state.error) {
+    const message = getOpenCodeToolError(part) || "OpenCode tool call failed.";
+    state.error = message;
+    void presenter.onError(message);
+  }
+}
+function mapOpencodePart(part, context, state, opts = {}) {
   const presenter = context.presenter;
-  const type = typeof parsed.type === "string" ? parsed.type : "";
-  if (!type) return false;
-  const sessionID = typeof parsed.sessionID === "string" ? parsed.sessionID : void 0;
-  if (sessionID) state.runtimeSessionId = sessionID;
-  const part = typeof parsed.part === "object" && parsed.part !== null ? parsed.part : null;
+  const type = getString(part.type);
   switch (type) {
-    case "step_start": {
+    case "step-start": {
       state.iterations += 1;
       void presenter.onLog(`[opencode] Step ${state.iterations} started`);
       return true;
     }
     case "text": {
-      const text = part && typeof part.text === "string" ? part.text : "";
+      const text = typeof part.text === "string" ? part.text : "";
       if (text) {
-        const delta = resolveOpenCodeTextDelta(text, getOpenCodePartId(parsed, part), state);
-        if (!delta) return true;
-        state.summary += delta;
-        void presenter.onAssistantText(delta);
+        const delta = resolveOpenCodeTextDelta(text, getOpenCodePartId(part), state);
+        if (delta) {
+          state.summary += delta;
+          void presenter.onAssistantText(delta);
+        }
       }
       return true;
     }
+    // Real Part schema only ever uses "reasoning"; "thinking" is a defensive alias in
+    // case a CLI dialect ever names the part itself that way.
     case "reasoning":
     case "thinking": {
-      const text = part && typeof part.text === "string" ? part.text : "";
+      const text = typeof part.text === "string" ? part.text : "";
       if (!text) return true;
-      const delta = resolveOpenCodeReasoningDelta(text, getOpenCodePartId(parsed, part), state);
+      const delta = resolveOpenCodeReasoningDelta(text, getOpenCodePartId(part), state);
       if (!delta) return true;
       state.iterations = Math.max(state.iterations, 1);
       void presenter.onThinking(delta);
       return true;
     }
-    case "tool_use":
-    case "tool.execute": {
-      const toolName = getString(parsed.tool) || (part && typeof part.name === "string" ? part.name : "") || getString(parsed.name) || (part && typeof part.tool === "string" ? part.tool : "") || "Tool";
-      const toolId = part && typeof part.id === "string" ? part.id : `opencode-tool-${Date.now()}`;
-      void presenter.onToolUse(toolName, part ?? {}, toolId);
-      return true;
-    }
     case "tool": {
-      const stateRecord = getRecord(parsed.state);
-      const toolName = getString(parsed.tool) || (part && typeof part.name === "string" ? part.name : "") || getString(parsed.name) || (part && typeof part.tool === "string" ? part.tool : "") || "Tool";
-      const toolId = getString(parsed.id) || getString(parsed.callID) || `opencode-tool-${Date.now()}`;
-      state.opencodeToolUseIds ??= /* @__PURE__ */ new Set();
-      if (!state.opencodeToolUseIds.has(toolId)) {
-        state.opencodeToolUseIds.add(toolId);
-        void presenter.onToolUse(toolName, stateRecord?.input ?? part ?? parsed, toolId);
-      }
-      const status = getString(stateRecord?.status);
-      if (status === "completed" || status === "error") {
-        const toolError = isOpenCodeToolError(parsed, part);
-        const output = getString(stateRecord?.output) || getString(stateRecord?.error) || JSON.stringify(stateRecord ?? part ?? parsed);
-        void presenter.onToolResult?.(toolId, output, toolError);
-        if (toolError && !state.error) {
-          const message = getOpenCodeToolError(parsed, part) || "OpenCode tool call failed.";
-          state.error = message;
-          void presenter.onError(message);
-        }
-      }
-      return true;
-    }
-    case "tool_result":
-    case "tool.result": {
-      const toolId = part && typeof part.id === "string" ? part.id : `opencode-tool-${Date.now()}`;
-      const output = part && typeof part.output === "string" ? part.output : JSON.stringify(part);
-      const toolError = isOpenCodeToolError(parsed, part);
-      void presenter.onToolResult?.(toolId, output, toolError);
-      if (toolError && !state.error) {
-        const message = getOpenCodeToolError(parsed, part) || "OpenCode tool call failed.";
-        state.error = message;
-        void presenter.onError(message);
-      }
+      emitOpenCodeToolPart(presenter, state, part, opts);
       return true;
     }
-    case "step_finish": {
-      if (part && typeof part.tokens === "object" && part.tokens !== null) {
-        const tokens = part.tokens;
+    case "step-finish": {
+      const tokens = getRecord(part.tokens);
+      if (tokens) {
+        const cache2 = getRecord(tokens.cache);
+        const cost = typeof part.cost === "number" ? part.cost : 0;
         state.usage = {
           model: typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() || "opencode",
           numTurns: Math.max(state.iterations, 1),
           durationMs: 0,
-          inputTokens: tokens.input ?? 0,
-          outputTokens: tokens.output ?? 0,
-          cacheReadTokens: tokens.cache_read ?? 0,
-          cacheCreationTokens: tokens.cache_creation ?? 0,
-          costUsd: 0
+          inputTokens: Number(tokens.input) || 0,
+          outputTokens: Number(tokens.output) || 0,
+          cacheReadTokens: Number(cache2?.read) || 0,
+          cacheCreationTokens: Number(cache2?.write) || 0,
+          costUsd: cost
         };
         void presenter.onUsageUpdate?.({
           model: state.usage.model,
@@ -19677,6 +19714,57 @@ function handleOpencodeStructuredEvent(parsed, context, state) {
       }
       return true;
     }
+    default:
+      return false;
+  }
+}
+function normalizeOpenCodePart(parsed, part, partType) {
+  return { ...parsed, ...part ?? {}, type: partType };
+}
+function handleOpencodeStructuredEvent(parsed, context, state) {
+  const presenter = context.presenter;
+  const type = typeof parsed.type === "string" ? parsed.type : "";
+  if (!type) return false;
+  const sessionID = typeof parsed.sessionID === "string" ? parsed.sessionID : void 0;
+  if (sessionID) state.runtimeSessionId = sessionID;
+  const part = typeof parsed.part === "object" && parsed.part !== null ? parsed.part : null;
+  switch (type) {
+    case "step_start":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "step-start"), context, state);
+    case "text":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "text"), context, state);
+    case "reasoning":
+    case "thinking":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "reasoning"), context, state);
+    // Real event: `opencode run --format json` emits exactly this shape — a single
+    // terminal event per tool call, carrying part.state.{input,output|error}. See
+    // notes/opencode-cli-reverse-engineering.md for the live-captured schema.
+    case "tool_use":
+    case "tool.execute":
+    case "tool":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "tool"), context, state);
+    case "step_finish":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "step-finish"), context, state);
+    // Defensive fallback only: no observed OpenCode version emits a separate
+    // tool_result/tool.result event in `--format json` mode (tool state always
+    // arrives via `tool_use` above). Kept in case a future/older CLI build splits
+    // the terminal tool event into a distinct result message. Deliberately NOT routed
+    // through mapOpencodePart — this shape has no part.state wrapper at all (output
+    // sits directly on the part), so it isn't a real Part-schema shape.
+    case "tool_result":
+    case "tool.result": {
+      const toolId = getString(part?.callID) || getString(parsed.callID) || getString(part?.id) || getString(parsed.id) || `opencode-tool-${Date.now()}`;
+      const output = part && typeof part.output === "string" ? part.output : JSON.stringify(part);
+      const stateRecord = getRecord(part?.state) ?? getRecord(parsed.state);
+      const toolError = part?.is_error === true || part?.isError === true || stateRecord?.status === "error" || Boolean(getString(part?.error) || getString(stateRecord?.error));
+      void presenter.onToolResult?.(toolId, output, toolError);
+      if (toolError && !state.error) {
+        const message = getString(part?.error) || getString(stateRecord?.error) || "OpenCode tool call failed.";
+        state.error = message;
+        void presenter.onError(message);
+      }
+      return true;
+    }
     case "session.error":
     case "error": {
       const errObj = typeof parsed.error === "object" && parsed.error !== null ? parsed.error : null;
@@ -19701,35 +19789,10 @@ var parseOpencodeStructuredLine = createStructuredLineParser(
   "opencode_cli",
   handleOpencodeStructuredEvent
 );
-var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
-  $schema: "https://opencode.ai/config.json",
-  permission: "allow"
-});
-function buildAutonomousOpenCodeConfigContent(existing) {
-  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
-  try {
-    const parsed = JSON.parse(existing);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return JSON.stringify({
-        ...parsed,
-        permission: "allow"
-      });
-    }
-  } catch {
-  }
-  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
-}
-function withAutonomousOpenCodePermissions(context) {
-  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
-  return {
-    ...context,
-    env: {
-      ...context.env,
-      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
-        context.env.OPENCODE_CONFIG_CONTENT
-      )
-    }
-  };
+function buildOpencodeEffortArgs(selectedEffortLevel) {
+  const trimmed = selectedEffortLevel?.trim().toLowerCase();
+  if (!trimmed || !isEffortLevel(trimmed)) return [];
+  return ["--variant", trimmed];
 }
 function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
   return {
@@ -19752,7 +19815,7 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
           command,
           args: [],
           buildArgs: (ctx, prompt) => {
-            const args = ["run", "--format", "json"];
+            const args = ["run", "--format", "json", "--thinking"];
             if (!shouldUseReadOnlyRuntimePermissions(ctx.config)) {
               args.push("--dangerously-skip-permissions");
             }
@@ -19760,6 +19823,7 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
             if (resumeId) args.push("--session", resumeId);
             const model = ctx.config.selectedModel?.trim();
             if (model?.includes("/")) args.push("--model", model);
+            args.push(...buildOpencodeEffortArgs(ctx.config.selectedEffortLevel));
             const attachmentPaths = [...imagePaths, ...filePaths];
             const fileArgs = attachmentPaths.flatMap((p) => ["--file", p]);
             if (fileArgs.length > 0) {
@@ -19780,6 +19844,395 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
     }
   };
 }
+function parseSseEventBlock(block) {
+  const dataLines = block.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(/^ /, ""));
+  if (dataLines.length === 0) return null;
+  try {
+    const parsed = JSON.parse(dataLines.join("\n"));
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      const record = parsed;
+      return {
+        id: typeof record.id === "string" ? record.id : void 0,
+        type: record.type,
+        properties: typeof record.properties === "object" && record.properties !== null ? record.properties : {}
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function connectOpenCodeSse(url2, signal) {
+  const response = await fetch(url2, {
+    signal,
+    headers: { Accept: "text/event-stream" }
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`OpenCode SSE connection failed: HTTP ${response.status}`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let closed = false;
+  async function* generate() {
+    let buffer = "";
+    try {
+      while (!closed) {
+        const { value: value2, done } = await reader.read();
+        if (done) return;
+        buffer += decoder.decode(value2, { stream: true });
+        let separatorIndex = buffer.indexOf("\n\n");
+        while (separatorIndex !== -1) {
+          const block = buffer.slice(0, separatorIndex);
+          buffer = buffer.slice(separatorIndex + 2);
+          const event = parseSseEventBlock(block);
+          if (event) yield event;
+          separatorIndex = buffer.indexOf("\n\n");
+        }
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  return {
+    events: generate(),
+    close: () => {
+      if (closed) return;
+      closed = true;
+      reader.cancel().catch(() => {
+      });
+    }
+  };
+}
+var SERVER_LISTENING_PATTERN = /listening on (https?:\/\/\S+)/i;
+var STARTUP_TIMEOUT_MS = 2e4;
+var HEALTH_POLL_INTERVAL_MS = 200;
+var HEALTH_POLL_MAX_ATTEMPTS = 50;
+function startOpenCodeServer(command, context) {
+  const child = spawnCli(command, ["serve", "--port", "0", "--hostname", "127.0.0.1"], context);
+  const ready = new Promise((resolve22, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(
+        new Error(`opencode serve did not report a listening URL within ${STARTUP_TIMEOUT_MS}ms`)
+      );
+    }, STARTUP_TIMEOUT_MS);
+    const stdoutRl = (0, import_readline2.createInterface)({ input: child.stdout });
+    const stderrRl = (0, import_readline2.createInterface)({ input: child.stderr });
+    const stderrLines = [];
+    const checkLine = (line) => {
+      if (settled) return;
+      const match = line.match(SERVER_LISTENING_PATTERN);
+      if (!match) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve22({ baseUrl: match[1].replace(/\/$/, "") });
+    };
+    stdoutRl.on("line", checkLine);
+    stderrRl.on("line", (line) => {
+      stderrLines.push(line);
+      checkLine(line);
+    });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("exit", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(
+        new Error(
+          `opencode serve exited (code ${code}) before reporting a listening URL. stderr: ${stderrLines.slice(-5).join("\n")}`
+        )
+      );
+    });
+  });
+  return { child, ready };
+}
+async function waitForHealthy(baseUrl, signal) {
+  for (let attempt = 0; attempt < HEALTH_POLL_MAX_ATTEMPTS; attempt++) {
+    if (signal.aborted)
+      throw new Error("Aborted while waiting for opencode server to become healthy");
+    try {
+      const response = await fetch(`${baseUrl}/global/health`, { signal });
+      if (response.ok) {
+        const body = await response.json().catch(() => null);
+        if (body?.healthy) return;
+      }
+    } catch {
+    }
+    await new Promise((resolve22) => setTimeout(resolve22, HEALTH_POLL_INTERVAL_MS));
+  }
+  throw new Error(`opencode server at ${baseUrl} did not become healthy in time`);
+}
+var NON_INTERACTIVE_DENY_RULES = [
+  { permission: "question", pattern: "*", action: "deny" },
+  { permission: "plan_enter", pattern: "*", action: "deny" },
+  { permission: "plan_exit", pattern: "*", action: "deny" }
+];
+async function resolveSession(baseUrl, context, signal) {
+  const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+  if (resumeId) {
+    const existing = await fetch(`${baseUrl}/session/${encodeURIComponent(resumeId)}`, {
+      signal
+    }).catch(() => null);
+    if (existing?.ok) return { id: resumeId };
+  }
+  const title = context.promptText.slice(0, 50) + (context.promptText.length > 50 ? "..." : "");
+  const response = await fetch(`${baseUrl}/session`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ title, permission: NON_INTERACTIVE_DENY_RULES })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create OpenCode session: HTTP ${response.status}`);
+  }
+  const info = await response.json();
+  if (!info.id) throw new Error("OpenCode session create response had no id");
+  return { id: info.id };
+}
+function buildPromptParts(promptText, imageFiles, attachmentFiles) {
+  const attachments = [...imageFiles, ...attachmentFiles].map(
+    (file) => ({
+      type: "file",
+      mime: file.mimeType,
+      filename: file.filename,
+      url: (0, import_url2.pathToFileURL)(file.path).href
+    })
+  );
+  return [...attachments, { type: "text", text: promptText }];
+}
+async function sendPrompt(baseUrl, sessionId, context, parts2, signal) {
+  const model = context.config.selectedModel?.trim();
+  const modelBody = model && model.includes("/") ? (() => {
+    const slashIndex = model.indexOf("/");
+    return { providerID: model.slice(0, slashIndex), modelID: model.slice(slashIndex + 1) };
+  })() : void 0;
+  const variant = context.config.selectedEffortLevel?.trim().toLowerCase();
+  const response = await fetch(`${baseUrl}/session/${encodeURIComponent(sessionId)}/message`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      parts: parts2,
+      ...modelBody ? { model: modelBody } : {},
+      ...variant && isEffortLevel(variant) ? { variant } : {}
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`OpenCode prompt request failed: HTTP ${response.status} ${text}`.trim());
+  }
+}
+async function replyToPermission(baseUrl, requestId, reply, signal) {
+  await fetch(`${baseUrl}/permission/${encodeURIComponent(requestId)}/reply`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ reply })
+  }).catch((error) => {
+    console.warn("[opencode_serve] Failed to reply to permission request", requestId, error);
+  });
+}
+function buildAgentResult(state, sessionId, aborted2) {
+  if (aborted2) {
+    return {
+      success: false,
+      summary: "Interrupted by user",
+      filesModified: [],
+      planFilesCreated: [],
+      iterations: Math.max(state.iterations, 1),
+      error: "Interrupted by user",
+      providerSessionId: sessionId,
+      runtimeSessionId: sessionId,
+      backendKind: "opencode_serve",
+      supportTier: "structured",
+      usage: state.usage
+    };
+  }
+  const failed = Boolean(state.error?.trim());
+  const summary = state.summary.trim() || state.error?.trim() || (failed ? "Task failed" : "Task completed");
+  return {
+    success: !failed,
+    summary,
+    filesModified: [],
+    planFilesCreated: [],
+    iterations: Math.max(state.iterations, 1),
+    ...state.error?.trim() ? { error: state.error.trim() } : {},
+    providerSessionId: sessionId,
+    runtimeSessionId: sessionId,
+    backendKind: "opencode_serve",
+    supportTier: "structured",
+    usage: state.usage
+  };
+}
+function createOpencodeServeBackend(command = "opencode") {
+  return {
+    kind: "opencode_serve",
+    supportTier: "structured",
+    async run(context) {
+      const { files: imageFiles, cleanup: cleanupImages } = writeImagesToTempFiles(
+        context.config.images,
+        context.cwd
+      );
+      const { files: attachmentFiles, cleanup: cleanupFiles } = writeFilesToTempFiles(
+        context.config.files,
+        context.cwd
+      );
+      const runContext = withAutonomousOpenCodePermissions(context);
+      const readOnly = shouldUseReadOnlyRuntimePermissions(context.config);
+      const { child, ready } = startOpenCodeServer(command, runContext);
+      const state = { process: child, iterations: 0, summary: "" };
+      context.onProcessSpawned?.(child);
+      context.registerLivenessProbe?.(() => ({
+        providerAlive: child.exitCode === null,
+        lastRawOutputAgoMs: typeof state.lastRawOutputAtMs === "number" ? Date.now() - state.lastRawOutputAtMs : null
+      }));
+      let sseClose = null;
+      let sessionId = "";
+      let aborted2 = false;
+      const onAbort = () => {
+        aborted2 = true;
+        sseClose?.();
+        killProcessTree(child.pid, { signal: "SIGTERM", child });
+      };
+      context.abortController.signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        const server = await ready;
+        state.lastRawOutputAtMs = Date.now();
+        await waitForHealthy(server.baseUrl, context.abortController.signal);
+        const session = await resolveSession(
+          server.baseUrl,
+          runContext,
+          context.abortController.signal
+        );
+        sessionId = session.id;
+        state.runtimeSessionId = sessionId;
+        const prompt = context.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(context.config, context.promptText)) : buildPromptWithSystem(context.config, context.promptText);
+        const parts2 = buildPromptParts(prompt, imageFiles, attachmentFiles);
+        const connection = await connectOpenCodeSse(
+          `${server.baseUrl}/event`,
+          context.abortController.signal
+        );
+        sseClose = connection.close;
+        const promptError = await sendPrompt(
+          server.baseUrl,
+          sessionId,
+          runContext,
+          parts2,
+          context.abortController.signal
+        ).then(() => null).catch((error) => ({
+          message: error instanceof Error ? error.message : String(error)
+        }));
+        if (context.abortController.signal.aborted) {
+        } else if (promptError) {
+          state.error = promptError.message;
+          void context.presenter.onError(promptError.message);
+        } else {
+          for await (const event of connection.events) {
+            if (aborted2) break;
+            const done = handleOpenCodeServeEvent(
+              event,
+              sessionId,
+              runContext,
+              state,
+              readOnly,
+              server.baseUrl
+            );
+            if (done) break;
+          }
+        }
+        return buildAgentResult(state, sessionId, aborted2);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!aborted2 && !context.abortController.signal.aborted) {
+          console.error("[opencode_serve] Run failed:", message);
+          state.error = message;
+          void context.presenter.onError(message);
+        }
+        return buildAgentResult(
+          state,
+          sessionId,
+          aborted2 || context.abortController.signal.aborted
+        );
+      } finally {
+        context.abortController.signal.removeEventListener("abort", onAbort);
+        sseClose?.();
+        killProcessTree(child.pid, { signal: "SIGTERM", child });
+        cleanupImages();
+        cleanupFiles();
+      }
+    }
+  };
+}
+function handleOpenCodeServeEvent(event, sessionId, context, state, readOnly, baseUrl) {
+  const properties = event.properties;
+  const eventSessionId = getString(properties.sessionID);
+  if (eventSessionId && eventSessionId !== sessionId) return false;
+  switch (event.type) {
+    // Live-verified: the SSE bus emits a message.updated (and matching
+    // message.part.updated) for the USER's own message too, not just the
+    // assistant's — track user message ids so their echoed text is never
+    // mistaken for assistant output below.
+    case "message.updated": {
+      const info = getRecord(properties.info);
+      if (getString(info?.role) === "user") {
+        const messageId = getString(info?.id);
+        if (messageId) {
+          state.opencodeUserMessageIds ??= /* @__PURE__ */ new Set();
+          state.opencodeUserMessageIds.add(messageId);
+        }
+      }
+      return false;
+    }
+    case "message.part.updated": {
+      const part = getRecord(properties.part);
+      if (!part) return false;
+      const messageId = getString(part.messageID);
+      if (messageId && state.opencodeUserMessageIds?.has(messageId)) return false;
+      mapOpencodePart(part, context, state);
+      return false;
+    }
+    // Live token-by-token streaming is explicitly out of scope — only the
+    // start/complete snapshots from message.part.updated are consumed.
+    case "message.part.delta":
+      return false;
+    case "permission.asked": {
+      const requestId = getString(properties.id);
+      if (requestId) {
+        void replyToPermission(
+          baseUrl,
+          requestId,
+          readOnly ? "reject" : "once",
+          context.abortController.signal
+        );
+      }
+      return false;
+    }
+    case "session.error": {
+      const errorRecord = getRecord(properties.error);
+      const message = getString(errorRecord?.message) || getString(properties.error) || "OpenCode session error.";
+      if (!state.error) {
+        state.error = message;
+        void context.presenter.onError(message);
+      }
+      return false;
+    }
+    case "session.status": {
+      const status = getRecord(properties.status);
+      return getString(status?.type) === "idle";
+    }
+    default:
+      return false;
+  }
+}
 function createGenericCliPassthroughBackend(command, defaultArgs = []) {
   return {
     kind: "generic_cli",
@@ -20008,6 +20461,7 @@ function defaultSelectedModelForBackend(backendKind) {
     case "grok_cli":
       return firstCatalogModelId(backendKind) ?? "grok-4.5";
     case "opencode_cli":
+    case "opencode_serve":
       return void 0;
     case "antigravity_cli":
       return void 0;
@@ -20224,6 +20678,7 @@ var BaseMachineAgent = class _BaseMachineAgent {
       case "cursor_agent_cli":
       case "droid_cli":
       case "opencode_cli":
+      case "opencode_serve":
       case "copilot_cli":
       case "supatest_cli":
       case "kimi_cli":
@@ -20291,7 +20746,7 @@ Prefer relative paths and keep your work scoped to this project.`
     const promptText = this.buildPromptText(runtimeConfig);
     const runtimeCommand = runtimeConfig.runtimeCommand || this.runtime.runtimeCommand;
     const runtimeArgs = runtimeConfig.runtimeArgs || this.runtime.runtimeArgs || [];
-    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "antigravity_cli" ? createAntigravityCliBackend(runtimeCommand || "agy", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "grok_cli" ? createGrokCliBackend(runtimeCommand || "grok", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
+    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "antigravity_cli" ? createAntigravityCliBackend(runtimeCommand || "agy", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "opencode_serve" ? createOpencodeServeBackend(runtimeCommand || "opencode") : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "grok_cli" ? createGrokCliBackend(runtimeCommand || "grok", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
       runtimeCommand || "generic-cli",
       runtimeArgs
     );
@@ -21004,13 +21459,20 @@ ${meta.description}`);
     }
     if (conversationId) artifactIds.push(`- conversationId: "${conversationId}"`);
     if (artifactIds.length > 0) {
+      const artifactTools = ["create_plan", "create_document_artifact", "create_test_report"];
+      if (taskId || isWorkflowSession) artifactTools.push("upsert_prototype_version");
       parts2.push(
         [
-          "When creating artifacts using MCP tools (create_plan, create_document_artifact, create_test_report, upsert_prototype_version), always pass these IDs:",
+          `When creating artifacts using MCP tools (${artifactTools.join(", ")}), always pass these IDs:`,
           ...artifactIds
         ].join("\n")
       );
     }
+    if (teamId && conversationId && !taskId && !isWorkflowSession) {
+      parts2.push(
+        "This is a standalone chat. For create_plan, create_document_artifact, and create_test_report, omit taskId and workflowId; conversationId is the artifact owner. Do not use create_document unless the user explicitly asks for a standalone team Document."
+      );
+    }
     if (workflowId && conversationId && teamId) {
       parts2.push(
         [
@@ -22274,9 +22736,7 @@ var CODEX_ALAN_TOML_SECTION = "mcp_servers.alan";
 function isCodexAlanTomlSection(section) {
   return section === CODEX_ALAN_TOML_SECTION || section.startsWith(`${CODEX_ALAN_TOML_SECTION}.`);
 }
-function mergeCodexAlanSection(path, existingContent, desiredContent) {
-  if (existingContent === null || existingContent.trim() === "") return desiredContent;
-  assertValidExistingToml(path, existingContent);
+function stripCodexAlanSection(existingContent) {
   const lines = existingContent.split("\n");
   const retained = [];
   let insideAlanSection = false;
@@ -22287,7 +22747,12 @@ function mergeCodexAlanSection(path, existingContent, desiredContent) {
     }
     if (!insideAlanSection) retained.push(line);
   }
-  const prefix = retained.join("\n").trimEnd();
+  return retained.join("\n").trimEnd();
+}
+function mergeCodexAlanSection(path, existingContent, desiredContent) {
+  if (existingContent === null || existingContent.trim() === "") return desiredContent;
+  assertValidExistingToml(path, existingContent);
+  const prefix = stripCodexAlanSection(existingContent);
   const merged = `${prefix}${prefix ? "\n\n" : ""}${desiredContent.trim()}
 `;
   try {
@@ -22373,6 +22838,45 @@ function verifyAlanMcpRegistered(backendKind, home = (0, import_node_os6.homedir
     verification: inspection.verification
   };
 }
+function removeAlanFromJsonConfig(path, existingContent) {
+  const config = parseJsonObject2(path, existingContent);
+  for (const containerKey of ["mcpServers", "mcp"]) {
+    const container = config[containerKey];
+    if (container && typeof container === "object" && !Array.isArray(container)) {
+      delete container.alan;
+    }
+  }
+  return JSON.stringify(config);
+}
+function unregisterAlanMcp(backendKind, home = (0, import_node_os6.homedir)()) {
+  const removedPaths = [];
+  const errors = [];
+  const files = alanMcpConfigFilesForBackend(backendKind, {}, home);
+  for (const file of files) {
+    if (!(0, import_node_fs7.existsSync)(file.path)) continue;
+    const releaseLock = waitForConfigLock(`${file.path}.alan-lock`);
+    try {
+      const current = (0, import_node_fs7.readFileSync)(file.path, "utf8");
+      let next;
+      if (file.path.endsWith(".toml")) {
+        const stripped = stripCodexAlanSection(current);
+        next = stripped ? `${stripped}
+` : "";
+      } else {
+        next = removeAlanFromJsonConfig(file.path, current);
+      }
+      if (next !== current) {
+        atomicWriteManagedConfig(file.path, next);
+        removedPaths.push(file.path);
+      }
+    } catch (err) {
+      errors.push(err instanceof Error ? err.message : String(err));
+    } finally {
+      releaseLock();
+    }
+  }
+  return { removedPaths, errors };
+}
 function isHttpUrl(value2) {
   if (typeof value2 !== "string") return false;
   try {
@@ -22719,6 +23223,88 @@ function extractCodexDiscoveredModelIdsFromDebugJson(value2) {
   }
   return [...new Set(ids)];
 }
+var OPENCODE_MODEL_ID_LINE_PATTERN = /^[a-z0-9][\w.-]*\/[\w.-]+$/i;
+var OPENCODE_KNOWN_VARIANT_KEYS = /* @__PURE__ */ new Set([
+  "minimal",
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "extra-high",
+  "max",
+  "ultra"
+]);
+function parseOpenCodeVerboseModelOutput(text) {
+  const entries = [];
+  const lines = text.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = (lines[i] ?? "").trim();
+    i += 1;
+    if (!OPENCODE_MODEL_ID_LINE_PATTERN.test(line)) continue;
+    let jsonStart = i;
+    while (jsonStart < lines.length && (lines[jsonStart] ?? "").trim() === "") jsonStart += 1;
+    if (jsonStart >= lines.length || !(lines[jsonStart] ?? "").trim().startsWith("{")) continue;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let endLineIdx = -1;
+    let buffer = "";
+    for (let j = jsonStart; j < lines.length; j += 1) {
+      const raw = lines[j] ?? "";
+      buffer += (buffer ? "\n" : "") + raw;
+      for (const ch of raw) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\" && inString) {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
+        if (inString) continue;
+        if (ch === "{") depth += 1;
+        else if (ch === "}") depth -= 1;
+      }
+      if (depth === 0) {
+        endLineIdx = j;
+        break;
+      }
+    }
+    if (endLineIdx === -1) break;
+    try {
+      const obj = JSON.parse(buffer);
+      entries.push({
+        id: line,
+        reasoning: obj.capabilities?.reasoning === true,
+        variants: obj.variants ? Object.keys(obj.variants) : []
+      });
+    } catch {
+    }
+    i = endLineIdx + 1;
+  }
+  return entries;
+}
+function extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text) {
+  const entries = parseOpenCodeVerboseModelOutput(text);
+  const ids = [];
+  for (const entry of entries) {
+    const knownVariants = entry.reasoning ? entry.variants.filter((variant) => OPENCODE_KNOWN_VARIANT_KEYS.has(variant)) : [];
+    if (knownVariants.length === 0) {
+      ids.push(entry.id);
+      continue;
+    }
+    for (const variant of knownVariants) {
+      ids.push(`${entry.id}-${variant}`);
+    }
+  }
+  return [...new Set(ids)];
+}
 function extractModelIdsFromText(value2) {
   const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   const ignoredLinePattern = /^(available models|models|usage|error|flag provided|try |agy\b|warning:)/i;
@@ -22829,12 +23415,24 @@ async function probeJsonOrTextModels(executable, env, argSets, options) {
   return [];
 }
 async function discoverOpenCodeModels(executable, env) {
-  const probed = await probeJsonOrTextModels(executable, env, [
+  const verbose = await runCliProbeAsync(
+    executable,
+    withModelProbeEnv(env),
+    ["models", "--verbose"],
+    MODEL_DISCOVERY_TIMEOUT_MS
+  );
+  if (verbose && !verbose.error && verbose.status === 0 && verbose.stdout.trim()) {
+    const withEffort = extractOpenCodeDiscoveredModelIdsFromVerboseOutput(verbose.stdout);
+    if (withEffort.length > 0) return withEffort;
+  }
+  const plain = await probeJsonOrTextModels(executable, env, [["models"]]);
+  if (plain.length > 0) return plain;
+  const legacy = await probeJsonOrTextModels(executable, env, [
     ["models", "--json"],
     ["models", "list", "--json"],
     ["model", "list", "--json"]
   ]);
-  return probed.length > 0 ? probed : OPENCODE_ZEN_MODEL_IDS;
+  return legacy.length > 0 ? legacy : OPENCODE_ZEN_MODEL_IDS;
 }
 async function discoverAntigravityModels(executable, env) {
   return probeJsonOrTextModels(executable, env, [["models"]], {
@@ -23080,7 +23678,7 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.43";
+var AGENT_VERSION = "0.1.44";
 
 // src/workspace-relocation.ts
 var import_node_child_process3 = require("child_process");
@@ -25224,6 +25822,21 @@ async function startDaemon(args) {
     recentLogs.push(`${(/* @__PURE__ */ new Date()).toISOString()} ${message}`);
     if (recentLogs.length > 200) recentLogs.splice(0, recentLogs.length - 200);
   };
+  const alanMcpRegisteredRuns = /* @__PURE__ */ new Set();
+  const alanMcpRegisteredBackends = /* @__PURE__ */ new Set();
+  const finalizeAlanMcpForRun = (runId) => {
+    if (!alanMcpRegisteredRuns.delete(runId)) return;
+    if (alanMcpRegisteredRuns.size > 0) return;
+    for (const backend of alanMcpRegisteredBackends) {
+      try {
+        const { removedPaths } = unregisterAlanMcp(backend);
+        if (removedPaths.length > 0) pushLog(`mcp-unregistered backend=${backend} run=${runId}`);
+      } catch (err) {
+        pushLog(`mcp-unregister-failed backend=${backend} ${err.message}`);
+      }
+    }
+    alanMcpRegisteredBackends.clear();
+  };
   const workspaceAccessTracker = new WorkspaceAccessTracker();
   const recheckWorkspaceIssue = () => {
     const previousPath = workspaceAccessTracker.recoveryPath();
@@ -26006,6 +26619,10 @@ async function startDaemon(args) {
       workspaceLease: workspaceLeaseCapture.lease
     });
     pendingRunStarts.delete(payload.runId);
+    if (payload.alanMcp && backendKind) {
+      alanMcpRegisteredRuns.add(payload.runId);
+      alanMcpRegisteredBackends.add(backendKind);
+    }
     void agent.run({
       task: payload.content,
       maxIterations: payload.maxIterations ?? 50,
@@ -26051,6 +26668,7 @@ async function startDaemon(args) {
       } catch {
         pushLog(`run-journal-remove-failed run=${payload.runId}`);
       }
+      finalizeAlanMcpForRun(payload.runId);
       releaseActiveRun();
     });
   });
@@ -28037,7 +28655,7 @@ async function runSessionFromEnv() {
   const task = process.env.ALAN_TASK;
   const teamId = process.env.ALAN_TEAM_ID || void 0;
   const projectPath = process.env.ALAN_PROJECT_PATH || "/home/user/workspace";
-  const backendKind = process.env.ALAN_BACKEND_KIND || "claude_cli";
+  const backendKind = process.env.ALAN_BACKEND_KIND || "codex_app_server";
   const agentId = process.env.ALAN_AGENT_ID || void 0;
   const agentPrompt = process.env.ALAN_AGENT_PROMPT || void 0;
   const mode = process.env.ALAN_MODE || "agent";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "type": "module",
   "description": "Alan agent runtime — cloud sandbox and local daemon (alan-agent CLI)",
   "bin": {
@@ -22,8 +22,8 @@
     "tsup": "^8.5.1",
     "tsx": "^4.19.0",
     "typescript": "~5.9.3",
-    "@alan-ai/agent-core": "0.1.0",
-    "@alan-ai/shared": "0.1.0"
+    "@alan-ai/shared": "0.1.0",
+    "@alan-ai/agent-core": "0.1.0"
   },
   "deprecated": "Use @alan-ai-hq/agent-manager instead.",
   "scripts": {