@wrongstack/providers 0.264.0 → 0.267.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { expectDefined, ProviderError, StreamHangError, safeParse, sanitizeJsonString, WrongStackError, ERROR_CODES } from '@wrongstack/core';
+import { expectDefined, ProviderError, compactToolDefinitionForWire, StreamHangError, safeParse, sanitizeJsonString, WrongStackError, ERROR_CODES } from '@wrongstack/core';
 import { Readable } from 'stream';
 import { toErrorMessage } from '@wrongstack/core/utils';
 import { randomUUID } from 'crypto';
@@ -362,6 +362,45 @@ var CAPABILITIES_BY_FAMILY = {
     maxContext: 0,
     cacheControl: "none"
   },
+  // Claude Pro/Max via OAuth (Sign in with Claude). Same wire as anthropic.
+  "anthropic-oauth": {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: true,
+    systemPrompt: true,
+    jsonMode: false,
+    reasoning: false,
+    maxContext: 2e5,
+    cacheControl: "native"
+  },
+  // GitHub Copilot subscription (OpenAI chat/completions-compatible wire).
+  "github-copilot": {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: false,
+    systemPrompt: true,
+    jsonMode: true,
+    reasoning: false,
+    maxContext: 128e3,
+    cacheControl: "auto"
+  },
+  // ChatGPT-backend Responses API (Sign in with ChatGPT / Codex subscription).
+  "openai-codex": {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: true,
+    systemPrompt: true,
+    jsonMode: false,
+    reasoning: true,
+    maxContext: 272e3,
+    cacheControl: "auto"
+  },
   google: {
     tools: true,
     parallelTools: true,
@@ -535,17 +574,20 @@ function normalizeGemini(stop) {
       return "end_turn";
   }
 }
-
-// src/tool-format/to-anthropic.ts
+var _cache = /* @__PURE__ */ new WeakMap();
 function toolsToAnthropic(tools) {
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.inputSchema ?? {
-      type: "object",
-      properties: {}
-    }
-  }));
+  const hit = _cache.get(tools);
+  if (hit) return hit;
+  const result = tools.map((t) => {
+    const compact = compactToolDefinitionForWire(t);
+    return {
+      name: compact.name,
+      description: compact.description,
+      input_schema: compact.inputSchema
+    };
+  });
+  _cache.set(tools, result);
+  return result;
 }
 
 // src/stream-debug-state.ts
@@ -864,12 +906,34 @@ var AnthropicProvider = class extends WireAdapter {
     return parseProviderHttpError(this.id, status, text);
   }
   normalizeMessage(m) {
-    return {
-      role: m.role === "system" ? "user" : m.role,
-      content: typeof m.content === "string" ? m.content : m.content
-    };
+    const role = m.role === "system" ? "user" : m.role;
+    if (typeof m.content === "string") return { role, content: m.content };
+    return { role, content: m.content.map((b) => sanitizeAnthropicBlock(b)) };
   }
 };
+function sanitizeAnthropicBlock(b) {
+  switch (b.type) {
+    case "text":
+      return b.cache_control ? { type: "text", text: b.text, cache_control: b.cache_control } : { type: "text", text: b.text };
+    case "tool_use":
+      return { type: "tool_use", id: b.id, name: b.name, input: b.input };
+    case "tool_result": {
+      const out = {
+        type: "tool_result",
+        tool_use_id: b.tool_use_id,
+        content: b.content
+      };
+      if (b.is_error) out["is_error"] = true;
+      return out;
+    }
+    case "thinking":
+      return b.signature ? { type: "thinking", thinking: b.thinking, signature: b.signature } : { type: "thinking", thinking: b.thinking };
+    case "image":
+      return { type: "image", source: b.source };
+    default:
+      return b;
+  }
+}
 async function* parseAnthropicStream(body, fallbackModel) {
   const blocks = /* @__PURE__ */ new Map();
   let model = fallbackModel;
@@ -972,12 +1036,575 @@ async function* parseAnthropicStream(body, fallbackModel) {
     yield { type: "message_stop", stopReason, usage };
   }
 }
