@hashgraphonline/conversational-agent 0.1.209 → 0.1.210

package/src/conversational-agent.ts

@@ -12,12 +12,13 @@ import { createAgent } from './agent-factory';
 import { LangChainProvider } from './providers';
 import type { ChatResponse, ConversationContext } from './base-agent';
 import { ChatOpenAI } from '@langchain/openai';
+import { ChatAnthropic } from '@langchain/anthropic';
 import { HumanMessage, AIMessage } from '@langchain/core/messages';
 import type { AgentOperationalMode, MirrorNodeConfig } from 'hedera-agent-kit';
 import { HCS10Plugin } from './plugins/hcs-10/HCS10Plugin';
 import { HCS2Plugin } from './plugins/hcs-2/HCS2Plugin';
 import { InscribePlugin } from './plugins/inscribe/InscribePlugin';
-import { HbarTransferPlugin } from './plugins/hbar-transfer/HbarTransferPlugin';
+import { HbarPlugin } from './plugins/hbar/HbarPlugin';
 import { OpenConvaiState } from '@hashgraphonline/standards-agent-kit';
 import type { IStateManager } from '@hashgraphonline/standards-agent-kit';
 import { PrivateKey } from '@hashgraph/sdk';
@@ -25,6 +26,11 @@ import { getSystemMessage } from './config/system-message';
 import type { MCPServerConfig, MCPConnectionStatus } from './mcp/types';
 import { ContentStoreManager } from './services/ContentStoreManager';
 import { SmartMemoryManager, type SmartMemoryConfig } from './memory';
