@ai-sdk/harness-codex 1.0.23 → 1.0.24

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @ai-sdk/harness-codex
 
+## 1.0.24
+
+### 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.23
 
 ### 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) {
@@ -555,6 +620,54 @@ function parseShellWords(command) {
   return words;
 }
 
+// src/bridge/codex-step-tracker.ts
+function createCodexStepTracker(input) {
+  let stepOpen = false;
+  const pendingToolItemIds = /* @__PURE__ */ new Set();
+  const finishStep = () => {
+    if (!stepOpen || pendingToolItemIds.size > 0) return;
+    input.send({
+      type: "finish-step",
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: defaultUsage(),
+      harnessMetadata: { codex: { inferredStep: true } }
+    });
+    stepOpen = false;
+  };
+  return {
+    observeEvent({ event, itemId }) {
+      const item = event.item;
+      if (!item || !isStepItem(item)) return;
+      stepOpen = true;
+      if (isToolStepItem(item)) {
+        if (event.type === "item.started" && itemId) {
+          pendingToolItemIds.add(itemId);
+        } else if (event.type === "item.completed") {
+          if (itemId) pendingToolItemIds.delete(itemId);
+          finishStep();
+        }
+        return;
+      }
+    },
+    finishStep
+  };
+}
+function isStepItem(item) {
+  return isModelStepItem(item) || isToolStepItem(item);
+}
+function isModelStepItem(item) {
+  return item.type === "reasoning" || item.type === "agent_message";
+}
+function isToolStepItem(item) {
+  return item.type === "command_execution" || item.type === "mcp_tool_call" || item.type === "web_search" || item.type === "file_change" || item.type === "todo_list";
+}
+function defaultUsage() {
+  return {
+    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+    outputTokens: { total: 0, text: 0 }
+  };
+}
+
 // src/bridge/tool-relay-auth.ts
 import { readdir, readFile, readlink } from "fs/promises";
 var ToolRelayAuthorizer = class {
@@ -819,6 +932,7 @@ async function runTurn(start, turn) {
   let turnUsage;
   const textByItem = /* @__PURE__ */ new Map();
   const reasoningByItem = /* @__PURE__ */ new Map();
+  const stepTracker = createCodexStepTracker({ send: emit });
   try {
     const { events } = await thread.runStreamed(userMessage, {
       signal: turn.abortSignal
@@ -842,10 +956,12 @@ async function runTurn(start, turn) {
           }
         }
         if (relayCall) {
+          stepTracker.observeEvent({ event, itemId: event.item.id });
           continue;
         }
       }
       if (relay && isHostMcpToolEvent(event)) {
+        stepTracker.observeEvent({ event, itemId: event.item?.id });
         const relayCall = relayCallFromCodexMcpEvent(event);
         if (relayCall) relay.authorizeToolCall(relayCall);
         continue;
@@ -854,11 +970,14 @@ async function runTurn(start, turn) {
         send: emit,
         textByItem,
         reasoningByItem,
-        setTurnUsage: (u) => turnUsage = u
+        stepTracker,
+        setTurnUsage: (u) => turnUsage = u,
+        emitWarning: turn.emitWarning,
+        emitError: turn.emitError
       });
     }
   } catch (err) {
-    emit({ type: "error", error: serialiseError2(err) });
+    turn.emitError({ error: err, message: "codex turn failed" });
     return;
   } finally {
     relay?.close();
@@ -895,27 +1014,29 @@ function relayCallFromCodexMcpEvent(event) {
 function translateAndEmit(event, ctx) {
   if (event.type === "turn.completed") {
     if (event.usage) ctx.setTurnUsage(mapUsage(event.usage));
-    ctx.send({
-      type: "finish-step",
-      finishReason: { unified: "stop", raw: "stop" },
-      usage: event.usage ? mapUsage(event.usage) : defaultUsage()
-    });
+    ctx.stepTracker.finishStep();
     return;
   }
   if (event.type === "turn.failed") {
-    ctx.send({
-      type: "error",
-      error: event.error?.message ?? "codex turn failed"
+    ctx.emitError({
+      error: event.error?.message ?? "codex turn failed",
+      message: "codex turn failed"
     });
     return;
   }
   if (event.type === "error") {
-    ctx.send({ type: "error", error: event.message ?? "codex error" });
+    ctx.emitError({
+      error: event.message ?? "codex error",
+      message: "codex stream error"
+    });
     return;
   }
   if (!event.item) return;
   const item = event.item;
   const id = item.id ?? randomUUID();
+  const observeStep = () => {
+    ctx.stepTracker.observeEvent({ event, itemId: id });
+  };
   if (item.type === "agent_message" && typeof item.text === "string") {
     if (!ctx.textByItem.has(id)) {
       ctx.send({ type: "text-start", id });
@@ -928,6 +1049,7 @@ function translateAndEmit(event, ctx) {
       ctx.textByItem.set(id, next);
     }
     if (event.type === "item.completed") ctx.send({ type: "text-end", id });
+    observeStep();
     return;
   }
   if (item.type === "reasoning" && typeof item.text === "string") {
@@ -943,6 +1065,7 @@ function translateAndEmit(event, ctx) {
     }
     if (event.type === "item.completed")
       ctx.send({ type: "reasoning-end", id });
+    observeStep();
     return;
   }
   if (item.type === "command_execution") {
@@ -968,6 +1091,7 @@ function translateAndEmit(event, ctx) {
         }
       });
     }
+    observeStep();
     return;
   }
   if (item.type === "mcp_tool_call") {
@@ -989,6 +1113,7 @@ function translateAndEmit(event, ctx) {
         result: extractMcpToolCallResult(item)
       });
     }
+    observeStep();
     return;
   }
   if (item.type === "web_search") {
@@ -1010,6 +1135,7 @@ function translateAndEmit(event, ctx) {
         result: item.result ?? null
       });
     }
+    observeStep();
     return;
   }
   if (item.type === "file_change" && event.type === "item.completed") {
@@ -1020,13 +1146,12 @@ function translateAndEmit(event, ctx) {
         path: change.path
       });
     }
+    observeStep();
     return;
   }
   if (item.type === "error" && event.type === "item.completed") {
-    ctx.send({
-      type: "error",
-      error: item.message ?? "codex item error"
-    });
+    const message = typeof item.message === "string" && item.message.trim() ? item.message : "codex reported a non-fatal error item";
+    ctx.emitWarning({ message });
     return;
   }
 }
@@ -1046,12 +1171,6 @@ function mapUsage(usage) {
     }
   };
 }
-function defaultUsage() {
-  return {
-    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
-    outputTokens: { total: 0, text: 0 }
-  };
-}
 async function startToolRelay({
   allowedScriptPaths,
   tools,
@@ -1160,12 +1279,6 @@ function parseArgs(args2) {
   }
   return out;
 }
-function serialiseError2(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  return err;
-}
 function emitFatal(message) {
   stdout2.write(JSON.stringify({ type: "bridge-fatal", message }) + "\n");
   process.exit(1);