@prestyj/ai 5.16.2 → 5.19.0

package/dist/index.js

@@ -505,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",
@@ -1007,13 +1109,11 @@ function toOpenAIMessages(messages, options) {
       const parts = typeof msg.content === "string" ? msg.content : void 0;
       const toolCalls = typeof msg.content !== "string" ? msg.content.filter(
         (p) => p.type === "tool_call"
-      ).map(
-        (tc) => ({
-          id: remapToolCallId(tc.id, idMap),
-          type: "function",
-          function: { name: tc.name, arguments: JSON.stringify(tc.args) }
-        })
-      ) : void 0;
+      ).map((tc) => ({
+        id: remapToolCallId(tc.id, idMap),
+        type: "function",
+        function: { name: tc.name, arguments: JSON.stringify(tc.args) }
+      })) : void 0;
       const textParts = typeof msg.content !== "string" ? msg.content.filter((p) => p.type === "text").map((p) => p.text).join("") : void 0;
       const thinkingParts = typeof msg.content !== "string" ? msg.content.filter((p) => p.type === "thinking").map((p) => p.text).join("") : void 0;
       const contentValue = parts || textParts || null;
@@ -1089,15 +1189,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";
@@ -1955,7 +2068,11 @@ async function* runStream2(options) {
     ...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 } } : {}
   };
@@ -2464,7 +2581,7 @@ function toCodexToolChoice(choice, tools) {
 function streamOpenAICodex(options) {
   return new StreamResult(runStream3(options), options.signal);
 }
-async function* runStream3(options) {
+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);
@@ -2534,6 +2651,20 @@ async function* runStream3(options) {
     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;
@@ -2913,13 +3044,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 {};