@hashgraphonline/conversational-agent 0.1.205 → 0.1.206

package/src/langchain-agent.ts

@@ -22,11 +22,13 @@ import {
 } from './base-agent';
 import { MCPClientManager } from './mcp/MCPClientManager';
 import { convertMCPToolToLangChain } from './mcp/adapters/langchain';
+import { SmartMemoryManager } from './memory/SmartMemoryManager';
 
 export class LangChainAgent extends BaseAgent {
   private executor: AgentExecutor | undefined;
   private systemMessage = '';
   private mcpManager?: MCPClientManager;
+  private smartMemory: SmartMemoryManager | undefined;
 
   async boot(): Promise<void> {
     if (this.initialized) {
@@ -51,7 +53,24 @@ export class LangChainAgent extends BaseAgent {
         await this.initializeMCP();
       }
 
+      this.smartMemory = new SmartMemoryManager({
+        modelName,
+        maxTokens: 90000,
+        reserveTokens: 10000,
+        storageLimit: 1000
+      });
+      
+      this.logger.info('SmartMemoryManager initialized:', {
+        modelName,
+        toolsCount: this.tools.length,
+        maxTokens: 90000,
+        reserveTokens: 10000
+      });
+
       this.systemMessage = this.buildSystemPrompt();
+      
+      // Set the system prompt in smart memory
+      this.smartMemory.setSystemPrompt(this.systemMessage);
 
       await this.createExecutor();
 
@@ -67,22 +86,64 @@ export class LangChainAgent extends BaseAgent {
     message: string,
     context?: ConversationContext
   ): Promise<ChatResponse> {
-    if (!this.initialized || !this.executor) {
+    if (!this.initialized || !this.executor || !this.smartMemory) {
       throw new Error('Agent not initialized. Call boot() first.');
     }
 
     try {
+      this.logger.info('LangChainAgent.chat called with:', { message, contextLength: context?.messages?.length || 0 });
+      
+      // If context is provided, populate smart memory with previous messages
+      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
+      });
+      
       const result = await this.executor.invoke({
         input: message,
-        chat_history: context?.messages || [],
+        chat_history: this.smartMemory.getMessages(),
       });
 
+      this.logger.info('LangChainAgent executor result:', result);
+
       let response: ChatResponse = {
         output: result.output || '',
         message: result.output || '',
         notes: [],
+        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)
+        }));
+        
+        if (toolCalls.length > 0) {
+          response.tool_calls = toolCalls;
+        }
+      }
+
       const parsedSteps = result?.intermediateSteps?.[0]?.observation;
       if (
         parsedSteps &&
@@ -101,6 +162,12 @@ 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));
+      }
+
       if (this.tokenTracker) {
         const tokenUsage = this.tokenTracker.getLatestTokenUsage();
         if (tokenUsage) {
@@ -109,8 +176,21 @@ export class LangChainAgent extends BaseAgent {
         }
       }
 
+      const finalMemoryStats = this.smartMemory.getMemoryStats();
+      response.metadata = {
+        ...response.metadata,
+        memoryStats: {
+          activeMessages: finalMemoryStats.totalActiveMessages,
+          tokenUsage: finalMemoryStats.currentTokenCount,
+          maxTokens: finalMemoryStats.maxTokens,
+          usagePercentage: finalMemoryStats.usagePercentage
+        }
+      };
+
+      this.logger.info('LangChainAgent.chat returning response:', response);
       return response;
     } catch (error) {
+      this.logger.error('LangChainAgent.chat error:', error);
       return this.handleError(error);
     }
   }
@@ -120,6 +200,11 @@ export class LangChainAgent extends BaseAgent {
       await this.mcpManager.disconnectAll();
     }
 
+    if (this.smartMemory) {
+      this.smartMemory.dispose();
+      this.smartMemory = undefined;
+    }
+
     this.executor = undefined;
     this.agentKit = undefined;
     this.tools = [];
@@ -175,6 +260,7 @@ export class LangChainAgent extends BaseAgent {
     }
   }
 
+
   private async createAgentKit(): Promise<HederaAgentKit> {
     const corePlugins = getAllHederaCorePlugins();
     const extensionPlugins = this.config.extensions?.plugins || [];
@@ -232,6 +318,7 @@ export class LangChainAgent extends BaseAgent {
       prompt,
     });
 
