@kenkaiiii/gg-ai 5.94.0 → 5.95.0

package/dist/index.js

@@ -243,6 +243,18 @@ function formatError(err) {
     }
     const miniMax = err.provider === "minimax" ? formatMiniMaxError(err, cleanMessage) : void 0;
     if (miniMax) return miniMax;
+    if (isUsageLimitError(err) && err.provider === "openai" && /chatgpt/i.test(err.message)) {
+      return {
+        headline: "ChatGPT plan usage limit reached.",
+        source: "provider",
+        message: "GG Coder has used what your ChatGPT plan allows for now. That can be your plan's limit or one you set for GG Coder.",
+        provider: err.provider,
+        statusCode: err.statusCode,
+        ...err.requestId ? { requestId: err.requestId } : {},
+        ...err.resetsAt ? { resetsAt: err.resetsAt } : {},
+        guidance: err.hint ?? "Check or raise it at chatgpt.com/settings/usage, or add an OpenAI API key to keep going."
+      };
+    }
     if (isUsageLimitError(err)) {
       const resetClause = err.resetsAt ? ` It resets at ${formatResetTime(err.resetsAt)}.` : "";
       return {
@@ -1143,7 +1155,7 @@ function toolCallNameRuleFor(provider, options) {
       return TOOL_CALL_NAME_RULES.anthropic;
     case "openai":
       if (options?.accountId) return TOOL_CALL_NAME_RULES["openai-responses"];
-      return isDefaultOrHost(options?.baseUrl, "api.openai.com") ? TOOL_CALL_NAME_RULES["openai-chat"] : TOOL_CALL_NAME_RULES.generic;
+      return isDefaultOrHost(options?.baseUrl, "api.openai.com") ? TOOL_CALL_NAME_RULES["openai-responses"] : TOOL_CALL_NAME_RULES.generic;
     case "gemini":
       return TOOL_CALL_NAME_RULES.gemini;
     default:
@@ -1341,8 +1353,8 @@ function usesDeferredToolLoading(options) {
     const firstParty = !options.baseUrl || options.baseUrl.includes("api.anthropic.com");
     return firstParty && supportsAnthropicDeferredTools(options.model);
   }
-  if (options.provider === "openai" && options.accountId) {
-    return supportsResponsesToolSearch(options.model);
+  if (options.provider === "openai" && !options.accountId) {
+    return isDefaultOrHost(options.baseUrl, "api.openai.com") && supportsResponsesToolSearch(options.model);
   }
   return false;
 }
@@ -1917,12 +1929,12 @@ function createProviderFetch(timeoutMs, { useEnvProxy = nodeUsesEnvProxy() } = {
   };
   const dispatcher = useEnvProxy ? new EnvHttpProxyAgent(timeouts) : new Agent(timeouts);
   const builtinFetch = globalThis.fetch;
-  const providerFetch2 = async (input, init2) => {
-    if (globalThis.fetch !== builtinFetch || input instanceof Request || init2?.body instanceof FormData) {
-      return globalThis.fetch(input, init2);
+  const providerFetch2 = async (input, init) => {
+    if (globalThis.fetch !== builtinFetch || input instanceof Request || init?.body instanceof FormData) {
+      return globalThis.fetch(input, init);
     }
     const response = await undiciFetch(input, {
-      ...init2,
+      ...init,
       dispatcher
     });
     return response;
@@ -1930,8 +1942,8 @@ function createProviderFetch(timeoutMs, { useEnvProxy = nodeUsesEnvProxy() } = {
   return Object.assign(providerFetch2, { Response: globalThis.Response });
 }
 function withBodyActivity(fetchImpl, onActivity) {
-  return async (input, init2) => {
-    const response = await fetchImpl(input, init2);
+  return async (input, init) => {
+    const response = await fetchImpl(input, init);
     if (!response.body || !response.headers.get("content-type")?.includes("text/event-stream")) {
       return response;
     }
@@ -3246,10 +3258,6 @@ function toError2(err, provider = "openai") {
   return new ProviderError(provider, String(err));
 }
 
-// src/providers/openai-codex.ts
-import os from "os";
-import * as zstd from "@bokuweb/zstd-wasm";
-
 // src/utils/sse.ts
 function parseSseBuffer(buffer) {
   const events = [];
@@ -3301,6 +3309,9 @@ function extractRequestIdFromMessage(message) {
   return match?.[1];
 }
 
+// src/user-agent.ts
+var GG_CODER_USER_AGENT = "ggcoder (+https://github.com/KenKaiii/gg-coder)";
+
 // src/providers/responses-stream.ts
 function isEncryptedReasoning(data) {
   return data.type === "reasoning" && typeof data.id === "string" && typeof data.encrypted_content === "string";
@@ -3348,9 +3359,11 @@ async function* consumeResponsesEvents(events, ctx) {
       });
     }
     if (type === "response.failed") {
-      const nested = event.error;
+      const nested = event.error ?? event.response?.error;
       const message = nested?.message ?? `${ctx.label} response failed.`;
       const requestId = extractRequestIdFromMessage(message) ?? event.request_id;
+      const usageLimit = nested ? ctx.errorChunk?.(nested, requestId) : null;
+      if (usageLimit) throw usageLimit;
       throw new ProviderError(ctx.provider, message, {
         ...requestId != null ? { requestId } : {}
       });
@@ -3700,6 +3713,7 @@ function toResponsesInput(messages, options) {
             ...sendItemId ? { id: mapId(itemId ?? callId, idMap) } : {},
             call_id: mapId(callId, idMap),
             name: part.name,
+            ...options.toolNamespace ? { namespace: options.toolNamespace } : {},
             arguments: JSON.stringify(part.args)
           });
         }
@@ -3763,85 +3777,46 @@ function toResponsesInput(messages, options) {
   return { system, input };
 }
 
-// src/providers/openai-codex.ts
-var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
-var CODEX_CLIENT_VERSION = "0.166.0";
-var CODEX_REQUEST_COMPRESSION_MIN_BYTES = 16 * 1024;
-var zstdInitPromise;
-async function encodeCodexRequest(body) {
-  const json = JSON.stringify(body);
-  const raw = new TextEncoder().encode(json);
-  if (raw.byteLength < CODEX_REQUEST_COMPRESSION_MIN_BYTES) {
-    return {
-      body: json,
-      compressed: false,
-      rawBytes: raw.byteLength,
-      encodedBytes: raw.byteLength
-    };
-  }
-  try {
-    zstdInitPromise ??= zstd.init();
-    await zstdInitPromise;
-    const compressed = Uint8Array.from(zstd.compress(raw));
-    if (compressed.byteLength >= raw.byteLength) {
-      return {
-        body: json,
-        compressed: false,
-        rawBytes: raw.byteLength,
-        encodedBytes: raw.byteLength
-      };
-    }
-    return {
-      body: compressed,
-      compressed: true,
-      rawBytes: raw.byteLength,
-      encodedBytes: compressed.byteLength
-    };
-  } catch (error) {
-    providerDiag("codex_request_compression_failed", {
-      error: error instanceof Error ? error.message : String(error),
-      rawBytes: raw.byteLength
-    });
-    return {
-      body: json,
-      compressed: false,
-      rawBytes: raw.byteLength,
-      encodedBytes: raw.byteLength
-    };
-  }
-}
+// src/providers/openai-responses.ts
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+var CHATGPT_PLAN_TOOL_NAMESPACE = "gg";
+var CHATGPT_USAGE_URL = "https://chatgpt.com/settings/usage";
 function usesResponsesLite(model) {
   return model.startsWith("gpt-5.6-") || model.startsWith("gpt-6-") || model.startsWith("gpt-6.");
 }
-function toCodexToolChoice(choice, tools) {
+function isChatGPTPlanRoute(options) {
+  return Boolean(options.accountId);
+}
+function toResponsesToolChoice(choice, tools) {
   const resolved = choice ?? "auto";
   if (typeof resolved === "object") {
     throw new GGAIError(
-      `OpenAI Codex does not support selecting the named tool \`${resolved.name}\`; use auto, none, or required.`,
+      `OpenAI Responses does not support selecting the named tool \`${resolved.name}\`; use auto, none, or required.`,
       { source: "capability" }
     );
   }
   if (resolved === "required" && !tools?.length) {
-    throw new GGAIError("OpenAI Codex cannot require a tool call when no tools are configured.", {
+    throw new GGAIError("OpenAI cannot require a tool call when no tools are configured.", {
       source: "capability"
     });
   }
   return resolved;
 }
-function streamOpenAICodex(options) {
+function streamOpenAIResponses(options) {
   return new StreamResult(runStream3(options), options.signal);
 }
 async function* runStream3(options, retriedWithoutReasoning = false) {
+  const plan = isChatGPTPlanRoute(options);
   const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
-  const url = `${baseUrl}/codex/responses`;
+  const url = `${baseUrl}/responses`;
   const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
   const downgraded = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
-  const deferredPlan = supportsResponsesToolSearch(options.model) ? planDeferredTools(options.tools, options.deferredTools, downgraded) : void 0;
+  const deferredPlan = !plan && supportsResponsesToolSearch(options.model) ? planDeferredTools(options.tools, options.deferredTools, downgraded) : void 0;
   const strictTools = options.strictTools ?? true;
   const toolSearchLoads = deferredPlan ? new Map(
     [...deferredPlan.loaded].map((name) => {
       const tool = deferredPlan.byName.get(name);
-      const [wire] = tool ? toCodexTools([tool], strictTools) : [];
+      const [wire] = tool ? toResponsesTools([tool], strictTools) : [];
       return [name, { ...wire, defer_loading: true }];
     })
   ) : void 0;
@@ -3849,28 +3824,36 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
   const { system, input } = toResponsesInput(downgraded, {
     supportsImages: options.supportsImages,
     toolSearchLoads,
-    mapId: remapCodexId,
+    mapId: remapCallId,
+    ...plan ? { toolNamespace: CHATGPT_PLAN_TOOL_NAMESPACE } : {},
     // Stamped reasoning belongs to another transport (e.g. Grok's) and would
-    // be rejected here; Codex's own items are never stamped.
+    // be rejected here; OpenAI's own items are never stamped.
     keepReasoning: (part) => part.origin === void 0
   });
-  const responsesLite = usesResponsesLite(options.model);
-  const liteShape = options.responsesLite ?? responsesLite;
+  const gpt6 = usesResponsesLite(options.model);
   const body = {
     model: options.model,
     store: false,
     stream: true,
     instructions: system,
     input,
-    tool_choice: toCodexToolChoice(options.toolChoice, liveTools),
-    parallel_tool_calls: !liteShape,
+    tool_choice: toResponsesToolChoice(options.toolChoice, liveTools),
+    parallel_tool_calls: true,
     include: ["reasoning.encrypted_content"]
   };
   if (liveTools?.length) {
-    body.tools = toCodexTools(liveTools, strictTools);
+    const wire = toResponsesTools(liveTools, strictTools);
+    body.tools = plan ? [
+      {
+        type: "namespace",
+        name: CHATGPT_PLAN_TOOL_NAMESPACE,
+        description: "GG Coder's tools for working in the user's project.",
+        tools: wire
+      }
+    ] : wire;
   }
   body.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder");
-  if (options.temperature != null && !options.thinking) {
+  if (!plan && options.temperature != null && !options.thinking) {
     body.temperature = options.temperature;
   }
   if (options.speed === "fast") {
@@ -3878,57 +3861,38 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
   }
   body.reasoning = {
     // GPT-5.6/6 require at least low; older models still support thinking off.
-    // Apply the floor here for every caller, including one-off prompt rewrites.
-    // `ultra` is a client orchestration preset, not a Codex API effort.
-    effort: options.thinking ? toCodexReasoningEffort(options.thinking, options.model) : responsesLite ? "low" : "none",
-    summary: "auto",
-    ...liteShape ? { context: "all_turns" } : {}
+    // `ultra` is a client orchestration preset, not an API effort.
+    effort: options.thinking ? toCodexReasoningEffort(options.thinking, options.model) : gpt6 ? "low" : "none",
+    summary: "auto"
   };
-  if (responsesLite) {
+  if (gpt6) {
     body.text = { verbosity: "low" };
   }
   const headers = {
     "Content-Type": "application/json",
     Accept: "text/event-stream",
     Authorization: `Bearer ${options.apiKey}`,
-    "OpenAI-Beta": "responses=experimental",
-    originator: responsesLite ? "codex_cli_rs" : "ggcoder",
-    "User-Agent": responsesLite ? `codex_cli_rs/${CODEX_CLIENT_VERSION}` : `ggcoder (${os.platform()} ${os.release()}; ${os.arch()})`,
-    ...responsesLite ? { version: CODEX_CLIENT_VERSION } : {},
-    ...liteShape ? { "X-OpenAI-Internal-Codex-Responses-Lite": "true" } : {}
+    "User-Agent": GG_CODER_USER_AGENT
   };
-  if (options.accountId) {
-    headers["chatgpt-account-id"] = options.accountId;
-  }
-  if (options.transportSessionId) {
-    const transportSessionId = normalizePromptCacheKey(options.transportSessionId);
-    headers["session_id"] = transportSessionId;
-    headers["x-client-request-id"] = transportSessionId;
-  }
-  const encodedRequest = await encodeCodexRequest(
-    mergeProviderOptions(body, options.providerOptions)
-  );
-  if (encodedRequest.compressed) headers["Content-Encoding"] = "zstd";
-  providerDiag("codex_request_body", {
-    rawBytes: encodedRequest.rawBytes,
-    encodedBytes: encodedRequest.encodedBytes,
-    compressed: encodedRequest.compressed
-  });
+  const json = JSON.stringify(mergeProviderOptions(body, options.providerOptions));
+  providerDiag("openai_responses_request_body", { rawBytes: json.length, plan });
   const response = await providerFetch(url, {
     method: "POST",
     headers,
-    body: encodedRequest.body,
+    body: json,
     signal: options.signal
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
-    const parsed = parseCodexErrorBody(text, response.status);
-    const message = parsed.message ?? `Codex API returned HTTP ${response.status}.`;
+    const parsed = parseErrorBody(text, response.status);
+    const message = parsed.message ?? `OpenAI returned HTTP ${response.status}.`;
     const requestId = parsed.requestId ?? readHeader(response.headers, "x-request-id", "openai-request-id", "x-oai-request-id");
     if (!retriedWithoutReasoning && !options.signal?.aborted && response.status === 400 && (parsed.errorObj?.code === "invalid_encrypted_content" || /encrypted content.*could not be (?:verified|decrypted|parsed)/i.test(message)) && options.messages.some(
       (msg) => msg.role === "assistant" && Array.isArray(msg.content) && msg.content.some((part) => part.type === "raw" && isEncryptedReasoning(part.data))
     )) {
-      providerDiag("codex_retry_without_encrypted_reasoning", { status: response.status });
+      providerDiag("openai_responses_retry_without_encrypted_reasoning", {
+        status: response.status
+      });
       const messages = options.messages.map(
         (msg) => msg.role === "assistant" && Array.isArray(msg.content) ? {
           ...msg,
@@ -3939,13 +3903,19 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
       );
       return yield* runStream3({ ...options, messages }, true);
     }
-    const usageLimit = codexUsageLimitError(parsed.errorObj, response.status, requestId);
-    if (usageLimit) throw usageLimit;
+    if (plan) {
+      const planError = chatGPTPlanError(
+        parsed.errorObj,
+        response.status,
+        requestId,
+        message,
+        options.model
+      );
+      if (planError) throw planError;
+    }
     let hint;
-    if (response.status === 400 && message === `The '${options.model}' model is not supported when using Codex with a ChatGPT account.`) {
-      hint = "This model is not available through your ChatGPT account. Choose another available model using the model selector.";
-    } else if (response.status === 404 && text.includes("does not exist")) {
-      hint = "This model is not in OpenAI's current catalog for your ChatGPT account. Choose another available model using the model selector.";
+    if (response.status === 404 && text.includes("does not exist")) {
+      hint = plan ? "This model isn't available on your ChatGPT plan. Choose another model using the model selector." : "This model isn't available to your OpenAI API key. Choose another model using the model selector.";
     }
     throw new ProviderError("openai", message, {
       statusCode: response.status,
@@ -3954,14 +3924,14 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     });
   }
   if (!response.body) {
-    throw new ProviderError("openai", "No response body from Codex API");
+    throw new ProviderError("openai", "No response body from OpenAI");
   }
   return yield* consumeResponsesEvents(parseSSE(response.body), {
     provider: "openai",
-    label: "Codex",
-    diagPrefix: "codex",
+    label: "OpenAI",
+    diagPrefix: "openai_responses",
     thinking: !!options.thinking,
-    errorChunk: (errorObj, requestId) => codexUsageLimitError(errorObj, void 0, requestId)
+    errorChunk: (errorObj, requestId) => plan ? chatGPTPlanError(errorObj, void 0, requestId, void 0, options.model) : null
   });
 }
 async function* parseSSE(body) {
@@ -3974,7 +3944,7 @@ async function* parseSSE(body) {
     }
   }
 }
-function remapCodexId(id, idMap) {
+function remapCallId(id, idMap) {
   const existing = idMap.get(id);
   if (existing) return existing;
   const withPrefix = id.startsWith("fc_") || id.startsWith("fc-") ? id : `fc_${id.replace(/^toolu_/, "")}`;
@@ -3988,7 +3958,7 @@ function remapCodexId(id, idMap) {
   idMap.set(id, mapped);
   return mapped;
 }
-function toCodexTools(tools, strictTools) {
+function toResponsesTools(tools, strictTools) {
   return tools.map((tool) => {
     let parameters = resolveToolSchema(tool);
     let strict = null;
@@ -4009,7 +3979,7 @@ function toCodexTools(tools, strictTools) {
     };
   });
 }
-function parseCodexErrorBody(text, statusCode) {
+function parseErrorBody(text, statusCode) {
   if (!text) return {};
   try {
     const parsed = JSON.parse(text);
@@ -4033,23 +4003,70 @@ function parseCodexErrorBody(text, statusCode) {
     return bounded ? { message: bounded } : {};
   }
 }
-var CODEX_USAGE_LIMIT_CODE = /usage_limit_reached|usage_not_included/i;
-var CODEX_RATE_LIMIT_CODE = /rate_limit_exceeded/i;
-function codexUsageLimitError(errorObj, statusCode, requestId) {
+function chatGPTPlanError(errorObj, statusCode, requestId, message, model) {
   const code = String(errorObj?.code ?? errorObj?.type ?? "");
-  const rateLimits = errorObj?.rate_limits;
-  const resetsAtRaw = (typeof errorObj?.resets_at === "number" ? errorObj.resets_at : void 0) ?? rateLimits?.primary?.resets_at ?? rateLimits?.secondary?.resets_at;
-  const resetsInSeconds = typeof errorObj?.resets_in_seconds === "number" ? errorObj.resets_in_seconds : void 0;
-  const resetsAt = typeof resetsAtRaw === "number" && resetsAtRaw > 0 ? resetsAtRaw : resetsInSeconds != null && resetsInSeconds > 0 ? Math.floor(Date.now() / 1e3) + resetsInSeconds : void 0;
-  const isHardUsage = CODEX_USAGE_LIMIT_CODE.test(code);
-  const isRateOr429 = CODEX_RATE_LIMIT_CODE.test(code) || statusCode === 429;
-  if (!isHardUsage && !(isRateOr429 && resetsAt != null)) return null;
-  return new ProviderError("openai", "ChatGPT usage limit reached", {
-    cause: errorObj,
-    statusCode: statusCode ?? 429,
-    ...requestId ? { requestId } : {},
-    ...resetsAt ? { resetsAt } : {}
-  });
+  const base = { ...requestId ? { requestId } : {}, cause: errorObj };
+  switch (code) {
+    // The plan's usage — or the limit the user set for GG Coder — is spent, or
+    // can't be checked right now. Both stop plan requests; the canonical
+    // "usage limit reached" message lets the session fall back to an API key.
+    case "subscription_sharing_usage_limit_exceeded":
+    case "subscription_sharing_usage_unavailable":
+      return new ProviderError("openai", "ChatGPT usage limit reached", {
+        ...base,
+        statusCode: statusCode ?? (code.endsWith("unavailable") ? 503 : 429),
+        hint: code === "subscription_sharing_usage_unavailable" ? "OpenAI couldn't check your ChatGPT plan usage just now. Try again shortly, or add an OpenAI API key to keep going." : `Check or raise what GG Coder may use at ${CHATGPT_USAGE_URL}, or add an OpenAI API key to keep going.`
+      });
+    case "subscription_sharing_user_not_eligible":
+      return new ProviderError(
+        "openai",
+        "ChatGPT plan use isn't available for this account or workspace.",
+        {
+          ...base,
+          statusCode: statusCode ?? 403,
+          hint: "Add an OpenAI API key, or ask your workspace admin to allow ChatGPT plan use in other apps."
+        }
+      );
+    // The account's plan doesn't include this model (live: 400 model_not_found,
+    // "…not supported when using Codex with a ChatGPT account").
+    case "model_not_found":
+      return new ProviderError(
+        "openai",
+        `${model ?? "This model"} isn't included in your ChatGPT plan.`,
+        {
+          ...base,
+          statusCode: statusCode ?? 400,
+          hint: "Pick a model your plan includes (the model picker marks the others), or use an OpenAI API key for this one."
+        }
+      );
+    case "subscription_sharing_unsupported_capability": {
+      const param = typeof errorObj?.param === "string" ? errorObj.param : void 0;
+      if (param?.includes("service_tier")) {
+        return new ProviderError("openai", "Fast mode isn't included in your ChatGPT plan.", {
+          ...base,
+          statusCode: statusCode ?? 400,
+          hint: "Switch to the standard model, or use an OpenAI API key for Fast mode."
+        });
+      }
+      return new ProviderError(
+        "openai",
+        message ?? `The ChatGPT plan route doesn't support ${param ?? "part of this request"}.`,
+        {
+          ...base,
+          statusCode: statusCode ?? 400,
+          hint: `${param ? `\`${param}\` isn't` : "Part of this request isn't"} available on the ChatGPT plan. Choose another model, or add an OpenAI API key.`
+        }
+      );
+    }
+    case "subscription_sharing_invalid_user":
+      return new ProviderError("openai", message ?? "ChatGPT couldn't validate your sign-in.", {
+        ...base,
+        statusCode: statusCode ?? 401,
+        hint: "Continue with ChatGPT again to reconnect."
+      });
+    default:
+      return null;
+  }
 }
 
 // src/providers/xai-responses.ts
@@ -4183,92 +4200,17 @@ async function* synthesizeResponseEvents(response) {
 }
 
 // src/providers/gemini.ts
-var DEFAULT_CODE_ASSIST_BASE_URL = "https://cloudcode-pa.googleapis.com";
-var CODE_ASSIST_API_VERSION = "v1internal";
-var GEMINI_CLI_USER_AGENT = "google-gemini-cli";
-var GEMINI_CLI_API_CLIENT = "gemini-cli/0.0.0";
-var CODE_ASSIST_NON_STREAMING_RETRIES = 3;
-var CODE_ASSIST_NON_STREAMING_RETRY_DELAY_MS = 1e3;
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com/v1beta";
+var NON_STREAMING_RETRIES = 3;
+var NON_STREAMING_RETRY_DELAY_MS = 1e3;
 var SYNTHETIC_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
-var CODE_ASSIST_SUPPORTED_MODELS = /* @__PURE__ */ new Set([
-  "gemini-3-pro-preview",
-  "gemini-3.1-pro-preview",
-  "gemini-3.1-pro-preview-customtools",
-  "gemini-3-flash-preview",
-  "gemini-3.5-flash",
-  "gemini-3-flash",
-  "gemini-3.1-flash-lite",
-  "gemini-3.7-flash",
-  "gemini-3.8-flash",
-  "gemini-3.5-flash-lite",
-  "gemini-2.5-pro",
-  "gemini-2.5-flash",
-  "gemma-4-31b-it",
-  "gemma-4-26b-a4b-it"
-]);
-function isGeminiApiKeyRoute(options) {
-  return options.baseUrl?.includes("generativelanguage.googleapis.com") === true;
-}
-function getGoogleProject(options) {
-  const env = getEnvironment();
-  return options.projectId ?? env?.GOOGLE_CLOUD_PROJECT ?? env?.GOOGLE_CLOUD_PROJECT_ID;
-}
-function getCodeAssistEndpoint(method) {
-  const env = getEnvironment();
-  const endpoint = env?.CODE_ASSIST_ENDPOINT ?? DEFAULT_CODE_ASSIST_BASE_URL;
-  const version = env?.CODE_ASSIST_API_VERSION || CODE_ASSIST_API_VERSION;
-  return new URL(`${endpoint}/${version}:${method}`);
-}
-function formatUnsupportedModelMessage(model) {
-  return `Gemini OAuth is configured to use the Gemini Code Assist subscription endpoint only. That endpoint does not currently expose model "${model}".`;
-}
-var ACCOUNT_GATED_MODELS = /* @__PURE__ */ new Set([
-  "gemini-3-flash",
-  "gemini-3.5-flash",
-  "gemini-3.1-pro-preview",
-  "gemini-3.1-pro-preview-customtools",
-  "gemini-3.7-flash",
-  "gemini-3.8-flash",
-  "gemini-3.5-flash-lite"
-]);
-function accountGatedMessage(model) {
-  if (model === "gemini-3.8-flash" || model === "gemini-3.5-flash-lite") {
-    return `${model} is not available through Code Assist for this account. Public Gemini API availability does not guarantee Code Assist OAuth access.`;
-  }
-  return `Your Google account isn't entitled to "${model}" over Gemini Code Assist OAuth, so the API reports it as not found. This is an account-access limit, not a ggcoder bug.`;
-}
-function accountGatedHint(model) {
-  if (model === "gemini-3.8-flash" || model === "gemini-3.5-flash-lite") {
-    return "Use /model to select Gemini 3.1 Flash Lite, or retry once Google enables this model through Code Assist for your account.";
-  }
-  return `Newer Gemini models (3.5 Flash, 3.1 Pro Preview) are available only to Code Assist Standard/Enterprise accounts with preview/GA access enabled by a cloud admin. Try Gemini 3.1 Flash Lite with /model, or sign in with a Code Assist Standard/Enterprise account that has preview access.`;
-}
-function isCodeAssistLicenseRequired(status, body) {
-  if (status !== 403) return false;
-  try {
-    const parsed = JSON.parse(body);
-    const details = typeof parsed === "object" && parsed !== null && "error" in parsed ? parsed.error?.details : void 0;
-    return Array.isArray(details) && details.some(
-      (detail) => typeof detail === "object" && detail !== null && detail.reason === "SUBSCRIPTION_REQUIRED"
-    );
-  } catch {
-    return false;
-  }
-}
 function isInvalidGeminiApiKey(status, body) {
   if (status !== 400 && status !== 401 && status !== 403) return false;
   return /"reason"\s*:\s*"API_KEY_INVALID"/.test(body) || /API key not valid/i.test(body);
 }
 var INVALID_API_KEY_MESSAGE = "Google rejected the Gemini API key: it is not valid.";
 var INVALID_API_KEY_HINT = "Create a key at aistudio.google.com/apikey and add it again under Gemini in Providers (or `ggcoder login`).";
-var LICENSE_REQUIRED_MESSAGE = "This Google account has no Gemini Code Assist licence. Google stopped serving Gemini through Code Assist to personal accounts (Google AI Pro/Ultra and the free individual tier) on June 18, 2026, so every Gemini model is refused, not just this one.";
-var LICENSE_REQUIRED_HINT = "Sign in to Gemini with a Google account that has a Gemini Code Assist Standard or Enterprise licence, or pick a model from another provider with /model.";
-function formatErrorMessage(status, body, model) {
-  if (status === 404 && !CODE_ASSIST_SUPPORTED_MODELS.has(model)) {
-    return `Gemini API error (404): ${body}
-
-${formatUnsupportedModelMessage(model)}`;
-  }
+function formatErrorMessage(status, body) {
   return `Gemini API error (${status}): ${body}`;
 }
 function parseRetryDelaySeconds(body) {
@@ -4474,27 +4416,15 @@ function buildGenerateRequest(options) {
     ...systemInstruction ? { systemInstruction } : {},
     ...tools ? { tools } : {},
     ...toolConfig ? { toolConfig } : {},
-    ...Object.keys(generationConfig).length > 0 ? { generationConfig } : {},
-    ...options.promptCacheKey ? { session_id: options.promptCacheKey } : {}
-  };
-}
-function buildCodeAssistRequest(options, request, projectId) {
-  return {
-    model: options.model,
-    ...projectId ? { project: projectId } : {},
-    user_prompt_id: crypto.randomUUID(),
-    request
+    ...Object.keys(generationConfig).length > 0 ? { generationConfig } : {}
   };
 }
 var API_KEY_MODEL_IDS = {
   "gemini-3-flash": "gemini-3.5-flash"
 };
-function buildApiKeyRequestPlan(options, method) {
-  const { session_id: _sessionId, ...request } = mergeProviderOptions(
-    buildGenerateRequest(options),
-    options.providerOptions
-  );
-  const base = (options.baseUrl ?? "").replace(/\/+$/, "");
+function buildRequestPlan(options, method) {
+  const request = mergeProviderOptions(buildGenerateRequest(options), options.providerOptions);
+  const base = (options.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
   return {
     url: new URL(
       `${base}/models/${encodeURIComponent(API_KEY_MODEL_IDS[options.model] ?? options.model)}:${method}`
@@ -4503,27 +4433,7 @@ function buildApiKeyRequestPlan(options, method) {
       "Content-Type": "application/json",
       "x-goog-api-key": options.apiKey ?? ""
     },
-    body: request,
-    route: "api-key"
-  };
-}
-function buildRequestPlan(options, method) {
-  if (isGeminiApiKeyRoute(options)) return buildApiKeyRequestPlan(options, method);
-  if (!CODE_ASSIST_SUPPORTED_MODELS.has(options.model)) {
-    throw new ProviderError("gemini", formatUnsupportedModelMessage(options.model));
-  }
-  const projectId = getGoogleProject(options);
-  const request = mergeProviderOptions(buildGenerateRequest(options), options.providerOptions);
-  return {
-    url: getCodeAssistEndpoint(method),
-    headers: {
-      Authorization: `Bearer ${options.apiKey}`,
-      "Content-Type": "application/json",
-      "User-Agent": GEMINI_CLI_USER_AGENT,
-      "X-Goog-Api-Client": GEMINI_CLI_API_CLIENT
-    },
-    body: buildCodeAssistRequest(options, request, projectId),
-    route: "code-assist"
+    body: request
   };
 }
 function normalizeGeminiStopReason(reason) {
@@ -4550,10 +4460,10 @@ async function* streamSse(response) {
   }
 }
 function candidatesFromResponse(response) {
-  return response.response?.candidates ?? response.candidates;
+  return response.candidates;
 }
 function usageFromResponse(response) {
-  return response.response?.usageMetadata ?? response.usageMetadata;
+  return response.usageMetadata;
 }
 function partsFromResponse(response) {
   return candidatesFromResponse(response)?.[0]?.content?.parts ?? [];
@@ -4575,7 +4485,7 @@ function readFunctionCallPart(part) {
 function makeToolCallId(index, providerId) {
   return providerId ?? `gemini_call_${index}_${crypto.randomUUID().replace(/-/g, "")}`;
 }
-function shouldRetryCodeAssistStatus(status) {
+function shouldRetryStatus(status) {
   return status === 429 || status === 499 || status >= 500 && status <= 599;
 }
 function isAbortError(err) {
@@ -4598,7 +4508,7 @@ async function sleep(ms, signal) {
     if (signal?.aborted) onAbort();
   });
 }
-async function fetchCodeAssist(plan, options) {
+async function fetchGemini(plan, options) {
   try {
     const response = await providerFetch(plan.url, {
       method: "POST",
@@ -4609,11 +4519,8 @@ async function fetchCodeAssist(plan, options) {
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       const quota = parseGeminiQuota(response.status, text);
-      const codeAssist = plan.route === "code-assist";
-      const accountGated = codeAssist && response.status === 404 && ACCOUNT_GATED_MODELS.has(options.model);
-      const licenseRequired = codeAssist && isCodeAssistLicenseRequired(response.status, text);
-      const invalidKey = !codeAssist && isInvalidGeminiApiKey(response.status, text);
-      let message = invalidKey ? INVALID_API_KEY_MESSAGE : licenseRequired ? LICENSE_REQUIRED_MESSAGE : accountGated ? accountGatedMessage(options.model) : formatErrorMessage(response.status, text, options.model);
+      const invalidKey = isInvalidGeminiApiKey(response.status, text);
+      let message = invalidKey ? INVALID_API_KEY_MESSAGE : formatErrorMessage(response.status, text);
       let resetsAt;
       if (quota?.exhausted) {
         message = `Gemini quota exhausted \u2014 usage limit reached. ${message}`;
@@ -4623,7 +4530,7 @@ async function fetchCodeAssist(plan, options) {
       throw new ProviderError("gemini", message, {
         statusCode: response.status,
         ...resetsAt !== void 0 ? { resetsAt } : {},
-        ...invalidKey ? { hint: INVALID_API_KEY_HINT, source: "auth" } : licenseRequired ? { hint: LICENSE_REQUIRED_HINT, source: "auth" } : accountGated ? { hint: accountGatedHint(options.model) } : {}
+        ...invalidKey ? { hint: INVALID_API_KEY_HINT, source: "auth" } : {}
       });
     }
     return response;
@@ -4631,26 +4538,26 @@ async function fetchCodeAssist(plan, options) {
     throw toError3(err);
   }
 }
-async function fetchCodeAssistWithRetry(plan, options) {
+async function fetchGeminiWithRetry(plan, options) {
   let lastError;
-  for (let attempt = 0; attempt <= CODE_ASSIST_NON_STREAMING_RETRIES; attempt++) {
+  for (let attempt = 0; attempt <= NON_STREAMING_RETRIES; attempt++) {
     try {
-      return await fetchCodeAssist(plan, options);
+      return await fetchGemini(plan, options);
     } catch (err) {
       const error = toError3(err);
       const statusCode = error instanceof ProviderError ? error.statusCode : void 0;
-      if (options.signal?.aborted || isAbortError(error) || attempt === CODE_ASSIST_NON_STREAMING_RETRIES || statusCode != null && !shouldRetryCodeAssistStatus(statusCode)) {
+      if (options.signal?.aborted || isAbortError(error) || attempt === NON_STREAMING_RETRIES || statusCode != null && !shouldRetryStatus(statusCode)) {
         throw error;
       }
       lastError = error;
     }
     try {
-      await sleep(CODE_ASSIST_NON_STREAMING_RETRY_DELAY_MS, options.signal);
+      await sleep(NON_STREAMING_RETRY_DELAY_MS, options.signal);
     } catch (err) {
       throw toError3(err);
     }
   }
-  throw lastError ?? new ProviderError("gemini", "Gemini Code Assist request failed.");
+  throw lastError ?? new ProviderError("gemini", "Gemini request failed.");
 }
 function streamGemini(options) {
   return new StreamResult(runStream5(options), options.signal);
@@ -4660,7 +4567,7 @@ async function* runStream5(options) {
   const method = useStreaming ? "streamGenerateContent" : "generateContent";
   const plan = buildRequestPlan(options, method);
   if (useStreaming) plan.url.searchParams.set("alt", "sse");
-  const response = useStreaming ? await fetchCodeAssist(plan, options) : await fetchCodeAssistWithRetry(plan, options);
+  const response = useStreaming ? await fetchGemini(plan, options) : await fetchGeminiWithRetry(plan, options);
   const contentParts = [];
   const pendingToolCalls = [];
   let textAccum = "";
@@ -4971,7 +4878,7 @@ async function postJson(request) {
 }
 function httpError(provider, response, text, headerRequestId, clean) {
   const status = response.status;
-  const parsed = parseErrorBody(text);
+  const parsed = parseErrorBody2(text);
   const rawMessage = parsed.message ?? (parsed.isJson ? "" : text.trim());
   const message = !rawMessage ? emptyProviderErrorMessage(status) : isRawHtmlErrorEcho(rawMessage) ? providerHtmlErrorMessage(status) : clean(rawMessage);
   const requestId = headerRequestId ?? parsed.requestId;
@@ -4997,7 +4904,7 @@ function httpError(provider, response, text, headerRequestId, clean) {
   }
   return new ProviderError(provider, message, base);
 }
-function parseErrorBody(text) {
+function parseErrorBody2(text) {
   let parsed;
   try {
     parsed = JSON.parse(text);
@@ -5429,10 +5336,7 @@ var OPENAI_EMBED_BATCH_SIZE = 2048;
 var OPENROUTER_EMBED_BATCH_SIZE = 64;
 var LOCAL_EMBED_BATCH_SIZE = 64;
 var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
-var GLM_CODING_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
-var KIMI_CODE_USER_AGENT = `kimi-code-cli/${process.env.KIMI_CODE_VERSION ?? "1.0.11"}`;
-var GROK_CLI_PROXY_HOST = "cli-chat-proxy.grok.com";
-var GROK_CLI_VERSION = process.env.GROK_CLI_VERSION ?? "1.0.67";
+var GLM_BASE_URL = "https://api.z.ai/api/paas/v4";
 providerRegistry.register("anthropic", {
   stream: (options) => streamAnthropic(options)
 });
@@ -5445,12 +5349,12 @@ providerRegistry.register("xiaomi", {
 });
 providerRegistry.register("openai", {
   stream: (options) => {
-    if (options.accountId) {
-      return streamOpenAICodex(options);
+    if (options.accountId || isOpenAIHost(options.baseUrl)) {
+      return streamOpenAIResponses(options);
     }
     return streamOpenAI(options);
   },
-  // OpenAI API-key auth only; ChatGPT-subscription (Codex) tokens have no embeddings API.
+  // OpenAI API-key auth only; the ChatGPT plan route has no embeddings API.
   // OpenAI has no task/input-type parameter, so `inputType` is ignored.
   embed: (request) => embedOpenAICompatible(request, {
     provider: "openai",
@@ -5460,22 +5364,24 @@ providerRegistry.register("openai", {
 });
 providerRegistry.register("gemini", {
   stream: (options) => streamGemini(options),
-  // Native Gemini API with an AI Studio key — not the Code Assist OAuth endpoint above.
+  // Native Gemini API with an AI Studio key.
   embed: (request) => embedGemini(request),
   embedBatchSize: GEMINI_EMBED_BATCH_SIZE
 });
 providerRegistry.register("glm", {
   stream: (options) => streamOpenAI({
     ...options,
-    baseUrl: options.baseUrl ?? GLM_CODING_BASE_URL
+    baseUrl: options.baseUrl ?? GLM_BASE_URL
   })
 });
 providerRegistry.register("moonshot", {
-  stream: (options) => {
-    const baseUrl = options.baseUrl ?? "https://api.moonshot.ai/v1";
-    const defaultHeaders = baseUrl.includes("api.kimi.com") ? { "User-Agent": KIMI_CODE_USER_AGENT, ...options.defaultHeaders } : options.defaultHeaders;
-    return streamOpenAI({ ...options, baseUrl, defaultHeaders });
-  }
+  // A Moonshot key goes to the public API; a Kimi Code plan key carries its
+  // own baseUrl (api.kimi.com / api.kimi.ai). Both get GG Coder's own identity.
+  stream: (options) => streamOpenAI({
+    ...options,
+    baseUrl: options.baseUrl ?? "https://api.moonshot.ai/v1",
+    defaultHeaders: { "User-Agent": GG_CODER_USER_AGENT, ...options.defaultHeaders }
+  })
 });
 providerRegistry.register("deepseek", {
   stream: (options) => streamOpenAI({
@@ -5524,27 +5430,10 @@ providerRegistry.register("sakana", {
   })
 });
 providerRegistry.register("xai", {
-  // Both Grok routes ride xAI's Responses API (see providers/xai-responses.ts):
-  // Chat Completions is deprecated for Grok reasoning models and can't carry
-  // the encrypted reasoning that keeps long tool loops coherent.
-  //
-  // Subscription OAuth (SuperGrok / X Premium) routes to the Grok CLI chat proxy
-  // instead, which serves the same `/v1/responses` surface but gates on Grok-CLI
-  // client identity. Inject those headers centrally here — exactly as the Kimi
-  // endpoint above — so EVERY stream (agent loop, compaction, title-gen,
-  // sub-agents) is accepted rather than depending on each call site to thread
-  // headers. Caller-provided headers still win on collision.
-  stream: (options) => {
-    const baseUrl = options.baseUrl ?? "https://api.x.ai/v1";
-    const defaultHeaders = baseUrl.includes(GROK_CLI_PROXY_HOST) ? {
-      "X-XAI-Token-Auth": "xai-grok-cli",
-      "x-grok-client-version": GROK_CLI_VERSION,
-      "x-grok-client-identifier": "ggcoder",
-      "x-grok-model-override": options.model,
-      ...options.defaultHeaders
-    } : options.defaultHeaders;
-    return streamXaiResponses({ ...options, baseUrl, defaultHeaders });
-  }
+  // xAI API key on xAI's Responses API (see providers/xai-responses.ts): Chat
+  // Completions is deprecated for Grok reasoning models and can't carry the
+  // encrypted reasoning that keeps long tool loops coherent.
+  stream: (options) => streamXaiResponses({ ...options, baseUrl: options.baseUrl ?? "https://api.x.ai/v1" })
 });
 providerRegistry.register("minimax", {
   stream: (options) => streamAnthropic({
@@ -5595,6 +5484,14 @@ providerRegistry.register("local", {
     }
   )
 });
+function isOpenAIHost(baseUrl) {
+  if (!baseUrl) return true;
+  try {
+    return new URL(baseUrl).hostname === "api.openai.com";
+  } catch {
+    return false;
+  }
+}
 function requireLocalBaseUrl(baseUrl) {
   if (!baseUrl) {
     throw new GGAIError(
@@ -5785,16 +5682,16 @@ function l2Normalize(vector) {
 
 // src/utils/preconnect.ts
 var PRECONNECT_INTERVAL_MS = 3e4;
-function defaultBaseUrl(provider, accountId) {
+function defaultBaseUrl(provider) {
   switch (provider) {
     case "anthropic":
       return "https://api.anthropic.com";
     case "openai":
-      return accountId ? "https://chatgpt.com/backend-api" : "https://api.openai.com/v1";
+      return "https://api.openai.com/v1";
     case "gemini":
-      return "https://cloudcode-pa.googleapis.com";
+      return "https://generativelanguage.googleapis.com/v1beta";
     case "glm":
-      return "https://api.z.ai/api/coding/paas/v4";
+      return "https://api.z.ai/api/paas/v4";
     case "moonshot":
       return "https://api.moonshot.ai/v1";
     case "deepseek":
@@ -5827,7 +5724,7 @@ function isLocalHost(hostname) {
   return a === 127 || a === 10 || a === 192 && b === 168 || a === 172 && b >= 16 && b <= 31;
 }
 function preconnectTarget(options) {
-  const raw = options.baseUrl ?? defaultBaseUrl(options.provider, options.accountId);
+  const raw = options.baseUrl ?? defaultBaseUrl(options.provider);
   if (!raw || options.provider === "local" || options.provider === "palsu") return void 0;
   let url;
   try {
@@ -6341,10 +6238,10 @@ function palsuRerankScore(query, document) {
   return hits / queryTokens.size;
 }
 export {
-  CODEX_CLIENT_VERSION,
   EventStream,
   FAST_MODE_SUFFIX,
   GGAIError,
+  GG_CODER_USER_AGENT,
   LOCAL_NO_API_KEY,
   PRECONNECT_INTERVAL_MS,
   ProviderError,