@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

package/src/tools/SendMessageToConnectionTool.ts

@@ -1,142 +0,0 @@
-// src/tools/send-message-to-connection-tool.ts
-
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/state-types';
-import { Logger } from '@hashgraphonline/standards-sdk'; // Assuming logger utility
-
-export interface SendMessageToConnectionToolParams extends ToolParams {
-  hcsClient: HCS10Client;
-  stateManager: IStateManager;
-}
-
-/**
- * A tool to send a message to an agent over an established HCS-10 connection.
- */
-export class SendMessageToConnectionTool extends StructuredTool {
-  name = 'send_message_to_connection';
-  description =
-    "Sends a text message to another agent using an existing active connection. Identify the target agent using their account ID (e.g., 0.0.12345) or the connection number shown in 'list_connections'. Return back the reply from the target agent if possible";
-  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."
-      ),
-    message: z.string().describe('The text message content to send.'),
-    disableMonitoring: z.boolean().optional().default(false),
-  });
-
-  private hcsClient: HCS10Client;
-  private stateManager: IStateManager;
-  private logger: Logger;
-
-  constructor({
-    hcsClient,
-    stateManager,
-    ...rest
-  }: SendMessageToConnectionToolParams) {
-    super(rest);
-    this.hcsClient = hcsClient;
-    this.stateManager = stateManager;
-    this.logger = Logger.getInstance({ module: 'SendMessageToConnectionTool' });
-  }
-
-  protected async _call({
-    targetIdentifier,
-    message,
-    disableMonitoring,
-  }: z.infer<this['schema']>): Promise<string> {
-    const currentAgent = this.stateManager.getCurrentAgent();
-    if (!currentAgent) {
-      return 'Error: Cannot send message. No agent is currently active. Please register or select an agent first.';
-    }
-
-    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;
-
-    // Construct the sender's operator ID
-    const operatorId = `${currentAgent.inboundTopicId}@${currentAgent.accountId}`;
-
-    this.logger.info(
-      `Sending message from ${operatorId} to ${targetAgentName} (${connection.targetAccountId}) via connection topic ${connectionTopicId}`
-    );
-
-    try {
-      // Call sendMessage with correct arguments
-      const sequenceNumber = await this.hcsClient.sendMessage(
-        connectionTopicId,
-        message, // Message content as 'data'
-        `Agent message from ${currentAgent.name}` // Optional memo
-      );
-
-      if (!sequenceNumber) {
-        throw new Error('Failed to send message');
-      }
-
-      if (!disableMonitoring) {
-        return `Message sent to ${targetAgentName} (${connection.targetAccountId}) via connection ${connectionTopicId}. Sequence Number: ${sequenceNumber}`;
-      }
-
-      const replyBack = await this.monitorResponses(
-        connectionTopicId,
-        operatorId,
-        sequenceNumber
-      );
-
-      if (replyBack) {
-        this.logger.info(`Got reply from ${targetAgentName}`, replyBack);
-        // Format the return string clearly as an observation/reply
-        return `Received reply from ${targetAgentName}: ${replyBack}`;
-      }
-
-      // Return message based on the status string if no reply was received/awaited
-      return `Message sent to ${targetAgentName} (${connection.targetAccountId}) via connection ${connectionTopicId}. Sequence Number: ${sequenceNumber}`;
-    } catch (error) {
-      this.logger.error(
-        `Failed to send message via connection ${connectionTopicId}: ${error}`
-      );
-      return `Error sending message to ${targetAgentName}: ${
-        error instanceof Error ? error.message : String(error)
-      }`;
-    }
-  }
-
-  private async monitorResponses(
-    topicId: string,
-    operatorId: string,
-    sequenceNumber: number
-  ): Promise<string | null> {
-    const maxAttempts = 30;
-    const attempts = 0;
-
-    while (attempts < maxAttempts) {
-      try {
-        const messages = await this.hcsClient.getMessageStream(topicId);
-
-        for (const message of messages.messages) {
-          if (
-            message.sequence_number < sequenceNumber ||
-            message.operator_id === operatorId
-          ) {
-            continue;
-          }
-          const content = await this.hcsClient.getMessageContent(message.data || '');
-
-          return content;
-        }
-      } catch (error) {
-        this.logger.error(`Error monitoring responses: ${error}`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, 4000));
-    }
-    return null;
-  }
-}

package/src/tools/SendMessageTool.ts

@@ -1,116 +0,0 @@
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { StructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { Logger } from '@hashgraphonline/standards-sdk';
-
-/**
- * SendMessageTool wraps the sendMessage() function of HCS10Client.
- * It sends a message to a specified Hedera topic and monitors for responses.
- */
-export class SendMessageTool extends StructuredTool {
-  name = 'send_message';
-  description =
-    'Sends a message to a specified Hedera topic using HCS-10 and monitors for responses.';
-  private client: HCS10Client;
-  private lastProcessedTimestamp: number = 0;
-  private logger: Logger;
-
-  schema = z.object({
-    topicId: z.string().describe('The Hedera topic ID to send the message to'),
-    message: z.string().describe('The message content to send'),
-    disableMonitoring: z
-      .boolean()
-      .optional()
-      .describe('Whether to disable monitoring for responses'),
-  });
-
-  /**
-   * @param client - Instance of HCS10Client.
-   */
-  constructor(client: HCS10Client) {
-    super();
-    this.client = client;
-    this.logger = Logger.getInstance({ module: 'SendMessageTool' });
-  }
-
-  /**
-   * Calls sendMessage() with the provided parameters.
-   */
-  async _call(input: {
-    topicId: string;
-    message: string;
-    disableMonitoring: boolean;
-  }): Promise<string> {
-    try {
-      const result = await this.client.sendMessage(
-        input.topicId,
-        input.message
-      );
-      if (!result) {
-        throw new Error('Failed to send message');
-      }
-      this.logger.info(`Message sent with sequence number ${result}`);
-      if (!input.disableMonitoring) {
-        const response = await this.monitorResponses(input.topicId, result);
-        return `Successfully sent message to topic ${input.topicId}${
-          response ? `\nResponse: ${response}` : ''
-        }`;
-      } else {
-        return `Successfully sent message to topic ${input.topicId}`;
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to send message: ${
-          error instanceof Error ? error.message : String(error)
-        }`
-      );
-    }
-  }
-
-  private async monitorResponses(
-    topicId: string,
-    sequenceNumber: number
-  ): Promise<string | null> {
-    const maxAttempts = 10;
-    let attempts = 0;
-
-    while (attempts < maxAttempts) {
-      try {
-        const messages = await this.client.getMessageStream(topicId);
-
-        for (const message of messages.messages) {
-          if (
-            message.created &&
-            message.created.getTime() > this.lastProcessedTimestamp
-          ) {
-            this.lastProcessedTimestamp = message.created.getTime();
-
-            const content = await this.client.getMessageContent(message.data || '');
-
-            let parsedContent;
-            try {
-              parsedContent = JSON.parse(content);
-            } catch (error) {
-              this.logger.error(`Error parsing message content: ${error}`);
-              continue;
-            }
-            if (message.sequence_number > sequenceNumber) {
-              // Unwrap nested data field if present
-              if (parsedContent && typeof parsedContent.data === 'string') {
-                return parsedContent.data;
-              }
-              return JSON.stringify(parsedContent);
-            }
-          }
-        }
-      } catch (error) {
-        this.logger.error(`Error monitoring responses: ${error}`);
-      }
-
-      attempts++;
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-
-    return null;
-  }
-}