+    // Create executor without memory - we handle memory manually with SmartMemoryManager
     this.executor = new AgentExecutor({
       agent,
       tools: langchainTools,

package/src/mcp/ContentProcessor.ts

@@ -0,0 +1,317 @@
+import type { ContentType, ContentSource } from '../types/content-reference';
+import type { ContentStorage } from '../memory/ContentStorage';
+import { Logger } from '@hashgraphonline/standards-sdk';
+
+export interface MCPResponseContent {
+  content: unknown;
+  type: 'text' | 'image' | 'resource' | 'text[]' | 'image[]';
+  sizeBytes: number;
+  mimeType?: string;
+}
+
+export interface ProcessedResponse {
+  content: unknown;
+  wasProcessed: boolean;
+  referenceCreated?: boolean;
+  referenceId?: string;
+  originalSize?: number;
+  errors?: string[];
+}
+
+export interface ContentAnalysis {
+  shouldProcess: boolean;
+  contents: MCPResponseContent[];
+  totalSize: number;
+  largestContentSize: number;
+}
+
+export class MCPContentProcessor {
+  private contentStorage: ContentStorage;
+  private logger: Logger;
+
+  constructor(contentStorage: ContentStorage, logger: Logger) {
+    this.contentStorage = contentStorage;
+    this.logger = logger;
+  }
+
+  analyzeResponse(response: unknown): ContentAnalysis {
+    const contents: MCPResponseContent[] = [];
+    let totalSize = 0;
+
+    this.extractContentFromResponse(response, contents);
+
+    totalSize = contents.reduce((sum, content) => sum + content.sizeBytes, 0);
+    const largestContentSize = contents.reduce((max, content) => 
+      Math.max(max, content.sizeBytes), 0);
+
+    const shouldProcess = contents.some(content => 
+      this.contentStorage.shouldUseReference(
+        typeof content.content === 'string' 
+          ? content.content 
+          : JSON.stringify(content.content)
+      )
+    );
+
+    return {
+      shouldProcess,
+      contents,
+      totalSize,
+      largestContentSize
+    };
+  }
+
+  async processResponse(
+    response: unknown,
+    serverName: string,
+    toolName: string
+  ): Promise<ProcessedResponse> {
+    try {
+      const analysis = this.analyzeResponse(response);
+      
+      if (!analysis.shouldProcess) {
+        return {
+          content: response,
+          wasProcessed: false
+        };
+      }
+
+      const processedResponse = await this.createReferencedResponse(
+        response,
+        analysis,
+        serverName,
+        toolName
+      );
+
+      return processedResponse;
+    } catch (error) {
+      this.logger.error('Error processing MCP response:', error);
+      return {
+        content: response,
+        wasProcessed: false,
+        errors: [error instanceof Error ? error.message : 'Unknown processing error']
+      };
+    }
+  }
+
+  private extractContentFromResponse(obj: unknown, contents: MCPResponseContent[]): void {
+    if (obj === null || obj === undefined) {
+      return;
+    }
+
+    if (Array.isArray(obj)) {
+      obj.forEach(item => this.extractContentFromResponse(item, contents));
+      return;
+    }
+
+    if (typeof obj === 'object') {
+      const record = obj as Record<string, unknown>;
+      
+      if (record.type === 'text' && typeof record.text === 'string') {
+        contents.push({
+          content: record.text,
+          type: 'text',
+          sizeBytes: Buffer.byteLength(record.text, 'utf8'),
+          mimeType: 'text/plain'
+        });
+        return;
+      }
+
+      if (record.type === 'image' && typeof record.data === 'string') {
+        contents.push({
+          content: record.data,
+          type: 'image',
+          sizeBytes: Math.ceil(record.data.length * 0.75),
+          mimeType: record.mimeType as string || 'image/jpeg'
+        });
+        return;
+      }
+
+      if (record.type === 'resource' && record.resource) {
+        const resourceStr = JSON.stringify(record.resource);
+        contents.push({
+          content: resourceStr,
+          type: 'resource',
+          sizeBytes: Buffer.byteLength(resourceStr, 'utf8'),
+          mimeType: 'application/json'
+        });
+        return;
+      }
+
+      Object.values(record).forEach(value => 
+        this.extractContentFromResponse(value, contents));
+      return;
+    }
+
+    if (typeof obj === 'string') {
+      if (obj.length > 1000) {
+        contents.push({
+          content: obj,
+          type: 'text',
+          sizeBytes: Buffer.byteLength(obj, 'utf8'),
+          mimeType: this.detectMimeType(obj)
+        });
+      }
+    }
+  }
+
+  private async createReferencedResponse(
+    originalResponse: unknown,
+    analysis: ContentAnalysis,
+    serverName: string,
+    toolName: string
+  ): Promise<ProcessedResponse> {
+    const processedResponse = this.deepClone(originalResponse);
+    const errors: string[] = [];
+    let referenceCreated = false;
+    let totalReferenceSize = 0;
+
+    for (const contentInfo of analysis.contents) {
+      if (this.contentStorage.shouldUseReference(
+        typeof contentInfo.content === 'string' 
+          ? contentInfo.content 
+          : JSON.stringify(contentInfo.content)
+      )) {
+        try {
+          const contentBuffer = Buffer.from(
+            typeof contentInfo.content === 'string' 
+              ? contentInfo.content 
+              : JSON.stringify(contentInfo.content),
+            'utf8'
+          );
+
+          const contentType = this.mapMimeTypeToContentType(contentInfo.mimeType);
+          
+          const metadata: Parameters<typeof this.contentStorage.storeContentIfLarge>[1] = {
+            contentType,
+            source: 'mcp_tool' as ContentSource,
+            mcpToolName: `${serverName}::${toolName}`,
+            tags: ['mcp_response', serverName, toolName]
+          };
+          
+          if (contentInfo.mimeType !== undefined) {
+            metadata.mimeType = contentInfo.mimeType;
+          }
+          
+          const reference = await this.contentStorage.storeContentIfLarge(
+            contentBuffer,
+            metadata
+          );
+
+          if (reference) {
+            this.replaceContentInResponse(
+              processedResponse,
+              contentInfo.content,
+              this.createLightweightReference(reference)
+            );
+            referenceCreated = true;
+            totalReferenceSize += contentBuffer.length;
+          }
+        } catch (error) {
+          errors.push(`Failed to create reference: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+      }
+    }
+
+    const result: ProcessedResponse = {
+      content: processedResponse,
+      wasProcessed: true,
+      referenceCreated,
+      originalSize: totalReferenceSize
+    };
+    
+    if (errors.length > 0) {
+      result.errors = errors;
+    }
+    
+    return result;
+  }
+
+  private createLightweightReference(reference: any): Record<string, unknown> {
+    return {
+      type: 'content_reference',
+      referenceId: reference.referenceId,
+      preview: reference.preview,
+      size: reference.metadata.sizeBytes,
+      contentType: reference.metadata.contentType,
+      format: 'ref://{id}',
+      _isReference: true
+    };
+  }
+
+  private replaceContentInResponse(obj: unknown, oldContent: unknown, newContent: unknown): void {
+    if (obj === null || obj === undefined) {
+      return;
+    }
+
+    if (Array.isArray(obj)) {
+      for (let i = 0; i < obj.length; i++) {
+        if (obj[i] === oldContent) {
+          obj[i] = newContent;
+        } else {
+          this.replaceContentInResponse(obj[i], oldContent, newContent);
+        }
+      }
+      return;
+    }
+
+    if (typeof obj === 'object') {
+      const record = obj as Record<string, unknown>;
+      
+      for (const key in record) {
+        if (record[key] === oldContent) {
+          record[key] = newContent;
+        } else {
+          this.replaceContentInResponse(record[key], oldContent, newContent);
+        }
+      }
+    }
+  }
+
+  private detectMimeType(content: string): string {
+    if (content.trim().startsWith('{') || content.trim().startsWith('[')) {
+      return 'application/json';
+    }
+    if (content.includes('<html>') || content.includes('<!DOCTYPE')) {
+      return 'text/html';
+    }
+    if (content.includes('# ') || content.includes('## ')) {
+      return 'text/markdown';
+    }
+    return 'text/plain';
+  }
+
+  private mapMimeTypeToContentType(mimeType?: string): ContentType {
+    if (!mimeType) return 'text';
+    
+    if (mimeType.startsWith('text/plain')) return 'text';
+    if (mimeType === 'application/json') return 'json';
+    if (mimeType === 'text/html') return 'html';
+    if (mimeType === 'text/markdown') return 'markdown';
+    if (mimeType.startsWith('text/')) return 'text';
+    
+    return 'binary';
+  }
+
+  private deepClone<T>(obj: T): T {
+    if (obj === null || typeof obj !== 'object') {
+      return obj;
+    }
+    
+    if (obj instanceof Date) {
+      return new Date(obj.getTime()) as T;
+    }
+    
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.deepClone(item)) as T;
+    }
+    
+    const cloned = {} as T;
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        cloned[key] = this.deepClone(obj[key]);
+      }
+    }
+    
+    return cloned;
+  }
+}

package/src/mcp/MCPClientManager.ts

@@ -2,6 +2,8 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import type { MCPServerConfig, MCPToolInfo, MCPConnectionStatus } from './types';
 import { Logger } from '@hashgraphonline/standards-sdk';
+import type { ContentStorage } from '../memory/ContentStorage';
+import { MCPContentProcessor, ProcessedResponse } from './ContentProcessor';
 
 /**
  * Manages connections to MCP servers and tool discovery
@@ -10,9 +12,13 @@ export class MCPClientManager {
   private clients: Map<string, Client> = new Map();
   private tools: Map<string, MCPToolInfo[]> = new Map();
   private logger: Logger;
+  private contentProcessor?: MCPContentProcessor;
 
-  constructor(logger: Logger) {
+  constructor(logger: Logger, contentStorage?: ContentStorage) {
     this.logger = logger;
+    if (contentStorage) {
+      this.contentProcessor = new MCPContentProcessor(contentStorage, logger);
+    }
   }
 
   /**
@@ -91,6 +97,27 @@ export class MCPClientManager {
         arguments: args,
       });
 
+      if (this.contentProcessor) {
+        const processed = await this.contentProcessor.processResponse(result, serverName, toolName);
+        
+        if (processed.wasProcessed) {
+          this.logger.debug(
+            `Processed MCP response from ${serverName}::${toolName}`,
+            {
+              referenceCreated: processed.referenceCreated,
+              originalSize: processed.originalSize,
+              errors: processed.errors
+            }
+          );
+
+          if (processed.errors && processed.errors.length > 0) {
+            this.logger.warn(`Content processing warnings for ${serverName}::${toolName}:`, processed.errors);
+          }
+        }
+
+        return processed.content;
+      }
+
       return result;
     } catch (error) {
       this.logger.error(`Error executing MCP tool ${toolName}:`, error);
@@ -145,4 +172,37 @@ export class MCPClientManager {
   getConnectedServers(): string[] {
     return Array.from(this.clients.keys());
   }
+
+  /**
+   * Enable content processing with content storage
+   */
+  enableContentProcessing(contentStorage: ContentStorage): void {
+    this.contentProcessor = new MCPContentProcessor(contentStorage, this.logger);
+    this.logger.info('Content processing enabled for MCP responses');
+  }
+
+  /**
+   * Disable content processing
+   */
+  disableContentProcessing(): void {
+    delete this.contentProcessor;
+    this.logger.info('Content processing disabled for MCP responses');
+  }
+
+  /**
+   * Check if content processing is enabled
+   */
+  isContentProcessingEnabled(): boolean {
+    return this.contentProcessor !== undefined;
+  }
+
+  /**
+   * Analyze a response without processing it (for testing/debugging)
+   */
+  analyzeResponseContent(response: unknown): unknown {
+    if (!this.contentProcessor) {
+      throw new Error('Content processing is not enabled');
+    }
+    return this.contentProcessor.analyzeResponse(response);
+  }
 }

package/src/mcp/adapters/langchain.ts

@@ -40,8 +40,10 @@ export function convertMCPToolToLangChain(
           input
         );
 
+        let responseText = '';
+        
         if (typeof result === 'string') {
-          return result;
+          responseText = result;
         } else if (
           result &&
           typeof result === 'object' &&
@@ -59,12 +61,15 @@ export function convertMCPToolToLangChain(
                   'text' in item
               )
               .map((item) => item.text);
-            return textParts.join('\n');
+            responseText = textParts.join('\n');
+          } else {
+            responseText = JSON.stringify(content);
           }
-          return JSON.stringify(content);
+        } else {
+          responseText = JSON.stringify(result);
         }
 
-        return JSON.stringify(result);
+        return responseText;
       } catch (error) {
         const errorMessage =
           error instanceof Error ? error.message : 'Unknown error';