@kenkaiiii/gg-ai 5.83.2 → 5.83.4

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(index_exports, {
   GGAIError: () => GGAIError,
   ProviderError: () => ProviderError,
   REDACTION_MARKER: () => REDACTED,
+  ResponseStalledError: () => ResponseStalledError,
   StreamResult: () => StreamResult,
   TOOL_CALL_NAME_RULES: () => TOOL_CALL_NAME_RULES,
   clampProviderContextImages: () => clampProviderContextImages,
@@ -205,6 +206,14 @@ var VideoUnsupportedError = class extends GGAIError {
     this.name = "VideoUnsupportedError";
   }
 };
+var ResponseStalledError = class extends GGAIError {
+  inToolCall;
+  constructor(message, options) {
+    super(message, { source: "network", hint: options.hint, cause: options.cause });
+    this.name = "ResponseStalledError";
+    this.inToolCall = options.inToolCall;
+  }
+};
 var ProviderError = class extends GGAIError {
   provider;
   statusCode;
@@ -340,6 +349,14 @@ function formatError(err) {
       guidance: err.hint ?? providerGuidance(err.provider, cleanMessage, err.statusCode)
     };
   }
+  if (err instanceof ResponseStalledError) {
+    return {
+      headline: "The response kept stalling before it finished.",
+      source: err.source,
+      message: err.message,
+      guidance: err.hint ?? "Retry once. If it keeps happening, choose another model."
+    };
+  }
   if (err instanceof GGAIError) {
     return finaliseBySource(err.source, err.message, err.requestId, err.hint);
   }
@@ -1751,9 +1768,43 @@ function parseToolArguments(argsJson) {
   }
 }
 
+// src/utils/provider-fetch.ts
+var import_undici = require("undici");
+var PROVIDER_TRANSPORT_TIMEOUT_MS = 30 * 6e4;
+function nodeUsesEnvProxy({
+  env = process.env,
+  execArgv = process.execArgv,
+  nodeVersion = process.versions.node
+} = {}) {
+  const flags = [...execArgv, ...(env.NODE_OPTIONS ?? "").split(/\s+/)];
+  if (flags.includes("--use-env-proxy")) return true;
+  if (env.NODE_USE_ENV_PROXY !== "1") return false;
+  const [major = 0, minor = 0] = nodeVersion.split(".").map(Number);
+  return major >= 24 || major === 22 && minor >= 21;
+}
+function createProviderFetch(timeoutMs, { useEnvProxy = nodeUsesEnvProxy() } = {}) {
+  const timeouts = { headersTimeout: timeoutMs, bodyTimeout: timeoutMs };
+  const dispatcher = useEnvProxy ? new import_undici.EnvHttpProxyAgent(timeouts) : new import_undici.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 response = await (0, import_undici.fetch)(input, {
+      ...init2,
+      dispatcher
+    });
+    return response;
+  };
+  return Object.assign(providerFetch2, { Response: globalThis.Response });
+}
+var providerFetch = createProviderFetch(
+  PROVIDER_TRANSPORT_TIMEOUT_MS
+);
+
 // src/providers/anthropic.ts
 var anthropicClientCache = /* @__PURE__ */ new Map();
