@jaypie/llm 1.3.4 → 1.3.5

package/dist/cjs/index.cjs

@@ -768,6 +768,119 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
+// Keywords a JSON Schema object node can carry that Natural Schema has no
+// representation for. Anything present here (or any other unrecognized key)
+// is dropped silently and logged, never thrown.
+const LOSSY_OBJECT_KEYWORDS = [
+    "$defs",
+    "$id",
+    "$ref",
+    "$schema",
+    "additionalProperties",
+    "const",
+    "default",
+    "description",
+    "format",
+    "maxLength",
+    "maximum",
+    "minLength",
+    "minimum",
+    "multipleOf",
+    "nullable",
+    "allOf",
+    "anyOf",
+    "oneOf",
+    "pattern",
+];
+const KNOWN_KEYWORDS = new Set([
+    "type",
+    "properties",
+    "required",
+    "items",
+    "enum",
+    ...LOSSY_OBJECT_KEYWORDS,
+]);
+/**
+ * Duck-type check for a bare JSON Schema object node: `{ type: "object", properties: {...} }`.
+ * Does not require the OpenAI-style `{ type: "json_schema", ... }` envelope.
+ */
+function isJsonSchema$1(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const schema = value;
+    return (schema.type === "object" &&
+        typeof schema.properties === "object" &&
+        schema.properties !== null &&
+        !Array.isArray(schema.properties));
+}
+/**
+ * Convert a Natural Schema to JSON Schema. Lossless: Natural Schema is a
+ * strict subset of what JSON Schema can express.
+ */
+function naturalSchemaToJsonSchema(schema) {
+    return v4.z.toJSONSchema(naturalZodSchema(schema));
+}
+function logDroppedKeywords(schema, path) {
+    for (const key of Object.keys(schema)) {
+        if (!KNOWN_KEYWORDS.has(key)) {
+            log$1.debug(`[jsonSchemaToNaturalSchema] Dropping unrecognized keyword "${key}" at "${path}"`);
+        }
+        else if (LOSSY_OBJECT_KEYWORDS.includes(key) &&
+            schema[key] !== undefined) {
+            log$1.debug(`[jsonSchemaToNaturalSchema] Dropping unsupported keyword "${key}" at "${path}"`);
+        }
+    }
+}
+function convertNode(schema, path) {
+    logDroppedKeywords(schema, path);
+    if (Array.isArray(schema.enum)) {
+        return schema.enum;
+    }
+    switch (schema.type) {
+        case "string":
+            return String;
+        case "number":
+        case "integer":
+            return Number;
+        case "boolean":
+            return Boolean;
+        case "array": {
+            const items = schema.items;
+            if (typeof items !== "object" || items === null || Array.isArray(items)) {
+                return Array;
+            }
+            return [convertNode(items, `${path}[]`)];
+        }
+        case "object": {
+            const properties = schema.properties;
+            if (!properties || Object.keys(properties).length === 0) {
+                return Object;
+            }
+            const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+            const result = {};
+            for (const [key, value] of Object.entries(properties)) {
+                if (!required.has(key)) {
+                    log$1.debug(`[jsonSchemaToNaturalSchema] Field "${path}.${key}" is optional; Natural Schema has no optional marker — treating as required`);
+                }
+                result[key] = convertNode(value, `${path}.${key}`);
+            }
+            return result;
+        }
+        default:
+            log$1.debug(`[jsonSchemaToNaturalSchema] Unsupported type "${String(schema.type)}" at "${path}"; defaulting to Object`);
+            return Object;
+    }
+}
+/**
+ * Convert a JSON Schema object node to Natural Schema. Lossy: constraints,
+ * descriptions, defaults, unions, and optionality have no Natural Schema
+ * representation. Dropped keywords are logged at debug level, never thrown.
+ */
+function jsonSchemaToNaturalSchema(schema) {
+    return convertNode(schema, "$");
+}
+
 /**
  * Converts a JSON Schema (Draft 2020-12) object to the OpenAPI 3.0 schema subset
  * that Gemini's `responseSchema` accepts. This constrains generation (not just validation)
@@ -1716,11 +1829,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object"; // Validator does not recognize "json_schema"
         }
@@ -2382,6 +2497,10 @@ class BedrockAdapter extends BaseProviderAdapter {
         }));
     }
     formatOutputSchema(schema) {
+        // Bare JSON Schema node: `{ type: "object", properties: {...} }`
+        if (isJsonSchema$1(schema)) {
+            return structuredClone(schema);
+        }
         const zodSchema = schema instanceof v4.z.ZodType
             ? schema
             : naturalZodSchema(schema);
@@ -2918,11 +3037,13 @@ class GoogleAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object";
         }
@@ -3889,21 +4010,35 @@ class OpenAiAdapter extends BaseProviderAdapter {
             schema.type === "json_schema") {
             return schema;
         }
-        // Convert NaturalSchema to Zod schema if needed
-        const zodSchema = schema instanceof v4.z.ZodType
-            ? schema
-            : naturalZodSchema(schema);
-        const responseFormat = zodResponseFormat(zodSchema, "response");
-        // Re-spread to drop zod v4's non-enumerable `~standard` Standard-Schema
-        // interop marker, then strip `$schema`: OpenAI's strict json_schema subset
-        // does not recognize the draft-2020-12 `$schema` keyword, and shipping it
-        // can leave strict structured-output enforcement silently disabled (the
-        // model then free-forms, omitting required fields and corrupting keys).
-        // Mirrors the OpenRouter adapter's sanitization.
-        const jsonSchema = {
-            ...v4.z.toJSONSchema(zodSchema),
-        };
-        delete jsonSchema.$schema;
+        // Bare JSON Schema node: `{ type: "object", properties: {...} }`
+        // Skip the zod round-trip and use it directly (still needs the
+        // additionalProperties + envelope treatment below).
+        let jsonSchema;
+        let name = "response";
+        let strict = true;
+        if (isJsonSchema$1(schema)) {
+            jsonSchema = { ...structuredClone(schema) };
+            delete jsonSchema.$schema;
+        }
+        else {
+            // Convert NaturalSchema to Zod schema if needed
+            const zodSchema = schema instanceof v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            const responseFormat = zodResponseFormat(zodSchema, "response");
+            // Re-spread to drop zod v4's non-enumerable `~standard` Standard-Schema
+            // interop marker, then strip `$schema`: OpenAI's strict json_schema subset
+            // does not recognize the draft-2020-12 `$schema` keyword, and shipping it
+            // can leave strict structured-output enforcement silently disabled (the
+            // model then free-forms, omitting required fields and corrupting keys).
+            // Mirrors the OpenRouter adapter's sanitization.
+            jsonSchema = {
+                ...v4.z.toJSONSchema(zodSchema),
+            };
+            delete jsonSchema.$schema;
+            name = responseFormat.json_schema.name;
+            strict = responseFormat.json_schema.strict;
+        }
         // OpenAI requires additionalProperties to be false on all objects
         const checks = [jsonSchema];
         while (checks.length > 0) {
@@ -3919,10 +4054,10 @@ class OpenAiAdapter extends BaseProviderAdapter {
             checks.shift();
         }
         return {
-            name: responseFormat.json_schema.name,
+            name,
             schema: jsonSchema,
-            strict: responseFormat.json_schema.strict,
-            type: responseFormat.type,
+            strict,
+            type: "json_schema",
         };
     }
     //
@@ -4564,11 +4699,13 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object"; // Normalize type
         }
@@ -9040,6 +9177,8 @@ exports.isLlmOperateInput = isLlmOperateInput;
 exports.isLlmOperateInputContent = isLlmOperateInputContent;
 exports.isLlmOperateInputFile = isLlmOperateInputFile;
 exports.isLlmOperateInputImage = isLlmOperateInputImage;
+exports.jsonSchemaToNaturalSchema = jsonSchemaToNaturalSchema;
+exports.naturalSchemaToJsonSchema = naturalSchemaToJsonSchema;
 exports.toolkit = toolkit;
 exports.tools = tools;
 //# sourceMappingURL=index.cjs.map