@juspay/neurolink 2.0.0 → 2.1.0

package/dist/lib/providers/ollama.js

@@ -12,6 +12,7 @@
  */
 import { streamText, generateText, Output } from "ai";
 import { logger } from "../utils/logger.js";
+import { getDefaultTimeout } from "../utils/timeout.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -275,32 +276,35 @@ class OllamaLanguageModel {
 export class Ollama {
     baseUrl;
     modelName;
-    timeout;
+    defaultTimeout;
     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
+        // Use environment variable for backward compatibility, but convert to format used by other providers
+        const envTimeout = process.env.OLLAMA_TIMEOUT ? parseInt(process.env.OLLAMA_TIMEOUT) : undefined;
+        this.defaultTimeout = envTimeout || parseInt(getDefaultTimeout('ollama', 'generate').replace(/[^\d]/g, ''));
         logger.debug("[Ollama] Initialized", {
             baseUrl: this.baseUrl,
             modelName: this.modelName,
-            timeout: this.timeout,
+            defaultTimeout: this.defaultTimeout,
         });
     }
     /**
      * Gets the appropriate model instance
      * @private
      */
-    getModel() {
+    getModel(timeout) {
         logger.debug("Ollama.getModel - Ollama model selected", {
             modelName: this.modelName,
+            timeout: timeout || this.defaultTimeout,
         });
-        return new OllamaLanguageModel(this.modelName, this.baseUrl, this.timeout);
+        return new OllamaLanguageModel(this.modelName, this.baseUrl, timeout || this.defaultTimeout);
     }
     /**
      * Health check - verify Ollama service is running and accessible
      */
     async checkHealth() {
-        const model = new OllamaLanguageModel(this.modelName, this.baseUrl, this.timeout);
+        const model = new OllamaLanguageModel(this.modelName, this.baseUrl, this.defaultTimeout);
         return await model["checkHealth"]();
     }
     /**
@@ -388,17 +392,22 @@ export class Ollama {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
+            // Convert timeout to milliseconds if provided as string
+            const timeoutMs = timeout
+                ? (typeof timeout === 'string' ? parseInt(getDefaultTimeout('ollama', 'generate').replace(/[^\d]/g, '')) : timeout)
+                : this.defaultTimeout;
             logger.debug(`[${functionTag}] Generate request started`, {
                 provider,
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout: timeoutMs,
             });
-            const model = this.getModel();
+            const model = this.getModel(timeoutMs);
             const generateOptions = {
                 model: model,
                 prompt: prompt,
@@ -446,9 +455,13 @@ export class Ollama {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
+            // Convert timeout to milliseconds if provided as string
+            const timeoutMs = timeout
+                ? (typeof timeout === 'string' ? parseInt(getDefaultTimeout('ollama', 'stream').replace(/[^\d]/g, '')) : timeout)
+                : this.defaultTimeout;
             logger.debug(`[${functionTag}] Stream request started`, {
                 provider,
                 modelName: this.modelName,
@@ -456,8 +469,9 @@ export class Ollama {
                 temperature,
                 maxTokens,
                 hasSchema: !!finalSchema,
+                timeout: timeoutMs,
             });
-            const model = this.getModel();
+            const model = this.getModel(timeoutMs);
             const streamOptions = {
                 model: model,
                 prompt: prompt,

package/dist/lib/providers/openAI.js

@@ -1,6 +1,7 @@
 import { openai } from "@ai-sdk/openai";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, getDefaultTimeout, TimeoutError } from "../utils/timeout.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -59,7 +60,7 @@ export class OpenAI {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, 'stream'), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream text started`, {
@@ -68,13 +69,18 @@ export class OpenAI {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout,
             });
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'stream');
             const streamOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
                 maxTokens,
+                // Add abort signal if available
+                ...(timeoutController && { abortSignal: timeoutController.controller.signal }),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -116,15 +122,28 @@ export class OpenAI {
                 });
             }
             const result = streamText(streamOptions);
+            // For streaming, we can't clean up immediately, but the timeout will auto-clean
+            // The user should handle the stream and any timeout errors
             return result;
         }
         catch (err) {
-            logger.debug(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in streaming text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.debug(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.debug(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in streaming text",
+                    err: String(err),
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }
@@ -136,7 +155,7 @@ export class OpenAI {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, 'generate'), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate text started`, {
@@ -145,36 +164,61 @@ export class OpenAI {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout,
             });
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'generate');
             const generateOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
                 maxTokens,
+                // Add abort signal if available
+                ...(timeoutController && { abortSignal: timeoutController.controller.signal }),
             };
             if (finalSchema) {
                 generateOptions.experimental_output = Output.object({
                     schema: finalSchema,
                 });
             }
-            const result = await generateText(generateOptions);
-            logger.debug(`[${functionTag}] Generate text completed`, {
-                provider,
-                modelName: this.modelName,
-                usage: result.usage,
-                finishReason: result.finishReason,
-                responseLength: result.text?.length || 0,
-            });
-            return result;
+            try {
+                const result = await generateText(generateOptions);
+                // Clean up timeout if successful
+                timeoutController?.cleanup();
+                logger.debug(`[${functionTag}] Generate text completed`, {
+                    provider,
+                    modelName: this.modelName,
+                    usage: result.usage,
+                    finishReason: result.finishReason,
+                    responseLength: result.text?.length || 0,
+                    timeout,
+                });
+                return result;
+            }
+            finally {
+                // Always cleanup timeout
+                timeoutController?.cleanup();
+            }
         }
         catch (err) {
-            logger.debug(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.debug(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.debug(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in generating text",
+                    err: String(err),
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }

package/dist/lib/providers/timeout-wrapper.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Timeout wrapper for AI provider operations
+ *
+ * Provides a consistent way to add timeout functionality to any async operation.
+ */
+/**
+ * Wrap an async operation with a timeout
+ * @param promise - The promise to wrap
+ * @param timeout - Timeout duration (number in ms or string with unit)
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type (generate or stream)
+ * @returns The result of the promise or throws TimeoutError
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeout: number | string | undefined, provider: string, operation: 'generate' | 'stream'): Promise<T>;
+/**
+ * Wrap a streaming async generator with timeout
+ * @param generator - The async generator to wrap
+ * @param timeout - Timeout duration for the entire stream
+ * @param provider - Provider name for error messages
+ * @returns Wrapped async generator that respects timeout
+ */
+export declare function withStreamingTimeout<T>(generator: AsyncGenerator<T>, timeout: number | string | undefined, provider: string): AsyncGenerator<T>;
+/**
+ * Create an abort controller with timeout
+ * @param timeout - Timeout duration
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type
+ * @returns AbortController and cleanup function
+ */
+export declare function createTimeoutController(timeout: number | string | undefined, provider: string, operation: 'generate' | 'stream'): {
+    controller: AbortController;
+    cleanup: () => void;
+    timeoutMs: number;
+} | null;
+/**
+ * Merge abort signals (for combining user abort with timeout)
+ * @param signals - Array of abort signals to merge
+ * @returns Combined abort controller
+ */
+export declare function mergeAbortSignals(signals: (AbortSignal | undefined)[]): AbortController;

package/dist/lib/providers/timeout-wrapper.js

@@ -0,0 +1,100 @@
+/**
+ * Timeout wrapper for AI provider operations
+ *
+ * Provides a consistent way to add timeout functionality to any async operation.
+ */
+import { parseTimeout, TimeoutError, createTimeoutPromise } from '../utils/timeout.js';
+/**
+ * Wrap an async operation with a timeout
+ * @param promise - The promise to wrap
+ * @param timeout - Timeout duration (number in ms or string with unit)
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type (generate or stream)
+ * @returns The result of the promise or throws TimeoutError
+ */
+export async function withTimeout(promise, timeout, provider, operation) {
+    const timeoutPromise = createTimeoutPromise(timeout, provider, operation);
+    if (!timeoutPromise) {
+        // No timeout specified, return original promise
+        return promise;
+    }
+    // Race between the actual operation and timeout
+    return Promise.race([promise, timeoutPromise]);
+}
+/**
+ * Wrap a streaming async generator with timeout
+ * @param generator - The async generator to wrap
+ * @param timeout - Timeout duration for the entire stream
+ * @param provider - Provider name for error messages
+ * @returns Wrapped async generator that respects timeout
+ */
+export async function* withStreamingTimeout(generator, timeout, provider) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        // No timeout, pass through original generator
+        yield* generator;
+        return;
+    }
+    const startTime = Date.now();
+    try {
+        for await (const chunk of generator) {
+            // Check if we've exceeded the timeout
+            if (Date.now() - startTime > timeoutMs) {
+                throw new TimeoutError(`${provider} streaming operation timed out after ${timeout}`, timeoutMs, provider, 'stream');
+            }
+            yield chunk;
+        }
+    }
+    finally {
+        // Ensure generator is properly closed
+        if (generator.return) {
+            await generator.return(undefined);
+        }
+    }
+}
+/**
+ * Create an abort controller with timeout
+ * @param timeout - Timeout duration
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type
+ * @returns AbortController and cleanup function
+ */
+export function createTimeoutController(timeout, provider, operation) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        return null;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+        controller.abort(new TimeoutError(`${provider} ${operation} operation timed out after ${timeout}`, timeoutMs, provider, operation));
+    }, timeoutMs);
+    // Cleanup function to clear the timer
+    const cleanup = () => {
+        clearTimeout(timer);
+    };
+    return { controller, cleanup, timeoutMs };
+}
+/**
+ * Merge abort signals (for combining user abort with timeout)
+ * @param signals - Array of abort signals to merge
+ * @returns Combined abort controller
+ */
+export function mergeAbortSignals(signals) {
+    const controller = new AbortController();
+    // Listen to all signals and abort when any fires
+    for (const signal of signals) {
+        if (signal && !signal.aborted) {
+            signal.addEventListener('abort', () => {
+                if (!controller.signal.aborted) {
+                    controller.abort(signal.reason);
+                }
+            });
+        }
+        // If any signal is already aborted, abort immediately
+        if (signal?.aborted) {
+            controller.abort(signal.reason);
+            break;
+        }
+    }
+    return controller;
+}

