@hashgraphonline/conversational-agent 0.1.209 → 0.1.211

package/dist/esm/index6.js

@@ -3,43 +3,53 @@ import { Logger, HederaMirrorNode } from "@hashgraphonline/standards-sdk";
 import { createAgent } from "./index9.js";
 import { LangChainProvider } from "./index10.js";
 import { ChatOpenAI } from "@langchain/openai";
+import { ChatAnthropic } from "@langchain/anthropic";
 import { HumanMessage, AIMessage } from "@langchain/core/messages";
 import { HCS10Plugin } from "./index2.js";
 import { HCS2Plugin } from "./index3.js";
 import { InscribePlugin } from "./index4.js";
-import { HbarTransferPlugin } from "./index5.js";
+import { HbarPlugin } from "./index5.js";
 import { OpenConvaiState } from "@hashgraphonline/standards-agent-kit";
 import { PrivateKey } from "@hashgraph/sdk";
-import { getSystemMessage } from "./index17.js";
-import { ContentStoreManager } from "./index18.js";
+import { getSystemMessage } from "./index20.js";
+import { ContentStoreManager } from "./index17.js";
 import "./index12.js";
 import "./index13.js";
 import "./index14.js";
 import { SmartMemoryManager } from "./index15.js";
+import { createEntityTools } from "./index16.js";
 const DEFAULT_MODEL_NAME = "gpt-4o";
 const DEFAULT_TEMPERATURE = 0.1;
 const DEFAULT_NETWORK = "testnet";
 const DEFAULT_OPERATIONAL_MODE = "autonomous";
 class ConversationalAgent {
   constructor(options) {
-    this.mcpConnectionStatus = /* @__PURE__ */ new Map();
     this.options = options;
     this.stateManager = options.stateManager || new OpenConvaiState();
     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
    */
@@ -49,7 +59,8 @@ class ConversationalAgent {
       privateKey,
       network = DEFAULT_NETWORK,
       openAIApiKey,
-      openAIModelName = DEFAULT_MODEL_NAME
+      openAIModelName = DEFAULT_MODEL_NAME,
+      llmProvider = "openai"
     } = this.options;
     this.validateOptions(accountId, privateKey);
     try {
@@ -63,21 +74,53 @@ class ConversationalAgent {
         privateKeyInstance,
         network
       );
+      let llm;
+      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 llm = new ChatOpenAI({
-        apiKey: openAIApiKey,
-        modelName: openAIModelName,
-        temperature: DEFAULT_TEMPERATURE
-      });
       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();
+      if (this.agent) {
+        const cfg = agentConfig;
+        cfg.filtering = cfg.filtering || {};
+        const originalPredicate = cfg.filtering.toolPredicate;
+        const userPredicate = this.options.toolFilter;
+        cfg.filtering.toolPredicate = (tool) => {
+          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();
       }
@@ -155,7 +198,7 @@ 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
@@ -167,7 +210,7 @@ class ConversationalAgent {
   }
   /**
    * Prepares the list of plugins to use based on configuration.
-   * 
+   *
    * @returns Array of plugins to initialize with the agent
    */
   preparePlugins() {
@@ -176,7 +219,7 @@ class ConversationalAgent {
       this.hcs10Plugin,
       this.hcs2Plugin,
       this.inscribePlugin,
-      this.hbarTransferPlugin
+      this.hbarPlugin
     ];
     const corePlugins = getAllHederaCorePlugins();
     if (enabledPlugins) {
@@ -190,7 +233,7 @@ class ConversationalAgent {
   }
   /**
    * Creates the agent configuration object.
-   * 
+   *
    * @param serverSigner - The server signer instance
    * @param llm - The language model instance
    * @param allPlugins - Array of plugins to use
@@ -235,7 +278,9 @@ class ConversationalAgent {
       },
       messaging: {
         systemPreamble: customSystemMessagePreamble || getSystemMessage(accountId),
-        ...customSystemMessagePostamble && { systemPostamble: customSystemMessagePostamble },
+        ...customSystemMessagePostamble && {
+          systemPostamble: customSystemMessagePostamble
+        },
         conciseMode: true
       },
       extensions: {
@@ -258,7 +303,7 @@ class ConversationalAgent {
   }
   /**
    * Configures the HCS-10 plugin with the state manager.
-   * 
+   *
    * @param allPlugins - Array of all plugins
    */
   configureHCS10Plugin(allPlugins) {
@@ -351,7 +396,7 @@ 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
    */
   async detectPrivateKeyType(accountId, privateKey, network) {
@@ -365,144 +410,92 @@ 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
    */
   async resolveEntitiesInMessage(content) {
-    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 || "";
-      }
-      if (content.length > 5e3) {
-        this.logger.warn("Content too long for entity resolution, truncating");
-        content = content.substring(0, 5e3);
-      }
-      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
-      ];
-      for (const pattern of patterns) {
-        try {
-          let match;
-          const matches = [];
-          while ((match = pattern.exec(resolvedContent)) !== null) {
-            matches.push(match);
-            if (!pattern.global) break;
-          }
-          for (const match2 of matches) {
-            try {
-              const originalRef = match2[0];
-              const entityName = match2[1] || match2[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 = [];
-              if (match2[1] && ["token", "account", "topic", "schedule"].includes(match2[1].toLowerCase())) {
-                const entityType = match2[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 entities = this.memoryManager.getEntityAssociations();
+      if (entities.length === 0) {
+        this.logger.info("No entities in memory, skipping resolution");
+        return content;
       }
+      this.logger.info(
+        `Starting LLM-based entity resolution for: "${content.substring(
+          0,
+          100
+        )}..."`
+      );
+      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
    */
   async extractAndStoreEntities(response, originalMessage) {
-    if (!this.memoryManager) {
+    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
-      };
-      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}`);
+      this.logger.info("Starting LLM-based entity extraction");
+      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;
     }
   }
   /**
@@ -512,11 +505,13 @@ class ConversationalAgent {
    */
   extractTransactionId(response) {
     try {
-      if (typeof response === "object" && response?.transactionId) {
+      if (typeof response === "object" && response && "transactionId" in response) {
         return response.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] : void 0;
       }
       return void 0;
@@ -532,68 +527,21 @@ class ConversationalAgent {
     if (!this.agent || !this.options.mcpServers) {
       return;
     }
-    this.options.mcpServers.forEach((server) => {
-      this.mcpConnectionStatus.set(server.name, {
-        serverName: server.name,
-        connected: false,
-        tools: []
-      });
+    this.agent.connectMCPServers().catch((e) => {
+      this.logger.error("Failed to connect MCP servers:", e);
+    }).then(() => {
+      this.logger.info("MCP servers connected successfully");
     });
-    if (typeof this.agent.connectMCPServers === "function") {
-      this.agent.connectMCPServers().catch((error) => {
-        this.logger.error("Failed to connect MCP servers:", error);
-      });
-    } else {
-      this.startConnections();
-    }
-  }
-  /**
-   * Start MCP connections without blocking initialization
-   * @private
-   */
-  async startConnections() {
-    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
-   */
-  async connectServer(server) {
-    try {
-      this.logger.info(`Connecting to MCP server: ${server.name}`);
-      const status = this.mcpConnectionStatus.get(server.name);
-      if (status) {
-        setTimeout(() => {
-          status.connected = true;
-          this.logger.info(`MCP server ${server.name} connected successfully`);
-        }, Math.random() * 2e3 + 1e3);
-      }
-    } 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";
-      }
-    }
   }
   /**
    * Get MCP connection status for all servers
    * @returns {Map<string, MCPConnectionStatus>} Connection status map
    */
   getMCPConnectionStatus() {
-    return new Map(this.mcpConnectionStatus);
+    if (this.agent) {
+      return this.agent.getMCPConnectionStatus();
+    }
+    return /* @__PURE__ */ new Map();
   }
   /**
    * Check if a specific MCP server is connected
@@ -601,8 +549,12 @@ class ConversationalAgent {
    * @returns {boolean} True if connected, false otherwise
    */
   isMCPServerConnected(serverName) {
-    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;
   }
   /**
    * Clean up resources
@@ -628,6 +580,15 @@ class ConversationalAgent {
       this.logger.error("Error during cleanup:", error);
     }
   }
+  extractResponseText(response) {
+    if (typeof response === "string") {
+      return response;
+    }
+    if (response && typeof response === "object" && "output" in response) {
+      return String(response.output);
+    }
+    return JSON.stringify(response);
+  }
 }
 export {
   ConversationalAgent