-var NON_STREAMING_REQUEST_TIMEOUT_MS = 6e5;
+var NON_STREAMING_REQUEST_TIMEOUT_MS = PROVIDER_TRANSPORT_TIMEOUT_MS;
 function fineGrainedToolStreamingEnabled() {
   const raw = process.env.GG_FINE_GRAINED_TOOL_STREAMING ?? process.env.CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING;
   if (!raw) return false;
@@ -1814,7 +1865,8 @@ function createClient(options) {
   const client = new import_sdk.default({
     ...isOAuth ? { apiKey: null, authToken: options.apiKey } : { apiKey: options.apiKey },
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
-    ...options.fetch ? { fetch: options.fetch } : {},
+    // Default transport lifts undici's 300s header/body caps (see provider-fetch.ts).
+    fetch: options.fetch ?? providerFetch,
     maxRetries: 0,
     ...isOAuth ? {
       defaultHeaders: {
@@ -2592,7 +2644,8 @@ function createClient2(options) {
   const client = new import_openai.default({
     apiKey: options.apiKey,
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
-    ...options.fetch ? { fetch: options.fetch } : {},
+    // Default transport lifts undici's 300s header/body caps (see provider-fetch.ts).
+    fetch: options.fetch ?? providerFetch,
     ...options.defaultHeaders ? { defaultHeaders: options.defaultHeaders } : {}
   });
   if (!options.fetch) {
@@ -2714,16 +2767,13 @@ async function* runStream2(options) {
 `
     );
   }
-  const requestHeaders = options.provider === "xai" ? {
-    headers: {
-      "x-grok-conv-id": normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder")
-    }
-  } : {};
   if (!useStreaming) {
     try {
       const completion = await client.chat.completions.create(requestParams, {
         signal: options.signal ?? void 0,
-        ...requestHeaders
+        // The whole reply arrives in one response, so the SDK's 10min default
+        // would undercut the agent loop's 15min thinking cap for this call.
+        timeout: PROVIDER_TRANSPORT_TIMEOUT_MS
       });
       yield* synthesizeEventsFromCompletion(completion, !!options.thinking, endpointKey);
       return completionToResponse(completion, endpointKey);
@@ -2734,8 +2784,7 @@ async function* runStream2(options) {
   let stream2;
   try {
     stream2 = await client.chat.completions.create(requestParams, {
-      signal: options.signal ?? void 0,
-      ...requestHeaders
+      signal: options.signal ?? void 0
     });
   } catch (err) {
     throw toError2(err, providerName);
@@ -2776,6 +2825,8 @@ async function* runStream2(options) {
         thinkingAccum += reasoning.text;
         if (options.thinking) {
           yield { type: "thinking_delta", text: reasoning.text };
+        } else {
+          yield { type: "keepalive", reasoning: true };
         }
       }
       if (delta.content) {
@@ -3094,55 +3145,9 @@ function extractRequestIdFromMessage(message) {
   return match?.[1];
 }
 
-// src/providers/openai-codex.ts
-var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
-var CODEX_CLIENT_VERSION = "0.161.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
-    };
-  }
-}
-function usesResponsesLite(model) {
-  return model.startsWith("gpt-5.6-") || model.startsWith("gpt-6-") || model.startsWith("gpt-6.");
+// src/providers/responses-stream.ts
+function isEncryptedReasoning(data) {
+  return data.type === "reasoning" && typeof data.id === "string" && typeof data.encrypted_content === "string";
 }
 function outputTextKey(itemId, contentIndex) {
   return `${itemId ?? ""}:${contentIndex ?? 0}`;
@@ -3150,132 +3155,7 @@ function outputTextKey(itemId, contentIndex) {
 function isVisibleOutputItem(itemType) {
   return itemType === "message";
 }
-function toCodexToolChoice(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.`,
-      { source: "capability" }
-    );
-  }
-  if (resolved === "required" && !tools?.length) {
-    throw new GGAIError("OpenAI Codex cannot require a tool call when no tools are configured.", {
-      source: "capability"
-    });
-  }
-  return resolved;
-}
-function streamOpenAICodex(options) {
-  return new StreamResult(runStream3(options), options.signal);
-}
-async function* runStream3(options, retriedWithoutReasoning = false) {
-  const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
-  const url = `${baseUrl}/codex/responses`;
-  const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
-  const downgraded = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
-  const { system, input } = toCodexInput(downgraded, { supportsImages: options.supportsImages });
-  const responsesLite = usesResponsesLite(options.model);
-  const liteShape = options.responsesLite ?? responsesLite;
-  const body = {
-    model: options.model,
-    store: false,
-    stream: true,
-    instructions: system,
-    input,
-    tool_choice: toCodexToolChoice(options.toolChoice, options.tools),
-    parallel_tool_calls: !liteShape,
-    include: ["reasoning.encrypted_content"]
-  };
-  if (options.tools?.length) {
-    body.tools = toCodexTools(options.tools, options.strictTools ?? true);
-  }
-  body.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder");
-  if (options.temperature != null && !options.thinking) {
-    body.temperature = options.temperature;
-  }
-  if (options.speed === "fast") {
-    body.service_tier = "priority";
-  }
-  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" } : {}
-  };
-  if (responsesLite) {
-    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 (${import_node_os.default.platform()} ${import_node_os.default.release()}; ${import_node_os.default.arch()})`,
-    ...responsesLite ? { version: CODEX_CLIENT_VERSION } : {},
-    ...liteShape ? { "X-OpenAI-Internal-Codex-Responses-Lite": "true" } : {}
-  };
-  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 response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: encodedRequest.body,
-    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 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 });
-      const messages = options.messages.map(
-        (msg) => msg.role === "assistant" && Array.isArray(msg.content) ? {
-          ...msg,
-          content: msg.content.filter(
-            (part) => !(part.type === "raw" && isEncryptedReasoning(part.data))
-          )
-        } : msg
-      );
-      return yield* runStream3({ ...options, messages }, true);
-    }
-    const usageLimit = codexUsageLimitError(parsed.errorObj, response.status, requestId);
-    if (usageLimit) throw usageLimit;
-    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.";
-    }
-    throw new ProviderError("openai", message, {
-      statusCode: response.status,
-      ...requestId ? { requestId } : {},
-      ...hint ? { hint } : {}
-    });
-  }
-  if (!response.body) {
-    throw new ProviderError("openai", "No response body from Codex API");
-  }
+async function* consumeResponsesEvents(events, ctx) {
   const contentParts = [];
   let textAccum = "";
   const toolCalls = /* @__PURE__ */ new Map();
@@ -3292,34 +3172,30 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
   let thinkingTextEmitted = false;
   const diagStart = Date.now();
   const diagSeen = /* @__PURE__ */ new Set();
-  for await (const event of parseSSE(response.body)) {
+  for await (const event of events) {
     const type = event.type;
     if (!type) continue;
     if (!diagSeen.has(type)) {
       diagSeen.add(type);
-      providerDiag("codex_event_first", { type, sinceStartMs: Date.now() - diagStart });
+      providerDiag(`${ctx.diagPrefix}_event_first`, { type, sinceStartMs: Date.now() - diagStart });
     }
     if (type === "error") {
       const nested = event.error ?? void 0;
-      const message = nested?.message ?? event.message ?? "Codex stream emitted an error chunk without a message.";
+      const message = nested?.message ?? event.message ?? `${ctx.label} stream emitted an error chunk without a message.`;
       const code = nested?.code ?? nested?.type ?? event.code ?? "server_error";
       const requestId = extractRequestIdFromMessage(message) ?? event.request_id;
-      const usageLimit = codexUsageLimitError(
-        nested ?? event,
-        void 0,
-        requestId
-      );
+      const usageLimit = ctx.errorChunk?.(nested ?? event, requestId);
       if (usageLimit) throw usageLimit;
-      throw new ProviderError("openai", message, {
+      throw new ProviderError(ctx.provider, message, {
         ...requestId != null ? { requestId } : {},
         ...code === "server_error" ? { statusCode: 500 } : {}
       });
     }
     if (type === "response.failed") {
       const nested = event.error;
-      const message = nested?.message ?? "Codex response failed.";
+      const message = nested?.message ?? `${ctx.label} response failed.`;
       const requestId = extractRequestIdFromMessage(message) ?? event.request_id;
-      throw new ProviderError("openai", message, {
+      throw new ProviderError(ctx.provider, message, {
         ...requestId != null ? { requestId } : {}
       });
     }
@@ -3368,15 +3244,17 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
       }
     }
     if (type === "response.reasoning_summary_part.added") {
-      if (options.thinking && thinkingTextEmitted) {
+      if (ctx.thinking && thinkingTextEmitted) {
         yield { type: "thinking_delta", text: "\n\n" };
       }
     }
     if (type === "response.reasoning_summary_text.delta" || type === "response.reasoning_summary.delta" || type === "response.reasoning_text.delta" || type === "response.reasoning.delta") {
       const delta = event.delta;
-      if (options.thinking && delta) {
+      if (ctx.thinking && delta) {
         thinkingTextEmitted = true;
         yield { type: "thinking_delta", text: delta };
+      } else if (delta) {
+        yield { type: "keepalive", reasoning: true };
       }
     }
     if (type === "response.output_item.added") {
@@ -3386,8 +3264,8 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
       if (itemId && itemType) {
         outputItemTypes.set(itemId, itemType);
       }
-      if (itemType === "reasoning" && options.thinking) {
-        yield { type: "thinking_delta", text: "" };
+      if (itemType === "reasoning") {
+        yield ctx.thinking ? { type: "thinking_delta", text: "" } : { type: "keepalive", reasoning: true };
       }
       if (itemId && itemType) {
         const pending = [...pendingOutputTextByPart.entries()].filter(([, pendingPart]) => pendingPart.itemId === itemId).sort(([, a], [, b]) => a.contentIndex - b.contentIndex);
@@ -3448,7 +3326,8 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
             kind: "reasoning",
             part: {
               type: "raw",
-              data: { ...item, summary: Array.isArray(item.summary) ? item.summary : [] }
+              data: { ...item, summary: Array.isArray(item.summary) ? item.summary : [] },
+              ...ctx.reasoningOrigin ? { origin: ctx.reasoningOrigin } : {}
             }
           });
         }
@@ -3457,6 +3336,13 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
         const callId = item.call_id;
         const itemId = item.id;
         const id = `${callId}|${itemId}`;
+        if (!toolCalls.has(id) && typeof item.name === "string") {
+          toolCalls.set(id, {
+            id,
+            name: item.name,
+            argsJson: typeof item.arguments === "string" ? item.arguments : ""
+          });
+        }
         const tc = toolCalls.get(id);
         if (tc) {
           finishedToolCalls.add(id);
@@ -3482,6 +3368,23 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
       } else {
         terminal = { status: "completed" };
       }
+      if (Array.isArray(resp?.output)) {
+        for (const raw of resp.output) {
+          const item = raw;
+          if (typeof item?.id !== "string" || typeof item.type !== "string") continue;
+          if (!outputItemTypes.has(item.id)) outputItemTypes.set(item.id, item.type);
+        }
+        const pending = [...pendingOutputTextByPart.entries()].sort(
+          ([, a], [, b]) => a.contentIndex - b.contentIndex
+        );
+        for (const [key, pendingPart] of pending) {
+          if (!isVisibleOutputItem(outputItemTypes.get(pendingPart.itemId))) continue;
+          pendingOutputTextByPart.delete(key);
+          if (!pendingPart.text) continue;
+          textAccum += pendingPart.text;
+          yield { type: "text_delta", text: pendingPart.text };
+        }
+      }
       const usage = resp?.usage;
       if (usage) {
         cacheRead = usage.input_tokens_details?.cached_tokens ?? 0;
@@ -3492,23 +3395,30 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     }
   }
   if (!terminal) {
-    throw new ProviderError("openai", "Stream ended before completion (no response.completed).", {
-      statusCode: 504
-    });
+    throw new ProviderError(
+      ctx.provider,
+      "Stream ended before completion (no response.completed).",
+      {
+        statusCode: 504
+      }
+    );
   }
   const droppedToolCalls = [...toolCalls.keys()].filter((id) => !finishedToolCalls.has(id)).length;
   if (terminal.status === "completed") {
     for (const [id, tc] of toolCalls) {
       if (!finishedToolCalls.has(id)) {
         throw new ProviderError(
-          "openai",
-          `Codex reply completed with an unfinished tool call: ${tc.name} (${id}).`,
+          ctx.provider,
+          `${ctx.label} reply completed with an unfinished tool call: ${tc.name} (${id}).`,
           { statusCode: 502 }
         );
       }
     }
   } else {
-    providerDiag("codex_incomplete", { reason: terminal.reason ?? null, droppedToolCalls });
+    providerDiag(`${ctx.diagPrefix}_incomplete`, {
+      reason: terminal.reason ?? null,
+      droppedToolCalls
+    });
   }
   const seenTool = /* @__PURE__ */ new Set();
   let textInserted = false;
@@ -3575,34 +3485,14 @@ function incompleteStopReason(reason) {
   if (reason === "content_filter") return "refusal";
   return "error";
 }
-async function* parseSSE(body) {
-  for await (const event of readSseStream(body)) {
-    const data = event.data.trim();
-    if (!data || data === "[DONE]") continue;
-    try {
-      yield JSON.parse(data);
-    } catch {
-    }
-  }
-}
-function remapCodexId(id, idMap) {
-  const existing = idMap.get(id);
-  if (existing) return existing;
-  const withPrefix = id.startsWith("fc_") || id.startsWith("fc-") ? id : `fc_${id.replace(/^toolu_/, "")}`;
-  const sanitized = withPrefix.replace(/[^A-Za-z0-9_-]/g, "_");
-  let mapped = sanitized;
-  let suffix = 2;
-  const used = new Set(idMap.values());
-  while (used.has(mapped)) {
-    mapped = `${sanitized}_${suffix++}`;
-  }
-  idMap.set(id, mapped);
-  return mapped;
-}
-function isEncryptedReasoning(data) {
-  return data.type === "reasoning" && typeof data.id === "string" && typeof data.encrypted_content === "string";
-}
-function toCodexInput(messages, options) {
+function toResponsesInput(messages, options) {
+  const mapId = options.mapId ?? ((id) => id);
+  const assistantText = (text) => options.minimalAssistantItems ? { role: "assistant", content: text } : {
+    type: "message",
+    role: "assistant",
+    content: [{ type: "output_text", text, annotations: [] }],
+    status: "completed"
+  };
   let system;
   const input = [];
   const idMap = /* @__PURE__ */ new Map();
@@ -3625,30 +3515,23 @@ function toCodexInput(messages, options) {
     }
     if (msg.role === "assistant") {
       if (typeof msg.content === "string") {
-        input.push({
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text: msg.content, annotations: [] }],
-          status: "completed"
-        });
+        input.push(assistantText(msg.content));
         continue;
       }
       for (const part of msg.content) {
         if (part.type === "raw" && isEncryptedReasoning(part.data)) {
+          if (!options.keepReasoning(part)) continue;
           input.push(part.data);
         } else if (part.type === "text") {
-          input.push({
-            type: "message",
-            role: "assistant",
-            content: [{ type: "output_text", text: part.text, annotations: [] }],
-            status: "completed"
-          });
+          input.push(assistantText(part.text));
         } else if (part.type === "tool_call") {
-          const [callId, itemId] = part.id.includes("|") ? part.id.split("|", 2) : [part.id, part.id];
+          const native = part.id.includes("|");
+          const [callId, itemId] = native ? part.id.split("|", 2) : [part.id, part.id];
+          const sendItemId = !options.minimalAssistantItems || native && !!itemId && itemId !== "undefined";
           input.push({
             type: "function_call",
-            id: remapCodexId(itemId, idMap),
-            call_id: remapCodexId(callId, idMap),
+            ...sendItemId ? { id: mapId(itemId ?? callId, idMap) } : {},
+            call_id: mapId(callId, idMap),
             name: part.name,
             arguments: JSON.stringify(part.args)
           });
@@ -3663,10 +3546,10 @@ function toCodexInput(messages, options) {
         const text = toolResultText(result.content);
         input.push({
           type: "function_call_output",
-          call_id: remapCodexId(callId, idMap),
+          call_id: mapId(callId, idMap),
           output: text.length > 0 ? text : "(see attached image)"
         });
-        if (options?.supportsImages !== false && Array.isArray(result.content)) {
+        if (options.supportsImages !== false && Array.isArray(result.content)) {
           for (const block of result.content) {
             if (block.type === "image") toolImages.push(block);
           }
@@ -3690,6 +3573,221 @@ function toCodexInput(messages, options) {
   }
   return { system, input };
 }
+
+// src/providers/openai-codex.ts
+var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
+var CODEX_CLIENT_VERSION = "0.161.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
+    };
+  }
+}
+function usesResponsesLite(model) {
+  return model.startsWith("gpt-5.6-") || model.startsWith("gpt-6-") || model.startsWith("gpt-6.");
+}
+function toCodexToolChoice(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.`,
+      { source: "capability" }
+    );
+  }
+  if (resolved === "required" && !tools?.length) {
+    throw new GGAIError("OpenAI Codex cannot require a tool call when no tools are configured.", {
+      source: "capability"
+    });
+  }
+  return resolved;
+}
+function streamOpenAICodex(options) {
+  return new StreamResult(runStream3(options), options.signal);
+}
+async function* runStream3(options, retriedWithoutReasoning = false) {
+  const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const url = `${baseUrl}/codex/responses`;
+  const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
+  const downgraded = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
+  const { system, input } = toResponsesInput(downgraded, {
+    supportsImages: options.supportsImages,
+    mapId: remapCodexId,
+    // Stamped reasoning belongs to another transport (e.g. Grok's) and would
+    // be rejected here; Codex's own items are never stamped.
+    keepReasoning: (part) => part.origin === void 0
+  });
+  const responsesLite = usesResponsesLite(options.model);
+  const liteShape = options.responsesLite ?? responsesLite;
+  const body = {
+    model: options.model,
+    store: false,
+    stream: true,
+    instructions: system,
+    input,
+    tool_choice: toCodexToolChoice(options.toolChoice, options.tools),
+    parallel_tool_calls: !liteShape,
+    include: ["reasoning.encrypted_content"]
+  };
+  if (options.tools?.length) {
+    body.tools = toCodexTools(options.tools, options.strictTools ?? true);
+  }
+  body.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder");
+  if (options.temperature != null && !options.thinking) {
+    body.temperature = options.temperature;
+  }
+  if (options.speed === "fast") {
+    body.service_tier = "priority";
+  }
+  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" } : {}
+  };
+  if (responsesLite) {
+    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 (${import_node_os.default.platform()} ${import_node_os.default.release()}; ${import_node_os.default.arch()})`,
+    ...responsesLite ? { version: CODEX_CLIENT_VERSION } : {},
+    ...liteShape ? { "X-OpenAI-Internal-Codex-Responses-Lite": "true" } : {}
+  };
+  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 response = await providerFetch(url, {
+    method: "POST",
+    headers,
+    body: encodedRequest.body,
+    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 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 });
+      const messages = options.messages.map(
+        (msg) => msg.role === "assistant" && Array.isArray(msg.content) ? {
+          ...msg,
+          content: msg.content.filter(
+            (part) => !(part.type === "raw" && isEncryptedReasoning(part.data))
+          )
+        } : msg
+      );
+      return yield* runStream3({ ...options, messages }, true);
+    }
+    const usageLimit = codexUsageLimitError(parsed.errorObj, response.status, requestId);
+    if (usageLimit) throw usageLimit;
+    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.";
+    }
+    throw new ProviderError("openai", message, {
+      statusCode: response.status,
+      ...requestId ? { requestId } : {},
+      ...hint ? { hint } : {}
+    });
+  }
+  if (!response.body) {
+    throw new ProviderError("openai", "No response body from Codex API");
+  }
+  return yield* consumeResponsesEvents(parseSSE(response.body), {
+    provider: "openai",
+    label: "Codex",
+    diagPrefix: "codex",
+    thinking: !!options.thinking,
+    errorChunk: (errorObj, requestId) => codexUsageLimitError(errorObj, void 0, requestId)
+  });
+}
+async function* parseSSE(body) {
+  for await (const event of readSseStream(body)) {
+    const data = event.data.trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      yield JSON.parse(data);
+    } catch {
+    }
+  }
+}
+function remapCodexId(id, idMap) {
+  const existing = idMap.get(id);
+  if (existing) return existing;
+  const withPrefix = id.startsWith("fc_") || id.startsWith("fc-") ? id : `fc_${id.replace(/^toolu_/, "")}`;
+  const sanitized = withPrefix.replace(/[^A-Za-z0-9_-]/g, "_");
+  let mapped = sanitized;
+  let suffix = 2;
+  const used = new Set(idMap.values());
+  while (used.has(mapped)) {
+    mapped = `${sanitized}_${suffix++}`;
+  }
+  idMap.set(id, mapped);
+  return mapped;
+}
 function toCodexTools(tools, strictTools) {
   return tools.map((tool) => {
     let parameters = resolveToolSchema(tool);
@@ -3754,6 +3852,136 @@ function codexUsageLimitError(errorObj, statusCode, requestId) {
   });
 }
 
+// src/providers/xai-responses.ts
+function streamXaiResponses(options) {
+  return new StreamResult(runStream4(options), options.signal);
+}
+function xaiReasoningOrigin(model) {
+  return `xai:${model}`;
+}
+async function* runStream4(options, dropReasoning = false) {
+  const providerName = options.provider ?? "xai";
+  const client = createClient2(options);
+  const origin = xaiReasoningOrigin(options.model);
+  const useStreaming = options.streaming !== false;
+  const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
+  const downgraded = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
+  const { system, input } = toResponsesInput(downgraded, {
+    supportsImages: options.supportsImages,
+    keepReasoning: (part) => !dropReasoning && part.origin === origin,
+    minimalAssistantItems: true
+  });
+  const replaysReasoning = input.some(isReasoningItem);
+  const params = {
+    model: options.model,
+    input: system ? [{ role: "system", content: system }, ...input] : input,
+    store: false,
+    stream: useStreaming,
+    include: ["reasoning.encrypted_content"],
+    // Responses' cache-routing key (Chat used the x-grok-conv-id header).
+    prompt_cache_key: normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder"),
+    ...options.maxTokens ? { max_output_tokens: options.maxTokens } : {},
+    // Grok reasoning can't be disabled; with thinking off the server default
+    // (high on Grok 4.7) applies, exactly as on the Chat path.
+    ...options.thinking ? { reasoning: { effort: toOpenAIReasoningEffort(options.thinking, options.model) } } : {},
+    ...options.temperature != null && !options.thinking ? { temperature: options.temperature } : {},
+    ...options.topP != null ? { top_p: options.topP } : {},
+    ...options.tools?.length ? { tools: toXaiTools(options.tools) } : {},
+    ...options.toolChoice && options.tools?.length ? { tool_choice: toXaiToolChoice(options.toolChoice) } : {}
+  };
+  const body = mergeProviderOptions(params, options.providerOptions);
+  const requestOptions = {
+    signal: options.signal ?? void 0,
+    // A non-streamed reply arrives in one response; never undercut the agent
+    // loop's own (up to 15min) cap with the SDK's 10min default.
+    timeout: PROVIDER_TRANSPORT_TIMEOUT_MS,
+    headers: {
+      "x-grok-conv-id": normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder")
+    }
+  };
+  let events;
+  try {
+    if (useStreaming) {
+      const stream2 = await client.responses.create(
+        body,
+        requestOptions
+      );
+      events = stream2;
+    } else {
+      const response = await client.responses.create(
+        body,
+        requestOptions
+      );
+      events = synthesizeResponseEvents(response);
+    }
+  } catch (err) {
+    if (replaysReasoning && !dropReasoning && !options.signal?.aborted && err.status === 400) {
+      providerDiag("xai_retry_without_encrypted_reasoning", { status: 400 });
+      return yield* runStream4(options, true);
+    }
+    throw toError2(err, providerName);
+  }
+  try {
+    return yield* consumeResponsesEvents(events, {
+      provider: providerName,
+      label: "Grok",
+      diagPrefix: "xai",
+      thinking: !!options.thinking,
+      reasoningOrigin: origin
+    });
+  } catch (err) {
+    throw toError2(err, providerName);
+  }
+}
+function isReasoningItem(item) {
+  return typeof item === "object" && item !== null && isEncryptedReasoning(item);
+}
+function toXaiTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: resolveToolSchema(tool)
+  }));
+}
+function toXaiToolChoice(choice) {
+  return typeof choice === "object" ? { type: "function", name: choice.name } : choice;
+}
+async function* synthesizeResponseEvents(response) {
+  const output = Array.isArray(response.output) ? response.output : [];
+  for (const [index, raw] of output.entries()) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const item = raw;
+    const withId = typeof item.id === "string" ? item : { ...item, id: `item_${index}` };
+    yield { type: "response.output_item.added", item: withId };
+    if (withId.type === "message" && Array.isArray(withId.content)) {
+      for (const [contentIndex, content] of withId.content.entries()) {
+        const part = content;
+        if (part?.type === "output_text" && typeof part.text === "string") {
+          yield {
+            type: "response.output_text.done",
+            item_id: withId.id,
+            content_index: contentIndex,
+            text: part.text
+          };
+        }
+      }
+    }
+    if (withId.type === "function_call") {
+      yield {
+        type: "response.function_call_arguments.done",
+        item_id: withId.id,
+        arguments: typeof withId.arguments === "string" ? withId.arguments : ""
+      };
+    }
+    yield { type: "response.output_item.done", item: withId };
+  }
+  yield {
+    type: response.status === "incomplete" ? "response.incomplete" : "response.completed",
+    response
+  };
+}
+
 // src/providers/gemini.ts
 var DEFAULT_CODE_ASSIST_BASE_URL = "https://cloudcode-pa.googleapis.com";
 var CODE_ASSIST_API_VERSION = "v1internal";
@@ -4172,7 +4400,7 @@ async function sleep(ms, signal) {
 }
 async function fetchCodeAssist(plan, options) {
   try {
-    const response = await fetch(plan.url, {
+    const response = await providerFetch(plan.url, {
       method: "POST",
       headers: plan.headers,
       body: JSON.stringify(plan.body),
@@ -4225,9 +4453,9 @@ async function fetchCodeAssistWithRetry(plan, options) {
   throw lastError ?? new ProviderError("gemini", "Gemini Code Assist request failed.");
 }
 function streamGemini(options) {
-  return new StreamResult(runStream4(options), options.signal);
+  return new StreamResult(runStream5(options), options.signal);
 }
-async function* runStream4(options) {
+async function* runStream5(options) {
   const useStreaming = options.streaming !== false;
   const method = useStreaming ? "streamGenerateContent" : "generateContent";
   const plan = buildRequestPlan(options, method);
@@ -5080,13 +5308,12 @@ providerRegistry.register("sakana", {
   })
 });
 providerRegistry.register("xai", {
-  // xAI's public API (console.x.ai key) is OpenAI-compatible — ride the Chat
-  // Completions transport like Moonshot/DeepSeek. Grok reasoning models take
-  // top-level `reasoning_effort` (low/medium/high/xhigh), which the shared thinking
-  // path already sends.
+  // 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 speaks the same Chat Completions wire but gates on Grok-CLI
+  // 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
@@ -5100,7 +5327,7 @@ providerRegistry.register("xai", {
       "x-grok-model-override": options.model,
       ...options.defaultHeaders
     } : options.defaultHeaders;
-    return streamOpenAI({ ...options, baseUrl, defaultHeaders });
+    return streamXaiResponses({ ...options, baseUrl, defaultHeaders });
   }
 });
 providerRegistry.register("minimax", {
@@ -5420,6 +5647,13 @@ function formatChatError(error) {
       "Wait for the reset, or use another provider."
     );
   }
+  if (error instanceof ResponseStalledError) {
+    return present(
+      "network",
+      "The response kept stalling",
+      error.inToolCall ? "Ask for the change in smaller pieces, then try again." : "Try again, or choose another model if it keeps happening."
+    );
+  }
   if (base.source === "network") {
     return present(
       "network",
@@ -5801,6 +6035,7 @@ function palsuRerankScore(query, document) {
   GGAIError,
   ProviderError,
   REDACTION_MARKER,
+  ResponseStalledError,
   StreamResult,
   TOOL_CALL_NAME_RULES,
   clampProviderContextImages,