@kenkaiiii/gg-ai 4.3.164 → 4.3.166

package/dist/index.cjs

@@ -34,6 +34,8 @@ __export(index_exports, {
   GGAIError: () => GGAIError,
   ProviderError: () => ProviderError,
   StreamResult: () => StreamResult,
+  formatError: () => formatError,
+  formatErrorForDisplay: () => formatErrorForDisplay,
   palsuAssistantMessage: () => palsuAssistantMessage,
   palsuText: () => palsuText,
   palsuThinking: () => palsuThinking,
@@ -46,21 +48,165 @@ module.exports = __toCommonJS(index_exports);
 
 // src/errors.ts
 var GGAIError = class extends Error {
+  source;
+  requestId;
+  hint;
   constructor(message, options) {
-    super(message, options);
+    super(message, { cause: options?.cause });
     this.name = "GGAIError";
+    this.source = options?.source ?? "ggcoder";
+    this.requestId = options?.requestId;
+    this.hint = options?.hint;
   }
 };
 var ProviderError = class extends GGAIError {
   provider;
   statusCode;
   constructor(provider, message, options) {
-    super(`[${provider}] ${message}`, { cause: options?.cause });
+    super(message, {
+      source: "provider",
+      requestId: options?.requestId,
+      hint: options?.hint,
+      cause: options?.cause
+    });
     this.name = "ProviderError";
     this.provider = provider;
     this.statusCode = options?.statusCode;
   }
 };
+var PROVIDER_DISPLAY = {
+  openai: "OpenAI",
+  anthropic: "Anthropic",
+  glm: "Z.AI (GLM)",
+  moonshot: "Moonshot",
+  deepseek: "DeepSeek",
+  openrouter: "OpenRouter",
+  xiaomi: "Xiaomi (MiMo)",
+  minimax: "MiniMax"
+};
+var PROVIDER_STATUS_URL = {
+  openai: "status.openai.com",
+  anthropic: "status.anthropic.com"
+};
+function providerDisplayName(provider) {
+  return PROVIDER_DISPLAY[provider] ?? provider;
+}
+function formatError(err) {
+  if (err instanceof ProviderError) {
+    const name = providerDisplayName(err.provider);
+    const cleanMessage = cleanProviderMessage(err.message);
+    return {
+      headline: `${name} returned an error.`,
+      source: "provider",
+      message: cleanMessage,
+      provider: err.provider,
+      statusCode: err.statusCode,
+      requestId: err.requestId,
+      guidance: err.hint ?? providerGuidance(err.provider, cleanMessage, err.statusCode)
+    };
+  }
+  if (err instanceof GGAIError) {
+    return finaliseBySource(err.source, err.message, err.requestId, err.hint);
+  }
+  if (err instanceof Error) {
+    const source = inferSource(err);
+    return finaliseBySource(source, err.message, void 0, void 0);
+  }
+  return finaliseBySource("ggcoder", String(err), void 0, void 0);
+}
+function finaliseBySource(source, message, requestId, hint) {
+  switch (source) {
+    case "network":
+      return {
+        headline: "Network error \u2014 couldn't reach the provider.",
+        source,
+        message,
+        guidance: hint ?? "Check your internet connection. Not a ggcoder issue \u2014 retry shortly.",
+        ...requestId ? { requestId } : {}
+      };
+    case "auth":
+      return {
+        headline: "Authentication issue.",
+        source,
+        message,
+        guidance: hint ?? "Run `ggcoder login` to refresh your credentials.",
+        ...requestId ? { requestId } : {}
+      };
+    case "provider":
+      return {
+        headline: "Provider returned an error.",
+        source,
+        message,
+        guidance: hint ?? providerGuidance(void 0, message, void 0),
+        ...requestId ? { requestId } : {}
+      };
+    case "ggcoder":
+      return {
+        headline: "ggcoder hit an unexpected error.",
+        source,
+        message,
+        guidance: hint ?? "This looks like a ggcoder bug \u2014 please report it to the developer (see /help).",
+        ...requestId ? { requestId } : {}
+      };
+  }
+}
+function formatErrorForDisplay(err) {
+  const f = formatError(err);
+  const lines = [f.headline];
+  if (f.message && f.message !== f.headline) lines.push(`  ${f.message}`);
+  lines.push(`  \u2192 ${f.guidance}`);
+  return lines.join("\n");
+}
+function cleanProviderMessage(message) {
+  return message.replace(/^\[[^\]]+\]\s*/, "").trim();
+}
+function inferSource(err) {
+  const msg = err.message.toLowerCase();
+  const code = err.code ?? "";
+  if (code === "ECONNREFUSED" || code === "ETIMEDOUT" || code === "ENOTFOUND" || code === "ECONNRESET" || msg.includes("fetch failed") || msg.includes("network request failed")) {
+    return "network";
+  }
+  if (msg.includes("not logged in") || msg.includes("token exchange failed") || msg.includes("token refresh failed") || msg.includes("invalid_grant")) {
+    return "auth";
+  }
+  return "ggcoder";
+}
+function providerGuidance(provider, message, statusCode) {
+  const name = provider ? providerDisplayName(provider) : "the provider";
+  const status = provider ? PROVIDER_STATUS_URL[provider] : void 0;
+  const lower = message.toLowerCase();
+  if (statusCode === 401 || lower.includes("unauthorized") || lower.includes("invalid api key")) {
+    return `Authentication failed with ${name}. Run \`ggcoder login\` to refresh your credentials.`;
+  }
+  if (lower.includes("overloaded") || lower.includes("engine_overloaded")) {
+    return `${name}'s servers are overloaded right now. Retry in a moment \u2014 not a ggcoder issue.`;
+  }
+  if (lower.includes("insufficient balance") || lower.includes("quota exceeded") || lower.includes("recharge") || lower.includes("no resource package")) {
+    return `Your ${name} account has a billing or quota issue \u2014 check your balance. Not a ggcoder issue.`;
+  }
+  if (statusCode === 429 || lower.includes("rate limit") || lower.includes("too many requests")) {
+    return `${name} rate limit hit. Wait a moment then retry \u2014 not a ggcoder issue.`;
+  }
+  if (statusCode === 502 || lower.includes("bad gateway")) {
+    return `${name} returned a bad gateway. Retry \u2014 this is on their side, not ggcoder.`;
+  }
+  if (statusCode === 503 || lower.includes("service unavailable")) {
+    return `${name} is temporarily unavailable. Retry shortly \u2014 not a ggcoder issue.`;
+  }
+  if (statusCode === 500 || lower.includes("server_error") || lower.includes("500") && lower.includes("internal server error")) {
+    return status ? `This is an error from ${name}, not ggcoder. Retry \u2014 if it keeps happening, check ${status}.` : `This is an error from ${name}, not ggcoder. Retry \u2014 if it keeps happening, try a different model with /model.`;
+  }
+  if (lower.includes("timeout") || lower.includes("timed out")) {
+    return `Request to ${name} timed out. Their servers may be slow \u2014 retry. Not a ggcoder issue.`;
+  }
+  if (lower.includes("does not recognize the requested model") || lower.includes("model") && (lower.includes("not exist") || lower.includes("not found") || lower.includes("no access"))) {
+    return `${name} doesn't recognise this model on your account. Use /model to switch, or check your subscription tier.`;
+  }
+  if (lower.includes("context_length_exceeded") || lower.includes("prompt is too long")) {
+    return `Context window for this ${name} model is full. Run /compact to shrink history, or start a new session.`;
+  }
+  return status ? `This is an error from ${name}, not ggcoder. Retry \u2014 if it persists, check ${status}.` : `This is an error from ${name}, not ggcoder. Retry \u2014 if it persists, try a different model with /model.`;
+}
 
 // src/providers/anthropic.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
@@ -428,8 +574,8 @@ function supportsAdaptiveThinking(model) {
 }
 function toAnthropicThinking(level, maxTokens, model) {
   if (supportsAdaptiveThinking(model)) {
-    let effort = level;
-    if (level === "max" && !model.includes("opus")) {
+    let effort = level === "xhigh" ? "max" : level;
+    if (effort === "max" && !model.includes("opus")) {
       effort = "high";
     }
     return {
@@ -438,7 +584,7 @@ function toAnthropicThinking(level, maxTokens, model) {
       outputConfig: { effort }
     };
   }
-  const effectiveLevel = level === "max" ? "high" : level;
+  const effectiveLevel = level === "xhigh" ? "high" : level;
   const budgetMap = {
     low: Math.max(1024, Math.floor(maxTokens * 0.25)),
     medium: Math.max(2048, Math.floor(maxTokens * 0.5)),
@@ -571,8 +717,12 @@ function toOpenAIToolChoice(choice) {
   if (choice === "required") return "required";
   return { type: "function", function: { name: choice.name } };
 }
-function toOpenAIReasoningEffort(level) {
-  return level === "max" ? "high" : level;
+function isOpenAIProVariant(model) {
+  return /^gpt-5\.\d+-pro$/i.test(model);
+}
+function toOpenAIReasoningEffort(level, model) {
+  if (isOpenAIProVariant(model) && level === "low") return "medium";
+  return level;
 }
 function normalizeAnthropicStopReason(reason) {
   switch (reason) {
@@ -995,8 +1145,10 @@ function messageToResponse(message) {
 }
 function toError(err) {
   if (err instanceof import_sdk.default.APIError) {
+    const requestId = err.request_id ?? err.error?.request_id;
     return new ProviderError("anthropic", err.message, {
       statusCode: err.status,
+      ...requestId ? { requestId } : {},
       cause: err
     });
   }
@@ -1039,7 +1191,7 @@ async function* runStream2(options) {
     ...effectiveTemp != null && !options.thinking ? { temperature: effectiveTemp } : {},
     ...options.topP != null ? { top_p: options.topP } : {},
     ...options.stop ? { stop: options.stop } : {},
-    ...options.thinking && !usesThinkingParam ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking) } : {},
+    ...options.thinking && !usesThinkingParam ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking, options.model) } : {},
     ...options.tools?.length ? { tools: toOpenAITools(options.tools) } : {},
     ...options.toolChoice && options.tools?.length ? { tool_choice: toOpenAIToolChoice(options.toolChoice) } : {},
     ...useStreaming ? { stream_options: { include_usage: true } } : {}
@@ -1288,19 +1440,19 @@ function completionToResponse(completion) {
 }
 function toError2(err, provider = "openai") {
   if (err instanceof import_openai.default.APIError) {
-    let msg = err.message;
     const body = err.error;
-    if (body) {
-      const modelName = body.model || "";
-      const _code = body.code || "";
-      const message = body.message || "";
-      if (modelName === "codex-mini-latest" || message.includes("codex-mini-latest")) {
-        msg = `codex-mini-latest requires an OpenAI Pro or Max subscription. You currently have access to GPT-5.4 and GPT-5.4 Mini with your account.`;
-      }
-      msg += ` | body: ${JSON.stringify(body)}`;
-    }
-    return new ProviderError(provider, msg, {
+    const bodyMessage = typeof body?.message === "string" && body.message.trim() ? body.message.trim() : void 0;
+    const modelName = typeof body?.model === "string" ? body.model : "";
+    const cleanMessage = bodyMessage ?? err.message;
+    let hint;
+    if (modelName === "codex-mini-latest" || cleanMessage.includes("codex-mini-latest")) {
+      hint = "codex-mini-latest requires an OpenAI Pro or Max subscription. Your account currently has access to GPT-5.4 and GPT-5.4 Mini.";
+    }
+    const requestId = err.request_id ?? (typeof body?.request_id === "string" ? body.request_id : void 0);
+    return new ProviderError(provider, cleanMessage, {
       statusCode: err.status,
+      ...requestId ? { requestId } : {},
+      ...hint ? { hint } : {},
       cause: err
     });
   }
@@ -1362,19 +1514,19 @@ async function* runStream3(options) {
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
-    let message = `Codex API error (${response.status}): ${text}`;
+    const parsed = parseCodexErrorBody(text);
+    const message = parsed.message ?? `Codex API returned HTTP ${response.status}.`;
+    const requestId = parsed.requestId ?? response.headers.get("x-request-id") ?? response.headers.get("openai-request-id") ?? void 0;
+    let hint;
     if (response.status === 400 && text.includes("not supported")) {
-      message += `
-
-Hint: Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription. The "codex-spark" variants require ChatGPT Pro. Ensure your account has an active subscription at https://chatgpt.com/settings`;
-    }
-    if (response.status === 404 && text.includes("does not exist")) {
-      message += `
-
-Hint: codex-mini-latest requires an OpenAI Pro ($200/mo) or Max subscription. GPT-5.4 and GPT-5.4 Mini work with any active ChatGPT plan.`;
+      hint = 'Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription. The "codex-spark" variants require ChatGPT Pro. Check your subscription at https://chatgpt.com/settings.';
+    } else if (response.status === 404 && text.includes("does not exist")) {
+      hint = "codex-mini-latest requires an OpenAI Pro ($200/mo) or Max subscription. GPT-5.4 and GPT-5.4 Mini work with any active ChatGPT plan.";
     }
     throw new ProviderError("openai", message, {
-      statusCode: response.status
+      statusCode: response.status,
+      ...requestId ? { requestId } : {},
+      ...hint ? { hint } : {}
     });
   }
   if (!response.body) {
@@ -1389,12 +1541,22 @@ Hint: codex-mini-latest requires an OpenAI Pro ($200/mo) or Max subscription. GP
     const type = event.type;
     if (!type) continue;
     if (type === "error") {
-      const msg = event.message || JSON.stringify(event);
-      throw new ProviderError("openai", `Codex error: ${msg}`);
+      const nested = event.error ?? void 0;
+      const message = nested?.message ?? event.message ?? "Codex stream emitted an error chunk without a message.";
+      const code = nested?.code ?? nested?.type ?? event.code ?? "server_error";
+      const requestId = extractCodexRequestId(message) ?? event.request_id;
+      throw new ProviderError("openai", message, {
+        ...requestId != null ? { requestId } : {},
+        ...code === "server_error" ? { statusCode: 500 } : {}
+      });
     }
     if (type === "response.failed") {
-      const msg = event.error?.message || "Codex response failed";
-      throw new ProviderError("openai", msg);
+      const nested = event.error;
+      const message = nested?.message ?? "Codex response failed.";
+      const requestId = extractCodexRequestId(message) ?? event.request_id;
+      throw new ProviderError("openai", message, {
+        ...requestId != null ? { requestId } : {}
+      });
     }
     if (type === "response.output_text.delta") {
       const delta = event.delta;
@@ -1639,6 +1801,23 @@ function toCodexTools(tools) {
     strict: null
   }));
 }
+function extractCodexRequestId(message) {
+  const match = message.match(/request ID ([a-z0-9-]{8,})/i);
+  return match?.[1];
+}
+function parseCodexErrorBody(text) {
+  if (!text) return {};
+  try {
+    const parsed = JSON.parse(text);
+    const error = parsed.error;
+    const message = error?.message ?? parsed.message;
+    const requestId = parsed.request_id ?? error?.request_id ?? (message ? extractCodexRequestId(message) : void 0);
+    return { ...message ? { message } : {}, ...requestId ? { requestId } : {} };
+  } catch {
+    const trimmed = text.trim().slice(0, 240);
+    return trimmed ? { message: trimmed } : {};
+  }
+}
 
 // src/provider-registry.ts
 var ProviderRegistryImpl = class {
@@ -1899,6 +2078,8 @@ function registerPalsuProvider(config) {
   GGAIError,
   ProviderError,
   StreamResult,
+  formatError,
+  formatErrorForDisplay,
   palsuAssistantMessage,
   palsuText,
   palsuThinking,