llm-fns 1.0.6 → 1.0.8

package/dist/createJsonSchemaLlmClient.d.ts

@@ -0,0 +1,29 @@
+import OpenAI from 'openai';
+import { PromptFunction, LlmPromptOptions, IsPromptCachedFunction } from "./createLlmClient.js";
+export type JsonSchemaLlmClientOptions = Omit<LlmPromptOptions, 'messages' | 'response_format'> & {
+    maxRetries?: number;
+    /**
+     * If true, passes `response_format: { type: 'json_object' }` to the model.
+     * If false, only includes the schema in the system prompt.
+     * Defaults to true.
+     */
+    useResponseFormat?: boolean;
+    /**
+     * A hook to process the parsed JSON data before it is validated.
+     * This can be used to merge partial results or perform other transformations.
+     * @param data The parsed JSON data from the LLM response.
+     * @returns The processed data to be validated.
+     */
+    beforeValidation?: (data: any) => any;
+};
+export interface CreateJsonSchemaLlmClientParams {
+    prompt: PromptFunction;
+    isPromptCached: IsPromptCachedFunction;
+    fallbackPrompt?: PromptFunction;
+    disableJsonFixer?: boolean;
+}
+export declare function createJsonSchemaLlmClient(params: CreateJsonSchemaLlmClientParams): {
+    promptJson: <T>(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], schema: Record<string, any>, validator: (data: any) => T, options?: JsonSchemaLlmClientOptions) => Promise<T>;
+    isPromptJsonCached: (messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], schema: Record<string, any>, options?: JsonSchemaLlmClientOptions) => Promise<boolean>;
+};
+export type JsonSchemaClient = ReturnType<typeof createJsonSchemaLlmClient>;

