@ai-sdk/harness-codex 1.0.41 → 1.0.43

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @ai-sdk/harness-codex
 
+## 1.0.43
+
+### Patch Changes
+
+- 07c977a: chore(harness): refactor bridge code to break out stream event emission from launcher to make it testable
+- 560db3a: fix(harness-codex): fix obsolete default Codex model ID
+- Updated dependencies [a94425b]
+- Updated dependencies [2de0611]
+  - @ai-sdk/harness@1.0.41
+
+## 1.0.42
+
+### Patch Changes
+
+- Updated dependencies [59a2306]
+- Updated dependencies [5f65e61]
+  - @ai-sdk/harness@1.0.40
+
 ## 1.0.41
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -53,6 +53,7 @@ async function runBridge(options) {
   let currentBoundPort = 0;
   let currentTurnState = "init";
   let activeSocket;
+  let activeSocketReadyForLiveEvents = false;
   let isFirstTurn = true;
   let turnAbort;
   let currentUserMessages;
@@ -152,7 +153,7 @@ async function runBridge(options) {
     diskBuffer += `${line}
 `;
     scheduleEventFlush();
-    if (activeSocket?.readyState === WS_OPEN) {
+    if (activeSocketReadyForLiveEvents && activeSocket?.readyState === WS_OPEN) {
       try {
         activeSocket.send(line);
       } catch {
@@ -255,6 +256,8 @@ async function runBridge(options) {
   const handleInbound = async (msg, ws) => {
     switch (msg.type) {
       case "start": {
+        if (activeSocket !== ws) return;
+        activeSocketReadyForLiveEvents = true;
         const firstTurn = isFirstTurn;
         isFirstTurn = false;
         eventLog = [];
@@ -357,7 +360,9 @@ async function runBridge(options) {
         }
         return;
       case "resume":
+        if (activeSocket !== ws) return;
         replay(ws, msg.lastSeenEventId);
+        activeSocketReadyForLiveEvents = true;
         return;
       case "shutdown":
         currentTurnState = "done";
@@ -422,6 +427,7 @@ async function runBridge(options) {
       return;
     }
     activeSocket = ws;
+    activeSocketReadyForLiveEvents = false;
     sendControl({
       type: "bridge-hello",
       state: currentTurnState,
@@ -444,6 +450,7 @@ async function runBridge(options) {
     ws.on("close", () => {
       if (activeSocket === ws) {
         activeSocket = void 0;
+        activeSocketReadyForLiveEvents = false;
       }
     });
     ws.on("error", () => {
@@ -478,7 +485,6 @@ function serialiseError(err) {
 }
 
 // src/bridge/index.ts
-import { randomUUID } from "crypto";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 
 // src/bridge/cli-relay.ts
@@ -724,6 +730,198 @@ function defaultUsage() {
   };
 }
 
+// src/bridge/create-emit-stream-event.ts
+import { randomUUID } from "crypto";
+var NATIVE_TO_COMMON = {
+  shell: "bash",
+  web_search: "webSearch"
+};
+function toCommonName(nativeName) {
+  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
+}
+function createEmitStreamEvent({
+  send,
+  stepTracker,
+  setTurnUsage,
+  setThreadId,
+  emitWarning,
+  emitError
+}) {
+  const textByItem = /* @__PURE__ */ new Map();
+  const reasoningByItem = /* @__PURE__ */ new Map();
+  return (event) => {
+    if (event.type === "thread.started" && typeof event.thread_id === "string") {
+      setThreadId(event.thread_id);
+      send({ type: "bridge-thread", threadId: event.thread_id });
+    }
+    if (event.type === "turn.completed") {
+      if (event.usage) setTurnUsage(mapUsage(event.usage));
+      stepTracker.finishStep();
+      return;
+    }
+    if (event.type === "turn.failed") {
+      emitError({
+        error: event.error?.message ?? "codex turn failed",
+        message: "codex turn failed"
+      });
+      return;
+    }
+    if (event.type === "error") {
+      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 = () => {
+      stepTracker.observeEvent({ event, itemId: id });
+    };
+    if (item.type === "agent_message" && typeof item.text === "string") {
+      if (!textByItem.has(id)) {
+        send({ type: "text-start", id });
+        textByItem.set(id, "");
+      }
+      const last = textByItem.get(id) ?? "";
+      const next = item.text;
+      if (next.length > last.length) {
+        send({ type: "text-delta", id, delta: next.slice(last.length) });
+        textByItem.set(id, next);
+      }
+      if (event.type === "item.completed") send({ type: "text-end", id });
+      observeStep();
+      return;
+    }
+    if (item.type === "reasoning" && typeof item.text === "string") {
+      if (!reasoningByItem.has(id)) {
+        send({ type: "reasoning-start", id });
+        reasoningByItem.set(id, "");
+      }
+      const last = reasoningByItem.get(id) ?? "";
+      const next = item.text;
+      if (next.length > last.length) {
+        send({ type: "reasoning-delta", id, delta: next.slice(last.length) });
+        reasoningByItem.set(id, next);
+      }
+      if (event.type === "item.completed") send({ type: "reasoning-end", id });
+      observeStep();
+      return;
+    }
+    if (item.type === "command_execution") {
+      const nativeName = "shell";
+      if (event.type === "item.started") {
+        send({
+          type: "tool-call",
+          toolCallId: id,
+          toolName: toCommonName(nativeName),
+          nativeName,
+          input: JSON.stringify({ command: item.command ?? "" }),
+          providerExecuted: true
+        });
+      } else if (event.type === "item.completed") {
+        send({
+          type: "tool-result",
+          toolCallId: id,
+          toolName: toCommonName(nativeName),
+          result: {
+            exitCode: item.exit_code ?? null,
+            output: item.aggregated_output ?? "",
+            status: item.status ?? "completed"
+          }
+        });
+      }
+      observeStep();
+      return;
+    }
+    if (item.type === "mcp_tool_call") {
+      if (event.type === "item.started") {
+        send({
+          type: "tool-call",
+          toolCallId: id,
+          toolName: item.tool ?? "unknown",
+          nativeName: item.tool ?? "unknown",
+          input: JSON.stringify(item.arguments ?? {}),
+          providerExecuted: true
+        });
+      } else if (event.type === "item.completed") {
+        send({
+          type: "tool-result",
+          toolCallId: id,
+          toolName: item.tool ?? "unknown",
+          result: extractMcpToolCallResult(item)
+        });
+      }
+      observeStep();
+      return;
+    }
+    if (item.type === "web_search") {
+      const nativeName = "web_search";
+      if (event.type === "item.started") {
+        send({
+          type: "tool-call",
+          toolCallId: id,
+          toolName: toCommonName(nativeName),
+          nativeName,
+          input: JSON.stringify({ query: item.query ?? "" }),
+          providerExecuted: true
+        });
+      } else if (event.type === "item.completed") {
+        send({
+          type: "tool-result",
+          toolCallId: id,
+          toolName: toCommonName(nativeName),
+          result: item.result ?? null
+        });
+      }
+      observeStep();
+      return;
+    }
+    if (item.type === "file_change" && event.type === "item.completed") {
+      for (const change of item.changes ?? []) {
+        send({
+          type: "file-change",
+          event: change.kind === "add" ? "create" : change.kind === "delete" ? "delete" : "modify",
+          path: change.path
+        });
+      }
+      observeStep();
+      return;
+    }
+    if (item.type === "error" && event.type === "item.completed") {
+      const message = typeof item.message === "string" && item.message.trim() ? item.message : "codex reported a non-fatal error item";
+      emitWarning({ message });
+    }
+  };
+}
+function extractMcpToolCallResult(item) {
+  if (item.result === void 0 || item.result === null || typeof item.result !== "object") {
+    return item.error?.message ? { error: item.error.message } : null;
+  }
+  const result = item.result;
+  if (result.structured_content !== void 0 && result.structured_content !== null) {
+    return result.structured_content;
+  }
+  return result.content ?? null;
+}
+function mapUsage(usage) {
+  const input = usage.input_tokens ?? 0;
+  const cacheRead = usage.cached_input_tokens ?? 0;
+  return {
+    inputTokens: {
+      total: input,
+      noCache: Math.max(0, input - cacheRead),
+      cacheRead,
+      cacheWrite: 0
+    },
+    outputTokens: {
+      total: usage.output_tokens ?? 0,
+      text: usage.output_tokens ?? 0
+    }
+  };
+}
+
 // src/bridge/tool-relay.ts
 import { createServer } from "http";
 
@@ -941,13 +1139,6 @@ function closeServer(server) {
 // src/bridge/index.ts
 import { argv, env as procEnv2, stdout as stdout2 } from "process";
 import * as codexSdkModule from "@openai/codex-sdk";
-var NATIVE_TO_COMMON = {
-  shell: "bash",
-  web_search: "webSearch"
-};
-function toCommonName(nativeName) {
-  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
-}
 var args = parseArgs(argv.slice(2));
 var workdir = requireArg({ value: args.workdir, name: "--workdir" });
 var bridgeStateDir = requireArg({
@@ -1040,19 +1231,21 @@ async function runTurn(start, turn) {
   emit({ type: "stream-start" });
   const userMessage = start.prompt;
   let turnUsage;
-  const textByItem = /* @__PURE__ */ new Map();
-  const reasoningByItem = /* @__PURE__ */ new Map();
   const stepTracker = createCodexStepTracker({ send: emit });
+  const emitStreamEvent = createEmitStreamEvent({
+    send: emit,
+    stepTracker,
+    setTurnUsage: (usage) => turnUsage = usage,
+    setThreadId: (threadId) => threadState.id = threadId,
+    emitWarning: turn.emitWarning,
+    emitError: turn.emitError
+  });
   try {
     const { events } = await thread.runStreamed(userMessage, {
       signal: turn.abortSignal
     });
     for await (const event of events) {
       if (turn.abortSignal.aborted) break;
-      if (event.type === "thread.started" && typeof event.thread_id === "string") {
-        threadState.id = event.thread_id;
-        emit({ type: "bridge-thread", threadId: event.thread_id });
-      }
       if (cliShimPath && event.item?.type === "command_execution") {
         const relayCalls = typeof event.item.command === "string" ? parseToolRelayCommands({
           command: event.item.command,
@@ -1068,15 +1261,7 @@ async function runTurn(start, turn) {
           continue;
         }
       }
-      translateAndEmit(event, {
-        send: emit,
-        textByItem,
-        reasoningByItem,
-        stepTracker,
-        setTurnUsage: (u) => turnUsage = u,
-        emitWarning: turn.emitWarning,
-        emitError: turn.emitError
-      });
+      emitStreamEvent(event);
     }
   } catch (err) {
     turn.emitError({ error: err, message: "codex turn failed" });
@@ -1091,175 +1276,6 @@ async function runTurn(start, turn) {
   });
   void turn.pendingUserMessages;
 }
-function extractMcpToolCallResult(item) {
-  if (item.result === void 0 || item.result === null || typeof item.result !== "object") {
-    return item.error?.message ? { error: item.error.message } : null;
-  }
-  const result = item.result;
-  if (result.structured_content !== void 0 && result.structured_content !== null) {
-    return result.structured_content;
-  }
-  return result.content ?? null;
-}
-function translateAndEmit(event, ctx) {
-  if (event.type === "turn.completed") {
-    if (event.usage) ctx.setTurnUsage(mapUsage(event.usage));
-    ctx.stepTracker.finishStep();
-    return;
-  }
-  if (event.type === "turn.failed") {
-    ctx.emitError({
-      error: event.error?.message ?? "codex turn failed",
-      message: "codex turn failed"
-    });
-    return;
-  }
-  if (event.type === "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 });
-      ctx.textByItem.set(id, "");
-    }
-    const last = ctx.textByItem.get(id) ?? "";
-    const next = item.text;
-    if (next.length > last.length) {
-      ctx.send({ type: "text-delta", id, delta: next.slice(last.length) });
-      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") {
-    if (!ctx.reasoningByItem.has(id)) {
-      ctx.send({ type: "reasoning-start", id });
-      ctx.reasoningByItem.set(id, "");
-    }
-    const last = ctx.reasoningByItem.get(id) ?? "";
-    const next = item.text;
-    if (next.length > last.length) {
-      ctx.send({ type: "reasoning-delta", id, delta: next.slice(last.length) });
-      ctx.reasoningByItem.set(id, next);
-    }
-    if (event.type === "item.completed")
-      ctx.send({ type: "reasoning-end", id });
-    observeStep();
-    return;
-  }
-  if (item.type === "command_execution") {
-    const nativeName = "shell";
-    if (event.type === "item.started") {
-      ctx.send({
-        type: "tool-call",
-        toolCallId: id,
-        toolName: toCommonName(nativeName),
-        nativeName,
-        input: JSON.stringify({ command: item.command ?? "" }),
-        providerExecuted: true
-      });
-    } else if (event.type === "item.completed") {
-      ctx.send({
-        type: "tool-result",
-        toolCallId: id,
-        toolName: toCommonName(nativeName),
-        result: {
-          exitCode: item.exit_code ?? null,
-          output: item.aggregated_output ?? "",
-          status: item.status ?? "completed"
-        }
-      });
-    }
-    observeStep();
-    return;
-  }
-  if (item.type === "mcp_tool_call") {
-    if (event.type === "item.started") {
-      ctx.send({
-        type: "tool-call",
-        toolCallId: id,
-        toolName: item.tool ?? "unknown",
-        nativeName: item.tool ?? "unknown",
-        input: JSON.stringify(item.arguments ?? {}),
-        providerExecuted: true
-      });
-    } else if (event.type === "item.completed") {
-      ctx.send({
-        type: "tool-result",
-        toolCallId: id,
-        toolName: item.tool ?? "unknown",
-        result: extractMcpToolCallResult(item)
-      });
-    }
-    observeStep();
-    return;
-  }
-  if (item.type === "web_search") {
-    const nativeName = "web_search";
-    if (event.type === "item.started") {
-      ctx.send({
-        type: "tool-call",
-        toolCallId: id,
-        toolName: toCommonName(nativeName),
-        nativeName,
-        input: JSON.stringify({ query: item.query ?? "" }),
-        providerExecuted: true
-      });
-    } else if (event.type === "item.completed") {
-      ctx.send({
-        type: "tool-result",
-        toolCallId: id,
-        toolName: toCommonName(nativeName),
-        result: item.result ?? null
-      });
-    }
-    observeStep();
-    return;
-  }
-  if (item.type === "file_change" && event.type === "item.completed") {
-    for (const change of item.changes ?? []) {
-      ctx.send({
-        type: "file-change",
-        event: change.kind === "add" ? "create" : change.kind === "delete" ? "delete" : "modify",
-        path: change.path
-      });
-    }
-    observeStep();
-    return;
-  }
-  if (item.type === "error" && event.type === "item.completed") {
-    const message = typeof item.message === "string" && item.message.trim() ? item.message : "codex reported a non-fatal error item";
-    ctx.emitWarning({ message });
-    return;
-  }
-}
-function mapUsage(usage) {
-  const input = usage.input_tokens ?? 0;
-  const cacheRead = usage.cached_input_tokens ?? 0;
-  return {
-    inputTokens: {
-      total: input,
-      noCache: Math.max(0, input - cacheRead),
-      cacheRead,
-      cacheWrite: 0
-    },
-    outputTokens: {
-      total: usage.output_tokens ?? 0,
-      text: usage.output_tokens ?? 0
-    }
-  };
-}
 async function startToolRelay({
   tools,
   emit,