package/dist/lib/utils/timeout.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Timeout utilities for NeuroLink
+ *
+ * Provides flexible timeout parsing and error handling for AI operations.
+ * Supports multiple time formats: milliseconds, seconds, minutes, hours.
+ */
+/**
+ * Custom error class for timeout operations
+ */
+export declare class TimeoutError extends Error {
+    readonly timeout: number;
+    readonly provider?: string | undefined;
+    readonly operation?: "generate" | "stream" | undefined;
+    constructor(message: string, timeout: number, provider?: string | undefined, operation?: "generate" | "stream" | undefined);
+}
+/**
+ * Parse timeout value from various formats
+ * @param timeout - Can be number (ms), string with unit, or undefined
+ * @returns Parsed timeout in milliseconds or undefined
+ * @throws Error if format is invalid
+ *
+ * Examples:
+ * - parseTimeout(5000) => 5000
+ * - parseTimeout('30s') => 30000
+ * - parseTimeout('2m') => 120000
+ * - parseTimeout('1.5h') => 5400000
+ * - parseTimeout(undefined) => undefined
+ */
+export declare function parseTimeout(timeout: number | string | undefined): number | undefined;
+/**
+ * Default timeout configurations for different providers and operations
+ */
+export declare const DEFAULT_TIMEOUTS: {
+    global: string;
+    streaming: string;
+    providers: {
+        openai: string;
+        bedrock: string;
+        vertex: string;
+        anthropic: string;
+        azure: string;
+        'google-ai': string;
+        huggingface: string;
+        ollama: string;
+        mistral: string;
+    };
+    tools: {
+        default: string;
+        filesystem: string;
+        network: string;
+        computation: string;
+    };
+};
+/**
+ * Get default timeout for a specific provider
+ * @param provider - Provider name
+ * @param operation - Operation type (generate or stream)
+ * @returns Default timeout string
+ */
+export declare function getDefaultTimeout(provider: string, operation?: 'generate' | 'stream'): string;
+/**
+ * Create a timeout promise that rejects after specified duration
+ * @param timeout - Timeout duration
+ * @param provider - Provider name for error message
+ * @param operation - Operation type for error message
+ * @returns Promise that rejects with TimeoutError
+ */
+export declare function createTimeoutPromise(timeout: number | string | undefined, provider: string, operation: 'generate' | 'stream'): Promise<never> | null;
+export { createTimeoutController } from '../providers/timeout-wrapper.js';