package/dist/createJsonSchemaLlmClient.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonSchemaLlmClient = createJsonSchemaLlmClient;
+const createLlmRetryClient_js_1 = require("./createLlmRetryClient.js");
+function createJsonSchemaLlmClient(params) {
+    const { prompt, isPromptCached, fallbackPrompt, disableJsonFixer = false } = params;
+    const llmRetryClient = (0, createLlmRetryClient_js_1.createLlmRetryClient)({ prompt, fallbackPrompt });
+    async function _tryToFixJson(brokenResponse, schemaJsonString, errorDetails, options) {
+        const fixupPrompt = `
+An attempt to generate a JSON object resulted in the following output, which is either not valid JSON or does not conform to the required schema.
+
+Your task is to act as a JSON fixer. Analyze the provided "BROKEN RESPONSE" and correct it to match the "REQUIRED JSON SCHEMA".
+
+- If the broken response contains all the necessary information to create a valid JSON object according to the schema, please provide the corrected, valid JSON object.
+- If the broken response is missing essential information, or is too garbled to be fixed, please respond with the exact string: "CANNOT_FIX".
+- Your response must be ONLY the corrected JSON object or the string "CANNOT_FIX". Do not include any other text, explanations, or markdown formatting.
+
+REQUIRED JSON SCHEMA:
+${schemaJsonString}
+
+ERROR DETAILS:
+${errorDetails}
+
+BROKEN RESPONSE:
+${brokenResponse}
+`;
+        const messages = [
+            { role: 'system', content: 'You are an expert at fixing malformed JSON data to match a specific schema.' },
+            { role: 'user', content: fixupPrompt }
+        ];
+        const useResponseFormat = options?.useResponseFormat ?? true;
+        const response_format = useResponseFormat
+            ? { type: 'json_object' }
+            : undefined;
+        const { maxRetries, useResponseFormat: _useResponseFormat, ...restOptions } = options || {};
+        const completion = await prompt({
+            messages,
+            response_format,
+            ...restOptions
+        });
+        const fixedResponse = completion.choices[0]?.message?.content;
+        if (fixedResponse && fixedResponse.trim() === 'CANNOT_FIX') {
+            return null;
+        }
+        return fixedResponse || null;
+    }
+    async function _parseOrFixJson(llmResponseString, schemaJsonString, options) {
+        let jsonDataToParse = llmResponseString.trim();
+        // Robust handling for responses wrapped in markdown code blocks
+        const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/;
+        const match = codeBlockRegex.exec(jsonDataToParse);
+        if (match && match[1]) {
+            jsonDataToParse = match[1].trim();
+        }
+        if (jsonDataToParse === "") {
+            throw new Error("LLM returned an empty string.");
+        }
+        try {
+            return JSON.parse(jsonDataToParse);
+        }
+        catch (parseError) {
+            if (disableJsonFixer) {
+                throw parseError; // re-throw original error
+            }
+            // Attempt a one-time fix before failing.
+            const errorDetails = `JSON Parse Error: ${parseError.message}`;
+            const fixedResponse = await _tryToFixJson(jsonDataToParse, schemaJsonString, errorDetails, options);
+            if (fixedResponse) {
+                try {
+                    return JSON.parse(fixedResponse);
+                }
+                catch (e) {
+                    // Fix-up failed, throw original error.
+                    throw parseError;
+                }
+            }
+            throw parseError; // if no fixed response
+        }
+    }
+    async function _validateOrFix(jsonData, validator, schemaJsonString, options) {
+        try {
+            if (options?.beforeValidation) {
+                jsonData = options.beforeValidation(jsonData);
+            }
+            return validator(jsonData);
+        }
+        catch (validationError) {
+            if (disableJsonFixer) {
+                throw validationError;
+            }
+            // Attempt a one-time fix for schema validation errors.
+            const errorDetails = `Schema Validation Error: ${validationError.message}`;
+            const fixedResponse = await _tryToFixJson(JSON.stringify(jsonData, null, 2), schemaJsonString, errorDetails, options);
+            if (fixedResponse) {
+                try {
+                    let fixedJsonData = JSON.parse(fixedResponse);
+                    if (options?.beforeValidation) {
+                        fixedJsonData = options.beforeValidation(fixedJsonData);
+                    }
+                    return validator(fixedJsonData);
+                }
+                catch (e) {
+                    // Fix-up failed, throw original validation error
+                    throw validationError;
+                }
+            }
+            throw validationError; // if no fixed response
+        }
+    }
+    function _getJsonPromptConfig(messages, schema, options) {
+        const schemaJsonString = JSON.stringify(schema);
+        const commonPromptFooter = `
+Your response MUST be a single JSON entity (object or array) that strictly adheres to the following JSON schema.
+Do NOT include any other text, explanations, or markdown formatting (like \`\`\`json) before or after the JSON entity.
+
+JSON schema:
+${schemaJsonString}`;
+        // Clone messages to avoid mutating the input
+        const finalMessages = [...messages];
+        // Find the first system message to append instructions to
+        const systemMessageIndex = finalMessages.findIndex(m => m.role === 'system');
+        if (systemMessageIndex !== -1) {
+            // Append to existing system message
+            const existingContent = finalMessages[systemMessageIndex].content;
+            finalMessages[systemMessageIndex] = {
+                ...finalMessages[systemMessageIndex],
+                content: `${existingContent}\n${commonPromptFooter}`
+            };
+        }
+        else {
+            // Prepend new system message
+            finalMessages.unshift({
+                role: 'system',
+                content: commonPromptFooter
+            });
+        }
+        const useResponseFormat = options?.useResponseFormat ?? true;
+        const response_format = useResponseFormat
+            ? { type: 'json_object' }
+            : undefined;
+        return { finalMessages, schemaJsonString, response_format };
+    }
+    async function promptJson(messages, schema, validator, options) {
+        const { finalMessages, schemaJsonString, response_format } = _getJsonPromptConfig(messages, schema, options);
+        const processResponse = async (llmResponseString) => {
+            let jsonData;
+            try {
+                jsonData = await _parseOrFixJson(llmResponseString, schemaJsonString, options);
+            }
+            catch (parseError) {
+                const errorMessage = `Your previous response resulted in an error.
+Error Type: JSON_PARSE_ERROR
+Error Details: ${parseError.message}
+The response provided was not valid JSON. Please correct it.`;
+                throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'JSON_PARSE_ERROR', undefined, llmResponseString);
+            }
+            try {
+                const validatedData = await _validateOrFix(jsonData, validator, schemaJsonString, options);
+                return validatedData;
+            }
+            catch (validationError) {
+                // We assume the validator throws an error with a meaningful message
+                const rawResponseForError = JSON.stringify(jsonData, null, 2);
+                const errorDetails = validationError.message;
+                const errorMessage = `Your previous response resulted in an error.
+Error Type: SCHEMA_VALIDATION_ERROR
+Error Details: ${errorDetails}
+The response was valid JSON but did not conform to the required schema. Please review the errors and the schema to provide a corrected response.`;
+                throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'CUSTOM_ERROR', validationError, rawResponseForError);
+            }
+        };
+        const retryOptions = {
+            ...options,
+            messages: finalMessages,
+            response_format,
+            validate: processResponse
+        };
+        return llmRetryClient.promptTextRetry(retryOptions);
+    }
+    async function isPromptJsonCached(messages, schema, options) {
+        const { finalMessages, response_format } = _getJsonPromptConfig(messages, schema, options);
+        const { maxRetries, useResponseFormat: _u, beforeValidation, ...restOptions } = options || {};
+        return isPromptCached({
+            messages: finalMessages,
+            response_format,
+            ...restOptions
+        });
+    }
+    return { promptJson, isPromptJsonCached };
+}

