@ai-sdk/harness-codex 0.0.0 → 1.0.0-canary.0

package/src/codex-auth.ts

@@ -0,0 +1,100 @@
+export type CodexAuthOptions = {
+  readonly openaiCompatible?: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly modelProviderName?: string;
+    readonly queryParamsJson?: string;
+  };
+  readonly openai?: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly organization?: string;
+    readonly project?: string;
+  };
+  readonly gateway?: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+  };
+};
+
+/**
+ * Resolve the environment-variable blob the codex bridge needs. Precedence:
+ *
+ *   1. Explicit `auth.openaiCompatible` — pin to a custom OpenAI-compatible endpoint.
+ *   2. Explicit `auth.openai` — pin to direct OpenAI auth.
+ *   3. Explicit `auth.gateway` — pin to Vercel AI Gateway.
+ *   4. Auto-detect from the host process env: gateway first
+ *      (`AI_GATEWAY_API_KEY`), then `CODEX_API_KEY` / `OPENAI_API_KEY`.
+ */
+export function resolveCodexEnv(
+  auth: CodexAuthOptions | undefined,
+  processEnv: Record<string, string | undefined> = process.env,
+): Record<string, string> {
+  if (auth?.openaiCompatible) {
+    return pickOpenAICompatible(auth.openaiCompatible, processEnv);
+  }
+  if (auth?.openai) {
+    return pickOpenAI({ explicit: auth.openai, processEnv });
+  }
+  if (auth?.gateway) {
+    return pickGateway(auth.gateway, processEnv);
+  }
+  if (processEnv.AI_GATEWAY_API_KEY) {
+    return pickGateway({}, processEnv);
+  }
+  return pickOpenAI({ processEnv });
+}
+
+function pickOpenAICompatible(
+  explicit: NonNullable<CodexAuthOptions['openaiCompatible']>,
+  processEnv: Record<string, string | undefined>,
+): Record<string, string> {
+  const env: Record<string, string> = {};
+  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,
+}: {
+  explicit?: NonNullable<CodexAuthOptions['openai']>;
+  processEnv: Record<string, string | undefined>;
+}): Record<string, string> {
+  const env: Record<string, string> = {};
+  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: NonNullable<CodexAuthOptions['gateway']>,
+  processEnv: Record<string, string | undefined>,
+): Record<string, string> {
+  const apiKey = explicit.apiKey ?? processEnv.AI_GATEWAY_API_KEY;
+  const baseUrl =
+    explicit.baseUrl ??
+    processEnv.AI_GATEWAY_BASE_URL ??
+    'https://ai-gateway.vercel.sh/v1';
+  const env: Record<string, string> = {};
+  if (apiKey) {
+    env.AI_GATEWAY_API_KEY = apiKey;
+    env.CODEX_API_KEY = apiKey;
+  }
+  env.AI_GATEWAY_BASE_URL = baseUrl;
+  return env;
+}

package/src/codex-bridge-protocol.ts

@@ -0,0 +1,48 @@
+import {
+  harnessV1BridgeInboundCommandSchemas,
+  harnessV1BridgeOutboundMessageSchema,
+  harnessV1BridgeReadySchema,
+  harnessV1BridgeStartBaseSchema,
+} from '@ai-sdk/harness';
+import { z } from 'zod/v4';
+
+/*
+ * Codex's bridge wire protocol. The outbound events (including `file-change`
+ * and the `bridge-thread` resume coordinate), transport frames, shared inbound
+ * commands, and `bridge-ready` line all come from the shared `@ai-sdk/harness`
+ * protocol — the only Codex-specific piece is the `start` payload.
+ */
+
+export const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+export type OutboundMessage = z.infer<typeof outboundMessageSchema>;
+
+export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+  instructions: z.string().optional(),
+  reasoningEffort: z.enum(['low', 'medium', 'high']).optional(),
+  webSearch: z.boolean().optional(),
+  skills: z
+    .array(
+      z.object({
+        name: z.string(),
+        description: z.string(),
+        content: 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`.
+  resumeThreadId: z.string().optional(),
+});
+
+export type StartMessage = z.infer<typeof startMessageSchema>;
+
+export const inboundMessageSchema = z.discriminatedUnion('type', [
+  startMessageSchema,
+  ...harnessV1BridgeInboundCommandSchemas,
+]);
+export type InboundMessage = z.infer<typeof inboundMessageSchema>;
+
+export const bridgeReadySchema = harnessV1BridgeReadySchema;
+export type BridgeReady = z.infer<typeof bridgeReadySchema>;