@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

package/dist/es/standards-agent-kit.es9.js

@@ -1,129 +1,47 @@
-import { StructuredTool } from "@langchain/core/tools";
 import { z } from "zod";
-import { Logger } from "@hashgraphonline/standards-sdk";
-class CheckMessagesTool extends StructuredTool {
-  constructor({ hcsClient, stateManager, ...rest }) {
-    super(rest);
+import { BaseHCS10QueryTool } from "./standards-agent-kit.es4.js";
+const CheckMessagesZodSchema = z.object({
+  targetIdentifier: z.string().describe(
+    "The account ID (e.g., 0.0.12345) of the target agent OR the connection number (e.g., '1', '2') from the 'list_connections' tool to check messages for."
+  ),
+  fetchLatest: z.boolean().optional().default(false).describe(
+    "Set to true to fetch the latest messages even if they have been seen before, ignoring the last checked timestamp. Defaults to false (fetching only new messages)."
+  ),
+  lastMessagesCount: z.number().int().positive().optional().describe(
+    "When fetchLatest is true, specifies how many of the most recent messages to retrieve. Defaults to 1."
+  )
+});
+class CheckMessagesTool extends BaseHCS10QueryTool {
+  constructor(params) {
+    super(params);
     this.name = "check_messages";
-    this.description = `Checks for and retrieves messages from an active connection. 
-Identify the target agent using their account ID (e.g., 0.0.12345) or the connection number shown in 'list_connections'. 
-By default, it only retrieves messages newer than the last check. 
-Use 'fetchLatest: true' to get the most recent messages regardless of when they arrived. 
+    this.description = `Checks for and retrieves messages from an active connection.
+Identify the target agent using their account ID (e.g., 0.0.12345) or the connection number shown in 'list_connections'.
+By default, it only retrieves messages newer than the last check.
+Use 'fetchLatest: true' to get the most recent messages regardless of when they arrived.
 Use 'lastMessagesCount' to specify how many latest messages to retrieve (default 1 when fetchLatest is true).`;
-    this.schema = z.object({
-      targetIdentifier: z.string().describe(
-        "The account ID (e.g., 0.0.12345) of the target agent OR the connection number (e.g., '1', '2') from the 'list_connections' tool to check messages for."
-      ),
-      fetchLatest: z.boolean().optional().default(false).describe(
-        "Set to true to fetch the latest messages even if they have been seen before, ignoring the last checked timestamp. Defaults to false (fetching only new messages)."
-      ),
-      lastMessagesCount: z.number().int().positive().optional().describe(
-        "When fetchLatest is true, specifies how many of the most recent messages to retrieve. Defaults to 1."
-      )
-    });
-    this.hcsClient = hcsClient;
-    this.stateManager = stateManager;
-    this.logger = Logger.getInstance({ module: "CheckMessagesTool" });
+    this.specificInputSchema = CheckMessagesZodSchema;
   }
-  async _call({
+  async executeQuery({
     targetIdentifier,
     fetchLatest,
     lastMessagesCount
   }) {
-    const connection = this.stateManager.getConnectionByIdentifier(targetIdentifier);
-    if (!connection) {
-      return `Error: Could not find an active connection matching identifier "${targetIdentifier}". Use 'list_connections' to see active connections.`;
-    }
-    const connectionTopicId = connection.connectionTopicId;
-    const targetAgentName = connection.targetAgentName;
-    const lastProcessedTimestamp = this.stateManager.getLastTimestamp(connectionTopicId);
-    this.logger.info(
-      `Checking messages for connection with ${targetAgentName} (${connection.targetAccountId}) on topic ${connectionTopicId} (fetchLatest: ${fetchLatest}, lastCount: ${lastMessagesCount}, since: ${lastProcessedTimestamp})`
-    );
-    try {
-      const result = await this.hcsClient.getMessages(connectionTopicId);
-      const allMessages = result.messages;
-      if (!allMessages || allMessages.length === 0) {
-        return `No messages found on connection topic ${connectionTopicId}.`;
-      }
-      let messagesToProcess = [];
-      let latestTimestampNanos = lastProcessedTimestamp;
-      const isFetchingLatest = fetchLatest === true;
-      if (isFetchingLatest) {
-        this.logger.info("Fetching latest messages regardless of timestamp.");
-        const count = lastMessagesCount ?? 1;
-        messagesToProcess = allMessages.slice(-count);
-      } else {
-        this.logger.info(
-          `Filtering for messages newer than ${lastProcessedTimestamp}`
-        );
-        messagesToProcess = allMessages.filter((msg) => {
-          const msgTimestampNanos = msg.timestamp * 1e6;
-          return msgTimestampNanos > lastProcessedTimestamp;
-        });
-        if (messagesToProcess.length > 0) {
-          latestTimestampNanos = messagesToProcess.reduce(
-            (maxTs, msg) => Math.max(maxTs, msg.timestamp * 1e6),
-            lastProcessedTimestamp
-          );
-        }
-      }
-      if (messagesToProcess.length === 0) {
-        return isFetchingLatest ? `Could not retrieve the latest message(s). No messages found on topic ${connectionTopicId}.` : `No new messages found for connection with ${targetAgentName} since last check.`;
-      }
-      this.logger.info(`Processing ${messagesToProcess.length} message(s).`);
-      let outputString = isFetchingLatest ? `Latest message(s) from ${targetAgentName}:
-` : `New messages from ${targetAgentName}:
-`;
-      for (const msg of messagesToProcess) {
-        let content = msg.data;
-        try {
-          if (typeof content === "string" && content.startsWith("hcs://")) {
-            this.logger.debug(`Resolving inscribed message: ${content}`);
-            content = await this.hcsClient.getMessageContent(content);
-            this.logger.debug(`Resolved content length: ${content?.length}`);
-          }
-          let displayContent = content;
-          try {
-            const parsed = JSON.parse(content || "{}");
-            if (parsed.p === "hcs-10" && parsed.op === "message" && parsed.data) {
-              const senderOpId = parsed.operator_id || "unknown_sender";
-              displayContent = `[${senderOpId}]: ${parsed.data}`;
-            } else {
-              displayContent = content;
-            }
-          } catch (parseError) {
-            displayContent = content;
-          }
-          const messageDate = new Date(msg.timestamp);
-          outputString += `
-[${messageDate.toLocaleString()}] (Seq: ${msg.sequence_number})
-${displayContent}
-`;
-        } catch (error) {
-          const errorMsg = `Error processing message (Seq: ${msg.sequence_number}): ${error instanceof Error ? error.message : String(error)}`;
-          this.logger.error(errorMsg);
-          outputString += `
-[Error processing message Seq: ${msg.sequence_number}]
-`;
-        }
-      }
-      if (!isFetchingLatest && latestTimestampNanos > lastProcessedTimestamp) {
-        this.logger.debug(
-          `Updating timestamp for topic ${connectionTopicId} to ${latestTimestampNanos}`
-        );
-        this.stateManager.updateTimestamp(
-          connectionTopicId,
-          latestTimestampNanos
-        );
-      }
-      return outputString.trim();
-    } catch (error) {
-      this.logger.error(
-        `Failed to check messages for topic ${connectionTopicId}: ${error}`
-      );
-      return `Error checking messages for ${targetAgentName}: ${error instanceof Error ? error.message : String(error)}`;
+    const hcs10Builder = this.hcs10Builder;
+    await hcs10Builder.checkMessages({
+      targetIdentifier,
+      fetchLatest,
+      lastMessagesCount: lastMessagesCount || 1
+    });
+    const result = await hcs10Builder.execute();
+    if (result.success && "rawResult" in result && result.rawResult) {
+      const raw = result.rawResult;
+      return {
+        success: true,
+        data: raw.formattedOutput || raw.message || "Messages checked"
+      };
     }
+    return result;
   }
 }
 export {

package/dist/es/standards-agent-kit.es9.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-agent-kit.es9.js","sources":["../../src/tools/CheckMessagesTool.ts"],"sourcesContent":["import { StructuredTool, ToolParams } from '@langchain/core/tools';\nimport { z } from 'zod';\nimport { HCS10Client, HCSMessageWithTimestamp } from '../hcs10/HCS10Client';\nimport { IStateManager } from '../state/state-types';\nimport { Logger } from '@hashgraphonline/standards-sdk'; // Assuming logger utility\n\nexport interface CheckMessagesToolParams extends ToolParams {\n  hcsClient: HCS10Client;\n  stateManager: IStateManager;\n}\n\n/**\n * A tool to check for new messages on an active HCS-10 connection topic,\n * or optionally fetch the latest messages regardless of timestamp.\n */\nexport class CheckMessagesTool extends StructuredTool {\n  name = 'check_messages';\n  description = `Checks for and retrieves messages from an active connection. \nIdentify the target agent using their account ID (e.g., 0.0.12345) or the connection number shown in 'list_connections'. \nBy default, it only retrieves messages newer than the last check. \nUse 'fetchLatest: true' to get the most recent messages regardless of when they arrived. \nUse 'lastMessagesCount' to specify how many latest messages to retrieve (default 1 when fetchLatest is true).`;\n  schema = z.object({\n    targetIdentifier: z\n      .string()\n      .describe(\n        \"The account ID (e.g., 0.0.12345) of the target agent OR the connection number (e.g., '1', '2') from the 'list_connections' tool to check messages for.\"\n      ),\n    fetchLatest: z\n      .boolean()\n      .optional()\n      .default(false)\n      .describe(\n        'Set to true to fetch the latest messages even if they have been seen before, ignoring the last checked timestamp. Defaults to false (fetching only new messages).'\n      ),\n    lastMessagesCount: z\n      .number()\n      .int()\n      .positive()\n      .optional()\n      .describe(\n        'When fetchLatest is true, specifies how many of the most recent messages to retrieve. Defaults to 1.'\n      ),\n  });\n\n  public hcsClient: HCS10Client;\n  private stateManager: IStateManager;\n  private logger: Logger;\n\n  constructor({ hcsClient, stateManager, ...rest }: CheckMessagesToolParams) {\n    super(rest);\n    this.hcsClient = hcsClient;\n    this.stateManager = stateManager;\n    this.logger = Logger.getInstance({ module: 'CheckMessagesTool' });\n  }\n\n  protected async _call({\n    targetIdentifier,\n    fetchLatest,\n    lastMessagesCount,\n  }: z.infer<this['schema']>): Promise<string> {\n    const connection =\n      this.stateManager.getConnectionByIdentifier(targetIdentifier);\n\n    if (!connection) {\n      return `Error: Could not find an active connection matching identifier \"${targetIdentifier}\". Use 'list_connections' to see active connections.`;\n    }\n\n    const connectionTopicId = connection.connectionTopicId;\n    const targetAgentName = connection.targetAgentName;\n    const lastProcessedTimestamp =\n      this.stateManager.getLastTimestamp(connectionTopicId);\n\n    this.logger.info(\n      `Checking messages for connection with ${targetAgentName} (${connection.targetAccountId}) on topic ${connectionTopicId} (fetchLatest: ${fetchLatest}, lastCount: ${lastMessagesCount}, since: ${lastProcessedTimestamp})`\n    );\n\n    try {\n      // 1. Get messages from the topic\n      const result = await this.hcsClient.getMessages(connectionTopicId);\n      const allMessages = result.messages;\n\n      if (!allMessages || allMessages.length === 0) {\n        return `No messages found on connection topic ${connectionTopicId}.`;\n      }\n\n      let messagesToProcess: HCSMessageWithTimestamp[] = [];\n      let latestTimestampNanos = lastProcessedTimestamp;\n      const isFetchingLatest = fetchLatest === true;\n\n      if (isFetchingLatest) {\n        this.logger.info('Fetching latest messages regardless of timestamp.');\n        const count = lastMessagesCount ?? 1;\n        messagesToProcess = allMessages.slice(-count);\n      } else {\n        this.logger.info(\n          `Filtering for messages newer than ${lastProcessedTimestamp}`\n        );\n        messagesToProcess = allMessages.filter((msg) => {\n          const msgTimestampNanos = msg.timestamp * 1_000_000;\n          return msgTimestampNanos > lastProcessedTimestamp;\n        });\n        \n        if (messagesToProcess.length > 0) {\n          latestTimestampNanos = messagesToProcess.reduce(\n            (maxTs, msg) => Math.max(maxTs, msg.timestamp * 1_000_000),\n             lastProcessedTimestamp\n          );\n        }\n      }\n\n      if (messagesToProcess.length === 0) {\n        return isFetchingLatest\n          ? `Could not retrieve the latest message(s). No messages found on topic ${connectionTopicId}.`\n          : `No new messages found for connection with ${targetAgentName} since last check.`;\n      }\n\n      this.logger.info(`Processing ${messagesToProcess.length} message(s).`);\n\n      // 3. Process messages (resolve inscriptions, format)\n      let outputString = isFetchingLatest\n        ? `Latest message(s) from ${targetAgentName}:\n`\n        : `New messages from ${targetAgentName}:\n`;\n\n      for (const msg of messagesToProcess) {\n        let content = msg.data;\n        try {\n          // Check for inscription HRL\n          if (typeof content === 'string' && content.startsWith('hcs://')) {\n            this.logger.debug(`Resolving inscribed message: ${content}`);\n            content = await this.hcsClient.getMessageContent(content);\n            this.logger.debug(`Resolved content length: ${content?.length}`);\n          }\n\n          // Attempt to parse the content as the HCS-10 structure\n          let displayContent = content; // Default to raw content\n          try {\n            const parsed = JSON.parse(content || '{}');\n            if (\n              parsed.p === 'hcs-10' &&\n              parsed.op === 'message' &&\n              parsed.data\n            ) {\n              // Extract sender and actual data from standard message format\n              const senderOpId = parsed.operator_id || 'unknown_sender';\n              displayContent = `[${senderOpId}]: ${parsed.data}`;\n            } else {\n              // If not standard format, maybe just show raw stringified version\n              displayContent = content; // Keep raw if parsing worked but not expected format\n            }\n          } catch (parseError) {\n            // Content wasn't JSON, keep raw content\n            displayContent = content;\n          }\n\n          const messageDate = new Date(msg.timestamp);\n          outputString += `\\n[${messageDate.toLocaleString()}] (Seq: ${\n            msg.sequence_number\n          })\n${displayContent}\n`;\n        } catch (error) {\n          const errorMsg = `Error processing message (Seq: ${\n            msg.sequence_number\n          }): ${error instanceof Error ? error.message : String(error)}`;\n          this.logger.error(errorMsg);\n          outputString += `\\n[Error processing message Seq: ${msg.sequence_number}]\\n`;\n        }\n      }\n\n      // 4. Update the timestamp in demo state ONLY if fetching NEW messages\n      if (!isFetchingLatest && latestTimestampNanos > lastProcessedTimestamp) {\n        this.logger.debug(\n          `Updating timestamp for topic ${connectionTopicId} to ${latestTimestampNanos}`\n        );\n        this.stateManager.updateTimestamp(\n          connectionTopicId,\n          latestTimestampNanos\n        );\n      }\n\n      return outputString.trim();\n    } catch (error) {\n      this.logger.error(\n        `Failed to check messages for topic ${connectionTopicId}: ${error}`\n      );\n      return `Error checking messages for ${targetAgentName}: ${\n        error instanceof Error ? error.message : String(error)\n      }`;\n    }\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"standards-agent-kit.es9.js","sources":["../../src/tools/hcs10/CheckMessagesTool.ts"],"sourcesContent":["import { z } from 'zod';\nimport { BaseHCS10QueryTool } from './base-hcs10-tools';\nimport { HCS10QueryToolParams } from './hcs10-tool-params';\n\n/**\n * A tool to check for new messages on an active HCS-10 connection topic,\n * or optionally fetch the latest messages regardless of timestamp.\n */\nconst CheckMessagesZodSchema = z.object({\n  targetIdentifier: z\n    .string()\n    .describe(\n      \"The account ID (e.g., 0.0.12345) of the target agent OR the connection number (e.g., '1', '2') from the 'list_connections' tool to check messages for.\"\n    ),\n  fetchLatest: z\n    .boolean()\n    .optional()\n    .default(false)\n    .describe(\n      'Set to true to fetch the latest messages even if they have been seen before, ignoring the last checked timestamp. Defaults to false (fetching only new messages).'\n    ),\n  lastMessagesCount: z\n    .number()\n    .int()\n    .positive()\n    .optional()\n    .describe(\n      'When fetchLatest is true, specifies how many of the most recent messages to retrieve. Defaults to 1.'\n    ),\n});\n\nexport class CheckMessagesTool extends BaseHCS10QueryTool<\n  typeof CheckMessagesZodSchema\n> {\n  name = 'check_messages';\n  description = `Checks for and retrieves messages from an active connection.\nIdentify the target agent using their account ID (e.g., 0.0.12345) or the connection number shown in 'list_connections'.\nBy default, it only retrieves messages newer than the last check.\nUse 'fetchLatest: true' to get the most recent messages regardless of when they arrived.\nUse 'lastMessagesCount' to specify how many latest messages to retrieve (default 1 when fetchLatest is true).`;\n  specificInputSchema = CheckMessagesZodSchema;\n  constructor(params: HCS10QueryToolParams) {\n    super(params);\n  }\n\n  protected async executeQuery({\n    targetIdentifier,\n    fetchLatest,\n    lastMessagesCount,\n  }: z.infer<typeof CheckMessagesZodSchema>): Promise<unknown> {\n    const hcs10Builder = this.hcs10Builder;\n    await hcs10Builder.checkMessages({\n      targetIdentifier,\n      fetchLatest,\n      lastMessagesCount: lastMessagesCount || 1,\n    });\n\n    const result = await hcs10Builder.execute();\n\n    if (result.success && 'rawResult' in result && result.rawResult) {\n      const raw = result.rawResult as {\n        formattedOutput?: string;\n        message?: string;\n      };\n      return {\n        success: true,\n        data: raw.formattedOutput || raw.message || 'Messages checked',\n      };\n    }\n\n    return result;\n  }\n}"],"names":[],"mappings":";;AAQA,MAAM,yBAAyB,EAAE,OAAO;AAAA,EACtC,kBAAkB,EACf,OAAA,EACA;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,aAAa,EACV,QAAA,EACA,WACA,QAAQ,KAAK,EACb;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,mBAAmB,EAChB,SACA,MACA,SAAA,EACA,SAAA,EACA;AAAA,IACC;AAAA,EAAA;AAEN,CAAC;AAEM,MAAM,0BAA0B,mBAErC;AAAA,EAQA,YAAY,QAA8B;AACxC,UAAM,MAAM;AARd,SAAA,OAAO;AACP,SAAA,cAAc;AAAA;AAAA;AAAA;AAAA;AAKd,SAAA,sBAAsB;AAAA,EAGtB;AAAA,EAEA,MAAgB,aAAa;AAAA,IAC3B;AAAA,IACA;AAAA,IACA;AAAA,EAAA,GAC2D;AAC3D,UAAM,eAAe,KAAK;AAC1B,UAAM,aAAa,cAAc;AAAA,MAC/B;AAAA,MACA;AAAA,MACA,mBAAmB,qBAAqB;AAAA,IAAA,CACzC;AAED,UAAM,SAAS,MAAM,aAAa,QAAA;AAElC,QAAI,OAAO,WAAW,eAAe,UAAU,OAAO,WAAW;AAC/D,YAAM,MAAM,OAAO;AAInB,aAAO;AAAA,QACL,SAAS;AAAA,QACT,MAAM,IAAI,mBAAmB,IAAI,WAAW;AAAA,MAAA;AAAA,IAEhD;AAEA,WAAO;AAAA,EACT;AACF;"}

package/dist/es/state/state-types.d.ts

@@ -86,7 +86,7 @@ export interface IStateManager {
     /**
      * Sets the current active agent, clearing any previous connections.
      */
-    setCurrentAgent(agent: RegisteredAgent | null): void;
+    setCurrentAgent(_agent: RegisteredAgent | null): void;
     /**
      * Gets the current active agent.
      */
@@ -95,12 +95,12 @@ export interface IStateManager {
      * Adds a new active connection to the state.
      * Will not add duplicates based on connectionTopicId.
      */
-    addActiveConnection(connection: ActiveConnection): void;
+    addActiveConnection(_connection: ActiveConnection): void;
     /**
      * Updates an existing connection or adds it if not found.
      * Preserves existing properties when updating.
      */
-    updateOrAddConnection(connection: ActiveConnection): void;
+    updateOrAddConnection(_connection: ActiveConnection): void;
     /**
      * Lists all active connections for the current agent.
      */
@@ -111,26 +111,26 @@ export interface IStateManager {
      * - A target account ID
      * - A connection topic ID
      */
-    getConnectionByIdentifier(identifier: string): ActiveConnection | undefined;
+    getConnectionByIdentifier(_identifier: string): ActiveConnection | undefined;
     /**
      * Gets the last processed message timestamp for a connection.
      */
-    getLastTimestamp(connectionTopicId: string): number;
+    getLastTimestamp(_connectionTopicId: string): number;
     /**
      * Updates the last processed message timestamp for a connection.
      */
-    updateTimestamp(connectionTopicId: string, timestampNanos: number): void;
+    updateTimestamp(_connectionTopicId: string, _timestampNanos: number): void;
     /**
      * Persists agent data to storage
      * Implementation may vary depending on the state manager
      */
-    persistAgentData?(agent: RegisteredAgent, options?: AgentPersistenceOptions): Promise<void>;
+    persistAgentData?(_agent: RegisteredAgent, _options?: AgentPersistenceOptions): Promise<void>;
     /**
      * Initializes the ConnectionsManager with the provided client
      * @param baseClient - The HCS10BaseClient instance to use
      * @returns The initialized ConnectionsManager
      */
-    initializeConnectionsManager(baseClient: HCS10BaseClient): IConnectionsManager;
+    initializeConnectionsManager(_baseClient: HCS10BaseClient): IConnectionsManager;
     /**
      * Gets the ConnectionsManager instance
      * @returns The ConnectionsManager instance or null if not initialized

package/dist/es/tools/hcs10/AcceptConnectionRequestTool.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { BaseHCS10TransactionTool } from './base-hcs10-tools';
+import { HCS10TransactionToolParams } from './hcs10-tool-params';
+import { BaseServiceBuilder } from 'hedera-agent-kit';
+declare const AcceptConnectionRequestZodSchema: z.ZodObject<{
+    requestKey: z.ZodString;
+    hbarFee: z.ZodOptional<z.ZodNumber>;
+    exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    requestKey: string;
+    exemptAccountIds?: string[] | undefined;
+    hbarFee?: number | undefined;
+}, {
+    requestKey: string;
+    exemptAccountIds?: string[] | undefined;
+    hbarFee?: number | undefined;
+}>;
+/**
+ * Tool for accepting incoming HCS-10 connection requests
+ */
+export declare class AcceptConnectionRequestTool extends BaseHCS10TransactionTool<typeof AcceptConnectionRequestZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        requestKey: z.ZodString;
+        hbarFee: z.ZodOptional<z.ZodNumber>;
+        exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        requestKey: string;
+        exemptAccountIds?: string[] | undefined;
+        hbarFee?: number | undefined;
+    }, {
+        requestKey: string;
+        exemptAccountIds?: string[] | undefined;
+        hbarFee?: number | undefined;
+    }>;
+    constructor(params: HCS10TransactionToolParams);
+    protected callBuilderMethod(builder: BaseServiceBuilder, specificArgs: z.infer<typeof AcceptConnectionRequestZodSchema>): Promise<void>;
+}
+export {};

package/dist/es/tools/hcs10/CheckMessagesTool.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { BaseHCS10QueryTool } from './base-hcs10-tools';
+import { HCS10QueryToolParams } from './hcs10-tool-params';
+/**
+ * A tool to check for new messages on an active HCS-10 connection topic,
+ * or optionally fetch the latest messages regardless of timestamp.
+ */
+declare const CheckMessagesZodSchema: z.ZodObject<{
+    targetIdentifier: z.ZodString;
+    fetchLatest: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    lastMessagesCount: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    targetIdentifier: string;
+    fetchLatest: boolean;
+    lastMessagesCount?: number | undefined;
+}, {
+    targetIdentifier: string;
+    fetchLatest?: boolean | undefined;
+    lastMessagesCount?: number | undefined;
+}>;
+export declare class CheckMessagesTool extends BaseHCS10QueryTool<typeof CheckMessagesZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        targetIdentifier: z.ZodString;
+        fetchLatest: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        lastMessagesCount: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        targetIdentifier: string;
+        fetchLatest: boolean;
+        lastMessagesCount?: number | undefined;
+    }, {
+        targetIdentifier: string;
+        fetchLatest?: boolean | undefined;
+        lastMessagesCount?: number | undefined;
+    }>;
+    constructor(params: HCS10QueryToolParams);
+    protected executeQuery({ targetIdentifier, fetchLatest, lastMessagesCount, }: z.infer<typeof CheckMessagesZodSchema>): Promise<unknown>;
+}
+export {};

package/dist/es/tools/hcs10/ConnectionMonitorTool.d.ts

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { BaseHCS10TransactionTool } from './base-hcs10-tools';
+import { HCS10TransactionToolParams } from './hcs10-tool-params';
+import { BaseServiceBuilder } from 'hedera-agent-kit';
+declare const ConnectionMonitorZodSchema: z.ZodObject<{
+    acceptAll: z.ZodOptional<z.ZodBoolean>;
+    targetAccountId: z.ZodOptional<z.ZodString>;
+    hbarFees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        amount: z.ZodNumber;
+        collectorAccount: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        amount: number;
+        collectorAccount?: string | undefined;
+    }, {
+        amount: number;
+        collectorAccount?: string | undefined;
+    }>, "many">>;
+    tokenFees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        amount: z.ZodNumber;
+        tokenId: z.ZodString;
+        collectorAccount: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        amount: number;
+        tokenId: string;
+        collectorAccount?: string | undefined;
+    }, {
+        amount: number;
+        tokenId: string;
+        collectorAccount?: string | undefined;
+    }>, "many">>;
+    exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    monitorDurationSeconds: z.ZodOptional<z.ZodNumber>;
+    defaultCollectorAccount: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    acceptAll?: boolean | undefined;
+    targetAccountId?: string | undefined;
+    monitorDurationSeconds?: number | undefined;
+    hbarFees?: {
+        amount: number;
+        collectorAccount?: string | undefined;
+    }[] | undefined;
+    tokenFees?: {
+        amount: number;
+        tokenId: string;
+        collectorAccount?: string | undefined;
+    }[] | undefined;
+    exemptAccountIds?: string[] | undefined;
+    defaultCollectorAccount?: string | undefined;
+}, {
+    acceptAll?: boolean | undefined;
+    targetAccountId?: string | undefined;
+    monitorDurationSeconds?: number | undefined;
+    hbarFees?: {
+        amount: number;
+        collectorAccount?: string | undefined;
+    }[] | undefined;
+    tokenFees?: {
+        amount: number;
+        tokenId: string;
+        collectorAccount?: string | undefined;
+    }[] | undefined;
+    exemptAccountIds?: string[] | undefined;
+    defaultCollectorAccount?: string | undefined;
+}>;
+/**
+ * A tool for monitoring incoming connection requests and accepting them with optional fee settings.
+ */
+export declare class ConnectionMonitorTool extends BaseHCS10TransactionTool<typeof ConnectionMonitorZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        acceptAll: z.ZodOptional<z.ZodBoolean>;
+        targetAccountId: z.ZodOptional<z.ZodString>;
+        hbarFees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            amount: z.ZodNumber;
+            collectorAccount: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            amount: number;
+            collectorAccount?: string | undefined;
+        }, {
+            amount: number;
+            collectorAccount?: string | undefined;
+        }>, "many">>;
+        tokenFees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            amount: z.ZodNumber;
+            tokenId: z.ZodString;
+            collectorAccount: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string | undefined;
+        }, {
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string | undefined;
+        }>, "many">>;
+        exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        monitorDurationSeconds: z.ZodOptional<z.ZodNumber>;
+        defaultCollectorAccount: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        acceptAll?: boolean | undefined;
+        targetAccountId?: string | undefined;
+        monitorDurationSeconds?: number | undefined;
+        hbarFees?: {
+            amount: number;
+            collectorAccount?: string | undefined;
+        }[] | undefined;
+        tokenFees?: {
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string | undefined;
+        }[] | undefined;
+        exemptAccountIds?: string[] | undefined;
+        defaultCollectorAccount?: string | undefined;
+    }, {
+        acceptAll?: boolean | undefined;
+        targetAccountId?: string | undefined;
+        monitorDurationSeconds?: number | undefined;
+        hbarFees?: {
+            amount: number;
+            collectorAccount?: string | undefined;
+        }[] | undefined;
+        tokenFees?: {
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string | undefined;
+        }[] | undefined;
+        exemptAccountIds?: string[] | undefined;
+        defaultCollectorAccount?: string | undefined;
+    }>;
+    constructor(params: HCS10TransactionToolParams);
+    protected callBuilderMethod(builder: BaseServiceBuilder, specificArgs: z.infer<typeof ConnectionMonitorZodSchema>): Promise<void>;
+}
+export {};

