@prestyj/ai 5.16.1 → 5.17.0

package/dist/index.js

@@ -235,6 +235,9 @@ function providerGuidance(provider, message, statusCode) {
   if (statusCode === 401 || lower.includes("unauthorized") || lower.includes("invalid api key")) {
     return `Authentication failed with ${name}. Re-authenticate to refresh your credentials.`;
   }
+  if (lower.includes("requires a newer version")) {
+    return `${name} needs a newer EZ Coder to serve this model. Update EZ Coder to the latest version and retry, or switch to another ${name} model via the model selector.`;
+  }
   if (lower.includes("overloaded") || lower.includes("engine_overloaded")) {
     return `${name}'s servers are overloaded right now. Retry in a moment \u2014 not a EZ Coder issue.`;
   }
@@ -502,6 +505,108 @@ function normalizeRootForAnthropic(schema) {
   return out;
 }
 
+// src/utils/strict-tool-schema.ts
+var UnsupportedStrictSchemaError = class extends Error {
+};
+var UNSUPPORTED_KEYS = [
+  "$ref",
+  "$defs",
+  "definitions",
+  "allOf",
+  "oneOf",
+  "patternProperties",
+  "dependentSchemas",
+  "dependencies",
+  "unevaluatedProperties",
+  "propertyNames",
+  "contains",
+  "prefixItems",
+  "not",
+  "if",
+  "then",
+  "else"
+];
+function isSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStructured(value) {
+  if (!isSchemaObject(value)) return false;
+  const types = typeof value.type === "string" ? [value.type] : Array.isArray(value.type) ? value.type : [];
+  return types.includes("object") || types.includes("array") || value.properties !== void 0 || value.items !== void 0;
+}
+function allowsNull(schema) {
+  if (!isSchemaObject(schema)) return false;
+  if (schema.type === "null" || Array.isArray(schema.type) && schema.type.includes("null"))
+    return true;
+  if (schema.const === null || Array.isArray(schema.enum) && schema.enum.includes(null))
+    return true;
+  return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => allowsNull(variant));
+}
+function makeNodeStrict(schema) {
+  if (!isSchemaObject(schema)) {
+    throw new UnsupportedStrictSchemaError("boolean schemas are unsupported");
+  }
+  for (const key of UNSUPPORTED_KEYS) {
+    if (schema[key] !== void 0) {
+      throw new UnsupportedStrictSchemaError(`${key} schemas are unsupported`);
+    }
+  }
+  if (schema.anyOf !== void 0) {
+    if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
+      throw new UnsupportedStrictSchemaError("anyOf must contain at least one schema");
+    }
+    for (const variant of schema.anyOf) {
+      if (isStructured(variant)) {
+        throw new UnsupportedStrictSchemaError("object and array unions are unsupported");
+      }
+      makeNodeStrict(variant);
+    }
+  }
+  if (schema.items !== void 0) {
+    if (Array.isArray(schema.items)) {
+      throw new UnsupportedStrictSchemaError("tuple schemas are unsupported");
+    }
+    makeNodeStrict(schema.items);
+  }
+  const isObjectSchema = schema.type === "object";
+  if (schema.properties !== void 0 && !isObjectSchema) {
+    throw new UnsupportedStrictSchemaError("properties require type object");
+  }
+  if (!isObjectSchema) return;
+  if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+    throw new UnsupportedStrictSchemaError(
+      "schema-valued or true additionalProperties is unsupported"
+    );
+  }
+  if (schema.properties !== void 0 && !isSchemaObject(schema.properties)) {
+    throw new UnsupportedStrictSchemaError("object properties must be a schema map");
+  }
+  const properties = schema.properties ?? {};
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  for (const [key, property] of Object.entries(properties)) {
+    makeNodeStrict(property);
+    if (!required.has(key) && !allowsNull(property)) {
+      properties[key] = { anyOf: [property, { type: "null" }] };
+    }
+  }
+  schema.required = Object.keys(properties);
+  schema.additionalProperties = false;
+}
+function supportsStrictToolSampling(provider) {
+  return provider === "openai";
+}
+function makeStrictToolSchema(schema) {
+  const cloned = structuredClone(schema);
+  if (!isSchemaObject(cloned)) {
+    throw new UnsupportedStrictSchemaError("root schema must be an object");
+  }
+  makeNodeStrict(cloned);
+  if (cloned.type !== "object") {
+    throw new UnsupportedStrictSchemaError("root schema must have type object");
+  }
+  return cloned;
+}
+
 // src/providers/reasoning-field.ts
 var REASONING_FIELD_ALIASES = [
   "reasoning_content",
@@ -982,7 +1087,7 @@ function toOpenAIMessages(messages, options) {
             (part) => {
               if (part.type === "text") return { type: "text", text: part.text };
               if (part.type === "video") {
-                const videoUrl = part.fileId ? { url: `ms://${part.fileId}`, id: part.fileId } : { url: `data:${part.mediaType};base64,${part.data}` };
+                const videoUrl = options?.provider === "moonshot" && part.fileId ? { url: `ms://${part.fileId}`, id: part.fileId } : { url: `data:${part.mediaType};base64,${part.data}` };
                 return {
                   type: "video_url",
                   video_url: videoUrl
@@ -1086,15 +1191,28 @@ function toOpenAIMessages(messages, options) {
   }
   return out;
 }
-function toOpenAITools(tools) {
-  return tools.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: resolveToolSchema(tool)
+function toOpenAITools(tools, opts) {
+  return tools.map((tool) => {
+    let parameters = resolveToolSchema(tool);
+    let strict;
+    if (opts?.strict) {
+      try {
+        parameters = makeStrictToolSchema(parameters);
+        strict = true;
+      } catch (error) {
+        if (!(error instanceof UnsupportedStrictSchemaError)) throw error;
+      }
     }
-  }));
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters,
+        ...strict ? { strict } : {}
+      }
+    };
+  });
 }
 function toOpenAIToolChoice(choice) {
   if (choice === "auto") return "auto";
@@ -1921,7 +2039,7 @@ async function* runStream2(options) {
   const k3Effort = options.thinking ? toKimiK3Effort(options.thinking) : void 0;
   const isKimiK27 = options.provider === "moonshot" && options.model.startsWith("kimi-k2.7-code");
   const hasFixedKimiSampling = isKimiK3 || isKimiK27;
-  const usesThinkingParam = options.provider === "glm" || options.provider === "moonshot" && !isKimiK3 && !isKimiK27 || options.provider === "xiaomi";
+  const usesThinkingParam = options.provider === "deepseek" || options.provider === "glm" || options.provider === "moonshot" && !isKimiK3 && !isKimiK27 || options.provider === "xiaomi";
   const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
   const downgradedMessages = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
   if (options.provider === "moonshot") {
@@ -1947,19 +2065,23 @@ async function* runStream2(options) {
     model: options.model,
     messages,
     stream: useStreaming,
-    ...options.maxTokens ? { max_completion_tokens: options.maxTokens } : {},
+    ...options.maxTokens ? options.provider === "deepseek" || options.provider === "glm" || options.provider === "moonshot" ? { max_tokens: options.maxTokens } : { max_completion_tokens: options.maxTokens } : {},
     ...effectiveTemp != null && !options.thinking && !hasFixedKimiSampling ? { temperature: effectiveTemp } : {},
     ...options.topP != null && !hasFixedKimiSampling ? { top_p: options.topP } : {},
     ...options.stop ? { stop: options.stop } : {},
     ...options.thinking && !usesThinkingParam && !isKimiK3 && !isKimiK27 && !isLocal ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking, options.model) } : {},
-    ...options.tools?.length ? { tools: toOpenAITools(options.tools) } : {},
+    ...options.tools?.length ? {
+      tools: toOpenAITools(options.tools, {
+        strict: supportsStrictToolSampling(options.provider)
+      })
+    } : {},
     ...options.toolChoice && options.tools?.length ? { tool_choice: toOpenAIToolChoice(options.toolChoice) } : {},
     ...useStreaming ? { stream_options: { include_usage: true } } : {}
   };
   if (options.provider === "openai" || options.provider === "moonshot") {
     const paramsAny = params;
     paramsAny.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ezcoder");
-    if (options.provider === "openai" && options.model.startsWith("gpt-5.6")) {
+    if (options.provider === "openai" && (options.model.startsWith("gpt-5.6") || options.model.startsWith("gpt-6"))) {
       paramsAny.prompt_cache_options = { mode: "implicit", ttl: "30m" };
     } else if (!isKimiK3 && (options.cacheRetention ?? "short") === "long") {
       paramsAny.prompt_cache_retention = "24h";
@@ -1970,6 +2092,9 @@ async function* runStream2(options) {
       options.thinking
     );
   }
+  if (options.provider === "sakana" && options.model === "fugu-ultra" && (options.thinking === "max" || options.thinking === "ultra")) {
+    params.reasoning_effort = "max";
+  }
   if (options.provider === "openai" && options.serviceTier) {
     params.service_tier = options.serviceTier;
   }
@@ -1986,7 +2111,9 @@ async function* runStream2(options) {
   if (usesThinkingParam) {
     if (options.thinking) {
       params.thinking = { type: "enabled" };
-      if (options.provider === "glm") {
+      if (options.provider === "deepseek") {
+        params.reasoning_effort = options.thinking === "low" ? "low" : options.thinking === "medium" || options.thinking === "high" ? "high" : "max";
+      } else if (options.provider === "glm") {
         params.reasoning_effort = toGlmReasoningEffort(
           options.thinking
         );
@@ -2381,7 +2508,7 @@ function extractRequestIdFromMessage(message) {
 
 // src/providers/openai-codex.ts
 var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
-var CODEX_CLIENT_VERSION = "0.144.1";
+var CODEX_CLIENT_VERSION = "0.153.4";
 var CODEX_REQUEST_COMPRESSION_MIN_BYTES = 16 * 1024;
 var zstdInitPromise;
 async function encodeCodexRequest(body) {
@@ -2427,7 +2554,7 @@ async function encodeCodexRequest(body) {
   }
 }
 function usesResponsesLite(model) {
-  return model.startsWith("gpt-5.6-");
+  return model.startsWith("gpt-5.6-") || model.startsWith("gpt-6-");
 }
 function outputTextKey(itemId, contentIndex) {
   return `${itemId ?? ""}:${contentIndex ?? 0}`;
@@ -2481,8 +2608,10 @@ async function* runStream3(options) {
     body.temperature = options.temperature;
   }
   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 === "ultra" ? "max" : options.thinking ?? "none",
+    effort: options.thinking === "ultra" ? "max" : options.thinking ?? (responsesLite ? "low" : "none"),
     summary: "auto",
     ...responsesLite ? { context: "all_turns" } : {}
   };
@@ -2527,14 +2656,10 @@ async function* runStream3(options) {
     const usageLimit = codexUsageLimitError(parsed.errorObj, response.status, requestId);
     if (usageLimit) throw usageLimit;
     let hint;
-    if (response.status === 400 && text.includes("not supported")) {
-      if (options.model === "gpt-5.5-pro") {
-        hint = "Use gpt-5.5 instead. OpenAI's Codex model catalog does not list gpt-5.5-pro.";
-      } else {
-        hint = "This model is not available through Codex for the authenticated account. Switch to a model listed for OpenAI Codex via the model selector, or check your Codex usage limits.";
-      }
+    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.";
     } else if (response.status === 404 && text.includes("does not exist")) {
-      hint = "This model is not in the current OpenAI Codex catalog for this account. Switch to gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, or gpt-5.5 via the model selector.";
+      hint = "This model is not in OpenAI's current catalog for your ChatGPT account. Switch to GPT-6 Astra, GPT-5.6 Sol, GPT-5.6 Terra, or GPT-5.6 Luna via the model selector.";
     }
     throw new ProviderError("openai", message, {
       statusCode: response.status,
@@ -2907,13 +3032,23 @@ function toCodexInput(messages, options) {
   return { system, input };
 }
 function toCodexTools(tools) {
-  return tools.map((tool) => ({
-    type: "function",
-    name: tool.name,
-    description: tool.description,
-    parameters: resolveToolSchema(tool),
-    strict: null
-  }));
+  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;
+    }
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters,
+      strict
+    };
+  });
 }
 function parseCodexErrorBody(text, statusCode) {
   if (!text) return {};
@@ -2974,6 +3109,8 @@ var CODE_ASSIST_SUPPORTED_MODELS = /* @__PURE__ */ new Set([
   "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",
@@ -2997,12 +3134,20 @@ var ACCOUNT_GATED_MODELS = /* @__PURE__ */ new Set([
   "gemini-3.5-flash",
   "gemini-3.1-pro-preview",
   "gemini-3.1-pro-preview-customtools",
-  "gemini-3.7-flash"
+  "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 ezcoder bug.`;
 }
-function accountGatedHint() {
+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.7 Flash, 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 \u2014 free/personal accounts usually can't call them. Switch to Gemini 3.1 Flash Lite (it works on this account) with /model, or sign in with a Code Assist Standard/Enterprise account that has preview access.`;
 }
 function formatErrorMessage(status, body, model) {
@@ -3328,7 +3473,7 @@ async function fetchCodeAssist(plan, options) {
       throw new ProviderError("gemini", message, {
         statusCode: response.status,
         ...resetsAt !== void 0 ? { resetsAt } : {},
-        ...accountGated ? { hint: accountGatedHint() } : {}
+        ...accountGated ? { hint: accountGatedHint(options.model) } : {}
       });
     }
     return response;