@kenkaiiii/gg-ai 5.57.0 → 5.57.2

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",
@@ -1089,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";
@@ -1954,7 +2069,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 } } : {}
   };
@@ -2909,13 +3028,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 {};