@ai-sdk/harness-codex 1.0.42 → 1.0.43

package/src/bridge/index.ts

@@ -14,9 +14,7 @@ import {
   type BridgeEvent,
   type BridgeTurn,
 } from '@ai-sdk/harness/bridge';
-import type { HarnessV1BuiltinToolName } from '@ai-sdk/harness';
 import type { StartMessage } from '../codex-bridge-protocol';
-import { randomUUID } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 // Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
 import {
@@ -24,11 +22,11 @@ import {
   buildCliShimScript,
   parseToolRelayCommands,
 } from './cli-relay';
+import { createCodexStepTracker, defaultUsage } from './codex-step-tracker';
 import {
-  createCodexStepTracker,
-  defaultUsage,
-  type CodexStepTracker,
-} from './codex-step-tracker';
+  createEmitStreamEvent,
+  type CodexEvent,
+} from './create-emit-stream-event';
 import { startAuthorizedToolRelay, type ToolRelay } from './tool-relay';
 import { argv, env as procEnv, stdout } from 'node:process';
 
@@ -51,20 +49,6 @@ import { argv, env as procEnv, stdout } from 'node:process';
  */
 import * as codexSdkModule from '@openai/codex-sdk';
 
-/*
- * Native Codex tool name → cross-harness common name. Tools outside this map
- * (e.g. MCP tools the model invokes by name) have no common equivalent; their
- * native name is forwarded as-is on `tool-call` events.
- */
-const NATIVE_TO_COMMON: Readonly<Record<string, HarnessV1BuiltinToolName>> = {
-  shell: 'bash',
-  web_search: 'webSearch',
-};
-
-function toCommonName(nativeName: string): HarnessV1BuiltinToolName | string {
-  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
-}
-
 const args = parseArgs(argv.slice(2));
 const workdir = requireArg({ value: args.workdir, name: '--workdir' });
 const bridgeStateDir = requireArg({
@@ -202,9 +186,15 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
 
   const userMessage = start.prompt;
   let turnUsage: Record<string, unknown> | undefined;
-  const textByItem = new Map<string, string>();
-  const reasoningByItem = new Map<string, string>();
   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, {
@@ -212,14 +202,6 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     });
     for await (const event of events as AsyncIterable<CodexEvent>) {
       if (turn.abortSignal.aborted) break;
-      if (
-        event.type === 'thread.started' &&
-        typeof event.thread_id === 'string'
-      ) {
-        threadState.id = event.thread_id;
-        // Announce to the host so it can include the id in resume state.
-        emit({ type: 'bridge-thread', threadId: event.thread_id });
-      }
       // Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
       if (cliShimPath && event.item?.type === 'command_execution') {
         const relayCalls =
@@ -239,15 +221,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
           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' });
@@ -265,259 +239,6 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   void turn.pendingUserMessages; // accepted but only consumed when codex supports streamed user input
 }
 
-type CodexItem = {
-  type: string;
-  id?: string;
-  text?: string;
-  command?: string;
-  exit_code?: number;
-  aggregated_output?: string;
-  status?: 'in_progress' | 'completed' | 'failed';
-  server?: string;
-  tool?: string;
-  arguments?: unknown;
-  result?: { content?: unknown; structured_content?: unknown } | unknown;
-  error?: { message?: string };
-  query?: string;
-  message?: string;
-  changes?: ReadonlyArray<{
-    path: string;
-    kind: 'add' | 'delete' | 'update';
-  }>;
-};
-
-function extractMcpToolCallResult(item: CodexItem): unknown {
-  if (
-    item.result === undefined ||
-    item.result === null ||
-    typeof item.result !== 'object'
-  ) {
-    return item.error?.message ? { error: item.error.message } : null;
-  }
-  const result = item.result as {
-    content?: unknown;
-    structured_content?: unknown;
-  };
-  if (
-    result.structured_content !== undefined &&
-    result.structured_content !== null
-  ) {
-    return result.structured_content;
-  }
-  return result.content ?? null;
-}
-
-type CodexEvent = {
-  type:
-    | 'thread.started'
-    | 'turn.completed'
-    | 'turn.failed'
-    | 'error'
-    | 'item.started'
-    | 'item.updated'
-    | 'item.completed';
-  item?: CodexItem;
-  usage?: Record<string, number>;
-  error?: { message: string };
-  message?: string;
-  thread_id?: string;
-};
-
-function translateAndEmit(
-  event: CodexEvent,
-  ctx: {
-    send: Emit;
-    textByItem: Map<string, string>;
-    reasoningByItem: Map<string, string>;
-    stepTracker: CodexStepTracker;
-    setTurnUsage: (u: Record<string, unknown>) => void;
-    emitWarning: BridgeTurn['emitWarning'];
-    emitError: BridgeTurn['emitError'];
-  },
-): void {
-  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 = (): void => {
-    ctx.stepTracker.observeEvent({ event, itemId: id });
-  };
-
-  if (item.type === 'agent_message' && typeof item.text === 'string') {
-    /*
-     * The presence of `id` in `textByItem` — not the `item.started` event —
-     * marks the text part as opened. Codex does not guarantee an
-     * `item.started` event carrying text precedes the first `item.updated`
-     * with text, so keying the `text-start` off the event type can emit a
-     * `text-delta` for a part that was never opened. Opening lazily on the
-     * first event with text keeps `text-start` before any `text-delta`.
-     */
-    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: Record<string, number>): Record<string, unknown> {
-  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,
-    },
-  };
-}
-
 /**
  * Tool relay — HTTP server on 127.0.0.1:0. The CLI shim invoked by Codex POSTs
  * each tool invocation here; the relay forwards the call to the host (via the

package/src/codex-harness.ts

@@ -60,12 +60,12 @@ type WriteSkillsResult = {
  * The model the adapter pins when the consumer configures none. The Codex SDK
  * does not report the model it resolves to at runtime (no model field on any
  * event), and exposes no default-model constant, so we pin the latest
- * codex-specialized model available for the bundled `@openai/codex@0.130.0`
- * (published 2026-05-08): `gpt-5.3-codex` (released 2026-02). Keep this in sync
- * when bumping the codex SDK/binary. Passing it explicitly makes the resolved
- * model deterministic and the telemetry (`gen_ai.request.model`) accurate.
+ * default model resolved by the bundled `@openai/codex@0.144.5`:
+ * `gpt-5.6-sol`. Keep this in sync when bumping the codex SDK/binary. Passing
+ * it explicitly makes the resolved model deterministic and the telemetry
+ * (`gen_ai.request.model`) accurate.
  */
-const DEFAULT_CODEX_MODEL = 'gpt-5.3-codex';
+const DEFAULT_CODEX_MODEL = 'gpt-5.6-sol';
 
 /**
  * Value to use in User-Agent and `x-client-app` headers.