@ai-sdk/harness-codex 0.0.0-6b196531-20260710185421

package/dist/index.js

@@ -0,0 +1,899 @@
+// src/codex-harness.ts
+import { randomBytes } from "crypto";
+import { readFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import {
+  commonTool,
+  HarnessCapabilityUnsupportedError,
+  harnessV1DiagnosticFromBridgeFrame
+} from "@ai-sdk/harness";
+import {
+  classifyDiskLog,
+  createBridgeErrorHandler,
+  createBridgeStartupError,
+  drainBridgeProcessStream,
+  forwardBridgeProcessStream,
+  markBridgeStarting,
+  resolveSandboxHomeDir,
+  SandboxChannel,
+  shellQuote,
+  waitForBridgeReady,
+  writeSkills as writeHarnessSkills
+} from "@ai-sdk/harness/utils";
+import { WebSocket } from "ws";
+import { z as z2 } from "zod/v4";
+
+// src/codex-auth.ts
+import { getAiGatewayAuthFromEnv } from "@ai-sdk/harness/utils";
+function resolveCodexEnv(auth, processEnv = process.env) {
+  if (auth?.openaiCompatible) {
+    return pickOpenAICompatible(auth.openaiCompatible, processEnv);
+  }
+  if (auth?.openai) {
+    return pickOpenAI({ explicit: auth.openai, processEnv });
+  }
+  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
+    env: processEnv
+  });
+  if (auth?.gateway) {
+    return pickGateway({
+      explicit: auth.gateway,
+      gatewayAuthFromEnv
+    });
+  }
+  if (gatewayAuthFromEnv.apiKey) {
+    return pickGateway({
+      explicit: {},
+      gatewayAuthFromEnv
+    });
+  }
+  return pickOpenAI({ processEnv });
+}
+function pickOpenAICompatible(explicit, processEnv) {
+  const env = {};
+  const apiKey = explicit.apiKey ?? processEnv.OPENAI_API_KEY ?? processEnv.CODEX_API_KEY;
+  if (apiKey) env.CODEX_API_KEY = apiKey;
+  if (explicit.baseUrl) env.OPENAI_BASE_URL = explicit.baseUrl;
+  if (explicit.modelProviderName)
+    env.CODEX_MODEL_PROVIDER_NAME = explicit.modelProviderName;
+  if (explicit.queryParamsJson)
+    env.OPENAI_QUERY_PARAMS_JSON = explicit.queryParamsJson;
+  return env;
+}
+function pickOpenAI({
+  explicit,
+  processEnv
+}) {
+  const env = {};
+  const apiKey = explicit?.apiKey ?? processEnv.OPENAI_API_KEY ?? processEnv.CODEX_API_KEY;
+  if (apiKey) env.CODEX_API_KEY = apiKey;
+  const baseUrl = explicit?.baseUrl ?? processEnv.OPENAI_BASE_URL;
+  if (baseUrl) env.OPENAI_BASE_URL = baseUrl;
+  const organization = explicit?.organization ?? processEnv.OPENAI_ORGANIZATION;
+  if (organization) env.OPENAI_ORGANIZATION = organization;
+  const project = explicit?.project ?? processEnv.OPENAI_PROJECT;
+  if (project) env.OPENAI_PROJECT = project;
+  return env;
+}
+function pickGateway({
+  explicit,
+  gatewayAuthFromEnv
+}) {
+  const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;
+  const baseUrl = toCodexGatewayBaseUrl(
+    explicit.baseUrl ?? gatewayAuthFromEnv.baseUrl
+  );
+  const env = {};
+  if (apiKey) {
+    env.AI_GATEWAY_API_KEY = apiKey;
+    env.CODEX_API_KEY = apiKey;
+  }
+  env.AI_GATEWAY_BASE_URL = baseUrl;
+  return env;
+}
+function toCodexGatewayBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+
+// src/codex-bridge-protocol.ts
+import {
+  harnessV1BridgeInboundCommandSchemas,
+  harnessV1BridgeOutboundMessageSchema,
+  harnessV1BridgeReadySchema,
+  harnessV1BridgeStartBaseSchema
+} from "@ai-sdk/harness";
+import { z } from "zod/v4";
+var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+  reasoningEffort: z.enum(["low", "medium", "high"]).optional(),
+  webSearch: z.boolean().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`.
+  resumeThreadId: z.string().optional()
+});
+var inboundMessageSchema = z.discriminatedUnion("type", [
+  startMessageSchema,
+  ...harnessV1BridgeInboundCommandSchemas
+]);
+
+// src/bridge/cli-relay.ts
+var CLI_SHIM_FILENAME = "harness-tool.mjs";
+
+// src/version.ts
+var VERSION = true ? "0.0.0-6b196531-20260710185421" : "0.0.0-test";
+
+// src/codex-harness.ts
+var DEFAULT_CODEX_MODEL = "gpt-5.3-codex";
+var CODEX_CLIENT_APP = `ai-sdk/harness-codex/${VERSION}`;
+var CODEX_BUILTIN_TOOLS = {
+  bash: commonTool("bash", {
+    nativeName: "shell",
+    toolUseKind: "bash",
+    description: "Execute a shell command",
+    inputSchema: z2.object({ command: z2.string() })
+  }),
+  webSearch: commonTool("webSearch", {
+    nativeName: "web_search",
+    toolUseKind: "readonly",
+    description: "Search the web",
+    inputSchema: z2.object({ query: z2.string() })
+  })
+};
+var BOOTSTRAP_DIR = "/tmp/harness/codex";
+var codexBridgeCoordsSchema = z2.object({
+  port: z2.number(),
+  token: z2.string(),
+  lastSeenEventId: z2.number(),
+  sandboxId: z2.string().optional()
+});
+var codexResumeStateSchema = z2.object({
+  threadId: z2.string().optional(),
+  bridge: codexBridgeCoordsSchema.optional()
+});
+function createCodex(settings = {}) {
+  let cachedBootstrap;
+  return {
+    specificationVersion: "harness-v1",
+    harnessId: "codex",
+    builtinTools: CODEX_BUILTIN_TOOLS,
+    supportsBuiltinToolApprovals: false,
+    lifecycleStateSchema: codexResumeStateSchema,
+    getBootstrap: async () => {
+      if (cachedBootstrap != null) return cachedBootstrap;
+      const [pkg, lock, bridge, hostToolMcp] = await Promise.all([
+        readBridgeAsset("package.json"),
+        readBridgeAsset("pnpm-lock.yaml"),
+        readBridgeAsset("index.mjs"),
+        readBridgeAsset("host-tool-mcp.mjs")
+      ]);
+      cachedBootstrap = {
+        harnessId: "codex",
+        bootstrapDir: BOOTSTRAP_DIR,
+        files: [
+          { path: `${BOOTSTRAP_DIR}/package.json`, content: pkg },
+          { path: `${BOOTSTRAP_DIR}/pnpm-lock.yaml`, content: lock },
+          { path: `${BOOTSTRAP_DIR}/bridge.mjs`, content: bridge },
+          {
+            path: `${BOOTSTRAP_DIR}/host-tool-mcp.mjs`,
+            content: hostToolMcp
+          }
+        ],
+        commands: [
+          { command: `mkdir -p ${BOOTSTRAP_DIR}` },
+          {
+            command: `pnpm --dir ${BOOTSTRAP_DIR} install --frozen-lockfile --store-dir ${BOOTSTRAP_DIR}/.pnpm-store`
+          }
+        ]
+      };
+      return cachedBootstrap;
+    },
+    doStart: async (startOpts) => {
+      if (startOpts.builtinToolFiltering != null) {
+        throw new HarnessCapabilityUnsupportedError({
+          message: "Harness 'codex' does not support built-in tool filtering controls.",
+          harnessId: "codex"
+        });
+      }
+      if (startOpts.permissionMode != null && startOpts.permissionMode !== "allow-all") {
+        throw new HarnessCapabilityUnsupportedError({
+          message: "Harness 'codex' does not support built-in tool approval requests; use permissionMode: 'allow-all'.",
+          harnessId: "codex"
+        });
+      }
+      const sandboxSession = startOpts.sandboxSession;
+      const session = sandboxSession.restricted();
+      const sandboxId = sandboxSession.id;
+      const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
+      const isResume = lifecycleState != null;
+      const isContinue = startOpts.continueFrom != null;
+      const resumeData = isResume && typeof lifecycleState?.data === "object" ? lifecycleState.data : void 0;
+      const resumeThreadId = resumeData?.threadId;
+      const resumeThreadIdString = typeof resumeThreadId === "string" && resumeThreadId.length > 0 ? resumeThreadId : void 0;
+      const coords = resumeData?.bridge;
+      const workDir = startOpts.sessionWorkDir;
+      const sessionDataDir = `${sandboxSession.defaultWorkingDirectory}/.agent-runs/${startOpts.sessionId}`;
+      const bridgeStateDir = `${sessionDataDir}/bridge`;
+      const cliShimDir = `${sessionDataDir}/codex`;
+      const cliShimPath = `${cliShimDir}/${CLI_SHIM_FILENAME}`;
+      const timeoutMs = settings.startupTimeoutMs ?? 12e4;
+      const report = startOpts.observability?.report;
+      const onDiagnostic = report ? (frame) => report(
+        harnessV1DiagnosticFromBridgeFrame(frame, {
+          sessionId: startOpts.sessionId,
+          timestamp: Date.now()
+        })
+      ) : void 0;
+      const onBridgeError = createBridgeErrorHandler({
+        harnessId: "codex",
+        sessionId: startOpts.sessionId
+      });
+      if (coords) {
+        try {
+          const attachUrl = await sandboxSession.getPortUrl({
+            port: coords.port,
+            protocol: "ws"
+          }) + `?agent_bridge_token=${encodeURIComponent(coords.token)}`;
+          const attachChannel = new SandboxChannel({
+            connect: () => openWebSocket(attachUrl),
+            outboundSchema: outboundMessageSchema,
+            initialLastSeenEventId: coords.lastSeenEventId,
+            onDiagnostic,
+            onBridgeError
+          });
+          await attachChannel.open(isContinue ? { resume: true } : void 0);
+          return createSession({
+            sessionId: startOpts.sessionId,
+            channel: attachChannel,
+            cliShimPath,
+            // The live bridge was spawned by another process; no process handle.
+            proc: void 0,
+            model: settings.model ?? DEFAULT_CODEX_MODEL,
+            reasoningEffort: settings.reasoningEffort,
+            webSearch: settings.webSearch,
+            resumeThreadId: resumeThreadIdString,
+            isResume: true,
+            seedResumeThreadOnFirstPrompt: false,
+            rerunContinue: false,
+            bridgePort: coords.port,
+            bridgeToken: coords.token,
+            sandboxId,
+            debug: startOpts.observability?.debug,
+            permissionMode: startOpts.permissionMode
+          });
+        } catch {
+        }
+      }
+      let respawnStrategy = isResume ? "rerun" : void 0;
+      if (coords && isContinue) {
+        const logRaw = await Promise.resolve(
+          session.readTextFile({
+            path: `${bridgeStateDir}/event-log.ndjson`,
+            abortSignal: startOpts.abortSignal
+          })
+        ).catch(() => null);
+        if (await classifyDiskLog(logRaw) === "replay") {
+          respawnStrategy = "replay";
+        }
+      }
+      const port = resolveBridgePort(sandboxSession, settings.port);
+      const token = randomBytes(32).toString("hex");
+      const codexSkillSetup = startOpts.skills && startOpts.skills.length > 0 ? await writeCodexSkills({
+        sandbox: session,
+        skills: startOpts.skills,
+        abortSignal: startOpts.abortSignal
+      }) : void 0;
+      const env = {
+        ...resolveCodexEnv(settings.auth),
+        AI_SDK_HARNESS_CLIENT_APP: CODEX_CLIENT_APP,
+        BRIDGE_CHANNEL_TOKEN: token,
+        BRIDGE_WS_PORT: String(port),
+        ...codexSkillSetup ? {
+          HOME: codexSkillSetup.homeDir,
+          CODEX_HOME: codexSkillSetup.codexHomeDir
+        } : {},
+        ...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
+      };
+      if (respawnStrategy === void 0) {
+        await session.run({
+          command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
+          abortSignal: startOpts.abortSignal
+        });
+      }
+      await markBridgeStarting({
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: "codex",
+        abortSignal: startOpts.abortSignal
+      });
+      const proc = await session.spawn({
+        command: `node ${BOOTSTRAP_DIR}/bridge.mjs --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --bootstrap-dir ${shellQuote(BOOTSTRAP_DIR)} --cli-shim-dir ${shellQuote(cliShimDir)}`,
+        env,
+        abortSignal: startOpts.abortSignal
+      });
+      const stderrTail = [];
+      const bridgeStderrDone = forwardBridgeProcessStream({
+        stream: proc.stderr,
+        streamName: "stderr",
+        source: "codex",
+        collectTail: stderrTail
+      });
+      const { port: boundPort } = await waitForBridgeReady({
+        proc,
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: "codex",
+        timeoutMs,
+        abortSignal: startOpts.abortSignal,
+        createTimeoutError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+          message: "codex bridge did not become ready in time.",
+          proc: proc2,
+          stdoutTail,
+          stderrTail,
+          stderrDone: bridgeStderrDone
+        }),
+        createExitError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+          message: "codex bridge exited before becoming ready.",
+          proc: proc2,
+          stdoutTail,
+          stderrTail,
+          stderrDone: bridgeStderrDone
+        })
+      });
+      void drainBridgeProcessStream(proc.stdout);
+      const wsUrl = await sandboxSession.getPortUrl({
+        port: boundPort,
+        protocol: "ws"
+      }) + `?agent_bridge_token=${encodeURIComponent(token)}`;
+      const channel = new SandboxChannel({
+        connect: () => openWebSocket(wsUrl),
+        outboundSchema: outboundMessageSchema,
+        onDiagnostic,
+        onBridgeError,
+        // In replay mode the respawned bridge reloaded the finished turn from
+        // disk; seed the cursor and resume so it streams the tail (incl.
+        // `finish`).
+        ...respawnStrategy === "replay" ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 } : {}
+      });
+      await channel.open(
+        respawnStrategy === "replay" ? { resume: true } : void 0
+      );
+      return createSession({
+        sessionId: startOpts.sessionId,
+        channel,
+        cliShimPath,
+        proc,
+        model: settings.model ?? DEFAULT_CODEX_MODEL,
+        reasoningEffort: settings.reasoningEffort,
+        webSearch: settings.webSearch,
+        resumeThreadId: resumeThreadIdString,
+        isResume: respawnStrategy !== void 0,
+        seedResumeThreadOnFirstPrompt: respawnStrategy !== void 0,
+        rerunContinue: respawnStrategy === "rerun",
+        bridgePort: boundPort,
+        bridgeToken: token,
+        sandboxId,
+        debug: startOpts.observability?.debug,
+        permissionMode: startOpts.permissionMode
+      });
+    }
+  };
+}
+function resolveBridgePort(sandboxSession, override) {
+  if (override !== void 0) return override;
+  if (sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+  throw new HarnessCapabilityUnsupportedError({
+    harnessId: "codex",
+    message: "The codex harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createCodex({ port })`."
+  });
+}
+async function readBridgeAsset(name) {
+  const candidates = [
+    new URL(`./bridge/${name}`, import.meta.url),
+    new URL(`../bridge/${name}`, import.meta.url)
+  ];
+  let lastErr;
+  for (const url of candidates) {
+    try {
+      return await readFile(fileURLToPath(url), "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") throw err;
+      lastErr = err;
+    }
+  }
+  throw lastErr ?? new Error(`bridge asset not found: ${name}`);
+}
+async function writeCodexSkills({
+  sandbox,
+  skills,
+  abortSignal
+}) {
+  const homeDir = await resolveSandboxHomeDir({ sandbox, abortSignal });
+  const codexHomeDir = path.posix.join(homeDir, ".codex");
+  await sandbox.run({
+    command: `mkdir -p ${shellQuote(codexHomeDir)}`,
+    abortSignal
+  });
+  const rootDir = path.posix.join(homeDir, ".agents", "skills");
+  await writeHarnessSkills({
+    sandbox,
+    rootDir,
+    skills,
+    abortSignal,
+    invalidSkillNameMessage: ({ name }) => `Invalid Codex skill name: ${name}`,
+    invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid Codex skill file path for ${skillName}: ${filePath}`
+  });
+  return {
+    homeDir,
+    codexHomeDir
+  };
+}
+function openWebSocket(url) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve(ws);
+    };
+    const onError = (err) => {
+      ws.off("open", onOpen);
+      reject(err);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+function createSession({
+  sessionId,
+  channel,
+  cliShimPath,
+  proc,
+  model,
+  reasoningEffort,
+  webSearch,
+  resumeThreadId,
+  isResume,
+  seedResumeThreadOnFirstPrompt,
+  rerunContinue,
+  bridgePort,
+  bridgeToken,
+  sandboxId,
+  debug,
+  permissionMode
+}) {
+  let stopped = false;
+  let stopPromise;
+  let pendingResumeThreadId = seedResumeThreadOnFirstPrompt ? resumeThreadId : void 0;
+  let instructionsApplied = isResume;
+  let latestThreadId = resumeThreadId;
+  channel.on("bridge-thread", (msg) => {
+    latestThreadId = msg.threadId;
+  });
+  const wireTurn = (turnOpts) => {
+    let pendingResolve;
+    let pendingReject;
+    const done = new Promise((resolve, reject) => {
+      pendingResolve = resolve;
+      pendingReject = reject;
+    });
+    const unsubs = [];
+    const forward = (event) => {
+      try {
+        turnOpts.emit(event);
+      } catch {
+      }
+    };
+    const eventTypes = [
+      "stream-start",
+      "text-start",
+      "text-delta",
+      "text-end",
+      "reasoning-start",
+      "reasoning-delta",
+      "reasoning-end",
+      "tool-call",
+      "tool-approval-request",
+      "tool-result",
+      "file-change",
+      "finish-step",
+      "raw"
+    ];
+    let isSettled = false;
+    const settleSuccess = () => {
+      if (isSettled) return;
+      isSettled = true;
+      for (const u of unsubs) u();
+      pendingResolve();
+    };
+    const settleError = (err) => {
+      if (isSettled) return;
+      isSettled = true;
+      for (const u of unsubs) u();
+      pendingReject(err);
+    };
+    for (const type of eventTypes) {
+      unsubs.push(
+        channel.on(type, (msg) => {
+          forward(msg);
+        })
+      );
+    }
+    unsubs.push(
+      channel.on("finish", (msg) => {
+        forward(msg);
+        settleSuccess();
+      })
+    );
+    unsubs.push(
+      channel.on("error", (msg) => {
+        forward(msg);
+        settleError(msg.error);
+      })
+    );
+    const onClose = (_code, reason) => {
+      if (isSettled) return;
+      if (reason === "suspended") {
+        settleSuccess();
+        return;
+      }
+      settleError(new Error("codex bridge closed before the turn finished."));
+    };
+    channel.onClose(onClose);
+    const onAbort = () => {
+      if (isSettled) return;
+      try {
+        channel.send({ type: "abort" });
+      } catch {
+      }
+      settleError(
+        turnOpts.abortSignal?.reason ?? new DOMException("Aborted", "AbortError")
+      );
+    };
+    if (turnOpts.abortSignal) {
+      if (turnOpts.abortSignal.aborted) {
+        onAbort();
+      } else {
+        turnOpts.abortSignal.addEventListener("abort", onAbort, {
+          once: true
+        });
+      }
+    }
+    const control = {
+      submitToolResult: async (input) => {
+        channel.send({
+          type: "tool-result",
+          toolCallId: input.toolCallId,
+          output: input.output,
+          isError: input.isError
+        });
+      },
+      submitToolApproval: async (input) => {
+        channel.send({
+          type: "tool-approval-response",
+          approvalId: input.approvalId,
+          approved: input.approved,
+          reason: input.reason
+        });
+      },
+      submitUserMessage: async (text) => {
+        channel.send({ type: "user-message", text });
+      },
+      done
+    };
+    return {
+      control,
+      sendStart: (send) => {
+        const timer = setTimeout(() => {
+          if (isSettled) return;
+          try {
+            send();
+          } catch (err) {
+            settleError(err);
+          }
+        }, 0);
+        timer.unref?.();
+      }
+    };
+  };
+  return {
+    sessionId,
+    isResume,
+    modelId: model,
+    doPromptTurn: async (promptOpts) => {
+      const turn = wireTurn({
+        emit: promptOpts.emit,
+        abortSignal: promptOpts.abortSignal
+      });
+      const tools = (promptOpts.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }));
+      let promptText = extractUserText(promptOpts.prompt);
+      if (!instructionsApplied) {
+        const instructions = (promptOpts.instructions ? promptOpts.instructions + "\n\n" : "") + "Only respond with your `final` message once you have fully addressed the user request.";
+        promptText = frameInitialPromptGuidance({
+          instructions,
+          toolUsageBlock: tools.length > 0 ? composeToolUsageInstructions({
+            tools,
+            cliShimPath
+          }) : void 0,
+          userText: promptText
+        });
+      }
+      instructionsApplied = true;
+      const startMessage = {
+        type: "start",
+        prompt: promptText,
+        tools,
+        model,
+        reasoningEffort,
+        webSearch,
+        ...permissionMode ? { permissionMode } : {},
+        ...pendingResumeThreadId ? { resumeThreadId: pendingResumeThreadId } : {},
+        ...debug ? { debug } : {}
+      };
+      pendingResumeThreadId = void 0;
+      turn.sendStart(() => channel.send(startMessage));
+      return turn.control;
+    },
+    doContinueTurn: async (continueOpts) => {
+      const turn = wireTurn({
+        emit: continueOpts.emit,
+        abortSignal: continueOpts.abortSignal
+      });
+      if (rerunContinue) {
+        const threadId = pendingResumeThreadId ?? latestThreadId;
+        pendingResumeThreadId = void 0;
+        turn.sendStart(
+          () => channel.send({
+            type: "start",
+            /*
+             * A continuation nudge rather than an empty prompt: `resumeThreadId`
+             * rehydrates the prior thread, and this is the new user turn that
+             * drives it forward. Keeping it non-empty avoids handing the runtime
+             * an empty user message (and mirrors the claude-code adapter, where an
+             * empty text block trips the Anthropic API's `cache_control` rule).
+             */
+            prompt: "Continue.",
+            tools: (continueOpts.tools ?? []).map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema
+            })),
+            model,
+            reasoningEffort,
+            webSearch,
+            ...permissionMode ? { permissionMode } : {},
+            ...threadId ? { resumeThreadId: threadId } : {},
+            ...debug ? { debug } : {}
+          })
+        );
+      }
+      return turn.control;
+    },
+    doCompact: async () => {
+      throw new HarnessCapabilityUnsupportedError({
+        message: "Harness 'codex' does not support manual compaction; Codex auto-compacts its context internally.",
+        harnessId: "codex"
+      });
+    },
+    doDetach: async () => {
+      if (stopped) {
+        throw new Error(
+          `codex session ${sessionId} is already stopped; cannot detach.`
+        );
+      }
+      stopped = true;
+      const lastSeenEventId = await channel.suspend();
+      const payload = {
+        type: "resume-session",
+        harnessId: "codex",
+        specificationVersion: "harness-v1",
+        data: {
+          ...latestThreadId ? { threadId: latestThreadId } : {},
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            sandboxId
+          }
+        }
+      };
+      return payload;
+    },
+    doDestroy: async () => {
+      if (stopped) return stopPromise;
+      stopped = true;
+      stopPromise = (async () => {
+        channel.beginClose();
+        try {
+          if (!channel.isClosed()) {
+            channel.send({ type: "shutdown" });
+          }
+        } catch {
+        }
+        let stopTimer;
+        try {
+          if (proc) {
+            await Promise.race([
+              proc.wait(),
+              new Promise((resolve) => {
+                stopTimer = setTimeout(resolve, 5e3);
+                stopTimer.unref?.();
+              })
+            ]);
+          }
+        } finally {
+          if (stopTimer) clearTimeout(stopTimer);
+          try {
+            await proc?.kill();
+          } catch {
+          }
+          channel.close();
+        }
+      })();
+      return stopPromise;
+    },
+    doStop: async () => {
+      if (stopped) {
+        throw new Error(
+          `codex session ${sessionId} is already stopped; cannot stop.`
+        );
+      }
+      stopped = true;
+      channel.beginClose();
+      const data = channel.isClosed() ? {} : await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          unsub();
+          reject(
+            new Error(
+              `codex session ${sessionId} did not reply to detach within 5s.`
+            )
+          );
+        }, 5e3);
+        timer.unref?.();
+        const unsub = channel.on("bridge-detach", (msg) => {
+          clearTimeout(timer);
+          unsub();
+          resolve(msg.data);
+        });
+        try {
+          channel.send({ type: "detach" });
+        } catch (err) {
+          clearTimeout(timer);
+          unsub();
+          reject(err);
+        }
+      });
+      let stopTimer;
+      try {
+        if (proc) {
+          await Promise.race([
+            proc.wait(),
+            new Promise((resolve) => {
+              stopTimer = setTimeout(resolve, 5e3);
+              stopTimer.unref?.();
+            })
+          ]);
+        }
+      } finally {
+        if (stopTimer) clearTimeout(stopTimer);
+        try {
+          await proc?.kill();
+        } catch {
+        }
+        channel.close();
+      }
+      const payload = {
+        type: "resume-session",
+        harnessId: "codex",
+        specificationVersion: "harness-v1",
+        data: data ?? {}
+      };
+      return payload;
+    },
+    doSuspendTurn: async () => {
+      if (stopped) {
+        throw new Error(
+          `codex session ${sessionId} is stopped; cannot suspend.`
+        );
+      }
+      stopped = true;
+      await channel.interrupt();
+      const lastSeenEventId = await channel.suspend();
+      const payload = {
+        type: "continue-turn",
+        harnessId: "codex",
+        specificationVersion: "harness-v1",
+        data: {
+          ...latestThreadId ? { threadId: latestThreadId } : {},
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            sandboxId
+          }
+        }
+      };
+      return payload;
+    }
+  };
+}
+function frameInitialPromptGuidance({
+  instructions,
+  toolUsageBlock,
+  userText
+}) {
+  const blocks = [];
+  if (instructions) {
+    blocks.push(
+      `<session-instructions>
+The block below is operating guidance from the system, not a message from the user \u2014 follow it, but do not mention it or attribute it to the user.
+
+${instructions}
+</session-instructions>`
+    );
+  }
+  if (toolUsageBlock) blocks.push(toolUsageBlock);
+  if (blocks.length === 0) return userText;
+  return `${blocks.join("\n\n")}
+
+<user-message>
+${userText}
+</user-message>`;
+}
+function composeToolUsageInstructions({
+  tools,
+  cliShimPath
+}) {
+  const lines = [
+    "<host-tool-instructions>",
+    "You have access to the following host-provided tools. To use one, run the following command via your built-in `bash` tool:",
+    "",
+    `  node ${cliShimPath} <toolName> '<jsonInput>'`,
+    "",
+    "The script prints the JSON result to stdout. Do not invent another way to call these tools \u2014 only this CLI invocation will work. Pass the JSON input as a single-quoted argument.",
+    "For every user request that depends on a host-provided tool, run a separate CLI invocation for each needed tool call in the current turn before answering. Do not reuse previous tool results, and do not say you used a host tool unless the command has completed in the current turn.",
+    ""
+  ];
+  for (const toolSpec of tools) {
+    lines.push(
+      `- **${toolSpec.name}**${toolSpec.description ? ": " + toolSpec.description : ""}`
+    );
+    lines.push(
+      `  - Input schema: \`${JSON.stringify(toolSpec.inputSchema ?? {})}\``
+    );
+  }
+  lines.push("</host-tool-instructions>");
+  return lines.join("\n");
+}
+function extractUserText(prompt) {
+  if (typeof prompt === "string") return prompt;
+  const { content } = prompt;
+  if (typeof content === "string") return content;
+  const parts = [];
+  for (const part of content) {
+    if (part.type !== "text") {
+      throw new HarnessCapabilityUnsupportedError({
+        harnessId: "codex",
+        message: `The codex harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`
+      });
+    }
+    parts.push(part.text);
+  }
+  return parts.join("\n\n");
+}
+
+// src/index.ts
+var codex = createCodex();
+export {
+  VERSION,
+  codex,
+  createCodex
+};
+//# sourceMappingURL=index.js.map