@juspay/neurolink 2.0.0 → 2.1.0

package/dist/lib/providers/googleAIStudio.js

@@ -1,6 +1,7 @@
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, getDefaultTimeout } from "../utils/timeout.js";
 // CRITICAL: Setup environment variables early for AI SDK compatibility
 // The AI SDK specifically looks for GOOGLE_GENERATIVE_AI_API_KEY
 // We need to ensure this is set before any AI SDK operations
@@ -109,7 +110,7 @@ export class GoogleAIStudio {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, 'stream'), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -121,8 +122,11 @@ export class GoogleAIStudio {
                 hasSchema: !!finalSchema,
                 hasTools: !!tools,
                 toolCount: tools ? Object.keys(tools).length : 0,
+                timeout,
             });
             const model = this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'stream');
             const streamOptions = {
                 model: model,
                 prompt: prompt,
@@ -130,6 +134,8 @@ export class GoogleAIStudio {
                 temperature,
                 maxTokens,
                 ...(tools && { tools }), // Add tools if provided
+                // 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);
@@ -171,18 +177,31 @@ export class GoogleAIStudio {
                 });
             }
             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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in streaming text",
-                err: String(err),
-                promptLength: typeof optionsOrPrompt === "string"
-                    ? optionsOrPrompt.length
-                    : optionsOrPrompt.prompt.length,
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in streaming text",
+                    err: String(err),
+                    promptLength: typeof optionsOrPrompt === "string"
+                        ? optionsOrPrompt.length
+                        : optionsOrPrompt.prompt.length,
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }
@@ -200,7 +219,7 @@ export class GoogleAIStudio {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, 'generate'), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate request started`, {
@@ -211,8 +230,11 @@ export class GoogleAIStudio {
                 maxTokens,
                 hasTools: !!tools,
                 toolCount: tools ? Object.keys(tools).length : 0,
+                timeout,
             });
             const model = this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'generate');
             const generateOptions = {
                 model: model,
                 prompt: prompt,
@@ -223,29 +245,51 @@ export class GoogleAIStudio {
                     tools,
                     maxSteps: 5, // Allow multiple steps for tool execution and response generation
                 }), // Add tools if provided
+                // 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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${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/googleVertexAI.js

@@ -23,6 +23,7 @@ async function getCreateVertexAnthropic() {
 }
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, getDefaultTimeout } from "../utils/timeout.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -285,7 +286,7 @@ export class GoogleVertexAI {
             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 request started`, {
@@ -296,14 +297,19 @@ export class GoogleVertexAI {
                 temperature,
                 maxTokens,
                 hasSchema: !!finalSchema,
+                timeout,
             });
             const model = await this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'stream');
             const streamOptions = {
                 model: 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);
@@ -345,16 +351,30 @@ export class GoogleVertexAI {
                 });
             }
             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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in streaming text",
-                err: String(err),
-                promptLength: prompt.length,
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    isAnthropic: isAnthropicModel(this.modelName),
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in streaming text",
+                    err: String(err),
+                    promptLength: prompt.length,
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }
@@ -372,7 +392,7 @@ export class GoogleVertexAI {
             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 request started`, {
@@ -382,37 +402,63 @@ export class GoogleVertexAI {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout,
             });
             const model = await this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'generate');
             const generateOptions = {
                 model: 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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    isAnthropic: isAnthropicModel(this.modelName),
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${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/huggingFace.js

@@ -1,6 +1,7 @@
 import { HfInference } from "@huggingface/inference";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, getDefaultTimeout } from "../utils/timeout.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -228,7 +229,7 @@ export class HuggingFace {
             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 request started`, {
@@ -238,14 +239,19 @@ export class HuggingFace {
                 temperature,
                 maxTokens,
                 hasSchema: !!finalSchema,
+                timeout,
             });
             const model = this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'stream');
             const streamOptions = {
                 model: 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);
@@ -287,18 +293,31 @@ export class HuggingFace {
                 });
             }
             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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in streaming text",
-                err: String(err),
-                promptLength: typeof optionsOrPrompt === "string"
-                    ? optionsOrPrompt.length
-                    : optionsOrPrompt.prompt.length,
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in streaming text",
+                    err: String(err),
+                    promptLength: typeof optionsOrPrompt === "string"
+                        ? optionsOrPrompt.length
+                        : optionsOrPrompt.prompt.length,
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }
@@ -316,7 +335,7 @@ export class HuggingFace {
             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 request started`, {
@@ -325,37 +344,62 @@ export class HuggingFace {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout,
             });
             const model = this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'generate');
             const generateOptions = {
                 model: 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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${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/mistralAI.js

@@ -1,6 +1,7 @@
 import { createMistral } from "@ai-sdk/mistral";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, getDefaultTimeout } from "../utils/timeout.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -88,7 +89,7 @@ export class MistralAI {
             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 request started`, {
@@ -98,14 +99,19 @@ export class MistralAI {
                 temperature,
                 maxTokens,
                 hasSchema: !!finalSchema,
+                timeout,
             });
             const model = this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'stream');
             const streamOptions = {
                 model: 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);
@@ -147,18 +153,31 @@ export class MistralAI {
                 });
             }
             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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in streaming text",
-                err: String(err),
-                promptLength: typeof optionsOrPrompt === "string"
-                    ? optionsOrPrompt.length
-                    : optionsOrPrompt.prompt.length,
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in streaming text",
+                    err: String(err),
+                    promptLength: typeof optionsOrPrompt === "string"
+                        ? optionsOrPrompt.length
+                        : optionsOrPrompt.prompt.length,
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }
@@ -176,7 +195,7 @@ export class MistralAI {
             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 request started`, {
@@ -185,37 +204,62 @@ export class MistralAI {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout,
             });
             const model = this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, 'generate');
             const generateOptions = {
                 model: 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.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${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/ollama.d.ts

@@ -17,7 +17,7 @@ import type { Schema } from "ai";
 export declare class Ollama implements AIProvider {
     private baseUrl;
     private modelName;
-    private timeout;
+    private defaultTimeout;
     constructor(modelName?: string);
     /**
      * Gets the appropriate model instance