llm-fns 1.0.8 → 1.0.10

package/dist/createJsonSchemaLlmClient.d.ts

@@ -23,7 +23,8 @@ export interface CreateJsonSchemaLlmClientParams {
     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>;
+    promptJson: <T>(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], schema: Record<string, any>, options?: JsonSchemaLlmClientOptions) => Promise<T>;
     isPromptJsonCached: (messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], schema: Record<string, any>, options?: JsonSchemaLlmClientOptions) => Promise<boolean>;
 };
 export type JsonSchemaClient = ReturnType<typeof createJsonSchemaLlmClient>;
+export type PromptJsonFunction = JsonSchemaClient['promptJson'];

package/dist/createJsonSchemaLlmClient.js

@@ -1,10 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJsonSchemaLlmClient = createJsonSchemaLlmClient;
+const ajv_1 = __importDefault(require("ajv"));
 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 });
+    const ajv = new ajv_1.default({ strict: false }); // Initialize AJV
     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.
@@ -140,7 +145,17 @@ ${schemaJsonString}`;
             : undefined;
         return { finalMessages, schemaJsonString, response_format };
     }
-    async function promptJson(messages, schema, validator, options) {
+    async function promptJson(messages, schema, options) {
+        // Always validate against the schema using AJV
+        const ajvValidator = (data) => {
+            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}`);
+            }
+            return data;
+        };
         const { finalMessages, schemaJsonString, response_format } = _getJsonPromptConfig(messages, schema, options);
         const processResponse = async (llmResponseString) => {
             let jsonData;
@@ -155,7 +170,7 @@ 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);
+                const validatedData = await _validateOrFix(jsonData, ajvValidator, schemaJsonString, options);
                 return validatedData;
             }
             catch (validationError) {

package/dist/createLlmRetryClient.d.ts

@@ -45,3 +45,4 @@ export declare function createLlmRetryClient(params: CreateLlmRetryClientParams)
         <T = Buffer<ArrayBufferLike>>(options: LlmRetryOptions<T>): Promise<T>;
     };
 };
+export type LlmRetryClient = ReturnType<typeof createLlmRetryClient>;

package/dist/createZodLlmClient.d.ts

@@ -26,3 +26,5 @@ export declare function createZodLlmClient(params: CreateZodLlmClientParams): {
         <T extends ZodTypeAny>(mainInstruction: string, userMessagePayload: string | OpenAI.Chat.Completions.ChatCompletionContentPart[], dataExtractionSchema: T, options?: ZodLlmClientOptions): Promise<boolean>;
     };
 };
+export type ZodLlmClient = ReturnType<typeof createZodLlmClient>;
+export type PromptZodFunction = ZodLlmClient['promptZod'];

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 zod_1 = require("zod");
 function isZodSchema(obj) {
     return (typeof obj === 'object' &&
         obj !== null &&
@@ -94,19 +93,11 @@ function createZodLlmClient(params) {
         const schema = z.toJSONSchema(dataExtractionSchema, {
             unrepresentable: 'any'
         });
-        const validator = (data) => {
-            try {
-                return dataExtractionSchema.parse(data);
-            }
-            catch (error) {
-                if (error instanceof zod_1.ZodError) {
-                    // Format the error nicely for the LLM
-                    throw new Error(JSON.stringify(error.format(), null, 2));
-                }
-                throw error;
-            }
-        };
-        return jsonSchemaClient.promptJson(messages, schema, validator, options);
+        const result = await jsonSchemaClient.promptJson(messages, schema, options);
+        // We still parse with Zod to ensure the types are correct and to apply any transformations/refinements
+        // that JSON Schema might not capture perfectly, or just to get the typed return.
+        // Note: If this fails, it won't trigger a retry in promptJson anymore, because promptJson only retries on AJV errors.
+        return dataExtractionSchema.parse(result);
     }
     async function isPromptZodCached(arg1, arg2, arg3, arg4) {
         const { messages, dataExtractionSchema, options } = normalizeZodArgs(arg1, arg2, arg3, arg4);

package/dist/llmFactory.d.ts

@@ -14,7 +14,7 @@ export declare function createLlm(params: CreateLlmFactoryParams): {
         <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>;
+    promptJson: <T>(messages: import("openai/resources/index.js").ChatCompletionMessageParam[], schema: Record<string, any>, 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>;
@@ -45,3 +45,4 @@ export declare function createLlm(params: CreateLlmFactoryParams): {
         (options: import("./createLlmClient.js").LlmPromptOptions): Promise<Buffer>;
     };
 };
+export type LlmClient = ReturnType<typeof createLlm>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-fns",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,6 +11,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "ajv": "^8.17.1",
     "openai": "^6.9.1",
     "zod": "^4.1.13"
   },

package/readme.md

@@ -7,7 +7,7 @@ Designed for power users who need to switch between simple string prompts and co
 ## Installation
 
 ```bash
-npm install openai zod cache-manager p-queue
+npm install openai zod cache-manager p-queue ajv
 ```
 
 ## Quick Start (Factory)
@@ -122,7 +122,7 @@ This is a high-level wrapper that employs a **Re-asking Loop**. If the LLM outpu
 **Return Type:** `Promise<T>`
 
 ### Level 1: Raw JSON Schema (`promptJson`)
-Use this if you have a standard JSON Schema object (e.g. from another library or API) and don't want to use Zod.
+Use this if you have a standard JSON Schema object (e.g. from another library or API) and don't want to use Zod. It uses **AJV** internally to validate the response against the schema.
 
 ```typescript
 const MySchema = {
@@ -137,8 +137,7 @@ const MySchema = {
 
 const result = await llm.promptJson(
     [{ role: "user", content: "I love this!" }],
-    MySchema,
-    (data) => data // Optional validator function
+    MySchema
 );
 ```