-var DEFAULT_BASE2 = "https://generativelanguage.googleapis.com/v1beta";
+var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var DEFAULT_BASE2 = "https://api.anthropic.com";
+var ANTHROPIC_VERSION = "2023-06-01";
+var OAUTH_BETA = "claude-code-20250219,oauth-2025-04-20";
+var REFRESH_SKEW_MS = 6e4;
+var CLAUDE_CODE_VERSION = "2.1.75";
+var CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude.";
+var CLAUDE_CODE_TOOLS = [
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "AskUserQuestion",
+  "EnterPlanMode",
+  "ExitPlanMode",
+  "KillShell",
+  "NotebookEdit",
+  "Skill",
+  "Task",
+  "TaskOutput",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch"
+];
+var CC_TOOL_BY_LOWER = new Map(CLAUDE_CODE_TOOLS.map((t) => [t.toLowerCase(), t]));
+function toClaudeCodeName(name) {
+  return CC_TOOL_BY_LOWER.get(name.toLowerCase()) ?? name;
+}
+function fromClaudeCodeName(name, tools) {
+  const lower = name.toLowerCase();
+  const match = tools?.find((t) => t.name.toLowerCase() === lower);
+  return match?.name ?? name;
+}
+async function refreshAnthropicOAuthToken(refreshToken, signal) {
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID,
+      refresh_token: refreshToken
+    }),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(3e4)]) : AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Claude token refresh failed (${res.status}): ${text || res.statusText}`);
+  }
+  const json = await res.json();
+  if (!json?.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
+    throw new Error("Claude token refresh response missing fields");
+  }
+  return {
+    access: json.access_token,
+    refresh: json.refresh_token,
+    expires: Date.now() + json.expires_in * 1e3
+  };
+}
+var AnthropicOAuthProvider = class extends AnthropicProvider {
+  id;
+  capabilities;
+  access;
+  refresh;
+  expiresAt;
+  onRefresh;
+  refreshFn;
+  constructor(opts) {
+    super({
+      apiKey: opts.credentials.accessToken,
+      baseUrl: opts.baseUrl ?? DEFAULT_BASE2,
+      fetchImpl: opts.fetchImpl,
+      streamOpts: opts.streamOpts
+    });
+    this.id = opts.id ?? "anthropic-oauth";
+    this.capabilities = capabilitiesForFamily("anthropic-oauth");
+    this.access = opts.credentials.accessToken;
+    this.refresh = opts.credentials.refreshToken;
+    this.expiresAt = opts.credentials.expiresAt;
+    this.onRefresh = opts.onRefresh;
+    this.refreshFn = opts.refreshFn ?? refreshAnthropicOAuthToken;
+  }
+  async *stream(req, opts) {
+    await this.ensureFreshToken(opts.signal);
+    try {
+      yield* this.remapToolNames(super.stream(req, opts), req.tools);
+    } catch (err) {
+      if (err instanceof ProviderError && err.status === 401 && this.refresh) {
+        await this.doRefresh(opts.signal);
+        yield* this.remapToolNames(super.stream(req, opts), req.tools);
+        return;
+      }
+      throw err;
+    }
+  }
+  /** Map Claude-Code-cased tool_use names in the stream back to real names. */
+  async *remapToolNames(events, tools) {
+    for await (const ev of events) {
+      if ((ev.type === "tool_use_start" || ev.type === "content_block_start") && typeof ev.name === "string") {
+        yield { ...ev, name: fromClaudeCodeName(ev.name, tools) };
+      } else {
+        yield ev;
+      }
+    }
+  }
+  async ensureFreshToken(signal) {
+    if (!this.refresh) return;
+    if (this.expiresAt !== void 0 && Date.now() < this.expiresAt - REFRESH_SKEW_MS) return;
+    await this.doRefresh(signal);
+  }
+  async doRefresh(signal) {
+    if (!this.refresh) return;
+    const t = await this.refreshFn(this.refresh, signal);
+    this.access = t.access;
+    this.refresh = t.refresh;
+    this.expiresAt = t.expires;
+    this.onRefresh?.({ accessToken: t.access, refreshToken: t.refresh, expiresAt: t.expires });
+  }
+  buildHeaders(_req) {
+    return {
+      "content-type": "application/json",
+      accept: "text/event-stream",
+      "anthropic-version": ANTHROPIC_VERSION,
+      authorization: `Bearer ${this.access}`,
+      "anthropic-beta": OAUTH_BETA,
+      // Present as the official Claude Code CLI so the subscription backend
+      // accepts the request and the client isn't trivially fingerprinted.
+      "user-agent": `claude-cli/${CLAUDE_CODE_VERSION}`,
+      "x-app": "cli",
+      "anthropic-dangerous-direct-browser-access": "true"
+    };
+  }
+  buildBody(req) {
+    const body = super.buildBody(req);
+    const existing = body["system"] ?? [];
+    const alreadyLed = existing[0]?.text?.startsWith(CLAUDE_CODE_SYSTEM_PROMPT) === true;
+    body["system"] = alreadyLed ? existing : [{ type: "text", text: CLAUDE_CODE_SYSTEM_PROMPT }, ...existing];
+    const tools = body["tools"];
+    if (Array.isArray(tools)) {
+      for (const t of tools) {
+        if (typeof t.name === "string") t.name = toClaudeCodeName(t.name);
+      }
+    }
+    const messages = body["messages"];
+    if (Array.isArray(messages)) {
+      for (const m of messages) {
+        if (!Array.isArray(m.content)) continue;
+        for (const block of m.content) {
+          if (block?.type === "tool_use" && typeof block.name === "string") {
+            block.name = toClaudeCodeName(block.name);
+          }
+        }
+      }
+    }
+    return body;
+  }
+};
+
+// src/openai.ts
+init_tool_input();
+var _cache2 = /* @__PURE__ */ new WeakMap();
+function toolsToOpenAI(tools) {
+  const hit = _cache2.get(tools);
+  if (hit) return hit;
+  const result = tools.map((t) => {
+    const compact = compactToolDefinitionForWire(t);
+    return {
+      type: "function",
+      function: {
+        name: compact.name,
+        description: compact.description,
+        parameters: compact.inputSchema
+      }
+    };
+  });
+  _cache2.set(tools, result);
+  return result;
+}
+function messagesToOpenAI(system, messages, opts = {}) {
+  const emptyContentMode = opts.emptyToolCallContent ?? "empty_string";
+  const out = [];
+  if (system && system.length > 0) {
+    const sysText = system.map((b) => b.text).join("\n\n");
+    if (opts.systemAsMessage) {
+      out.push({ role: "user", content: sysText });
+    } else {
+      out.push({ role: "system", content: sysText });
+    }
+  }
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const blocks = normalizeContent(msg.content);
+      const toolResults = blocks.filter((b) => b.type === "tool_result");
+      const others = blocks.filter((b) => b.type !== "tool_result");
+      for (const r of toolResults) {
+        const content = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
+        out.push({
+          role: "tool",
+          tool_call_id: r.tool_use_id,
+          content
+        });
+      }
+      if (others.length > 0) {
+        out.push({
+          role: "user",
+          content: opts.flattenContentToString ? blocksToString(others) : blocksToContentArray(others)
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const blocks = normalizeContent(msg.content);
+      const textBlocks = blocks.filter((b) => b.type === "text");
+      const toolUses = blocks.filter((b) => b.type === "tool_use");
+      const thinkingBlocks = blocks.filter((b) => b.type === "thinking");
+      const text = textBlocks.map((b) => b.text).join("");
+      const reasoning = thinkingBlocks.map((b) => b.thinking).filter((t) => t && t.length > 0).join("");
+      const toolCalls = toolUses.map((u) => ({
+        id: u.id,
+        type: "function",
+        function: { name: u.name, arguments: JSON.stringify(u.input) }
+      }));
+      const message = { role: "assistant" };
+      if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+        if (text) {
+          message.content = text;
+        } else {
+          message.content = emptyContentMode === "null" ? null : "";
+        }
+      } else {
+        message.content = text;
+      }
+      if (reasoning.length > 0) {
+        message.reasoning_content = reasoning;
+      }
+      out.push(message);
+    }
+  }
+  return out;
+}
+function normalizeContent(content) {
+  return typeof content === "string" ? [{ type: "text", text: content }] : content;
+}
+function blocksToString(blocks) {
+  return blocks.map((b) => {
+    if (b.type === "text") return b.text;
+    if (b.type === "image") return "[image]";
+    return "";
+  }).join("");
+}
+function blocksToContentArray(blocks) {
+  const hasImage = blocks.some((b) => b.type === "image");
+  if (!hasImage) {
+    return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+  }
+  return blocks.map((b) => {
+    if (b.type === "text") return { type: "text", text: b.text };
+    if (b.type === "image") {
+      const url = b.source.type === "url" ? b.source.url ?? "" : `data:${b.source.media_type ?? "image/png"};base64,${b.source.data ?? ""}`;
+      return { type: "image_url", image_url: { url } };
+    }
+    return null;
+  }).filter((c) => c !== null);
+}
+
+// src/openai.ts
+var DEFAULT_BASE3 = "https://api.openai.com/v1";
+var OpenAIProvider = class extends WireAdapter {
+  id;
+  capabilities;
+  opts;
+  constructor(opts) {
+    super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE3, opts.fetchImpl, opts.streamOpts);
+    this.opts = opts;
+    this.id = opts.id ?? "openai";
+    this.capabilities = capabilitiesForFamily("openai", {
+      parallelTools: !opts.quirks?.parallelToolsDisabled,
+      systemPrompt: !opts.quirks?.systemAsMessage,
+      ...opts.capabilities
+    });
+  }
+  buildUrl(_req) {
+    const base = this.baseUrl.replace(/\/+$/, "");
+    if (/\/chat\/completions$/.test(base)) return base;
+    if (/\/v\d+(\/[a-z0-9_-]+)*$/i.test(base)) return `${base}/chat/completions`;
+    return `${base}/v1/chat/completions`;
+  }
+  buildHeaders(req) {
+    const headers = {
+      ...super.buildHeaders(req),
+      authorization: `Bearer ${this.apiKey}`
+    };
+    if (this.opts.organization) {
+      headers["openai-organization"] = this.opts.organization;
+    }
+    return headers;
+  }
+  /**
+   * The request field used to cap output length. Real OpenAI deprecated
+   * `max_tokens` and the newer model families (gpt-4o, o1/o3/o4) 400 on it —
+   * they require `max_completion_tokens`. OpenAI-compatible endpoints that
+   * still only accept `max_tokens` override this. See issue #10.
+   */
+  tokenLimitParam() {
+    return "max_completion_tokens";
+  }
+  buildBody(req) {
+    const body = {
+      model: req.model,
+      messages: messagesToOpenAI(this.stripCacheControl(req), req.messages, {
+        ...this.opts.quirks
+      }),
+      [this.tokenLimitParam()]: req.maxTokens,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (req.tools && req.tools.length > 0) {
+      body["tools"] = toolsToOpenAI(req.tools);
+      if (req.toolChoice) {
+        if (typeof req.toolChoice === "string") {
+          body["tool_choice"] = req.toolChoice === "required" ? "required" : req.toolChoice;
+        } else {
+          body["tool_choice"] = {
+            type: "function",
+            function: { name: req.toolChoice.name }
+          };
+        }
+      }
+    }
+    if (req.temperature !== void 0) body["temperature"] = req.temperature;
+    if (req.topP !== void 0) body["top_p"] = req.topP;
+    if (req.stopSequences) body["stop"] = req.stopSequences;
+    return body;
+  }
+  parseStream(body, fallbackModel) {
+    return parseOpenAIStream(body, fallbackModel);
+  }
+  translateError(status, text) {
+    return parseProviderHttpError(this.id, status, text);
+  }
+  stripCacheControl(req) {
+    if (!req.system) return void 0;
+    return req.system.map((b) => {
+      const { cache_control: _cc, ...rest } = b;
+      return rest;
+    });
+  }
+};
+async function* parseOpenAIStream(body, fallbackModel) {
+  let model = fallbackModel;
+  let usage = { input: 0, output: 0 };
+  let stopReason = "end_turn";
+  let started = false;
+  let thinkingOpen = false;
+  const toolByIndex = /* @__PURE__ */ new Map();
+  for await (const msg of parseSSE(body)) {
+    if (!msg.data || msg.data === "[DONE]") continue;
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) continue;
+    const obj = parsed.value;
+    if (typeof obj["model"] === "string") model = obj["model"];
+    if (!started) {
+      started = true;
+      yield { type: "message_start", model };
+    }
+    const choices = obj["choices"];
+    const choice = choices?.[0];
+    const reasoningDelta = typeof choice?.delta?.reasoning_content === "string" ? choice.delta.reasoning_content : typeof choice?.delta?.reasoning === "string" ? choice.delta.reasoning : void 0;
+    if (reasoningDelta && reasoningDelta.length > 0) {
+      if (!thinkingOpen) {
+        thinkingOpen = true;
+        yield { type: "thinking_start" };
+      }
+      yield { type: "thinking_delta", text: reasoningDelta };
+    }
+    if (choice?.delta?.content) {
+      if (thinkingOpen) {
+        thinkingOpen = false;
+        yield { type: "thinking_stop" };
+      }
+      yield { type: "text_delta", text: choice.delta.content };
+    }
+    if (choice?.delta?.tool_calls) {
+      if (thinkingOpen) {
+        thinkingOpen = false;
+        yield { type: "thinking_stop" };
+      }
+      for (const tc of choice.delta.tool_calls) {
+        const idx = tc.index ?? 0;
+        let entry = toolByIndex.get(idx);
+        if (!entry) {
+          entry = {
+            id: tc.id,
+            name: tc.function?.name,
+            argBuf: "",
+            emittedStart: false,
+            emittedArgLength: 0
+          };
+          toolByIndex.set(idx, entry);
+        } else {
+          if (tc.id && !entry.id) entry.id = tc.id;
+          if (tc.function?.name && !entry.name) entry.name = tc.function.name;
+        }
+        if (tc.function?.arguments) {
+          entry.argBuf += tc.function.arguments;
+        }
+        if (!entry.emittedStart && entry.id && entry.name) {
+          entry.emittedStart = true;
+          yield { type: "tool_use_start", id: entry.id, name: entry.name };
+        }
+        if (entry.emittedStart && entry.id && entry.emittedArgLength < entry.argBuf.length) {
+          const partial = entry.argBuf.slice(entry.emittedArgLength);
+          entry.emittedArgLength = entry.argBuf.length;
+          yield {
+            type: "tool_use_input_delta",
+            id: entry.id,
+            partial
+          };
+        }
+      }
+    }
+    if (choice?.finish_reason) {
+      stopReason = normalizeOpenAI(choice.finish_reason);
+    }
+    const u = obj["usage"];
+    if (u) {
+      const hasDeepSeekCacheFields = u.prompt_cache_hit_tokens !== void 0 || u.prompt_cache_miss_tokens !== void 0;
+      const cached = u.prompt_tokens_details?.cached_tokens ?? u.prompt_cache_hit_tokens ?? 0;
+      const promptTotal = u.prompt_tokens ?? u.input_tokens ?? (hasDeepSeekCacheFields ? (u.prompt_cache_hit_tokens ?? 0) + (u.prompt_cache_miss_tokens ?? 0) : usage.input + cached);
+      usage = {
+        input: u.prompt_cache_miss_tokens ?? Math.max(0, promptTotal - cached),
+        output: u.completion_tokens ?? usage.output,
+        cacheRead: cached || usage.cacheRead
+      };
+    }
+  }
+  if (thinkingOpen) {
+    yield { type: "thinking_stop" };
+  }
+  for (const entry of toolByIndex.values()) {
+    if (!entry.name) continue;
+    if (!entry.id) entry.id = `call_${randomUUID()}`;
+    if (!entry.emittedStart) {
+      yield { type: "tool_use_start", id: entry.id, name: entry.name };
+    }
+    const input = parseToolInput(entry.argBuf);
+    yield { type: "tool_use_stop", id: entry.id, input };
+  }
+  if (started) {
+    yield { type: "message_stop", stopReason, usage };
+  }
+}
+
+// src/github-copilot.ts
+var COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
+var COPILOT_API_VERSION = "2026-06-01";
+var COPILOT_HEADERS = {
+  "User-Agent": "GitHubCopilotChat/0.35.0",
+  "Editor-Version": "vscode/1.107.0",
+  "Editor-Plugin-Version": "copilot-chat/0.35.0",
+  "Copilot-Integration-Id": "vscode-chat"
+};
+var DEFAULT_API_BASE = "https://api.individual.githubcopilot.com";
+var REFRESH_SKEW_MS2 = 6e4;
+function copilotBaseUrlFromToken(token) {
+  if (token) {
+    const m = token.match(/proxy-ep=([^;]+)/);
+    if (m?.[1]) return `https://${m[1].replace(/^proxy\./, "api.")}`;
+  }
+  return DEFAULT_API_BASE;
+}
+async function refreshCopilotToken(githubToken, signal) {
+  const res = await fetch(COPILOT_TOKEN_URL, {
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${githubToken}`,
+      ...COPILOT_HEADERS
+    },
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Copilot token request failed (${res.status}): ${text || res.statusText}`);
+  }
+  const json = await res.json();
+  if (!json?.token || typeof json.expires_at !== "number") {
+    throw new Error("Copilot token response missing fields");
+  }
+  return { token: json.token, expires: json.expires_at * 1e3 };
+}
+var GitHubCopilotProvider = class extends OpenAIProvider {
+  capabilities;
+  copilotToken;
+  githubToken;
+  expiresAt;
+  apiBase;
+  onRefresh;
+  refreshFn;
+  constructor(opts) {
+    const apiBase = copilotBaseUrlFromToken(opts.credentials.copilotToken);
+    super({
+      // OpenAIProvider requires a non-empty apiKey; use a placeholder when the
+      // Copilot token is empty (it will be minted before the first request).
+      apiKey: opts.credentials.copilotToken || "pending",
+      baseUrl: apiBase,
+      id: opts.id ?? "github-copilot",
+      fetchImpl: opts.fetchImpl,
+      streamOpts: opts.streamOpts,
+      capabilities: opts.capabilities
+    });
+    this.copilotToken = opts.credentials.copilotToken;
+    this.githubToken = opts.credentials.githubToken;
+    this.expiresAt = opts.credentials.expiresAt;
+    this.apiBase = apiBase;
+    this.onRefresh = opts.onRefresh;
+    this.refreshFn = opts.refreshFn ?? refreshCopilotToken;
+    this.capabilities = capabilitiesForFamily("github-copilot", { ...opts.capabilities });
+  }
+  async *stream(req, opts) {
+    await this.ensureFreshToken(opts.signal);
+    try {
+      yield* super.stream(req, opts);
+    } catch (err) {
+      if (err instanceof ProviderError && err.status === 401 && this.githubToken) {
+        await this.doRefresh(opts.signal);
+        yield* super.stream(req, opts);
+        return;
+      }
+      throw err;
+    }
+  }
+  async ensureFreshToken(signal) {
+    const stale = this.expiresAt === void 0 || Date.now() >= this.expiresAt - REFRESH_SKEW_MS2;
+    if (!this.copilotToken || stale && this.githubToken) {
+      await this.doRefresh(signal);
+    }
+  }
+  async doRefresh(signal) {
+    if (!this.githubToken) return;
+    const t = await this.refreshFn(this.githubToken, signal);
+    this.copilotToken = t.token;
+    this.expiresAt = t.expires;
+    this.apiBase = copilotBaseUrlFromToken(t.token);
+    this.onRefresh?.({
+      accessToken: t.token,
+      refreshToken: this.githubToken,
+      expiresAt: t.expires
+    });
+  }
+  buildUrl(_req) {
+    return `${this.apiBase.replace(/\/+$/, "")}/chat/completions`;
+  }
+  buildHeaders(_req) {
+    return {
+      "content-type": "application/json",
+      accept: "text/event-stream",
+      authorization: `Bearer ${this.copilotToken}`,
+      "X-GitHub-Api-Version": COPILOT_API_VERSION,
+      ...COPILOT_HEADERS
+    };
+  }
+};
+var DEFAULT_BASE4 = "https://generativelanguage.googleapis.com/v1beta";
 var GoogleProvider = class extends WireAdapter {
   id;
   capabilities;
   constructor(opts) {
-    super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE2, opts.fetchImpl, opts.streamOpts);
+    super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE4, opts.fetchImpl, opts.streamOpts);
     this.id = opts.id ?? "google";
     this.capabilities = capabilitiesForFamily("google", {
       ...opts.capabilities
@@ -1022,14 +1649,17 @@ var GoogleProvider = class extends WireAdapter {
   }
 };
 function toolsToGemini(tools) {
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    parameters: sanitizeSchemaForGemini(t.inputSchema) ?? {
-      type: "object",
-      properties: {}
-    }
-  }));
+  return tools.map((t) => {
+    const compact = compactToolDefinitionForWire(t);
+    return {
+      name: compact.name,
+      description: compact.description,
+      parameters: sanitizeSchemaForGemini(compact.inputSchema) ?? {
+        type: "object",
+        properties: {}
+      }
+    };
+  });
 }
 var GEMINI_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "type",