package/dist/lib/utils/timeout.js

@@ -0,0 +1,130 @@
+/**
+ * Timeout utilities for NeuroLink
+ *
+ * Provides flexible timeout parsing and error handling for AI operations.
+ * Supports multiple time formats: milliseconds, seconds, minutes, hours.
+ */
+/**
+ * Custom error class for timeout operations
+ */
+export class TimeoutError extends Error {
+    timeout;
+    provider;
+    operation;
+    constructor(message, timeout, provider, operation) {
+        super(message);
+        this.timeout = timeout;
+        this.provider = provider;
+        this.operation = operation;
+        this.name = 'TimeoutError';
+        // Maintains proper stack trace for where error was thrown
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TimeoutError);
+        }
+    }
+}
+/**
+ * Parse timeout value from various formats
+ * @param timeout - Can be number (ms), string with unit, or undefined
+ * @returns Parsed timeout in milliseconds or undefined
+ * @throws Error if format is invalid
+ *
+ * Examples:
+ * - parseTimeout(5000) => 5000
+ * - parseTimeout('30s') => 30000
+ * - parseTimeout('2m') => 120000
+ * - parseTimeout('1.5h') => 5400000
+ * - parseTimeout(undefined) => undefined
+ */
+export function parseTimeout(timeout) {
+    if (timeout === undefined)
+        return undefined;
+    if (typeof timeout === 'number') {
+        if (timeout <= 0) {
+            throw new Error(`Timeout must be positive, got: ${timeout}`);
+        }
+        return timeout; // Assume milliseconds
+    }
+    if (typeof timeout === 'string') {
+        // Match number (including decimals) followed by optional unit
+        const match = timeout.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+        if (!match) {
+            throw new Error(`Invalid timeout format: ${timeout}. Use formats like '30s', '2m', '500ms', or '1.5h'`);
+        }
+        const value = parseFloat(match[1]);
+        if (value <= 0) {
+            throw new Error(`Timeout must be positive, got: ${value}`);
+        }
+        const unit = match[2] || 'ms';
+        switch (unit) {
+            case 'ms': return value;
+            case 's': return value * 1000;
+            case 'm': return value * 60 * 1000;
+            case 'h': return value * 60 * 60 * 1000;
+            default: return value; // Should never reach here due to regex
+        }
+    }
+    throw new Error(`Invalid timeout type: ${typeof timeout}`);
+}
+/**
+ * Default timeout configurations for different providers and operations
+ */
+export const DEFAULT_TIMEOUTS = {
+    global: '30s', // Default for all providers
+    streaming: '2m', // Longer timeout for streaming operations
+    providers: {
+        openai: '30s', // OpenAI typically responds quickly
+        bedrock: '45s', // AWS can be slower, especially for cold starts
+        vertex: '60s', // Google Cloud can be slower
+        anthropic: '30s', // Direct Anthropic API is fast
+        azure: '30s', // Azure OpenAI similar to OpenAI
+        'google-ai': '30s', // Google AI Studio is fast
+        huggingface: '2m', // Open source models vary significantly
+        ollama: '5m', // Local models need more time, especially large ones
+        mistral: '45s' // Mistral AI moderate speed
+    },
+    tools: {
+        default: '10s', // Default timeout for MCP tool execution
+        filesystem: '5s', // File operations should be quick
+        network: '30s', // Network requests might take longer
+        computation: '2m' // Heavy computation tools need more time
+    }
+};
+/**
+ * Get default timeout for a specific provider
+ * @param provider - Provider name
+ * @param operation - Operation type (generate or stream)
+ * @returns Default timeout string
+ */
+export function getDefaultTimeout(provider, operation = 'generate') {
+    if (operation === 'stream') {
+        return DEFAULT_TIMEOUTS.streaming;
+    }
+    const providerKey = provider.toLowerCase().replace('_', '-');
+    return DEFAULT_TIMEOUTS.providers[providerKey]
+        || DEFAULT_TIMEOUTS.global;
+}
+/**
+ * Create a timeout promise that rejects after specified duration
+ * @param timeout - Timeout duration
+ * @param provider - Provider name for error message
+ * @param operation - Operation type for error message
+ * @returns Promise that rejects with TimeoutError
+ */
+export function createTimeoutPromise(timeout, provider, operation) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        return null; // No timeout
+    }
+    return new Promise((_, reject) => {
+        const timer = setTimeout(() => {
+            reject(new TimeoutError(`${provider} ${operation} operation timed out after ${timeout}`, timeoutMs, provider, operation));
+        }, timeoutMs);
+        // Unref the timer so it doesn't keep the process alive (Node.js only)
+        if (typeof timer === 'object' && timer && 'unref' in timer && typeof timer.unref === 'function') {
+            timer.unref();
+        }
+    });
+}
+// Re-export createTimeoutController from timeout-wrapper for convenience
+export { createTimeoutController } from '../providers/timeout-wrapper.js';

package/dist/neurolink.d.ts

@@ -12,6 +12,7 @@ export interface TextGenerationOptions {
     maxTokens?: number;
     systemPrompt?: string;
     schema?: any;
+    timeout?: number | string;
     disableTools?: boolean;
 }
 export interface StreamTextOptions {
@@ -20,6 +21,7 @@ export interface StreamTextOptions {
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
+    timeout?: number | string;
 }
 export interface TextGenerationResult {
     content: string;