llm-fns 1.0.3 → 1.0.5

package/dist/createLlmClient.d.ts

@@ -0,0 +1,79 @@
+import OpenAI from "openai";
+import type { Cache } from 'cache-manager';
+import type PQueue from 'p-queue';
+export declare function countChars(message: OpenAI.Chat.Completions.ChatCompletionMessageParam): number;
+export declare function truncateSingleMessage(message: OpenAI.Chat.Completions.ChatCompletionMessageParam, charLimit: number): OpenAI.Chat.Completions.ChatCompletionMessageParam;
+export declare function truncateMessages(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], limit: number): OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+/**
+ * The response format for OpenAI and OpenRouter.
+ * OpenRouter extends this with 'json_schema'.
+ */
+export type ModelConfig = string | ({
+    model?: string;
+} & Record<string, any>);
+export type OpenRouterResponseFormat = {
+    type: 'text' | 'json_object';
+} | {
+    type: 'json_schema';
+    json_schema: {
+        name: string;
+        strict?: boolean;
+        schema: object;
+    };
+};
+/**
+ * Options for the individual "prompt" function calls.
+ * These can override defaults or add call-specific parameters.
+ * 'messages' is a required property, inherited from OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming.
+ */
+export interface LlmPromptOptions extends Omit<OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming, 'model' | 'response_format' | 'modalities' | 'messages'> {
+    messages: string | OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+    model?: ModelConfig;
+    ttl?: number;
+    retries?: number;
+    /** @deprecated Use `reasoning` object instead. */
+    response_format?: OpenRouterResponseFormat;
+    modalities?: string[];
+    image_config?: {
+        aspect_ratio?: string;
+    };
+}
+/**
+ * Options required to create an instance of the LlmClient.
+ * These are the core dependencies.
+ */
+export interface CreateLlmClientParams {
+    openai: OpenAI;
+    cache?: Cache;
+    defaultModel: ModelConfig;
+    maxConversationChars?: number;
+    queue?: PQueue;
+}
+export declare function normalizeOptions(arg1: string | LlmPromptOptions, arg2?: Omit<LlmPromptOptions, 'messages'>): LlmPromptOptions;
+/**
+ * Factory function that creates a GPT "prompt" function, with optional caching.
+ * @param params - The core dependencies (API key, base URL, default model, and optional cache instance).
+ * @returns An async function `prompt` ready to make OpenAI calls, with caching if configured.
+ */
+export declare function createLlmClient(params: CreateLlmClientParams): {
+    prompt: {
+        (content: string, options?: Omit<LlmPromptOptions, "messages">): Promise<OpenAI.Chat.Completions.ChatCompletion>;
+        (options: LlmPromptOptions): Promise<OpenAI.Chat.Completions.ChatCompletion>;
+    };
+    isPromptCached: {
+        (content: string, options?: Omit<LlmPromptOptions, "messages">): Promise<boolean>;
+        (options: LlmPromptOptions): Promise<boolean>;
+    };
+    promptText: {
+        (content: string, options?: Omit<LlmPromptOptions, "messages">): Promise<string>;
+        (options: LlmPromptOptions): Promise<string>;
+    };
+    promptImage: {
+        (content: string, options?: Omit<LlmPromptOptions, "messages">): Promise<Buffer>;
+        (options: LlmPromptOptions): Promise<Buffer>;
+    };
+};
+export type PromptFunction = ReturnType<typeof createLlmClient>['prompt'];
+export type IsPromptCachedFunction = ReturnType<typeof createLlmClient>['isPromptCached'];
+export type PromptTextFunction = ReturnType<typeof createLlmClient>['promptText'];
+export type PromptImageFunction = ReturnType<typeof createLlmClient>['promptImage'];

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

