@ai-sdk/harness-opencode 1.0.21 → 1.0.23

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @ai-sdk/harness-opencode
 
+## 1.0.23
+
+### Patch Changes
+
+- 39c8276: fix(harness): improve opaque sandbox bridge error handling
+- 91fe6d8: fix(harness): emit `finish-step` stream parts correctly per the underlying model steps
+- Updated dependencies [39c8276]
+- Updated dependencies [91fe6d8]
+- Updated dependencies [0be5014]
+  - @ai-sdk/harness@1.0.23
+
+## 1.0.22
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.22
+- @ai-sdk/provider-utils@5.0.7
+
 ## 1.0.21
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -20,6 +20,15 @@ function formatBridgeError(err) {
   if (err instanceof Error) {
     return { name: err.name, message: err.message, stack: err.stack };
   }
+  if (typeof err === "string") {
+    return { message: err };
+  }
+  if (err !== null && typeof err === "object") {
+    try {
+      return { message: JSON.stringify(err) };
+    } catch {
+    }
+  }
   return { message: String(err) };
 }
 function parseEnvList(value) {
@@ -47,6 +56,7 @@ async function runBridge(options) {
   let isFirstTurn = true;
   let turnAbort;
   let currentUserMessages;
+  let currentInterruptHandler;
   let debugConfig;
   let consoleCaptureInstalled = false;
   const envDebugEnabled = ENV_TRUTHY.has(
@@ -164,6 +174,38 @@ async function runBridge(options) {
   };
   const rawStdoutWrite = process.stdout.write.bind(process.stdout);
   const rawStderrWrite = process.stderr.write.bind(process.stderr);
+  const writeErrorToStderr = (input) => {
+    try {
+      const formatted = formatBridgeError(input.error);
+      rawStderrWrite(
+        `[harness:${bridgeType}:error] ${input.message}: ${formatted.message}
+`
+      );
+      if (formatted.stack) {
+        rawStderrWrite(`${formatted.stack}
+`);
+      }
+    } catch {
+    }
+  };
+  const emitWarning = (input) => {
+    try {
+      for (const line of input.message.split("\n")) {
+        if (line.trim().length > 0) {
+          rawStderrWrite(`[harness:${bridgeType}:warn] ${line}
+`);
+        }
+      }
+    } catch {
+    }
+  };
+  const emitError = (input) => {
+    writeErrorToStderr({
+      message: input.message ?? "bridge error",
+      error: input.error
+    });
+    emit({ type: "error", error: serialiseError(input.error) });
+  };
   const installConsoleCapture = () => {
     if (consoleCaptureInstalled) return;
     consoleCaptureInstalled = true;
@@ -221,6 +263,7 @@ async function runBridge(options) {
         });
         turnAbort = new AbortController();
         currentTurnState = "running";
+        currentInterruptHandler = void 0;
         void writeStartConfig(msg);
         void writeBridgeMeta("running");
         const startDebug = msg.debug;
@@ -242,6 +285,9 @@ async function runBridge(options) {
           }),
           pendingUserMessages: [],
           abortSignal: turnAbort.signal,
+          onInterrupt: (handler) => {
+            currentInterruptHandler = handler;
+          },
           firstTurn,
           bridgeLog: (input) => {
             const level = input.level ?? "debug";
@@ -254,14 +300,17 @@ async function runBridge(options) {
               ...input.attrs ? { attrs: input.attrs } : {},
               ...input.error !== void 0 ? { error: formatBridgeError(input.error) } : {}
             });
-          }
+          },
+          emitWarning,
+          emitError
         };
         currentUserMessages = turn.pendingUserMessages;
         try {
           await onStart(msg, turn);
         } catch (err) {
-          emit({ type: "error", error: serialiseError(err) });
+          emitError({ error: err, message: "bridge turn failed" });
         } finally {
+          currentInterruptHandler = void 0;
           currentTurnState = "waiting";
           void writeBridgeMeta("waiting");
         }
