llm-fns 1.0.3 → 1.0.5

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

@@ -1,129 +1,95 @@
-import OpenAI from 'openai';
-import { PromptFunction, LlmPromptOptions, normalizeOptions } from "./createLlmClient.js";
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlmRetryAttemptError = exports.LlmRetryExhaustedError = exports.LlmRetryError = void 0;
+exports.createLlmRetryClient = createLlmRetryClient;
+const createLlmClient_js_1 = require("./createLlmClient.js");
 // Custom error for the querier to handle, allowing retries with structured feedback.
-export class LlmRetryError extends Error {
-    constructor(
-        public readonly message: string,
-        public readonly type: 'JSON_PARSE_ERROR' | 'CUSTOM_ERROR',
-        public readonly details?: any,
-        public readonly rawResponse?: string | null,
-    ) {
+class LlmRetryError extends Error {
+    message;
+    type;
+    details;
+    rawResponse;
+    constructor(message, type, details, rawResponse) {
         super(message);
+        this.message = message;
+        this.type = type;
+        this.details = details;
+        this.rawResponse = rawResponse;
         this.name = 'LlmRetryError';
     }
 }
-
-export class LlmRetryExhaustedError extends Error {
-    constructor(
-        public readonly message: string,
-        options?: ErrorOptions
-    ) {
+exports.LlmRetryError = LlmRetryError;
+class LlmRetryExhaustedError extends Error {
+    message;
+    constructor(message, options) {
         super(message, options);
+        this.message = message;
         this.name = 'LlmRetryExhaustedError';
     }
 }
-
+exports.LlmRetryExhaustedError = LlmRetryExhaustedError;
 // This error is thrown by LlmRetryClient for each failed attempt.
 // It wraps the underlying error (from API call or validation) and adds context.
-export class LlmRetryAttemptError extends Error {
-    constructor(
-        public readonly message: string,
-        public readonly mode: 'main' | 'fallback',
-        public readonly conversation: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
-        public readonly attemptNumber: number,
-        options?: ErrorOptions
-    ) {
+class LlmRetryAttemptError extends Error {
+    message;
+    mode;
+    conversation;
+    attemptNumber;
+    constructor(message, mode, conversation, attemptNumber, options) {
         super(message, options);
+        this.message = message;
+        this.mode = mode;
+        this.conversation = conversation;
+        this.attemptNumber = attemptNumber;
         this.name = 'LlmRetryAttemptError';
     }
 }
-
-export interface LlmRetryResponseInfo {
-    mode: 'main' | 'fallback';
-    conversation: OpenAI.Chat.Completions.ChatCompletionMessageParam[];
-    attemptNumber: number;
-}
-
-export type LlmRetryOptions<T = any> = LlmPromptOptions & {
-    maxRetries?: number;
-    validate?: (response: any, info: LlmRetryResponseInfo) => Promise<T>;
-};
-
-export interface CreateLlmRetryClientParams {
-    prompt: PromptFunction;
-    fallbackPrompt?: PromptFunction;
-}
-
-function constructLlmMessages(
-    initialMessages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
-    attemptNumber: number,
-    previousError?: LlmRetryAttemptError
-): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {
+exports.LlmRetryAttemptError = LlmRetryAttemptError;
+function constructLlmMessages(initialMessages, attemptNumber, previousError) {
     if (attemptNumber === 0) {
         // First attempt
         return initialMessages;
     }
-
     if (!previousError) {
         // Should not happen for attempt > 0, but as a safeguard...
         throw new Error("Invariant violation: previousError is missing for a retry attempt.");
     }
     const cause = previousError.cause;
-
     if (!(cause instanceof LlmRetryError)) {
-        throw Error('cause must be an instanceof LlmRetryError')
+        throw Error('cause must be an instanceof LlmRetryError');
     }
-
-    const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [...previousError.conversation];
-
+    const messages = [...previousError.conversation];
     messages.push({ role: "user", content: cause.message });
-
     return messages;
 }
-
-export function createLlmRetryClient(params: CreateLlmRetryClientParams) {
+function createLlmRetryClient(params) {
     const { prompt, fallbackPrompt } = params;
-
-    async function runPromptLoop<T>(
-        options: LlmRetryOptions<T>,
-        responseType: 'raw' | 'text' | 'image'
-    ): Promise<T> {
+    async function runPromptLoop(options, responseType) {
         const { maxRetries = 3, validate, messages, ...restOptions } = options;
-        
         // Ensure messages is an array (normalizeOptions ensures this but types might be loose)
-        const initialMessages = messages as OpenAI.Chat.Completions.ChatCompletionMessageParam[];
-
-        let lastError: LlmRetryAttemptError | undefined;
-
+        const initialMessages = messages;
+        let lastError;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             const useFallback = !!fallbackPrompt && attempt > 0;
-            const currentPrompt = useFallback ? fallbackPrompt! : prompt;
+            const currentPrompt = useFallback ? fallbackPrompt : prompt;
             const mode = useFallback ? 'fallback' : 'main';
-
-            const currentMessages = constructLlmMessages(
-                initialMessages,
-                attempt,
-                lastError
-            );
-
+            const currentMessages = constructLlmMessages(initialMessages, attempt, lastError);
             try {
                 const completion = await currentPrompt({
                     messages: currentMessages,
                     ...restOptions,
                 });
-
                 const assistantMessage = completion.choices[0]?.message;
-                let dataToProcess: any = completion;
-                
+                let dataToProcess = completion;
                 if (responseType === 'text') {
                     const content = assistantMessage?.content;
                     if (content === null || content === undefined) {
                         throw new LlmRetryError("LLM returned no text content.", 'CUSTOM_ERROR', undefined, JSON.stringify(completion));
                     }
                     dataToProcess = content;
-                } else if (responseType === 'image') {
-                    const messageAny = assistantMessage as any;
+                }
+                else if (responseType === 'image') {
+                    const messageAny = assistantMessage;
                     if (messageAny.images && Array.isArray(messageAny.images) && messageAny.images.length > 0) {
                         const imageUrl = messageAny.images[0].image_url.url;
                         if (typeof imageUrl === 'string') {
@@ -131,114 +97,69 @@ export function createLlmRetryClient(params: CreateLlmRetryClientParams) {
                                 const imgRes = await fetch(imageUrl);
                                 const arrayBuffer = await imgRes.arrayBuffer();
                                 dataToProcess = Buffer.from(arrayBuffer);
-                            } else {
+                            }
+                            else {
                                 const base64Data = imageUrl.replace(/^data:image\/\w+;base64,/, "");
                                 dataToProcess = Buffer.from(base64Data, 'base64');
                             }
-                        } else {
+                        }
+                        else {
                             throw new LlmRetryError("LLM returned invalid image URL.", 'CUSTOM_ERROR', undefined, JSON.stringify(completion));
                         }
-                    } else {
+                    }
+                    else {
                         throw new LlmRetryError("LLM returned no image.", 'CUSTOM_ERROR', undefined, JSON.stringify(completion));
                     }
                 }
-
                 // Construct conversation history for success or potential error reporting
                 const finalConversation = [...currentMessages];
                 if (assistantMessage) {
                     finalConversation.push(assistantMessage);
                 }
-
-                const info: LlmRetryResponseInfo = {
+                const info = {
                     mode,
                     conversation: finalConversation,
                     attemptNumber: attempt,
                 };
-
                 if (validate) {
                     const result = await validate(dataToProcess, info);
                     return result;
                 }
-
-                return dataToProcess as T;
-
-            } catch (error: any) {
+                return dataToProcess;
+            }
+            catch (error) {
                 if (error instanceof LlmRetryError) {
                     // This is a recoverable error, so we'll create a detailed attempt error and continue the loop.
                     const conversationForError = [...currentMessages];
-                    
                     // If the error contains the raw response (e.g. the invalid text), add it to history
                     // so the LLM knows what it generated previously.
                     if (error.rawResponse) {
                         conversationForError.push({ role: 'assistant', content: error.rawResponse });
-                    } else if (responseType === 'raw' && error.details) {
+                    }
+                    else if (responseType === 'raw' && error.details) {
                         // For raw mode, if we have details, maybe we can infer something, but usually rawResponse is key.
                     }
-
-                    lastError = new LlmRetryAttemptError(
-                        `Attempt ${attempt + 1} failed.`,
-                        mode,
-                        conversationForError, 
-                        attempt,
-                        { cause: error }
-                    );
-                } else {
+                    lastError = new LlmRetryAttemptError(`Attempt ${attempt + 1} failed.`, mode, conversationForError, attempt, { cause: error });
+                }
+                else {
                     // This is a non-recoverable error (e.g., network, API key), so we re-throw it immediately.
                     throw error;
                 }
             }
         }
-
-        throw new LlmRetryExhaustedError(
-            `Operation failed after ${maxRetries + 1} attempts.`,
-            { cause: lastError }
-        );
+        throw new LlmRetryExhaustedError(`Operation failed after ${maxRetries + 1} attempts.`, { cause: lastError });
     }
-
-    async function promptRetry<T = OpenAI.Chat.Completions.ChatCompletion>(
-        content: string,
-        options?: Omit<LlmRetryOptions<T>, 'messages'>
-    ): Promise<T>;
-    async function promptRetry<T = OpenAI.Chat.Completions.ChatCompletion>(
-        options: LlmRetryOptions<T>
-    ): Promise<T>;
-    async function promptRetry<T = OpenAI.Chat.Completions.ChatCompletion>(
-        arg1: string | LlmRetryOptions<T>,
-        arg2?: Omit<LlmRetryOptions<T>, 'messages'>
-    ): Promise<T> {
-        const options = normalizeOptions(arg1, arg2) as LlmRetryOptions<T>;
+    async function promptRetry(arg1, arg2) {
+        const options = (0, createLlmClient_js_1.normalizeOptions)(arg1, arg2);
         return runPromptLoop(options, 'raw');
     }
-
-    async function promptTextRetry<T = string>(
-        content: string,
-        options?: Omit<LlmRetryOptions<T>, 'messages'>
-    ): Promise<T>;
-    async function promptTextRetry<T = string>(
-        options: LlmRetryOptions<T>
-    ): Promise<T>;
-    async function promptTextRetry<T = string>(
-        arg1: string | LlmRetryOptions<T>,
-        arg2?: Omit<LlmRetryOptions<T>, 'messages'>
-    ): Promise<T> {
-        const options = normalizeOptions(arg1, arg2) as LlmRetryOptions<T>;
+    async function promptTextRetry(arg1, arg2) {
+        const options = (0, createLlmClient_js_1.normalizeOptions)(arg1, arg2);
         return runPromptLoop(options, 'text');
     }
-
-    async function promptImageRetry<T = Buffer>(
-        content: string,
-        options?: Omit<LlmRetryOptions<T>, 'messages'>
-    ): Promise<T>;
-    async function promptImageRetry<T = Buffer>(
-        options: LlmRetryOptions<T>
-    ): Promise<T>;
-    async function promptImageRetry<T = Buffer>(
-        arg1: string | LlmRetryOptions<T>,
-        arg2?: Omit<LlmRetryOptions<T>, 'messages'>
-    ): Promise<T> {
-        const options = normalizeOptions(arg1, arg2) as LlmRetryOptions<T>;
+    async function promptImageRetry(arg1, arg2) {
+        const options = (0, createLlmClient_js_1.normalizeOptions)(arg1, arg2);
         return runPromptLoop(options, 'image');
     }
-
     return { promptRetry, promptTextRetry, promptImageRetry };
 }

package/dist/createZodLlmClient.d.ts

@@ -0,0 +1,45 @@
+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;
+};
+export interface CreateZodLlmClientParams {
+    prompt: PromptFunction;
+    isPromptCached: IsPromptCachedFunction;
+    fallbackPrompt?: PromptFunction;
+    disableJsonFixer?: boolean;
+}
+export interface NormalizedZodArgs<T extends ZodTypeAny> {
+    mainInstruction: string;
+    userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[];
+    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 createZodLlmClient(params: CreateZodLlmClientParams): {
+    promptZod: {
+        <T extends ZodTypeAny>(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>(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>;
+    };
+};