@@ -1,11 +1,18 @@
-import crypto from 'crypto';
-import OpenAI from "openai";
-import type { Cache } from 'cache-manager'; // Using Cache from cache-manager
-import type PQueue from 'p-queue';
-import { executeWithRetry } from './retryUtils.js';
-
-export function countChars(message: OpenAI.Chat.Completions.ChatCompletionMessageParam): number {
-    if (!message.content) return 0;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countChars = countChars;
+exports.truncateSingleMessage = truncateSingleMessage;
+exports.truncateMessages = truncateMessages;
+exports.normalizeOptions = normalizeOptions;
+exports.createLlmClient = createLlmClient;
+const crypto_1 = __importDefault(require("crypto"));
+const retryUtils_js_1 = require("./retryUtils.js");
+function countChars(message) {
+    if (!message.content)
+        return 0;
     if (typeof message.content === 'string') {
         return message.content.length;
     }
@@ -22,97 +29,81 @@ export function countChars(message: OpenAI.Chat.Completions.ChatCompletionMessag
     }
     return 0;
 }
-
-export function truncateSingleMessage(message: OpenAI.Chat.Completions.ChatCompletionMessageParam, charLimit: number): OpenAI.Chat.Completions.ChatCompletionMessageParam {
+function truncateSingleMessage(message, charLimit) {
     const TRUNCATION_SUFFIX = '...[truncated]';
     const messageCopy = JSON.parse(JSON.stringify(message));
-
     if (charLimit <= 0) {
         messageCopy.content = null;
         return messageCopy;
     }
-
     if (!messageCopy.content || countChars(messageCopy) <= charLimit) {
         return messageCopy;
     }
-
     if (typeof messageCopy.content === 'string') {
         let newContent = messageCopy.content;
         if (newContent.length > charLimit) {
             if (charLimit > TRUNCATION_SUFFIX.length) {
                 newContent = newContent.substring(0, charLimit - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
-            } else {
+            }
+            else {
                 newContent = newContent.substring(0, charLimit);
             }
         }
         messageCopy.content = newContent;
         return messageCopy;
     }
-
     if (Array.isArray(messageCopy.content)) {
         // Complex case: multipart message.
         // Strategy: consolidate text, remove images if needed, then truncate text.
-        const textParts = messageCopy.content.filter((p: any) => p.type === 'text');
-        const imageParts = messageCopy.content.filter((p: any) => p.type === 'image_url');
-        let combinedText = textParts.map((p: any) => p.text).join('\n');
+        const textParts = messageCopy.content.filter((p) => p.type === 'text');
+        const imageParts = messageCopy.content.filter((p) => p.type === 'image_url');
+        let combinedText = textParts.map((p) => p.text).join('\n');
         let keptImages = [...imageParts];
-
         while (combinedText.length + (keptImages.length * 2500) > charLimit && keptImages.length > 0) {
             keptImages.pop(); // remove images from the end
         }
-
         const imageChars = keptImages.length * 2500;
         const textCharLimit = charLimit - imageChars;
-
         if (combinedText.length > textCharLimit) {
             if (textCharLimit > TRUNCATION_SUFFIX.length) {
                 combinedText = combinedText.substring(0, textCharLimit - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
-            } else if (textCharLimit >= 0) {
+            }
+            else if (textCharLimit >= 0) {
                 combinedText = combinedText.substring(0, textCharLimit);
-            } else {
+            }
+            else {
                 combinedText = "";
             }
         }
-
-        const newContent: OpenAI.Chat.Completions.ChatCompletionContentPart[] = [];
+        const newContent = [];
         if (combinedText) {
             newContent.push({ type: 'text', text: combinedText });
         }
         newContent.push(...keptImages);
         messageCopy.content = newContent;
     }
-
     return messageCopy;
 }
-
-
-export function truncateMessages(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], limit: number): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {
+function truncateMessages(messages, limit) {
     const systemMessage = messages.find(m => m.role === 'system');
     const otherMessages = messages.filter(m => m.role !== 'system');
-
-    let totalChars = otherMessages.reduce((sum: number, msg) => sum + countChars(msg), 0);
-
+    let totalChars = otherMessages.reduce((sum, msg) => sum + countChars(msg), 0);
     if (totalChars <= limit) {
         return messages;
     }
-
-    const mutableOtherMessages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = JSON.parse(JSON.stringify(otherMessages));
+    const mutableOtherMessages = JSON.parse(JSON.stringify(otherMessages));
     let excessChars = totalChars - limit;
-
     // Truncate messages starting from the second one.
     for (let i = 1; i < mutableOtherMessages.length; i++) {
-        if (excessChars <= 0) break;
-
+        if (excessChars <= 0)
+            break;
         const message = mutableOtherMessages[i];
         const messageChars = countChars(message);
         const charsToCut = Math.min(excessChars, messageChars);
-
         const newCharCount = messageChars - charsToCut;
         mutableOtherMessages[i] = truncateSingleMessage(message, newCharCount);
-
         excessChars -= charsToCut;
     }
-
     // If still over limit, truncate the first message.
     if (excessChars > 0) {
         const firstMessage = mutableOtherMessages[0];
@@ -121,24 +112,23 @@ export function truncateMessages(messages: OpenAI.Chat.Completions.ChatCompletio
         const newCharCount = firstMessageChars - charsToCut;
         mutableOtherMessages[0] = truncateSingleMessage(firstMessage, newCharCount);
     }
-
     // Filter out empty messages (char count is 0)
     const finalMessages = mutableOtherMessages.filter(msg => countChars(msg) > 0);
-
     return systemMessage ? [systemMessage, ...finalMessages] : finalMessages;
 }
-
-function concatMessageText(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[]): string {
-    const textParts: string[] = [];
+function concatMessageText(messages) {
+    const textParts = [];
     for (const message of messages) {
         if (message.content) {
             if (typeof message.content === 'string') {
                 textParts.push(message.content);
-            } else if (Array.isArray(message.content)) {
+            }
+            else if (Array.isArray(message.content)) {
                 for (const part of message.content) {
                     if (part.type === 'text') {
                         textParts.push(part.text);
-                    } else if (part.type === 'image_url') {
+                    }
+                    else if (part.type === 'image_url') {
                         textParts.push('[IMAGE]');
                     }
                 }
@@ -147,68 +137,23 @@ function concatMessageText(messages: OpenAI.Chat.Completions.ChatCompletionMessa
     }
     return textParts.join(' ');
 }
-
-function getPromptSummary(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[]): string {
+function getPromptSummary(messages) {
     const fullText = concatMessageText(messages);
     // Replace multiple whitespace chars with a single space and trim.
     const cleanedText = fullText.replace(/\s+/g, ' ').trim();
-    // Truncate to a reasonable length.
-    const maxLength = 150;
-    if (cleanedText.length > maxLength) {
-        return cleanedText.substring(0, maxLength) + '...';
+    if (cleanedText.length <= 50) {
+        return cleanedText;
     }
-    return cleanedText;
-}
-
-/**
- * The response format for OpenAI and OpenRouter.
- * OpenRouter extends this with 'json_schema'.
- */
-export type ModelConfig = string | ({ model?: string } & Record<string, any>);
-
-export type OpenRouterResponseFormat =
-    | { type: 'text' | 'json_object' }
-    | {
-    type: 'json_schema';
-    json_schema: {
-        name: string;
-        strict?: boolean;
-        schema: object;
-    };
-};
-
-
-/**
- * Options for the individual "prompt" function calls.
- * These can override defaults or add call-specific parameters.
- * 'messages' is a required property, inherited from OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming.
- */
-export interface LlmPromptOptions extends Omit<OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming, 'model' | 'response_format' | 'modalities' | 'messages'> {
-    messages: string | OpenAI.Chat.Completions.ChatCompletionMessageParam[];
-    model?: ModelConfig;    // Allow overriding the default model for a specific call
-    ttl?: number;      // Cache TTL in *MILLISECONDS* for this specific call, used if cache is enabled
-    retries?: number;  // Number of retries for the API call.
-    /** @deprecated Use `reasoning` object instead. */
-    response_format?: OpenRouterResponseFormat;
-    modalities?: string[];
-    image_config?: {
-        aspect_ratio?: string;
-    };
-}
-
-/**
- * Options required to create an instance of the LlmClient.
- * These are the core dependencies.
- */
-export interface CreateLlmClientParams {
-    openai: OpenAI;
-    cache?: Cache; // Cache instance is now optional. Expect a cache-manager compatible instance if provided.
-    defaultModel: ModelConfig; // The default OpenAI model to use if not overridden in LlmPromptOptions
-    maxConversationChars?: number;
-    queue?: PQueue;
+    const partLength = 15;
+    const start = cleanedText.substring(0, partLength);
+    const end = cleanedText.substring(cleanedText.length - partLength);
+    const midIndex = Math.floor(cleanedText.length / 2);
+    const midStart = Math.max(partLength, midIndex - Math.ceil(partLength / 2));
+    const midEnd = Math.min(cleanedText.length - partLength, midStart + partLength);
+    const middle = cleanedText.substring(midStart, midEnd);
+    return `${start}...${middle}...${end}`;
 }
-
-export function normalizeOptions(arg1: string | LlmPromptOptions, arg2?: Omit<LlmPromptOptions, 'messages'>): LlmPromptOptions {
+function normalizeOptions(arg1, arg2) {
     if (typeof arg1 === 'string') {
         return {
             messages: [{ role: 'user', content: arg1 }],
@@ -224,130 +169,100 @@ export function normalizeOptions(arg1: string | LlmPromptOptions, arg2?: Omit<Ll
     }
     return options;
 }
-
 /**
  * Factory function that creates a GPT "prompt" function, with optional caching.
  * @param params - The core dependencies (API key, base URL, default model, and optional cache instance).
  * @returns An async function `prompt` ready to make OpenAI calls, with caching if configured.
  */
-export function createLlmClient(params: CreateLlmClientParams) {
+function createLlmClient(params) {
     const { openai, cache: cacheInstance, defaultModel: factoryDefaultModel, maxConversationChars, queue } = params;
-
-    const getCompletionParamsAndCacheKey = (options: LlmPromptOptions) => {
+    const getCompletionParamsAndCacheKey = (options) => {
         const { ttl, model: callSpecificModel, messages, reasoning_effort, retries, ...restApiOptions } = options;
-
         // Ensure messages is an array (it should be if normalized, but for safety/types)
-        const messagesArray = typeof messages === 'string' 
-            ? [{ role: 'user', content: messages }] as OpenAI.Chat.Completions.ChatCompletionMessageParam[]
+        const messagesArray = typeof messages === 'string'
+            ? [{ role: 'user', content: messages }]
             : messages;
-
         const finalMessages = maxConversationChars ? truncateMessages(messagesArray, maxConversationChars) : messagesArray;
-
         const baseConfig = typeof factoryDefaultModel === 'object' && factoryDefaultModel !== null
             ? factoryDefaultModel
             : (typeof factoryDefaultModel === 'string' ? { model: factoryDefaultModel } : {});
-
         const overrideConfig = typeof callSpecificModel === 'object' && callSpecificModel !== null
             ? callSpecificModel
             : (typeof callSpecificModel === 'string' ? { model: callSpecificModel } : {});
-
         const modelConfig = { ...baseConfig, ...overrideConfig };
-
         const { model: modelToUse, ...modelParams } = modelConfig;
-
         if (typeof modelToUse !== 'string' || !modelToUse) {
             throw new Error('A model must be specified either in the default configuration or in the prompt options.');
         }
-
         const completionParams = {
             ...modelParams,
             model: modelToUse,
             messages: finalMessages,
             ...restApiOptions,
         };
-
-        let cacheKey: string | undefined;
+        let cacheKey;
         if (cacheInstance) {
             const cacheKeyString = JSON.stringify(completionParams);
-            cacheKey = `gptask:${crypto.createHash('md5').update(cacheKeyString).digest('hex')}`;
+            cacheKey = `gptask:${crypto_1.default.createHash('md5').update(cacheKeyString).digest('hex')}`;
         }
-
         return { completionParams, cacheKey, ttl, modelToUse, finalMessages, retries };
     };
-
-    async function prompt(content: string, options?: Omit<LlmPromptOptions, 'messages'>): Promise<OpenAI.Chat.Completions.ChatCompletion>;
-    async function prompt(options: LlmPromptOptions): Promise<OpenAI.Chat.Completions.ChatCompletion>;
-    async function prompt(arg1: string | LlmPromptOptions, arg2?: Omit<LlmPromptOptions, 'messages'>): Promise<OpenAI.Chat.Completions.ChatCompletion> {
+    async function prompt(arg1, arg2) {
         const options = normalizeOptions(arg1, arg2);
         const { completionParams, cacheKey, ttl, modelToUse, finalMessages, retries } = getCompletionParamsAndCacheKey(options);
-
         if (cacheInstance && cacheKey) {
             try {
-                const cachedResponse = await cacheInstance.get<string>(cacheKey);
+                const cachedResponse = await cacheInstance.get(cacheKey);
                 if (cachedResponse !== undefined && cachedResponse !== null) {
                     return JSON.parse(cachedResponse);
                 }
-            } catch (error) {
+            }
+            catch (error) {
                 console.warn("Cache get error:", error);
             }
         }
-
         const promptSummary = getPromptSummary(finalMessages);
-
-        const apiCallAndCache = async (): Promise<OpenAI.Chat.Completions.ChatCompletion> => {
-            const task = () => executeWithRetry<OpenAI.Chat.Completions.ChatCompletion, OpenAI.Chat.Completions.ChatCompletion>(
-                async () => {
-                    return openai.chat.completions.create(completionParams as any);
-                },
-                async (completion) => {
-                    return { isValid: true, data: completion };
-                },
-                retries ?? 3,
-                undefined,
-                (error: any) => {
-                    // Do not retry if the API key is invalid (401) or if the error code explicitly states it.
-                    if (error?.status === 401 || error?.code === 'invalid_api_key') {
-                        return false;
-                    }
-                    return true;
+        const apiCallAndCache = async () => {
+            const task = () => (0, retryUtils_js_1.executeWithRetry)(async () => {
+                return openai.chat.completions.create(completionParams);
+            }, async (completion) => {
+                return { isValid: true, data: completion };
+            }, retries ?? 3, undefined, (error) => {
+                // Do not retry if the API key is invalid (401) or if the error code explicitly states it.
+                if (error?.status === 401 || error?.code === 'invalid_api_key') {
+                    return false;
                 }
-            );
-
-            const response = (await (queue ? queue.add(task, { id: promptSummary } as any) : task())) as OpenAI.Chat.Completions.ChatCompletion;
-
+                return true;
+            });
+            const response = (await (queue ? queue.add(task, { id: promptSummary, messages: finalMessages }) : task()));
             if (cacheInstance && response && cacheKey) {
                 try {
                     await cacheInstance.set(cacheKey, JSON.stringify(response), ttl);
-                } catch (error) {
+                }
+                catch (error) {
                     console.warn("Cache set error:", error);
                 }
             }
             return response;
         };
-
         return apiCallAndCache();
     }
-
-    async function isPromptCached(content: string, options?: Omit<LlmPromptOptions, 'messages'>): Promise<boolean>;
-    async function isPromptCached(options: LlmPromptOptions): Promise<boolean>;
-    async function isPromptCached(arg1: string | LlmPromptOptions, arg2?: Omit<LlmPromptOptions, 'messages'>): Promise<boolean> {
+    async function isPromptCached(arg1, arg2) {
         const options = normalizeOptions(arg1, arg2);
         const { cacheKey } = getCompletionParamsAndCacheKey(options);
         if (!cacheInstance || !cacheKey) {
             return false;
         }
         try {
-            const cachedResponse = await cacheInstance.get<string>(cacheKey);
+            const cachedResponse = await cacheInstance.get(cacheKey);
             return cachedResponse !== undefined && cachedResponse !== null;
-        } catch (error) {
+        }
+        catch (error) {
             console.warn("Cache get error:", error);
             return false;
         }
     }
-
-    async function promptText(content: string, options?: Omit<LlmPromptOptions, 'messages'>): Promise<string>;
-    async function promptText(options: LlmPromptOptions): Promise<string>;
-    async function promptText(arg1: string | LlmPromptOptions, arg2?: Omit<LlmPromptOptions, 'messages'>): Promise<string> {
+    async function promptText(arg1, arg2) {
         const options = normalizeOptions(arg1, arg2);
         const response = await prompt(options);
         const content = response.choices[0]?.message?.content;
@@ -356,14 +271,10 @@ export function createLlmClient(params: CreateLlmClientParams) {
         }
         return content;
     }
-
-    async function promptImage(content: string, options?: Omit<LlmPromptOptions, 'messages'>): Promise<Buffer>;
-    async function promptImage(options: LlmPromptOptions): Promise<Buffer>;
-    async function promptImage(arg1: string | LlmPromptOptions, arg2?: Omit<LlmPromptOptions, 'messages'>): Promise<Buffer> {
+    async function promptImage(arg1, arg2) {
         const options = normalizeOptions(arg1, arg2);
         const response = await prompt(options);
-        const message = response.choices[0]?.message as any;
-
+        const message = response.choices[0]?.message;
         if (message.images && Array.isArray(message.images) && message.images.length > 0) {
             const imageUrl = message.images[0].image_url.url;
             if (typeof imageUrl === 'string') {
@@ -371,7 +282,8 @@ export function createLlmClient(params: CreateLlmClientParams) {
                     const imgRes = await fetch(imageUrl);
                     const arrayBuffer = await imgRes.arrayBuffer();
                     return Buffer.from(arrayBuffer);
-                } else {
+                }
+                else {
                     const base64Data = imageUrl.replace(/^data:image\/\w+;base64,/, "");
                     return Buffer.from(base64Data, 'base64');
                 }
@@ -379,11 +291,5 @@ export function createLlmClient(params: CreateLlmClientParams) {
         }
         throw new Error("LLM returned no image content.");
     }
-
     return { prompt, isPromptCached, promptText, promptImage };
 }
-
-export type PromptFunction = ReturnType<typeof createLlmClient>['prompt'];
-export type IsPromptCachedFunction = ReturnType<typeof createLlmClient>['isPromptCached'];
-export type PromptTextFunction = ReturnType<typeof createLlmClient>['promptText'];
-export type PromptImageFunction = ReturnType<typeof createLlmClient>['promptImage'];

package/dist/createLlmClient.spec.d.ts

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

package/dist/createLlmClient.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const createLlmClient_js_1 = require("./createLlmClient.js");
+(0, vitest_1.describe)('normalizeOptions', () => {
+    (0, vitest_1.it)('should normalize a simple string prompt', () => {
+        const result = (0, createLlmClient_js_1.normalizeOptions)('Hello world');
+        (0, vitest_1.expect)(result).toEqual({
+            messages: [{ role: 'user', content: 'Hello world' }]
+        });
+    });
+    (0, vitest_1.it)('should normalize a string prompt with options', () => {
+        const result = (0, createLlmClient_js_1.normalizeOptions)('Hello world', { temperature: 0.5 });
+        (0, vitest_1.expect)(result).toEqual({
+            messages: [{ role: 'user', content: 'Hello world' }],
+            temperature: 0.5
+        });
+    });
+    (0, vitest_1.it)('should normalize an options object with string messages', () => {
+        const result = (0, createLlmClient_js_1.normalizeOptions)({
+            messages: 'Hello world',
+            temperature: 0.7
+        });
+        (0, vitest_1.expect)(result).toEqual({
+            messages: [{ role: 'user', content: 'Hello world' }],
+            temperature: 0.7
+        });
+    });
+    (0, vitest_1.it)('should pass through an options object with array messages', () => {
+        const messages = [{ role: 'user', content: 'Hello' }];
+        const result = (0, createLlmClient_js_1.normalizeOptions)({
+            messages,
+            temperature: 0.7
+        });
+        (0, vitest_1.expect)(result).toEqual({
+            messages,
+            temperature: 0.7
+        });
+    });
+});

package/dist/createLlmRetryClient.d.ts

@@ -0,0 +1,47 @@
+import OpenAI from 'openai';
+import { PromptFunction, LlmPromptOptions } from "./createLlmClient.js";
+export declare class LlmRetryError extends Error {
+    readonly message: string;
+    readonly type: 'JSON_PARSE_ERROR' | 'CUSTOM_ERROR';
+    readonly details?: any | undefined;
+    readonly rawResponse?: string | null | undefined;
+    constructor(message: string, type: 'JSON_PARSE_ERROR' | 'CUSTOM_ERROR', details?: any | undefined, rawResponse?: string | null | undefined);
+}
+export declare class LlmRetryExhaustedError extends Error {
+    readonly message: string;
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class LlmRetryAttemptError extends Error {
+    readonly message: string;
+    readonly mode: 'main' | 'fallback';
+    readonly conversation: OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+    readonly attemptNumber: number;
+    constructor(message: string, mode: 'main' | 'fallback', conversation: OpenAI.Chat.Completions.ChatCompletionMessageParam[], attemptNumber: number, options?: ErrorOptions);
+}
+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;
+}
+export declare function createLlmRetryClient(params: CreateLlmRetryClientParams): {
+    promptRetry: {
+        <T = OpenAI.Chat.Completions.ChatCompletion>(content: string, options?: Omit<LlmRetryOptions<T>, "messages">): Promise<T>;
+        <T = OpenAI.Chat.Completions.ChatCompletion>(options: LlmRetryOptions<T>): Promise<T>;
+    };
+    promptTextRetry: {
+        <T = string>(content: string, options?: Omit<LlmRetryOptions<T>, "messages">): Promise<T>;
+        <T = string>(options: LlmRetryOptions<T>): Promise<T>;
+    };
+    promptImageRetry: {
+        <T = Buffer<ArrayBufferLike>>(content: string, options?: Omit<LlmRetryOptions<T>, "messages">): Promise<T>;
+        <T = Buffer<ArrayBufferLike>>(options: LlmRetryOptions<T>): Promise<T>;
+    };
+};