@jaypie/llm 1.2.40 → 1.2.41

package/dist/cjs/operate/OperateLoop.d.ts

@@ -34,6 +34,12 @@ export declare class OperateLoop {
     private createContext;
     private buildInitialRequest;
     private executeOneTurn;
+    /**
+     * 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.
+     */
+    private applyFormatArrayDefaults;
     /**
      * Sync the current input state from the updated provider request.
      * This is necessary because appendToolResult modifies the provider-specific request,

package/dist/cjs/util/fillFormatArrays.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+import { JsonObject, NaturalSchema } from "@jaypie/types";
+type Format = JsonObject | NaturalSchema | z.ZodType;
+/**
+ * Ensure every array field declared in `format` is present in `content` as an
+ * array. A declared `format` is a schema contract: an empty list should surface
+ * as `[]`, not be dropped from the response. Some providers/models omit empty
+ * array fields entirely, leaving consumers to read `.length` on `undefined`.
+ *
+ * Only mutates a (cloned) structured object; strings and non-objects pass
+ * through untouched.
+ */
+export declare function fillFormatArrays({ content, format, }: {
+    content: JsonObject;
+    format: Format;
+}): JsonObject;
+export {};

package/dist/cjs/util/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./determineModelProvider.js";
 export * from "./extractReasoning.js";
+export * from "./fillFormatArrays.js";
 export * from "./formatOperateInput.js";
 export * from "./formatOperateMessage.js";
 export * from "./jsonSchemaToOpenApi3.js";

package/dist/esm/index.js

@@ -572,6 +572,154 @@ function extractReasoning(history) {
     return reasoningTexts;
 }
 
+function naturalZodSchema(definition) {
+    if (Array.isArray(definition)) {
+        if (definition.length === 0) {
+            // Handle empty array - accept any[]
+            return z.array(z.any());
+        }
+        else if (definition.length === 1) {
+            // Handle array types
+            const itemType = definition[0];
+            switch (itemType) {
+                case String:
+                    return z.array(z.string());
+                case Number:
+                    return z.array(z.number());
+                case Boolean:
+                    return z.array(z.boolean());
+                default:
+                    if (typeof itemType === "object") {
+                        // Handle array of objects
+                        return z.array(naturalZodSchema(itemType));
+                    }
+                    // Handle enum arrays
+                    return z.enum(definition);
+            }
+        }
+        else {
+            // Handle enum arrays
+            return z.enum(definition);
+        }
+    }
+    else if (definition && typeof definition === "object") {
+        if (Object.keys(definition).length === 0) {
+            // Handle empty object - accept any key-value pairs
+            return z.record(z.string(), z.any());
+        }
+        else {
+            // Handle object with properties
+            const schemaShape = {};
+            for (const [key, value] of Object.entries(definition)) {
+                schemaShape[key] = naturalZodSchema(value);
+            }
+            return z.object(schemaShape);
+        }
+    }
+    else {
+        switch (definition) {
+            case String:
+                return z.string();
+            case Number:
+                return z.number();
+            case Boolean:
+                return z.boolean();
+            case Object:
+                return z.record(z.string(), z.any());
+            case Array:
+                return z.array(z.any());
+            default:
+                throw new Error(`Unsupported type: ${definition}`);
+        }
+    }
+}
+
+//
+//
+// 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 z.ZodType) {
+        return z.toJSONSchema(format);
+    }
+    if (isPlainObject(format) && format.type === "json_schema") {
+        const clone = structuredClone(format);
+        clone.type = "object";
+        return clone;
+    }
+    try {
+        return z.toJSONSchema(naturalZodSchema(format));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Walk a JSON Schema alongside a parsed value, filling any declared array field
+ * that is absent (`undefined`/`null`) with `[]`. Recurses into object
+ * properties and array items so nested declared arrays are also backfilled.
+ */
+function fillFromSchema(schema, value) {
+    if (!isPlainObject(schema)) {
+        return value;
+    }
+    const type = schema.type;
+    const isArray = type === "array" || (type === undefined && "items" in schema);
+    if (isArray) {
+        if (value === undefined || value === null) {
+            return [];
+        }
+        const items = schema.items;
+        if (Array.isArray(value) && isPlainObject(items)) {
+            return value.map((entry) => fillFromSchema(items, entry));
+        }
+        return value;
+    }
+    const isObject = type === "object" || (type === undefined && "properties" in schema);
+    if (isObject) {
+        if (!isPlainObject(value)) {
+            return value;
+        }
+        const properties = schema.properties;
+        if (isPlainObject(properties)) {
+            for (const [key, propSchema] of Object.entries(properties)) {
+                value[key] = fillFromSchema(propSchema, value[key]);
+            }
+        }
+        return value;
+    }
+    return value;
+}
+//
+//
+// Main
+//
+/**
+ * Ensure every array field declared in `format` is present in `content` as an
+ * array. A declared `format` is a schema contract: an empty list should surface
+ * as `[]`, not be dropped from the response. Some providers/models omit empty
+ * array fields entirely, leaving consumers to read `.length` on `undefined`.
+ *
+ * Only mutates a (cloned) structured object; strings and non-objects pass
+ * through untouched.
+ */
+function fillFormatArrays({ content, format, }) {
+    const schema = formatToJsonSchema(format);
+    if (!schema) {
+        return content;
+    }
+    return fillFromSchema(schema, structuredClone(content));
+}
+
 /**
  * Converts a string to a standardized LlmInputMessage
  * @param input - String to format
@@ -699,68 +847,6 @@ function maxTurnsFromOptions(options) {
     return 1;
 }
 
-function naturalZodSchema(definition) {
-    if (Array.isArray(definition)) {
-        if (definition.length === 0) {
-            // Handle empty array - accept any[]
-            return z.array(z.any());
-        }
-        else if (definition.length === 1) {
-            // Handle array types
-            const itemType = definition[0];
-            switch (itemType) {
-                case String:
-                    return z.array(z.string());
-                case Number:
-                    return z.array(z.number());
-                case Boolean:
-                    return z.array(z.boolean());
-                default:
-                    if (typeof itemType === "object") {
-                        // Handle array of objects
-                        return z.array(naturalZodSchema(itemType));
-                    }
-                    // Handle enum arrays
-                    return z.enum(definition);
-            }
-        }
-        else {
-            // Handle enum arrays
-            return z.enum(definition);
-        }
-    }
-    else if (definition && typeof definition === "object") {
-        if (Object.keys(definition).length === 0) {
-            // Handle empty object - accept any key-value pairs
-            return z.record(z.string(), z.any());
-        }
-        else {
-            // Handle object with properties
-            const schemaShape = {};
-            for (const [key, value] of Object.entries(definition)) {
-                schemaShape[key] = naturalZodSchema(value);
-            }
-            return z.object(schemaShape);
-        }
-    }
-    else {
-        switch (definition) {
-            case String:
-                return z.string();
-            case Number:
-                return z.number();
-            case Boolean:
-                return z.boolean();
-            case Object:
-                return z.record(z.string(), z.any());
-            case Array:
-                return z.array(z.any());
-            default:
-                throw new Error(`Unsupported type: ${definition}`);
-        }
-    }
-}
-
 //
 // Constants
 //
@@ -6089,7 +6175,7 @@ class OperateLoop {
         if (this.adapter.hasStructuredOutput(response)) {
             const structuredOutput = this.adapter.extractStructuredOutput(response);
             if (structuredOutput) {
-                state.responseBuilder.setContent(structuredOutput);
+                state.responseBuilder.setContent(this.applyFormatArrayDefaults(structuredOutput, options));
                 state.responseBuilder.complete();
                 return false; // Stop loop
             }
@@ -6214,7 +6300,7 @@ class OperateLoop {
             }
         }
         // No tool calls or no toolkit - we're done
-        state.responseBuilder.setContent(parsed.content);
+        state.responseBuilder.setContent(this.applyFormatArrayDefaults(parsed.content, options));
         state.responseBuilder.complete();
         // Add final history items
         const historyItems = this.adapter.responseToHistoryItems(parsed.raw);
@@ -6223,6 +6309,20 @@ 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.
+     */
+    applyFormatArrayDefaults(content, options) {
+        if (!options.format) {
+            return content;
+        }
+        if (typeof content !== "object" || content === null) {
+            return content;
+        }
+        return fillFormatArrays({ content, format: options.format });
+    }
     /**
      * Sync the current input state from the updated provider request.
      * This is necessary because appendToolResult modifies the provider-specific request,