@@ -289,6 +338,22 @@ async function runBridge(options) {
       case "abort":
         turnAbort?.abort();
         return;
+      case "interrupt":
+        try {
+          if (currentInterruptHandler) {
+            await currentInterruptHandler();
+          } else {
+            turnAbort?.abort();
+          }
+          sendControl({ type: "bridge-interrupted", ok: true });
+        } catch (err) {
+          sendControl({
+            type: "bridge-interrupted",
+            ok: false,
+            error: serialiseError(err)
+          });
+        }
+        return;
       case "resume":
         replay(ws, msg.lastSeenEventId);
         return;
@@ -383,10 +448,10 @@ async function runBridge(options) {
     });
   });
   process.on("uncaughtException", (err) => {
-    emit({ type: "error", error: serialiseError(err) });
+    emitError({ error: err, message: "uncaught exception" });
   });
   process.on("unhandledRejection", (err) => {
-    emit({ type: "error", error: serialiseError(err) });
+    emitError({ error: err, message: "unhandled rejection" });
   });
   await new Promise((resolve, reject) => {
     if (wss.address() != null) {
@@ -477,19 +542,6 @@ function asRecord(value) {
   return value;
 }
 
-// src/bridge/opencode-path.ts
-import path from "path";
-var fallbackPath = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
-function prependOpenCodeBinToPath({
-  bootstrapDir: bootstrapDir2,
-  env
-}) {
-  env.PATH = [
-    path.join(bootstrapDir2, "node_modules", ".bin"),
-    env.PATH || fallbackPath
-  ].join(path.delimiter);
-}
-
 // src/bridge/opencode-usage.ts
 function mapUsage(tokens) {
   const value = extractOpenCodeTokens(tokens) ?? zeroOpenCodeTokens();
@@ -608,6 +660,47 @@ function add({
   return leftNumber == null && rightNumber == null ? void 0 : (leftNumber ?? 0) + (rightNumber ?? 0);
 }
 
+// src/bridge/opencode-finish-step.ts
+function mapOpenCodeFinishReason(reason) {
+  const normalized = reason.toLowerCase();
+  if (normalized.includes("length")) return "length";
+  if (normalized.includes("filter")) return "content-filter";
+  if (normalized.includes("tool")) return "tool-calls";
+  if (normalized.includes("error") || normalized.includes("fail"))
+    return "error";
+  if (normalized === "stop" || normalized === "end") return "stop";
+  return "other";
+}
+function legacyStepFinishPartToFinishStep(part) {
+  if (!isRecord(part) || part.type !== "step-finish") return void 0;
+  const rawFinish = typeof part.reason === "string" ? part.reason : "stop";
+  return {
+    type: "finish-step",
+    finishReason: {
+      unified: mapOpenCodeFinishReason(rawFinish),
+      raw: rawFinish
+    },
+    usage: mapUsage(part.tokens),
+    ...typeof part.cost === "number" ? { harnessMetadata: { opencode: { cost: part.cost } } } : {}
+  };
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/bridge/opencode-path.ts
+import path from "path";
+var fallbackPath = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+function prependOpenCodeBinToPath({
+  bootstrapDir: bootstrapDir2,
+  env
+}) {
+  env.PATH = [
+    path.join(bootstrapDir2, "node_modules", ".bin"),
+    env.PATH || fallbackPath
+  ].join(path.delimiter);
+}
+
 // src/bridge/tool-relay-auth.ts
 import { readdir, readFile, readlink } from "fs/promises";
 var ToolRelayAuthorizer = class {
@@ -790,7 +883,7 @@ async function runTurn(start, turn) {
       totalUsage = await runPrompt({ client, sessionId, start, turn, emit });
     }
   } catch (err) {
-    emit({ type: "error", error: serialiseError2(err) });
+    turn.emitError({ error: err, message: "OpenCode turn failed" });
   } finally {
     emit({
       type: "finish",
@@ -1032,11 +1125,38 @@ function legacyStatusType(event) {
   const status = event.properties?.status;
   return status && typeof status === "object" ? String(status.type ?? "") : void 0;
 }
-function legacyStatusMessage(event) {
+function legacyRetryStatusMessage(event) {
   const status = event.properties?.status;
-  if (!status || typeof status !== "object") return void 0;
-  const message = status.message;
-  return typeof message === "string" ? message : void 0;
+  const details = [];
+  if (status && typeof status === "object") {
+    const retryStatus = status;
+    if (typeof retryStatus.attempt === "number") {
+      details.push(`attempt ${retryStatus.attempt}`);
+    }
+    if (typeof retryStatus.message === "string" && retryStatus.message.trim()) {
+      details.push(retryStatus.message.trim());
+    }
+  }
+  return details.length > 0 ? `OpenCode session retry: ${details.join("; ")}` : "OpenCode session retry";
+}
+function nextRetryEventMessage(event) {
+  const props = event.properties ?? {};
+  const details = [];
+  if (typeof props.attempt === "number") {
+    details.push(`attempt ${props.attempt}`);
+  }
+  const error = props.error;
+  if (isRecord2(error)) {
+    const message = stringValue(error.message) ?? (isRecord2(error.data) ? stringValue(error.data.message) : void 0);
+    const statusCode = error.statusCode;
+    if (typeof statusCode === "number") {
+      details.push(`HTTP ${statusCode}`);
+    }
+    if (message) details.push(message);
+  } else if (error != null) {
+    details.push(formatError(error));
+  }
+  return details.length > 0 ? `OpenCode session retry: ${details.join("; ")}` : "OpenCode session retry";
 }
 async function ensureSession({
   client,
@@ -1119,9 +1239,7 @@ async function runPrompt({
         sawBusy = true;
       } else if (status === "retry") {
         sawBusy = true;
-        terminalError = legacyStatusMessage(event) ?? "Session retry";
-        turnSettled.resolve();
-        return true;
+        turn.emitWarning({ message: legacyRetryStatusMessage(event) });
       } else if (sawBusy && status === "idle") {
         turnSettled.resolve();
         return true;
@@ -1221,9 +1339,7 @@ async function runCompaction({
         sawBusy = true;
       } else if (status === "retry") {
         sawBusy = true;
-        terminalError = legacyStatusMessage(event) ?? "Session retry";
-        compactionSettled.resolve();
-        return true;
+        turn.emitWarning({ message: legacyRetryStatusMessage(event) });
       } else if (sawBusy && status === "idle") {
         compactionSettled.resolve();
         return true;
@@ -1306,7 +1422,8 @@ function createTranslationState() {
     messageRoles: /* @__PURE__ */ new Map(),
     turnUsage: void 0,
     legacyTextPartIds: /* @__PURE__ */ new Set(),
-    legacyReasoningPartIds: /* @__PURE__ */ new Set()
+    legacyReasoningPartIds: /* @__PURE__ */ new Set(),
+    legacyStepFinishPartIds: /* @__PURE__ */ new Set()
   };
 }
 async function translateAndEmit({
@@ -1323,7 +1440,7 @@ async function translateAndEmit({
   const props = event.properties ?? {};
   if (type === "message.updated") {
     const info = props.info;
-    if (isRecord(info)) {
+    if (isRecord2(info)) {
       const id = stringValue(info.id);
       const role = stringValue(info.role);
       if (id && role) state.messageRoles.set(id, role);
@@ -1361,6 +1478,7 @@ async function translateAndEmit({
   }
   if (type === "message.part.updated") {
     if (emitLegacyTextPartUpdate({ part: props.part, state, emit })) return;
+    if (emitLegacyStepFinishPart({ part: props.part, state, emit })) return;
     emitLegacyToolPart({ part: props.part, state, emit });
     return;
   }
@@ -1508,13 +1626,25 @@ async function translateAndEmit({
     });
     return;
   }
+  if (type === "session.next.retried") {
+    const error = props.error ?? event;
+    if (isRecord2(error) && error.isRetryable === false) {
+      turn.emitError({
+        error,
+        message: "OpenCode session retry failed"
+      });
+    } else {
+      turn.emitWarning({ message: nextRetryEventMessage(event) });
+    }
+    return;
+  }
   if (type === "session.next.step.ended") {
     closeLegacyOpenParts({ state, emit });
     state.turnUsage = mapUsage(props.tokens);
     emit({
       type: "finish-step",
       finishReason: {
-        unified: mapFinishReason(String(props.finish ?? "stop")),
+        unified: mapOpenCodeFinishReason(String(props.finish ?? "stop")),
         raw: String(props.finish ?? "stop")
       },
       usage: state.turnUsage,
@@ -1544,7 +1674,11 @@ async function translateAndEmit({
     return;
   }
   if (type === "session.error" || type === "session.next.step.failed") {
-    emit({ type: "error", error: formatError(props.error ?? event) });
+    const error = props.error ?? event;
+    turn.emitError({
+      error,
+      message: type === "session.error" ? "OpenCode session error" : "OpenCode step failed"
+    });
     return;
   }
   if (type === "permission.v2.asked") {
@@ -1592,7 +1726,7 @@ function emitLegacyTextPartUpdate({
   state,
   emit
 }) {
-  if (!isRecord(part)) return false;
+  if (!isRecord2(part)) return false;
   if (part.type !== "text" && part.type !== "reasoning") return false;
   const id = stringValue(part.id);
   if (!id) return true;
@@ -1627,7 +1761,7 @@ function emitLegacyTextPartUpdate({
   return true;
 }
 function legacyPartEnded(part) {
-  return isRecord(part.time) && part.time.end != null;
+  return isRecord2(part.time) && part.time.end != null;
 }
 function closeLegacyOpenParts({
   state,
@@ -1644,6 +1778,23 @@ function closeLegacyOpenParts({
   }
   state.legacyTextPartIds.clear();
 }
+function emitLegacyStepFinishPart({
+  part,
+  state,
+  emit
+}) {
+  const event = legacyStepFinishPartToFinishStep(part);
+  if (!event) return false;
+  const id = isRecord2(part) ? stringValue(part.id) : void 0;
+  if (id) {
+    if (state.legacyStepFinishPartIds.has(id)) return true;
+    state.legacyStepFinishPartIds.add(id);
+  }
+  closeLegacyOpenParts({ state, emit });
+  state.turnUsage = event.usage;
+  emit(event);
+  return true;
+}
 function emitLegacyToolPart({
   part,
   state,
@@ -1704,9 +1855,9 @@ function legacyToolPartStatus(part) {
 function legacyToolPartInput(part) {
   const state = typeof part.state === "object" && part.state !== null ? part.state : void 0;
   return {
-    ...isRecord(part.metadata) ? part.metadata : {},
-    ...isRecord(state?.metadata) ? state.metadata : {},
-    ...isRecord(state?.input) ? state.input : {}
+    ...isRecord2(part.metadata) ? part.metadata : {},
+    ...isRecord2(state?.metadata) ? state.metadata : {},
+    ...isRecord2(state?.input) ? state.input : {}
   };
 }
 function legacyToolPartOutput(part) {
@@ -1716,7 +1867,7 @@ function legacyToolPartOutput(part) {
   }
   return state?.output ?? state?.result ?? state?.structured ?? state?.content ?? null;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function parseToolInput(state, props) {
@@ -1912,7 +2063,7 @@ async function emitContextFallback({
   emit({
     type: "finish-step",
     finishReason: {
-      unified: mapFinishReason(rawFinish),
+      unified: mapOpenCodeFinishReason(rawFinish),
       raw: rawFinish
     },
     usage: mapUsage(assistant.tokens),
@@ -1989,16 +2140,6 @@ function emitAssistantContentPart(part, emit) {
   if (text) emit({ type: "reasoning-delta", id, delta: text });
   emit({ type: "reasoning-end", id });
 }
-function mapFinishReason(reason) {
-  const normalized = reason.toLowerCase();
-  if (normalized.includes("length")) return "length";
-  if (normalized.includes("filter")) return "content-filter";
-  if (normalized.includes("tool")) return "tool-calls";
-  if (normalized.includes("error") || normalized.includes("fail"))
-    return "error";
-  if (normalized === "stop" || normalized === "end") return "stop";
-  return "other";
-}
 async function startToolRelay({
   allowedScriptPaths,
   tools,
@@ -2123,13 +2264,13 @@ function modelRefFromAssistantSnapshot(assistant) {
   if (model) return model;
   const direct = modelRefFromValue(assistant);
   if (direct) return direct;
-  if (isRecord(assistant.metadata)) {
+  if (isRecord2(assistant.metadata)) {
     return modelRefFromValue(assistant.metadata.assistant);
   }
   return void 0;
 }
 function modelRefFromSessionInfo(data) {
-  if (!isRecord(data)) return void 0;
+  if (!isRecord2(data)) return void 0;
   return modelRefFromValue(data.model) ?? modelRefFromValue(data);
 }
 function modelRefFromStart(start) {
@@ -2141,7 +2282,7 @@ function modelRefFromStart(start) {
   };
 }
 function modelRefFromValue(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const providerID = stringValue(value.providerID);
   const modelID = stringValue(value.modelID ?? value.id);
   if (!providerID || !modelID) return void 0;
@@ -2180,14 +2321,8 @@ function formatError(error) {
     return String(error);
   }
 }
-function serialiseError2(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  return err;
-}
 function emitFatal(message) {
-  process.stderr.write(`[opencode bridge] ${message}
+  process.stderr.write(`[OpenCode bridge] ${message}
 `);
   process.exit(1);
 }