@juspay/neurolink 7.33.3 → 7.34.0

package/dist/lib/neurolink.js

@@ -31,8 +31,7 @@ import { transformToolExecutions, transformToolExecutionsForMCP, transformAvaila
 // Enhanced error handling imports
 import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
 import { EventEmitter } from "events";
-import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
-import { applyConversationMemoryDefaults, getConversationMessages, storeConversationTurn, } from "./utils/conversationMemoryUtils.js";
+import { getConversationMessages, storeConversationTurn, } from "./utils/conversationMemory.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 // Import direct tools server for automatic registration
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
@@ -44,6 +43,9 @@ export class NeuroLink {
     autoDiscoveredServerInfos = [];
     // External MCP server management
     externalServerManager;
+    // Cache for available tools to improve performance
+    toolCache = null;
+    toolCacheDuration;
     // Enhanced error handling support
     toolCircuitBreakers = new Map();
     toolExecutionMetrics = new Map();
@@ -71,6 +73,8 @@ export class NeuroLink {
     }
     // Conversation memory support
     conversationMemory;
+    conversationMemoryNeedsInit = false;
+    conversationMemoryConfig;
     /**
      * Creates a new NeuroLink instance for AI text generation with MCP tool integration.
      *
@@ -100,6 +104,11 @@ export class NeuroLink {
      * @throws {Error} When external server manager initialization fails
      */
     constructor(config) {
+        // Read tool cache duration from environment variables, with a default
+        const cacheDurationEnv = process.env.NEUROLINK_TOOL_CACHE_DURATION;
+        this.toolCacheDuration = cacheDurationEnv
+            ? parseInt(cacheDurationEnv, 10)
+            : 20000;
         const constructorStartTime = Date.now();
         const constructorHrTimeStart = process.hrtime.bigint();
         const constructorId = `neurolink-constructor-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
@@ -208,53 +217,23 @@ export class NeuroLink {
                     maxTurnsPerSession: config.conversationMemory.maxTurnsPerSession,
                     keys: Object.keys(config.conversationMemory),
                 },
-                message: "Starting conversation memory initialization",
+                message: "Conversation memory initialization flag set for lazy loading",
+            });
+            // Store config for later use and set flag for lazy initialization
+            this.conversationMemoryConfig = config;
+            this.conversationMemoryNeedsInit = true;
+            const memoryInitEndTime = process.hrtime.bigint();
+            const memoryInitDurationNs = memoryInitEndTime - memoryInitStartTime;
+            logger.debug(`[NeuroLink] ✅ LOG_POINT_C006_MEMORY_INIT_FLAG_SET_SUCCESS`, {
+                logPoint: "C006_MEMORY_INIT_FLAG_SET_SUCCESS",
+                constructorId,
+                timestamp: new Date().toISOString(),
+                elapsedMs: Date.now() - constructorStartTime,
+                elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                memoryInitDurationNs: memoryInitDurationNs.toString(),
+                memoryInitDurationMs: Number(memoryInitDurationNs) / NANOSECOND_TO_MS_DIVISOR,
+                message: "Conversation memory initialization flag set successfully for lazy loading",
             });
-            try {
-                const memoryConfig = applyConversationMemoryDefaults(config.conversationMemory);
-                const memoryManagerCreateStartTime = process.hrtime.bigint();
-                this.conversationMemory = new ConversationMemoryManager(memoryConfig);
-                const memoryManagerCreateEndTime = process.hrtime.bigint();
-                const memoryManagerCreateDurationNs = memoryManagerCreateEndTime - memoryManagerCreateStartTime;
-                const memoryInitEndTime = process.hrtime.bigint();
-                const memoryInitDurationNs = memoryInitEndTime - memoryInitStartTime;
-                logger.info(`[NeuroLink] ✅ LOG_POINT_C006_MEMORY_INIT_SUCCESS`, {
-                    logPoint: "C006_MEMORY_INIT_SUCCESS",
-                    constructorId,
-                    timestamp: new Date().toISOString(),
-                    elapsedMs: Date.now() - constructorStartTime,
-                    elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
-                    memoryInitDurationNs: memoryInitDurationNs.toString(),
-                    memoryInitDurationMs: Number(memoryInitDurationNs) / NANOSECOND_TO_MS_DIVISOR,
-                    memoryManagerCreateDurationNs: memoryManagerCreateDurationNs.toString(),
-                    memoryManagerCreateDurationMs: Number(memoryManagerCreateDurationNs) / NANOSECOND_TO_MS_DIVISOR,
-                    finalMemoryConfig: {
-                        maxSessions: memoryConfig.maxSessions,
-                        maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
-                    },
-                    memoryUsageAfterInit: process.memoryUsage(),
-                    message: "NeuroLink initialized with conversation memory successfully",
-                });
-            }
-            catch (error) {
-                const memoryInitErrorTime = process.hrtime.bigint();
-                const memoryInitDurationNs = memoryInitErrorTime - memoryInitStartTime;
-                logger.error(`[NeuroLink] ❌ LOG_POINT_C007_MEMORY_INIT_ERROR`, {
-                    logPoint: "C007_MEMORY_INIT_ERROR",
-                    constructorId,
-                    timestamp: new Date().toISOString(),
-                    elapsedMs: Date.now() - constructorStartTime,
-                    elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
-                    memoryInitDurationNs: memoryInitDurationNs.toString(),
-                    memoryInitDurationMs: Number(memoryInitDurationNs) / NANOSECOND_TO_MS_DIVISOR,
-                    error: error instanceof Error ? error.message : String(error),
-                    errorName: error instanceof Error ? error.name : "UnknownError",
-                    errorStack: error instanceof Error ? error.stack : undefined,
-                    memoryConfig: config.conversationMemory,
-                    message: "Conversation memory initialization failed",
-                });
-                throw error;
-            }
         }
         else {
             logger.debug(`[NeuroLink] 🚫 LOG_POINT_C008_MEMORY_DISABLED`, {
@@ -1087,6 +1066,7 @@ export class NeuroLink {
     }
     /**
      * Initialize conversation memory for generation
+     * Lazily initializes memory if needed from constructor flags
      */
     async initializeConversationMemoryForGeneration(generateInternalId, generateInternalStartTime, generateInternalHrTimeStart) {
         const conversationMemoryStartTime = process.hrtime.bigint();
@@ -1098,10 +1078,15 @@ export class NeuroLink {
             elapsedNs: (process.hrtime.bigint() - generateInternalHrTimeStart).toString(),
             conversationMemoryStartTimeNs: conversationMemoryStartTime.toString(),
             hasConversationMemory: !!this.conversationMemory,
-            conversationMemoryEnabled: !!this.conversationMemory,
-            conversationMemoryType: this.conversationMemory?.constructor?.name || "NOT_AVAILABLE",
+            needsLazyInit: this.conversationMemoryNeedsInit,
+            hasConfig: !!this.conversationMemoryConfig,
             message: "Checking conversation memory initialization requirement",
         });
+        // Handle lazy initialization if needed
+        if (this.conversationMemoryNeedsInit && this.conversationMemoryConfig) {
+            await this.lazyInitializeConversationMemory(generateInternalId, generateInternalStartTime, generateInternalHrTimeStart);
+        }
+        // Normal initialization for already created memory manager
         if (this.conversationMemory) {
             logger.debug(`[NeuroLink] 🧠 LOG_POINT_G003_CONVERSATION_MEMORY_INIT_START`, {
                 logPoint: "G003_CONVERSATION_MEMORY_INIT_START",
@@ -1412,7 +1397,7 @@ export class NeuroLink {
                 toolsUsed: result.toolsUsed || [],
                 toolExecutions: transformedToolExecutions,
                 enhancedWithTools: Boolean(hasToolExecutions), // Mark as enhanced if tools were actually used
-                availableTools: transformToolsForMCP(availableTools),
+                availableTools: transformToolsForMCP(transformToolsToExpectedFormat(availableTools)),
                 // Include analytics and evaluation from BaseProvider
                 analytics: result.analytics,
                 evaluation: result.evaluation,
@@ -1517,7 +1502,12 @@ export class NeuroLink {
         if (availableTools.length === 0) {
             return originalSystemPrompt || "";
         }
-        const toolDescriptions = transformToolsToDescriptions(availableTools);
+        const toolDescriptions = transformToolsToDescriptions(availableTools.map((t) => ({
+            name: t.name,
+            description: t.description ?? "",
+            server: t.serverId ?? "unknown",
+            inputSchema: t.inputSchema,
+        })));
         const toolPrompt = `\n\nYou have access to these additional tools if needed:\n${toolDescriptions}\n\nIMPORTANT: You are a general-purpose AI assistant. Answer all requests directly and creatively. These tools are optional helpers - use them only when they would genuinely improve your response. For creative tasks like storytelling, writing, or general conversation, respond naturally without requiring tools.`;
         return (originalSystemPrompt || "") + toolPrompt;
     }
@@ -1648,6 +1638,7 @@ export class NeuroLink {
         const functionTag = "NeuroLink.stream";
         const streamId = `neurolink-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         const journeyStartTime = new Date().toISOString();
+        const originalPrompt = options.input.text; // Store the original prompt for memory storage
         this.logStreamEntryPoint(streamId, journeyStartTime, functionTag, startTime, hrTimeStart, options);
         this.logPerformanceBaseline(streamId, startTime, hrTimeStart);
         await this.validateStreamInput(options, streamId, startTime, hrTimeStart);
@@ -1655,6 +1646,9 @@ export class NeuroLink {
         let enhancedOptions;
         let factoryResult;
         try {
+            // Initialize conversation memory if needed (for lazy loading)
+            await this.initializeConversationMemoryForGeneration(streamId, startTime, hrTimeStart);
+            // Initialize MCP
             await this.initializeMCP();
             factoryResult = processStreamingFactoryOptions(options);
             enhancedOptions = createCleanStreamOptions(options);
@@ -1665,10 +1659,45 @@ export class NeuroLink {
                 }
             }
             const { stream: mcpStream, provider: providerName } = await this.createMCPStream(enhancedOptions);
+            // Create a wrapper around the stream that accumulates content
+            let accumulatedContent = "";
+            const processedStream = (async function* (self) {
+                try {
+                    for await (const chunk of mcpStream) {
+                        if (chunk && "content" in chunk && typeof chunk.content === "string") {
+                            accumulatedContent += chunk.content;
+                            // Emit chunk event for compatibility
+                            self.emitter.emit("response:chunk", chunk.content);
+                        }
+                        yield chunk; // Preserve original streaming behavior
+                    }
+                }
+                finally {
+                    // Store memory after stream consumption is complete
+                    if (self.conversationMemory) {
+                        try {
+                            await self.conversationMemory.storeConversationTurn(enhancedOptions.context
+                                ?.sessionId, enhancedOptions.context
+                                ?.userId, originalPrompt ?? "", accumulatedContent);
+                            logger.debug("Stream conversation turn stored", {
+                                sessionId: enhancedOptions.context
+                                    ?.sessionId,
+                                userInputLength: originalPrompt?.length ?? 0,
+                                responseLength: accumulatedContent.length,
+                            });
+                        }
+                        catch (error) {
+                            logger.warn("Failed to store stream conversation turn", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    }
+                }
+            })(this);
             const streamResult = await this.processStreamResult(mcpStream, enhancedOptions, factoryResult);
             const responseTime = Date.now() - startTime;
             this.emitStreamEndEvents(streamResult);
-            return this.createStreamResponse(streamResult, mcpStream, {
+            return this.createStreamResponse(streamResult, processedStream, {
                 providerName,
                 options,
                 startTime,
@@ -1831,7 +1860,16 @@ export class NeuroLink {
             customTools: this.getCustomTools(),
             executeTool: this.executeTool.bind(this),
         }, "NeuroLink.createMCPStream");
-        const streamResult = await provider.stream(options);
+        // Get conversation messages for context by creating a minimal TextGenerationOptions object
+        const conversationMessages = await getConversationMessages(this.conversationMemory, {
+            prompt: options.input.text,
+            context: options.context,
+        });
+        // Pass conversation history to stream just like in generate method
+        const streamResult = await provider.stream({
+            ...options,
+            conversationMessages, // Inject conversation history
+        });
         return { stream: streamResult.stream, provider: providerName };
     }
     /**
@@ -1884,29 +1922,65 @@ export class NeuroLink {
     /**
      * Handle stream error with fallback
      */
-    async handleStreamError(error, options, startTime, streamId, _enhancedOptions, _factoryResult) {
+    async handleStreamError(error, options, startTime, streamId, enhancedOptions, _factoryResult) {
         logger.error("Stream generation failed, attempting fallback", {
             error: error instanceof Error ? error.message : String(error),
         });
+        const originalPrompt = options.input.text;
         const responseTime = Date.now() - startTime;
         const providerName = await getBestProvider(options.provider);
         const provider = await AIProviderFactory.createProvider(providerName, options.model, false);
-        const fallbackStream = await provider.stream({
+        const fallbackStreamResult = await provider.stream({
             input: { text: options.input.text },
             model: options.model,
             temperature: options.temperature,
             maxTokens: options.maxTokens,
         });
+        // Create a wrapper around the fallback stream that accumulates content
+        let fallbackAccumulatedContent = "";
+        const fallbackProcessedStream = (async function* (self) {
+            try {
+                for await (const chunk of fallbackStreamResult.stream) {
+                    if (chunk && "content" in chunk && typeof chunk.content === "string") {
+                        fallbackAccumulatedContent += chunk.content;
+                        // Emit chunk event
+                        self.emitter.emit("response:chunk", chunk.content);
+                    }
+                    yield chunk; // Preserve original streaming behavior
+                }
+            }
+            finally {
+                // Store memory after fallback stream consumption is complete
+                if (self.conversationMemory) {
+                    try {
+                        const sessionId = enhancedOptions?.context?.sessionId;
+                        const userId = enhancedOptions?.context
+                            ?.userId;
+                        await self.conversationMemory.storeConversationTurn(sessionId || options.context?.sessionId, userId || options.context?.userId, originalPrompt ?? "", fallbackAccumulatedContent);
+                        logger.debug("Fallback stream conversation turn stored", {
+                            sessionId: sessionId || options.context?.sessionId,
+                            userInputLength: originalPrompt?.length ?? 0,
+                            responseLength: fallbackAccumulatedContent.length,
+                        });
+                    }
+                    catch (error) {
+                        logger.warn("Failed to store fallback stream conversation turn", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+        })(this);
         return {
-            stream: fallbackStream.stream,
+            stream: fallbackProcessedStream,
             provider: providerName,
             model: options.model,
-            usage: fallbackStream.usage,
-            finishReason: fallbackStream.finishReason || "stop",
-            toolCalls: fallbackStream.toolCalls || [],
-            toolResults: fallbackStream.toolResults || [],
-            analytics: fallbackStream.analytics,
-            evaluation: fallbackStream.evaluation,
+            usage: fallbackStreamResult.usage,
+            finishReason: fallbackStreamResult.finishReason || "stop",
+            toolCalls: fallbackStreamResult.toolCalls || [],
+            toolResults: fallbackStreamResult.toolResults || [],
+            analytics: fallbackStreamResult.analytics,
+            evaluation: fallbackStreamResult.evaluation,
             metadata: {
                 streamId,
                 startTime,
@@ -2101,6 +2175,7 @@ export class NeuroLink {
      * @param tool - Tool in MCPExecutableTool format (unified MCP protocol type)
      */
     registerTool(name, tool) {
+        this.invalidateToolCache(); // Invalidate cache when a tool is registered
         // Emit tool registration start event
         this.emitter.emit("tools-register:start", {
             toolName: name,
@@ -2191,6 +2266,7 @@ export class NeuroLink {
      * @returns true if the tool was removed, false if it didn't exist
      */
     unregisterTool(name) {
+        this.invalidateToolCache(); // Invalidate cache when a tool is unregistered
         const serverId = `custom-tool-${name}`;
         const removed = toolRegistry.unregisterServer(serverId);
         if (removed) {
@@ -2230,6 +2306,7 @@ export class NeuroLink {
      * @param serverInfo - Server configuration
      */
     async addInMemoryMCPServer(serverId, serverInfo) {
+        this.invalidateToolCache(); // Invalidate cache when a server is added
         try {
             mcpLogger.debug(`[NeuroLink] Registering in-memory MCP server: ${serverId}`);
             // Initialize tools array if not provided
@@ -2417,7 +2494,7 @@ export class NeuroLink {
                 }
                 else if (error.message.includes("not found")) {
                     const availableTools = await this.getAllAvailableTools();
-                    structuredError = ErrorFactory.toolNotFound(toolName, extractToolNames(availableTools));
+                    structuredError = ErrorFactory.toolNotFound(toolName, extractToolNames(availableTools.map((t) => ({ name: t.name }))));
                 }
                 else if (error.message.includes("validation") ||
                     error.message.includes("parameter")) {
@@ -2525,7 +2602,17 @@ export class NeuroLink {
      * Get all available tools including custom and in-memory ones
      * @returns Array of available tools with metadata
      */
+    invalidateToolCache() {
+        this.toolCache = null;
+        logger.debug("Tool cache invalidated");
+    }
     async getAllAvailableTools() {
+        // Return from cache if available and not stale
+        if (this.toolCache &&
+            Date.now() - this.toolCache.timestamp < this.toolCacheDuration) {
+            logger.debug("Returning available tools from cache");
+            return this.toolCache.tools;
+        }
         // 🚀 EXHAUSTIVE LOGGING POINT A001: GET ALL AVAILABLE TOOLS ENTRY
         const getAllToolsId = `get-all-tools-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         const getAllToolsStartTime = Date.now();
@@ -2655,8 +2742,14 @@ export class NeuroLink {
                     mcpLogger.debug("💡 Tool collection optimized for large sets. Memory usage reduced through efficient object reuse.");
                 }
             }
-            // Transform to expected format with required properties
-            return transformToolsToExpectedFormat(uniqueTools);
+            // Return canonical ToolInfo[]; defer presentation transforms to call sites
+            const tools = uniqueTools;
+            // Update the cache
+            this.toolCache = {
+                tools,
+                timestamp: Date.now(),
+            };
+            return tools;
         }
         catch (error) {
             mcpLogger.error("Failed to list available tools", { error });
@@ -3179,6 +3272,9 @@ export class NeuroLink {
      * Get conversation memory statistics (public API)
      */
     async getConversationStats() {
+        // First ensure memory is initialized
+        const initId = `stats-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
         if (!this.conversationMemory) {
             throw new Error("Conversation memory is not enabled");
         }
@@ -3190,6 +3286,9 @@ export class NeuroLink {
      * @returns Array of ChatMessage objects in chronological order, or empty array if session doesn't exist
      */
     async getConversationHistory(sessionId) {
+        // First ensure memory is initialized
+        const initId = `history-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
         if (!this.conversationMemory) {
             throw new Error("Conversation memory is not enabled");
         }
@@ -3198,7 +3297,7 @@ export class NeuroLink {
         }
         try {
             // Use the existing buildContextMessages method to get the complete history
-            const messages = this.conversationMemory.buildContextMessages(sessionId);
+            const messages = await this.conversationMemory.buildContextMessages(sessionId);
             logger.debug("Retrieved conversation history", {
                 sessionId,
                 messageCount: messages.length,
@@ -3219,6 +3318,9 @@ export class NeuroLink {
      * Clear conversation history for a specific session (public API)
      */
     async clearConversationSession(sessionId) {
+        // First ensure memory is initialized
+        const initId = `clear-session-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
         if (!this.conversationMemory) {
             throw new Error("Conversation memory is not enabled");
         }
@@ -3228,6 +3330,9 @@ export class NeuroLink {
      * Clear all conversation history (public API)
      */
     async clearAllConversations() {
+        // First ensure memory is initialized
+        const initId = `clear-all-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
         if (!this.conversationMemory) {
             throw new Error("Conversation memory is not enabled");
         }
@@ -3242,6 +3347,7 @@ export class NeuroLink {
      * @returns Operation result with server instance
      */
     async addExternalMCPServer(serverId, config) {
+        this.invalidateToolCache(); // Invalidate cache when an external server is added
         try {
             mcpLogger.info(`[NeuroLink] Adding external MCP server: ${serverId}`, {
                 command: config.command,
@@ -3280,6 +3386,7 @@ export class NeuroLink {
      * @returns Operation result
      */
     async removeExternalMCPServer(serverId) {
+        this.invalidateToolCache(); // Invalidate cache when an external server is removed
         try {
             mcpLogger.info(`[NeuroLink] Removing external MCP server: ${serverId}`);
             const result = await this.externalServerManager.removeServer(serverId);
@@ -3489,6 +3596,50 @@ export class NeuroLink {
             mcpLogger.error(`[NeuroLink] Failed to unregister external MCP tool ${toolName} from registry:`, error);
         }
     }
+    /**
+     * Lazily initialize conversation memory when needed
+     * This is called the first time a generate or stream operation is performed
+     */
+    async lazyInitializeConversationMemory(generateInternalId, generateInternalStartTime, generateInternalHrTimeStart) {
+        try {
+            // Import the integration module
+            const { initializeConversationMemory } = await import("./core/conversationMemoryInitializer.js");
+            // Use the integration module to create the appropriate memory manager
+            const memoryManagerCreateStartTime = process.hrtime.bigint();
+            const memoryManager = await initializeConversationMemory(this.conversationMemoryConfig);
+            // Assign to conversationMemory with proper type to handle both memory manager types
+            this.conversationMemory = memoryManager;
+            const memoryManagerCreateEndTime = process.hrtime.bigint();
+            const memoryManagerCreateDurationNs = memoryManagerCreateEndTime - memoryManagerCreateStartTime;
+            logger.info(`[NeuroLink] ✅ LOG_POINT_G004_MEMORY_LAZY_INIT_SUCCESS`, {
+                logPoint: "G004_MEMORY_LAZY_INIT_SUCCESS",
+                generateInternalId,
+                timestamp: new Date().toISOString(),
+                elapsedMs: Date.now() - generateInternalStartTime,
+                elapsedNs: (process.hrtime.bigint() - generateInternalHrTimeStart).toString(),
+                memoryManagerCreateDurationNs: memoryManagerCreateDurationNs.toString(),
+                memoryManagerCreateDurationMs: Number(memoryManagerCreateDurationNs) / 1000000,
+                storageType: process.env.STORAGE_TYPE || "memory",
+                message: "Lazy conversation memory initialization completed successfully",
+            });
+            // Reset the lazy init flag since we've now initialized
+            this.conversationMemoryNeedsInit = false;
+        }
+        catch (error) {
+            logger.error(`[NeuroLink] ❌ LOG_POINT_G005_MEMORY_LAZY_INIT_ERROR`, {
+                logPoint: "G005_MEMORY_LAZY_INIT_ERROR",
+                generateInternalId,
+                timestamp: new Date().toISOString(),
+                elapsedMs: Date.now() - generateInternalStartTime,
+                elapsedNs: (process.hrtime.bigint() - generateInternalHrTimeStart).toString(),
+                error: error instanceof Error ? error.message : String(error),
+                errorName: error instanceof Error ? error.name : "UnknownError",
+                errorStack: error instanceof Error ? error.stack : undefined,
+                message: "Lazy conversation memory initialization failed",
+            });
+            throw error;
+        }
+    }
     /**
      * Unregister all external MCP tools from the main registry
      */

package/dist/lib/providers/amazonBedrock.d.ts

@@ -12,9 +12,9 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      * This prevents the health check failure we saw in production logs
      */
     private performInitialHealthCheck;
-    protected getAISDKModel(): never;
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    getAISDKModel(): never;
+    getProviderName(): AIProviderName;
+    getDefaultModel(): string;
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
     private conversationLoop;
     private callBedrock;
@@ -36,5 +36,5 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      * Uses ListFoundationModels API to validate connectivity and permissions
      */
     checkBedrockHealth(): Promise<void>;
-    protected handleProviderError(error: unknown): Error;
+    handleProviderError(error: unknown): Error;
 }

package/dist/lib/providers/amazonBedrock.js

@@ -157,7 +157,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                     },
                 ],
                 inferenceConfig: {
-                    maxTokens: options.maxTokens || 4096,
+                    maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                     temperature: options.temperature || 0.7,
                 },
             };
@@ -718,7 +718,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 },
             ],
             inferenceConfig: {
-                maxTokens: options.maxTokens || 4096,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 temperature: options.temperature || 0.7,
             },
         };

package/dist/lib/providers/anthropic.d.ts

@@ -10,13 +10,13 @@ import { BaseProvider } from "../core/baseProvider.js";
 export declare class AnthropicProvider extends BaseProvider {
     private model;
     constructor(modelName?: string, sdk?: unknown);
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    getProviderName(): AIProviderName;
+    getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Anthropic
      */
-    protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
+    getAISDKModel(): LanguageModelV1;
+    handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     isAvailable(): Promise<boolean>;
     getModel(): LanguageModelV1;

package/dist/lib/providers/anthropic.js

@@ -5,7 +5,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
-import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
@@ -98,7 +98,7 @@ export class AnthropicProvider extends BaseProvider {
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
@@ -111,22 +111,13 @@ export class AnthropicProvider extends BaseProvider {
             // Full tool support is now available with real streaming
             const toolCalls = [];
             const toolResults = [];
-            const usage = await result.usage;
-            const finishReason = await result.finishReason;
             return {
                 stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 toolCalls, // ✅ Include tool calls in stream result
                 toolResults, // ✅ Include tool results in stream result
-                usage: usage
-                    ? {
-                        input: usage.promptTokens || 0,
-                        output: usage.completionTokens || 0,
-                        total: usage.totalTokens || 0,
-                    }
-                    : undefined,
-                finishReason: finishReason || undefined,
+                // Note: omit usage/finishReason to avoid blocking streaming; compute asynchronously if needed.
             };
         }
         catch (error) {

package/dist/lib/providers/anthropicBaseProvider.js

@@ -4,7 +4,6 @@ import { AnthropicModels } from "../types/index.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { validateApiKey, createAnthropicBaseConfig, } from "../utils/providerConfig.js";
 /**
  * Anthropic provider implementation using BaseProvider pattern
@@ -70,7 +69,7 @@ export class AnthropicProviderV2 extends BaseProvider {
                 prompt: options.input.text,
                 system: options.systemPrompt,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,

package/dist/lib/providers/azureOpenai.d.ts

@@ -9,13 +9,13 @@ export declare class AzureOpenAIProvider extends BaseProvider {
     private apiVersion;
     private azureProvider;
     constructor(modelName?: string, sdk?: unknown);
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    getProviderName(): AIProviderName;
+    getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Azure OpenAI
      */
-    protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
+    getAISDKModel(): LanguageModelV1;
+    handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: unknown): Promise<StreamResult>;
 }
 export default AzureOpenAIProvider;