@ai-sdk/harness-codex 1.0.126 → 1.0.129

package/src/bridge/index.ts

@@ -1,13 +1,9 @@
-// Long-running process that runs alongside the `codex` CLI in the sandbox.
-// The generic transport — WebSocket server, token auth, single-flight
-// reconnect, the in-memory event log + `seq`, resume replay, and the
-// lifecycle/meta files — lives in the shared `@ai-sdk/harness/bridge` runtime.
-// This file supplies only the Codex-specific turn driver.
-//
-// Host-defined tools are routed through an HTTP relay bound to
-// `127.0.0.1:0`. The bridge writes a CLI shim into the per-session runtime
-// directory; the shim POSTs each tool call to the relay, which emits
-// `tool-call` to the host and waits for the matching `tool-result`.
+/*
+ * This long-running bridge process runs Codex app-server in the sandbox. The
+ * shared bridge runtime owns the WebSocket transport, authentication,
+ * reconnects, event replay, and lifecycle files; this entry point supplies the
+ * Codex-specific turn implementation.
+ */
 
 import {
   runBridge,
@@ -15,64 +11,32 @@ import {
   type BridgeTurn,
 } from '@ai-sdk/harness/bridge';
 import type { StartMessage } from '../codex-bridge-protocol';
-import { mkdir, writeFile } from 'node:fs/promises';
-// Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
-import {
-  CLI_SHIM_FILENAME,
-  buildCliShimScript,
-  parseToolRelayCommands,
-} from './cli-relay';
+import { createCodexAppServerRuntime } from './codex-app-server-driver';
 import { createCodexStepTracker, defaultUsage } from './codex-step-tracker';
-import {
-  createEmitStreamEvent,
-  type CodexEvent,
-} from './create-emit-stream-event';
-import { startAuthorizedToolRelay, type ToolRelay } from './tool-relay';
+import { createEmitStreamEvent } from './create-emit-stream-event';
 import { argv, env as procEnv, stdout } from 'node:process';
 
-/*
- * CONSTRAINT — the third-party imports below are NEVER bundled into the
- * compiled `bridge/index.mjs`. They are declared `external` in
- * tsup.config.ts and resolved at runtime from the node_modules that this
- * bridge installs *inside the sandbox* from `src/bridge/package.json` (and
- * its pinned `pnpm-lock.yaml`). That bridge package.json — NOT this host
- * package — is the single source of truth for these packages and their
- * versions; the published `@ai-sdk/harness-codex` package does not provide
- * them at runtime.
- *
- * When adding or changing a third-party import here you MUST keep all three
- * in sync, or the bridge will either get the dependency bundled in or fail
- * to resolve it in the sandbox:
- *   1. the import statement below,
- *   2. the `external` array in tsup.config.ts, and
- *   3. the dependency entry in `src/bridge/package.json`.
- */
-import * as codexSdkModule from '@openai/codex-sdk';
-
 const args = parseArgs(argv.slice(2));
 const workdir = requireArg({ value: args.workdir, name: '--workdir' });
 const bridgeStateDir = requireArg({
   value: args.bridgeStateDir,
   name: '--bridge-state-dir',
 });
-const cliShimDir = requireArg({
-  value: args.cliShimDir,
-  name: '--cli-shim-dir',
-});
 const HARNESS_CLIENT_APP = procEnv.AI_SDK_HARNESS_CLIENT_APP;
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const codexSdk = codexSdkModule as any;
-
-// Codex thread id — survives across turns within this bridge process and is
-// returned to the host on `stop` so a future process can resume the thread.
 const threadState: { id: string | undefined } = { id: undefined };
+const appServer = createCodexAppServerRuntime();
 
 await runBridge<StartMessage>({
   bridgeType: 'codex',
   bridgeStateDir,
   onStart: runTurn,
-  onStop: () => (threadState.id ? { threadId: threadState.id } : {}),
+  onStop: async () => {
+    const data = threadState.id ? { threadId: threadState.id } : {};
+    await appServer.close();
+    return data;
+  },
+  onDestroy: () => appServer.close(),
 });
 
 type Emit = (msg: Record<string, unknown>) => void;
@@ -80,9 +44,6 @@ type Emit = (msg: Record<string, unknown>) => void;
 async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   const emit: Emit = msg => turn.emit(msg as BridgeEvent);
 
-  // Cross-process resume: the host carries the threadId we returned on stop.
-  // Seed `threadState.id` so the codex SDK call below takes the `resumeThread`
-  // branch.
   if (start.restartThread) {
     threadState.id = undefined;
   } else if (
@@ -92,36 +53,50 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     threadState.id = start.resumeThreadId;
   }
 
-  /*
-   * Known limitation: codex CLI does not reliably surface MCP tools to the
-   * model in `codex exec --experimental-json` mode (the path the
-   * `@openai/codex-sdk` uses). Some versions do not register MCP tools at all;
-   * others expose the tool names but pass empty arguments.
-   *
-   * Until that's fixed, host tools are made available to the model via a
-   * separate CLI-relay workaround (see `./cli-relay.ts`). Writing the shim
-   * here, adding matching prompt guidance in the host adapter, and filtering
-   * the shim command below implement the workaround and can be removed once the
-   * upstream bug is fixed.
-   */
-  let relay: ToolRelay | undefined;
-  let cliShimPath: string | undefined;
-  if (start.tools && start.tools.length > 0) {
-    cliShimPath = `${cliShimDir}/${CLI_SHIM_FILENAME}`;
-    relay = await startToolRelay({
-      tools: start.tools,
+  const runtime = resolveCodexRuntime({ start });
+  let turnUsage: Record<string, unknown> = defaultUsage();
+  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 {
+    await appServer.runTurn({
+      start,
+      turn,
       emit,
-      requestToolResult: turn.requestToolResult,
+      workdir,
+      threadId: threadState.id,
+      codexModel: runtime.codexModel,
+      codexConfig: runtime.codexConfig,
+      stepTracker,
+      emitStreamEvent,
     });
-    // Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
-    await mkdir(cliShimDir, { recursive: true });
-    await writeFile(
-      cliShimPath,
-      buildCliShimScript({ relayPort: relay.port }),
-      'utf8',
-    );
+  } catch (error) {
+    if (!turn.abortSignal.aborted) {
+      turn.emitError({ error, message: 'codex turn failed' });
+    }
+    return;
   }
 
+  emit({
+    type: 'finish',
+    finishReason: { unified: 'stop', raw: 'stop' },
+    totalUsage: turnUsage,
+  });
+}
+
+type CodexRuntime = {
+  codexConfig: Record<string, unknown>;
+  codexModel: string | undefined;
+};
+
+function resolveCodexRuntime({ start }: { start: StartMessage }): CodexRuntime {
   const codexConfig: Record<string, unknown> = {
     ...start.codexConfig,
     developer_instructions: [
@@ -140,10 +115,17 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       'AI Gateway auth was selected but AI_GATEWAY_BASE_URL is missing from the Codex bridge environment.',
     );
   }
+  /*
+   * The standalone app-server deliberately ignores CODEX_API_KEY for its
+   * built-in OpenAI provider. A custom provider with an explicit env_key keeps
+   * direct credentials process-local.
+   */
   const apiBaseUrl = hasGatewayAuth
     ? gatewayBaseUrl
     : (procEnv.OPENAI_BASE_URL ??
-      (start.headers != null ? 'https://api.openai.com/v1' : undefined));
+      (procEnv.CODEX_API_KEY != null || start.headers != null
+        ? 'https://api.openai.com/v1'
+        : undefined));
   const codexModel =
     start.model && hasGatewayAuth && !start.model.includes('/')
       ? `openai/${start.model}`
@@ -186,133 +168,22 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   if (start.mcpServers != null) {
     codexConfig.mcp_servers = start.mcpServers;
   }
-  const usesConfiguredModelProvider =
-    typeof codexConfig.model_provider === 'string';
-
-  const codex = new codexSdk.Codex({
-    ...(procEnv.CODEX_API_KEY ? { apiKey: procEnv.CODEX_API_KEY } : {}),
-    ...(!usesConfiguredModelProvider && apiBaseUrl
-      ? { baseUrl: apiBaseUrl }
-      : {}),
-    env: Object.fromEntries(
-      Object.entries(procEnv).filter(
-        (entry): entry is [string, string] => typeof entry[1] === 'string',
-      ),
-    ),
-    ...(Object.keys(codexConfig).length > 0 ? { config: codexConfig } : {}),
-  });
-
-  const threadOptions = {
-    ...(codexModel ? { model: codexModel } : {}),
-    sandboxMode: 'danger-full-access',
-    approvalPolicy: 'never',
-    workingDirectory: workdir,
-    skipGitRepoCheck: true,
-    ...(start.reasoningEffort
-      ? { modelReasoningEffort: start.reasoningEffort }
-      : {}),
-    webSearchMode: start.webSearch ? 'live' : 'disabled',
-  };
-  const thread = threadState.id
-    ? codex.resumeThread(threadState.id, threadOptions)
-    : codex.startThread(threadOptions);
-
-  emit({ type: 'stream-start' });
-
-  const userMessage = start.prompt;
-  let turnUsage: Record<string, unknown> | undefined;
-  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,
-      ...(start.responseFormat?.type === 'json' &&
-      start.responseFormat.schema != null
-        ? { outputSchema: start.responseFormat.schema }
-        : {}),
-    });
-    for await (const event of events as AsyncIterable<CodexEvent>) {
-      if (turn.abortSignal.aborted) break;
-      // Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
-      if (cliShimPath && event.item?.type === 'command_execution') {
-        const relayCalls =
-          typeof event.item.command === 'string'
-            ? parseToolRelayCommands({
-                command: event.item.command,
-                cliShimPath,
-              })
-            : undefined;
-        if (event.type === 'item.started' && relay && relayCalls) {
-          for (const relayCall of relayCalls) {
-            relay.authorizeToolCall(relayCall);
-          }
-        }
-        if (relayCalls) {
-          stepTracker.observeEvent({ event, itemId: event.item.id });
-          continue;
-        }
-      }
-      emitStreamEvent(event);
-    }
-  } catch (err) {
-    turn.emitError({ error: err, message: 'codex turn failed' });
-    return;
-  } finally {
-    relay?.close();
-  }
-
-  emit({
-    type: 'finish',
-    finishReason: { unified: 'stop', raw: 'stop' },
-    totalUsage: turnUsage ?? defaultUsage(),
-  });
-}
-
-/**
- * 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
- * shared runtime's `emit`), awaits the matching `tool-result` (via
- * `requestToolResult`), and responds with `{ result }`.
- */
-async function startToolRelay({
-  tools,
-  emit,
-  requestToolResult,
-}: {
-  tools: ReadonlyArray<{ name: string }>;
-  emit: Emit;
-  requestToolResult: (
-    toolCallId: string,
-  ) => Promise<{ output: unknown; isError?: boolean }>;
-}): Promise<ToolRelay> {
-  return startAuthorizedToolRelay({ tools, emit, requestToolResult });
+  return { codexConfig, codexModel };
 }
 
 function parseArgs(args: string[]): {
   workdir?: string;
   bridgeStateDir?: string;
-  cliShimDir?: string;
 } {
   const out: {
     workdir?: string;
     bridgeStateDir?: string;
-    cliShimDir?: string;
   } = {};
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--workdir' && i + 1 < args.length) {
       out.workdir = args[++i];
     } else if (args[i] === '--bridge-state-dir' && i + 1 < args.length) {
       out.bridgeStateDir = args[++i];
-    } else if (args[i] === '--cli-shim-dir' && i + 1 < args.length) {
-      out.cliShimDir = args[++i];
     }
   }
   return out;