package/dist/es/tools/hcs10/FindRegistrationsTool.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { AIAgentCapability } from '@hashgraphonline/standards-sdk';
+import { BaseHCS10QueryTool } from './base-hcs10-tools';
+import { HCS10QueryToolParams } from './hcs10-tool-params';
+/**
+ * A tool to search for registered HCS-10 agents using the configured registry.
+ */
+declare const FindRegistrationsZodSchema: z.ZodObject<{
+    accountId: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof AIAgentCapability>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    accountId?: string | undefined;
+    tags?: AIAgentCapability[] | undefined;
+}, {
+    accountId?: string | undefined;
+    tags?: AIAgentCapability[] | undefined;
+}>;
+export declare class FindRegistrationsTool extends BaseHCS10QueryTool<typeof FindRegistrationsZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        accountId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof AIAgentCapability>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        accountId?: string | undefined;
+        tags?: AIAgentCapability[] | undefined;
+    }, {
+        accountId?: string | undefined;
+        tags?: AIAgentCapability[] | undefined;
+    }>;
+    constructor(params: HCS10QueryToolParams);
+    protected executeQuery({ accountId, tags, }: z.infer<typeof FindRegistrationsZodSchema>): Promise<unknown>;
+}
+export {};

package/dist/es/tools/hcs10/InitiateConnectionTool.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { BaseHCS10TransactionTool } from './base-hcs10-tools';
+import { HCS10TransactionToolParams } from './hcs10-tool-params';
+import { BaseServiceBuilder } from 'hedera-agent-kit';
+declare const InitiateConnectionZodSchema: z.ZodObject<{
+    targetAccountId: z.ZodString;
+    disableMonitor: z.ZodOptional<z.ZodBoolean>;
+    memo: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    targetAccountId: string;
+    disableMonitor?: boolean | undefined;
+    memo?: string | undefined;
+}, {
+    targetAccountId: string;
+    disableMonitor?: boolean | undefined;
+    memo?: string | undefined;
+}>;
+/**
+ * A tool to actively START a NEW HCS-10 connection TO a target agent.
+ * Requires the target agent's account ID.
+ * It retrieves their profile, sends a connection request, and optionally waits for confirmation.
+ * Use this tool ONLY to actively INITIATE an OUTGOING connection.
+ */
+export declare class InitiateConnectionTool extends BaseHCS10TransactionTool<typeof InitiateConnectionZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        targetAccountId: z.ZodString;
+        disableMonitor: z.ZodOptional<z.ZodBoolean>;
+        memo: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        targetAccountId: string;
+        disableMonitor?: boolean | undefined;
+        memo?: string | undefined;
+    }, {
+        targetAccountId: string;
+        disableMonitor?: boolean | undefined;
+        memo?: string | undefined;
+    }>;
+    constructor(params: HCS10TransactionToolParams);
+    protected callBuilderMethod(builder: BaseServiceBuilder, specificArgs: z.infer<typeof InitiateConnectionZodSchema>): Promise<void>;
+}
+export {};

