@namzu/cli 34.1.1 → 36.0.0

package/dist/chunks/dist-R3I3ATSG.js

@@ -0,0 +1,1018 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  OpenAI
+} from "./chunk-VRL2WNQN.js";
+import {
+  ProviderRegistry,
+  ProviderRequestError,
+  assertThinkingUnsupported,
+  attributionHeaders,
+  isCallerAbortError,
+  isProviderRequestError,
+  providerVendorError,
+  selectAssistantText,
+  toToolResultBlocks,
+  toolResultToText
+} from "./chunk-K5HARZ7G.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// ../providers/openai/dist/client.js
+var OPENAI_CAPABILITIES = {
+  supportsNativeStructuredOutput: true,
+  supportsTools: true,
+  supportsStreaming: true,
+  supportsFunctionCalling: true,
+  supportsVision: true,
+  supportsDocuments: true,
+  supportsToolResultImages: false,
+  supportsToolResultDocuments: false
+};
+var GPT_5_EFFORT = [
+  "minimal",
+  "low",
+  "medium",
+  "high"
+];
+var GPT_5_1_EFFORT = [
+  "none",
+  "low",
+  "medium",
+  "high"
+];
+var GPT_5_2_TO_5_5_EFFORT = [
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+var GPT_6_ASTRA_EFFORT = ["low", "medium", "high", "xhigh", "max"];
+var GPT_5_6_EFFORT = [
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function openAIReasoningEffortLevels(model) {
+  const normalized = model.toLowerCase();
+  if (normalized === "gpt-6-astra")
+    return GPT_6_ASTRA_EFFORT;
+  if (/^gpt-5\.6(?:-(?:sol|terra|luna))?(?:-\d{4}-\d{2}-\d{2})?$/.test(normalized)) {
+    return GPT_5_6_EFFORT;
+  }
+  if (/^gpt-5\.5(?:-\d{4}-\d{2}-\d{2})?$/.test(normalized)) {
+    return GPT_5_2_TO_5_5_EFFORT;
+  }
+  if (/^gpt-5\.4(?:-(?:mini|nano))?(?:-\d{4}-\d{2}-\d{2})?$/.test(normalized)) {
+    return GPT_5_2_TO_5_5_EFFORT;
+  }
+  if (/^gpt-5\.2(?:-\d{4}-\d{2}-\d{2})?$/.test(normalized)) {
+    return GPT_5_2_TO_5_5_EFFORT;
+  }
+  if (/^gpt-5\.1(?:-\d{4}-\d{2}-\d{2})?$/.test(normalized)) {
+    return GPT_5_1_EFFORT;
+  }
+  if (/^gpt-5(?:-(?:mini|nano))?(?:-\d{4}-\d{2}-\d{2})?$/.test(normalized)) {
+    return GPT_5_EFFORT;
+  }
+  return void 0;
+}
+__name(openAIReasoningEffortLevels, "openAIReasoningEffortLevels");
+function assertOpenAIReasoningEffort(model, effort) {
+  if (effort === void 0)
+    return;
+  const supported = openAIReasoningEffortLevels(model);
+  if (supported === void 0 || supported.includes(effort))
+    return;
+  throw new Error(`OpenAIProvider: effort "${effort}" is not supported by model "${model}". Supported levels: ${supported.join(", ")}. Choose one of those levels or omit \`effort\`.`);
+}
+__name(assertOpenAIReasoningEffort, "assertOpenAIReasoningEffort");
+function withReasoningEffort(request, effort) {
+  if (effort === void 0)
+    return request;
+  return {
+    ...request,
+    reasoning_effort: effort
+  };
+}
+__name(withReasoningEffort, "withReasoningEffort");
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool_calls";
+    case "content_filter":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+__name(mapFinishReason, "mapFinishReason");
+function parseUsage(raw) {
+  if (!raw) {
+    return {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+      cachedTokens: 0,
+      cacheWriteTokens: 0
+    };
+  }
+  const promptTokens = raw.prompt_tokens ?? 0;
+  const completionTokens = raw.completion_tokens ?? 0;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: raw.total_tokens ?? promptTokens + completionTokens,
+    cachedTokens: raw.prompt_tokens_details?.cached_tokens ?? 0,
+    cacheWriteTokens: 0
+  };
+}
+__name(parseUsage, "parseUsage");
+function formatToolChoice(tc) {
+  if (tc === void 0)
+    return void 0;
+  if (tc === "auto" || tc === "none" || tc === "required")
+    return tc;
+  if (typeof tc === "object" && tc.type === "function") {
+    return { type: "function", function: { name: tc.function.name } };
+  }
+  return void 0;
+}
+__name(formatToolChoice, "formatToolChoice");
+function assertThinkingSupported(params) {
+  assertThinkingUnsupported("OpenAIProvider", { thinking: params.thinking });
+}
+__name(assertThinkingSupported, "assertThinkingSupported");
+function assertCitationsSupported(attachment, index) {
+  if (!attachment.citations)
+    return;
+  const which = attachment.name ?? `attachment ${index}`;
+  throw new Error(`This provider cannot return citations, and ${which} asked for them. Drop \`citations\` to send the document without them, or use a provider whose capabilities include citation support.`);
+}
+__name(assertCitationsSupported, "assertCitationsSupported");
+function toOpenAIMessages(messages) {
+  return messages.map((msg) => {
+    if (msg.role === "system") {
+      return { role: "system", content: msg.content };
+    }
+    if (msg.role === "user") {
+      if (msg.attachments && msg.attachments.length > 0) {
+        const parts = [];
+        if (msg.content.length > 0) {
+          parts.push({ type: "text", text: msg.content });
+        }
+        for (const [index, att] of msg.attachments.entries()) {
+          if (att.type === "document") {
+            assertCitationsSupported(att, index);
+            parts.push({
+              type: "file",
+              file: {
+                file_data: `data:${att.mediaType};base64,${att.data}`,
+                ...att.name ? { filename: att.name } : {}
+              }
+            });
+            continue;
+          }
+          if (att.type === "stored") {
+            throw new Error(`A stored attachment ("${att.ref}") reached the driver unresolved. Resolve it against the run's attachment store before sending.`);
+          }
+          parts.push({
+            type: "image_url",
+            image_url: { url: `data:${att.mediaType};base64,${att.data}` }
+          });
+        }
+        return { role: "user", content: parts };
+      }
+      return { role: "user", content: msg.content };
+    }
+    if (msg.role === "tool") {
+      return {
+        role: "tool",
+        // Tool messages are text-only on this wire, so a content block
+        // degrades to an honest placeholder rather than having its
+        // base64 payload dumped as text.
+        content: toolResultToText(msg.content),
+        tool_call_id: msg.toolCallId
+      };
+    }
+    const assistant = {
+      role: "assistant",
+      content: msg.content
+    };
+    if ("toolCalls" in msg && msg.toolCalls && msg.toolCalls.length > 0) {
+      ;
+      assistant.tool_calls = msg.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        }
+      }));
+    }
+    return assistant;
+  });
+}
+__name(toOpenAIMessages, "toOpenAIMessages");
+function toOpenAITools(params) {
+  if (!params.tools || params.tools.length === 0)
+    return void 0;
+  const enforced = new Set(params.enforceToolInputSchema ?? []);
+  return params.tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.function.name,
+      description: t.function.description ?? "",
+      parameters: t.function.parameters ?? {},
+      ...enforced.has(t.function.name) ? { strict: true } : {}
+    }
+  }));
+}
+__name(toOpenAITools, "toOpenAITools");
+var OpenAIProvider = class {
+  static {
+    __name(this, "OpenAIProvider");
+  }
+  id = "openai";
+  name = "OpenAI";
+  capabilities = OPENAI_CAPABILITIES;
+  client;
+  defaultModel;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY env variable.");
+    }
+    const clientOptions = {
+      apiKey: config.apiKey
+    };
+    if (config.baseURL)
+      clientOptions.baseURL = config.baseURL;
+    if (config.organization)
+      clientOptions.organization = config.organization;
+    if (config.project)
+      clientOptions.project = config.project;
+    if (config.timeout !== void 0)
+      clientOptions.timeout = config.timeout;
+    clientOptions.defaultHeaders = {
+      ...attributionHeaders(),
+      ...config.defaultHeaders ?? {}
+    };
+    this.client = new OpenAI(clientOptions);
+    this.defaultModel = config.model;
+  }
+  resolveModel(params) {
+    const model = params.model || this.defaultModel;
+    if (!model) {
+      throw new Error("OpenAIProvider: model is required. Pass `model` in config or on the chat call.");
+    }
+    return model;
+  }
+  reasoningEffortLevelsFor(model) {
+    return openAIReasoningEffortLevels(model);
+  }
+  async *chatStream(params) {
+    const model = this.resolveModel(params);
+    assertThinkingSupported(params);
+    assertOpenAIReasoningEffort(model, params.effort);
+    let stream;
+    try {
+      stream = await this.client.chat.completions.create(
+        withReasoningEffort({
+          model,
+          messages: toOpenAIMessages(params.messages),
+          stream: true,
+          stream_options: { include_usage: true },
+          tools: toOpenAITools(params),
+          tool_choice: formatToolChoice(params.toolChoice),
+          parallel_tool_calls: params.parallelToolCalls,
+          temperature: params.temperature,
+          max_tokens: params.maxTokens,
+          top_p: params.topP,
+          frequency_penalty: params.frequencyPenalty,
+          presence_penalty: params.presencePenalty,
+          stop: params.stop,
+          response_format: params.responseFormat
+        }, params.effort),
+        // Per-request abort: a Stop tears the in-flight SSE request down.
+        { signal: params.signal }
+      );
+    } catch (err) {
+      if (isCallerAbortError(err, params.signal))
+        throw params.signal?.reason ?? err;
+      if (isProviderRequestError(err))
+        throw err;
+      throw providerVendorError({ providerId: "openai", error: err });
+    }
+    try {
+      for await (const chunk of stream) {
+        params.signal?.throwIfAborted();
+        try {
+          const choice = chunk.choices[0];
+          const delta = choice?.delta;
+          const toolCalls = delta?.tool_calls?.map((tc) => ({
+            index: tc.index,
+            id: tc.id,
+            type: tc.type,
+            function: tc.function ? {
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            } : void 0
+          }));
+          const hasDelta = delta?.content !== void 0 && delta.content !== null || toolCalls && toolCalls.length > 0;
+          const finishReason = choice?.finish_reason ? mapFinishReason(choice.finish_reason) : void 0;
+          const usage = chunk.usage ? parseUsage(chunk.usage) : void 0;
+          if (!hasDelta && !finishReason && !usage)
+            continue;
+          yield {
+            id: chunk.id,
+            delta: {
+              content: delta?.content ?? void 0,
+              toolCalls
+            },
+            finishReason,
+            usage
+          };
+        } catch (parseErr) {
+          if (isProviderRequestError(parseErr))
+            throw parseErr;
+          throw new ProviderRequestError({
+            kind: "server",
+            providerId: "openai",
+            detail: "the provider stream returned malformed data"
+          });
+        }
+      }
+    } catch (err) {
+      if (isCallerAbortError(err, params.signal))
+        throw params.signal?.reason ?? err;
+      if (isProviderRequestError(err))
+        throw err;
+      throw providerVendorError({ providerId: "openai", error: err });
+    }
+  }
+  /**
+   * Declared even though this driver's listing already fails correctly on a
+   * bad key. The check is a declared capability rather than something inferred
+   * from whether a menu happened to throw, so a driver that answers the
+   * question has to say so — otherwise it is reported unverifiable, which is
+   * the honest default and would be a regression here.
+   */
+  async probeCredential(signal) {
+    signal?.throwIfAborted();
+    await this.client.models.list(signal ? { signal } : void 0);
+    signal?.throwIfAborted();
+  }
+  async listModels(signal) {
+    signal?.throwIfAborted();
+    const page = await this.client.models.list(signal ? { signal } : void 0);
+    signal?.throwIfAborted();
+    return page.data.map((m) => ({
+      id: m.id,
+      name: m.id,
+      supportsToolUse: true,
+      supportsStreaming: true
+    }));
+  }
+  async healthCheck() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../providers/openai/dist/codex.js
+var CODEX_CAPABILITIES = {
+  supportsHostedWebSearch: true,
+  supportsTools: true,
+  supportsStreaming: true,
+  supportsFunctionCalling: true,
+  supportsNativeStructuredOutput: true,
+  supportsVision: true,
+  supportsDocuments: false,
+  supportsToolResultImages: true,
+  supportsToolResultDocuments: false
+};
+var DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+var KNOWN_EFFORT_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
+];
+function subscriptionReasoningProfile(item) {
+  if (!Array.isArray(item.supported_reasoning_levels))
+    return void 0;
+  const levels = [];
+  for (const entry of item.supported_reasoning_levels) {
+    const effort = record(entry)?.effort;
+    if (typeof effort !== "string" || !KNOWN_EFFORT_LEVELS.includes(effort))
+      return void 0;
+    if (levels.includes(effort))
+      return void 0;
+    levels.push(effort);
+  }
+  const defaultLevel = item.default_reasoning_level;
+  return {
+    levels: Object.freeze(levels),
+    ...typeof defaultLevel === "string" && levels.includes(defaultLevel) ? { default: defaultLevel } : {}
+  };
+}
+__name(subscriptionReasoningProfile, "subscriptionReasoningProfile");
+function sameRoute(left, right) {
+  return left.providerId === right.providerId && left.model === right.model && left.chainIndex === right.chainIndex;
+}
+__name(sameRoute, "sameRoute");
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+__name(record, "record");
+function isRoute(value) {
+  const route = record(value);
+  return typeof route?.providerId === "string" && typeof route.model === "string" && Number.isInteger(route.chainIndex) && route.chainIndex >= 0;
+}
+__name(isRoute, "isRoute");
+function durableToolCalls(message) {
+  return (message.toolCalls ?? []).map((call) => ({
+    id: call.id,
+    name: call.function.name,
+    arguments: call.function.arguments
+  }));
+}
+__name(durableToolCalls, "durableToolCalls");
+function isCodexReplayState(value) {
+  const state = record(value);
+  if (state?.kind !== "namzu.codex.responses" || state.version !== 1 || !isRoute(state.route) || state.content !== null && typeof state.content !== "string" || !Array.isArray(state.toolCalls) || !Array.isArray(state.items)) {
+    return false;
+  }
+  return state.toolCalls.every((item) => {
+    const call = record(item);
+    return typeof call?.id === "string" && typeof call.name === "string" && typeof call.arguments === "string";
+  });
+}
+__name(isCodexReplayState, "isCodexReplayState");
+function replayItems(message, targetRoute) {
+  const source = message.source;
+  if (!source || source.type !== "model" || !sameRoute(source, targetRoute))
+    return null;
+  const state = source.replayState;
+  if (!isCodexReplayState(state) || !sameRoute(state.route, source))
+    return null;
+  if (state.content !== message.content)
+    return null;
+  if (state.textParts !== void 0 && JSON.stringify(state.textParts) !== JSON.stringify(message.textParts))
+    return null;
+  if (JSON.stringify(state.toolCalls) !== JSON.stringify(durableToolCalls(message)))
+    return null;
+  return state.items;
+}
+__name(replayItems, "replayItems");
+var IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+var TOOL_RESULT_IMAGE_DETAIL = "high";
+function codexImage(data, mediaType, source) {
+  if (!IMAGE_MEDIA_TYPES.has(mediaType)) {
+    throw new Error(`CodexProvider: ${source} image type '${mediaType}' is not supported. Use image/png, image/jpeg, image/webp, or image/gif.`);
+  }
+  return {
+    type: "input_image",
+    detail: source === "tool result" ? TOOL_RESULT_IMAGE_DETAIL : "auto",
+    image_url: `data:${mediaType};base64,${data}`
+  };
+}
+__name(codexImage, "codexImage");
+function codexUserContent(message) {
+  const attachments = message.attachments ?? [];
+  if (attachments.length === 0)
+    return message.content;
+  const content = [];
+  if (message.content.length > 0)
+    content.push({ type: "input_text", text: message.content });
+  for (const attachment of attachments) {
+    if (attachment.type === "stored") {
+      throw new Error("CodexProvider: an unresolved stored attachment reached the driver. Configure an AttachmentStore so Namzu can resolve its bytes before the model request.");
+    }
+    if (attachment.type === "document") {
+      throw new Error("CodexProvider: this subscription transport does not support document input. Route the turn to a document-capable provider.");
+    }
+    if (attachment.modelOmission) {
+      throw new Error("CodexProvider: an image marked for model omission reached the driver without request projection.");
+    }
+    content.push(codexImage(attachment.data, attachment.mediaType, "user attachment"));
+  }
+  return content;
+}
+__name(codexUserContent, "codexUserContent");
+function codexToolOutput(content) {
+  if (typeof content === "string")
+    return content;
+  if (content.length === 0)
+    return "";
+  const output = [];
+  for (const block of toToolResultBlocks(content)) {
+    if (block.type === "text") {
+      output.push({ type: "input_text", text: block.text });
+      continue;
+    }
+    if (block.type === "document") {
+      throw new Error("CodexProvider: this subscription transport does not support document tool results. Route the turn to a provider whose tool-result wire admits documents.");
+    }
+    if (block.modelOmission) {
+      throw new Error("CodexProvider: a tool image marked for model omission reached the driver without request projection.");
+    }
+    output.push(codexImage(block.data, block.mediaType, "tool result"));
+  }
+  return output;
+}
+__name(codexToolOutput, "codexToolOutput");
+function toCodexInput(messages, targetRoute) {
+  const input = [];
+  for (const message of messages) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "user") {
+      input.push({
+        type: "message",
+        role: "user",
+        content: codexUserContent(message)
+      });
+      continue;
+    }
+    if (message.role === "tool") {
+      input.push({
+        type: "function_call_output",
+        call_id: message.toolCallId,
+        output: codexToolOutput(message.content)
+      });
+      continue;
+    }
+    const replayed = replayItems(message, targetRoute);
+    if (replayed) {
+      input.push(...replayed);
+      continue;
+    }
+    if (message.content) {
+      input.push({
+        type: "message",
+        role: "assistant",
+        content: message.content
+      });
+    }
+    for (const call of message.toolCalls ?? []) {
+      input.push({
+        type: "function_call",
+        call_id: call.id,
+        name: call.function.name,
+        arguments: call.function.arguments
+      });
+    }
+  }
+  return input;
+}
+__name(toCodexInput, "toCodexInput");
+function toCodexTools(params) {
+  const tools = (params.tools ?? []).map((tool) => ({
+    type: "function",
+    name: tool.function.name,
+    description: tool.function.description ?? "",
+    parameters: tool.function.parameters ?? {},
+    // The ChatGPT Codex backend validates `strict: true` against a narrower
+    // Responses schema than the Chat Completions endpoint. In particular,
+    // every composition branch needs an explicit type and every object
+    // property must also be required. Namzu model schemas deliberately keep
+    // conditional edit shapes optional and validate the selected shape at
+    // execution, so claiming strictness rejects the whole request before the
+    // model can answer. The Codex client uses the same boundary for its own
+    // tools: Responses function tools are sent with `strict: false` and tool
+    // inputs are validated by the runtime. `enforceToolInputSchema` remains a
+    // provider hint; this transport cannot truthfully consume it for Namzu's
+    // general tool-schema contract.
+    strict: false
+  }));
+  if (params.webSearch) {
+    if (params.webSearch.mode !== "live" && params.webSearch.mode !== "cached")
+      throw new Error("Invalid web search mode.");
+    const hosted = {
+      type: "web_search",
+      external_web_access: params.webSearch.mode === "live"
+    };
+    tools.push(hosted);
+  }
+  return tools.length ? tools : void 0;
+}
+__name(toCodexTools, "toCodexTools");
+function responseUsage(usage) {
+  const promptTokens = usage.input_tokens ?? 0;
+  const completionTokens = usage.output_tokens ?? 0;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: usage.total_tokens ?? promptTokens + completionTokens,
+    cachedTokens: usage.input_tokens_details?.cached_tokens ?? 0,
+    cacheWriteTokens: 0
+  };
+}
+__name(responseUsage, "responseUsage");
+function buildRequest(params, model, targetRoute, supportedEffort) {
+  if (params.effort !== void 0 && supportedEffort !== void 0 && !supportedEffort.includes(params.effort)) {
+    throw new Error(`CodexProvider: effort "${params.effort}" is not supported by model "${model}". Supported levels: ${supportedEffort.join(", ")}. Choose one of those levels or omit \`effort\`.`);
+  }
+  if (params.thinking?.type === "enabled") {
+    throw new Error("CodexProvider: manual thinking budgets are not a Responses API capability. Use adaptive thinking or omit `thinking`.");
+  }
+  if (params.thinking?.type === "disabled" && params.effort !== "none") {
+    throw new Error('CodexProvider: disabling reasoning requires `effort: "none"`; omitting that level would not prove reasoning was disabled.');
+  }
+  const instructions = params.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n");
+  const request = {
+    model,
+    stream: true,
+    store: false,
+    instructions: instructions || void 0,
+    input: toCodexInput(params.messages, targetRoute),
+    // The Codex subscription request schema deliberately has no
+    // `max_output_tokens` member. `ChatCompletionParams.maxTokens` is a public
+    // API control, but projecting it onto this route makes the whole request
+    // invalid; the backend owns the output budget here.
+    // The subscription Responses backend expects these three fields even for a
+    // turn that exposes no tools.  The ordinary public Responses endpoint admits
+    // their omission, which is why the generated client types all make them
+    // optional; the Codex wire does not have the same defaulting contract.
+    tools: toCodexTools(params) ?? [],
+    tool_choice: params.toolChoice ?? "auto",
+    parallel_tool_calls: params.parallelToolCalls ?? true,
+    include: ["reasoning.encrypted_content"],
+    ...params.responseFormat ? {
+      text: {
+        format: params.responseFormat.type === "json_schema" ? { type: "json_schema", ...params.responseFormat.json_schema } : { type: "json_object" }
+      }
+    } : {},
+    ...params.effort !== void 0 ? { reasoning: { effort: params.effort, summary: "auto" } } : params.thinking?.type === "adaptive" ? { reasoning: { summary: "auto" } } : {}
+  };
+  return request;
+}
+__name(buildRequest, "buildRequest");
+var CodexProvider = class {
+  static {
+    __name(this, "CodexProvider");
+  }
+  id = "codex";
+  name = "OpenAI Codex";
+  capabilities = CODEX_CAPABILITIES;
+  client;
+  defaultModel;
+  reasoningProfiles = /* @__PURE__ */ new Map();
+  constructor(config) {
+    if (!config.accessToken)
+      throw new Error("Codex access token is required.");
+    if (!config.accountId)
+      throw new Error("Codex ChatGPT account id is required.");
+    this.client = new OpenAI({
+      apiKey: config.accessToken,
+      baseURL: config.baseURL ?? DEFAULT_CODEX_BASE_URL,
+      timeout: config.timeout,
+      defaultHeaders: {
+        ...attributionHeaders(),
+        "ChatGPT-Account-Id": config.accountId,
+        originator: "Codex Namzu",
+        "User-Agent": "Codex Namzu/1.0",
+        ...config.defaultHeaders ?? {}
+      }
+    });
+    this.defaultModel = config.model;
+  }
+  resolveModel(params) {
+    const model = params.model || this.defaultModel;
+    if (!model)
+      throw new Error("CodexProvider: model is required.");
+    return model;
+  }
+  reasoningEffortLevelsFor(model) {
+    return this.reasoningProfiles.get(model.toLowerCase())?.levels;
+  }
+  reasoningEffortDefaultFor(model) {
+    return this.reasoningProfiles.get(model.toLowerCase())?.default;
+  }
+  async *chatStream(params) {
+    const model = this.resolveModel(params);
+    const targetRoute = params.providerRoute ?? {
+      providerId: this.id,
+      model,
+      chainIndex: 0
+    };
+    const request = buildRequest(params, model, targetRoute, this.reasoningEffortLevelsFor(model));
+    let stream;
+    try {
+      stream = await this.client.responses.create(request, {
+        signal: params.signal
+      });
+    } catch (error) {
+      if (isCallerAbortError(error, params.signal))
+        throw params.signal?.reason ?? error;
+      if (isProviderRequestError(error))
+        throw error;
+      throw providerVendorError({ providerId: this.id, error });
+    }
+    const callIndex = /* @__PURE__ */ new Map();
+    const completedItems = /* @__PURE__ */ new Map();
+    const textItems = /* @__PURE__ */ new Map();
+    let nextCallIndex = 0;
+    let responseId = "codex-response";
+    try {
+      for await (const event of stream) {
+        params.signal?.throwIfAborted();
+        switch (event.type) {
+          case "response.created":
+            responseId = event.response.id;
+            break;
+          case "response.output_text.delta": {
+            const textPart = textItems.get(event.item_id);
+            yield {
+              id: responseId,
+              delta: {
+                content: event.delta,
+                ...textPart ? { textPart } : {}
+              }
+            };
+            break;
+          }
+          case "response.reasoning_summary_text.delta":
+            yield {
+              id: responseId,
+              delta: {
+                reasoning: {
+                  index: event.output_index,
+                  type: "thinking",
+                  text: event.delta
+                }
+              }
+            };
+            break;
+          case "response.reasoning_summary_text.done":
+            yield {
+              id: responseId,
+              delta: {
+                reasoning: {
+                  index: event.output_index,
+                  type: "thinking",
+                  done: true
+                }
+              }
+            };
+            break;
+          case "response.output_item.added":
+            if (event.item.type === "message" && (event.item.phase === "commentary" || event.item.phase === "final_answer"))
+              textItems.set(event.item.id, { id: event.item.id, phase: event.item.phase });
+            if (event.item.type === "web_search_call") {
+              yield {
+                id: responseId,
+                delta: {
+                  hostedTool: {
+                    id: event.item.id,
+                    name: "web_search",
+                    status: "running",
+                    ...webSearchDetail(event.item)
+                  }
+                }
+              };
+            }
+            if (event.item.type === "function_call") {
+              const index = nextCallIndex++;
+              callIndex.set(event.item.id ?? event.item.call_id, index);
+              callIndex.set(event.item.call_id, index);
+              yield {
+                id: responseId,
+                delta: {
+                  toolCalls: [
+                    {
+                      index,
+                      id: event.item.call_id,
+                      type: "function",
+                      function: {
+                        name: event.item.name,
+                        arguments: event.item.arguments
+                      }
+                    }
+                  ]
+                }
+              };
+            }
+            break;
+          case "response.function_call_arguments.delta": {
+            const index = callIndex.get(event.item_id) ?? event.output_index;
+            yield {
+              id: responseId,
+              delta: {
+                toolCalls: [{ index, function: { arguments: event.delta } }]
+              }
+            };
+            break;
+          }
+          case "response.output_item.done":
+            completedItems.set(event.output_index, event.item);
+            if (event.item.type === "web_search_call") {
+              yield {
+                id: responseId,
+                delta: {
+                  hostedTool: {
+                    id: event.item.id,
+                    name: "web_search",
+                    status: event.item.status === "completed" ? "completed" : "failed",
+                    ...webSearchDetail(event.item)
+                  }
+                }
+              };
+            }
+            if (event.item.type === "function_call") {
+              yield {
+                id: responseId,
+                delta: {
+                  toolCallEnd: {
+                    index: callIndex.get(event.item.id ?? event.item.call_id) ?? event.output_index,
+                    id: event.item.call_id
+                  }
+                }
+              };
+            }
+            break;
+          case "response.completed": {
+            const output = event.response.output?.length ? event.response.output : [...completedItems].sort(([left], [right]) => left - right).map(([, item]) => item);
+            const calls = output.filter((item) => item.type === "function_call").map((item) => ({
+              id: item.call_id,
+              name: item.name,
+              arguments: item.arguments
+            }));
+            const textParts = output.filter((item) => item.type === "message").map((item) => ({
+              id: item.id,
+              ...item.phase === "commentary" || item.phase === "final_answer" ? { phase: item.phase } : {},
+              text: item.content.filter((part) => part.type === "output_text").map((part) => part.text).join("")
+            }));
+            const phased = textParts.some((part) => part.phase !== void 0);
+            let content = phased ? selectAssistantText(textParts) : textParts.map((part) => part.text).join("");
+            const sources = /* @__PURE__ */ new Map();
+            for (const item of output) {
+              if (item.type !== "message")
+                continue;
+              for (const part of item.content) {
+                if (part.type !== "output_text")
+                  continue;
+                for (const annotation of part.annotations ?? []) {
+                  if (annotation.type === "url_citation" && /^https?:\/\//i.test(annotation.url) && !content.includes(annotation.url)) {
+                    sources.set(annotation.url, annotation.title);
+                  }
+                }
+              }
+            }
+            if (sources.size) {
+              const links = [...sources].map(([url, title]) => `[${title.replace(/[\[\]\r\n]/g, " ")}](<${url.replace(/[<>\s]/g, (c) => encodeURIComponent(c))}>)`).join(" \xB7 ");
+              const suffix = `
+
+Sources: ${links}`;
+              content += suffix;
+              let partIndex = textParts.length - 1;
+              for (let i = textParts.length - 1; i >= 0; i--) {
+                if (textParts[i]?.phase === "final_answer") {
+                  partIndex = i;
+                  break;
+                }
+              }
+              const part = textParts[partIndex];
+              if (part)
+                textParts[partIndex] = { ...part, text: part.text + suffix };
+              yield { id: responseId, delta: { content: suffix, contentOrigin: "driver" } };
+            }
+            const replayState = {
+              kind: "namzu.codex.responses",
+              version: 1,
+              route: targetRoute,
+              content: content || null,
+              ...phased ? { textParts } : {},
+              toolCalls: calls,
+              items: output
+            };
+            yield {
+              id: event.response.id,
+              delta: {},
+              ...phased ? { textParts } : {},
+              finishReason: calls.length > 0 ? "tool_calls" : "stop",
+              usage: responseUsage(event.response.usage ?? {}),
+              replayState
+            };
+            break;
+          }
+          case "response.incomplete": {
+            const reason = event.response.incomplete_details?.reason;
+            yield {
+              id: event.response.id,
+              delta: {},
+              finishReason: reason === "content_filter" ? "content_filter" : "length",
+              usage: responseUsage(event.response.usage ?? {})
+            };
+            break;
+          }
+          case "error":
+          case "response.failed":
+            throw new ProviderRequestError({
+              kind: "server",
+              providerId: this.id,
+              detail: "the Codex Responses stream failed"
+            });
+        }
+      }
+    } catch (error) {
+      if (isCallerAbortError(error, params.signal))
+        throw params.signal?.reason ?? error;
+      if (isProviderRequestError(error))
+        throw error;
+      throw providerVendorError({ providerId: this.id, error });
+    }
+  }
+  async listModels(signal) {
+    signal?.throwIfAborted();
+    const response = await this.client.get("/models?client_version=1.0.0", {
+      signal
+    });
+    signal?.throwIfAborted();
+    const profiles = /* @__PURE__ */ new Map();
+    const models = (Array.isArray(response.models) ? response.models : []).flatMap((value) => {
+      const item = record(value);
+      if (typeof item?.slug !== "string" || item.slug.length === 0)
+        return [];
+      if (item.visibility === "hide" || item.visibility === "hidden")
+        return [];
+      const profile = subscriptionReasoningProfile(item);
+      if (profile)
+        profiles.set(item.slug.toLowerCase(), profile);
+      return [
+        {
+          id: item.slug,
+          name: typeof item.display_name === "string" ? item.display_name : item.slug,
+          supportsToolUse: true,
+          supportsStreaming: true,
+          ...profile ? { reasoningEffortLevels: profile.levels } : {},
+          ...profile?.default !== void 0 ? { reasoningEffortDefault: profile.default } : {}
+        }
+      ];
+    });
+    this.reasoningProfiles = profiles;
+    return models;
+  }
+  async probeCredential(signal) {
+    await this.listModels(signal);
+  }
+  async healthCheck() {
+    try {
+      await this.probeCredential();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function webSearchDetail(item) {
+  const action = item.action;
+  if (!action || typeof action !== "object")
+    return {};
+  const queries = Array.isArray(action.queries) ? action.queries.filter((q) => typeof q === "string" && q.trim().length > 0) : [];
+  const query = typeof action.query === "string" && action.query.trim().length > 0 ? action.query.trim() : queries[0]?.trim();
+  const url = typeof action.url === "string" && action.url.length > 0 ? action.url : void 0;
+  return {
+    ...query ? { query } : {},
+    ...url && !query ? { url } : {},
+    ...Array.isArray(action.sources) ? { results: action.sources.length } : {}
+  };
+}
+__name(webSearchDetail, "webSearchDetail");
+
+// ../providers/openai/dist/index.js
+function registerCodex(options) {
+  ProviderRegistry.register("codex", CodexProvider, CODEX_CAPABILITIES, options);
+}
+__name(registerCodex, "registerCodex");
+function registerOpenAI(options) {
+  ProviderRegistry.register("openai", OpenAIProvider, OPENAI_CAPABILITIES, options);
+}
+__name(registerOpenAI, "registerOpenAI");
+export {
+  CODEX_CAPABILITIES,
+  CodexProvider,
+  OPENAI_CAPABILITIES,
+  OpenAIProvider,
+  openAIReasoningEffortLevels,
+  registerCodex,
+  registerOpenAI
+};
+//# sourceMappingURL=dist-R3I3ATSG.js.map