@ai-sdk/harness-codex 1.0.126 → 1.0.129

package/dist/bridge/index.mjs

@@ -643,202 +643,1214 @@ function serialiseError(err) {
   return err;
 }
 
-// src/bridge/index.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+// src/bridge/codex-app-server-driver.ts
+import { createHash as createHash2 } from "crypto";
+import { fileURLToPath } from "url";
 
-// src/bridge/cli-relay.ts
-var CLI_SHIM_FILENAME = "harness-tool.mjs";
-function buildCliShimScript({
-  relayPort
+// src/bridge/codex-tool-filtering.ts
+function resolveCodexBuiltinToolPolicy({
+  builtinToolFiltering,
+  webSearch
 }) {
-  return `#!/usr/bin/env node
-const [toolName, inputJson = '{}'] = process.argv.slice(2);
-if (!toolName) {
-  console.error('Usage: harness-tool <tool_name> <json_input>');
-  process.exit(64);
+  const included = (toolName) => builtinToolFiltering == null || (builtinToolFiltering.mode === "allow" ? builtinToolFiltering.toolNames.includes(toolName) : !builtinToolFiltering.toolNames.includes(toolName));
+  const disabled = {
+    bash: !included("bash"),
+    webSearch: !included("webSearch"),
+    apply_patch: !included("apply_patch"),
+    view_image: !included("view_image")
+  };
+  const disableEnvironments = disabled.bash && disabled.apply_patch && disabled.view_image;
+  return {
+    disabled,
+    disableEnvironments,
+    denyApplyPatchWithHook: disabled.apply_patch && !disableEnvironments,
+    webSearchMode: webSearch && !disabled.webSearch ? "live" : "disabled"
+  };
 }
-let input;
-try {
-  input = JSON.parse(inputJson);
-} catch (error) {
-  console.error('Invalid JSON input: ' + (error instanceof Error ? error.message : String(error)));
-  process.exit(64);
+
+// src/bridge/codex-app-server-client.ts
+import { spawn } from "child_process";
+var CodexAppServerRequestError = class extends Error {
+  constructor({ method, error }) {
+    super(`Codex app-server ${method} failed: ${error.message}`);
+    this.name = "CodexAppServerRequestError";
+    this.method = method;
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+var CodexAppServerClient = class {
+  constructor({
+    executable,
+    args: args2,
+    cwd,
+    env,
+    onNotification,
+    onRequest,
+    onStderr
+  }) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextRequestId = 1;
+    this.stdoutBuffer = "";
+    this.parseQueue = Promise.resolve();
+    this.closed = false;
+    this.resolveFailure = () => {
+    };
+    this.exitResult = null;
+    this.onNotification = onNotification;
+    this.onRequest = onRequest;
+    this.onStderr = onStderr;
+    this.failed = new Promise((resolve) => {
+      this.resolveFailure = resolve;
+    });
+    this.child = spawn(executable, args2, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.exited = new Promise((resolve) => {
+      this.child.once("exit", (code, signal) => {
+        this.exitResult = { code, signal };
+        this.fail(
+          new Error(
+            `Codex app-server exited (code ${code ?? "null"}, signal ${signal ?? "null"}).`
+          )
+        );
+        resolve(this.exitResult);
+      });
+    });
+    this.child.once("error", (error) => this.fail(error));
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => this.consumeStdout(String(chunk)));
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (chunk) => this.onStderr(String(chunk)));
+  }
+  async initialize({
+    clientName,
+    clientVersion
+  }) {
+    await this.request({
+      method: "initialize",
+      params: {
+        clientInfo: { name: clientName, version: clientVersion },
+        capabilities: { experimentalApi: true }
+      }
+    });
+    this.notify({ method: "initialized" });
+  }
+  request({
+    method,
+    params
+  }) {
+    if (this.closed || this.exitResult != null) {
+      return Promise.reject(new Error("Codex app-server is not running."));
+    }
+    const id = this.nextRequestId++;
+    const response = new Promise((resolve, reject) => {
+      this.pending.set(id, { method, resolve, reject });
+    });
+    try {
+      this.write({ id, method, ...params === void 0 ? {} : { params } });
+    } catch (error) {
+      this.pending.delete(id);
+      return Promise.reject(error);
+    }
+    return response;
+  }
+  notify({ method, params }) {
+    this.write({ method, ...params === void 0 ? {} : { params } });
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.child.stdin.end();
+    if (await this.waitForExit({ timeoutMs: 500 })) return;
+    this.child.kill("SIGTERM");
+    if (await this.waitForExit({ timeoutMs: 1e3 })) return;
+    this.child.kill("SIGKILL");
+    await this.waitForExit({ timeoutMs: 1e3 });
+  }
+  waitUntilExit() {
+    return this.exited;
+  }
+  waitUntilFailure() {
+    return this.failed.then((error) => {
+      throw error;
+    });
+  }
+  write(message) {
+    if (this.closed || this.exitResult != null || !this.child.stdin.writable) {
+      throw new Error("Codex app-server is not writable.");
+    }
+    this.child.stdin.write(`${JSON.stringify(message)}
+`);
+  }
+  consumeStdout(chunk) {
+    this.stdoutBuffer += chunk;
+    let newline = this.stdoutBuffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = this.stdoutBuffer.slice(0, newline).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1);
+      if (line.length > 0) {
+        this.parseQueue = this.parseQueue.then(() => this.processLine(line)).catch((error) => this.fail(error));
+      }
+      newline = this.stdoutBuffer.indexOf("\n");
+    }
+  }
+  async processLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      throw new Error("Codex app-server wrote an invalid JSON-RPC message.");
+    }
+    if (!isRecord(message)) {
+      throw new Error("Codex app-server wrote an invalid JSON-RPC message.");
+    }
+    if (typeof message.method === "string") {
+      if (isJsonRpcId(message.id)) {
+        void this.handleServerRequest({
+          id: message.id,
+          method: message.method,
+          ...message.params === void 0 ? {} : { params: message.params }
+        });
+      } else {
+        this.onNotification({
+          method: message.method,
+          ...message.params === void 0 ? {} : { params: message.params }
+        });
+      }
+      return;
+    }
+    if (!isJsonRpcId(message.id)) {
+      throw new Error("Codex app-server response is missing a valid id.");
+    }
+    const pending = this.pending.get(message.id);
+    if (pending == null) return;
+    this.pending.delete(message.id);
+    if (isJsonRpcError(message.error)) {
+      pending.reject(
+        new CodexAppServerRequestError({
+          method: pending.method,
+          error: message.error
+        })
+      );
+      return;
+    }
+    if (!Object.prototype.hasOwnProperty.call(message, "result")) {
+      pending.reject(
+        new Error(`Codex app-server ${pending.method} response has no result.`)
+      );
+      return;
+    }
+    pending.resolve(message.result);
+  }
+  async handleServerRequest(request) {
+    try {
+      const result = await this.onRequest(request);
+      if (!this.closed && this.exitResult == null) {
+        this.write({ id: request.id, result });
+      }
+    } catch (error) {
+      if (!this.closed && this.exitResult == null) {
+        this.write({
+          id: request.id,
+          error: {
+            code: -32603,
+            message: error instanceof Error ? error.message : String(error)
+          }
+        });
+      }
+    }
+  }
+  failPending(error) {
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+  fail(error) {
+    this.failPending(error);
+    if (this.failure !== void 0) return;
+    this.failure = error;
+    this.resolveFailure(error);
+  }
+  async waitForExit({
+    timeoutMs
+  }) {
+    if (this.exitResult != null) return true;
+    return Promise.race([
+      this.exited.then(() => true),
+      new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(false), timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  }
+};
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
 }
-const requestId = 'cli-' + Date.now() + '-' + Math.random().toString(16).slice(2);
-const response = await fetch('http://127.0.0.1:${relayPort}', {
-  method: 'POST',
-  headers: { 'Content-Type': 'application/json' },
-  body: JSON.stringify({ requestId, toolName, input }),
-});
-const text = await response.text();
-let payload;
-try {
-  payload = text ? JSON.parse(text) : {};
-} catch {
-  payload = { error: text };
+function isJsonRpcId(value) {
+  return typeof value === "string" || typeof value === "number";
 }
-if (!response.ok || payload.error) {
-  console.error(String(payload.error ?? ('tool relay failed with HTTP ' + response.status)));
-  process.exit(1);
+function isJsonRpcError(value) {
+  return isRecord(value) && typeof value.code === "number" && typeof value.message === "string";
 }
-console.log(JSON.stringify(payload.result ?? payload, null, 2));
-`;
+
+// src/bridge/create-app-server-event-handler.ts
+function createAppServerEventHandler({
+  stepTracker,
+  emitStreamEvent,
+  emitWarning,
+  emitError
+}) {
+  let activeThreadId;
+  let activeTurnId;
+  let settled = false;
+  let accumulatedUsage = emptyUsageBreakdown();
+  let lastCumulativeUsageKey;
+  const textByItem = /* @__PURE__ */ new Map();
+  const reasoningByItem = /* @__PURE__ */ new Map();
+  const nativeToolCalls = /* @__PURE__ */ new Map();
+  let resolveCompletion = () => {
+  };
+  const completion = new Promise((resolve) => {
+    resolveCompletion = resolve;
+  });
+  const announceThread = (threadId) => {
+    if (activeThreadId != null) return;
+    activeThreadId = threadId;
+    emitStreamEvent({ type: "thread.started", thread_id: threadId });
+  };
+  const handleItem = ({
+    eventType,
+    params
+  }) => {
+    if (!matchesActiveTurn({ params, activeThreadId, activeTurnId })) return;
+    const item = asRecord(params.item);
+    if (item == null || typeof item.type !== "string") return;
+    if (eventType === "item.completed" && typeof item.id === "string") {
+      const call = nativeToolCalls.get(item.id);
+      if (call?.name === "apply_patch" && item.type === "fileChange") {
+        call.successConfirmed = item.status === "completed";
+      } else if (call?.name === "view_image" && item.type === "imageView") {
+        call.successConfirmed = true;
+      }
+    }
+    const normalized = normalizeItem({ item, textByItem, reasoningByItem });
+    if (normalized == null) return;
+    if (normalized.type === "dynamic_tool_call") {
+      stepTracker.observeEvent({
+        event: { type: eventType, item: normalized },
+        itemId: normalized.id
+      });
+      return;
+    }
+    emitStreamEvent({ type: eventType, item: normalized });
+  };
+  const emitNativeToolResult = ({
+    callId,
+    result
+  }) => {
+    const call = nativeToolCalls.get(callId);
+    if (call == null || call.resultEmitted) return;
+    call.resultEmitted = true;
+    emitStreamEvent({
+      type: "item.completed",
+      item: {
+        type: "native_tool",
+        id: callId,
+        tool: call.name,
+        result,
+        ...!call.successConfirmed ? { isError: true } : {}
+      }
+    });
+  };
+  const handleRawItem = (params) => {
+    if (!matchesActiveTurn({ params, activeThreadId, activeTurnId })) return;
+    const item = asRecord(params.item);
+    if (item == null) return;
+    const toolCall = normalizeNativeToolCall({ item });
+    if (toolCall != null) {
+      if (nativeToolCalls.has(toolCall.callId)) return;
+      nativeToolCalls.set(toolCall.callId, {
+        name: toolCall.name,
+        resultEmitted: false,
+        successConfirmed: false
+      });
+      emitStreamEvent({
+        type: "item.started",
+        item: {
+          type: "native_tool",
+          id: toolCall.callId,
+          tool: toolCall.name,
+          input: toolCall.input
+        }
+      });
+      return;
+    }
+    if (typeof item.call_id !== "string") return;
+    const call = nativeToolCalls.get(item.call_id);
+    if (call == null || (call.name === "apply_patch" ? item.type !== "custom_tool_call_output" : item.type !== "function_call_output") || !Object.prototype.hasOwnProperty.call(item, "output")) {
+      return;
+    }
+    emitNativeToolResult({
+      callId: item.call_id,
+      result: call.name === "view_image" && call.successConfirmed && Array.isArray(item.output) && item.output.length === 0 ? "Image viewed." : item.output
+    });
+  };
+  return {
+    announceThread,
+    setTurnId(turnId) {
+      activeTurnId = turnId;
+    },
+    handle(notification) {
+      const params = asRecord(notification.params);
+      if (notification.method === "thread/started") {
+        const thread = asRecord(params?.thread);
+        if (typeof thread?.id === "string") announceThread(thread.id);
+        return;
+      }
+      if (notification.method === "turn/started") {
+        const turn = asRecord(params?.turn);
+        if (params?.threadId === activeThreadId && typeof turn?.id === "string") {
+          activeTurnId = turn.id;
+        }
+        return;
+      }
+      if (notification.method === "item/started" && params != null) {
+        handleItem({ eventType: "item.started", params });
+        return;
+      }
+      if (notification.method === "item/completed" && params != null) {
+        handleItem({ eventType: "item.completed", params });
+        return;
+      }
+      if (notification.method === "rawResponseItem/completed" && params != null) {
+        handleRawItem(params);
+        return;
+      }
+      if (notification.method === "item/agentMessage/delta" && params != null && matchesActiveTurn({ params, activeThreadId, activeTurnId }) && typeof params.itemId === "string" && typeof params.delta === "string") {
+        const text = (textByItem.get(params.itemId) ?? "") + params.delta;
+        textByItem.set(params.itemId, text);
+        emitStreamEvent({
+          type: "item.updated",
+          item: { type: "agent_message", id: params.itemId, text }
+        });
+        return;
+      }
+      if (notification.method === "item/reasoning/summaryTextDelta" && params != null && matchesActiveTurn({ params, activeThreadId, activeTurnId }) && typeof params.itemId === "string" && typeof params.delta === "string") {
+        const text = (reasoningByItem.get(params.itemId) ?? "") + params.delta;
+        reasoningByItem.set(params.itemId, text);
+        emitStreamEvent({
+          type: "item.updated",
+          item: { type: "reasoning", id: params.itemId, text }
+        });
+        return;
+      }
+      if (notification.method === "thread/tokenUsage/updated" && params != null && matchesActiveTurn({ params, activeThreadId, activeTurnId })) {
+        const tokenUsage = asRecord(params.tokenUsage);
+        const total = readUsageBreakdown(tokenUsage?.total);
+        const last = readUsageBreakdown(tokenUsage?.last);
+        if (total != null && last != null) {
+          const key = usageKey(total);
+          if (key !== lastCumulativeUsageKey) {
+            lastCumulativeUsageKey = key;
+            accumulatedUsage = addUsage({
+              total: accumulatedUsage,
+              increment: last
+            });
+          }
+        }
+        return;
+      }
+      if (notification.method === "error" && params != null) {
+        if (!matchesActiveTurn({ params, activeThreadId, activeTurnId }))
+          return;
+        const error = asRecord(params.error);
+        const message = typeof error?.message === "string" ? error.message : "Codex app-server reported an error.";
+        if (params.willRetry === true) {
+          emitWarning({ message });
+        } else {
+          emitError({ error: message, message: "codex turn failed" });
+        }
+        return;
+      }
+      if ((notification.method === "warning" || notification.method === "configWarning" || notification.method === "deprecationNotice") && typeof params?.message === "string") {
+        emitWarning({ message: params.message });
+        return;
+      }
+      if (notification.method === "turn/completed" && params != null && matchesActiveTurn({ params, activeThreadId, activeTurnId })) {
+        if (settled) return;
+        settled = true;
+        const turn = asRecord(params.turn);
+        const status = typeof turn?.status === "string" ? turn.status : "failed";
+        const turnError = asRecord(turn?.error);
+        if (status === "completed") {
+          for (const [callId, call] of nativeToolCalls) {
+            if (call.resultEmitted) continue;
+            emitNativeToolResult({
+              callId,
+              result: call.successConfirmed ? call.name === "apply_patch" ? "Patch applied." : "Image viewed." : "Codex did not report the tool result."
+            });
+          }
+        }
+        emitStreamEvent({
+          type: "turn.completed",
+          usage: toLegacyUsage(accumulatedUsage)
+        });
+        resolveCompletion({
+          status,
+          ...typeof turnError?.message === "string" ? { error: turnError.message } : {}
+        });
+      }
+    },
+    waitForCompletion: () => completion
+  };
+}
+function normalizeNativeToolCall({
+  item
+}) {
+  if (item.namespace != null || typeof item.call_id !== "string" || item.call_id.length === 0) {
+    return void 0;
+  }
+  if (item.type === "custom_tool_call" && item.name === "apply_patch" && typeof item.input === "string") {
+    return {
+      callId: item.call_id,
+      name: "apply_patch",
+      input: JSON.stringify(item.input)
+    };
+  }
+  if (item.type === "function_call" && item.name === "view_image" && typeof item.arguments === "string") {
+    return {
+      callId: item.call_id,
+      name: "view_image",
+      input: item.arguments
+    };
+  }
+  return void 0;
 }
-function parseToolRelayCommands({
-  command,
-  cliShimPath
+function normalizeItem({
+  item,
+  textByItem,
+  reasoningByItem
 }) {
-  return parseToolRelayCommandsInternal({ command, cliShimPath, depth: 0 });
+  const id = typeof item.id === "string" ? item.id : void 0;
+  if (item.type === "agentMessage") {
+    const text = typeof item.text === "string" ? item.text : "";
+    if (id != null) textByItem.set(id, text);
+    return { type: "agent_message", id, text };
+  }
+  if (item.type === "reasoning") {
+    const summary = stringArray(item.summary).join("\n\n");
+    const content = stringArray(item.content).join("\n\n");
+    const text = summary || reasoningByItem.get(id ?? "") || content;
+    if (id != null) reasoningByItem.set(id, text);
+    return { type: "reasoning", id, text };
+  }
+  if (item.type === "commandExecution") {
+    return {
+      type: "command_execution",
+      id,
+      command: typeof item.command === "string" ? item.command : "",
+      exit_code: typeof item.exitCode === "number" ? item.exitCode : void 0,
+      aggregated_output: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : void 0,
+      status: normalizeCommandStatus(item.status)
+    };
+  }
+  if (item.type === "mcpToolCall") {
+    const result = asRecord(item.result);
+    return {
+      type: "mcp_tool_call",
+      id,
+      server: typeof item.server === "string" ? item.server : void 0,
+      tool: typeof item.tool === "string" ? item.tool : void 0,
+      arguments: item.arguments,
+      result: result == null ? item.result : {
+        content: result.content,
+        structured_content: result.structuredContent
+      },
+      error: asRecord(item.error)
+    };
+  }
+  if (item.type === "dynamicToolCall") {
+    return { type: "dynamic_tool_call", id };
+  }
+  if (item.type === "webSearch") {
+    return {
+      type: "web_search",
+      id,
+      query: typeof item.query === "string" ? item.query : void 0,
+      action: asRecord(item.action) ?? void 0,
+      result: item.results
+    };
+  }
+  if (item.type === "fileChange") {
+    return {
+      type: "file_change",
+      id,
+      changes: Array.isArray(item.changes) ? item.changes.flatMap((change) => {
+        const value = asRecord(change);
+        const kind = asRecord(value?.kind)?.type;
+        return typeof value?.path === "string" && (kind === "add" || kind === "delete" || kind === "update") ? [{ path: value.path, kind }] : [];
+      }) : []
+    };
+  }
+  if (item.type === "plan") return { type: "todo_list", id };
+  return void 0;
+}
+function normalizeCommandStatus(value) {
+  if (value === "completed") return "completed";
+  if (value === "inProgress") return "in_progress";
+  return "failed";
 }
-function parseToolRelayCommandsInternal({
-  command,
-  cliShimPath,
-  depth
+function matchesActiveTurn({
+  params,
+  activeThreadId,
+  activeTurnId
 }) {
-  const commands = splitShellAndCommands(command);
-  if (!commands) return void 0;
-  if (commands.length > 1) {
-    const relayCalls = [];
-    for (const nestedCommand of commands) {
-      const nestedCalls = parseToolRelayCommandsInternal({
-        command: nestedCommand,
-        cliShimPath,
-        depth
-      });
-      if (!nestedCalls) return void 0;
-      relayCalls.push(...nestedCalls);
+  const nestedTurn = asRecord(params.turn);
+  const turnId = typeof params.turnId === "string" ? params.turnId : typeof nestedTurn?.id === "string" ? nestedTurn.id : void 0;
+  return activeThreadId != null && activeTurnId != null && params.threadId === activeThreadId && turnId === activeTurnId;
+}
+function asRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function emptyUsageBreakdown() {
+  return {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    cacheWriteInputTokens: 0,
+    outputTokens: 0
+  };
+}
+function readUsageBreakdown(value) {
+  const usage = asRecord(value);
+  if (usage == null) return void 0;
+  return {
+    inputTokens: numberOrZero(usage.inputTokens),
+    cachedInputTokens: numberOrZero(usage.cachedInputTokens),
+    cacheWriteInputTokens: numberOrZero(usage.cacheWriteInputTokens),
+    outputTokens: numberOrZero(usage.outputTokens)
+  };
+}
+function addUsage({
+  total,
+  increment
+}) {
+  return {
+    inputTokens: total.inputTokens + increment.inputTokens,
+    cachedInputTokens: total.cachedInputTokens + increment.cachedInputTokens,
+    cacheWriteInputTokens: total.cacheWriteInputTokens + increment.cacheWriteInputTokens,
+    outputTokens: total.outputTokens + increment.outputTokens
+  };
+}
+function usageKey(usage) {
+  return [
+    usage.inputTokens,
+    usage.cachedInputTokens,
+    usage.cacheWriteInputTokens,
+    usage.outputTokens
+  ].join(":");
+}
+function toLegacyUsage(usage) {
+  return {
+    input_tokens: usage.inputTokens,
+    cached_input_tokens: usage.cachedInputTokens,
+    cache_write_input_tokens: usage.cacheWriteInputTokens,
+    output_tokens: usage.outputTokens
+  };
+}
+function numberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/bridge/codex-app-server-driver.ts
+import { isDeepStrictEqual } from "util";
+
+// src/bridge/codex-tool-filtering-hook.ts
+import { createHash } from "crypto";
+import path from "path";
+var MATCHER = "^apply_patch$";
+var TIMEOUT_SECONDS = 10;
+var COMMAND = `printf '%s\\n' "Tool 'apply_patch' is inactive due to the HarnessAgent tool filtering policy." >&2; exit 2`;
+function createTrustedApplyPatchHook({
+  codexConfig
+}) {
+  const threadConfig = { ...codexConfig };
+  const hooks = { ...asRecord2(threadConfig.hooks) };
+  delete threadConfig.hooks;
+  for (const [key2, value] of Object.entries(threadConfig)) {
+    if (!key2.startsWith("hooks.")) continue;
+    const name = key2.slice("hooks.".length);
+    if (name.startsWith("state.")) {
+      hooks.state = {
+        ...asRecord2(hooks.state),
+        [name.slice("state.".length)]: value
+      };
+    } else {
+      hooks[name] = value;
     }
-    return relayCalls;
+    delete threadConfig[key2];
   }
-  const argv2 = parseShellWords(command);
-  if (!argv2) return void 0;
-  const relayCall = parseDirectToolRelayArgv({ argv: argv2, cliShimPath });
-  if (relayCall) return [relayCall];
-  const innerCommand = extractShellEvalCommand(argv2);
-  if (!innerCommand || depth >= 2) return void 0;
-  return parseToolRelayCommandsInternal({
-    command: innerCommand,
-    cliShimPath,
-    depth: depth + 1
-  });
+  const userGroups = hooks.PreToolUse ?? [];
+  if (!Array.isArray(userGroups)) {
+    throw new Error("Codex config hooks.PreToolUse must be an array.");
+  }
+  const handler = {
+    type: "command",
+    command: COMMAND,
+    timeout: TIMEOUT_SECONDS,
+    async: false
+  };
+  const hash = `sha256:${createHash("sha256").update(
+    JSON.stringify(
+      canonicalize({
+        event_name: "pre_tool_use",
+        matcher: MATCHER,
+        hooks: [handler]
+      })
+    )
+  ).digest("hex")}`;
+  const sourcePath = process.platform === "win32" ? path.win32.resolve("C:\\", "<session-flags>/config.toml") : path.posix.resolve("/", "<session-flags>/config.toml");
+  const key = `${sourcePath}:pre_tool_use:${userGroups.length}:0`;
+  hooks.PreToolUse = [...userGroups, { matcher: MATCHER, hooks: [handler] }];
+  hooks.state = {
+    ...asRecord2(hooks.state),
+    [key]: { enabled: true, trusted_hash: hash }
+  };
+  return {
+    cliOverrides: [`hooks=${toTomlInline(hooks)}`, "features.hooks=true"],
+    threadConfig,
+    key,
+    hash,
+    command: COMMAND
+  };
 }
-function parseDirectToolRelayArgv({
-  argv: argv2,
-  cliShimPath
+function assertTrustedApplyPatchHook({
+  response,
+  hook
 }) {
-  if (argv2.length < 3 || argv2.length > 4) return void 0;
-  if (argv2[0] !== "node" || argv2[1] !== cliShimPath) return void 0;
-  const toolName = argv2[2];
-  if (!toolName) return void 0;
-  try {
-    return { toolName, input: JSON.parse(argv2[3] ?? "{}") };
-  } catch {
-    return void 0;
+  const data = asRecord2(response)?.data;
+  const entry = Array.isArray(data) && data.length === 1 ? data[0] : null;
+  const record = asRecord2(entry);
+  const matches = Array.isArray(record?.hooks) ? record.hooks.filter((item) => asRecord2(item)?.key === hook.key) : [];
+  const match = matches.length === 1 ? asRecord2(matches[0]) : void 0;
+  if (!match || match.eventName !== "preToolUse" || match.handlerType !== "command" || match.command !== hook.command || match.matcher !== MATCHER || match.currentHash !== hook.hash || match.enabled !== true || match.trustStatus !== "trusted" || Array.isArray(record?.errors) && record.errors.length > 0) {
+    throw new Error(
+      "Codex app-server did not load the trusted apply_patch filtering hook."
+    );
   }
 }
-function extractShellEvalCommand(argv2) {
-  if (argv2.length !== 3) return void 0;
-  const shellName = argv2[0].split("/").at(-1);
-  if (shellName !== "bash" && shellName !== "sh" && shellName !== "zsh") {
-    return void 0;
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value != null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonicalize(item)])
+    );
   }
-  if (argv2[1] !== "-c" && argv2[1] !== "-lc") return void 0;
-  return argv2[2];
+  return value;
 }
-function splitShellAndCommands(command) {
-  const commands = [];
-  let start = 0;
-  let quote;
-  for (let i = 0; i < command.length; i++) {
-    const char = command[i];
-    if (quote === "'") {
-      if (char === "'") quote = void 0;
-      continue;
-    }
-    if (quote === '"') {
-      if (char === '"') {
-        quote = void 0;
-      } else if (char === "\\") {
-        i++;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-    if (char === "\\") {
-      i++;
-      continue;
-    }
-    if (char === "&" && command[i + 1] === "&") {
-      const nestedCommand2 = command.slice(start, i).trim();
-      if (!nestedCommand2) return void 0;
-      commands.push(nestedCommand2);
-      start = i + 2;
-      i++;
-    }
+function toTomlInline(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(toTomlInline).join(",")}]`;
+  }
+  if (value != null && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => `${JSON.stringify(key)}=${toTomlInline(item)}`).join(",")}}`;
   }
-  if (quote) return void 0;
-  const nestedCommand = command.slice(start).trim();
-  if (!nestedCommand) return void 0;
-  commands.push(nestedCommand);
-  return commands;
+  throw new Error("Codex hook configuration contains an unsupported value.");
 }
-function parseShellWords(command) {
-  const words = [];
-  let current = "";
-  let quote;
-  let hasCurrent = false;
-  const pushCurrent = () => {
-    if (!hasCurrent) return;
-    words.push(current);
-    current = "";
-    hasCurrent = false;
+function asRecord2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// src/bridge/codex-app-server-driver.ts
+var CODEX_CLI_PATH = fileURLToPath(
+  new URL("./node_modules/@openai/codex/bin/codex.js", import.meta.url)
+);
+function createCodexAppServerRuntime() {
+  let client;
+  let loadedThreadId;
+  let loadedConfig;
+  let activeTurn;
+  const close = async () => {
+    const previous = client;
+    client = void 0;
+    loadedThreadId = void 0;
+    loadedConfig = void 0;
+    await previous?.close();
   };
-  for (let i = 0; i < command.length; i++) {
-    const char = command[i];
-    if (quote === "'") {
-      if (char === "'") {
-        quote = void 0;
-      } else {
-        current += char;
-      }
-      hasCurrent = true;
-      continue;
+  const runTurn2 = async (options) => {
+    const { start, turn, emit, workdir: workdir2, threadId, codexModel, codexConfig } = options;
+    if (activeTurn != null) throw new Error("A Codex turn is already active.");
+    const toolPolicy = resolveCodexBuiltinToolPolicy({
+      builtinToolFiltering: start.builtinToolFiltering,
+      webSearch: start.webSearch
+    });
+    const trustedHook = toolPolicy.denyApplyPatchWithHook ? createTrustedApplyPatchHook({ codexConfig }) : void 0;
+    const nextConfig = {
+      ...trustedHook?.threadConfig ?? codexConfig,
+      web_search: toolPolicy.webSearchMode,
+      ...toolPolicy.disabled.bash || toolPolicy.disabled.view_image ? {
+        features: {
+          ...asRecord3(codexConfig.features),
+          ...toolPolicy.disabled.bash ? { shell_tool: false } : {},
+          ...toolPolicy.disabled.view_image ? { view_image: false } : {}
+        }
+      } : {}
+    };
+    const processConfig = {
+      thread: nextConfig,
+      cliOverrides: trustedHook?.cliOverrides ?? []
+    };
+    if (client != null && !isDeepStrictEqual(loadedConfig, processConfig)) {
+      await close();
     }
-    if (quote === '"') {
-      if (char === '"') {
-        quote = void 0;
-      } else if (char === "\\" && i + 1 < command.length) {
-        current += command[++i];
-      } else {
-        current += char;
-      }
-      hasCurrent = true;
-      continue;
+    const handler = createAppServerEventHandler({
+      stepTracker: options.stepTracker,
+      emitStreamEvent: options.emitStreamEvent,
+      emitWarning: turn.emitWarning,
+      emitError: turn.emitError
+    });
+    const dynamicTools = createDynamicTools(start.tools ?? []);
+    let rejectProtocolFailure = () => {
+    };
+    const protocolFailure = new Promise((_, reject) => {
+      rejectProtocolFailure = reject;
+    });
+    const currentTurn = {
+      threadId,
+      turnId: void 0,
+      handler,
+      dynamicTools,
+      options,
+      fail: rejectProtocolFailure
+    };
+    activeTurn = currentTurn;
+    let initialized = false;
+    if (client == null) {
+      const created = new CodexAppServerClient({
+        executable: process.execPath,
+        args: createCodexAppServerArgs({
+          cliOverrides: trustedHook?.cliOverrides
+        }),
+        cwd: workdir2,
+        env: process.env,
+        onNotification: (notification) => {
+          if (client !== created || activeTurn == null) return;
+          const params = asRecord3(notification.params);
+          if (notification.method === "turn/started" && params?.threadId === activeTurn.threadId && activeTurn.turnId == null) {
+            const turnId = asRecord3(params?.turn)?.id;
+            if (typeof turnId === "string") activeTurn.turnId = turnId;
+          }
+          activeTurn.handler.handle(notification);
+        },
+        onRequest: (request) => {
+          const active = activeTurn;
+          const params = asRecord3(request.params);
+          if (client !== created || active == null || params?.threadId !== active.threadId || params?.turnId !== active.turnId || active.turnId == null) {
+            return Promise.reject(
+              new Error(
+                "Codex app-server requested a tool for an inactive turn."
+              )
+            );
+          }
+          return handleAppServerRequest({
+            request,
+            dynamicTools: active.dynamicTools,
+            emit: active.options.emit,
+            requestToolResult: active.options.turn.requestToolResult
+          }).catch((error) => {
+            active.fail(error);
+            throw error;
+          });
+        },
+        onStderr: (text) => {
+          const message = text.trim();
+          if (message.length > 0) {
+            activeTurn?.options.turn.bridgeLog({
+              level: "debug",
+              subsystem: "codex.app-server.stderr",
+              message
+            });
+          }
+        }
+      });
+      client = created;
+      loadedConfig = processConfig;
+      initialized = true;
     }
-    if (/\s/.test(char)) {
-      pushCurrent();
-      continue;
+    const runningClient = client;
+    const clientFailure = runningClient.waitUntilFailure();
+    const exitFailure = runningClient.waitUntilExit().then(({ code, signal }) => {
+      throw new Error(
+        `Codex app-server exited before the turn completed (code ${code ?? "null"}, signal ${signal ?? "null"}).`
+      );
+    });
+    let removeAbortListener = () => {
+    };
+    const abortFailure = new Promise((_, reject) => {
+      const onAbort = () => {
+        if (currentTurn.threadId != null && currentTurn.turnId != null) {
+          void runningClient.request({
+            method: "turn/interrupt",
+            params: {
+              threadId: currentTurn.threadId,
+              turnId: currentTurn.turnId
+            }
+          }).catch(() => {
+          });
+        }
+        reject(
+          turn.abortSignal.reason ?? new DOMException("Aborted", "AbortError")
+        );
+      };
+      if (turn.abortSignal.aborted) onAbort();
+      else {
+        turn.abortSignal.addEventListener("abort", onAbort, { once: true });
+        removeAbortListener = () => turn.abortSignal.removeEventListener("abort", onAbort);
+      }
+    });
+    const raceWithProcess = ({ operation }) => Promise.race([
+      operation,
+      abortFailure,
+      protocolFailure,
+      clientFailure,
+      exitFailure
+    ]);
+    let stopSteering = () => {
+    };
+    const steeringStopped = new Promise((resolve) => {
+      stopSteering = resolve;
+    });
+    const userMessageLoop = async () => {
+      for await (const message of turn.experimental_userMessages) {
+        try {
+          const response = await Promise.race([
+            raceWithProcess({
+              operation: runningClient.request({
+                method: "turn/steer",
+                params: {
+                  threadId: currentTurn.threadId,
+                  expectedTurnId: currentTurn.turnId,
+                  clientUserMessageId: message.messageId,
+                  input: [
+                    { type: "text", text: message.text, text_elements: [] }
+                  ]
+                }
+              })
+            }),
+            steeringStopped.then(() => {
+              throw new Error(
+                "The Codex turn ended before accepting the user message."
+              );
+            })
+          ]);
+          if (asRecord3(response)?.turnId !== currentTurn.turnId) {
+            throw new Error(
+              "Codex app-server turn/steer returned an unexpected turn ID."
+            );
+          }
+          message.accept();
+        } catch (error) {
+          message.reject(error);
+        }
+      }
+    };
+    let keepClient = false;
+    try {
+      if (initialized) {
+        await raceWithProcess({
+          operation: runningClient.initialize({
+            clientName: "ai-sdk-harness-codex",
+            clientVersion: "1"
+          })
+        });
+      }
+      if (start.restartThread && loadedThreadId != null) {
+        await raceWithProcess({
+          operation: runningClient.request({
+            method: "thread/unsubscribe",
+            params: { threadId: loadedThreadId }
+          })
+        });
+        loadedThreadId = void 0;
+      }
+      if (trustedHook != null) {
+        const hooks = await raceWithProcess({
+          operation: runningClient.request({
+            method: "hooks/list",
+            params: {}
+          })
+        });
+        assertTrustedApplyPatchHook({ response: hooks, hook: trustedHook });
+      }
+      const threadMethod = threadId == null ? "thread/start" : "thread/resume";
+      if (loadedThreadId !== threadId || threadId == null) {
+        const threadResponse = await raceWithProcess({
+          operation: runningClient.request({
+            method: threadMethod,
+            params: threadId == null ? {
+              ...createThreadParams({
+                start,
+                workdir: workdir2,
+                codexModel,
+                codexConfig: nextConfig
+              }),
+              dynamicTools: dynamicTools.specs,
+              experimentalRawEvents: true
+            } : {
+              threadId,
+              ...createThreadParams({
+                start,
+                workdir: workdir2,
+                codexModel,
+                codexConfig: nextConfig
+              }),
+              excludeTurns: true
+            }
+          })
+        });
+        assertCodexThreadPermissions({
+          response: threadResponse,
+          method: threadMethod
+        });
+        currentTurn.threadId = readNestedString({
+          value: threadResponse,
+          path: ["thread", "id"],
+          method: threadMethod
+        });
+        loadedThreadId = currentTurn.threadId;
+      }
+      handler.announceThread(currentTurn.threadId);
+      emit({ type: "stream-start" });
+      const turnResponse = await raceWithProcess({
+        operation: runningClient.request({
+          method: "turn/start",
+          params: createTurnParams({
+            threadId: currentTurn.threadId,
+            start,
+            codexModel,
+            disableEnvironments: toolPolicy.disableEnvironments
+          })
+        })
+      });
+      currentTurn.turnId = readNestedString({
+        value: turnResponse,
+        path: ["turn", "id"],
+        method: "turn/start"
+      });
+      handler.setTurnId(currentTurn.turnId);
+      void userMessageLoop();
+      const result = await raceWithProcess({
+        operation: handler.waitForCompletion()
+      });
+      keepClient = true;
+      assertSuccessfulTurn(result);
+    } catch (error) {
+      if (turn.abortSignal.aborted && currentTurn.turnId != null) {
+        let timer;
+        try {
+          keepClient = await Promise.race([
+            handler.waitForCompletion().then(() => true),
+            new Promise((resolve) => {
+              timer = setTimeout(() => resolve(false), 5e3);
+            }),
+            clientFailure.then(
+              () => false,
+              () => false
+            )
+          ]);
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      throw error;
+    } finally {
+      turn.experimental_userMessages.close();
+      stopSteering();
+      removeAbortListener();
+      if (activeTurn === currentTurn) activeTurn = void 0;
+      if (!keepClient) await close();
     }
-    if (char === '"' || char === "'") {
-      quote = char;
-      hasCurrent = true;
-      continue;
+  };
+  return { runTurn: runTurn2, close };
+}
+function createCodexAppServerArgs({
+  cliOverrides = []
+} = {}) {
+  return [
+    CODEX_CLI_PATH,
+    "--config",
+    'sandbox_mode="danger-full-access"',
+    "--config",
+    'approval_policy="never"',
+    ...cliOverrides.flatMap((override) => ["--config", override]),
+    "app-server",
+    "--stdio"
+  ];
+}
+function createThreadParams({
+  start,
+  workdir: workdir2,
+  codexModel,
+  codexConfig
+}) {
+  return {
+    ...codexModel == null ? {} : { model: codexModel },
+    cwd: workdir2,
+    approvalPolicy: "never",
+    sandbox: "danger-full-access",
+    config: {
+      ...codexConfig,
+      web_search: codexConfig.web_search ?? (start.webSearch ? "live" : "disabled")
     }
-    if (char === "\\" && i + 1 < command.length) {
-      current += command[++i];
-      hasCurrent = true;
-      continue;
+  };
+}
+function createTurnParams({
+  threadId,
+  start,
+  codexModel,
+  disableEnvironments = false
+}) {
+  return {
+    threadId,
+    ...disableEnvironments ? { environments: [] } : {},
+    input: [{ type: "text", text: start.prompt, text_elements: [] }],
+    approvalPolicy: "never",
+    sandboxPolicy: {
+      type: "externalSandbox",
+      networkAccess: "enabled"
+    },
+    ...codexModel == null ? {} : { model: codexModel },
+    ...start.reasoningEffort == null ? {} : { effort: start.reasoningEffort },
+    ...start.responseFormat?.type === "json" && start.responseFormat.schema != null ? { outputSchema: start.responseFormat.schema } : {}
+  };
+}
+function assertCodexThreadPermissions({
+  response,
+  method
+}) {
+  const value = asRecord3(response);
+  const sandbox = asRecord3(value?.sandbox);
+  if (value?.approvalPolicy !== "never" || sandbox?.type !== "dangerFullAccess") {
+    throw new Error(
+      `Codex app-server ${method} did not disable approvals and its platform sandbox.`
+    );
+  }
+}
+function createDynamicTools(tools) {
+  const validOriginalNames = new Set(
+    tools.map((tool) => tool.name).filter(isValidDynamicToolName)
+  );
+  const usedAliases = /* @__PURE__ */ new Set();
+  const originalNameByAlias = /* @__PURE__ */ new Map();
+  const specs = tools.map((tool, index) => {
+    let alias = tool.name;
+    if (!isValidDynamicToolName(alias) || usedAliases.has(alias)) {
+      const digest = createHash2("sha256").update(tool.name).digest("hex").slice(0, 16);
+      const base = `ai_sdk_tool_${digest}`;
+      alias = base;
+      let suffix = index;
+      while (usedAliases.has(alias) || validOriginalNames.has(alias)) {
+        alias = `${base}_${suffix++}`;
+      }
     }
-    if (/[;&|<>()`$]/.test(char)) return void 0;
-    current += char;
-    hasCurrent = true;
+    usedAliases.add(alias);
+    originalNameByAlias.set(alias, tool.name);
+    return {
+      type: "function",
+      name: alias,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema ?? {}
+    };
+  });
+  return { specs, originalNameByAlias };
+}
+function isValidDynamicToolName(name) {
+  return name.length > 0 && name.length <= 128 && /^[a-zA-Z0-9_-]+$/.test(name) && name !== "mcp" && !name.startsWith("mcp__");
+}
+async function handleAppServerRequest({
+  request,
+  dynamicTools,
+  emit,
+  requestToolResult
+}) {
+  if (request.method !== "item/tool/call") {
+    throw new Error(
+      `Codex app-server requested unsupported method '${request.method}'.`
+    );
+  }
+  const params = asRecord3(request.params);
+  if (params == null || typeof params.callId !== "string" || typeof params.tool !== "string") {
+    throw new Error("Codex app-server sent an invalid dynamic tool request.");
+  }
+  const originalToolName = dynamicTools.originalNameByAlias.get(params.tool);
+  if (originalToolName == null) {
+    throw new Error(
+      `Codex app-server requested unknown dynamic tool '${params.tool}'.`
+    );
   }
-  if (quote) return void 0;
-  pushCurrent();
-  return words;
+  emit({
+    type: "tool-call",
+    toolCallId: params.callId,
+    toolName: originalToolName,
+    input: JSON.stringify(params.arguments ?? {}),
+    providerExecuted: false
+  });
+  const result = await requestToolResult(params.callId);
+  emit({
+    type: "tool-result",
+    toolCallId: params.callId,
+    toolName: originalToolName,
+    result: result.output ?? null,
+    isError: result.isError === true
+  });
+  return {
+    contentItems: [
+      { type: "inputText", text: serializeToolOutput(result.output) }
+    ],
+    success: result.isError !== true
+  };
+}
+function serializeToolOutput(output) {
+  if (typeof output === "string") return output;
+  try {
+    return JSON.stringify(output) ?? String(output);
+  } catch {
+    return String(output);
+  }
+}
+function readNestedString({
+  value,
+  path: path2,
+  method
+}) {
+  let current = value;
+  for (const segment of path2) current = asRecord3(current)?.[segment];
+  if (typeof current !== "string" || current.length === 0) {
+    throw new Error(`Codex app-server ${method} returned an invalid response.`);
+  }
+  return current;
+}
+function assertSuccessfulTurn(result) {
+  if (result.status === "completed") return;
+  if (result.status === "interrupted") {
+    throw new DOMException("Codex turn was interrupted.", "AbortError");
+  }
+  throw new Error(
+    result.error ?? `Codex turn ended with status '${result.status}'.`
+  );
+}
+function asRecord3(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 
 // src/bridge/codex-step-tracker.ts
@@ -882,7 +1894,7 @@ 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";
+  return item.type === "command_execution" || item.type === "native_tool" || item.type === "mcp_tool_call" || item.type === "dynamic_tool_call" || item.type === "web_search" || item.type === "file_change" || item.type === "todo_list";
 }
 function defaultUsage() {
   return {
@@ -941,6 +1953,27 @@ function createEmitStreamEvent({
     const observeStep = () => {
       stepTracker.observeEvent({ event, itemId: id });
     };
+    if (item.type === "native_tool" && item.tool != null) {
+      if (event.type === "item.started" && item.input != null) {
+        send({
+          type: "tool-call",
+          toolCallId: id,
+          toolName: item.tool,
+          input: item.input,
+          providerExecuted: true
+        });
+      } else if (event.type === "item.completed") {
+        send({
+          type: "tool-result",
+          toolCallId: id,
+          toolName: item.tool,
+          result: item.result,
+          ...item.isError ? { isError: true } : {}
+        });
+      }
+      stepTracker.observeEvent({ event, itemId: `native-tool:${id}` });
+      return;
+    }
     if (item.type === "agent_message" && typeof item.text === "string") {
       if (!textByItem.has(id)) {
         send({ type: "text-start", id });
@@ -1108,12 +2141,13 @@ function extractMcpToolCallResult(item) {
 function mapUsage(usage) {
   const input = usage.input_tokens ?? 0;
   const cacheRead = usage.cached_input_tokens ?? 0;
+  const cacheWrite = usage.cache_write_input_tokens ?? 0;
   return {
     inputTokens: {
       total: input,
-      noCache: Math.max(0, input - cacheRead),
+      noCache: Math.max(0, input - cacheRead - cacheWrite),
       cacheRead,
-      cacheWrite: 0
+      cacheWrite
     },
     outputTokens: {
       total: usage.output_tokens ?? 0,
@@ -1122,241 +2156,27 @@ function mapUsage(usage) {
   };
 }
 
-// src/bridge/tool-relay.ts
-import { createServer } from "http";
-
-// src/bridge/tool-relay-auth.ts
-var ToolRelayAuthorizer = class {
-  constructor({
-    ttlMs = 1e4,
-    now = Date.now
-  } = {}) {
-    this.authorizations = [];
-    this.pendingRequests = [];
-    this.ttlMs = ttlMs;
-    this.now = now;
-  }
-  authorizeToolCall(call) {
-    this.pruneExpired();
-    const key = toolRelayCallKey(call);
-    const pendingRequestIndex = this.pendingRequests.findIndex(
-      (request) => request.key === key
-    );
-    if (pendingRequestIndex !== -1) {
-      const [pendingRequest] = this.pendingRequests.splice(
-        pendingRequestIndex,
-        1
-      );
-      clearTimeout(pendingRequest.timeout);
-      pendingRequest.resolve(true);
-      return;
-    }
-    this.authorizations.push({
-      key,
-      expiresAt: this.now() + this.ttlMs
-    });
-  }
-  waitForToolCallAuthorization(call) {
-    this.pruneExpired();
-    const key = toolRelayCallKey(call);
-    const authorizationIndex = this.authorizations.findIndex(
-      (authorization) => authorization.key === key
-    );
-    if (authorizationIndex !== -1) {
-      this.authorizations.splice(authorizationIndex, 1);
-      return Promise.resolve(true);
-    }
-    const expiresAt = this.now() + this.ttlMs;
-    return new Promise((resolve) => {
-      const pendingRequest = {
-        key,
-        expiresAt,
-        timeout: setTimeout(() => {
-          const index = this.pendingRequests.indexOf(pendingRequest);
-          if (index !== -1) this.pendingRequests.splice(index, 1);
-          resolve(false);
-        }, this.ttlMs),
-        resolve
-      };
-      this.pendingRequests.push(pendingRequest);
-    });
-  }
-  close() {
-    this.authorizations.length = 0;
-    for (const pendingRequest of this.pendingRequests.splice(0)) {
-      clearTimeout(pendingRequest.timeout);
-      pendingRequest.resolve(false);
-    }
-  }
-  pruneExpired() {
-    const now = this.now();
-    for (let i = this.authorizations.length - 1; i >= 0; i--) {
-      if (this.authorizations[i].expiresAt <= now) {
-        this.authorizations.splice(i, 1);
-      }
-    }
-    for (let i = this.pendingRequests.length - 1; i >= 0; i--) {
-      const pendingRequest = this.pendingRequests[i];
-      if (pendingRequest.expiresAt <= now) {
-        this.pendingRequests.splice(i, 1);
-        clearTimeout(pendingRequest.timeout);
-        pendingRequest.resolve(false);
-      }
-    }
-  }
-};
-var ToolRelayPendingCalls = class {
-  constructor() {
-    this.calls = /* @__PURE__ */ new Map();
-  }
-  begin({
-    call,
-    run
-  }) {
-    const key = toolRelayCallKey(call);
-    const existing = this.calls.get(key);
-    if (existing) return { result: existing, isNew: false };
-    const result = run();
-    this.calls.set(key, result);
-    void result.finally(() => {
-      if (this.calls.get(key) === result) {
-        this.calls.delete(key);
-      }
-    }).catch(() => {
-    });
-    return { result, isNew: true };
-  }
-};
-function toolRelayCallKey({ toolName, input }) {
-  return `${toolName}\0${canonicalJson(input ?? {})}`;
-}
-function canonicalJson(value) {
-  return JSON.stringify(normalizeJsonValue(value));
-}
-function normalizeJsonValue(value) {
-  if (Array.isArray(value)) {
-    return value.map(normalizeJsonValue);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, normalizeJsonValue(entryValue)])
-    );
-  }
-  return value;
-}
-
-// src/bridge/tool-relay.ts
-async function startAuthorizedToolRelay({
-  tools,
-  emit,
-  requestToolResult,
-  authorizer = new ToolRelayAuthorizer()
-}) {
-  const toolNames = new Set(tools.map((tool) => tool.name));
-  const pendingCalls = new ToolRelayPendingCalls();
-  const server = createServer(async (req, res) => {
-    try {
-      if (req.method !== "POST" || req.url !== "/") {
-        res.writeHead(401, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "unauthorized tool relay request" }));
-        return;
-      }
-      const chunks = [];
-      for await (const chunk of req) {
-        chunks.push(chunk);
-      }
-      const body = Buffer.concat(chunks).toString("utf8");
-      const { requestId, toolName, input } = JSON.parse(body);
-      if (!toolNames.has(toolName)) {
-        res.writeHead(403, { "Content-Type": "application/json" });
-        res.end(
-          JSON.stringify({ error: `Tool "${toolName}" is not available` })
-        );
-        return;
-      }
-      const relayCall = { toolName, input };
-      if (!await authorizer.waitForToolCallAuthorization(relayCall)) {
-        res.writeHead(401, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "unauthorized tool relay request" }));
-        return;
-      }
-      const { result } = pendingCalls.begin({
-        call: relayCall,
-        run: async () => {
-          emit({
-            type: "tool-call",
-            toolCallId: requestId,
-            toolName,
-            input: JSON.stringify(input ?? {}),
-            providerExecuted: false
-          });
-          const toolResult = await requestToolResult(requestId);
-          emit({
-            type: "tool-result",
-            toolCallId: requestId,
-            toolName,
-            result: toolResult.output ?? null,
-            isError: !!toolResult.isError
-          });
-          return toolResult;
-        }
-      });
-      const { output } = await result;
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ result: output }));
-    } catch (error) {
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(
-        JSON.stringify({
-          error: error instanceof Error ? error.message : String(error)
-        })
-      );
-    }
-  });
-  await new Promise(
-    (resolve) => server.listen(0, "127.0.0.1", () => resolve())
-  );
-  const address = server.address();
-  if (!address || typeof address === "string") {
-    throw new Error("tool relay did not expose a numeric port");
-  }
-  return {
-    port: address.port,
-    close: () => {
-      authorizer.close();
-      closeServer(server);
-    },
-    authorizeToolCall: (call) => authorizer.authorizeToolCall(call)
-  };
-}
-function closeServer(server) {
-  try {
-    server.close();
-  } catch {
-  }
-}
-
 // src/bridge/index.ts
 import { argv, env as procEnv2, stdout as stdout2 } from "process";
-import * as codexSdkModule from "@openai/codex-sdk";
 var args = parseArgs(argv.slice(2));
 var workdir = requireArg({ value: args.workdir, name: "--workdir" });
 var bridgeStateDir = requireArg({
   value: args.bridgeStateDir,
   name: "--bridge-state-dir"
 });
-var cliShimDir = requireArg({
-  value: args.cliShimDir,
-  name: "--cli-shim-dir"
-});
 var HARNESS_CLIENT_APP = procEnv2.AI_SDK_HARNESS_CLIENT_APP;
-var codexSdk = codexSdkModule;
 var threadState = { id: void 0 };
+var appServer = createCodexAppServerRuntime();
 await runBridge({
   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()
 });
 async function runTurn(start, turn) {
   const emit = (msg) => turn.emit(msg);
@@ -1365,22 +2185,42 @@ async function runTurn(start, turn) {
   } else if (typeof start.resumeThreadId === "string" && start.resumeThreadId.length > 0) {
     threadState.id = start.resumeThreadId;
   }
-  let relay;
-  let cliShimPath;
-  if (start.tools && start.tools.length > 0) {
-    cliShimPath = `${cliShimDir}/${CLI_SHIM_FILENAME}`;
-    relay = await startToolRelay({
-      tools: start.tools,
+  const runtime = resolveCodexRuntime({ start });
+  let turnUsage = 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
     });
-    await mkdir2(cliShimDir, { recursive: true });
-    await writeFile2(
-      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
+  });
+}
+function resolveCodexRuntime({ start }) {
   const codexConfig = {
     ...start.codexConfig,
     developer_instructions: [
@@ -1396,7 +2236,7 @@ async function runTurn(start, turn) {
       "AI Gateway auth was selected but AI_GATEWAY_BASE_URL is missing from the Codex bridge environment."
     );
   }
-  const apiBaseUrl = hasGatewayAuth ? gatewayBaseUrl : procEnv2.OPENAI_BASE_URL ?? (start.headers != null ? "https://api.openai.com/v1" : void 0);
+  const apiBaseUrl = hasGatewayAuth ? gatewayBaseUrl : procEnv2.OPENAI_BASE_URL ?? (procEnv2.CODEX_API_KEY != null || start.headers != null ? "https://api.openai.com/v1" : void 0);
   const codexModel = start.model && hasGatewayAuth && !start.model.includes("/") ? `openai/${start.model}` : start.model;
   if (hasGatewayAuth && codexModel?.startsWith("openai/")) {
     codexConfig.model_supports_reasoning_summaries = true;
@@ -1426,81 +2266,7 @@ async function runTurn(start, turn) {
   if (start.mcpServers != null) {
     codexConfig.mcp_servers = start.mcpServers;
   }
-  const usesConfiguredModelProvider = typeof codexConfig.model_provider === "string";
-  const codex = new codexSdk.Codex({
-    ...procEnv2.CODEX_API_KEY ? { apiKey: procEnv2.CODEX_API_KEY } : {},
-    ...!usesConfiguredModelProvider && apiBaseUrl ? { baseUrl: apiBaseUrl } : {},
-    env: Object.fromEntries(
-      Object.entries(procEnv2).filter(
-        (entry) => 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;
-  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) {
-      if (turn.abortSignal.aborted) break;
-      if (cliShimPath && event.item?.type === "command_execution") {
-        const relayCalls = typeof event.item.command === "string" ? parseToolRelayCommands({
-          command: event.item.command,
-          cliShimPath
-        }) : void 0;
-        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()
-  });
-}
-async function startToolRelay({
-  tools,
-  emit,
-  requestToolResult
-}) {
-  return startAuthorizedToolRelay({ tools, emit, requestToolResult });
+  return { codexConfig, codexModel };
 }
 function parseArgs(args2) {
   const out = {};
@@ -1509,8 +2275,6 @@ function parseArgs(args2) {
       out.workdir = args2[++i];
     } else if (args2[i] === "--bridge-state-dir" && i + 1 < args2.length) {
       out.bridgeStateDir = args2[++i];
-    } else if (args2[i] === "--cli-shim-dir" && i + 1 < args2.length) {
-      out.cliShimDir = args2[++i];
     }
   }
   return out;