package/dist/es/tools/hcs10/ListConnectionsTool.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { BaseHCS10QueryTool } from './base-hcs10-tools';
+import { HCS10QueryToolParams } from './hcs10-tool-params';
+/**
+ * A tool to list currently active HCS-10 connections stored in the state manager.
+ * Enhanced to show more details similar to moonscape's implementation.
+ */
+declare const ListConnectionsZodSchema: z.ZodObject<{
+    includeDetails: z.ZodOptional<z.ZodBoolean>;
+    showPending: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    includeDetails?: boolean | undefined;
+    showPending?: boolean | undefined;
+}, {
+    includeDetails?: boolean | undefined;
+    showPending?: boolean | undefined;
+}>;
+export declare class ListConnectionsTool extends BaseHCS10QueryTool<typeof ListConnectionsZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        includeDetails: z.ZodOptional<z.ZodBoolean>;
+        showPending: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        includeDetails?: boolean | undefined;
+        showPending?: boolean | undefined;
+    }, {
+        includeDetails?: boolean | undefined;
+        showPending?: boolean | undefined;
+    }>;
+    constructor(params: HCS10QueryToolParams);
+    protected executeQuery(args: z.infer<typeof ListConnectionsZodSchema>): Promise<unknown>;
+}
+export {};

