llm-fns 1.0.2 → 1.0.4

package/{src/createZodLlmClient.ts → dist/createZodLlmClient.js}

@@ -1,98 +1,83 @@
-import OpenAI from 'openai'; // Import the OpenAI library
-import * as z from "zod";
-import { PromptFunction, LlmPromptOptions, OpenRouterResponseFormat, IsPromptCachedFunction } from "./createLlmClient.js";
-import { createLlmRetryClient, LlmRetryError, LlmRetryOptions } from "./createLlmRetryClient.js";
-import { ZodError, 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;
-}
-
-export interface CreateZodLlmClientParams {
-    prompt: PromptFunction;
-    isPromptCached: IsPromptCachedFunction;
-    fallbackPrompt?: PromptFunction;
-    disableJsonFixer?: boolean;
-}
-
-function isZodSchema(obj: any): obj is ZodTypeAny {
-    return (
-        typeof obj === 'object' &&
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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' &&
         obj !== null &&
         'parse' in obj &&
-        '_def' in obj
-    );
+        '_def' in obj);
 }
-
-export interface NormalizedZodArgs<T extends ZodTypeAny> {
-    mainInstruction: string;
-    userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[];
-    dataExtractionSchema: T;
-    options?: ZodLlmClientOptions;
-}
-
-export function normalizeZodArgs<T extends ZodTypeAny>(
-    arg1: string | T,
-    arg2?: string | OpenAI.Chat.Completions.ChatCompletionContentPart[] | T | ZodLlmClientOptions,
-    arg3?: T | ZodLlmClientOptions,
-    arg4?: ZodLlmClientOptions
-): NormalizedZodArgs<T> {
+function normalizeZodArgs(arg1, arg2, arg3, arg4) {
     if (isZodSchema(arg1)) {
         // Case 1: promptZod(schema, options?)
         return {
             mainInstruction: "Generate a valid JSON object based on the schema.",
             userMessagePayload: "Generate the data.",
             dataExtractionSchema: arg1,
-            options: arg2 as ZodLlmClientOptions | undefined
+            options: arg2
         };
     }
-
     if (typeof arg1 === 'string') {
         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,
-                dataExtractionSchema: arg2 as T,
-                options: arg3 as ZodLlmClientOptions | undefined
+                dataExtractionSchema: arg2,
+                options: arg3
             };
         }
-
         // Case 3: promptZod(system, user, schema, options?)
         return {
             mainInstruction: arg1,
-            userMessagePayload: arg2 as string | OpenAI.Chat.Completions.ChatCompletionContentPart[],
-            dataExtractionSchema: arg3 as T,
+            userMessagePayload: arg2,
+            dataExtractionSchema: arg3,
             options: arg4
         };
     }
-
     throw new Error("Invalid arguments passed to promptZod");
 }