package/src/bridge/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@openai/codex-sdk": "0.155.0",
+    "@openai/codex": "0.155.0",
     "ws": "8.21.0"
   }
 }

package/src/bridge/pnpm-lock.yaml

@@ -8,7 +8,7 @@ importers:
 
   .:
     dependencies:
-      '@openai/codex-sdk':
+      '@openai/codex':
         specifier: 0.155.0
         version: 0.155.0
       ws:
@@ -17,10 +17,6 @@ importers:
 
 packages:
 
-  '@openai/codex-sdk@0.155.0':
-    resolution: {integrity: sha512-oD/7iCZnXqDlrnoWWpGkZExrUStpAau1koyUO/fSW3WwkqewRf+MGj3OS41Buw7gNwj0oM6ilI9RHqP5QQWJaQ==}
-    engines: {node: '>=18'}
-
   '@openai/codex@0.155.0':
     resolution: {integrity: sha512-35a85Hbwy9WXkDTJumLjTcmMgpR7BMdrTloWBVGjoA+FBCh7jb3+cYp2W+3U4klqGAjAskoIvQZv7/eedmCjHA==}
     engines: {node: '>=16'}
@@ -76,10 +72,6 @@ packages:
 
 snapshots:
 
-  '@openai/codex-sdk@0.155.0':
-    dependencies:
-      '@openai/codex': 0.155.0
-
   '@openai/codex@0.155.0':
     optionalDependencies:
       '@openai/codex-darwin-arm64': '@openai/codex@0.155.0-darwin-arm64'

package/src/codex-bridge-protocol.ts

@@ -23,10 +23,10 @@ export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
   codexConfig: z.record(z.string(), z.unknown()).optional(),
   mcpServers: z.record(z.string(), z.unknown()).optional(),
   headers: z.record(z.string(), z.string()).optional(),
-  // Resume signal. When supplied, the bridge calls
-  // `codex.resumeThread(resumeThreadId, …)` instead of starting a fresh thread.
-  // The host sources the id from lifecycle state `data` cached from a prior
-  // `agent.detach`.
+  /*
+   * The host carries this app-server thread ID in lifecycle state. Supplying it
+   * makes the bridge call `thread/resume` instead of starting a fresh thread.
+   */
   resumeThreadId: z.string().optional(),
   restartThread: z.boolean().optional(),
 });