package/dist/es/tools/hcs10/ListUnapprovedConnectionRequestsTool.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { BaseHCS10QueryTool } from './base-hcs10-tools';
+import { HCS10QueryToolParams } from './hcs10-tool-params';
+declare const ListUnapprovedConnectionRequestsZodSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Lists all connection requests that are not fully established
+ */
+export declare class ListUnapprovedConnectionRequestsTool extends BaseHCS10QueryTool<typeof ListUnapprovedConnectionRequestsZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    constructor(params: HCS10QueryToolParams);
+    protected executeQuery(): Promise<unknown>;
+}
+export {};

package/dist/es/tools/hcs10/ManageConnectionRequestsTool.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { BaseHCS10QueryTool } from './base-hcs10-tools';
+import { HCS10QueryToolParams } from './hcs10-tool-params';
+declare const ManageConnectionRequestsZodSchema: z.ZodObject<{
+    action: z.ZodEnum<["list", "view", "reject"]>;
+    requestKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "list" | "view" | "reject";
+    requestKey?: string | undefined;
+}, {
+    action: "list" | "view" | "reject";
+    requestKey?: string | undefined;
+}>;
+/**
+ * A tool for managing incoming connection requests in a LangChain-compatible way.
+ * This tool allows an agent to list, view details of, and reject incoming connection requests.
+ */
+export declare class ManageConnectionRequestsTool extends BaseHCS10QueryTool<typeof ManageConnectionRequestsZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        action: z.ZodEnum<["list", "view", "reject"]>;
+        requestKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        action: "list" | "view" | "reject";
+        requestKey?: string | undefined;
+    }, {
+        action: "list" | "view" | "reject";
+        requestKey?: string | undefined;
+    }>;
+    constructor(params: HCS10QueryToolParams);
+    protected executeQuery({ action, requestKey, }: z.infer<typeof ManageConnectionRequestsZodSchema>): Promise<unknown>;
+}
+export {};