recursive-llm-ts 4.0.1 → 4.1.0

package/dist/rlm.d.ts

@@ -15,5 +15,6 @@ export declare class RLM {
         parallelExecution?: boolean;
     }): Promise<StructuredRLMResult<T>>;
     private zodToJsonSchema;
+    private escapeRegex;
     cleanup(): Promise<void>;
 }

package/dist/rlm.js

@@ -52,62 +52,349 @@ class RLM {
         });
     }
     zodToJsonSchema(schema) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const def = schema._def;
-        // Check for object type by presence of shape
-        if (def.shape) {
-            const shape = def.shape;
+        const defType = def.type;
+        // Handle wrapped types (optional, nullable, default, catch)
+        if (defType === 'optional' || defType === 'nullable' || defType === 'default' || defType === 'catch') {
+            const inner = this.zodToJsonSchema(def.innerType);
+            if (defType === 'nullable') {
+                return Object.assign(Object.assign({}, inner), { nullable: true });
+            }
+            return inner; // Optional/Default/Catch don't change the schema, just validation
+        }
+        // Handle effects (refine, transform, preprocess) - unwrap to inner type
+        if (defType === 'effects') {
+            return this.zodToJsonSchema(def.schema);
+        }
+        // Handle pipeline (pipe) - use the output schema
+        if (defType === 'pipeline') {
+            return this.zodToJsonSchema(def.out);
+        }
+        // Handle lazy schemas - unwrap the getter
+        if (defType === 'lazy') {
+            // For lazy schemas, we need to call the getter to get the actual schema
+            try {
+                const actualSchema = def.getter();
+                return this.zodToJsonSchema(actualSchema);
+            }
+            catch (e) {
+                // If lazy getter fails, fall back to generic object
+                return { type: 'object' };
+            }
+        }
+        // Handle branded types - unwrap to base type
+        if (defType === 'branded') {
+            return this.zodToJsonSchema(def.type);
+        }
+        // Handle readonly - pass through
+        if (defType === 'readonly') {
+            return this.zodToJsonSchema(def.innerType);
+        }
+        // Handle literals
+        if (defType === 'literal') {
+            // Literals in this Zod version use 'values' array
+            if (def.values && def.values.length > 0) {
+                const value = def.values[0];
+                const valueType = typeof value;
+                return {
+                    type: valueType === 'object' ? 'string' : valueType,
+                    enum: [value]
+                };
+            }
+            // Fallback for other literal formats
+            const value = def.value;
+            if (value !== undefined) {
+                const valueType = typeof value;
+                return {
+                    type: valueType === 'object' ? 'string' : valueType,
+                    enum: [value]
+                };
+            }
+        }
+        // Handle unions
+        if (defType === 'union' || defType === 'discriminatedUnion') {
+            const options = def.options || Array.from(((_a = def.optionsMap) === null || _a === void 0 ? void 0 : _a.values()) || []);
+            if (options.length > 0) {
+                return {
+                    anyOf: options.map((opt) => this.zodToJsonSchema(opt))
+                };
+            }
+        }
+        // Handle intersections
+        if (defType === 'intersection') {
+            return {
+                allOf: [
+                    this.zodToJsonSchema(def.left),
+                    this.zodToJsonSchema(def.right)
+                ]
+            };
+        }
+        // Handle object type
+        if (def.shape || defType === 'object') {
+            const shape = def.shape || {};
             const properties = {};
             const required = [];
             for (const [key, value] of Object.entries(shape)) {
                 properties[key] = this.zodToJsonSchema(value);
-                if (!value.isOptional()) {
+                // A field is required if it's not optional and doesn't have a default
+                const valueDef = value._def;
+                const isOptional = (_d = (_c = (_b = value).isOptional) === null || _c === void 0 ? void 0 : _c.call(_b)) !== null && _d !== void 0 ? _d : false;
+                const hasDefault = (valueDef === null || valueDef === void 0 ? void 0 : valueDef.type) === 'default';
+                if (!isOptional && !hasDefault) {
                     required.push(key);
                 }
             }
-            return {
+            const result = {
                 type: 'object',
-                properties,
-                required: required.length > 0 ? required : undefined
+                properties
             };
+            if (required.length > 0) {
+                result.required = required;
+            }
+            // Handle unknown keys via catchall
+            if (def.catchall) {
+                const catchallType = (_e = def.catchall._def) === null || _e === void 0 ? void 0 : _e.type;
+                if (catchallType === 'unknown') {
+                    result.additionalProperties = true;
+                }
+                else if (catchallType === 'never') {
+                    result.additionalProperties = false;
+                }
+            }
+            // Also check legacy unknownKeys
+            if (def.unknownKeys === 'passthrough') {
+                result.additionalProperties = true;
+            }
+            else if (def.unknownKeys === 'strict') {
+                result.additionalProperties = false;
+            }
+            return result;
         }
-        // Check for array type - Zod arrays have an 'element' property (or 'type' in older versions)
-        if (def.type === 'array' && (def.element || def.type)) {
-            const itemSchema = def.element || def.type;
-            return {
+        // Handle array type
+        if (defType === 'array') {
+            const itemSchema = def.element;
+            const result = {
                 type: 'array',
                 items: this.zodToJsonSchema(itemSchema)
             };
+            // Handle array length constraints from checks
+            if (def.checks && Array.isArray(def.checks)) {
+                for (const check of def.checks) {
+                    const checkDef = ((_f = check._zod) === null || _f === void 0 ? void 0 : _f.def) || check.def || check;
+                    switch (checkDef.check) {
+                        case 'min_length':
+                            result.minItems = checkDef.minimum || checkDef.value;
+                            break;
+                        case 'max_length':
+                            result.maxItems = checkDef.maximum || checkDef.value;
+                            break;
+                        case 'exact_length':
+                            result.minItems = checkDef.value;
+                            result.maxItems = checkDef.value;
+                            break;
+                    }
+                }
+            }
+            // Also check direct properties (legacy)
+            if (def.minLength)
+                result.minItems = def.minLength.value || def.minLength;
+            if (def.maxLength)
+                result.maxItems = def.maxLength.value || def.maxLength;
+            if (def.exactLength) {
+                const exact = def.exactLength.value || def.exactLength;
+                result.minItems = exact;
+                result.maxItems = exact;
+            }
+            return result;
         }
-        // Check for enum - Zod enums have a 'type' of 'enum' and 'entries' object
-        if (def.type === 'enum' && def.entries) {
+        // Handle tuple
+        if (defType === 'tuple') {
+            const items = ((_g = def.items) === null || _g === void 0 ? void 0 : _g.map((item) => this.zodToJsonSchema(item))) || [];
+            const result = {
+                type: 'array',
+                prefixItems: items,
+                minItems: items.length,
+                maxItems: def.rest ? undefined : items.length
+            };
+            // Handle rest element
+            if (def.rest) {
+                result.items = this.zodToJsonSchema(def.rest);
+            }
+            else {
+                result.items = false; // No additional items allowed
+            }
+            return result;
+        }
+        // Handle set - convert to array
+        if (defType === 'set') {
             return {
-                type: 'string',
-                enum: Object.keys(def.entries)
+                type: 'array',
+                uniqueItems: true,
+                items: def.valueType ? this.zodToJsonSchema(def.valueType) : {}
             };
         }
-        // Check for legacy enum with values array
-        if (def.values && Array.isArray(def.values)) {
+        // Handle map - convert to object
+        if (defType === 'map') {
             return {
-                type: 'string',
-                enum: def.values
+                type: 'object',
+                additionalProperties: def.valueType ? this.zodToJsonSchema(def.valueType) : true
             };
         }
-        // Check for optional/nullable
-        if (def.innerType) {
-            const inner = this.zodToJsonSchema(def.innerType);
-            return def.typeName === 'ZodNullable' ? Object.assign(Object.assign({}, inner), { nullable: true }) : inner;
+        // Handle record
+        if (defType === 'record') {
+            return {
+                type: 'object',
+                additionalProperties: def.valueType ? this.zodToJsonSchema(def.valueType) : true
+            };
         }
-        // Detect primitive types
-        const defType = def.type;
-        if (defType === 'string')
-            return { type: 'string' };
-        if (defType === 'number')
-            return { type: 'number' };
-        if (defType === 'boolean')
+        // Handle enum
+        if (defType === 'enum' || defType === 'nativeEnum') {
+            if (def.values && Array.isArray(def.values)) {
+                return { type: 'string', enum: def.values };
+            }
+            if (def.entries) {
+                return { type: 'string', enum: Object.keys(def.entries) };
+            }
+        }
+        // Handle string with constraints
+        if (defType === 'string') {
+            const result = { type: 'string' };
+            if (def.checks && Array.isArray(def.checks)) {
+                for (const check of def.checks) {
+                    // Access the actual check data via _zod.def
+                    const checkDef = ((_h = check._zod) === null || _h === void 0 ? void 0 : _h.def) || check.def || check;
+                    switch (checkDef.check) {
+                        case 'min_length':
+                            result.minLength = checkDef.minimum || checkDef.value;
+                            break;
+                        case 'max_length':
+                            result.maxLength = checkDef.maximum || checkDef.value;
+                            break;
+                        case 'length_equals':
+                            result.minLength = checkDef.length;
+                            result.maxLength = checkDef.length;
+                            break;
+                        case 'string_format':
+                            switch (checkDef.format) {
+                                case 'email':
+                                    result.format = 'email';
+                                    break;
+                                case 'url':
+                                    result.format = 'uri';
+                                    break;
+                                case 'uuid':
+                                    result.format = 'uuid';
+                                    break;
+                                case 'regex':
+                                    if (checkDef.pattern) {
+                                        result.pattern = checkDef.pattern.source || checkDef.pattern;
+                                    }
+                                    break;
+                            }
+                            break;
+                        case 'regex':
+                            result.pattern = ((_j = checkDef.pattern) === null || _j === void 0 ? void 0 : _j.source) || checkDef.pattern;
+                            break;
+                    }
+                    // Also check nested def for formats
+                    if (check.def && check.def.format) {
+                        switch (check.def.format) {
+                            case 'email':
+                                result.format = 'email';
+                                break;
+                            case 'url':
+                                result.format = 'uri';
+                                break;
+                            case 'uuid':
+                                result.format = 'uuid';
+                                break;
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+        // Handle number/bigint with constraints
+        if (defType === 'number' || defType === 'bigint') {
+            const result = { type: defType === 'bigint' ? 'integer' : 'number' };
+            if (def.checks && Array.isArray(def.checks)) {
+                for (const check of def.checks) {
+                    // Access the actual check data via _zod.def
+                    const checkDef = ((_k = check._zod) === null || _k === void 0 ? void 0 : _k.def) || check.def || check;
+                    switch (checkDef.check) {
+                        case 'number_format':
+                            if (checkDef.format === 'safeint') {
+                                result.type = 'integer';
+                            }
+                            break;
+                        case 'greater_than':
+                            result.minimum = checkDef.value;
+                            if (!checkDef.inclusive) {
+                                result.exclusiveMinimum = true;
+                            }
+                            break;
+                        case 'less_than':
+                            result.maximum = checkDef.value;
+                            if (!checkDef.inclusive) {
+                                result.exclusiveMaximum = true;
+                            }
+                            break;
+                        case 'multiple_of':
+                            result.multipleOf = checkDef.value;
+                            break;
+                    }
+                    // Also check direct properties (legacy support)
+                    if (check.isInt === true) {
+                        result.type = 'integer';
+                    }
+                }
+            }
+            return result;
+        }
+        // Handle boolean
+        if (defType === 'boolean') {
             return { type: 'boolean' };
+        }
+        // Handle date
+        if (defType === 'date') {
+            return { type: 'string', format: 'date-time' };
+        }
+        // Handle null
+        if (defType === 'null') {
+            return { type: 'null' };
+        }
+        // Handle undefined (not really JSON-serializable, but treat as null)
+        if (defType === 'undefined') {
+            return { type: 'null' };
+        }
+        // Handle void (same as undefined)
+        if (defType === 'void') {
+            return { type: 'null' };
+        }
+        // Handle any/unknown - no constraints
+        if (defType === 'any' || defType === 'unknown') {
+            return {}; // Empty schema accepts anything
+        }
+        // Handle never - impossible to satisfy
+        if (defType === 'never') {
+            return { not: {} }; // Schema that matches nothing
+        }
+        // Handle promise - unwrap to inner type
+        if (defType === 'promise') {
+            return this.zodToJsonSchema(def.innerType || def.type);
+        }
+        // Handle function - not JSON-serializable
+        if (defType === 'function') {
+            return { type: 'string', description: 'Function (not serializable)' };
+        }
         // Default fallback
+        console.warn(`Unknown Zod type: ${defType}, falling back to string`);
         return { type: 'string' };
     }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
     cleanup() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.bridge) {

package/go/internal/rlm/structured.go

@@ -235,27 +235,75 @@ func generateSchemaConstraints(schema *JSONSchema) string {
 	return ""
 }
 
-// generateFieldQuery creates a focused query for a specific field
+// generateFieldQuery creates a focused query for a specific field based on its schema
 func generateFieldQuery(fieldName string, schema *JSONSchema) string {
-	fieldQueries := map[string]string{
-		"sentiment":             "Analyze the overall sentiment of this conversation. Return a JSON object with: score (integer 1-5), confidence (number 0-1), and optional reasoning (string).",
-		"sentimentValue":        "What is the overall sentiment score (1-5) of this conversation?",
-		"sentimentExplanation":  "Explain in 2-3 sentences why the conversation has this sentiment score.",
-		"phrases":               "Extract key phrases that significantly impacted the sentiment, excluding neutral (3-value) phrases. For each phrase, include the sentiment value and the phrase itself (1 sentence).",
-		"keyMoments":            "Identify key moments in the conversation such as churn mentions, personnel changes, competitive mentions, etc. For each moment, provide the phrase and categorize the type.",
-	}
-
-	if query, exists := fieldQueries[fieldName]; exists {
-		return query
-	}
-
-	// For object types, provide more detailed instructions about required fields
-	if schema.Type == "object" && len(schema.Required) > 0 {
-		return fmt.Sprintf("Extract the %s from the conversation. Return a JSON object with these required fields: %s.", 
-			fieldName, strings.Join(schema.Required, ", "))
+	var queryParts []string
+	
+	// Start with field name
+	queryParts = append(queryParts, fmt.Sprintf("Extract the %s from the conversation.", fieldName))
+	
+	// Add type-specific instructions
+	switch schema.Type {
+	case "object":
+		if len(schema.Required) > 0 {
+			fieldDetails := make([]string, 0, len(schema.Required))
+			for _, reqField := range schema.Required {
+				if propSchema, exists := schema.Properties[reqField]; exists {
+					fieldDetails = append(fieldDetails, fmt.Sprintf("'%s' (%s)", reqField, propSchema.Type))
+				}
+			}
+			queryParts = append(queryParts, fmt.Sprintf("Return a JSON object with these REQUIRED fields: %s.", strings.Join(fieldDetails, ", ")))
+		} else {
+			queryParts = append(queryParts, "Return a JSON object.")
+		}
+		
+	case "array":
+		if schema.Items != nil {
+			if schema.Items.Type == "object" && schema.Items.Properties != nil {
+				// Build detailed description of array item structure
+				requiredFields := make([]string, 0)
+				optionalFields := make([]string, 0)
+				
+				for propName, propSchema := range schema.Items.Properties {
+					fieldDesc := fmt.Sprintf("'%s' (%s)", propName, propSchema.Type)
+					if contains(schema.Items.Required, propName) {
+						requiredFields = append(requiredFields, fieldDesc)
+					} else {
+						optionalFields = append(optionalFields, fieldDesc)
+					}
+				}
+				
+				var itemDesc []string
+				if len(requiredFields) > 0 {
+					itemDesc = append(itemDesc, fmt.Sprintf("REQUIRED fields: %s", strings.Join(requiredFields, ", ")))
+				}
+				if len(optionalFields) > 0 {
+					itemDesc = append(itemDesc, fmt.Sprintf("Optional fields: %s", strings.Join(optionalFields, ", ")))
+				}
+				
+				queryParts = append(queryParts, fmt.Sprintf("Return a JSON array where each item is an object with %s.", strings.Join(itemDesc, ". ")))
+			} else {
+				queryParts = append(queryParts, fmt.Sprintf("Return a JSON array of %s values.", schema.Items.Type))
+			}
+		} else {
+			queryParts = append(queryParts, "Return a JSON array.")
+		}
+		
+	case "string":
+		if schema.Enum != nil && len(schema.Enum) > 0 {
+			queryParts = append(queryParts, fmt.Sprintf("Return EXACTLY one of these values: %s (use exact strings).", strings.Join(schema.Enum, ", ")))
+		} else {
+			queryParts = append(queryParts, "Return a string value.")
+		}
+		
+	case "number":
+		queryParts = append(queryParts, "Return a numeric value.")
+		
+	case "boolean":
+		queryParts = append(queryParts, "Return a boolean value (true or false).")
 	}
-
-	return fmt.Sprintf("Extract the %s from the conversation.", fieldName)
+	
+	return strings.Join(queryParts, " ")
 }
 
 // parseAndValidateJSON extracts JSON from response and validates against schema  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recursive-llm-ts",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "TypeScript bridge for recursive-llm: Recursive Language Models for unbounded context processing with structured outputs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",