llm-fns 1.0.19 → 1.0.21

package/dist/createJsonSchemaLlmClient.d.ts

@@ -1,5 +1,8 @@
 import OpenAI from 'openai';
 import { PromptFunction, LlmCommonOptions } from "./createLlmClient.js";
+export declare class SchemaValidationError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
 /**
  * Options for JSON schema prompt functions.
  * Extends common options with JSON-specific settings.

package/dist/createJsonSchemaLlmClient.js

@@ -3,9 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidationError = void 0;
 exports.createJsonSchemaLlmClient = createJsonSchemaLlmClient;
 const ajv_1 = __importDefault(require("ajv"));
 const createLlmRetryClient_js_1 = require("./createLlmRetryClient.js");
+class SchemaValidationError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'SchemaValidationError';
+    }
+}
+exports.SchemaValidationError = SchemaValidationError;
 function createJsonSchemaLlmClient(params) {
     const { prompt, fallbackPrompt, disableJsonFixer = false } = params;
     const llmRetryClient = (0, createLlmRetryClient_js_1.createLlmRetryClient)({ prompt, fallbackPrompt });
@@ -63,6 +71,11 @@ ${brokenResponse}
             return JSON.parse(jsonDataToParse);
         }
         catch (parseError) {
+            // Only attempt to fix SyntaxErrors (JSON parsing errors).
+            // Other errors (like runtime errors) should bubble up.
+            if (!(parseError instanceof SyntaxError)) {
+                throw parseError;
+            }
             if (disableJsonFixer) {
                 throw parseError;
             }
@@ -87,6 +100,11 @@ ${brokenResponse}
             return validator(jsonData);
         }
         catch (validationError) {
+            // Only attempt to fix known validation errors (SchemaValidationError).
+            // Arbitrary errors thrown by custom validators (e.g. "Database Error") should bubble up.
+            if (!(validationError instanceof SchemaValidationError)) {
+                throw validationError;
+            }
             if (disableJsonFixer) {
                 throw validationError;
             }
@@ -142,8 +160,8 @@ ${schemaJsonString}`;
                 const validate = ajv.compile(schema);
                 const valid = validate(data);
                 if (!valid) {
-                    const errors = validate.errors?.map(e => `${e.instancePath} ${e.message}`).join(', ');
-                    throw new Error(`AJV Validation Error: ${errors}`);
+                    const errors = (validate.errors || []).map(e => `${e.instancePath} ${e.message}`).join(', ');
+                    throw new SchemaValidationError(`AJV Validation Error: ${errors}`);
                 }
                 return data;
             }
@@ -159,24 +177,34 @@ ${schemaJsonString}`;
                 jsonData = await _parseOrFixJson(llmResponseString, schemaJsonString, options);
             }
             catch (parseError) {
-                const errorMessage = `Your previous response resulted in an error.
+                // Only wrap SyntaxErrors (JSON parse errors) for retry.
+                if (parseError instanceof SyntaxError) {
+                    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);
+                    throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'JSON_PARSE_ERROR', undefined, llmResponseString);
+                }
+                // Rethrow other errors (e.g. fatal errors, runtime errors)
+                throw parseError;
             }
             try {
                 const validatedData = await _validateOrFix(jsonData, validator, schemaJsonString, options);
                 return validatedData;
             }
             catch (validationError) {
-                const rawResponseForError = JSON.stringify(jsonData, null, 2);
-                const errorDetails = validationError.message;
-                const errorMessage = `Your previous response resulted in an error.
+                // Only wrap known validation errors for retry.
+                if (validationError instanceof SchemaValidationError) {
+                    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);
+                    throw new createLlmRetryClient_js_1.LlmRetryError(errorMessage, 'CUSTOM_ERROR', validationError, rawResponseForError);
+                }
+                // Rethrow other errors
+                throw validationError;
             }
         };
         const { maxRetries, useResponseFormat: _useResponseFormat, beforeValidation, validator: _validator, ...restOptions } = options || {};

package/dist/createLlmClient.d.ts

@@ -1,5 +1,11 @@
 import OpenAI from "openai";
 import type PQueue from 'p-queue';
+export declare class LlmFatalError extends Error {
+    readonly cause?: any | undefined;
+    readonly messages?: OpenAI.Chat.Completions.ChatCompletionMessageParam[] | undefined;
+    readonly rawResponse?: string | null | undefined;
+    constructor(message: string, cause?: any | undefined, messages?: OpenAI.Chat.Completions.ChatCompletionMessageParam[] | undefined, rawResponse?: string | null | undefined);
+}
 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[];

package/dist/createLlmClient.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlmFatalError = void 0;
 exports.countChars = countChars;
 exports.truncateSingleMessage = truncateSingleMessage;
 exports.truncateMessages = truncateMessages;
@@ -7,6 +8,20 @@ exports.mergeRequestOptions = mergeRequestOptions;
 exports.normalizeOptions = normalizeOptions;
 exports.createLlmClient = createLlmClient;
 const retryUtils_js_1 = require("./retryUtils.js");
+class LlmFatalError extends Error {
+    cause;
+    messages;
+    rawResponse;
+    constructor(message, cause, messages, rawResponse) {
+        super(message);
+        this.cause = cause;
+        this.messages = messages;
+        this.rawResponse = rawResponse;
+        this.name = 'LlmFatalError';
+        this.cause = cause;
+    }
+}
+exports.LlmFatalError = LlmFatalError;
 function countChars(message) {
     if (!message.content)
         return 0;
@@ -222,7 +237,15 @@ function createLlmClient(params) {
         const promptSummary = getPromptSummary(finalMessages);
         const apiCall = async () => {
             const task = () => (0, retryUtils_js_1.executeWithRetry)(async () => {
-                return openai.chat.completions.create(completionParams, requestOptions);
+                try {
+                    return await openai.chat.completions.create(completionParams, requestOptions);
+                }
+                catch (error) {
+                    if (error?.status === 400 || error?.status === 401 || error?.status === 403) {
+                        throw new LlmFatalError(error.message || 'Fatal API Error', error, finalMessages);
+                    }
+                    throw error;
+                }
             }, async (completion) => {
                 if (completion.error) {
                     return {
@@ -231,7 +254,9 @@ function createLlmClient(params) {
                 }
                 return { isValid: true, data: completion };
             }, retries ?? 3, undefined, (error) => {
-                if (error?.status === 401 || error?.code === 'invalid_api_key') {
+                if (error instanceof LlmFatalError)
+                    return false;
+                if (error?.status === 400 || error?.status === 401 || error?.status === 403 || error?.code === 'invalid_api_key') {
                     return false;
                 }
                 return true;

package/dist/createLlmRetryClient.d.ts

@@ -16,7 +16,9 @@ export declare class LlmRetryAttemptError extends Error {
     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);
+    readonly error: Error;
+    readonly rawResponse?: string | null | undefined;
+    constructor(message: string, mode: 'main' | 'fallback', conversation: OpenAI.Chat.Completions.ChatCompletionMessageParam[], attemptNumber: number, error: Error, rawResponse?: string | null | undefined, options?: ErrorOptions);
 }
 export interface LlmRetryResponseInfo {
     mode: 'main' | 'fallback';

package/dist/createLlmRetryClient.js

@@ -32,12 +32,16 @@ class LlmRetryAttemptError extends Error {
     mode;
     conversation;
     attemptNumber;
-    constructor(message, mode, conversation, attemptNumber, options) {
+    error;
+    rawResponse;
+    constructor(message, mode, conversation, attemptNumber, error, rawResponse, options) {
         super(message, options);
         this.message = message;
         this.mode = mode;
         this.conversation = conversation;
         this.attemptNumber = attemptNumber;
+        this.error = error;
+        this.rawResponse = rawResponse;
         this.name = 'LlmRetryAttemptError';
     }
 }
@@ -57,7 +61,7 @@ function constructLlmMessages(initialMessages, attemptNumber, previousError) {
     if (!previousError) {
         throw new Error("Invariant violation: previousError is missing for a retry attempt.");
     }
-    const cause = previousError.cause;
+    const cause = previousError.error;
     if (!(cause instanceof LlmRetryError)) {
         throw Error('cause must be an instanceof LlmRetryError');
     }
@@ -128,12 +132,16 @@ function createLlmRetryClient(params) {
                 return dataToProcess;
             }
             catch (error) {
+                if (error instanceof createLlmClient_js_1.LlmFatalError) {
+                    const fatalAttemptError = new LlmRetryAttemptError(`Fatal error on attempt ${attempt + 1}: ${error.message}`, mode, currentMessages, attempt, error, error.rawResponse, { cause: lastError });
+                    throw new LlmRetryExhaustedError(`Operation failed with fatal error on attempt ${attempt + 1}.`, { cause: fatalAttemptError });
+                }
                 if (error instanceof LlmRetryError) {
                     const conversationForError = [...currentMessages];
                     if (error.rawResponse) {
                         conversationForError.push({ role: 'assistant', content: error.rawResponse });
                     }
-                    lastError = new LlmRetryAttemptError(`Attempt ${attempt + 1} failed.`, mode, conversationForError, attempt, { cause: error });
+                    lastError = new LlmRetryAttemptError(`Attempt ${attempt + 1} failed: ${error.message}`, mode, conversationForError, attempt, error, error.rawResponse, { cause: lastError });
                 }
                 else {
                     throw error;

package/dist/createZodLlmClient.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeZodArgs = normalizeZodArgs;
 exports.createZodLlmClient = createZodLlmClient;
 const z = __importStar(require("zod"));
+const createJsonSchemaLlmClient_js_1 = require("./createJsonSchemaLlmClient.js");
 function isZodSchema(obj) {
     return (typeof obj === 'object' &&
         obj !== null &&
@@ -94,7 +95,15 @@ function createZodLlmClient(params) {
             unrepresentable: 'any'
         });
         const zodValidator = (data) => {
-            return dataExtractionSchema.parse(data);
+            try {
+                return dataExtractionSchema.parse(data);
+            }
+            catch (error) {
+                if (error instanceof z.ZodError) {
+                    throw new createJsonSchemaLlmClient_js_1.SchemaValidationError(error.toString(), { cause: error });
+                }
+                throw error;
+            }
         };
         const result = await jsonSchemaClient.promptJson(messages, schema, {
             ...options,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-fns",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,7 @@
     "ajv": "^8.17.1",
     "openai": "^6.9.1",
     "undici": "^7.16.0",
-    "zod": "^4.1.13"
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "@keyv/sqlite": "^4.0.6",