@juspay/neurolink 1.6.0 → 1.10.0

package/dist/providers/ollama.js

@@ -10,20 +10,20 @@
  * - Health checking and service validation
  * - Streaming and non-streaming text generation
  */
-import { streamText, generateText, Output } from 'ai';
-import { logger } from '../utils/logger.js';
+import { streamText, generateText, Output } from "ai";
+import { logger } from "../utils/logger.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
-    systemPrompt: 'You are a helpful AI assistant.'
+    systemPrompt: "You are a helpful AI assistant.",
 };
 // Custom LanguageModelV1 implementation for Ollama
 class OllamaLanguageModel {
-    specificationVersion = 'v1';
-    provider = 'ollama';
+    specificationVersion = "v1";
+    provider = "ollama";
     modelId;
     maxTokens;
     supportsStreaming = true;
-    defaultObjectGenerationMode = 'json';
+    defaultObjectGenerationMode = "json";
     baseUrl;
     timeout;
     constructor(modelId, baseUrl, timeout) {
@@ -36,29 +36,29 @@ class OllamaLanguageModel {
     }
     convertMessagesToPrompt(messages) {
         return messages
-            .map(msg => {
-            if (typeof msg.content === 'string') {
+            .map((msg) => {
+            if (typeof msg.content === "string") {
                 return `${msg.role}: ${msg.content}`;
             }
             else if (Array.isArray(msg.content)) {
                 // Handle multi-part content (text, images, etc.)
                 return `${msg.role}: ${msg.content
-                    .filter((part) => part.type === 'text')
+                    .filter((part) => part.type === "text")
                     .map((part) => part.text)
-                    .join(' ')}`;
+                    .join(" ")}`;
             }
-            return '';
+            return "";
         })
-            .join('\n');
+            .join("\n");
     }
     async checkHealth() {
         try {
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), 5000);
             const response = await fetch(`${this.baseUrl}/api/tags`, {
-                method: 'GET',
+                method: "GET",
                 signal: controller.signal,
-                headers: { 'Content-Type': 'application/json' }
+                headers: { "Content-Type": "application/json" },
             });
             clearTimeout(timeoutId);
             return response.ok;
@@ -70,16 +70,17 @@ class OllamaLanguageModel {
     async ensureModelAvailable() {
         try {
             const response = await fetch(`${this.baseUrl}/api/tags`);
-            if (!response.ok)
-                throw new Error('Cannot access Ollama');
-            const data = await response.json();
-            const models = data.models?.map(m => m.name) || [];
+            if (!response.ok) {
+                throw new Error("Cannot access Ollama");
+            }
+            const data = (await response.json());
+            const models = data.models?.map((m) => m.name) || [];
             if (!models.includes(this.modelId)) {
                 // Try to pull the model
                 const pullResponse = await fetch(`${this.baseUrl}/api/pull`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name: this.modelId })
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ name: this.modelId }),
                 });
                 if (!pullResponse.ok) {
                     throw new Error(`Model '${this.modelId}' not available and cannot be pulled`);
@@ -94,7 +95,7 @@ class OllamaLanguageModel {
         // Health check and model availability
         const isHealthy = await this.checkHealth();
         if (!isHealthy) {
-            throw new Error('Ollama service is not running or accessible. Please ensure Ollama is installed and running.');
+            throw new Error("Ollama service is not running or accessible. Please ensure Ollama is installed and running.");
         }
         await this.ensureModelAvailable();
         const prompt = this.convertMessagesToPrompt(options.prompt);
@@ -105,24 +106,30 @@ class OllamaLanguageModel {
             options: {
                 temperature: options.temperature || 0.7,
                 num_predict: options.maxTokens || 500,
-            }
+            },
         };
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
             const response = await fetch(`${this.baseUrl}/api/generate`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(requestPayload),
-                signal: controller.signal
+                signal: controller.signal,
             });
             clearTimeout(timeoutId);
             if (!response.ok) {
+                if (response.status === 404) {
+                    const errorData = await response.json();
+                    if (errorData.error && errorData.error.includes("not found")) {
+                        throw new Error(`Model '${this.modelId}' not found. Please run 'ollama pull ${this.modelId}'`);
+                    }
+                }
                 throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
             }
-            const data = await response.json();
+            const data = (await response.json());
             if (!data.response) {
-                throw new Error('No response received from Ollama');
+                throw new Error("No response received from Ollama");
             }
             const promptTokens = this.estimateTokens(prompt);
             const completionTokens = this.estimateTokens(data.response);
@@ -131,22 +138,25 @@ class OllamaLanguageModel {
                 usage: {
                     promptTokens,
                     completionTokens,
-                    totalTokens: promptTokens + completionTokens
+                    totalTokens: promptTokens + completionTokens,
                 },
-                finishReason: 'stop',
+                finishReason: "stop",
                 logprobs: undefined,
                 rawCall: { rawPrompt: prompt, rawSettings: options },
-                rawResponse: { headers: {} }
+                rawResponse: { headers: {} },
             };
         }
         catch (error) {
             clearTimeout(timeoutId);
             const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes('AbortError') || errorMessage.includes('timeout')) {
+            if (errorMessage.includes("AbortError") ||
+                errorMessage.includes("timeout")) {
                 throw new Error(`Ollama request timeout (${this.timeout}ms). The model may be large or the system is under load.`);
             }
-            if (errorMessage.includes('ECONNREFUSED') || errorMessage.includes('fetch failed')) {
-                throw new Error('Cannot connect to Ollama service. Please ensure Ollama is installed and running on ' + this.baseUrl);
+            if (errorMessage.includes("ECONNREFUSED") ||
+                errorMessage.includes("fetch failed")) {
+                throw new Error("Cannot connect to Ollama service. Please ensure Ollama is installed and running on " +
+                    this.baseUrl);
             }
             throw error;
         }
@@ -155,7 +165,7 @@ class OllamaLanguageModel {
         // Health check and model availability
         const isHealthy = await this.checkHealth();
         if (!isHealthy) {
-            throw new Error('Ollama service is not running or accessible. Please ensure Ollama is installed and running.');
+            throw new Error("Ollama service is not running or accessible. Please ensure Ollama is installed and running.");
         }
         await this.ensureModelAvailable();
         const prompt = this.convertMessagesToPrompt(options.prompt);
@@ -166,23 +176,29 @@ class OllamaLanguageModel {
             options: {
                 temperature: options.temperature || 0.7,
                 num_predict: options.maxTokens || 500,
-            }
+            },
         };
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
             const response = await fetch(`${this.baseUrl}/api/generate`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(requestPayload),
-                signal: controller.signal
+                signal: controller.signal,
             });
             clearTimeout(timeoutId);
             if (!response.ok) {
+                if (response.status === 404) {
+                    const errorData = await response.json();
+                    if (errorData.error && errorData.error.includes("not found")) {
+                        throw new Error(`Model '${this.modelId}' not found. Please run 'ollama pull ${this.modelId}'`);
+                    }
+                }
                 throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
             }
             if (!response.body) {
-                throw new Error('No response body received from Ollama streaming API');
+                throw new Error("No response body received from Ollama streaming API");
             }
             // Create a ReadableStream that parses Ollama's streaming format
             const stream = new ReadableStream({
@@ -193,29 +209,31 @@ class OllamaLanguageModel {
                     try {
                         while (true) {
                             const { done, value } = await reader.read();
-                            if (done)
+                            if (done) {
                                 break;
+                            }
                             const chunk = decoder.decode(value, { stream: true });
-                            const lines = chunk.split('\n').filter(line => line.trim());
+                            const lines = chunk.split("\n").filter((line) => line.trim());
                             for (const line of lines) {
                                 try {
                                     const data = JSON.parse(line);
                                     if (data.response) {
                                         controller.enqueue({
-                                            type: 'text-delta',
-                                            textDelta: data.response
+                                            type: "text-delta",
+                                            textDelta: data.response,
                                         });
                                         totalTokens += Math.ceil(data.response.length / 4);
                                     }
                                     if (data.done) {
                                         controller.enqueue({
-                                            type: 'finish',
-                                            finishReason: 'stop',
+                                            type: "finish",
+                                            finishReason: "stop",
                                             usage: {
-                                                promptTokens: data.prompt_eval_count || Math.ceil(prompt.length / 4),
-                                                completionTokens: data.eval_count || totalTokens
+                                                promptTokens: data.prompt_eval_count ||
+                                                    Math.ceil(prompt.length / 4),
+                                                completionTokens: data.eval_count || totalTokens,
                                             },
-                                            logprobs: undefined
+                                            logprobs: undefined,
                                         });
                                         controller.close();
                                         return;
@@ -230,22 +248,25 @@ class OllamaLanguageModel {
                     finally {
                         reader.releaseLock();
                     }
-                }
+                },
             });
             return {
                 stream,
                 rawCall: { rawPrompt: prompt, rawSettings: options },
-                rawResponse: { headers: {} }
+                rawResponse: { headers: {} },
             };
         }
         catch (error) {
             clearTimeout(timeoutId);
             const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes('AbortError') || errorMessage.includes('timeout')) {
+            if (errorMessage.includes("AbortError") ||
+                errorMessage.includes("timeout")) {
                 throw new Error(`Ollama streaming timeout (${this.timeout}ms). The model may be large or the system is under load.`);
             }
-            if (errorMessage.includes('ECONNREFUSED') || errorMessage.includes('fetch failed')) {
-                throw new Error('Cannot connect to Ollama service. Please ensure Ollama is installed and running on ' + this.baseUrl);
+            if (errorMessage.includes("ECONNREFUSED") ||
+                errorMessage.includes("fetch failed")) {
+                throw new Error("Cannot connect to Ollama service. Please ensure Ollama is installed and running on " +
+                    this.baseUrl);
             }
             throw error;
         }
@@ -256,13 +277,13 @@ export class Ollama {
     modelName;
     timeout;
     constructor(modelName) {
-        this.baseUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
-        this.modelName = modelName || process.env.OLLAMA_MODEL || 'llama2';
-        this.timeout = parseInt(process.env.OLLAMA_TIMEOUT || '60000'); // 60 seconds default
-        logger.debug('[Ollama] Initialized', {
+        this.baseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+        this.modelName = modelName || process.env.OLLAMA_MODEL || "llama2";
+        this.timeout = parseInt(process.env.OLLAMA_TIMEOUT || "60000"); // 60 seconds default
+        logger.debug("[Ollama] Initialized", {
             baseUrl: this.baseUrl,
             modelName: this.modelName,
-            timeout: this.timeout
+            timeout: this.timeout,
         });
     }
     /**
@@ -270,8 +291,8 @@ export class Ollama {
      * @private
      */
     getModel() {
-        logger.debug('Ollama.getModel - Ollama model selected', {
-            modelName: this.modelName
+        logger.debug("Ollama.getModel - Ollama model selected", {
+            modelName: this.modelName,
         });
         return new OllamaLanguageModel(this.modelName, this.baseUrl, this.timeout);
     }
@@ -280,35 +301,35 @@ export class Ollama {
      */
     async checkHealth() {
         const model = new OllamaLanguageModel(this.modelName, this.baseUrl, this.timeout);
-        return await model['checkHealth']();
+        return await model["checkHealth"]();
     }
     /**
      * List available models on the Ollama instance
      */
     async listModels() {
-        const functionTag = 'Ollama.listModels';
+        const functionTag = "Ollama.listModels";
         try {
             logger.debug(`[${functionTag}] Listing available models`);
             const response = await fetch(`${this.baseUrl}/api/tags`, {
-                method: 'GET',
+                method: "GET",
                 headers: {
-                    'Content-Type': 'application/json'
-                }
+                    "Content-Type": "application/json",
+                },
             });
             if (!response.ok) {
                 throw new Error(`Failed to list models: ${response.status} ${response.statusText}`);
             }
-            const data = await response.json();
-            const modelNames = data.models?.map(model => model.name) || [];
+            const data = (await response.json());
+            const modelNames = data.models?.map((model) => model.name) || [];
             logger.debug(`[${functionTag}] Found models`, {
                 count: modelNames.length,
-                models: modelNames
+                models: modelNames,
             });
             return modelNames;
         }
         catch (error) {
             logger.debug(`[${functionTag}] Error listing models`, {
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
             throw new Error(`Failed to list Ollama models: ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -329,17 +350,17 @@ export class Ollama {
      * Pull/download a model to the local Ollama instance
      */
     async pullModel(modelName) {
-        const functionTag = 'Ollama.pullModel';
+        const functionTag = "Ollama.pullModel";
         try {
             logger.debug(`[${functionTag}] Pulling model`, { modelName });
             const response = await fetch(`${this.baseUrl}/api/pull`, {
-                method: 'POST',
+                method: "POST",
                 headers: {
-                    'Content-Type': 'application/json'
+                    "Content-Type": "application/json",
                 },
                 body: JSON.stringify({
-                    name: modelName
-                })
+                    name: modelName,
+                }),
             });
             if (!response.ok) {
                 throw new Error(`Failed to pull model: ${response.status} ${response.statusText}`);
@@ -351,7 +372,7 @@ export class Ollama {
         catch (error) {
             logger.debug(`[${functionTag}] Error pulling model`, {
                 modelName,
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
             throw new Error(`Failed to pull model '${modelName}': ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -360,14 +381,14 @@ export class Ollama {
      * Generate text using Ollama local models
      */
     async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'Ollama.generateText';
-        const provider = 'ollama';
+        const functionTag = "Ollama.generateText";
+        const provider = "ollama";
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate request started`, {
@@ -375,7 +396,7 @@ export class Ollama {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const model = this.getModel();
             const generateOptions = {
@@ -383,18 +404,23 @@ export class Ollama {
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
-                maxTokens
+                maxTokens,
             };
             if (finalSchema) {
-                generateOptions.experimental_output = Output.object({ schema: finalSchema });
+                generateOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
             }
             const result = await generateText(generateOptions);
+            if (result.text.includes("model not found")) {
+                throw new Error(`Model '${this.modelName}' not found. Please run 'ollama pull ${this.modelName}'`);
+            }
             logger.debug(`[${functionTag}] Generate text completed`, {
                 provider,
                 modelName: this.modelName,
                 usage: result.usage,
                 finishReason: result.finishReason,
-                responseLength: result.text?.length || 0
+                responseLength: result.text?.length || 0,
             });
             return result;
         }
@@ -402,8 +428,8 @@ export class Ollama {
             logger.debug(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in generating text',
-                err: String(err)
+                message: "Error in generating text",
+                err: String(err),
             });
             throw err; // Re-throw error to trigger fallback
         }
@@ -412,15 +438,15 @@ export class Ollama {
      * Generate streaming text using Ollama local models
      */
     async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'Ollama.streamText';
-        const provider = 'ollama';
+        const functionTag = "Ollama.streamText";
+        const provider = "ollama";
         let chunkCount = 0;
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -429,7 +455,7 @@ export class Ollama {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
-                hasSchema: !!finalSchema
+                hasSchema: !!finalSchema,
             });
             const model = this.getModel();
             const streamOptions = {
@@ -448,7 +474,7 @@ export class Ollama {
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
-                        chunkCount
+                        chunkCount,
                     });
                 },
                 onFinish: (event) => {
@@ -459,7 +485,7 @@ export class Ollama {
                         usage: event.usage,
                         totalChunks: chunkCount,
                         promptLength: prompt.length,
-                        responseLength: event.text?.length || 0
+                        responseLength: event.text?.length || 0,
                     });
                 },
                 onChunk: (event) => {
@@ -469,12 +495,14 @@ export class Ollama {
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
                         chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type
+                        chunkType: event.chunk.type,
                     });
-                }
+                },
             };
             if (finalSchema) {
-                streamOptions.experimental_output = Output.object({ schema: finalSchema });
+                streamOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
             }
             const result = streamText(streamOptions);
             return result;
@@ -483,9 +511,11 @@ export class Ollama {
             logger.debug(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in streaming text',
+                message: "Error in streaming text",
                 err: String(err),
-                promptLength: typeof optionsOrPrompt === 'string' ? optionsOrPrompt.length : optionsOrPrompt.prompt.length
+                promptLength: typeof optionsOrPrompt === "string"
+                    ? optionsOrPrompt.length
+                    : optionsOrPrompt.prompt.length,
             });
             throw err; // Re-throw error to trigger fallback
         }

package/dist/providers/openAI.d.ts

@@ -1,10 +1,14 @@
-import type { ZodType, ZodTypeDef } from 'zod';
-import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from 'ai';
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
+import type { ZodType, ZodTypeDef } from "zod";
+import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult, type LanguageModelV1 } from "ai";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
 export declare class OpenAI implements AIProvider {
     private modelName;
     private model;
     constructor(modelName?: string | null);
+    /**
+     * Get the underlying model for function calling
+     */
+    getModel(): LanguageModelV1;
     streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
     generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
 }