package/dist/createZodLlmClient.d.ts

@@ -1,28 +1,10 @@
 import OpenAI from 'openai';
 import * as z from "zod";
-import { PromptFunction, LlmPromptOptions, IsPromptCachedFunction } from "./createLlmClient.js";
 import { ZodTypeAny } from "zod";
-export type ZodLlmClientOptions = Omit<LlmPromptOptions, 'messages' | 'response_format'> & {
-    maxRetries?: number;
-    /**
-     * If true, passes `response_format: { type: 'json_object' }` to the model.
-     * If false, only includes the schema in the system prompt.
-     * Defaults to true.
-     */
-    useResponseFormat?: boolean;
-    /**
-     * A hook to process the parsed JSON data before it is validated against the Zod schema.
-     * This can be used to merge partial results or perform other transformations.
-     * @param data The parsed JSON data from the LLM response.
-     * @returns The processed data to be validated.
-     */
-    beforeValidation?: (data: any) => any;
-};
+import { JsonSchemaClient, JsonSchemaLlmClientOptions } from "./createJsonSchemaLlmClient.js";
+export type ZodLlmClientOptions = JsonSchemaLlmClientOptions;
 export interface CreateZodLlmClientParams {
-    prompt: PromptFunction;
-    isPromptCached: IsPromptCachedFunction;
-    fallbackPrompt?: PromptFunction;
-    disableJsonFixer?: boolean;
+    jsonSchemaClient: JsonSchemaClient;
 }
 export interface NormalizedZodArgs<T extends ZodTypeAny> {
     messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[];

package/dist/createZodLlmClient.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeZodArgs = normalizeZodArgs;
 exports.createZodLlmClient = createZodLlmClient;
 const z = __importStar(require("zod"));
-const createLlmRetryClient_js_1 = require("./createLlmRetryClient.js");
 const zod_1 = require("zod");
 function isZodSchema(obj) {
     return (typeof obj === 'object' &&
@@ -89,197 +88,32 @@ function normalizeZodArgs(arg1, arg2, arg3, arg4) {
     throw new Error("Invalid arguments passed to promptZod");
 }
 function createZodLlmClient(params) {
-    const { prompt, isPromptCached, fallbackPrompt, disableJsonFixer = false } = params;
-    const llmRetryClient = (0, createLlmRetryClient_js_1.createLlmRetryClient)({ prompt, fallbackPrompt });
-    async function _tryToFixJson(brokenResponse, schemaJsonString, errorDetails, options) {
-        const fixupPrompt = `
-An attempt to generate a JSON object resulted in the following output, which is either not valid JSON or does not conform to the required schema.
-
-Your task is to act as a JSON fixer. Analyze the provided "BROKEN RESPONSE" and correct it to match the "REQUIRED JSON SCHEMA".
-
-- If the broken response contains all the necessary information to create a valid JSON object according to the schema, please provide the corrected, valid JSON object.
-- If the broken response is missing essential information, or is too garbled to be fixed, please respond with the exact string: "CANNOT_FIX".
-- Your response must be ONLY the corrected JSON object or the string "CANNOT_FIX". Do not include any other text, explanations, or markdown formatting.
-
-REQUIRED JSON SCHEMA:
-${schemaJsonString}
-
-ERROR DETAILS:
-${errorDetails}
-
-BROKEN RESPONSE:
-${brokenResponse}
-`;
-        const messages = [
-            { role: 'system', content: 'You are an expert at fixing malformed JSON data to match a specific schema.' },
-            { role: 'user', content: fixupPrompt }
-        ];
-        const useResponseFormat = options?.useResponseFormat ?? true;
-        const response_format = useResponseFormat
-            ? { type: 'json_object' }
-            : undefined;
-        const { maxRetries, useResponseFormat: _useResponseFormat, ...restOptions } = options || {};
-        const completion = await prompt({
-            messages,
-            response_format,
-            ...restOptions
-        });
-        const fixedResponse = completion.choices[0]?.message?.content;
-        if (fixedResponse && fixedResponse.trim() === 'CANNOT_FIX') {
-            return null;
-        }
-        return fixedResponse || null;
-    }
-    async function _parseOrFixJson(llmResponseString, schemaJsonString, options) {
-        let jsonDataToParse = llmResponseString.trim();
-        // Robust handling for responses wrapped in markdown code blocks
-        const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/;
-        const match = codeBlockRegex.exec(jsonDataToParse);
-        if (match && match[1]) {
-            jsonDataToParse = match[1].trim();
-        }
-        if (jsonDataToParse === "") {
-            throw new Error("LLM returned an empty string.");
-        }
-        try {
-            return JSON.parse(jsonDataToParse);
-        }
-        catch (parseError) {
-            if (disableJsonFixer) {
-                throw parseError; // re-throw original error
-            }
-            // Attempt a one-time fix before failing.
-            const errorDetails = `JSON Parse Error: ${parseError.message}`;
-            const fixedResponse = await _tryToFixJson(jsonDataToParse, schemaJsonString, errorDetails, options);
-            if (fixedResponse) {
-                try {
-                    return JSON.parse(fixedResponse);
-                }
-                catch (e) {
-                    // Fix-up failed, throw original error.
-                    throw parseError;
-                }
-            }
-            throw parseError; // if no fixed response
-        }
-    }
-    async function _validateOrFixSchema(jsonData, dataExtractionSchema, schemaJsonString, options) {
-        try {
-            if (options?.beforeValidation) {
-                jsonData = options.beforeValidation(jsonData);
-            }
-            return dataExtractionSchema.parse(jsonData);
-        }
-        catch (validationError) {
-            if (!(validationError instanceof zod_1.ZodError) || disableJsonFixer) {
-                throw validationError;
-            }
-            // Attempt a one-time fix for schema validation errors.
-            const errorDetails = `Schema Validation Error: ${JSON.stringify(validationError.format(), null, 2)}`;
-            const fixedResponse = await _tryToFixJson(JSON.stringify(jsonData, null, 2), schemaJsonString, errorDetails, options);
-            if (fixedResponse) {
-                try {
-                    let fixedJsonData = JSON.parse(fixedResponse);
-                    if (options?.beforeValidation) {
-                        fixedJsonData = options.beforeValidation(fixedJsonData);
-                    }
-                    return dataExtractionSchema.parse(fixedJsonData);
-                }
-                catch (e) {
-                    // Fix-up failed, throw original validation error
-                    throw validationError;
-                }
-            }
-            throw validationError; // if no fixed response
-        }
-    }
-    function _getZodPromptConfig(messages, dataExtractionSchema, options) {
+    const { jsonSchemaClient } = params;
+    async function promptZod(arg1, arg2, arg3, arg4) {
+        const { messages, dataExtractionSchema, options } = normalizeZodArgs(arg1, arg2, arg3, arg4);
         const schema = z.toJSONSchema(dataExtractionSchema, {
             unrepresentable: 'any'
         });
-        const schemaJsonString = JSON.stringify(schema);
-        const commonPromptFooter = `
-Your response MUST be a single JSON entity (object or array) that strictly adheres to the following JSON schema.
-Do NOT include any other text, explanations, or markdown formatting (like \`\`\`json) before or after the JSON entity.
-
-JSON schema:
-${schemaJsonString}`;
-        // Clone messages to avoid mutating the input
-        const finalMessages = [...messages];
-        // Find the first system message to append instructions to
-        const systemMessageIndex = finalMessages.findIndex(m => m.role === 'system');
-        if (systemMessageIndex !== -1) {
-            // Append to existing system message
-            const existingContent = finalMessages[systemMessageIndex].content;
-            finalMessages[systemMessageIndex] = {
-                ...finalMessages[systemMessageIndex],
-                content: `${existingContent}\n${commonPromptFooter}`
-            };
-        }
-        else {
-            // Prepend new system message
-            finalMessages.unshift({
-                role: 'system',
-                content: commonPromptFooter
-            });
-        }
-        const useResponseFormat = options?.useResponseFormat ?? true;
-        const response_format = useResponseFormat
-            ? { type: 'json_object' }
-            : undefined;
-        return { finalMessages, schemaJsonString, response_format };
-    }
-    async function promptZod(arg1, arg2, arg3, arg4) {
-        const { messages, dataExtractionSchema, options } = normalizeZodArgs(arg1, arg2, arg3, arg4);
-        const { finalMessages, schemaJsonString, response_format } = _getZodPromptConfig(messages, dataExtractionSchema, options);
-        const processResponse = async (llmResponseString) => {
-            let jsonData;
-            try {
-                jsonData = await _parseOrFixJson(llmResponseString, schemaJsonString, options);
-            }
-            catch (parseError) {
-                const errorMessage = `Your previous response resulted in an error.
-Error Type: JSON_PARSE_ERROR
-Error Details: ${parseError.message}
-The response provided was not valid JSON. Please correct it.`;
-                throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'JSON_PARSE_ERROR', undefined, llmResponseString);
-            }
+        const validator = (data) => {
             try {
-                const validatedData = await _validateOrFixSchema(jsonData, dataExtractionSchema, schemaJsonString, options);
-                return validatedData;
+                return dataExtractionSchema.parse(data);
             }
-            catch (validationError) {
-                if (validationError instanceof zod_1.ZodError) {
-                    const rawResponseForError = JSON.stringify(jsonData, null, 2);
-                    const errorDetails = JSON.stringify(validationError.format(), null, 2);
-                    const errorMessage = `Your previous response resulted in an error.
-Error Type: SCHEMA_VALIDATION_ERROR
-Error Details: ${errorDetails}
-The response was valid JSON but did not conform to the required schema. Please review the errors and the schema to provide a corrected response.`;
-                    throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'CUSTOM_ERROR', validationError.format(), rawResponseForError);
+            catch (error) {
+                if (error instanceof zod_1.ZodError) {
+                    // Format the error nicely for the LLM
+                    throw new Error(JSON.stringify(error.format(), null, 2));
                 }
-                // For other errors, rethrow and let LlmRetryClient handle as critical.
-                throw validationError;
+                throw error;
             }
         };
-        const retryOptions = {
-            ...options,
-            messages: finalMessages,
-            response_format,
-            validate: processResponse
-        };
-        // Use promptTextRetry because we expect a string response to parse as JSON
-        return llmRetryClient.promptTextRetry(retryOptions);
+        return jsonSchemaClient.promptJson(messages, schema, validator, options);
     }
     async function isPromptZodCached(arg1, arg2, arg3, arg4) {
         const { messages, dataExtractionSchema, options } = normalizeZodArgs(arg1, arg2, arg3, arg4);
-        const { finalMessages, response_format } = _getZodPromptConfig(messages, dataExtractionSchema, options);
-        const { maxRetries, useResponseFormat: _u, beforeValidation, ...restOptions } = options || {};
-        return isPromptCached({
-            messages: finalMessages,
-            response_format,
-            ...restOptions
+        const schema = z.toJSONSchema(dataExtractionSchema, {
+            unrepresentable: 'any'
         });
+        return jsonSchemaClient.isPromptJsonCached(messages, schema, options);
     }
     return { promptZod, isPromptZodCached };
 }

package/dist/createZodLlmClient.spec.js

@@ -79,6 +79,19 @@ const createZodLlmClient_js_1 = require("./createZodLlmClient.js");
         (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
         (0, vitest_1.expect)(result.options).toBe(options);
     });
+    (0, vitest_1.it)('should normalize Messages Array with few-shot examples + Schema (Case 0)', () => {
+        const messages = [
+            { role: 'system', content: 'Extract sentiment.' },
+            { role: 'user', content: 'I love this!' },
+            { role: 'assistant', content: JSON.stringify({ sentiment: 'positive' }) },
+            { role: 'user', content: 'I hate this.' }
+        ];
+        const Schema = zod_1.z.object({ sentiment: zod_1.z.enum(['positive', 'negative']) });
+        const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(messages, Schema);
+        (0, vitest_1.expect)(result.messages).toBe(messages);
+        (0, vitest_1.expect)(result.dataExtractionSchema).toBe(Schema);
+        (0, vitest_1.expect)(result.options).toBeUndefined();
+    });
     (0, vitest_1.it)('should throw error for invalid arguments', () => {
         (0, vitest_1.expect)(() => (0, createZodLlmClient_js_1.normalizeZodArgs)({})).toThrow('Invalid arguments');
     });

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './createLlmClient.js';
 export * from './createLlmRetryClient.js';
 export * from './createZodLlmClient.js';
+export * from './createJsonSchemaLlmClient.js';
 export * from './llmFactory.js';
 export * from './retryUtils.js';

package/dist/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./createLlmClient.js"), exports);
 __exportStar(require("./createLlmRetryClient.js"), exports);
 __exportStar(require("./createZodLlmClient.js"), exports);
+__exportStar(require("./createJsonSchemaLlmClient.js"), exports);
 __exportStar(require("./llmFactory.js"), exports);
 __exportStar(require("./retryUtils.js"), exports);

package/dist/llmFactory.d.ts

@@ -14,6 +14,8 @@ export declare function createLlm(params: CreateLlmFactoryParams): {
         <T extends import("zod").ZodType>(prompt: string, schema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<boolean>;
         <T extends import("zod").ZodType>(mainInstruction: string, userMessagePayload: string | import("openai/resources/index.js").ChatCompletionContentPart[], dataExtractionSchema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<boolean>;
     };
+    promptJson: <T>(messages: import("openai/resources/index.js").ChatCompletionMessageParam[], schema: Record<string, any>, validator: (data: any) => T, options?: import("./createJsonSchemaLlmClient.js").JsonSchemaLlmClientOptions) => Promise<T>;
+    isPromptJsonCached: (messages: import("openai/resources/index.js").ChatCompletionMessageParam[], schema: Record<string, any>, options?: import("./createJsonSchemaLlmClient.js").JsonSchemaLlmClientOptions) => Promise<boolean>;
     promptRetry: {
         <T = import("openai/resources/index.js").ChatCompletion>(content: string, options?: Omit<import("./createLlmRetryClient.js").LlmRetryOptions<T>, "messages">): Promise<T>;
         <T = import("openai/resources/index.js").ChatCompletion>(options: import("./createLlmRetryClient.js").LlmRetryOptions<T>): Promise<T>;

package/dist/llmFactory.js

@@ -4,18 +4,23 @@ exports.createLlm = createLlm;
 const createLlmClient_js_1 = require("./createLlmClient.js");
 const createLlmRetryClient_js_1 = require("./createLlmRetryClient.js");
 const createZodLlmClient_js_1 = require("./createZodLlmClient.js");
+const createJsonSchemaLlmClient_js_1 = require("./createJsonSchemaLlmClient.js");
 function createLlm(params) {
     const baseClient = (0, createLlmClient_js_1.createLlmClient)(params);
     const retryClient = (0, createLlmRetryClient_js_1.createLlmRetryClient)({
         prompt: baseClient.prompt
     });
-    const zodClient = (0, createZodLlmClient_js_1.createZodLlmClient)({
+    const jsonSchemaClient = (0, createJsonSchemaLlmClient_js_1.createJsonSchemaLlmClient)({
         prompt: baseClient.prompt,
         isPromptCached: baseClient.isPromptCached
     });
+    const zodClient = (0, createZodLlmClient_js_1.createZodLlmClient)({
+        jsonSchemaClient
+    });
     return {
         ...baseClient,
         ...retryClient,
+        ...jsonSchemaClient,
         ...zodClient
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-fns",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

@@ -115,47 +115,50 @@ const buffer2 = await llm.promptImage({
 
 ---
 
-# Use Case 3: Structured Data (`llm.promptZod`)
+# Use Case 3: Structured Data (`llm.promptJson` & `llm.promptZod`)
 
-This is a high-level wrapper that employs a **Re-asking Loop**. If the LLM outputs invalid JSON or data that fails the Zod schema validation, the client automatically feeds the error back to the LLM and asks it to fix it (up to `maxRetries`).
+This is a high-level wrapper that employs a **Re-asking Loop**. If the LLM outputs invalid JSON or data that fails the schema validation, the client automatically feeds the error back to the LLM and asks it to fix it (up to `maxRetries`).
 
-**Return Type:** `Promise<z.infer<typeof Schema>>`
+**Return Type:** `Promise<T>`
+
+### Level 1: Raw JSON Schema (`promptJson`)
+Use this if you have a standard JSON Schema object (e.g. from another library or API) and don't want to use Zod.
 
-### Level 1: Generation (Schema Only)
-The client "hallucinates" data matching the shape.
+```typescript
+const MySchema = {
+    type: "object",
+    properties: {
+        sentiment: { type: "string", enum: ["positive", "negative"] },
+        score: { type: "number" }
+    },
+    required: ["sentiment", "score"],
+    additionalProperties: false
+};
+
+const result = await llm.promptJson(
+    [{ role: "user", content: "I love this!" }],
+    MySchema,
+    (data) => data // Optional validator function
+);
+```
+
+### Level 2: Zod Wrapper (`promptZod`)
+This is syntactic sugar over `promptJson`. It converts your Zod schema to JSON Schema and automatically sets up the validator to throw formatted Zod errors for the retry loop.
+
+**Return Type:** `Promise<z.infer<typeof Schema>>`
 
 ```typescript
 import { z } from 'zod';
 const UserSchema = z.object({ name: z.string(), age: z.number() });
 
-// Input: Schema only
+// 1. Schema Only (Hallucinate data)
 const user = await llm.promptZod(UserSchema);
-// Output: { name: "Alice", age: 32 }
-```
-
-### Level 2: Extraction (Injection Shortcuts)
-Pass context alongside the schema. This automates the "System Prompt JSON Injection".
 
-```typescript
-// 1. Extract from String
+// 2. Extraction (Context + Schema)
 const email = "Meeting at 2 PM with Bob.";
 const event = await llm.promptZod(email, z.object({ time: z.string(), who: z.string() }));
 
-// 2. Strict Separation (System, User, Schema)
-// Useful for auditing code or translations where instructions must not bleed into data.
-const analysis = await llm.promptZod(
-    "You are a security auditor.", // Arg 1: System
-    "function dangerous() {}",     // Arg 2: User Data
-    SecuritySchema                 // Arg 3: Schema
-);
-```
-
-### Level 3: State & Options (History + Config)
-Process full chat history into state, and use the **Options Object (4th Argument)** to control the internals (Models, Retries, Caching).
-
-**Input Type:** `ZodLlmClientOptions`
-
-```typescript
+// 3. Full Control (History + Schema + Options)
 const history = [
     { role: "user", content: "I cast Fireball." },
     { role: "assistant", content: "It misses." }
@@ -173,12 +176,12 @@ const gameState = await llm.promptZod(
 );
 ```
 
-### Level 4: Hooks & Pre-processing
-Sometimes LLMs output data that is *almost* correct (e.g., strings for numbers). You can sanitize data before Zod validation runs.
+### Level 3: Hooks & Pre-processing
+Sometimes LLMs output data that is *almost* correct (e.g., strings for numbers). You can sanitize data before validation runs.
 
 ```typescript
 const result = await llm.promptZod(MySchema, {
-    // Transform JSON before Zod validation runs
+    // Transform JSON before validation runs
     beforeValidation: (data) => {
         if (data.price && typeof data.price === 'string') {
             return { ...data, price: parseFloat(data.price) };
@@ -187,7 +190,6 @@ const result = await llm.promptZod(MySchema, {
     },
     
     // Toggle usage of 'response_format: { type: "json_object" }'
-    // Sometimes strict JSON mode is too restrictive for creative tasks
     useResponseFormat: false 
 });
 ```