+import {
+  createEntityTools,
+  ResolveEntitiesTool,
+  ExtractEntitiesTool,
+} from './tools/EntityResolverTool';
 
 export type ToolDescriptor = {
   name: string;
@@ -51,6 +57,7 @@ export interface ConversationalAgentOptions {
   network?: NetworkType;
   openAIApiKey: string;
   openAIModelName?: string;
+  llmProvider?: 'openai' | 'anthropic';
   verbose?: boolean;
   operationalMode?: AgentOperationalMode;
   userAccountId?: string;
@@ -64,10 +71,10 @@ export interface ConversationalAgentOptions {
   enabledPlugins?: string[];
   toolFilter?: (tool: { name: string; namespace?: string }) => boolean;
   mcpServers?: MCPServerConfig[];
-  
+
   /** Enable automatic entity memory functionality (default: true) */
   entityMemoryEnabled?: boolean;
-  
+
   /** Configuration for entity memory system */
   entityMemoryConfig?: SmartMemoryConfig;
 }
@@ -86,13 +93,16 @@ export class ConversationalAgent {
   public hcs10Plugin: HCS10Plugin;
   public hcs2Plugin: HCS2Plugin;
   public inscribePlugin: InscribePlugin;
-  public hbarTransferPlugin: HbarTransferPlugin;
+  public hbarPlugin: HbarPlugin;
   public stateManager: IStateManager;
   private options: ConversationalAgentOptions;
-  protected logger: Logger;
-  private contentStoreManager?: ContentStoreManager;
-  private memoryManager?: SmartMemoryManager | undefined;
-  private mcpConnectionStatus: Map<string, MCPConnectionStatus> = new Map();
+  public logger: Logger;
+  protected contentStoreManager?: ContentStoreManager;
+  public memoryManager?: SmartMemoryManager | undefined;
+  private entityTools?: {
+    resolveEntities: ResolveEntitiesTool;
+    extractEntities: ExtractEntitiesTool;
+  };
 
   constructor(options: ConversationalAgentOptions) {
     this.options = options;
@@ -100,20 +110,31 @@ export class ConversationalAgent {
     this.hcs10Plugin = new HCS10Plugin();
     this.hcs2Plugin = new HCS2Plugin();
     this.inscribePlugin = new InscribePlugin();
-    this.hbarTransferPlugin = new HbarTransferPlugin();
+    this.hbarPlugin = new HbarPlugin();
     this.logger = new Logger({
       module: 'ConversationalAgent',
       silent: options.disableLogging || false,
     });
-    
+
     if (this.options.entityMemoryEnabled !== false) {
-      this.memoryManager = new SmartMemoryManager(this.options.entityMemoryConfig);
+      if (!options.openAIApiKey) {
+        throw new Error(
+          'OpenAI API key is required when entity memory is enabled'
+        );
+      }
+
+      this.memoryManager = new SmartMemoryManager(
+        this.options.entityMemoryConfig
+      );
       this.logger.info('Entity memory initialized');
+
+      this.entityTools = createEntityTools(options.openAIApiKey, 'gpt-4o-mini');
+      this.logger.info('LLM-based entity resolver tools initialized');
     }
   }
 
   /**
-   * Initialize the conversational agent with Hedera network connection and AI configuration
+   * Initialize the conversational agent with Hedera Hashgraph connection and AI configuration
    * @throws {Error} If account ID or private key is missing
    * @throws {Error} If initialization fails
    */
@@ -124,6 +145,7 @@ export class ConversationalAgent {
       network = DEFAULT_NETWORK,
       openAIApiKey,
       openAIModelName = DEFAULT_MODEL_NAME,
+      llmProvider = 'openai',
     } = this.options;
 
     this.validateOptions(accountId, privateKey);
@@ -141,28 +163,66 @@ export class ConversationalAgent {
         network as MirrorNetwork
       );
 
-      const allPlugins = this.preparePlugins();
-
-      const llm = new ChatOpenAI({
-        apiKey: openAIApiKey,
-        modelName: openAIModelName,
-        temperature: DEFAULT_TEMPERATURE,
-      });
+      let llm: ChatOpenAI | ChatAnthropic;
+      if (llmProvider === 'anthropic') {
+        llm = new ChatAnthropic({
+          apiKey: openAIApiKey,
+          modelName: openAIModelName || 'claude-3-5-sonnet-20241022',
+          temperature: DEFAULT_TEMPERATURE,
+        });
+      } else {
+        const modelName = openAIModelName || 'gpt-4o-mini';
+        const isGPT5Model =
+          modelName.toLowerCase().includes('gpt-5') ||
+          modelName.toLowerCase().includes('gpt5');
+        llm = new ChatOpenAI({
+          apiKey: openAIApiKey,
+          modelName: openAIModelName,
+          ...(isGPT5Model
+            ? { temperature: 1 }
+            : { temperature: DEFAULT_TEMPERATURE }),
+        });
+      }
 
+      const allPlugins = this.preparePlugins();
       const agentConfig = this.createAgentConfig(serverSigner, llm, allPlugins);
+
       this.agent = createAgent(agentConfig);
 
       this.configureHCS10Plugin(allPlugins);
 
-      if (this.options.mcpServers && this.options.mcpServers.length > 0) {
-        this.contentStoreManager = new ContentStoreManager();
-        await this.contentStoreManager.initialize();
-        this.logger.info('ContentStoreManager initialized for MCP content reference support');
-      }
+      this.contentStoreManager = new ContentStoreManager();
+      await this.contentStoreManager.initialize();
+      this.logger.info(
+        'ContentStoreManager initialized for content reference support'
+      );
 
       await this.agent.boot();
 
-      // Start MCP connections asynchronously after agent is booted
+      if (this.agent) {
+        const cfg = agentConfig;
+        cfg.filtering = cfg.filtering || {};
+        const originalPredicate = cfg.filtering.toolPredicate as
+          | ((t: ToolDescriptor) => boolean)
+          | undefined;
+        const userPredicate = this.options.toolFilter;
+        cfg.filtering.toolPredicate = (tool: ToolDescriptor): boolean => {
+          if (tool && tool.name === 'hedera-account-transfer-hbar') {
+            return false;
+          }
+          if (tool && tool.name === 'hedera-hts-airdrop-token') {
+            return false;
+          }
+          if (originalPredicate && !originalPredicate(tool)) {
+            return false;
+          }
+          if (userPredicate && !userPredicate(tool)) {
+            return false;
+          }
+          return true;
+        };
+      }
+
       if (this.options.mcpServers && this.options.mcpServers.length > 0) {
         this.connectMCP();
       }
@@ -225,7 +285,7 @@ export class ConversationalAgent {
     }
 
     try {
-      const resolvedMessage = this.memoryManager 
+      const resolvedMessage = this.memoryManager
         ? await this.resolveEntitiesInMessage(message)
         : message;
 
@@ -242,13 +302,13 @@ export class ConversationalAgent {
       };
 
       const response = await this.agent.chat(resolvedMessage, context);
-      
+
       if (this.memoryManager) {
         await this.extractAndStoreEntities(response, message);
       }
-      
+
       this.logger.info('Message processed successfully');
-      
+
       return response;
     } catch (error) {
       this.logger.error('Error processing message:', error);
@@ -258,7 +318,7 @@ export class ConversationalAgent {
 
   /**
    * Validates initialization options and throws if required fields are missing.
-   * 
+   *
    * @param accountId - The Hedera account ID
    * @param privateKey - The private key for the account
    * @throws {Error} If required fields are missing
@@ -271,21 +331,21 @@ export class ConversationalAgent {
 
   /**
    * Prepares the list of plugins to use based on configuration.
-   * 
+   *
    * @returns Array of plugins to initialize with the agent
    */
   private preparePlugins(): BasePlugin[] {
     const { additionalPlugins = [], enabledPlugins } = this.options;
-    
+
     const standardPlugins = [
       this.hcs10Plugin,
       this.hcs2Plugin,
       this.inscribePlugin,
-      this.hbarTransferPlugin,
+      this.hbarPlugin,
     ];
-    
-    const corePlugins: BasePlugin[] = getAllHederaCorePlugins();
-    
+
+    const corePlugins = getAllHederaCorePlugins();
+
     if (enabledPlugins) {
       const enabledSet = new Set(enabledPlugins);
       const filteredPlugins = [...standardPlugins, ...corePlugins].filter(
@@ -293,13 +353,13 @@ export class ConversationalAgent {
       );
       return [...filteredPlugins, ...additionalPlugins];
     }
-    
+
     return [...standardPlugins, ...corePlugins, ...additionalPlugins];
   }
 
   /**
    * Creates the agent configuration object.
-   * 
+   *
    * @param serverSigner - The server signer instance
    * @param llm - The language model instance
    * @param allPlugins - Array of plugins to use
@@ -307,7 +367,7 @@ export class ConversationalAgent {
    */
   private createAgentConfig(
     serverSigner: ServerSigner,
-    llm: ChatOpenAI,
+    llm: ChatOpenAI | ChatAnthropic,
     allPlugins: BasePlugin[]
   ): Parameters<typeof createAgent>[0] {
     const {
@@ -330,7 +390,8 @@ export class ConversationalAgent {
         operationalMode: operationalMode,
         ...(userAccountId && { userAccountId }),
         ...(scheduleUserTransactionsInBytesMode !== undefined && {
-          scheduleUserTransactionsInBytesMode: scheduleUserTransactionsInBytesMode,
+          scheduleUserTransactionsInBytesMode:
+            scheduleUserTransactionsInBytesMode,
           scheduleUserTransactions: scheduleUserTransactionsInBytesMode,
         }),
       },
@@ -350,7 +411,9 @@ export class ConversationalAgent {
       messaging: {
         systemPreamble:
           customSystemMessagePreamble || getSystemMessage(accountId),
-        ...(customSystemMessagePostamble && { systemPostamble: customSystemMessagePostamble }),
+        ...(customSystemMessagePostamble && {
+          systemPostamble: customSystemMessagePostamble,
+        }),
         conciseMode: true,
       },
       extensions: {
@@ -374,13 +437,15 @@ export class ConversationalAgent {
 
   /**
    * Configures the HCS-10 plugin with the state manager.
-   * 
+   *
    * @param allPlugins - Array of all plugins
    */
   private configureHCS10Plugin(allPlugins: BasePlugin[]): void {
     const hcs10 = allPlugins.find((p) => p.id === 'hcs-10');
     if (hcs10) {
-      (hcs10 as BasePlugin & { appConfig?: Record<string, unknown> }).appConfig = {
+      (
+        hcs10 as BasePlugin & { appConfig?: Record<string, unknown> }
+      ).appConfig = {
         stateManager: this.stateManager,
       };
     }
@@ -496,7 +561,7 @@ export class ConversationalAgent {
    * Detect the private key type by querying the account info from mirror node
    * @param {string} accountId - The Hedera account ID
    * @param {string} privateKey - The private key string
-   * @param {NetworkType} network - The Hedera network
+   * @param {NetworkType} network - The Hedera Hashgraph
    * @returns {Promise<PrivateKey>} The appropriate PrivateKey instance
    */
   private async detectPrivateKeyType(
@@ -517,171 +582,109 @@ export class ConversationalAgent {
   }
 
   /**
-   * Resolve entity references in the message content
+   * Resolve entity references using LLM-based resolver
    * @param content - Message content to resolve
    * @returns Resolved message content with entity IDs replaced
    */
   private async resolveEntitiesInMessage(content: string): Promise<string> {
-    if (!this.memoryManager) {
+    if (!this.memoryManager || !this.entityTools) {
       return content;
     }
 
     try {
-      this.logger.info(`Starting entity resolution for message: "${content.substring(0, 100)}..."`);
-      
-      if (!content || typeof content !== 'string') {
-        this.logger.warn('Invalid content provided for entity resolution');
-        return content || '';
-      }
+      const entities = this.memoryManager.getEntityAssociations();
 
-      if (content.length > 5000) {
-        this.logger.warn('Content too long for entity resolution, truncating');
-        content = content.substring(0, 5000);
+      if (entities.length === 0) {
+        this.logger.info('No entities in memory, skipping resolution');
+        return content;
       }
 
-      let resolvedContent = content;
-
-      const patterns = [
-        /\b(my|the|our)\s+(token|account|topic|schedule)\b/gi,
-        /'([^']+)'/g,
-        /"([^"]+)"/g,
-        /\b([A-Z][A-Za-z0-9_-]{2,})\b/g
-      ];
+      this.logger.info(
+        `Starting LLM-based entity resolution for: "${content.substring(
+          0,
+          100
+        )}..."`
+      );
 
-      for (const pattern of patterns) {
-        try {
-          let match;
-          const matches: any[] = [];
-          while ((match = pattern.exec(resolvedContent)) !== null) {
-            matches.push(match);
-            if (!pattern.global) break;
-          }
-          
-          for (const match of matches) {
-            try {
-              const originalRef = match[0];
-              const entityName = match[1] || match[0];
-              
-              if (entityName.length > 50) {
-                this.logger.debug(`Skipping overly long entity name: ${entityName.substring(0, 20)}...`);
-                continue;
-              }
-              
-              const commonWords = ['the', 'my', 'our', 'this', 'that', 'it', 'is', 'are', 'was', 'will'];
-              if (commonWords.includes(entityName.toLowerCase())) {
-                continue;
-              }
-              
-              let entityAssociations: any[] = [];
-              
-              if (match[1] && ['token', 'account', 'topic', 'schedule'].includes(match[1].toLowerCase())) {
-                const entityType = match[1].toLowerCase();
-                entityAssociations = this.memoryManager.resolveEntityReference(
-                  entityName, 
-                  { entityType, limit: 1, fuzzyMatch: true }
-                );
-              } else {
-                entityAssociations = this.memoryManager.resolveEntityReference(
-                  entityName,
-                  { limit: 1, fuzzyMatch: false }
-                );
-              }
-
-              if (entityAssociations.length > 0) {
-                const entity = entityAssociations[0];
-                if (entity.entityId && entity.entityId.trim().length > 0) {
-                  if (entityAssociations.length > 1) {
-                    this.logger.info(`Multiple entities found for "${originalRef}", using most recent: ${entity.entityName}`);
-                  }
-                  
-                  resolvedContent = resolvedContent.replace(originalRef, entity.entityId);
-                  this.logger.info(`Resolved entity reference: "${originalRef}" -> ${entity.entityId}`);
-                }
-              }
-            } catch (matchError) {
-              this.logger.debug('Error processing entity match:', matchError);
-              continue;
-            }
-          }
-        } catch (patternError) {
-          this.logger.debug('Error processing pattern:', patternError);
-          continue;
-        }
-      }
+      const resolvedContent = await this.entityTools.resolveEntities.call({
+        message: content,
+        entities: entities.map((e) => ({
+          entityId: e.entityId,
+          entityName: e.entityName,
+          entityType: e.entityType,
+        })),
+      });
 
       if (resolvedContent !== content) {
-        this.logger.info(`Entity resolution completed. Original: "${content}" -> Resolved: "${resolvedContent}"`);
-      } else {
-        this.logger.info('No entity references resolved in message');
+        this.logger.info(
+          `Entity resolution completed. Original: "${content}" -> Resolved: "${resolvedContent}"`
+        );
       }
-      
+
       return resolvedContent;
     } catch (error) {
-      this.logger.warn('Entity resolution failed, using original message:', error);
-      return content;
+      this.logger.error('Entity resolution failed:', error);
+      throw error;
     }
   }
 
   /**
-   * Extract and store entity associations from transaction responses
+   * Extract and store entities from agent responses
    * @param response - Agent response containing potential entity information
    * @param originalMessage - Original user message for context
    */
-  private async extractAndStoreEntities(response: any, originalMessage: string): Promise<void> {
-    if (!this.memoryManager) {
+  private async extractAndStoreEntities(
+    response: unknown,
+    originalMessage: string
+  ): Promise<void> {
+    if (!this.memoryManager || !this.entityTools) {
       return;
     }
 
     try {
-      this.logger.info('Starting entity extraction from response');
-      
-      const entityPatterns = {
-        token: /(?:token|Token)\s*(?:ID\s*[:"*\s]*)?([0-9]+\.[0-9]+\.[0-9]+)/g,
-        account: /(?:account|Account)\s*(?:ID\s*[:"*\s]*)?([0-9]+\.[0-9]+\.[0-9]+)/g,
-        topic: /(?:topic|Topic)\s*(?:ID\s*[:"*\s]*)?([0-9]+\.[0-9]+\.[0-9]+)/g,
-        schedule: /(?:schedule|Schedule)\s*(?:ID\s*[:"*\s]*)?([0-9]+\.[0-9]+\.[0-9]+)/g
-      };
+      this.logger.info('Starting LLM-based entity extraction');
 
-      const responseText = typeof response === 'string' ? response : JSON.stringify(response);
-      this.logger.info(`Searching response text: ${responseText.substring(0, 200)}...`);
-      
-      for (const [entityType, pattern] of Object.entries(entityPatterns)) {
-        let match;
-        while ((match = pattern.exec(responseText)) !== null) {
-          const entityId = match[1];
-          
-          let entityName = `${entityType}-${entityId}`;
-          
-          const namePatterns = [
-            new RegExp(`(?:called|named)\\s+([\\w\\d_-]+)`, 'i'),
-            new RegExp(`(?:token|account|topic|schedule)\\s+([\\w\\d_-]+)`, 'i'),
-            new RegExp(`([\\w\\d_-]+)\\s+${entityType}`, 'i')
-          ];
-          
-          for (const namePattern of namePatterns) {
-            const nameMatch = originalMessage.match(namePattern);
-            if (nameMatch && nameMatch[1]) {
-              entityName = nameMatch[1].trim();
-              break;
-            }
-          }
-          
-          this.logger.info(`Extracting entity: ${entityName} (${entityType}) -> ${entityId}`);
-          
+      const responseText = this.extractResponseText(response);
+
+      const entitiesJson = await this.entityTools.extractEntities.call({
+        response: responseText,
+        userMessage: originalMessage,
+      });
+
+      try {
+        const entities = JSON.parse(entitiesJson);
+
+        for (const entity of entities) {
+          this.logger.info(
+            `Storing entity: ${entity.name} (${entity.type}) -> ${entity.id}`
+          );
+
+          const transactionId = this.extractTransactionId(response);
           this.memoryManager.storeEntityAssociation(
-            entityId,
-            entityName,
-            entityType,
-            this.extractTransactionId(response)
+            entity.id,
+            entity.name,
+            entity.type,
+            transactionId
           );
-          
-          this.logger.info(`Stored entity association: ${entityName} (${entityId})`);
         }
+
+        if (entities.length > 0) {
+          this.logger.info(
+            `Stored ${entities.length} entities via LLM extraction`
+          );
+        } else {
+          this.logger.info('No entities found in response via LLM extraction');
+        }
+      } catch (parseError) {
+        this.logger.error(
+          'Failed to parse extracted entities JSON:',
+          parseError
+        );
+        throw parseError;
       }
-      
-      this.logger.info('Entity extraction completed');
     } catch (error) {
-      this.logger.warn('Entity extraction failed:', error);
+      this.logger.error('Entity extraction failed:', error);
+      throw error;
     }
   }
 
@@ -690,13 +693,19 @@ export class ConversationalAgent {
    * @param response - Transaction response
    * @returns Transaction ID or undefined
    */
-  private extractTransactionId(response: any): string | undefined {
+  private extractTransactionId(response: unknown): string | undefined {
     try {
-      if (typeof response === 'object' && response?.transactionId) {
-        return response.transactionId;
+      if (
+        typeof response === 'object' &&
+        response &&
+        'transactionId' in response
+      ) {
+        return (response as { transactionId?: string }).transactionId;
       }
       if (typeof response === 'string') {
-        const match = response.match(/transaction[\s\w]*ID[\s:"]*([0-9a-fA-F@\.\-]+)/i);
+        const match = response.match(
+          /transaction[\s\w]*ID[\s:"]*([0-9a-fA-F@\.\-]+)/i
+        );
         return match ? match[1] : undefined;
       }
       return undefined;
@@ -714,75 +723,14 @@ export class ConversationalAgent {
       return;
     }
 
-    // Initialize connection status for all servers
-    this.options.mcpServers.forEach(server => {
-      this.mcpConnectionStatus.set(server.name, {
-        serverName: server.name,
-        connected: false,
-        tools: []
-      });
-    });
-
-    // Call the agent's MCP connection method if available
-    if (typeof (this.agent as any).connectMCPServers === 'function') {
-      (this.agent as any).connectMCPServers().catch((error: any) => {
-        this.logger.error('Failed to connect MCP servers:', error);
+    this.agent
+      .connectMCPServers()
+      .catch((e) => {
+        this.logger.error('Failed to connect MCP servers:', e);
+      })
+      .then(() => {
+        this.logger.info('MCP servers connected successfully');
       });
-    } else {
-      // Fallback for agents that don't support async MCP connections
-      this.startConnections();
-    }
-  }
-
-  /**
-   * Start MCP connections without blocking initialization
-   * @private
-   */
-  private async startConnections(): Promise<void> {
-    if (!this.agent || !this.options.mcpServers) {
-      return;
-    }
-
-    try {
-      this.logger.info('Starting MCP server connections asynchronously...');
-      
-      for (const server of this.options.mcpServers) {
-        this.connectServer(server);
-      }
-    } catch (error) {
-      this.logger.error('Error starting MCP connections:', error);
-    }
-  }
-
-  /**
-   * Connect to a single MCP server
-   * @param {MCPServerConfig} server - Server configuration
-   * @private
-   */
-  private async connectServer(server: MCPServerConfig): Promise<void> {
-    try {
-      this.logger.info(`Connecting to MCP server: ${server.name}`);
-      
-      // TODO: Implement actual MCP connection logic
-      // For now, we'll simulate the connection process
-      const status = this.mcpConnectionStatus.get(server.name);
-      if (status) {
-        // Simulate connection success after a delay
-        setTimeout(() => {
-          status.connected = true;
-          this.logger.info(`MCP server ${server.name} connected successfully`);
-        }, Math.random() * 2000 + 1000); // 1-3 second delay
-      }
-      
-    } catch (error) {
-      this.logger.error(`Failed to connect to MCP server ${server.name}:`, error);
-      
-      const status = this.mcpConnectionStatus.get(server.name);
-      if (status) {
-        status.connected = false;
-        status.error = error instanceof Error ? error.message : 'Unknown error';
-      }
-    }
   }
 
   /**
@@ -790,7 +738,10 @@ export class ConversationalAgent {
    * @returns {Map<string, MCPConnectionStatus>} Connection status map
    */
   getMCPConnectionStatus(): Map<string, MCPConnectionStatus> {
-    return new Map(this.mcpConnectionStatus);
+    if (this.agent) {
+      return this.agent.getMCPConnectionStatus();
+    }
+    return new Map();
   }
 
   /**
@@ -799,8 +750,12 @@ export class ConversationalAgent {
    * @returns {boolean} True if connected, false otherwise
    */
   isMCPServerConnected(serverName: string): boolean {
-    const status = this.mcpConnectionStatus.get(serverName);
-    return status?.connected ?? false;
+    if (this.agent) {
+      const statusMap = this.agent.getMCPConnectionStatus();
+      const status = statusMap.get(serverName);
+      return status?.connected ?? false;
+    }
+    return false;
   }
 
   /**
@@ -809,7 +764,7 @@ export class ConversationalAgent {
   async cleanup(): Promise<void> {
     try {
       this.logger.info('Cleaning up ConversationalAgent...');
-      
+
       if (this.memoryManager) {
         try {
           this.memoryManager.dispose();
@@ -817,17 +772,29 @@ export class ConversationalAgent {
         } catch (error) {
           this.logger.warn('Error cleaning up memory manager:', error);
         }
-        this.memoryManager = undefined as any;
+        this.memoryManager = undefined;
       }
-      
+
       if (this.contentStoreManager) {
         await this.contentStoreManager.dispose();
         this.logger.info('ContentStoreManager cleaned up');
       }
-      
+
       this.logger.info('ConversationalAgent cleanup completed');
     } catch (error) {
       this.logger.error('Error during cleanup:', error);
     }
   }
+
+  private extractResponseText(response: unknown): string {
+    if (typeof response === 'string') {
+      return response;
+    }
+
+    if (response && typeof response === 'object' && 'output' in response) {
+      return String(response.output);
+    }
+
+    return JSON.stringify(response);
+  }
 }