@juspay/neurolink 1.11.3 → 2.1.0

package/dist/lib/providers/agent-enhanced-provider.js

@@ -9,6 +9,7 @@ import { anthropic } from "@ai-sdk/anthropic";
 import { getToolsForCategory, } from "../agent/direct-tools.js";
 import { UnifiedMCPSystem } from "../mcp/unified-mcp.js";
 import { mcpLogger } from "../mcp/logging.js";
+import { parseTimeout } from "../utils/timeout.js";
 /**
  * Agent-Enhanced Provider Class
  * Provides AI generation with tool calling capabilities
@@ -114,7 +115,21 @@ export class AgentEnhancedProvider {
                     description: toolInfo.description || `MCP tool: ${toolInfo.name}`,
                     parameters: toolInfo.inputSchema || {},
                     execute: async (args) => {
+                        let timeoutId;
                         try {
+                            // Create timeout controller for tool execution if configured
+                            const toolTimeout = this.config.toolExecutionTimeout;
+                            const toolAbortController = toolTimeout
+                                ? new AbortController()
+                                : undefined;
+                            if (toolAbortController && toolTimeout) {
+                                const timeoutMs = typeof toolTimeout === 'string'
+                                    ? parseTimeout(toolTimeout)
+                                    : toolTimeout;
+                                timeoutId = setTimeout(() => {
+                                    toolAbortController.abort();
+                                }, timeoutMs);
+                            }
                             const context = {
                                 sessionId: 'cli-session',
                                 userId: 'cli-user',
@@ -185,10 +200,33 @@ export class AgentEnhancedProvider {
                                     }
                                 }
                             };
-                            const result = await this.mcpSystem.executeTool(toolInfo.name, args, context);
+                            const toolPromise = this.mcpSystem.executeTool(toolInfo.name, args, context);
+                            let result;
+                            if (toolAbortController) {
+                                // Race between tool execution and timeout
+                                result = await Promise.race([
+                                    toolPromise,
+                                    new Promise((_, reject) => {
+                                        toolAbortController.signal.addEventListener('abort', () => {
+                                            reject(new Error(`Tool ${toolInfo.name} timed out after ${this.config.toolExecutionTimeout}`));
+                                        });
+                                    })
+                                ]);
+                            }
+                            else {
+                                result = await toolPromise;
+                            }
+                            // Clear timeout if successful
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
                             return result.data || result;
                         }
                         catch (error) {
+                            // Clear timeout on error
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
                             mcpLogger.error(`MCP tool ${toolInfo.name} execution failed:`, error);
                             throw error;
                         }
@@ -206,7 +244,7 @@ export class AgentEnhancedProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, schema, } = options;
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, schema, timeout, } = options;
         // Get combined tools (direct + MCP) if enabled
         const tools = this.config.enableTools
             ? await this.getCombinedTools()
@@ -220,6 +258,14 @@ export class AgentEnhancedProvider {
             maxSteps: this.config.maxSteps
         });
         try {
+            // Parse timeout if provided
+            let abortSignal;
+            if (timeout) {
+                const timeoutMs = typeof timeout === 'string' ? parseTimeout(timeout) : timeout;
+                if (timeoutMs !== undefined) {
+                    abortSignal = AbortSignal.timeout(timeoutMs);
+                }
+            }
             // The AI SDK with maxSteps automatically handles tool calling and result integration
             const result = await generateText({
                 model: this.model,
@@ -231,6 +277,7 @@ export class AgentEnhancedProvider {
                 temperature,
                 maxTokens,
                 toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
+                abortSignal, // Pass abort signal for timeout support
             });
             log('Generation completed', {
                 text: result.text?.substring(0, 200),
@@ -307,12 +354,20 @@ export class AgentEnhancedProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, } = options;
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, timeout, } = options;
         // Get combined tools (direct + MCP) if enabled
         const tools = this.config.enableTools
             ? await this.getCombinedTools()
             : {};
         try {
+            // Parse timeout if provided
+            let abortSignal;
+            if (timeout) {
+                const timeoutMs = typeof timeout === 'string' ? parseTimeout(timeout) : timeout;
+                if (timeoutMs !== undefined) {
+                    abortSignal = AbortSignal.timeout(timeoutMs);
+                }
+            }
             const result = await streamText({
                 model: this.model,
                 prompt: systemPrompt
@@ -323,6 +378,7 @@ export class AgentEnhancedProvider {
                 temperature,
                 maxTokens,
                 toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
+                abortSignal, // Pass abort signal for timeout support
             });
             return result;
         }

package/dist/lib/providers/amazonBedrock.js

@@ -1,6 +1,7 @@
 import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
 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.",
@@ -128,7 +129,7 @@ export class AmazonBedrock {
             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`, {
@@ -137,13 +138,18 @@ export class AmazonBedrock {
                 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);
@@ -193,16 +199,30 @@ export class AmazonBedrock {
                 modelName: this.modelName,
                 promptLength: prompt.length,
             });
+            // 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,
-                region: getAWSRegion(),
-                message: "Error in streaming text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    region: getAWSRegion(),
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    region: getAWSRegion(),
+                    message: "Error in streaming text",
+                    err: String(err),
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }
@@ -214,7 +234,7 @@ export class AmazonBedrock {
             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`, {
@@ -224,36 +244,62 @@ export class AmazonBedrock {
                 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.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,
+                    region: getAWSRegion(),
+                    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 instead of returning null
         }
     }

package/dist/lib/providers/anthropic.js

@@ -6,6 +6,7 @@
  */
 import { AIProviderName } from "../core/types.js";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, getDefaultTimeout } from "../utils/timeout.js";
 export class AnthropicProvider {
     name = AIProviderName.ANTHROPIC;
     apiKey;
@@ -29,7 +30,7 @@ export class AnthropicProvider {
     getModel() {
         return this.defaultModel;
     }
-    async makeRequest(endpoint, body, stream = false) {
+    async makeRequest(endpoint, body, stream = false, signal) {
         const url = `${this.baseURL}/v1/${endpoint}`;
         const headers = {
             "Content-Type": "application/json",
@@ -43,6 +44,7 @@ export class AnthropicProvider {
             method: "POST",
             headers,
             body: JSON.stringify(body),
+            signal, // Add abort signal for timeout support
         });
         if (!response.ok) {
             const errorText = await response.text();
@@ -52,13 +54,15 @@ export class AnthropicProvider {
         return response;
     }
     async generateText(optionsOrPrompt, schema) {
-        logger.debug("[AnthropicProvider.generateText] Starting text generation");
+        const functionTag = "AnthropicProvider.generateText";
+        const provider = "anthropic";
+        logger.debug(`[${functionTag}] Starting text generation`);
         // Parse parameters with backward compatibility
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", } = options;
-        logger.debug(`[AnthropicProvider.generateText] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}`);
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, 'generate'), } = options;
+        logger.debug(`[${functionTag}] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}, Timeout: ${timeout}`);
         const requestBody = {
             model: this.getModel(),
             max_tokens: maxTokens,
@@ -71,10 +75,14 @@ export class AnthropicProvider {
             temperature,
             system: systemPrompt,
         };
+        // Create timeout controller if timeout is specified
+        const timeoutController = createTimeoutController(timeout, provider, 'generate');
         try {
-            const response = await this.makeRequest("messages", requestBody);
+            const response = await this.makeRequest("messages", requestBody, false, timeoutController?.controller.signal);
             const data = await response.json();
-            logger.debug(`[AnthropicProvider.generateText] Success. Generated ${data.usage.output_tokens} tokens`);
+            // Clean up timeout if successful
+            timeoutController?.cleanup();
+            logger.debug(`[${functionTag}] Success. Generated ${data.usage.output_tokens} tokens`);
             const content = data.content.map((block) => block.text).join("");
             return {
                 content,
@@ -89,18 +97,42 @@ export class AnthropicProvider {
             };
         }
         catch (error) {
-            logger.error("[AnthropicProvider.generateText] Error:", error);
+            // Always cleanup timeout
+            timeoutController?.cleanup();
+            // Log timeout errors specifically
+            if (error instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: error.timeout,
+                    message: error.message,
+                });
+            }
+            else if (error?.name === 'AbortError') {
+                // Convert AbortError to TimeoutError
+                const timeoutError = new TimeoutError(`${provider} generate operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, 'generate');
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: timeoutController?.timeoutMs,
+                    message: timeoutError.message,
+                });
+                throw timeoutError;
+            }
+            else {
+                logger.error(`[${functionTag}] Error:`, error);
+            }
             throw error;
         }
     }
     async streamText(optionsOrPrompt, schema) {
-        logger.debug("[AnthropicProvider.streamText] Starting text streaming");
+        const functionTag = "AnthropicProvider.streamText";
+        const provider = "anthropic";
+        logger.debug(`[${functionTag}] Starting text streaming`);
         // Parse parameters with backward compatibility
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", } = options;
-        logger.debug(`[AnthropicProvider.streamText] Streaming prompt: "${prompt.substring(0, 100)}..."`);
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, 'stream'), } = options;
+        logger.debug(`[${functionTag}] Streaming prompt: "${prompt.substring(0, 100)}...", Timeout: ${timeout}`);
         const requestBody = {
             model: this.getModel(),
             max_tokens: maxTokens,
@@ -114,30 +146,60 @@ export class AnthropicProvider {
             system: systemPrompt,
             stream: true,
         };
+        // Create timeout controller if timeout is specified
+        const timeoutController = createTimeoutController(timeout, provider, 'stream');
         try {
-            const response = await this.makeRequest("messages", requestBody, true);
+            const response = await this.makeRequest("messages", requestBody, true, timeoutController?.controller.signal);
             if (!response.body) {
                 throw new Error("No response body received");
             }
-            // Return a StreamTextResult-like object
+            // Return a StreamTextResult-like object with timeout signal
             return {
-                textStream: this.createAsyncIterable(response.body),
+                textStream: this.createAsyncIterable(response.body, timeoutController?.controller.signal),
                 text: "",
                 usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
                 finishReason: "end_turn",
+                // Store timeout controller for external cleanup if needed
+                _timeoutController: timeoutController,
             };
         }
         catch (error) {
-            logger.error("[AnthropicProvider.streamText] Error:", error);
+            // Cleanup timeout on error
+            timeoutController?.cleanup();
+            // Log timeout errors specifically
+            if (error instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: error.timeout,
+                    message: error.message,
+                });
+            }
+            else if (error?.name === 'AbortError') {
+                // Convert AbortError to TimeoutError
+                const timeoutError = new TimeoutError(`${provider} stream operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, 'stream');
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: timeoutController?.timeoutMs,
+                    message: timeoutError.message,
+                });
+                throw timeoutError;
+            }
+            else {
+                logger.error(`[${functionTag}] Error:`, error);
+            }
             throw error;
         }
     }
-    async *createAsyncIterable(body) {
+    async *createAsyncIterable(body, signal) {
         const reader = body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
         try {
             while (true) {
+                // Check if aborted
+                if (signal?.aborted) {
+                    throw new Error('AbortError');
+                }
                 const { done, value } = await reader.read();
                 if (done) {
                     break;

package/dist/lib/providers/azureOpenAI.js

@@ -6,6 +6,7 @@
  */
 import { AIProviderName } from "../core/types.js";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, getDefaultTimeout } from "../utils/timeout.js";
 export class AzureOpenAIProvider {
     name = AIProviderName.AZURE;
     apiKey;
@@ -44,7 +45,7 @@ export class AzureOpenAIProvider {
     getApiUrl(stream = false) {
         return `${this.endpoint}/openai/deployments/${this.deploymentId}/chat/completions?api-version=${this.apiVersion}`;
     }
-    async makeRequest(body, stream = false) {
+    async makeRequest(body, stream = false, signal) {
         const url = this.getApiUrl(stream);
         const headers = {
             "Content-Type": "application/json",
@@ -56,6 +57,7 @@ export class AzureOpenAIProvider {
             method: "POST",
             headers,
             body: JSON.stringify(body),
+            signal, // Add abort signal for timeout support
         });
         if (!response.ok) {
             const errorText = await response.text();
@@ -65,13 +67,15 @@ export class AzureOpenAIProvider {
         return response;
     }
     async generateText(optionsOrPrompt, schema) {
-        logger.debug("[AzureOpenAIProvider.generateText] Starting text generation");
+        const functionTag = "AzureOpenAIProvider.generateText";
+        const provider = "azure";
+        logger.debug(`[${functionTag}] Starting text generation`);
         // Parse parameters with backward compatibility
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are a helpful AI assistant.", } = options;
-        logger.debug(`[AzureOpenAIProvider.generateText] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}`);
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are a helpful AI assistant.", timeout = getDefaultTimeout(provider, 'generate'), } = options;
+        logger.debug(`[${functionTag}] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}, Timeout: ${timeout}`);
         const messages = [];
         if (systemPrompt) {
             messages.push({
@@ -88,10 +92,14 @@ export class AzureOpenAIProvider {
             temperature,
             max_tokens: maxTokens,
         };
+        // Create timeout controller if timeout is specified
+        const timeoutController = createTimeoutController(timeout, provider, 'generate');
         try {
-            const response = await this.makeRequest(requestBody);
+            const response = await this.makeRequest(requestBody, false, timeoutController?.controller.signal);
             const data = await response.json();
-            logger.debug(`[AzureOpenAIProvider.generateText] Success. Generated ${data.usage.completion_tokens} tokens`);
+            // Clean up timeout if successful
+            timeoutController?.cleanup();
+            logger.debug(`[${functionTag}] Success. Generated ${data.usage.completion_tokens} tokens`);
             const content = data.choices[0]?.message?.content || "";
             return {
                 content,
@@ -106,18 +114,42 @@ export class AzureOpenAIProvider {
             };
         }
         catch (error) {
-            logger.error("[AzureOpenAIProvider.generateText] Error:", error);
+            // Always cleanup timeout
+            timeoutController?.cleanup();
+            // Log timeout errors specifically
+            if (error instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: error.timeout,
+                    message: error.message,
+                });
+            }
+            else if (error?.name === 'AbortError') {
+                // Convert AbortError to TimeoutError
+                const timeoutError = new TimeoutError(`${provider} generate operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, 'generate');
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: timeoutController?.timeoutMs,
+                    message: timeoutError.message,
+                });
+                throw timeoutError;
+            }
+            else {
+                logger.error(`[${functionTag}] Error:`, error);
+            }
             throw error;
         }
     }
     async streamText(optionsOrPrompt, schema) {
-        logger.debug("[AzureOpenAIProvider.streamText] Starting text streaming");
+        const functionTag = "AzureOpenAIProvider.streamText";
+        const provider = "azure";
+        logger.debug(`[${functionTag}] Starting text streaming`);
         // Parse parameters with backward compatibility
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are a helpful AI assistant.", } = options;
-        logger.debug(`[AzureOpenAIProvider.streamText] Streaming prompt: "${prompt.substring(0, 100)}..."`);
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are a helpful AI assistant.", timeout = getDefaultTimeout(provider, 'stream'), } = options;
+        logger.debug(`[${functionTag}] Streaming prompt: "${prompt.substring(0, 100)}...", Timeout: ${timeout}`);
         const messages = [];
         if (systemPrompt) {
             messages.push({
@@ -135,30 +167,60 @@ export class AzureOpenAIProvider {
             max_tokens: maxTokens,
             stream: true,
         };
+        // Create timeout controller if timeout is specified
+        const timeoutController = createTimeoutController(timeout, provider, 'stream');
         try {
-            const response = await this.makeRequest(requestBody, true);
+            const response = await this.makeRequest(requestBody, true, timeoutController?.controller.signal);
             if (!response.body) {
                 throw new Error("No response body received");
             }
-            // Return a StreamTextResult-like object
+            // Return a StreamTextResult-like object with timeout signal
             return {
-                textStream: this.createAsyncIterable(response.body),
+                textStream: this.createAsyncIterable(response.body, timeoutController?.controller.signal),
                 text: "",
                 usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
                 finishReason: "stop",
+                // Store timeout controller for external cleanup if needed
+                _timeoutController: timeoutController,
             };
         }
         catch (error) {
-            logger.error("[AzureOpenAIProvider.streamText] Error:", error);
+            // Cleanup timeout on error
+            timeoutController?.cleanup();
+            // Log timeout errors specifically
+            if (error instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: error.timeout,
+                    message: error.message,
+                });
+            }
+            else if (error?.name === 'AbortError') {
+                // Convert AbortError to TimeoutError
+                const timeoutError = new TimeoutError(`${provider} stream operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, 'stream');
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    timeout: timeoutController?.timeoutMs,
+                    message: timeoutError.message,
+                });
+                throw timeoutError;
+            }
+            else {
+                logger.error(`[${functionTag}] Error:`, error);
+            }
             throw error;
         }
     }
-    async *createAsyncIterable(body) {
+    async *createAsyncIterable(body, signal) {
         const reader = body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
         try {
             while (true) {
+                // Check if aborted
+                if (signal?.aborted) {
+                    throw new Error('AbortError');
+                }
                 const { done, value } = await reader.read();
                 if (done) {
                     break;