@jaypie/llm 1.3.1 → 1.3.3

package/dist/cjs/index.cjs

@@ -641,7 +641,7 @@ function naturalZodSchema(definition) {
 //
 // Helpers
 //
-function isPlainObject(value) {
+function isPlainObject$1(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -650,11 +650,11 @@ function isPlainObject(value) {
  * provider adapters perform in `formatOutputSchema`, but without any
  * provider-specific sanitization.
  */
-function formatToJsonSchema(format) {
+function formatToJsonSchema$1(format) {
     if (format instanceof v4.z.ZodType) {
         return v4.z.toJSONSchema(format);
     }
-    if (isPlainObject(format) && format.type === "json_schema") {
+    if (isPlainObject$1(format) && format.type === "json_schema") {
         const clone = structuredClone(format);
         clone.type = "object";
         return clone;
@@ -672,7 +672,7 @@ function formatToJsonSchema(format) {
  * properties and array items so nested declared arrays are also backfilled.
  */
 function fillFromSchema(schema, value) {
-    if (!isPlainObject(schema)) {
+    if (!isPlainObject$1(schema)) {
         return value;
     }
     const type = schema.type;
@@ -682,18 +682,18 @@ function fillFromSchema(schema, value) {
             return [];
         }
         const items = schema.items;
-        if (Array.isArray(value) && isPlainObject(items)) {
+        if (Array.isArray(value) && isPlainObject$1(items)) {
             return value.map((entry) => fillFromSchema(items, entry));
         }
         return value;
     }
     const isObject = type === "object" || (type === undefined && "properties" in schema);
     if (isObject) {
-        if (!isPlainObject(value)) {
+        if (!isPlainObject$1(value)) {
             return value;
         }
         const properties = schema.properties;
-        if (isPlainObject(properties)) {
+        if (isPlainObject$1(properties)) {
             for (const [key, propSchema] of Object.entries(properties)) {
                 value[key] = fillFromSchema(propSchema, value[key]);
             }
@@ -716,7 +716,7 @@ function fillFromSchema(schema, value) {
  * through untouched.
  */
 function fillFormatArrays({ content, format, }) {
-    const schema = formatToJsonSchema(format);
+    const schema = formatToJsonSchema$1(format);
     if (!schema) {
         return content;
     }
@@ -978,6 +978,116 @@ function random$1(defaultSeed) {
     return rngFn;
 }
 
+//
+//
+// Helpers
+//
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Convert a `format` declaration (Zod schema, NaturalSchema, or a JSON Schema
+ * JsonObject) into a plain JSON Schema we can walk. Mirrors the conversion the
+ * provider adapters perform in `formatOutputSchema`, but without any
+ * provider-specific sanitization.
+ */
+function formatToJsonSchema(format) {
+    if (format instanceof v4.z.ZodType) {
+        return v4.z.toJSONSchema(format);
+    }
+    if (isPlainObject(format) && format.type === "json_schema") {
+        const clone = structuredClone(format);
+        clone.type = "object";
+        return clone;
+    }
+    try {
+        return v4.z.toJSONSchema(naturalZodSchema(format));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Strip a single pair of surrounding double quotes from a key, if present.
+ * `"Merchant Request"` -> `Merchant Request`; `Confidence` -> `Confidence`.
+ */
+function dequoteKey(key) {
+    if (key.length >= 2 && key.startsWith('"') && key.endsWith('"')) {
+        return key.slice(1, -1);
+    }
+    return key;
+}
+/**
+ * Walk a JSON Schema alongside a parsed value, renaming any object key whose
+ * de-quoted form matches a declared property name. Recurses into declared
+ * object properties and array items so nested corrupted keys are also repaired.
+ */
+function repairFromSchema(schema, value) {
+    if (!isPlainObject(schema)) {
+        return value;
+    }
+    const type = schema.type;
+    const isArray = type === "array" || (type === undefined && "items" in schema);
+    if (isArray) {
+        const items = schema.items;
+        if (Array.isArray(value) && isPlainObject(items)) {
+            return value.map((entry) => repairFromSchema(items, entry));
+        }
+        return value;
+    }
+    const isObject = type === "object" || (type === undefined && "properties" in schema);
+    if (isObject && isPlainObject(value)) {
+        const properties = schema.properties;
+        if (isPlainObject(properties)) {
+            const declared = new Set(Object.keys(properties));
+            // Repair keys: rename a quote-wrapped key to its declared form, unless
+            // the correct key is already present (then drop the corrupted duplicate).
+            for (const key of Object.keys(value)) {
+                if (declared.has(key)) {
+                    continue;
+                }
+                const repaired = dequoteKey(key);
+                if (repaired !== key && declared.has(repaired)) {
+                    if (!(repaired in value)) {
+                        value[repaired] = value[key];
+                    }
+                    delete value[key];
+                }
+            }
+            // Recurse into declared properties now that keys are aligned.
+            for (const [key, propSchema] of Object.entries(properties)) {
+                if (key in value) {
+                    value[key] = repairFromSchema(propSchema, value[key]);
+                }
+            }
+        }
+        return value;
+    }
+    return value;
+}
+//
+//
+// Main
+//
+/**
+ * Repair structured-output keys that a provider/model corrupted by wrapping
+ * them in literal double quotes (observed on OpenAI for multi-word `format`
+ * keys: `Merchant Request` returned as `"Merchant Request"`). A declared
+ * `format` is a schema contract: returned keys should match the declared names
+ * exactly. Any returned key whose de-quoted form matches a declared key is
+ * renamed back to the declared key.
+ *
+ * Only mutates a (cloned) structured object; strings and non-objects pass
+ * through untouched.
+ */
+function repairFormatKeys({ content, format, }) {
+    const schema = formatToJsonSchema(format);
+    if (!schema) {
+        return content;
+    }
+    return repairFromSchema(schema, structuredClone(content));
+}
+
 /**
  * Helper function to safely call a function that might throw
  * @param fn Function to call safely
@@ -3547,7 +3657,16 @@ class OpenAiAdapter extends BaseProviderAdapter {
             ? schema
             : naturalZodSchema(schema);
         const responseFormat = zod.zodResponseFormat(zodSchema, "response");
-        const jsonSchema = v4.z.toJSONSchema(zodSchema);
+        // 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;
         // OpenAI requires additionalProperties to be false on all objects
         const checks = [jsonSchema];
         while (checks.length > 0) {
@@ -6313,9 +6432,12 @@ class OperateLoop {
         return false; // Stop loop
     }
     /**
-     * Backfill declared array fields when a `format` is supplied. A declared
-     * `format` is a schema contract: an empty array field should surface as `[]`
-     * rather than be dropped by a provider/model that omits empty lists.
+     * Reconcile structured output against the declared `format` contract. A
+     * declared `format` is a schema contract: returned keys should match the
+     * declared names exactly and every declared array field should be present.
+     * First repairs keys a provider/model corrupted by wrapping them in literal
+     * double quotes (observed on OpenAI for multi-word keys), then backfills any
+     * declared array field a provider/model omitted, surfacing it as `[]`.
      */
     applyFormatArrayDefaults(content, options) {
         if (!options.format) {
@@ -6324,7 +6446,8 @@ class OperateLoop {
         if (typeof content !== "object" || content === null) {
             return content;
         }
-        return fillFormatArrays({ content, format: options.format });
+        const repaired = repairFormatKeys({ content, format: options.format });
+        return fillFormatArrays({ content: repaired, format: options.format });
     }
     /**
      * Sync the current input state from the updated provider request.