@hashgraphonline/conversational-agent 0.1.208 → 0.1.210

package/src/langchain-agent.ts

@@ -24,12 +24,14 @@ import {
 import { MCPClientManager } from './mcp/MCPClientManager';
 import { convertMCPToolToLangChain } from './mcp/adapters/langchain';
 import { SmartMemoryManager } from './memory/SmartMemoryManager';
+import type { MCPConnectionStatus } from './mcp/types';
 
 export class LangChainAgent extends BaseAgent {
   private executor: ContentAwareAgentExecutor | undefined;
   private systemMessage = '';
   private mcpManager?: MCPClientManager;
   private smartMemory: SmartMemoryManager | undefined;
+  private mcpConnectionStatus: Map<string, MCPConnectionStatus> = new Map();
 
   async boot(): Promise<void> {
     if (this.initialized) {
@@ -51,26 +53,32 @@ export class LangChainAgent extends BaseAgent {
       this.tools = this.filterTools(allTools);
 
       if (this.config.mcp?.servers && this.config.mcp.servers.length > 0) {
-        await this.initializeMCP();
+        if (this.config.mcp.autoConnect !== false) {
+          await this.initializeMCP();
+        } else {
+          this.logger.info(
+            'MCP servers configured but autoConnect=false, skipping synchronous connection'
+          );
+          this.mcpManager = new MCPClientManager(this.logger);
+        }
       }
 
       this.smartMemory = new SmartMemoryManager({
         modelName,
         maxTokens: 90000,
         reserveTokens: 10000,
-        storageLimit: 1000
+        storageLimit: 1000,
       });
-      
+
       this.logger.info('SmartMemoryManager initialized:', {
         modelName,
         toolsCount: this.tools.length,
         maxTokens: 90000,
-        reserveTokens: 10000
+        reserveTokens: 10000,
       });
 
       this.systemMessage = this.buildSystemPrompt();
-      
-      // Set the system prompt in smart memory
+
       this.smartMemory.setSystemPrompt(this.systemMessage);
 
       await this.createExecutor();
@@ -92,31 +100,31 @@ export class LangChainAgent extends BaseAgent {
     }
 
     try {
-      this.logger.info('LangChainAgent.chat called with:', { message, contextLength: context?.messages?.length || 0 });
-      
-      // If context is provided, populate smart memory with previous messages
+      this.logger.info('LangChainAgent.chat called with:', {
+        message,
+        contextLength: context?.messages?.length || 0,
+      });
+
       if (context?.messages && context.messages.length > 0) {
-        // Clear existing memory and add messages from context
         this.smartMemory.clear();
-        
+
         for (const msg of context.messages) {
           this.smartMemory.addMessage(msg);
         }
       }
-      
-      // Add the current user message to memory
+
       const { HumanMessage } = await import('@langchain/core/messages');
       this.smartMemory.addMessage(new HumanMessage(message));
-      
+
       const memoryStats = this.smartMemory.getMemoryStats();
       this.logger.info('Memory stats before execution:', {
         totalMessages: memoryStats.totalActiveMessages,
         currentTokens: memoryStats.currentTokenCount,
         maxTokens: memoryStats.maxTokens,
         usagePercentage: memoryStats.usagePercentage,
-        toolsCount: this.tools.length
+        toolsCount: this.tools.length,
       });
-      
+
       const result = await this.executor.invoke({
         input: message,
         chat_history: this.smartMemory.getMessages(),
@@ -131,15 +139,19 @@ export class LangChainAgent extends BaseAgent {
         intermediateSteps: result.intermediateSteps,
       };
 
-      // Extract tool calls from intermediate steps
       if (result.intermediateSteps && Array.isArray(result.intermediateSteps)) {
-        const toolCalls = result.intermediateSteps.map((step: any, index: number) => ({
-          id: `call_${index}`,
-          name: step.action?.tool || 'unknown',
-          args: step.action?.toolInput || {},
-          output: typeof step.observation === 'string' ? step.observation : JSON.stringify(step.observation)
-        }));
-        
+        const toolCalls = result.intermediateSteps.map(
+          (step: any, index: number) => ({
+            id: `call_${index}`,
+            name: step.action?.tool || 'unknown',
+            args: step.action?.toolInput || {},
+            output:
+              typeof step.observation === 'string'
+                ? step.observation
+                : JSON.stringify(step.observation),
+          })
+        );
+
         if (toolCalls.length > 0) {
           response.tool_calls = toolCalls;
         }
@@ -163,7 +175,6 @@ export class LangChainAgent extends BaseAgent {
         response.output = 'Agent action complete.';
       }
 
-      // Add the AI response to memory
       if (response.output) {
         const { AIMessage } = await import('@langchain/core/messages');
         this.smartMemory.addMessage(new AIMessage(response.output));
@@ -184,8 +195,8 @@ export class LangChainAgent extends BaseAgent {
           activeMessages: finalMemoryStats.totalActiveMessages,
           tokenUsage: finalMemoryStats.currentTokenCount,
           maxTokens: finalMemoryStats.maxTokens,
-          usagePercentage: finalMemoryStats.usagePercentage
-        }
+          usagePercentage: finalMemoryStats.usagePercentage,
+        },
       };
 
       this.logger.info('LangChainAgent.chat returning response:', response);
@@ -261,6 +272,9 @@ export class LangChainAgent extends BaseAgent {
     }
   }
 
+  getMCPConnectionStatus(): Map<string, MCPConnectionStatus> {
+    return new Map(this.mcpConnectionStatus);
+  }
 
   private async createAgentKit(): Promise<HederaAgentKit> {
     const corePlugins = getAllHederaCorePlugins();
@@ -276,7 +290,7 @@ export class LangChainAgent extends BaseAgent {
       { plugins },
       operationalMode,
       this.config.execution?.userAccountId,
-      this.config.execution?.scheduleUserTransactionsInBytesMode ?? true,
+      this.config.execution?.scheduleUserTransactionsInBytesMode ?? false,
       undefined,
       modelName,
       this.config.extensions?.mirrorConfig,
@@ -296,11 +310,16 @@ export class LangChainAgent extends BaseAgent {
         throw new Error('OpenAI API key required');
       }
 
+      const modelName = this.config.ai?.modelName || 'gpt-4o-mini';
+      const isGPT5Model =
+        modelName.toLowerCase().includes('gpt-5') ||
+        modelName.toLowerCase().includes('gpt5');
+
       llm = new ChatOpenAI({
         apiKey,
-        modelName: this.config.ai?.modelName || 'gpt-4o-mini',
-        temperature: this.config.ai?.temperature ?? 0.1,
+        modelName,
         callbacks: this.tokenTracker ? [this.tokenTracker] : [],
+        ...(isGPT5Model ? { temperature: 1 } : {}),
       });
     }
 
@@ -319,7 +338,6 @@ export class LangChainAgent extends BaseAgent {
       prompt,
     });
 
-    // Create executor without memory - we handle memory manually with SmartMemoryManager
     this.executor = new ContentAwareAgentExecutor({
       agent,
       tools: langchainTools,
@@ -343,9 +361,49 @@ export class LangChainAgent extends BaseAgent {
       }
     }
 
+    let userFriendlyMessage = errorMessage;
+    let userFriendlyOutput = errorMessage;
+
+    if (errorMessage.includes('429')) {
+      if (errorMessage.includes('quota')) {
+        userFriendlyMessage =
+          'API quota exceeded. Please check your OpenAI billing and usage limits.';
+        userFriendlyOutput =
+          "I'm currently unable to respond because the API quota has been exceeded. Please check your OpenAI account billing and usage limits, then try again.";
+      } else {
+        userFriendlyMessage =
+          'Too many requests. Please wait a moment and try again.';
+        userFriendlyOutput =
+          "I'm receiving too many requests right now. Please wait a moment and try again.";
+      }
+    } else if (
+      errorMessage.includes('401') ||
+      errorMessage.includes('unauthorized')
+    ) {
+      userFriendlyMessage =
+        'API authentication failed. Please check your API key configuration.';
+      userFriendlyOutput =
+        "There's an issue with the API authentication. Please check your OpenAI API key configuration in settings.";
+    } else if (errorMessage.includes('timeout')) {
+      userFriendlyMessage = 'Request timed out. Please try again.';
+      userFriendlyOutput =
+        'The request took too long to process. Please try again.';
+    } else if (
+      errorMessage.includes('network') ||
+      errorMessage.includes('fetch')
+    ) {
+      userFriendlyMessage =
+        'Network error. Please check your internet connection and try again.';
+      userFriendlyOutput =
+        'There was a network error. Please check your internet connection and try again.';
+    } else if (errorMessage.includes('400')) {
+      userFriendlyMessage = errorMessage;
+      userFriendlyOutput = errorMessage;
+    }
+
     const errorResponse: ChatResponse = {
-      output: 'Sorry, I encountered an error processing your request.',
-      message: 'Error processing request.',
+      output: userFriendlyOutput,
+      message: userFriendlyMessage,
       error: errorMessage,
       notes: [],
     };
@@ -395,6 +453,83 @@ export class LangChainAgent extends BaseAgent {
     }
   }
 
+  /**
+   * Connect to MCP servers asynchronously after agent boot with background timeout pattern
+   */
+  async connectMCPServers(): Promise<void> {
+    if (!this.config.mcp?.servers || this.config.mcp.servers.length === 0) {
+      return;
+    }
+
+    if (!this.mcpManager) {
+      this.mcpManager = new MCPClientManager(this.logger);
+    }
+
+    this.logger.info(
+      `Starting background MCP server connections for ${this.config.mcp.servers.length} servers...`
+    );
+
+    this.config.mcp.servers.forEach((serverConfig) => {
+      this.connectServerInBackground(serverConfig);
+    });
+
+    this.logger.info('MCP server connections initiated in background');
+  }
+
+  /**
+   * Connect to a single MCP server in background with timeout
+   */
+  private connectServerInBackground(serverConfig: any): void {
+    const serverName = serverConfig.name;
+
+    setTimeout(async () => {
+      try {
+        this.logger.info(`Background connecting to MCP server: ${serverName}`);
+
+        const status = await this.mcpManager!.connectServer(serverConfig);
+        this.mcpConnectionStatus.set(serverName, status);
+
+        if (status.connected) {
+          this.logger.info(
+            `Successfully connected to MCP server ${status.serverName} with ${status.tools.length} tools`
+          );
+
+          for (const mcpTool of status.tools) {
+            const langchainTool = convertMCPToolToLangChain(
+              mcpTool,
+              this.mcpManager!,
+              serverConfig
+            );
+            this.tools.push(langchainTool);
+          }
+
+          if (this.initialized && this.executor) {
+            this.logger.info(
+              `Recreating executor with ${this.tools.length} total tools`
+            );
+            await this.createExecutor();
+          }
+        } else {
+          this.logger.error(
+            `Failed to connect to MCP server ${status.serverName}: ${status.error}`
+          );
+        }
+      } catch (error) {
+        this.logger.error(
+          `Background connection failed for MCP server ${serverName}:`,
+          error
+        );
+
+        this.mcpConnectionStatus.set(serverName, {
+          connected: false,
+          serverName,
+          tools: [],
+          error: error instanceof Error ? error.message : 'Connection failed',
+        });
+      }
+    }, 1000);
+  }
+
   /**
    * Check if a string is valid JSON
    */

package/src/mcp/ContentProcessor.ts

@@ -111,7 +111,7 @@ export class MCPContentProcessor {
           content: record.text,
           type: 'text',
           sizeBytes: Buffer.byteLength(record.text, 'utf8'),
-          mimeType: 'text/plain'
+          mimeType: this.detectMimeType(record.text as string)
         });
         return;
       }
@@ -238,7 +238,7 @@ export class MCPContentProcessor {
     };
   }
 
-  private replaceContentInResponse(obj: unknown, oldContent: unknown, newContent: unknown): void {
+  private replaceContentInResponse(obj: unknown, oldContent: unknown, newContent: any): void {
     if (obj === null || obj === undefined) {
       return;
     }
@@ -256,7 +256,15 @@ export class MCPContentProcessor {
 
     if (typeof obj === 'object') {
       const record = obj as Record<string, unknown>;
-      
+      if (record.type === 'text' && record.text === oldContent) {
+        for (const key of Object.keys(record)) {
+          delete record[key];
+        }
+        for (const key of Object.keys(newContent)) {
+          record[key] = newContent[key];
+        }
+        return;
+      }
       for (const key in record) {
         if (record[key] === oldContent) {
           record[key] = newContent;

package/src/mcp/adapters/langchain.ts

@@ -71,16 +71,12 @@ export function convertMCPToolToLangChain(
           responseText = JSON.stringify(result);
         }
 
-        // Check if content should be stored as reference
         const responseBuffer = Buffer.from(responseText, 'utf8');
-        console.log(`[MCP Adapter] Response size: ${responseBuffer.length} bytes, tool: ${tool.serverName}_${tool.name}`);
         
-        // Use a lower threshold for MCP tools (10KB) to avoid token limit issues
-        const MCP_REFERENCE_THRESHOLD = 10 * 1024; // 10KB
+        const MCP_REFERENCE_THRESHOLD = 10 * 1024;
         const shouldStoreMCPContent = responseBuffer.length > MCP_REFERENCE_THRESHOLD;
         
         if (shouldStoreMCPContent || shouldUseReference(responseBuffer)) {
-          console.log(`[MCP Adapter] Content exceeds threshold (${responseBuffer.length} > ${MCP_REFERENCE_THRESHOLD}), storing as reference`);
           const contentStore = ContentStoreService.getInstance();
           if (contentStore) {
             try {
@@ -90,14 +86,9 @@ export function convertMCPToolToLangChain(
                 mcpToolName: `${tool.serverName}_${tool.name}`,
                 originalSize: responseBuffer.length
               });
-              console.log(`[MCP Adapter] Stored content as reference: content-ref:${referenceId}`);
               return `content-ref:${referenceId}`;
             } catch (storeError) {
-              // If storage fails, fall back to returning the content
-              console.warn('Failed to store large MCP content as reference:', storeError);
             }
-          } else {
-            console.warn('[MCP Adapter] ContentStoreService not available');
           }
         }