@prestyj/ai 5.29.0 → 5.30.0

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   classifyProviderError: () => classifyProviderError,
   dropInvalidToolCalls: () => dropInvalidToolCalls,
   environmentSecrets: () => environmentSecrets,
+  formatChatError: () => formatChatError,
   formatError: () => formatError,
   formatErrorForDisplay: () => formatErrorForDisplay,
   hasLoneSurrogate: () => hasLoneSurrogate,
@@ -65,7 +66,8 @@ __export(index_exports, {
   toAnthropicMessages: () => toAnthropicMessages,
   toOpenAIMessages: () => toOpenAIMessages,
   toWellFormedText: () => toWellFormedText,
-  toolCallNameRuleFor: () => toolCallNameRuleFor
+  toolCallNameRuleFor: () => toolCallNameRuleFor,
+  usesResponsesLite: () => usesResponsesLite
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1497,6 +1499,10 @@ function toLocalReasoningEffort(level) {
 function toGlmReasoningEffort(level) {
   return level === "ultra" ? "max" : level;
 }
+function toCodexReasoningEffort(level, model) {
+  if (level !== "ultra") return level;
+  return model === "gpt-6-astra" || model === "gpt-6.1-sol" ? "xhigh" : "max";
+}
 function toOpenAIReasoningEffort(level, model) {
   const effort = level === "max" || level === "ultra" ? "xhigh" : level;
   if (model.startsWith("fugu") && (effort === "low" || effort === "medium")) {
@@ -2428,7 +2434,7 @@ async function* runStream2(options) {
     ...options.thinking && !usesThinkingParam && !isKimiK3 && !isKimiK27 && !isLocal ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking, options.model) } : {},
     ...options.tools?.length ? {
       tools: toOpenAITools(options.tools, {
-        strict: supportsStrictToolSampling(options.provider)
+        strict: supportsStrictToolSampling(options.provider) && (options.strictTools ?? true)
       })
     } : {},
     ...options.toolChoice && options.tools?.length ? { tool_choice: toOpenAIToolChoice(options.toolChoice) } : {},
@@ -2762,7 +2768,7 @@ function toError2(err, provider = "openai") {
     const cleanMessage = isRawHtmlErrorEcho(messageCandidate) ? providerHtmlErrorMessage(err.status) : bodyMessage ? bodyMessage : isRawJsonErrorEcho(err.message) ? emptyProviderErrorMessage(err.status) : 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.";
+      hint = "This request could not use codex-mini-latest. Check your account access or choose another available model.";
     }
     const requestId = err.request_id ?? (typeof body?.request_id === "string" ? body.request_id : void 0);
     const code = typeof err.code === "string" ? err.code : void 0;
@@ -2946,6 +2952,7 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
   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,
@@ -2953,11 +2960,11 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     instructions: system,
     input,
     tool_choice: toCodexToolChoice(options.toolChoice, options.tools),
-    parallel_tool_calls: !responsesLite,
+    parallel_tool_calls: !liteShape,
     include: ["reasoning.encrypted_content"]
   };
   if (options.tools?.length) {
-    body.tools = toCodexTools(options.tools);
+    body.tools = toCodexTools(options.tools, options.strictTools ?? true);
   }
   body.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ezcoder");
   if (options.temperature != null && !options.thinking) {
@@ -2967,9 +2974,9 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     // 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 === "ultra" ? "max" : options.thinking ?? (responsesLite ? "low" : "none"),
+    effort: options.thinking ? toCodexReasoningEffort(options.thinking, options.model) : responsesLite ? "low" : "none",
     summary: "auto",
-    ...responsesLite ? { context: "all_turns" } : {}
+    ...liteShape ? { context: "all_turns" } : {}
   };
   if (responsesLite) {
     body.text = { verbosity: "low" };
@@ -2981,10 +2988,8 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     "OpenAI-Beta": "responses=experimental",
     originator: responsesLite ? "codex_cli_rs" : "ezcoder",
     "User-Agent": responsesLite ? `codex_cli_rs/${CODEX_CLIENT_VERSION}` : `ezcoder (${import_node_os.default.platform()} ${import_node_os.default.release()}; ${import_node_os.default.arch()})`,
-    ...responsesLite ? {
-      version: CODEX_CLIENT_VERSION,
-      "X-OpenAI-Internal-Codex-Responses-Lite": "true"
-    } : {}
+    ...responsesLite ? { version: CODEX_CLIENT_VERSION } : {},
+    ...liteShape ? { "X-OpenAI-Internal-Codex-Responses-Lite": "true" } : {}
   };
   if (options.accountId) {
     headers["chatgpt-account-id"] = options.accountId;
@@ -3030,9 +3035,9 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     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. Switch to a model listed for OpenAI via the model selector, or check your ChatGPT usage limits.";
+      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. Switch to GPT-6 Astra, GPT-6.1 Sol, or GPT-6 Luna via the model selector.";
+      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,
@@ -3448,15 +3453,17 @@ function toCodexInput(messages, options) {
   }
   return { system, input };
 }
-function toCodexTools(tools) {
+function toCodexTools(tools, strictTools) {
   return tools.map((tool) => {
     let parameters = resolveToolSchema(tool);
     let strict = null;
-    try {
-      parameters = makeStrictToolSchema(parameters);
-      strict = true;
-    } catch (error) {
-      if (!(error instanceof UnsupportedStrictSchemaError)) throw error;
+    if (strictTools) {
+      try {
+        parameters = makeStrictToolSchema(parameters);
+        strict = true;
+      } catch (error) {
+        if (!(error instanceof UnsupportedStrictSchemaError)) throw error;
+      }
     }
     return {
       type: "function",
@@ -3503,6 +3510,7 @@ function codexUsageLimitError(errorObj, statusCode, requestId) {
   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 } : {}
@@ -3693,6 +3701,17 @@ function stripUnsupportedSchemaFields(value) {
   }
   delete value.$schema;
   delete value.additionalProperties;
+  for (const [key, target, step] of [
+    ["exclusiveMinimum", "minimum", 1],
+    ["exclusiveMaximum", "maximum", -1]
+  ]) {
+    const bound = value[key];
+    if (bound === void 0) continue;
+    delete value[key];
+    if (typeof bound === "number" && value[target] === void 0) {
+      value[target] = value.type === "integer" ? bound + step : bound;
+    }
+  }
   for (const item of Object.values(value)) {
     if (isJsonObject(item) || Array.isArray(item)) {
       stripUnsupportedSchemaFields(item);
@@ -4422,6 +4441,157 @@ function messagesContainVideo(messages) {
   return false;
 }
 
+// src/chat-error.ts
+function causeCode(error) {
+  if (!(error instanceof Error) || !error.cause || typeof error.cause !== "object") return "";
+  const cause = error.cause;
+  if ("code" in cause && typeof cause.code === "string") return cause.code;
+  if ("type" in cause && typeof cause.type === "string") return cause.type;
+  return "";
+}
+function formatChatError(error) {
+  const base = formatError(error);
+  const raw = error instanceof Error ? error.message : "";
+  const code = causeCode(error);
+  const text = `${code} ${raw}`.toLowerCase();
+  const provider = /chatgpt/i.test(raw) ? "ChatGPT" : providerLabel(base.provider);
+  const present = (reason, headline, guidance) => ({
+    ...base,
+    ...raw ? { message: raw } : {},
+    reason,
+    headline,
+    guidance
+  });
+  if (error instanceof VideoUnsupportedError) {
+    return present(
+      "capability",
+      "This model can\u2019t read this video",
+      "Choose a model that supports video."
+    );
+  }
+  if (base.source === "capability") {
+    return present(
+      "unknown",
+      "This request isn\u2019t supported",
+      "Open details to check the request requirements."
+    );
+  }
+  if (/requires a newer version of codex/.test(text)) {
+    return present(
+      "update",
+      "EZ Coder needs an update",
+      "Update the app, or choose another model."
+    );
+  }
+  if (/insufficient.*(?:balance|credits?)|(?:balance|credits?).*(?:insufficient|exhausted|depleted)|credit balance is too low|payment_required/.test(
+    text
+  )) {
+    return present(
+      "billing",
+      `${provider} credits are unavailable`,
+      "Check your balance and billing, or use another provider."
+    );
+  }
+  if (/usage_not_included|does not yet include access|not supported when using codex with a chatgpt account|(?:model[^\n]*(?:not found|not available|does not exist))|model_not_found/.test(
+    text
+  )) {
+    return present(
+      "model_access",
+      "This model isn\u2019t available to this account",
+      "Choose another model available to your account."
+    );
+  }
+  if (/insufficient_quota|exceeded your current quota|billing.?limit|spend.?limit|quota.?exceeded/.test(
+    text
+  )) {
+    return present(
+      "quota",
+      `${provider} quota is unavailable`,
+      "Check your plan or billing, or use another provider."
+    );
+  }
+  if (/^rate_limit_exceeded$/i.test(code)) {
+    return present(
+      "rate_limit",
+      `${provider} is limiting requests`,
+      "Wait a moment before trying again."
+    );
+  }
+  if (/usage limit reached|usage_limit_reached/.test(text)) {
+    return present(
+      "usage_limit",
+      `${provider} usage limit reached`,
+      "Wait for the reset, or use another provider."
+    );
+  }
+  if (base.source === "network") {
+    return present(
+      "network",
+      "Couldn\u2019t reach the provider",
+      "Check your connection before trying again."
+    );
+  }
+  if (base.source === "auth" || base.statusCode === 401) {
+    return present(
+      "auth",
+      `${provider} sign-in needs attention`,
+      "Reconnect your account in provider settings."
+    );
+  }
+  if (base.statusCode === 413 || /context[_ ](?:length|window)|maximum context|request_too_large|prompt is too long/.test(text)) {
+    return present(
+      "context",
+      "This conversation is too large",
+      "Compact the conversation or send a smaller request."
+    );
+  }
+  if (base.statusCode === 429 || /rate_limit|rate limit|too many requests/.test(text)) {
+    return present(
+      "rate_limit",
+      `${provider} is limiting requests`,
+      "Wait a moment before trying again."
+    );
+  }
+  if (base.statusCode === 403) {
+    return present(
+      "model_access",
+      "This account can\u2019t use this request",
+      "Check account access or choose another model."
+    );
+  }
+  if (error instanceof ProviderError) {
+    if (base.statusCode != null && base.statusCode >= 500) {
+      return present(
+        "provider",
+        `${provider} couldn\u2019t complete the request`,
+        "Try again later. Check details if it keeps happening."
+      );
+    }
+    return present(
+      "provider",
+      `${provider} didn\u2019t accept the request`,
+      "Check the details before trying again."
+    );
+  }
+  return present("unknown", "Something went wrong", "Open details to see what was reported.");
+}
+function providerLabel(provider) {
+  switch (provider) {
+    case "openai":
+      return "OpenAI";
+    case "anthropic":
+      return "Anthropic";
+    case "gemini":
+      return "Gemini";
+    case "xai":
+      return "xAI";
+    case "local":
+      return "The local server";
+    default:
+      return "The provider";
+  }
+}
+
 // src/error-classification.ts
 var CONTEXT_OVERFLOW_PATTERNS = [
   /context_length_exceeded/i,
@@ -4812,6 +4982,7 @@ function registerPalsuProvider(config) {
   classifyProviderError,
   dropInvalidToolCalls,
   environmentSecrets,
+  formatChatError,
   formatError,
   formatErrorForDisplay,
   hasLoneSurrogate,
@@ -4837,6 +5008,7 @@ function registerPalsuProvider(config) {
   toAnthropicMessages,
   toOpenAIMessages,
   toWellFormedText,
-  toolCallNameRuleFor
+  toolCallNameRuleFor,
+  usesResponsesLite
 });
 //# sourceMappingURL=index.cjs.map