llm-fns 1.0.5 → 1.0.7

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,44 +1,27 @@
 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> {
-    mainInstruction: string;
-    userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[];
+    messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[];
     dataExtractionSchema: T;
     options?: ZodLlmClientOptions;
 }
-export declare function normalizeZodArgs<T extends ZodTypeAny>(arg1: string | T, arg2?: string | OpenAI.Chat.Completions.ChatCompletionContentPart[] | T | ZodLlmClientOptions, arg3?: T | ZodLlmClientOptions, arg4?: ZodLlmClientOptions): NormalizedZodArgs<T>;
+export declare function normalizeZodArgs<T extends ZodTypeAny>(arg1: string | OpenAI.Chat.Completions.ChatCompletionMessageParam[] | T, arg2?: string | OpenAI.Chat.Completions.ChatCompletionContentPart[] | T | ZodLlmClientOptions, arg3?: T | ZodLlmClientOptions, arg4?: ZodLlmClientOptions): NormalizedZodArgs<T>;
 export declare function createZodLlmClient(params: CreateZodLlmClientParams): {
     promptZod: {
         <T extends ZodTypeAny>(schema: T, options?: ZodLlmClientOptions): Promise<z.infer<T>>;
+        <T extends ZodTypeAny>(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], schema: T, options?: ZodLlmClientOptions): Promise<z.infer<T>>;
         <T extends ZodTypeAny>(prompt: string, schema: T, options?: ZodLlmClientOptions): Promise<z.infer<T>>;
         <T extends ZodTypeAny>(mainInstruction: string, userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[], dataExtractionSchema: T, options?: ZodLlmClientOptions): Promise<z.infer<T>>;
     };
     isPromptZodCached: {
         <T extends ZodTypeAny>(schema: T, options?: ZodLlmClientOptions): Promise<boolean>;
+        <T extends ZodTypeAny>(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], schema: T, options?: ZodLlmClientOptions): Promise<boolean>;
         <T extends ZodTypeAny>(prompt: string, schema: T, options?: ZodLlmClientOptions): Promise<boolean>;
         <T extends ZodTypeAny>(mainInstruction: string, userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[], dataExtractionSchema: T, options?: ZodLlmClientOptions): Promise<boolean>;
     };

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' &&
@@ -45,11 +44,21 @@ function isZodSchema(obj) {
         '_def' in obj);
 }
 function normalizeZodArgs(arg1, arg2, arg3, arg4) {
+    // Case 0: promptZod(messages[], schema, options?)
+    if (Array.isArray(arg1)) {
+        return {
+            messages: arg1,
+            dataExtractionSchema: arg2,
+            options: arg3
+        };
+    }
     if (isZodSchema(arg1)) {
         // Case 1: promptZod(schema, options?)
         return {
-            mainInstruction: "Generate a valid JSON object based on the schema.",
-            userMessagePayload: "Generate the data.",
+            messages: [
+                { role: 'system', content: "Generate a valid JSON object based on the schema." },
+                { role: 'user', content: "Generate the data." }
+            ],
             dataExtractionSchema: arg1,
             options: arg2
         };
@@ -58,16 +67,20 @@ function normalizeZodArgs(arg1, arg2, arg3, arg4) {
         if (isZodSchema(arg2)) {
             // Case 2: promptZod(prompt, schema, options?)
             return {
-                mainInstruction: "You are a helpful assistant that outputs JSON matching the provided schema.",
-                userMessagePayload: arg1,
+                messages: [
+                    { role: 'system', content: "You are a helpful assistant that outputs JSON matching the provided schema." },
+                    { role: 'user', content: arg1 }
+                ],
                 dataExtractionSchema: arg2,
                 options: arg3
             };
         }
         // Case 3: promptZod(system, user, schema, options?)
         return {
-            mainInstruction: arg1,
-            userMessagePayload: arg2,
+            messages: [
+                { role: 'system', content: arg1 },
+                { role: 'user', content: arg2 }
+            ],
             dataExtractionSchema: arg3,
             options: arg4
         };
@@ -75,187 +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(mainInstruction, 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}`;
-        const finalMainInstruction = `${mainInstruction}\n${commonPromptFooter}`;
-        const useResponseFormat = options?.useResponseFormat ?? true;
-        const response_format = useResponseFormat
-            ? { type: 'json_object' }
-            : undefined;
-        return { finalMainInstruction, schemaJsonString, response_format };
-    }
-    async function promptZod(arg1, arg2, arg3, arg4) {
-        const { mainInstruction, userMessagePayload, dataExtractionSchema, options } = normalizeZodArgs(arg1, arg2, arg3, arg4);
-        const { finalMainInstruction, schemaJsonString, response_format } = _getZodPromptConfig(mainInstruction, 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 messages = [
-            { role: "system", content: finalMainInstruction },
-            { role: "user", content: userMessagePayload }
-        ];
-        const retryOptions = {
-            ...options,
-            messages,
-            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 { mainInstruction, userMessagePayload, dataExtractionSchema, options } = normalizeZodArgs(arg1, arg2, arg3, arg4);
-        const { finalMainInstruction, response_format } = _getZodPromptConfig(mainInstruction, dataExtractionSchema, options);
-        const messages = [
-            { role: "system", content: finalMainInstruction },
-            { role: "user", content: userMessagePayload }
-        ];
-        const { maxRetries, useResponseFormat: _u, beforeValidation, ...restOptions } = options || {};
-        return isPromptCached({
-            messages,
-            response_format,
-            ...restOptions
+        const { messages, dataExtractionSchema, options } = normalizeZodArgs(arg1, arg2, arg3, arg4);
+        const schema = z.toJSONSchema(dataExtractionSchema, {
+            unrepresentable: 'any'
         });
+        return jsonSchemaClient.isPromptJsonCached(messages, schema, options);
     }
     return { promptZod, isPromptZodCached };
 }

package/dist/createZodLlmClient.spec.js

@@ -9,24 +9,24 @@ const createZodLlmClient_js_1 = require("./createZodLlmClient.js");
     });
     (0, vitest_1.it)('should normalize Schema Only (Case 1)', () => {
         const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(TestSchema);
-        (0, vitest_1.expect)(result.mainInstruction).toContain('Generate a valid JSON');
-        (0, vitest_1.expect)(result.userMessagePayload).toBe('Generate the data.');
+        (0, vitest_1.expect)(result.messages[0].content).toContain('Generate a valid JSON');
+        (0, vitest_1.expect)(result.messages[1].content).toBe('Generate the data.');
         (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
         (0, vitest_1.expect)(result.options).toBeUndefined();
     });
     (0, vitest_1.it)('should normalize Schema Only with Options (Case 1)', () => {
         const options = { temperature: 0.5 };
         const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(TestSchema, options);
-        (0, vitest_1.expect)(result.mainInstruction).toContain('Generate a valid JSON');
-        (0, vitest_1.expect)(result.userMessagePayload).toBe('Generate the data.');
+        (0, vitest_1.expect)(result.messages[0].content).toContain('Generate a valid JSON');
+        (0, vitest_1.expect)(result.messages[1].content).toBe('Generate the data.');
         (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
         (0, vitest_1.expect)(result.options).toBe(options);
     });
     (0, vitest_1.it)('should normalize Prompt + Schema (Case 2)', () => {
         const prompt = "Extract data";
         const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(prompt, TestSchema);
-        (0, vitest_1.expect)(result.mainInstruction).toContain('You are a helpful assistant');
-        (0, vitest_1.expect)(result.userMessagePayload).toBe(prompt);
+        (0, vitest_1.expect)(result.messages[0].content).toContain('You are a helpful assistant');
+        (0, vitest_1.expect)(result.messages[1].content).toBe(prompt);
         (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
         (0, vitest_1.expect)(result.options).toBeUndefined();
     });
@@ -34,8 +34,8 @@ const createZodLlmClient_js_1 = require("./createZodLlmClient.js");
         const prompt = "Extract data";
         const options = { temperature: 0.5 };
         const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(prompt, TestSchema, options);
-        (0, vitest_1.expect)(result.mainInstruction).toContain('You are a helpful assistant');
-        (0, vitest_1.expect)(result.userMessagePayload).toBe(prompt);
+        (0, vitest_1.expect)(result.messages[0].content).toContain('You are a helpful assistant');
+        (0, vitest_1.expect)(result.messages[1].content).toBe(prompt);
         (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
         (0, vitest_1.expect)(result.options).toBe(options);
     });
@@ -43,8 +43,8 @@ const createZodLlmClient_js_1 = require("./createZodLlmClient.js");
         const system = "System prompt";
         const user = "User prompt";
         const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(system, user, TestSchema);
-        (0, vitest_1.expect)(result.mainInstruction).toBe(system);
-        (0, vitest_1.expect)(result.userMessagePayload).toBe(user);
+        (0, vitest_1.expect)(result.messages[0].content).toBe(system);
+        (0, vitest_1.expect)(result.messages[1].content).toBe(user);
         (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
         (0, vitest_1.expect)(result.options).toBeUndefined();
     });
@@ -53,11 +53,45 @@ const createZodLlmClient_js_1 = require("./createZodLlmClient.js");
         const user = "User prompt";
         const options = { temperature: 0.5 };
         const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(system, user, TestSchema, options);
-        (0, vitest_1.expect)(result.mainInstruction).toBe(system);
-        (0, vitest_1.expect)(result.userMessagePayload).toBe(user);
+        (0, vitest_1.expect)(result.messages[0].content).toBe(system);
+        (0, vitest_1.expect)(result.messages[1].content).toBe(user);
         (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
         (0, vitest_1.expect)(result.options).toBe(options);
     });
+    (0, vitest_1.it)('should normalize Messages Array + Schema (Case 0)', () => {
+        const messages = [
+            { role: 'system', content: 'Sys' },
+            { role: 'user', content: 'Usr' }
+        ];
+        const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(messages, TestSchema);
+        (0, vitest_1.expect)(result.messages).toBe(messages);
+        (0, vitest_1.expect)(result.dataExtractionSchema).toBe(TestSchema);
+        (0, vitest_1.expect)(result.options).toBeUndefined();
+    });
+    (0, vitest_1.it)('should normalize Messages Array + Schema with Options (Case 0)', () => {
+        const messages = [
+            { role: 'system', content: 'Sys' },
+            { role: 'user', content: 'Usr' }
+        ];
+        const options = { temperature: 0.5 };
+        const result = (0, createZodLlmClient_js_1.normalizeZodArgs)(messages, TestSchema, options);
+        (0, vitest_1.expect)(result.messages).toBe(messages);
+        (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

@@ -4,14 +4,18 @@ export interface CreateLlmFactoryParams extends CreateLlmClientParams {
 export declare function createLlm(params: CreateLlmFactoryParams): {
     promptZod: {
         <T extends import("zod").ZodType>(schema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<import("zod").infer<T>>;
+        <T extends import("zod").ZodType>(messages: import("openai/resources/index.js").ChatCompletionMessageParam[], schema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<import("zod").infer<T>>;
         <T extends import("zod").ZodType>(prompt: string, schema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<import("zod").infer<T>>;
         <T extends import("zod").ZodType>(mainInstruction: string, userMessagePayload: string | import("openai/resources/index.js").ChatCompletionContentPart[], dataExtractionSchema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<import("zod").infer<T>>;
     };
     isPromptZodCached: {
         <T extends import("zod").ZodType>(schema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<boolean>;
+        <T extends import("zod").ZodType>(messages: import("openai/resources/index.js").ChatCompletionMessageParam[], schema: T, options?: import("./createZodLlmClient.js").ZodLlmClientOptions): Promise<boolean>;
         <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.5",
+  "version": "1.0.7",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",