-
-export function createZodLlmClient(params: CreateZodLlmClientParams) {
+function createZodLlmClient(params) {
     const { prompt, isPromptCached, fallbackPrompt, disableJsonFixer = false } = params;
-    const llmRetryClient = createLlmRetryClient({ prompt, fallbackPrompt });
-
-    async function _tryToFixJson(
-        brokenResponse: string,
-        schemaJsonString: string,
-        errorDetails: string,
-        options?: ZodLlmClientOptions
-    ): Promise<string | null> {
+    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.
 
@@ -111,97 +96,73 @@ ${errorDetails}
 BROKEN RESPONSE:
 ${brokenResponse}
 `;
-
-        const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
+        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: OpenRouterResponseFormat | undefined = useResponseFormat
+        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: string,
-        schemaJsonString: string,
-        options: ZodLlmClientOptions | undefined
-    ): Promise<any> {
-        let jsonDataToParse: string = llmResponseString.trim();
-
+    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: any) {
+        }
+        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) {
+                }
+                catch (e) {
                     // Fix-up failed, throw original error.
                     throw parseError;
                 }
             }
-
             throw parseError; // if no fixed response
         }
     }
-
-    async function _validateOrFixSchema<SchemaType extends ZodTypeAny>(
-        jsonData: any,
-        dataExtractionSchema: SchemaType,
-        schemaJsonString: string,
-        options: ZodLlmClientOptions | undefined
-    ): Promise<z.infer<SchemaType>> {
+    async function _validateOrFixSchema(jsonData, dataExtractionSchema, schemaJsonString, options) {
         try {
             if (options?.beforeValidation) {
                 jsonData = options.beforeValidation(jsonData);
             }
             return dataExtractionSchema.parse(jsonData);
-        } catch (validationError: any) {
-            if (!(validationError instanceof ZodError) || disableJsonFixer) {
+        }
+        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);
@@ -209,170 +170,92 @@ ${brokenResponse}
                         fixedJsonData = options.beforeValidation(fixedJsonData);
                     }
                     return dataExtractionSchema.parse(fixedJsonData);
-                } catch (e) {
+                }
+                catch (e) {
                     // Fix-up failed, throw original validation error
                     throw validationError;
                 }
             }
-
             throw validationError; // if no fixed response
         }
     }
-
-    function _getZodPromptConfig<T extends ZodTypeAny>(
-        mainInstruction: string,
-        dataExtractionSchema: T,
-        options?: ZodLlmClientOptions
-    ) {
+    function _getZodPromptConfig(mainInstruction, dataExtractionSchema, options) {
         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: OpenRouterResponseFormat | undefined = useResponseFormat
+        const response_format = useResponseFormat
             ? { type: 'json_object' }
             : undefined;
-
         return { finalMainInstruction, schemaJsonString, response_format };
     }
-
-    async function promptZod<T extends ZodTypeAny>(
-        schema: T,
-        options?: ZodLlmClientOptions
-    ): Promise<z.infer<T>>;
-    async function promptZod<T extends ZodTypeAny>(
-        prompt: string,
-        schema: T,
-        options?: ZodLlmClientOptions
-    ): Promise<z.infer<T>>;
-    async function promptZod<T extends ZodTypeAny>(
-        mainInstruction: string,
-        userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[],
-        dataExtractionSchema: T,
-        options?: ZodLlmClientOptions
-    ): Promise<z.infer<T>>;
-    async function promptZod<T extends ZodTypeAny>(
-        arg1: string | T,
-        arg2?: string | OpenAI.Chat.Completions.ChatCompletionContentPart[] | T | ZodLlmClientOptions,
-        arg3?: T | ZodLlmClientOptions,
-        arg4?: ZodLlmClientOptions
-    ): Promise<z.infer<T>> {
+    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: string): Promise<z.infer<T>> => {
-            let jsonData: any;
+        const { finalMainInstruction, schemaJsonString, response_format } = _getZodPromptConfig(mainInstruction, dataExtractionSchema, options);
+        const processResponse = async (llmResponseString) => {
+            let jsonData;
             try {
                 jsonData = await _parseOrFixJson(llmResponseString, schemaJsonString, options);
-            } catch (parseError: any) {
+            }
+            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 LlmRetryError(
-                    errorMessage,
-                    'JSON_PARSE_ERROR',
-                    undefined,
-                    llmResponseString
-                );
+                throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'JSON_PARSE_ERROR', undefined, llmResponseString);
             }
-
             try {
                 const validatedData = await _validateOrFixSchema(jsonData, dataExtractionSchema, schemaJsonString, options);
                 return validatedData;
-            } catch (validationError: any) {
-                if (validationError instanceof ZodError) {
+            }
+            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 LlmRetryError(
-                        errorMessage,
-                        'CUSTOM_ERROR',
-                        validationError.format(),
-                        rawResponseForError
-                    );
+                    throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'CUSTOM_ERROR', validationError.format(), rawResponseForError);
                 }
                 // For other errors, rethrow and let LlmRetryClient handle as critical.
                 throw validationError;
             }
         };
-
-        const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
+        const messages = [
             { role: "system", content: finalMainInstruction },
             { role: "user", content: userMessagePayload }
         ];
-
-        const retryOptions: LlmRetryOptions<z.infer<T>> = {
+        const retryOptions = {
             ...options,
             messages,
             response_format,
             validate: processResponse
         };
-
         // Use promptTextRetry because we expect a string response to parse as JSON
         return llmRetryClient.promptTextRetry(retryOptions);
     }
-
-    async function isPromptZodCached<T extends ZodTypeAny>(
-        schema: T,
-        options?: ZodLlmClientOptions
-    ): Promise<boolean>;
-    async function isPromptZodCached<T extends ZodTypeAny>(
-        prompt: string,
-        schema: T,
-        options?: ZodLlmClientOptions
-    ): Promise<boolean>;
-    async function isPromptZodCached<T extends ZodTypeAny>(
-        mainInstruction: string,
-        userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[],
-        dataExtractionSchema: T,
-        options?: ZodLlmClientOptions
-    ): Promise<boolean>;
-    async function isPromptZodCached<T extends ZodTypeAny>(
-        arg1: string | T,
-        arg2?: string | OpenAI.Chat.Completions.ChatCompletionContentPart[] | T | ZodLlmClientOptions,
-        arg3?: T | ZodLlmClientOptions,
-        arg4?: ZodLlmClientOptions
-    ): Promise<boolean> {
+    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: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
+        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
         });
     }
-
     return { promptZod, isPromptZodCached };
 }

package/dist/createZodLlmClient.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/createZodLlmClient.spec.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const zod_1 = require("zod");
+const createZodLlmClient_js_1 = require("./createZodLlmClient.js");
+(0, vitest_1.describe)('normalizeZodArgs', () => {
+    const TestSchema = zod_1.z.object({
+        foo: zod_1.z.string()
+    });
+    (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.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.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.dataExtractionSchema).toBe(TestSchema);
+        (0, vitest_1.expect)(result.options).toBeUndefined();
+    });
+    (0, vitest_1.it)('should normalize Prompt + Schema with Options (Case 2)', () => {
+        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.dataExtractionSchema).toBe(TestSchema);
+        (0, vitest_1.expect)(result.options).toBe(options);
+    });
+    (0, vitest_1.it)('should normalize System + User + Schema (Case 3)', () => {
+        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.dataExtractionSchema).toBe(TestSchema);
+        (0, vitest_1.expect)(result.options).toBeUndefined();
+    });
+    (0, vitest_1.it)('should normalize System + User + Schema with Options (Case 3)', () => {
+        const system = "System prompt";
+        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.dataExtractionSchema).toBe(TestSchema);
+        (0, vitest_1.expect)(result.options).toBe(options);
+    });
+    (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.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createLlmClient.js"), exports);
+__exportStar(require("./createLlmRetryClient.js"), exports);
+__exportStar(require("./createZodLlmClient.js"), exports);
+__exportStar(require("./llmFactory.js"), exports);
+__exportStar(require("./retryUtils.js"), exports);

package/dist/llmFactory.d.ts

@@ -0,0 +1,43 @@
+import { CreateLlmClientParams } from "./createLlmClient.js";
+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>(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>(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>;
+    };
+    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>;
+    };
+    promptTextRetry: {
+        <T = string>(content: string, options?: Omit<import("./createLlmRetryClient.js").LlmRetryOptions<T>, "messages">): Promise<T>;
+        <T = string>(options: import("./createLlmRetryClient.js").LlmRetryOptions<T>): Promise<T>;
+    };
+    promptImageRetry: {
+        <T = Buffer<ArrayBufferLike>>(content: string, options?: Omit<import("./createLlmRetryClient.js").LlmRetryOptions<T>, "messages">): Promise<T>;
+        <T = Buffer<ArrayBufferLike>>(options: import("./createLlmRetryClient.js").LlmRetryOptions<T>): Promise<T>;
+    };
+    prompt: {
+        (content: string, options?: Omit<import("./createLlmClient.js").LlmPromptOptions, "messages">): Promise<import("openai/resources/index.js").ChatCompletion>;
+        (options: import("./createLlmClient.js").LlmPromptOptions): Promise<import("openai/resources/index.js").ChatCompletion>;
+    };
+    isPromptCached: {
+        (content: string, options?: Omit<import("./createLlmClient.js").LlmPromptOptions, "messages">): Promise<boolean>;
+        (options: import("./createLlmClient.js").LlmPromptOptions): Promise<boolean>;
+    };
+    promptText: {
+        (content: string, options?: Omit<import("./createLlmClient.js").LlmPromptOptions, "messages">): Promise<string>;
+        (options: import("./createLlmClient.js").LlmPromptOptions): Promise<string>;
+    };
+    promptImage: {
+        (content: string, options?: Omit<import("./createLlmClient.js").LlmPromptOptions, "messages">): Promise<Buffer>;
+        (options: import("./createLlmClient.js").LlmPromptOptions): Promise<Buffer>;
+    };
+};

package/dist/llmFactory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLlm = createLlm;
+const createLlmClient_js_1 = require("./createLlmClient.js");
+const createLlmRetryClient_js_1 = require("./createLlmRetryClient.js");
+const createZodLlmClient_js_1 = require("./createZodLlmClient.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)({
+        prompt: baseClient.prompt,
+        isPromptCached: baseClient.isPromptCached
+    });
+    return {
+        ...baseClient,
+        ...retryClient,
+        ...zodClient
+    };
+}

package/dist/retryUtils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Describes the outcome of a validation/processing step in a retry loop.
+ */
+export interface RetryValidationResult<ValidatedDataType, FeedbackType = any> {
+    isValid: boolean;
+    data?: ValidatedDataType;
+    feedbackForNextAttempt?: FeedbackType;
+    isCriticalFailure?: boolean;
+}
+/**
+ * Executes an operation with a retry mechanism.
+ *
+ * @param operation - An async function representing the operation to be tried.
+ *                    It receives the current attempt number and feedback from the previous validation.
+ * @param validateAndProcess - An async function that processes the raw result from the operation
+ *                             and validates it. It returns a RetryValidationResult.
+ * @param maxRetries - The maximum number of retries after the initial attempt (e.g., 2 means 3 total attempts).
+ * @param initialFeedbackForOperation - Optional initial feedback to pass to the very first call of the operation.
+ * @param shouldRetryError - Optional function to determine if a specific error should trigger a retry. Returns true to retry, false to throw immediately.
+ * @returns A Promise that resolves with the validated data if successful.
+ * @throws An error if all attempts fail or a critical failure occurs.
+ */
+export declare function executeWithRetry<OperationReturnType, ValidatedDataType, FeedbackType = any>(operation: (attemptNumber: number, feedbackForOperation?: FeedbackType) => Promise<OperationReturnType>, validateAndProcess: (rawResult: OperationReturnType, attemptNumber: number) => Promise<RetryValidationResult<ValidatedDataType, FeedbackType>>, maxRetries: number, initialFeedbackForOperation?: FeedbackType, shouldRetryError?: (error: any) => boolean): Promise<ValidatedDataType>;