@@ -1192,296 +1822,356 @@ async function* parseGoogleStream(body, fallbackModel) {
   }
 }
 
-// src/openai.ts
+// src/openai-codex.ts
 init_tool_input();
-
-// src/tool-format/to-openai.ts
-function toolsToOpenAI(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    function: {
-      name: t.name,
-      description: t.description,
-      parameters: t.inputSchema ?? {
-        type: "object",
-        properties: {}
-      }
-    }
-  }));
+var _toolCache = /* @__PURE__ */ new WeakMap();
+function toolsToResponses(tools) {
+  const hit = _toolCache.get(tools);
+  if (hit) return hit;
+  const result = tools.map((t) => {
+    const compact = compactToolDefinitionForWire(t);
+    return {
+      type: "function",
+      name: compact.name,
+      description: compact.description,
+      parameters: compact.inputSchema,
+      strict: false
+    };
+  });
+  _toolCache.set(tools, result);
+  return result;
 }
-function messagesToOpenAI(system, messages, opts = {}) {
-  const emptyContentMode = opts.emptyToolCallContent ?? "empty_string";
+function normalizeContent2(content) {
+  return typeof content === "string" ? [{ type: "text", text: content }] : content;
+}
+function imageUrl(b) {
+  return b.source.type === "url" ? b.source.url ?? "" : `data:${b.source.media_type ?? "image/png"};base64,${b.source.data ?? ""}`;
+}
+function messagesToResponsesInput(messages) {
   const out = [];
-  if (system && system.length > 0) {
-    const sysText = system.map((b) => b.text).join("\n\n");
-    if (opts.systemAsMessage) {
-      out.push({ role: "user", content: sysText });
-    } else {
-      out.push({ role: "system", content: sysText });
-    }
-  }
   for (const msg of messages) {
+    const blocks = normalizeContent2(msg.content);
     if (msg.role === "user") {
-      const blocks = normalizeContent(msg.content);
       const toolResults = blocks.filter((b) => b.type === "tool_result");
-      const others = blocks.filter((b) => b.type !== "tool_result");
       for (const r of toolResults) {
-        const content = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
         out.push({
-          role: "tool",
-          tool_call_id: r.tool_use_id,
-          content
+          type: "function_call_output",
+          call_id: r.tool_use_id,
+          output: typeof r.content === "string" ? r.content : JSON.stringify(r.content)
         });
       }
-      if (others.length > 0) {
-        out.push({
-          role: "user",
-          content: opts.flattenContentToString ? blocksToString(others) : blocksToContentArray(others)
-        });
+      const others = blocks.filter((b) => b.type !== "tool_result");
+      if (others.length > 0) {
+        const content = others.map((b) => {
+          if (b.type === "text") return { type: "input_text", text: b.text };
+          if (b.type === "image") {
+            return { type: "input_image", detail: "auto", image_url: imageUrl(b) };
+          }
+          return null;
+        }).filter((c) => c !== null);
+        if (content.length > 0) out.push({ role: "user", content });
       }
     } else if (msg.role === "assistant") {
-      const blocks = normalizeContent(msg.content);
       const textBlocks = blocks.filter((b) => b.type === "text");
       const toolUses = blocks.filter((b) => b.type === "tool_use");
-      const thinkingBlocks = blocks.filter((b) => b.type === "thinking");
       const text = textBlocks.map((b) => b.text).join("");
-      const reasoning = thinkingBlocks.map((b) => b.thinking).filter((t) => t && t.length > 0).join("");
-      const toolCalls = toolUses.map((u) => ({
-        id: u.id,
-        type: "function",
-        function: { name: u.name, arguments: JSON.stringify(u.input) }
-      }));
-      const message = { role: "assistant" };
-      if (toolCalls.length > 0) {
-        message.tool_calls = toolCalls;
-        if (text) {
-          message.content = text;
-        } else {
-          message.content = emptyContentMode === "null" ? null : "";
-        }
-      } else {
-        message.content = text;
+      if (text.length > 0) {
+        out.push({
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text, annotations: [] }],
+          status: "completed"
+        });
       }
-      if (reasoning.length > 0) {
-        message.reasoning_content = reasoning;
+      for (const u of toolUses) {
+        out.push({
+          type: "function_call",
+          call_id: u.id,
+          name: u.name,
+          arguments: JSON.stringify(u.input ?? {})
+        });
       }
-      out.push(message);
     }
   }
   return out;
 }
-function normalizeContent(content) {
-  return typeof content === "string" ? [{ type: "text", text: content }] : content;
-}
-function blocksToString(blocks) {
-  return blocks.map((b) => {
-    if (b.type === "text") return b.text;
-    if (b.type === "image") return "[image]";
-    return "";
-  }).join("");
-}
-function blocksToContentArray(blocks) {
-  const hasImage = blocks.some((b) => b.type === "image");
-  if (!hasImage) {
-    return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+
+// src/openai-codex.ts
+var CLIENT_ID2 = "app_EMoamEEZ73f0CkXaXp7hrann";
+var TOKEN_URL2 = "https://auth.openai.com/oauth/token";
+var JWT_CLAIM_PATH = "https://api.openai.com/auth";
+var DEFAULT_CODEX_BASE = "https://chatgpt.com/backend-api";
+var REFRESH_SKEW_MS3 = 6e4;
+async function refreshCodexAccessToken(refreshToken, signal) {
+  const res = await fetch(TOKEN_URL2, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID2,
+      refresh_token: refreshToken
+    }).toString(),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(3e4)]) : AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Codex token refresh failed (${res.status}): ${text || res.statusText}`);
   }
-  return blocks.map((b) => {
-    if (b.type === "text") return { type: "text", text: b.text };
-    if (b.type === "image") {
-      const url = b.source.type === "url" ? b.source.url ?? "" : `data:${b.source.media_type ?? "image/png"};base64,${b.source.data ?? ""}`;
-      return { type: "image_url", image_url: { url } };
-    }
+  const json = await res.json();
+  if (!json?.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
+    throw new Error("Codex token refresh response missing fields");
+  }
+  return {
+    access: json.access_token,
+    refresh: json.refresh_token,
+    expires: Date.now() + json.expires_in * 1e3
+  };
+}
+function extractAccountId(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    const auth = payload[JWT_CLAIM_PATH];
+    const id = auth?.chatgpt_account_id;
+    return typeof id === "string" && id.length > 0 ? id : null;
+  } catch {
     return null;
-  }).filter((c) => c !== null);
+  }
 }
-
-// src/openai.ts
-var DEFAULT_BASE3 = "https://api.openai.com/v1";
-var OpenAIProvider = class extends WireAdapter {
+var OpenAICodexProvider = class extends WireAdapter {
   id;
   capabilities;
-  opts;
+  access;
+  refresh;
+  expiresAt;
+  accountId;
+  onRefresh;
+  refreshFn;
+  reasoningEffort;
   constructor(opts) {
-    super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE3, opts.fetchImpl, opts.streamOpts);
-    this.opts = opts;
-    this.id = opts.id ?? "openai";
-    this.capabilities = capabilitiesForFamily("openai", {
-      parallelTools: !opts.quirks?.parallelToolsDisabled,
-      systemPrompt: !opts.quirks?.systemAsMessage,
-      ...opts.capabilities
+    super(
+      opts.credentials.accessToken,
+      opts.baseUrl ?? DEFAULT_CODEX_BASE,
+      opts.fetchImpl,
+      opts.streamOpts
+    );
+    this.id = opts.id ?? "openai-codex";
+    this.access = opts.credentials.accessToken;
+    this.refresh = opts.credentials.refreshToken;
+    this.expiresAt = opts.credentials.expiresAt;
+    this.accountId = opts.credentials.accountId ?? extractAccountId(this.access) ?? void 0;
+    this.onRefresh = opts.onRefresh;
+    this.refreshFn = opts.refreshFn ?? refreshCodexAccessToken;
+    this.reasoningEffort = opts.reasoningEffort ?? "medium";
+    this.capabilities = capabilitiesForFamily("openai-codex", { ...opts.capabilities });
+  }
+  async *stream(req, opts) {
+    await this.ensureFreshToken(opts.signal);
+    try {
+      yield* super.stream(req, opts);
+    } catch (err) {
+      if (err instanceof ProviderError && err.status === 401 && this.refresh) {
+        await this.doRefresh(opts.signal);
+        yield* super.stream(req, opts);
+        return;
+      }
+      throw err;
+    }
+  }
+  async ensureFreshToken(signal) {
+    if (!this.refresh) return;
+    if (this.expiresAt !== void 0 && Date.now() < this.expiresAt - REFRESH_SKEW_MS3) return;
+    await this.doRefresh(signal);
+  }
+  async doRefresh(signal) {
+    if (!this.refresh) return;
+    const t = await this.refreshFn(this.refresh, signal);
+    this.access = t.access;
+    this.refresh = t.refresh;
+    this.expiresAt = t.expires;
+    this.accountId = extractAccountId(t.access) ?? this.accountId;
+    this.onRefresh?.({
+      accessToken: t.access,
+      refreshToken: t.refresh,
+      expiresAt: t.expires,
+      accountId: this.accountId
     });
   }
   buildUrl(_req) {
-    const base = this.baseUrl.replace(/\/+$/, "");
-    if (/\/chat\/completions$/.test(base)) return base;
-    if (/\/v\d+(\/[a-z0-9_-]+)*$/i.test(base)) return `${base}/chat/completions`;
-    return `${base}/v1/chat/completions`;
+    return resolveCodexUrl(this.baseUrl);
   }
-  buildHeaders(req) {
+  buildHeaders(_req) {
     const headers = {
-      ...super.buildHeaders(req),
-      authorization: `Bearer ${this.apiKey}`
+      ...super.buildHeaders(_req),
+      authorization: `Bearer ${this.access}`,
+      originator: "wrongstack",
+      "OpenAI-Beta": "responses=experimental"
     };
-    if (this.opts.organization) {
-      headers["openai-organization"] = this.opts.organization;
-    }
+    if (this.accountId) headers["chatgpt-account-id"] = this.accountId;
     return headers;
   }
-  /**
-   * The request field used to cap output length. Real OpenAI deprecated
-   * `max_tokens` and the newer model families (gpt-4o, o1/o3/o4) 400 on it —
-   * they require `max_completion_tokens`. OpenAI-compatible endpoints that
-   * still only accept `max_tokens` override this. See issue #10.
-   */
-  tokenLimitParam() {
-    return "max_completion_tokens";
-  }
   buildBody(req) {
+    const instructions = req.system && req.system.length > 0 ? req.system.map((b) => b.text).join("\n\n") : "You are a helpful assistant.";
     const body = {
       model: req.model,
-      messages: messagesToOpenAI(this.stripCacheControl(req), req.messages, {
-        ...this.opts.quirks
-      }),
-      [this.tokenLimitParam()]: req.maxTokens,
+      // The ChatGPT Codex backend rejects `store: true` ("Store must be set to
+      // false"). We send the full conversation as `input` each turn.
+      store: false,
       stream: true,
-      stream_options: { include_usage: true }
+      instructions,
+      input: messagesToResponsesInput(req.messages),
+      include: ["reasoning.encrypted_content"],
+      parallel_tool_calls: true
     };
     if (req.tools && req.tools.length > 0) {
-      body["tools"] = toolsToOpenAI(req.tools);
-      if (req.toolChoice) {
-        if (typeof req.toolChoice === "string") {
-          body["tool_choice"] = req.toolChoice === "required" ? "required" : req.toolChoice;
-        } else {
-          body["tool_choice"] = {
-            type: "function",
-            function: { name: req.toolChoice.name }
-          };
-        }
-      }
+      body["tools"] = toolsToResponses(req.tools);
+      body["tool_choice"] = mapToolChoice(req.toolChoice);
     }
     if (req.temperature !== void 0) body["temperature"] = req.temperature;
     if (req.topP !== void 0) body["top_p"] = req.topP;
-    if (req.stopSequences) body["stop"] = req.stopSequences;
+    if (this.reasoningEffort !== "none") {
+      body["reasoning"] = { effort: this.reasoningEffort, summary: "auto" };
+    }
     return body;
   }
   parseStream(body, fallbackModel) {
-    return parseOpenAIStream(body, fallbackModel);
+    return parseCodexResponsesStream(body, fallbackModel);
   }
   translateError(status, text) {
     return parseProviderHttpError(this.id, status, text);
   }
-  stripCacheControl(req) {
-    if (!req.system) return void 0;
-    return req.system.map((b) => {
-      const { cache_control: _cc, ...rest } = b;
-      return rest;
-    });
-  }
 };
-async function* parseOpenAIStream(body, fallbackModel) {
+function resolveCodexUrl(baseUrl) {
+  const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE;
+  const normalized = raw.replace(/\/+$/, "");
+  if (normalized.endsWith("/codex/responses")) return normalized;
+  if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+  return `${normalized}/codex/responses`;
+}
+function mapToolChoice(choice) {
+  if (choice === void 0) return "auto";
+  if (choice === "auto" || choice === "required" || choice === "none") return choice;
+  return { type: "function", name: choice.name };
+}
+async function* parseCodexResponsesStream(body, fallbackModel) {
   let model = fallbackModel;
+  let started = false;
   let usage = { input: 0, output: 0 };
   let stopReason = "end_turn";
-  let started = false;
-  let thinkingOpen = false;
-  const toolByIndex = /* @__PURE__ */ new Map();
+  let sawToolUse = false;
+  let toolCallId;
+  let toolArgBuf = "";
+  const ensureStart = () => {
+    if (started) return void 0;
+    started = true;
+    return { type: "message_start", model };
+  };
   for await (const msg of parseSSE(body)) {
     if (!msg.data || msg.data === "[DONE]") continue;
     const parsed = safeParse(msg.data);
     if (!parsed.ok || !parsed.value) continue;
-    const obj = parsed.value;
-    if (typeof obj["model"] === "string") model = obj["model"];
-    if (!started) {
-      started = true;
-      yield { type: "message_start", model };
-    }
-    const choices = obj["choices"];
-    const choice = choices?.[0];
-    const reasoningDelta = typeof choice?.delta?.reasoning_content === "string" ? choice.delta.reasoning_content : typeof choice?.delta?.reasoning === "string" ? choice.delta.reasoning : void 0;
-    if (reasoningDelta && reasoningDelta.length > 0) {
-      if (!thinkingOpen) {
-        thinkingOpen = true;
-        yield { type: "thinking_start" };
+    const evt = parsed.value;
+    const type = typeof evt["type"] === "string" ? evt["type"] : "";
+    switch (type) {
+      case "response.created":
+      case "response.in_progress": {
+        const resp = evt["response"];
+        if (typeof resp?.model === "string") model = resp.model;
+        const s = ensureStart();
+        if (s) yield s;
+        break;
       }
-      yield { type: "thinking_delta", text: reasoningDelta };
-    }
-    if (choice?.delta?.content) {
-      if (thinkingOpen) {
-        thinkingOpen = false;
-        yield { type: "thinking_stop" };
+      case "response.output_item.added": {
+        const s = ensureStart();
+        if (s) yield s;
+        const item = evt["item"];
+        if (!item) break;
+        if (item.type === "reasoning") {
+          yield { type: "thinking_start" };
+        } else if (item.type === "function_call") {
+          toolCallId = item.call_id ?? item.id ?? `call_${Math.random().toString(36).slice(2)}`;
+          toolArgBuf = item.arguments ?? "";
+          sawToolUse = true;
+          yield { type: "tool_use_start", id: toolCallId, name: item.name ?? "unknown" };
+          if (toolArgBuf.length > 0) {
+            yield { type: "tool_use_input_delta", id: toolCallId, partial: toolArgBuf };
+          }
+        }
+        break;
       }
-      yield { type: "text_delta", text: choice.delta.content };
-    }
-    if (choice?.delta?.tool_calls) {
-      if (thinkingOpen) {
-        thinkingOpen = false;
-        yield { type: "thinking_stop" };
+      case "response.output_text.delta":
+      case "response.refusal.delta": {
+        const delta = typeof evt["delta"] === "string" ? evt["delta"] : "";
+        if (delta) yield { type: "text_delta", text: delta };
+        break;
       }
-      for (const tc of choice.delta.tool_calls) {
-        const idx = tc.index ?? 0;
-        let entry = toolByIndex.get(idx);
-        if (!entry) {
-          entry = {
-            id: tc.id,
-            name: tc.function?.name,
-            argBuf: "",
-            emittedStart: false,
-            emittedArgLength: 0
-          };
-          toolByIndex.set(idx, entry);
-        } else {
-          if (tc.id && !entry.id) entry.id = tc.id;
-          if (tc.function?.name && !entry.name) entry.name = tc.function.name;
-        }
-        if (tc.function?.arguments) {
-          entry.argBuf += tc.function.arguments;
-        }
-        if (!entry.emittedStart && entry.id && entry.name) {
-          entry.emittedStart = true;
-          yield { type: "tool_use_start", id: entry.id, name: entry.name };
+      case "response.reasoning_text.delta":
+      case "response.reasoning_summary_text.delta": {
+        const delta = typeof evt["delta"] === "string" ? evt["delta"] : "";
+        if (delta) yield { type: "thinking_delta", text: delta };
+        break;
+      }
+      case "response.function_call_arguments.delta": {
+        const delta = typeof evt["delta"] === "string" ? evt["delta"] : "";
+        if (toolCallId && delta) {
+          toolArgBuf += delta;
+          yield { type: "tool_use_input_delta", id: toolCallId, partial: delta };
         }
-        if (entry.emittedStart && entry.id && entry.emittedArgLength < entry.argBuf.length) {
-          const partial = entry.argBuf.slice(entry.emittedArgLength);
-          entry.emittedArgLength = entry.argBuf.length;
-          yield {
-            type: "tool_use_input_delta",
-            id: entry.id,
-            partial
-          };
+        break;
+      }
+      case "response.function_call_arguments.done": {
+        const args = typeof evt["arguments"] === "string" ? evt["arguments"] : void 0;
+        if (args !== void 0) toolArgBuf = args;
+        break;
+      }
+      case "response.output_item.done": {
+        const item = evt["item"];
+        if (!item) break;
+        if (item.type === "reasoning") {
+          yield { type: "thinking_stop" };
+        } else if (item.type === "function_call") {
+          const id = item.call_id ?? toolCallId ?? `call_${Math.random().toString(36).slice(2)}`;
+          const raw = item.arguments && item.arguments.length > 0 ? item.arguments : toolArgBuf;
+          yield { type: "tool_use_stop", id, input: parseToolInput(raw || "{}") };
+          toolCallId = void 0;
+          toolArgBuf = "";
         }
+        break;
+      }
+      case "response.completed":
+      case "response.incomplete": {
+        const resp = evt["response"];
+        if (resp?.usage) usage = normalizeUsage(resp.usage);
+        stopReason = mapResponsesStatus(resp?.status, sawToolUse);
+        break;
+      }
+      case "error":
+      case "response.failed": {
+        const message = evt["message"] ?? evt["response"]?.error?.message ?? "Codex response failed";
+        throw new ProviderError(message, 502, true, "openai-codex", {
+          body: { message }
+        });
       }
     }
-    if (choice?.finish_reason) {
-      stopReason = normalizeOpenAI(choice.finish_reason);
-    }
-    const u = obj["usage"];
-    if (u) {
-      const hasDeepSeekCacheFields = u.prompt_cache_hit_tokens !== void 0 || u.prompt_cache_miss_tokens !== void 0;
-      const cached = u.prompt_tokens_details?.cached_tokens ?? u.prompt_cache_hit_tokens ?? 0;
-      const promptTotal = u.prompt_tokens ?? u.input_tokens ?? (hasDeepSeekCacheFields ? (u.prompt_cache_hit_tokens ?? 0) + (u.prompt_cache_miss_tokens ?? 0) : usage.input + cached);
-      usage = {
-        input: u.prompt_cache_miss_tokens ?? Math.max(0, promptTotal - cached),
-        output: u.completion_tokens ?? usage.output,
-        cacheRead: cached || usage.cacheRead
-      };
-    }
-  }
-  if (thinkingOpen) {
-    yield { type: "thinking_stop" };
-  }
-  for (const entry of toolByIndex.values()) {
-    if (!entry.name) continue;
-    if (!entry.id) entry.id = `call_${randomUUID()}`;
-    if (!entry.emittedStart) {
-      yield { type: "tool_use_start", id: entry.id, name: entry.name };
-    }
-    const input = parseToolInput(entry.argBuf);
-    yield { type: "tool_use_stop", id: entry.id, input };
   }
   if (started) {
     yield { type: "message_stop", stopReason, usage };
   }
 }
+function normalizeUsage(u) {
+  const cached = u.input_tokens_details?.cached_tokens ?? 0;
+  const total = u.input_tokens ?? 0;
+  return {
+    input: Math.max(0, total - cached),
+    output: u.output_tokens ?? 0,
+    cacheRead: cached || void 0
+  };
+}
+function mapResponsesStatus(status, sawToolUse) {
+  if (status === "incomplete") return "max_tokens";
+  return sawToolUse ? "tool_use" : "end_turn";
+}
 
 // src/openai-compatible.ts
 var VALID_QUIRK_KEYS = /* @__PURE__ */ new Set([
@@ -2148,14 +2838,17 @@ function buildGenConfig(req) {
   return cfg;
 }
 function toolsToGemini2(tools) {
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    parameters: sanitizeSchemaForGemini2(t.inputSchema) ?? {
-      type: "object",
-      properties: {}
-    }
-  }));
+  return tools.map((t) => {
+    const compact = compactToolDefinitionForWire(t);
+    return {
+      name: compact.name,
+      description: compact.description,
+      parameters: sanitizeSchemaForGemini2(compact.inputSchema) ?? {
+        type: "object",
+        properties: {}
+      }
+    };
+  });
 }
 var GEMINI_ALLOWED_KEYS2 = /* @__PURE__ */ new Set([
   "type",
@@ -2409,6 +3102,11 @@ function parseToolArguments(raw, toolName, toolCallId, opts) {
 }
 
 // src/index.ts
+var _oauthPersist;
+function setOAuthTokenPersister(fn) {
+  _oauthPersist = fn;
+}
+var setCodexTokenPersister = setOAuthTokenPersister;
 async function buildProviderFactoriesFromRegistry(opts) {
   const providers = await opts.registry.listProviders();
   const factories = [];
@@ -2442,10 +3140,24 @@ async function buildProviderFactoriesFromRegistry(opts) {
   }
   return factories;
 }
+function resolveActiveKey(cfg) {
+  if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
+    const active = cfg.activeKey ? cfg.apiKeys.find((k) => k.label === cfg.activeKey) : void 0;
+    return (active ?? cfg.apiKeys[0])?.apiKey;
+  }
+  return cfg.apiKey && cfg.apiKey.length > 0 ? cfg.apiKey : void 0;
+}
+function resolveActiveKeyEntry(cfg) {
+  if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
+    const active = cfg.activeKey ? cfg.apiKeys.find((k) => k.label === cfg.activeKey) : void 0;
+    return active ?? cfg.apiKeys[0];
+  }
+  return void 0;
+}
 function makeProvider(p, cfg) {
   const family = cfg.family ?? p.family;
   const envVars = cfg.envVars && cfg.envVars.length > 0 ? cfg.envVars : p.envVars;
-  const apiKey = cfg.apiKey ?? readFromEnv(envVars);
+  const apiKey = resolveActiveKey(cfg) ?? readFromEnv(envVars);
   if (!apiKey && family !== "unsupported") {
     throw new Error(
       `Provider "${p.id}" requires an API key. Set ${envVars.join(" or ") || "apiKey in config"} or run \`wstack auth ${p.id}\`.`
@@ -2480,6 +3192,48 @@ function makeProvider(p, cfg) {
         headers: cfg.headers,
         quirks: validateQuirks(p.id, cfg.quirks)
       });
+    case "openai-codex": {
+      const entry = resolveActiveKeyEntry(cfg);
+      const parsedExpiry = entry?.expiresAt ? Date.parse(entry.expiresAt) : Number.NaN;
+      return new OpenAICodexProvider({
+        id: p.id,
+        baseUrl,
+        credentials: {
+          accessToken: expectDefined(apiKey),
+          refreshToken: entry?.refreshToken,
+          expiresAt: Number.isFinite(parsedExpiry) ? parsedExpiry : void 0,
+          accountId: entry?.accountId
+        },
+        onRefresh: (creds) => _oauthPersist?.(p.id, creds)
+      });
+    }
+    case "anthropic-oauth": {
+      const entry = resolveActiveKeyEntry(cfg);
+      const parsedExpiry = entry?.expiresAt ? Date.parse(entry.expiresAt) : Number.NaN;
+      return new AnthropicOAuthProvider({
+        id: p.id,
+        baseUrl,
+        credentials: {
+          accessToken: expectDefined(apiKey),
+          refreshToken: entry?.refreshToken,
+          expiresAt: Number.isFinite(parsedExpiry) ? parsedExpiry : void 0
+        },
+        onRefresh: (creds) => _oauthPersist?.(p.id, creds)
+      });
+    }
+    case "github-copilot": {
+      const entry = resolveActiveKeyEntry(cfg);
+      const parsedExpiry = entry?.expiresAt ? Date.parse(entry.expiresAt) : Number.NaN;
+      return new GitHubCopilotProvider({
+        id: p.id,
+        credentials: {
+          copilotToken: resolveActiveKey(cfg) ?? "",
+          githubToken: entry?.refreshToken,
+          expiresAt: Number.isFinite(parsedExpiry) ? parsedExpiry : void 0
+        },
+        onRefresh: (creds) => _oauthPersist?.(p.id, creds)
+      });
+    }
     case "google":
       return new GoogleProvider({ id: p.id, apiKey: expectDefined(apiKey), baseUrl });
     default:
@@ -2510,7 +3264,8 @@ function readFromEnv(vars) {
   return void 0;
 }
 function requireKey(cfg) {
-  if (cfg.apiKey) return cfg.apiKey;
+  const key = resolveActiveKey(cfg);
+  if (key) return key;
   throw new Error("Provider config requires apiKey (or set the corresponding env var).");
 }
 function validateQuirks(providerId, quirks) {
@@ -2523,6 +3278,6 @@ function validateQuirks(providerId, quirks) {
   });
 }
 
