@corbat-tech/coco 2.11.0 → 2.11.1

package/dist/index.js

@@ -11805,12 +11805,16 @@ var AnthropicProvider = class {
       );
       const streamTimeout = this.config.timeout ?? 12e4;
       let lastActivityTime = Date.now();
-      const checkTimeout = () => {
+      const timeoutController = new AbortController();
+      const timeoutInterval = setInterval(() => {
         if (Date.now() - lastActivityTime > streamTimeout) {
-          throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+          clearInterval(timeoutInterval);
+          timeoutController.abort();
         }
-      };
-      const timeoutInterval = setInterval(checkTimeout, 5e3);
+      }, 5e3);
+      timeoutController.signal.addEventListener("abort", () => stream.controller.abort(), {
+        once: true
+      });
       try {
         let streamStopReason;
         for await (const event of stream) {
@@ -11831,6 +11835,9 @@ var AnthropicProvider = class {
       } finally {
         clearInterval(timeoutInterval);
       }
+      if (timeoutController.signal.aborted) {
+        throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+      }
     } catch (error) {
       throw this.handleError(error);
     }
@@ -11857,12 +11864,16 @@ var AnthropicProvider = class {
       let currentToolInputJson = "";
       const streamTimeout = this.config.timeout ?? 12e4;
       let lastActivityTime = Date.now();
-      const checkTimeout = () => {
+      const timeoutController = new AbortController();
+      const timeoutInterval = setInterval(() => {
         if (Date.now() - lastActivityTime > streamTimeout) {
-          throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+          clearInterval(timeoutInterval);
+          timeoutController.abort();
         }
-      };
-      const timeoutInterval = setInterval(checkTimeout, 5e3);
+      }, 5e3);
+      timeoutController.signal.addEventListener("abort", () => stream.controller.abort(), {
+        once: true
+      });
       try {
         let streamStopReason;
         for await (const event of stream) {
@@ -11947,6 +11958,9 @@ var AnthropicProvider = class {
       } finally {
         clearInterval(timeoutInterval);
       }
+      if (timeoutController.signal.aborted) {
+        throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+      }
     } catch (error) {
       throw this.handleError(error);
     }
@@ -12282,6 +12296,9 @@ var LOCAL_MODEL_PATTERNS = [
   "starcoder"
 ];
 var MODELS_WITH_THINKING_MODE = ["kimi-k2.5", "kimi-k2-0324", "kimi-latest"];
+function needsResponsesApi(model) {
+  return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model.startsWith("o3-");
+}
 var OpenAIProvider = class {
   id;
   name;
@@ -12351,9 +12368,12 @@ var OpenAIProvider = class {
    */
   async chat(messages, options) {
     this.ensureInitialized();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (needsResponsesApi(model)) {
+      return this.chatViaResponses(messages, options);
+    }
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
         const supportsTemp = this.supportsTemperature(model);
         const response = await this.client.chat.completions.create({
           model,
@@ -12385,9 +12405,12 @@ var OpenAIProvider = class {
    */
   async chatWithTools(messages, options) {
     this.ensureInitialized();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (needsResponsesApi(model)) {
+      return this.chatWithToolsViaResponses(messages, options);
+    }
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
         const supportsTemp = this.supportsTemperature(model);
         const extraBody = this.getExtraBody(model);
         const requestParams = {
@@ -12429,8 +12452,12 @@ var OpenAIProvider = class {
    */
   async *stream(messages, options) {
     this.ensureInitialized();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (needsResponsesApi(model)) {
+      yield* this.streamViaResponses(messages, options);
+      return;
+    }
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
       const supportsTemp = this.supportsTemperature(model);
       const stream = await this.client.chat.completions.create({
         model,
@@ -12460,8 +12487,12 @@ var OpenAIProvider = class {
    */
   async *streamWithTools(messages, options) {
     this.ensureInitialized();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (needsResponsesApi(model)) {
+      yield* this.streamWithToolsViaResponses(messages, options);
+      return;
+    }
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
       const supportsTemp = this.supportsTemperature(model);
       const extraBody = this.getExtraBody(model);
       const requestParams = {
@@ -12484,12 +12515,16 @@ var OpenAIProvider = class {
       const toolCallBuilders = /* @__PURE__ */ new Map();
       const streamTimeout = this.config.timeout ?? 12e4;
       let lastActivityTime = Date.now();
-      const checkTimeout = () => {
+      const timeoutController = new AbortController();
+      const timeoutInterval = setInterval(() => {
         if (Date.now() - lastActivityTime > streamTimeout) {
-          throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+          clearInterval(timeoutInterval);
+          timeoutController.abort();
         }
-      };
-      const timeoutInterval = setInterval(checkTimeout, 5e3);
+      }, 5e3);
+      timeoutController.signal.addEventListener("abort", () => stream.controller.abort(), {
+        once: true
+      });
       const providerName = this.name;
       const parseArguments = (builder) => {
         let input = {};
@@ -12593,6 +12628,9 @@ var OpenAIProvider = class {
       } finally {
         clearInterval(timeoutInterval);
       }
+      if (timeoutController.signal.aborted) {
+        throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+      }
     } catch (error) {
       throw this.handleError(error);
     }
@@ -12925,1010 +12963,1043 @@ var OpenAIProvider = class {
       cause: error instanceof Error ? error : void 0
     });
   }
-};
-function createKimiProvider(config) {
-  const provider = new OpenAIProvider("kimi", "Kimi (Moonshot)");
-  const kimiConfig = {
-    ...config,
-    baseUrl: config?.baseUrl ?? process.env["KIMI_BASE_URL"] ?? "https://api.moonshot.ai/v1",
-    apiKey: config?.apiKey ?? process.env["KIMI_API_KEY"] ?? process.env["MOONSHOT_API_KEY"],
-    model: config?.model ?? "kimi-k2.5"
-  };
-  if (kimiConfig.apiKey) {
-    provider.initialize(kimiConfig).catch(() => {
-    });
-  }
-  return provider;
-}
-var OAUTH_CONFIGS = {
+  // --- Responses API support (GPT-5+, Codex, o3, o4 models) ---
   /**
-   * OpenAI OAuth (ChatGPT Plus/Pro subscriptions)
-   * Uses the official Codex client ID (same as OpenCode, Codex CLI, etc.)
+   * Simple chat via Responses API (no tools)
    */
-  openai: {
-    provider: "openai",
-    clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
-    authorizationEndpoint: "https://auth.openai.com/oauth/authorize",
-    tokenEndpoint: "https://auth.openai.com/oauth/token",
-    deviceAuthEndpoint: "https://auth.openai.com/oauth/device/code",
-    verificationUri: "https://chatgpt.com/codex/device",
-    scopes: ["openid", "profile", "email", "offline_access"],
-    extraAuthParams: {
-      id_token_add_organizations: "true",
-      codex_cli_simplified_flow: "true",
-      originator: "opencode"
-    }
-  }
-  // NOTE: Gemini OAuth removed - Google's client ID is restricted to official apps
-  // Use API Key (https://aistudio.google.com/apikey) or gcloud ADC instead
-};
-async function refreshAccessToken(provider, refreshToken) {
-  const config = OAUTH_CONFIGS[provider];
-  if (!config) {
-    throw new Error(`OAuth not supported for provider: ${provider}`);
-  }
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    client_id: config.clientId,
-    refresh_token: refreshToken
-  });
-  const response = await fetch(config.tokenEndpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: body.toString()
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Token refresh failed: ${error}`);
-  }
-  const data = await response.json();
-  return {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token || refreshToken,
-    expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0,
-    tokenType: data.token_type
-  };
-}
-function getTokenStoragePath(provider) {
-  const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path17.join(home, ".coco", "tokens", `${provider}.json`);
-}
-async function saveTokens(provider, tokens) {
-  const filePath = getTokenStoragePath(provider);
-  const dir = path17.dirname(filePath);
-  await fs16.mkdir(dir, { recursive: true, mode: 448 });
-  await fs16.writeFile(filePath, JSON.stringify(tokens, null, 2), { mode: 384 });
-}
-async function loadTokens(provider) {
-  const filePath = getTokenStoragePath(provider);
-  try {
-    const content = await fs16.readFile(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
+  async chatViaResponses(messages, options) {
+    this.ensureInitialized();
+    return withRetry(async () => {
+      try {
+        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+        const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+        const response = await this.client.responses.create({
+          model,
+          input,
+          instructions: instructions ?? void 0,
+          max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+          temperature: options?.temperature ?? this.config.temperature ?? 0,
+          store: false
+        });
+        return {
+          id: response.id,
+          content: response.output_text ?? "",
+          stopReason: response.status === "completed" ? "end_turn" : "max_tokens",
+          usage: {
+            inputTokens: response.usage?.input_tokens ?? 0,
+            outputTokens: response.usage?.output_tokens ?? 0
+          },
+          model: String(response.model)
+        };
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }, this.retryConfig);
   }
-}
-async function deleteTokens(provider) {
-  const filePath = getTokenStoragePath(provider);
-  try {
-    await fs16.unlink(filePath);
-  } catch {
+  /**
+   * Chat with tools via Responses API
+   */
+  async chatWithToolsViaResponses(messages, options) {
+    this.ensureInitialized();
+    return withRetry(async () => {
+      try {
+        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+        const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+        const tools = this.convertToolsForResponses(options.tools);
+        const response = await this.client.responses.create({
+          model,
+          input,
+          instructions: instructions ?? void 0,
+          tools,
+          max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+          temperature: options?.temperature ?? this.config.temperature ?? 0,
+          store: false
+        });
+        let content = "";
+        const toolCalls = [];
+        for (const item of response.output) {
+          if (item.type === "message") {
+            for (const part of item.content) {
+              if (part.type === "output_text") {
+                content += part.text;
+              }
+            }
+          } else if (item.type === "function_call") {
+            toolCalls.push({
+              id: item.call_id,
+              name: item.name,
+              input: this.parseResponsesArguments(item.arguments)
+            });
+          }
+        }
+        return {
+          id: response.id,
+          content,
+          stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn",
+          usage: {
+            inputTokens: response.usage?.input_tokens ?? 0,
+            outputTokens: response.usage?.output_tokens ?? 0
+          },
+          model: String(response.model),
+          toolCalls
+        };
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }, this.retryConfig);
   }
-}
-function isTokenExpired(tokens) {
-  if (!tokens.expiresAt) return false;
-  return Date.now() >= tokens.expiresAt - 5 * 60 * 1e3;
-}
-async function getValidAccessToken(provider) {
-  const config = OAUTH_CONFIGS[provider];
-  if (!config) return null;
-  const tokens = await loadTokens(provider);
-  if (!tokens) return null;
-  if (isTokenExpired(tokens)) {
-    if (tokens.refreshToken) {
+  /**
+   * Stream via Responses API (no tools)
+   */
+  async *streamViaResponses(messages, options) {
+    this.ensureInitialized();
+    try {
+      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+      const stream = await this.client.responses.create({
+        model,
+        input,
+        instructions: instructions ?? void 0,
+        max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+        temperature: options?.temperature ?? this.config.temperature ?? 0,
+        store: false,
+        stream: true
+      });
+      const streamTimeout = this.config.timeout ?? 12e4;
+      let lastActivityTime = Date.now();
+      const timeoutController = new AbortController();
+      const timeoutInterval = setInterval(() => {
+        if (Date.now() - lastActivityTime > streamTimeout) {
+          clearInterval(timeoutInterval);
+          timeoutController.abort();
+        }
+      }, 5e3);
+      timeoutController.signal.addEventListener(
+        "abort",
+        () => stream.controller?.abort(),
+        { once: true }
+      );
       try {
-        const newTokens = await refreshAccessToken(provider, tokens.refreshToken);
-        await saveTokens(provider, newTokens);
-        return { accessToken: newTokens.accessToken, isNew: true };
-      } catch {
-        await deleteTokens(provider);
-        return null;
+        for await (const event of stream) {
+          lastActivityTime = Date.now();
+          if (event.type === "response.output_text.delta") {
+            yield { type: "text", text: event.delta };
+          } else if (event.type === "response.completed") {
+            yield { type: "done", stopReason: "end_turn" };
+          }
+        }
+      } finally {
+        clearInterval(timeoutInterval);
       }
+      if (timeoutController.signal.aborted) {
+        throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+      }
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Stream with tools via Responses API
+   *
+   * IMPORTANT: fnCallBuilders is keyed by output item ID (fc.id), NOT by
+   * call_id. The streaming events (function_call_arguments.delta/done) use
+   * item_id which references the output item's id field, not call_id.
+   */
+  async *streamWithToolsViaResponses(messages, options) {
+    this.ensureInitialized();
+    try {
+      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+      const tools = options.tools.length > 0 ? this.convertToolsForResponses(options.tools) : void 0;
+      const requestParams = {
+        model,
+        input,
+        instructions: instructions ?? void 0,
+        max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+        temperature: options?.temperature ?? this.config.temperature ?? 0,
+        store: false,
+        stream: true
+      };
+      if (tools) {
+        requestParams.tools = tools;
+      }
+      const stream = await this.client.responses.create(
+        requestParams
+      );
+      const fnCallBuilders = /* @__PURE__ */ new Map();
+      const streamTimeout = this.config.timeout ?? 12e4;
+      let lastActivityTime = Date.now();
+      const timeoutController = new AbortController();
+      const timeoutInterval = setInterval(() => {
+        if (Date.now() - lastActivityTime > streamTimeout) {
+          clearInterval(timeoutInterval);
+          timeoutController.abort();
+        }
+      }, 5e3);
+      timeoutController.signal.addEventListener(
+        "abort",
+        () => stream.controller?.abort(),
+        { once: true }
+      );
+      try {
+        for await (const event of stream) {
+          lastActivityTime = Date.now();
+          switch (event.type) {
+            case "response.output_text.delta":
+              yield { type: "text", text: event.delta };
+              break;
+            case "response.output_item.added":
+              if (event.item.type === "function_call") {
+                const fc = event.item;
+                const itemKey = fc.id ?? fc.call_id;
+                fnCallBuilders.set(itemKey, {
+                  callId: fc.call_id,
+                  name: fc.name,
+                  arguments: ""
+                });
+                yield {
+                  type: "tool_use_start",
+                  toolCall: { id: fc.call_id, name: fc.name }
+                };
+              }
+              break;
+            case "response.function_call_arguments.delta":
+              {
+                const builder = fnCallBuilders.get(event.item_id);
+                if (builder) {
+                  builder.arguments += event.delta;
+                }
+              }
+              break;
+            case "response.function_call_arguments.done":
+              {
+                const builder = fnCallBuilders.get(event.item_id);
+                if (builder) {
+                  yield {
+                    type: "tool_use_end",
+                    toolCall: {
+                      id: builder.callId,
+                      name: builder.name,
+                      input: this.parseResponsesArguments(event.arguments)
+                    }
+                  };
+                  fnCallBuilders.delete(event.item_id);
+                }
+              }
+              break;
+            case "response.completed":
+              {
+                for (const [, builder] of fnCallBuilders) {
+                  yield {
+                    type: "tool_use_end",
+                    toolCall: {
+                      id: builder.callId,
+                      name: builder.name,
+                      input: this.parseResponsesArguments(builder.arguments)
+                    }
+                  };
+                }
+                fnCallBuilders.clear();
+                const hasToolCalls = event.response.output.some(
+                  (i) => i.type === "function_call"
+                );
+                yield {
+                  type: "done",
+                  stopReason: hasToolCalls ? "tool_use" : "end_turn"
+                };
+              }
+              break;
+          }
+        }
+      } finally {
+        clearInterval(timeoutInterval);
+      }
+      if (timeoutController.signal.aborted) {
+        throw new Error(`Stream timeout: No response from LLM for ${streamTimeout / 1e3}s`);
+      }
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  // --- Responses API conversion helpers ---
+  /**
+   * Convert internal messages to Responses API input format.
+   *
+   * The Responses API uses a flat array of input items instead of the
+   * chat completions messages array.
+   */
+  convertToResponsesInput(messages, systemPrompt) {
+    const input = [];
+    let instructions = null;
+    if (systemPrompt) {
+      instructions = systemPrompt;
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        instructions = (instructions ? instructions + "\n\n" : "") + this.contentToString(msg.content);
+      } else if (msg.role === "user") {
+        if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "tool_result")) {
+          for (const block of msg.content) {
+            if (block.type === "tool_result") {
+              const tr = block;
+              input.push({
+                type: "function_call_output",
+                call_id: tr.tool_use_id,
+                output: tr.content
+              });
+            }
+          }
+        } else if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "image")) {
+          const parts = [];
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              parts.push({ type: "input_text", text: block.text });
+            } else if (block.type === "image") {
+              const imgBlock = block;
+              parts.push({
+                type: "input_image",
+                image_url: `data:${imgBlock.source.media_type};base64,${imgBlock.source.data}`,
+                detail: "auto"
+              });
+            }
+          }
+          input.push({
+            role: "user",
+            content: parts
+          });
+        } else {
+          input.push({
+            role: "user",
+            content: this.contentToString(msg.content)
+          });
+        }
+      } else if (msg.role === "assistant") {
+        if (typeof msg.content === "string") {
+          input.push({ role: "assistant", content: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          const textParts = [];
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              textParts.push(block.text);
+            } else if (block.type === "tool_use") {
+              if (textParts.length > 0) {
+                input.push({ role: "assistant", content: textParts.join("") });
+                textParts.length = 0;
+              }
+              input.push({
+                type: "function_call",
+                call_id: block.id,
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              });
+            }
+          }
+          if (textParts.length > 0) {
+            input.push({ role: "assistant", content: textParts.join("") });
+          }
+        }
+      }
+    }
+    return { input, instructions };
+  }
+  /**
+   * Convert tool definitions to Responses API FunctionTool format
+   */
+  convertToolsForResponses(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description ?? void 0,
+      parameters: tool.input_schema ?? null,
+      strict: false
+    }));
+  }
+  /**
+   * Parse tool call arguments with jsonrepair fallback (Responses API)
+   */
+  parseResponsesArguments(args) {
+    try {
+      return args ? JSON.parse(args) : {};
+    } catch {
+      try {
+        if (args) {
+          const repaired = jsonrepair(args);
+          return JSON.parse(repaired);
+        }
+      } catch {
+        console.error(`[${this.name}] Cannot parse tool arguments: ${args.slice(0, 200)}`);
+      }
+      return {};
     }
-    await deleteTokens(provider);
-    return null;
-  }
-  return { accessToken: tokens.accessToken, isNew: false };
-}
-function detectWSL() {
-  if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) return true;
-  try {
-    return /microsoft/i.test(readFileSync("/proc/version", "utf-8"));
-  } catch {
-    return false;
   }
-}
-var isWSL = detectWSL();
-var COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
-var COPILOT_BASE_URLS = {
-  individual: "https://api.githubcopilot.com",
-  business: "https://api.business.githubcopilot.com",
-  enterprise: "https://api.enterprise.githubcopilot.com"
 };
-var DEFAULT_COPILOT_BASE_URL = "https://api.githubcopilot.com";
-var REFRESH_BUFFER_MS = 6e4;
-var CopilotAuthError = class extends Error {
-  constructor(message, permanent) {
-    super(message);
-    this.permanent = permanent;
-    this.name = "CopilotAuthError";
+function createKimiProvider(config) {
+  const provider = new OpenAIProvider("kimi", "Kimi (Moonshot)");
+  const kimiConfig = {
+    ...config,
+    baseUrl: config?.baseUrl ?? process.env["KIMI_BASE_URL"] ?? "https://api.moonshot.ai/v1",
+    apiKey: config?.apiKey ?? process.env["KIMI_API_KEY"] ?? process.env["MOONSHOT_API_KEY"],
+    model: config?.model ?? "kimi-k2.5"
+  };
+  if (kimiConfig.apiKey) {
+    provider.initialize(kimiConfig).catch(() => {
+    });
+  }
+  return provider;
+}
+var OAUTH_CONFIGS = {
+  /**
+   * OpenAI OAuth (ChatGPT Plus/Pro subscriptions)
+   * Uses the official Codex client ID (same as OpenCode, Codex CLI, etc.)
+   */
+  openai: {
+    provider: "openai",
+    clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+    authorizationEndpoint: "https://auth.openai.com/oauth/authorize",
+    tokenEndpoint: "https://auth.openai.com/oauth/token",
+    deviceAuthEndpoint: "https://auth.openai.com/oauth/device/code",
+    verificationUri: "https://chatgpt.com/codex/device",
+    scopes: ["openid", "profile", "email", "offline_access"],
+    extraAuthParams: {
+      id_token_add_organizations: "true",
+      codex_cli_simplified_flow: "true",
+      originator: "opencode"
+    }
   }
+  // NOTE: Gemini OAuth removed - Google's client ID is restricted to official apps
+  // Use API Key (https://aistudio.google.com/apikey) or gcloud ADC instead
 };
-async function exchangeForCopilotToken(githubToken) {
-  const response = await fetch(COPILOT_TOKEN_URL, {
-    method: "GET",
+async function refreshAccessToken(provider, refreshToken) {
+  const config = OAUTH_CONFIGS[provider];
+  if (!config) {
+    throw new Error(`OAuth not supported for provider: ${provider}`);
+  }
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: config.clientId,
+    refresh_token: refreshToken
+  });
+  const response = await fetch(config.tokenEndpoint, {
+    method: "POST",
     headers: {
-      Authorization: `token ${githubToken}`,
-      Accept: "application/json",
-      "User-Agent": "Corbat-Coco/1.0"
-    }
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: body.toString()
   });
   if (!response.ok) {
     const error = await response.text();
-    if (response.status === 401) {
-      throw new CopilotAuthError(
-        "GitHub token is invalid or expired. Please re-authenticate with /provider copilot.",
-        true
-      );
-    }
-    if (response.status === 403) {
-      throw new CopilotAuthError(
-        "GitHub Copilot is not enabled for this account.\n   Please ensure you have an active Copilot subscription:\n   https://github.com/settings/copilot",
-        true
-      );
-    }
-    throw new Error(`Copilot token exchange failed: ${response.status} - ${error}`);
-  }
-  return await response.json();
-}
-function getCopilotBaseUrl(accountType) {
-  if (accountType && accountType in COPILOT_BASE_URLS) {
-    return COPILOT_BASE_URLS[accountType];
+    throw new Error(`Token refresh failed: ${error}`);
   }
-  return DEFAULT_COPILOT_BASE_URL;
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0,
+    tokenType: data.token_type
+  };
 }
-function getCopilotCredentialsPath() {
+function getTokenStoragePath(provider) {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path17.join(home, ".coco", "tokens", "copilot.json");
+  return path17.join(home, ".coco", "tokens", `${provider}.json`);
 }
-async function saveCopilotCredentials(creds) {
-  const filePath = getCopilotCredentialsPath();
+async function saveTokens(provider, tokens) {
+  const filePath = getTokenStoragePath(provider);
   const dir = path17.dirname(filePath);
   await fs16.mkdir(dir, { recursive: true, mode: 448 });
-  await fs16.writeFile(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
+  await fs16.writeFile(filePath, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
-var CopilotCredentialsSchema = z.object({
-  githubToken: z.string().min(1),
-  copilotToken: z.string().optional(),
-  copilotTokenExpiresAt: z.number().optional(),
-  accountType: z.string().optional()
-});
-async function loadCopilotCredentials() {
+async function loadTokens(provider) {
+  const filePath = getTokenStoragePath(provider);
   try {
-    const content = await fs16.readFile(getCopilotCredentialsPath(), "utf-8");
-    const parsed = CopilotCredentialsSchema.safeParse(JSON.parse(content));
-    return parsed.success ? parsed.data : null;
+    const content = await fs16.readFile(filePath, "utf-8");
+    return JSON.parse(content);
   } catch {
     return null;
   }
 }
-async function deleteCopilotCredentials() {
-  try {
-    await fs16.unlink(getCopilotCredentialsPath());
-  } catch {
-  }
-}
-function isCopilotTokenExpired(creds) {
-  if (!creds.copilotToken || !creds.copilotTokenExpiresAt) return true;
-  return Date.now() >= creds.copilotTokenExpiresAt - REFRESH_BUFFER_MS;
-}
-async function getValidCopilotToken() {
-  const creds = await loadCopilotCredentials();
-  if (!creds) return null;
-  const envToken = process.env["GITHUB_TOKEN"] || process.env["GH_TOKEN"];
-  const githubToken = envToken || creds.githubToken;
-  if (!isCopilotTokenExpired(creds) && creds.copilotToken) {
-    return {
-      token: creds.copilotToken,
-      baseUrl: getCopilotBaseUrl(creds.accountType),
-      isNew: false
-    };
-  }
-  try {
-    const copilotToken = await exchangeForCopilotToken(githubToken);
-    const updatedCreds = {
-      ...creds,
-      githubToken: creds.githubToken,
-      copilotToken: copilotToken.token,
-      copilotTokenExpiresAt: copilotToken.expires_at * 1e3,
-      accountType: copilotToken.annotations?.copilot_plan ?? creds.accountType
-    };
-    await saveCopilotCredentials(updatedCreds);
-    return {
-      token: copilotToken.token,
-      baseUrl: getCopilotBaseUrl(updatedCreds.accountType),
-      isNew: true
-    };
-  } catch (error) {
-    if (error instanceof CopilotAuthError && error.permanent) {
-      await deleteCopilotCredentials();
-      return null;
-    }
-    throw error;
-  }
-}
-
-// src/auth/flow.ts
-promisify(execFile);
-var execAsync2 = promisify(exec);
-async function getADCAccessToken() {
-  try {
-    const { stdout } = await execAsync2("gcloud auth application-default print-access-token", {
-      timeout: 1e4
-    });
-    const accessToken = stdout.trim();
-    if (!accessToken) return null;
-    const expiresAt = Date.now() + 55 * 60 * 1e3;
-    return {
-      accessToken,
-      expiresAt
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("not logged in") || message.includes("no application default credentials")) {
-      return null;
-    }
-    return null;
-  }
-}
-var cachedToken = null;
-async function getCachedADCToken() {
-  if (cachedToken && cachedToken.expiresAt && Date.now() < cachedToken.expiresAt) {
-    return cachedToken;
-  }
-  cachedToken = await getADCAccessToken();
-  return cachedToken;
-}
-
-// src/providers/codex.ts
-var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
-var DEFAULT_MODEL3 = "gpt-5.3-codex";
-var CONTEXT_WINDOWS3 = {
-  "gpt-5.3-codex": 2e5,
-  "gpt-5.2-codex": 2e5,
-  "gpt-5-codex": 2e5,
-  "gpt-5.1-codex": 2e5,
-  "gpt-5": 2e5,
-  "gpt-5.2": 2e5,
-  "gpt-5.1": 2e5
-};
-function parseJwtClaims(token) {
-  const parts = token.split(".");
-  if (parts.length !== 3 || !parts[1]) return void 0;
+async function deleteTokens(provider) {
+  const filePath = getTokenStoragePath(provider);
   try {
-    return JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    await fs16.unlink(filePath);
   } catch {
-    return void 0;
   }
 }
-function extractAccountId(accessToken) {
-  const claims = parseJwtClaims(accessToken);
-  if (!claims) return void 0;
-  const auth = claims["https://api.openai.com/auth"];
-  return claims["chatgpt_account_id"] || auth?.["chatgpt_account_id"] || claims["organizations"]?.[0]?.id;
-}
-var CodexProvider = class {
-  id = "codex";
-  name = "OpenAI Codex (ChatGPT Plus/Pro)";
-  config = {};
-  accessToken = null;
-  accountId;
-  /**
-   * Initialize the provider with OAuth tokens
-   */
-  async initialize(config) {
-    this.config = config;
-    const tokenResult = await getValidAccessToken("openai");
-    if (tokenResult) {
-      this.accessToken = tokenResult.accessToken;
-      this.accountId = extractAccountId(tokenResult.accessToken);
-    } else if (config.apiKey) {
-      this.accessToken = config.apiKey;
-      this.accountId = extractAccountId(config.apiKey);
-    }
-    if (!this.accessToken) {
-      throw new ProviderError(
-        "No OAuth token found. Please run authentication first with: coco --provider openai",
-        { provider: this.id }
-      );
-    }
-  }
-  /**
-   * Ensure provider is initialized
-   */
-  ensureInitialized() {
-    if (!this.accessToken) {
-      throw new ProviderError("Provider not initialized", {
-        provider: this.id
-      });
+function isTokenExpired(tokens) {
+  if (!tokens.expiresAt) return false;
+  return Date.now() >= tokens.expiresAt - 5 * 60 * 1e3;
+}
+async function getValidAccessToken(provider) {
+  const config = OAUTH_CONFIGS[provider];
+  if (!config) return null;
+  const tokens = await loadTokens(provider);
+  if (!tokens) return null;
+  if (isTokenExpired(tokens)) {
+    if (tokens.refreshToken) {
+      try {
+        const newTokens = await refreshAccessToken(provider, tokens.refreshToken);
+        await saveTokens(provider, newTokens);
+        return { accessToken: newTokens.accessToken, isNew: true };
+      } catch {
+        await deleteTokens(provider);
+        return null;
+      }
     }
+    await deleteTokens(provider);
+    return null;
   }
-  /**
-   * Get context window size for a model
-   */
-  getContextWindow(model) {
-    const m = model ?? this.config.model ?? DEFAULT_MODEL3;
-    return CONTEXT_WINDOWS3[m] ?? 128e3;
+  return { accessToken: tokens.accessToken, isNew: false };
+}
+function detectWSL() {
+  if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) return true;
+  try {
+    return /microsoft/i.test(readFileSync("/proc/version", "utf-8"));
+  } catch {
+    return false;
   }
-  /**
-   * Count tokens in text (approximate)
-   * Uses GPT-4 approximation: ~4 chars per token
-   */
-  countTokens(text) {
-    return Math.ceil(text.length / 4);
+}
+var isWSL = detectWSL();
+var COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
+var COPILOT_BASE_URLS = {
+  individual: "https://api.githubcopilot.com",
+  business: "https://api.business.githubcopilot.com",
+  enterprise: "https://api.enterprise.githubcopilot.com"
+};
+var DEFAULT_COPILOT_BASE_URL = "https://api.githubcopilot.com";
+var REFRESH_BUFFER_MS = 6e4;
+var CopilotAuthError = class extends Error {
+  constructor(message, permanent) {
+    super(message);
+    this.permanent = permanent;
+    this.name = "CopilotAuthError";
   }
-  /**
-   * Check if provider is available (has valid OAuth tokens)
-   */
-  async isAvailable() {
-    try {
-      const tokenResult = await getValidAccessToken("openai");
-      return tokenResult !== null;
-    } catch {
-      return false;
+};
+async function exchangeForCopilotToken(githubToken) {
+  const response = await fetch(COPILOT_TOKEN_URL, {
+    method: "GET",
+    headers: {
+      Authorization: `token ${githubToken}`,
+      Accept: "application/json",
+      "User-Agent": "Corbat-Coco/1.0"
     }
-  }
-  /**
-   * Make a request to the Codex API
-   */
-  async makeRequest(body) {
-    this.ensureInitialized();
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.accessToken}`
-    };
-    if (this.accountId) {
-      headers["ChatGPT-Account-Id"] = this.accountId;
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    if (response.status === 401) {
+      throw new CopilotAuthError(
+        "GitHub token is invalid or expired. Please re-authenticate with /provider copilot.",
+        true
+      );
     }
-    const response = await fetch(CODEX_API_ENDPOINT, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new ProviderError(`Codex API error: ${response.status} - ${errorText}`, {
-        provider: this.id,
-        statusCode: response.status
-      });
+    if (response.status === 403) {
+      throw new CopilotAuthError(
+        "GitHub Copilot is not enabled for this account.\n   Please ensure you have an active Copilot subscription:\n   https://github.com/settings/copilot",
+        true
+      );
     }
-    return response;
+    throw new Error(`Copilot token exchange failed: ${response.status} - ${error}`);
   }
-  /**
-   * Extract text content from a message
-   */
-  extractTextContent(msg) {
-    if (typeof msg.content === "string") {
-      return msg.content;
-    }
-    if (Array.isArray(msg.content)) {
-      return msg.content.map((part) => {
-        if (part.type === "text") return part.text;
-        if (part.type === "tool_result") return `Tool result: ${JSON.stringify(part.content)}`;
-        return "";
-      }).join("\n");
-    }
-    return "";
+  return await response.json();
+}
+function getCopilotBaseUrl(accountType) {
+  if (accountType && accountType in COPILOT_BASE_URLS) {
+    return COPILOT_BASE_URLS[accountType];
   }
-  /**
-   * Convert messages to Codex Responses API format
-   * Codex uses a different format than Chat Completions:
-   * {
-   *   "input": [
-   *     { "type": "message", "role": "developer|user", "content": [{ "type": "input_text", "text": "..." }] },
-   *     { "type": "message", "role": "assistant", "content": [{ "type": "output_text", "text": "..." }] }
-   *   ]
-   * }
-   *
-   * IMPORTANT: User/developer messages use "input_text", assistant messages use "output_text"
-   */
-  convertMessagesToResponsesFormat(messages) {
-    return messages.map((msg) => {
-      const text = this.extractTextContent(msg);
-      const role = msg.role === "system" ? "developer" : msg.role;
-      const contentType = msg.role === "assistant" ? "output_text" : "input_text";
-      return {
-        type: "message",
-        role,
-        content: [{ type: contentType, text }]
-      };
-    });
+  return DEFAULT_COPILOT_BASE_URL;
+}
+function getCopilotCredentialsPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path17.join(home, ".coco", "tokens", "copilot.json");
+}
+async function saveCopilotCredentials(creds) {
+  const filePath = getCopilotCredentialsPath();
+  const dir = path17.dirname(filePath);
+  await fs16.mkdir(dir, { recursive: true, mode: 448 });
+  await fs16.writeFile(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
+}
+var CopilotCredentialsSchema = z.object({
+  githubToken: z.string().min(1),
+  copilotToken: z.string().optional(),
+  copilotTokenExpiresAt: z.number().optional(),
+  accountType: z.string().optional()
+});
+async function loadCopilotCredentials() {
+  try {
+    const content = await fs16.readFile(getCopilotCredentialsPath(), "utf-8");
+    const parsed = CopilotCredentialsSchema.safeParse(JSON.parse(content));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
   }
-  /**
-   * Send a chat message using Codex Responses API format
-   */
-  async chat(messages, options) {
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
-    const systemMsg = messages.find((m) => m.role === "system");
-    const instructions = systemMsg ? this.extractTextContent(systemMsg) : "You are a helpful coding assistant.";
-    const inputMessages = messages.filter((m) => m.role !== "system").map((msg) => this.convertMessagesToResponsesFormat([msg])[0]);
-    const body = {
-      model,
-      instructions,
-      input: inputMessages,
-      tools: [],
-      store: false,
-      stream: true
-      // Codex API requires streaming
-    };
-    const response = await this.makeRequest(body);
-    if (!response.body) {
-      throw new ProviderError("No response body from Codex API", {
-        provider: this.id
-      });
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let content = "";
-    let responseId = `codex-${Date.now()}`;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let status = "completed";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6).trim();
-            if (!data || data === "[DONE]") continue;
-            try {
-              const parsed = JSON.parse(data);
-              if (parsed.id) {
-                responseId = parsed.id;
-              }
-              if (parsed.type === "response.output_text.delta" && parsed.delta) {
-                content += parsed.delta;
-              } else if (parsed.type === "response.completed" && parsed.response) {
-                if (parsed.response.usage) {
-                  inputTokens = parsed.response.usage.input_tokens ?? 0;
-                  outputTokens = parsed.response.usage.output_tokens ?? 0;
-                }
-                status = parsed.response.status ?? "completed";
-              } else if (parsed.type === "response.output_text.done" && parsed.text) {
-                content = parsed.text;
-              }
-            } catch {
-            }
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-    if (!content) {
-      throw new ProviderError("No response content from Codex API", {
-        provider: this.id
-      });
-    }
-    const stopReason = status === "completed" ? "end_turn" : status === "incomplete" ? "max_tokens" : "end_turn";
+}
+async function deleteCopilotCredentials() {
+  try {
+    await fs16.unlink(getCopilotCredentialsPath());
+  } catch {
+  }
+}
+function isCopilotTokenExpired(creds) {
+  if (!creds.copilotToken || !creds.copilotTokenExpiresAt) return true;
+  return Date.now() >= creds.copilotTokenExpiresAt - REFRESH_BUFFER_MS;
+}
+async function getValidCopilotToken() {
+  const creds = await loadCopilotCredentials();
+  if (!creds) return null;
+  const envToken = process.env["GITHUB_TOKEN"] || process.env["GH_TOKEN"];
+  const githubToken = envToken || creds.githubToken;
+  if (!isCopilotTokenExpired(creds) && creds.copilotToken) {
     return {
-      id: responseId,
-      content,
-      stopReason,
-      model,
-      usage: {
-        inputTokens,
-        outputTokens
-      }
+      token: creds.copilotToken,
+      baseUrl: getCopilotBaseUrl(creds.accountType),
+      isNew: false
     };
   }
-  /**
-   * Send a chat message with tool use
-   * Note: Codex Responses API tool support is complex; for now we delegate to chat()
-   * and return empty toolCalls. Full tool support can be added later.
-   */
-  async chatWithTools(messages, options) {
-    const response = await this.chat(messages, options);
+  try {
+    const copilotToken = await exchangeForCopilotToken(githubToken);
+    const updatedCreds = {
+      ...creds,
+      githubToken: creds.githubToken,
+      copilotToken: copilotToken.token,
+      copilotTokenExpiresAt: copilotToken.expires_at * 1e3,
+      accountType: copilotToken.annotations?.copilot_plan ?? creds.accountType
+    };
+    await saveCopilotCredentials(updatedCreds);
     return {
-      ...response,
-      toolCalls: []
-      // Tools not yet supported in Codex provider
+      token: copilotToken.token,
+      baseUrl: getCopilotBaseUrl(updatedCreds.accountType),
+      isNew: true
     };
+  } catch (error) {
+    if (error instanceof CopilotAuthError && error.permanent) {
+      await deleteCopilotCredentials();
+      return null;
+    }
+    throw error;
   }
-  /**
-   * Stream a chat response
-   * Note: True streaming with Codex Responses API is complex.
-   * For now, we make a non-streaming call and simulate streaming by emitting chunks.
-   */
-  async *stream(messages, options) {
-    const response = await this.chat(messages, options);
-    if (response.content) {
-      const content = response.content;
-      const chunkSize = 20;
-      for (let i = 0; i < content.length; i += chunkSize) {
-        const chunk = content.slice(i, i + chunkSize);
-        yield { type: "text", text: chunk };
-        if (i + chunkSize < content.length) {
-          await new Promise((resolve3) => setTimeout(resolve3, 5));
-        }
-      }
+}
+
+// src/auth/flow.ts
+promisify(execFile);
+var execAsync2 = promisify(exec);
+async function getADCAccessToken() {
+  try {
+    const { stdout } = await execAsync2("gcloud auth application-default print-access-token", {
+      timeout: 1e4
+    });
+    const accessToken = stdout.trim();
+    if (!accessToken) return null;
+    const expiresAt = Date.now() + 55 * 60 * 1e3;
+    return {
+      accessToken,
+      expiresAt
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("not logged in") || message.includes("no application default credentials")) {
+      return null;
     }
-    yield { type: "done", stopReason: response.stopReason };
+    return null;
   }
-  /**
-   * Stream a chat response with tool use
-   * Note: Tools and true streaming with Codex Responses API are not yet implemented.
-   * For now, we delegate to stream() which uses non-streaming under the hood.
-   */
-  async *streamWithTools(messages, options) {
-    yield* this.stream(messages, options);
+}
+var cachedToken = null;
+async function getCachedADCToken() {
+  if (cachedToken && cachedToken.expiresAt && Date.now() < cachedToken.expiresAt) {
+    return cachedToken;
   }
-};
-var CONTEXT_WINDOWS4 = {
-  // Claude models
-  "claude-sonnet-4.6": 2e5,
-  "claude-opus-4.6": 2e5,
-  "claude-sonnet-4.5": 2e5,
-  "claude-opus-4.5": 2e5,
-  "claude-haiku-4.5": 2e5,
-  // OpenAI models — chat/completions
-  "gpt-4.1": 1048576,
-  // OpenAI models — /responses API (Codex/GPT-5+)
-  "gpt-5.3-codex": 4e5,
-  "gpt-5.2-codex": 4e5,
-  "gpt-5.1-codex-max": 4e5,
-  "gpt-5.2": 4e5,
-  "gpt-5.1": 4e5,
-  // Google models
-  "gemini-3.1-pro-preview": 1e6,
-  "gemini-3-flash-preview": 1e6,
-  "gemini-2.5-pro": 1048576
-};
-var DEFAULT_MODEL4 = "claude-sonnet-4.6";
-var COPILOT_HEADERS = {
-  "Copilot-Integration-Id": "vscode-chat",
-  "Editor-Version": "vscode/1.99.0",
-  "Editor-Plugin-Version": "copilot-chat/0.26.7",
-  "X-GitHub-Api-Version": "2025-04-01"
-};
-function needsResponsesApi(model) {
-  return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model.startsWith("o3-");
+  cachedToken = await getADCAccessToken();
+  return cachedToken;
 }
-var CopilotProvider = class extends OpenAIProvider {
-  baseUrl = "https://api.githubcopilot.com";
-  currentToken = null;
-  /** In-flight refresh promise to prevent concurrent token exchanges */
-  refreshPromise = null;
-  constructor() {
-    super("copilot", "GitHub Copilot");
+
+// src/providers/codex.ts
+var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+var DEFAULT_MODEL3 = "gpt-5.3-codex";
+var CONTEXT_WINDOWS3 = {
+  "gpt-5.3-codex": 2e5,
+  "gpt-5.2-codex": 2e5,
+  "gpt-5-codex": 2e5,
+  "gpt-5.1-codex": 2e5,
+  "gpt-5": 2e5,
+  "gpt-5.2": 2e5,
+  "gpt-5.1": 2e5
+};
+function parseJwtClaims(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3 || !parts[1]) return void 0;
+  try {
+    return JSON.parse(Buffer.from(parts[1], "base64url").toString());
+  } catch {
+    return void 0;
   }
+}
+function extractAccountId(accessToken) {
+  const claims = parseJwtClaims(accessToken);
+  if (!claims) return void 0;
+  const auth = claims["https://api.openai.com/auth"];
+  return claims["chatgpt_account_id"] || auth?.["chatgpt_account_id"] || claims["organizations"]?.[0]?.id;
+}
+var CodexProvider = class {
+  id = "codex";
+  name = "OpenAI Codex (ChatGPT Plus/Pro)";
+  config = {};
+  accessToken = null;
+  accountId;
   /**
-   * Initialize the provider with Copilot credentials.
-   *
-   * Gets a valid Copilot API token (from cache or by refreshing),
-   * then creates an OpenAI client configured for the Copilot endpoint.
+   * Initialize the provider with OAuth tokens
    */
   async initialize(config) {
-    this.config = {
-      ...config,
-      model: config.model ?? DEFAULT_MODEL4
-    };
-    const tokenResult = await getValidCopilotToken();
+    this.config = config;
+    const tokenResult = await getValidAccessToken("openai");
     if (tokenResult) {
-      this.currentToken = tokenResult.token;
-      this.baseUrl = tokenResult.baseUrl;
+      this.accessToken = tokenResult.accessToken;
+      this.accountId = extractAccountId(tokenResult.accessToken);
     } else if (config.apiKey) {
-      this.currentToken = config.apiKey;
+      this.accessToken = config.apiKey;
+      this.accountId = extractAccountId(config.apiKey);
     }
-    if (!this.currentToken) {
+    if (!this.accessToken) {
       throw new ProviderError(
-        "No Copilot token found. Please authenticate with: coco --provider copilot",
+        "No OAuth token found. Please run authentication first with: coco --provider openai",
         { provider: this.id }
-      );
-    }
-    this.createCopilotClient();
-  }
-  /**
-   * Create the OpenAI client configured for Copilot API
-   */
-  createCopilotClient() {
-    this.client = new OpenAI({
-      apiKey: this.currentToken,
-      baseURL: this.config.baseUrl ?? this.baseUrl,
-      timeout: this.config.timeout ?? 12e4,
-      defaultHeaders: COPILOT_HEADERS
-    });
-  }
-  /**
-   * Refresh the Copilot token if expired.
-   *
-   * Uses a mutex so concurrent callers share a single in-flight token
-   * exchange. The slot is cleared inside the IIFE's finally block,
-   * which runs after all awaiting callers have resumed.
-   */
-  async refreshTokenIfNeeded() {
-    if (!this.refreshPromise) {
-      this.refreshPromise = (async () => {
-        try {
-          const tokenResult = await getValidCopilotToken();
-          if (tokenResult && tokenResult.isNew) {
-            this.currentToken = tokenResult.token;
-            this.baseUrl = tokenResult.baseUrl;
-            this.createCopilotClient();
-          }
-        } finally {
-          this.refreshPromise = null;
-        }
-      })();
-    }
-    await this.refreshPromise;
-  }
-  // --- Override public methods to add token refresh + Responses API routing ---
-  async chat(messages, options) {
-    await this.refreshTokenIfNeeded();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-    if (needsResponsesApi(model)) {
-      return this.chatViaResponses(messages, options);
-    }
-    return super.chat(messages, options);
-  }
-  async chatWithTools(messages, options) {
-    await this.refreshTokenIfNeeded();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-    if (needsResponsesApi(model)) {
-      return this.chatWithToolsViaResponses(messages, options);
-    }
-    return super.chatWithTools(messages, options);
-  }
-  // Note: Token is refreshed before the stream starts but NOT mid-stream.
-  // Copilot tokens last ~25 min. Very long streams may get a 401 mid-stream
-  // which surfaces as a ProviderError. The retry layer handles re-attempts.
-  async *stream(messages, options) {
-    await this.refreshTokenIfNeeded();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-    if (needsResponsesApi(model)) {
-      yield* this.streamViaResponses(messages, options);
-      return;
+      );
     }
-    yield* super.stream(messages, options);
   }
-  async *streamWithTools(messages, options) {
-    await this.refreshTokenIfNeeded();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-    if (needsResponsesApi(model)) {
-      yield* this.streamWithToolsViaResponses(messages, options);
-      return;
+  /**
+   * Ensure provider is initialized
+   */
+  ensureInitialized() {
+    if (!this.accessToken) {
+      throw new ProviderError("Provider not initialized", {
+        provider: this.id
+      });
     }
-    yield* super.streamWithTools(messages, options);
   }
-  // --- Responses API implementations ---
   /**
-   * Simple chat via Responses API (no tools)
+   * Get context window size for a model
    */
-  async chatViaResponses(messages, options) {
-    this.ensureInitialized();
-    return withRetry(async () => {
-      try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-        const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-        const response = await this.client.responses.create({
-          model,
-          input,
-          instructions: instructions ?? void 0,
-          max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-          temperature: options?.temperature ?? this.config.temperature ?? 0,
-          store: false
-        });
-        return {
-          id: response.id,
-          content: response.output_text ?? "",
-          stopReason: response.status === "completed" ? "end_turn" : "max_tokens",
-          usage: {
-            inputTokens: response.usage?.input_tokens ?? 0,
-            outputTokens: response.usage?.output_tokens ?? 0
-          },
-          model: String(response.model)
-        };
-      } catch (error) {
-        throw this.handleError(error);
-      }
-    }, DEFAULT_RETRY_CONFIG);
+  getContextWindow(model) {
+    const m = model ?? this.config.model ?? DEFAULT_MODEL3;
+    return CONTEXT_WINDOWS3[m] ?? 128e3;
   }
   /**
-   * Chat with tools via Responses API
+   * Count tokens in text (approximate)
+   * Uses GPT-4 approximation: ~4 chars per token
    */
-  async chatWithToolsViaResponses(messages, options) {
-    this.ensureInitialized();
-    return withRetry(async () => {
-      try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-        const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-        const tools = this.convertToolsForResponses(options.tools);
-        const response = await this.client.responses.create({
-          model,
-          input,
-          instructions: instructions ?? void 0,
-          tools,
-          max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-          temperature: options?.temperature ?? this.config.temperature ?? 0,
-          store: false
-        });
-        let content = "";
-        const toolCalls = [];
-        for (const item of response.output) {
-          if (item.type === "message") {
-            for (const part of item.content) {
-              if (part.type === "output_text") {
-                content += part.text;
-              }
-            }
-          } else if (item.type === "function_call") {
-            toolCalls.push({
-              id: item.call_id,
-              name: item.name,
-              input: this.parseToolArguments(item.arguments)
-            });
-          }
-        }
-        return {
-          id: response.id,
-          content,
-          stopReason: response.status === "completed" ? "end_turn" : "tool_use",
-          usage: {
-            inputTokens: response.usage?.input_tokens ?? 0,
-            outputTokens: response.usage?.output_tokens ?? 0
-          },
-          model: String(response.model),
-          toolCalls
-        };
-      } catch (error) {
-        throw this.handleError(error);
-      }
-    }, DEFAULT_RETRY_CONFIG);
+  countTokens(text) {
+    return Math.ceil(text.length / 4);
   }
   /**
-   * Stream via Responses API (no tools)
+   * Check if provider is available (has valid OAuth tokens)
    */
-  async *streamViaResponses(messages, options) {
-    this.ensureInitialized();
+  async isAvailable() {
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const stream = await this.client.responses.create({
-        model,
-        input,
-        instructions: instructions ?? void 0,
-        max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-        temperature: options?.temperature ?? this.config.temperature ?? 0,
-        store: false,
-        stream: true
-      });
-      for await (const event of stream) {
-        if (event.type === "response.output_text.delta") {
-          yield { type: "text", text: event.delta };
-        } else if (event.type === "response.completed") {
-          yield { type: "done", stopReason: "end_turn" };
-        }
-      }
-    } catch (error) {
-      throw this.handleError(error);
+      const tokenResult = await getValidAccessToken("openai");
+      return tokenResult !== null;
+    } catch {
+      return false;
     }
   }
   /**
-   * Stream with tools via Responses API
+   * Make a request to the Codex API
    */
-  async *streamWithToolsViaResponses(messages, options) {
+  async makeRequest(body) {
     this.ensureInitialized();
-    try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
-      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const tools = this.convertToolsForResponses(options.tools);
-      const stream = await this.client.responses.create({
-        model,
-        input,
-        instructions: instructions ?? void 0,
-        tools,
-        max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-        temperature: options?.temperature ?? this.config.temperature ?? 0,
-        store: false,
-        stream: true
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.accessToken}`
+    };
+    if (this.accountId) {
+      headers["ChatGPT-Account-Id"] = this.accountId;
+    }
+    const response = await fetch(CODEX_API_ENDPOINT, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ProviderError(`Codex API error: ${response.status} - ${errorText}`, {
+        provider: this.id,
+        statusCode: response.status
       });
-      const fnCallBuilders = /* @__PURE__ */ new Map();
-      for await (const event of stream) {
-        switch (event.type) {
-          case "response.output_text.delta":
-            yield { type: "text", text: event.delta };
-            break;
-          case "response.output_item.added":
-            if (event.item.type === "function_call") {
-              const fc = event.item;
-              fnCallBuilders.set(fc.call_id, {
-                callId: fc.call_id,
-                name: fc.name,
-                arguments: ""
-              });
-              yield {
-                type: "tool_use_start",
-                toolCall: { id: fc.call_id, name: fc.name }
-              };
-            }
-            break;
-          case "response.function_call_arguments.delta":
-            {
-              const builder = fnCallBuilders.get(event.item_id);
-              if (builder) {
-                builder.arguments += event.delta;
-              }
-            }
-            break;
-          case "response.function_call_arguments.done":
-            {
-              const builder = fnCallBuilders.get(event.item_id);
-              if (builder) {
-                yield {
-                  type: "tool_use_end",
-                  toolCall: {
-                    id: builder.callId,
-                    name: builder.name,
-                    input: this.parseToolArguments(event.arguments)
-                  }
-                };
-                fnCallBuilders.delete(event.item_id);
+    }
+    return response;
+  }
+  /**
+   * Extract text content from a message
+   */
+  extractTextContent(msg) {
+    if (typeof msg.content === "string") {
+      return msg.content;
+    }
+    if (Array.isArray(msg.content)) {
+      return msg.content.map((part) => {
+        if (part.type === "text") return part.text;
+        if (part.type === "tool_result") return `Tool result: ${JSON.stringify(part.content)}`;
+        return "";
+      }).join("\n");
+    }
+    return "";
+  }
+  /**
+   * Convert messages to Codex Responses API format
+   * Codex uses a different format than Chat Completions:
+   * {
+   *   "input": [
+   *     { "type": "message", "role": "developer|user", "content": [{ "type": "input_text", "text": "..." }] },
+   *     { "type": "message", "role": "assistant", "content": [{ "type": "output_text", "text": "..." }] }
+   *   ]
+   * }
+   *
+   * IMPORTANT: User/developer messages use "input_text", assistant messages use "output_text"
+   */
+  convertMessagesToResponsesFormat(messages) {
+    return messages.map((msg) => {
+      const text = this.extractTextContent(msg);
+      const role = msg.role === "system" ? "developer" : msg.role;
+      const contentType = msg.role === "assistant" ? "output_text" : "input_text";
+      return {
+        type: "message",
+        role,
+        content: [{ type: contentType, text }]
+      };
+    });
+  }
+  /**
+   * Send a chat message using Codex Responses API format
+   */
+  async chat(messages, options) {
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+    const systemMsg = messages.find((m) => m.role === "system");
+    const instructions = systemMsg ? this.extractTextContent(systemMsg) : "You are a helpful coding assistant.";
+    const inputMessages = messages.filter((m) => m.role !== "system").map((msg) => this.convertMessagesToResponsesFormat([msg])[0]);
+    const body = {
+      model,
+      instructions,
+      input: inputMessages,
+      tools: [],
+      store: false,
+      stream: true
+      // Codex API requires streaming
+    };
+    const response = await this.makeRequest(body);
+    if (!response.body) {
+      throw new ProviderError("No response body from Codex API", {
+        provider: this.id
+      });
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let content = "";
+    let responseId = `codex-${Date.now()}`;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let status = "completed";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6).trim();
+            if (!data || data === "[DONE]") continue;
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.id) {
+                responseId = parsed.id;
               }
-            }
-            break;
-          case "response.completed":
-            {
-              for (const [, builder] of fnCallBuilders) {
-                yield {
-                  type: "tool_use_end",
-                  toolCall: {
-                    id: builder.callId,
-                    name: builder.name,
-                    input: this.parseToolArguments(builder.arguments)
-                  }
-                };
+              if (parsed.type === "response.output_text.delta" && parsed.delta) {
+                content += parsed.delta;
+              } else if (parsed.type === "response.completed" && parsed.response) {
+                if (parsed.response.usage) {
+                  inputTokens = parsed.response.usage.input_tokens ?? 0;
+                  outputTokens = parsed.response.usage.output_tokens ?? 0;
+                }
+                status = parsed.response.status ?? "completed";
+              } else if (parsed.type === "response.output_text.done" && parsed.text) {
+                content = parsed.text;
               }
-              fnCallBuilders.clear();
-              const hasToolCalls = event.response.output.some((i) => i.type === "function_call");
-              yield {
-                type: "done",
-                stopReason: hasToolCalls ? "tool_use" : "end_turn"
-              };
+            } catch {
             }
-            break;
+          }
         }
       }
-    } catch (error) {
-      throw this.handleError(error);
+    } finally {
+      reader.releaseLock();
+    }
+    if (!content) {
+      throw new ProviderError("No response content from Codex API", {
+        provider: this.id
+      });
     }
+    const stopReason = status === "completed" ? "end_turn" : status === "incomplete" ? "max_tokens" : "end_turn";
+    return {
+      id: responseId,
+      content,
+      stopReason,
+      model,
+      usage: {
+        inputTokens,
+        outputTokens
+      }
+    };
   }
-  // --- Responses API helpers ---
   /**
-   * Convert our internal messages to Responses API input format.
-   *
-   * The Responses API uses a flat array of input items (EasyInputMessage,
-   * function_call, function_call_output) instead of the chat completions
-   * messages array.
+   * Send a chat message with tool use
+   * Note: Codex Responses API tool support is complex; for now we delegate to chat()
+   * and return empty toolCalls. Full tool support can be added later.
    */
-  convertToResponsesInput(messages, systemPrompt) {
-    const input = [];
-    let instructions = null;
-    if (systemPrompt) {
-      instructions = systemPrompt;
-    }
-    for (const msg of messages) {
-      if (msg.role === "system") {
-        instructions = (instructions ? instructions + "\n\n" : "") + this.contentToStr(msg.content);
-      } else if (msg.role === "user") {
-        if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "tool_result")) {
-          for (const block of msg.content) {
-            if (block.type === "tool_result") {
-              const tr = block;
-              input.push({
-                type: "function_call_output",
-                call_id: tr.tool_use_id,
-                output: tr.content
-              });
-            }
-          }
-        } else {
-          input.push({
-            role: "user",
-            content: this.contentToStr(msg.content)
-          });
-        }
-      } else if (msg.role === "assistant") {
-        if (typeof msg.content === "string") {
-          input.push({
-            role: "assistant",
-            content: msg.content
-          });
-        } else if (Array.isArray(msg.content)) {
-          const textParts = [];
-          for (const block of msg.content) {
-            if (block.type === "text") {
-              textParts.push(block.text);
-            } else if (block.type === "tool_use") {
-              if (textParts.length > 0) {
-                input.push({
-                  role: "assistant",
-                  content: textParts.join("")
-                });
-                textParts.length = 0;
-              }
-              input.push({
-                type: "function_call",
-                call_id: block.id,
-                name: block.name,
-                arguments: JSON.stringify(block.input)
-              });
-            }
-          }
-          if (textParts.length > 0) {
-            input.push({
-              role: "assistant",
-              content: textParts.join("")
-            });
-          }
+  async chatWithTools(messages, options) {
+    const response = await this.chat(messages, options);
+    return {
+      ...response,
+      toolCalls: []
+      // Tools not yet supported in Codex provider
+    };
+  }
+  /**
+   * Stream a chat response
+   * Note: True streaming with Codex Responses API is complex.
+   * For now, we make a non-streaming call and simulate streaming by emitting chunks.
+   */
+  async *stream(messages, options) {
+    const response = await this.chat(messages, options);
+    if (response.content) {
+      const content = response.content;
+      const chunkSize = 20;
+      for (let i = 0; i < content.length; i += chunkSize) {
+        const chunk = content.slice(i, i + chunkSize);
+        yield { type: "text", text: chunk };
+        if (i + chunkSize < content.length) {
+          await new Promise((resolve3) => setTimeout(resolve3, 5));
         }
       }
     }
-    return { input, instructions };
+    yield { type: "done", stopReason: response.stopReason };
   }
   /**
-   * Convert our tool definitions to Responses API FunctionTool format
+   * Stream a chat response with tool use
+   * Note: Tools and true streaming with Codex Responses API are not yet implemented.
+   * For now, we delegate to stream() which uses non-streaming under the hood.
    */
-  convertToolsForResponses(tools) {
-    return tools.map((tool) => ({
-      type: "function",
-      name: tool.name,
-      description: tool.description ?? void 0,
-      parameters: tool.input_schema ?? null,
-      strict: false
-    }));
+  async *streamWithTools(messages, options) {
+    yield* this.stream(messages, options);
+  }
+};
+var CONTEXT_WINDOWS4 = {
+  // Claude models
+  "claude-sonnet-4.6": 2e5,
+  "claude-opus-4.6": 2e5,
+  "claude-sonnet-4.5": 2e5,
+  "claude-opus-4.5": 2e5,
+  "claude-haiku-4.5": 2e5,
+  // OpenAI models — chat/completions
+  "gpt-4.1": 1048576,
+  // OpenAI models — /responses API (Codex/GPT-5+)
+  "gpt-5.3-codex": 4e5,
+  "gpt-5.2-codex": 4e5,
+  "gpt-5.1-codex-max": 4e5,
+  "gpt-5.2": 4e5,
+  "gpt-5.1": 4e5,
+  // Google models
+  "gemini-3.1-pro-preview": 1e6,
+  "gemini-3-flash-preview": 1e6,
+  "gemini-2.5-pro": 1048576
+};
+var DEFAULT_MODEL4 = "claude-sonnet-4.6";
+var COPILOT_HEADERS = {
+  "Copilot-Integration-Id": "vscode-chat",
+  "Editor-Version": "vscode/1.99.0",
+  "Editor-Plugin-Version": "copilot-chat/0.26.7",
+  "X-GitHub-Api-Version": "2025-04-01"
+};
+var CopilotProvider = class extends OpenAIProvider {
+  baseUrl = "https://api.githubcopilot.com";
+  currentToken = null;
+  /** In-flight refresh promise to prevent concurrent token exchanges */
+  refreshPromise = null;
+  constructor() {
+    super("copilot", "GitHub Copilot");
   }
   /**
-   * Parse tool call arguments with jsonrepair fallback
+   * Initialize the provider with Copilot credentials.
+   *
+   * Gets a valid Copilot API token (from cache or by refreshing),
+   * then creates an OpenAI client configured for the Copilot endpoint.
    */
-  parseToolArguments(args) {
-    try {
-      return args ? JSON.parse(args) : {};
-    } catch {
-      try {
-        if (args) {
-          const repaired = jsonrepair(args);
-          return JSON.parse(repaired);
-        }
-      } catch {
-        console.error(`[${this.name}] Cannot parse tool arguments: ${args.slice(0, 200)}`);
-      }
-      return {};
+  async initialize(config) {
+    this.config = {
+      ...config,
+      model: config.model ?? DEFAULT_MODEL4
+    };
+    const tokenResult = await getValidCopilotToken();
+    if (tokenResult) {
+      this.currentToken = tokenResult.token;
+      this.baseUrl = tokenResult.baseUrl;
+    } else if (config.apiKey) {
+      this.currentToken = config.apiKey;
+    }
+    if (!this.currentToken) {
+      throw new ProviderError(
+        "No Copilot token found. Please authenticate with: coco --provider copilot",
+        { provider: this.id }
+      );
     }
+    this.createCopilotClient();
   }
   /**
-   * Convert message content to string
+   * Create the OpenAI client configured for Copilot API
+   */
+  createCopilotClient() {
+    this.client = new OpenAI({
+      apiKey: this.currentToken,
+      baseURL: this.config.baseUrl ?? this.baseUrl,
+      timeout: this.config.timeout ?? 12e4,
+      defaultHeaders: COPILOT_HEADERS
+    });
+  }
+  /**
+   * Refresh the Copilot token if expired.
+   *
+   * Uses a mutex so concurrent callers share a single in-flight token
+   * exchange. The slot is cleared inside the IIFE's finally block,
+   * which runs after all awaiting callers have resumed.
    */
-  contentToStr(content) {
-    if (typeof content === "string") return content;
-    return content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  async refreshTokenIfNeeded() {
+    if (!this.refreshPromise) {
+      this.refreshPromise = (async () => {
+        try {
+          const tokenResult = await getValidCopilotToken();
+          if (tokenResult && tokenResult.isNew) {
+            this.currentToken = tokenResult.token;
+            this.baseUrl = tokenResult.baseUrl;
+            this.createCopilotClient();
+          }
+        } finally {
+          this.refreshPromise = null;
+        }
+      })();
+    }
+    await this.refreshPromise;
+  }
+  // --- Override public methods to add token refresh ---
+  async chat(messages, options) {
+    await this.refreshTokenIfNeeded();
+    return super.chat(messages, options);
+  }
+  async chatWithTools(messages, options) {
+    await this.refreshTokenIfNeeded();
+    return super.chatWithTools(messages, options);
+  }
+  async *stream(messages, options) {
+    await this.refreshTokenIfNeeded();
+    yield* super.stream(messages, options);
+  }
+  async *streamWithTools(messages, options) {
+    await this.refreshTokenIfNeeded();
+    yield* super.streamWithTools(messages, options);
   }
   // --- Override metadata methods ---
   /**