-export { AnthropicProvider, CAPABILITIES_BY_FAMILY, GoogleProvider, OpenAICompatibleProvider, OpenAIProvider, WireAdapter, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, capabilitiesForFamily, contentFromAnthropic, contentFromOpenAI, createWireFormatFactory, defaultDebugStreamCallback, defineWireFormat, googleWireFormat, isDebugStreamEnabled, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, pushDebugChunkStats, setDebugStreamCallback, setDebugStreamEnabled, toolsToAnthropic, toolsToOpenAI };
+export { AnthropicOAuthProvider, AnthropicProvider, CAPABILITIES_BY_FAMILY, CLAUDE_CODE_SYSTEM_PROMPT, GitHubCopilotProvider, GoogleProvider, OpenAICodexProvider, OpenAICompatibleProvider, OpenAIProvider, WireAdapter, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, capabilitiesForFamily, contentFromAnthropic, contentFromOpenAI, copilotBaseUrlFromToken, createWireFormatFactory, defaultDebugStreamCallback, defineWireFormat, extractAccountId, googleWireFormat, isDebugStreamEnabled, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, pushDebugChunkStats, refreshAnthropicOAuthToken, refreshCodexAccessToken, refreshCopilotToken, resolveCodexUrl, setCodexTokenPersister, setDebugStreamCallback, setDebugStreamEnabled, setOAuthTokenPersister, toolsToAnthropic, toolsToOpenAI };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map