@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

package/src/tools/ConnectionTool.ts

@@ -1,231 +0,0 @@
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-// Import FeeConfigBuilder if needed for explicit fee handling
-// import { FeeConfigBuilder } from '@hashgraphonline/standards-sdk';
-import { Logger } from '@hashgraphonline/standards-sdk';
-import {
-  IStateManager,
-  ActiveConnection,
-} from '../state/state-types'; // Corrected import path/name
-
-export interface ConnectionToolParams extends ToolParams {
-  client: HCS10Client;
-  stateManager: IStateManager;
-}
-
-/**
- * ConnectionTool monitors the *current* agent's inbound topic for connection requests
- * and automatically handles them using the HCS-10 standard SDK flow.
- * Use this ONLY to passively LISTEN for other agents trying to connect TO YOU.
- * This tool takes NO arguments and does NOT start outgoing connections.
- */
-export class ConnectionTool extends StructuredTool {
-  name = 'monitor_connections';
-  description =
-    "Starts passively LISTENING on the current agent's own inbound topic for INCOMING HCS-10 connection requests. Handles received requests automatically. Takes NO arguments. DO NOT use this to start a new connection TO someone else.";
-  public client: HCS10Client;
-  public logger: Logger;
-  private stateManager: IStateManager; // Renamed property
-  private isMonitoring: boolean = false; // Flag to prevent multiple monitors
-  private monitoringTopic: string | null = null;
-
-  // Schema now takes NO arguments
-  schema = z.object({});
-
-  /**
-   * @param client - Instance of HCS10Client.
-   * @param stateManager - Instance of StateManager for shared state management.
-   */
-  constructor({ client, stateManager, ...rest }: ConnectionToolParams) {
-    super(rest);
-    this.client = client;
-    this.stateManager = stateManager; // Renamed assignment
-    this.logger = Logger.getInstance({
-      module: 'ConnectionTool',
-      level: 'info',
-    });
-  }
-
-  /**
-   * Initiates the connection request monitoring process in the background.
-   * Gets the inbound topic ID from the configured client.
-   */
-  async _call(/* _input: z.infer<typeof this.schema> */): Promise<string> {
-    // Get inboundTopicId from the client
-    let inboundTopicId: string;
-    try {
-      // Assuming getInboundTopicId() is implemented and available
-      inboundTopicId = await this.client.getInboundTopicId();
-    } catch (error) {
-      const errorMsg = `Error getting inbound topic ID for monitoring: ${
-        error instanceof Error ? error.message : String(error)
-      }`;
-      this.logger.error(errorMsg);
-      return errorMsg;
-    }
-
-    if (!inboundTopicId) {
-      return 'Error: Could not determine the inbound topic ID for the current agent.';
-    }
-
-    if (this.isMonitoring) {
-      if (this.monitoringTopic === inboundTopicId) {
-        return `Already monitoring topic ${inboundTopicId}.`;
-      } else {
-        return `Error: Already monitoring a different topic (${this.monitoringTopic}). Stop the current monitor first.`;
-        // TODO: Add a mechanism to stop the monitor if needed.
-      }
-    }
-
-    this.isMonitoring = true;
-    this.monitoringTopic = inboundTopicId;
-    this.logger.info(
-      `Initiating connection request monitoring for topic ${inboundTopicId}...`
-    );
-
-    // Start the monitoring process asynchronously without awaiting it
-    // This allows the tool call to return quickly.
-    this.monitorIncomingRequests(inboundTopicId).catch((error) => {
-      this.logger.error(
-        `Monitoring loop for ${inboundTopicId} encountered an unrecoverable error:`,
-        error
-      );
-      this.isMonitoring = false; // Reset flag on loop failure
-      this.monitoringTopic = null;
-    });
-
-    return `Started monitoring inbound topic ${inboundTopicId} for connection requests in the background.`;
-  }
-
-  /**
-   * The core monitoring loop.
-   */
-  private async monitorIncomingRequests(inboundTopicId: string): Promise<void> {
-    this.logger.info(`Monitoring inbound topic ${inboundTopicId}...`);
-
-    let lastProcessedMessageSequence = 0;
-    const processedRequestIds = new Set<number>(); // Track processed requests within this monitoring session
-
-    // Main monitoring loop
-    while (this.isMonitoring && this.monitoringTopic === inboundTopicId) {
-      try {
-        const messagesResult = await this.client.getMessages(inboundTopicId);
-
-        const allMessages = messagesResult.messages;
-
-        const connectionRequests = allMessages.filter(
-          (msg) =>
-            msg.op === 'connection_request' &&
-            typeof msg.sequence_number === 'number' // Keep filtering by sequence number if needed, or remove if checking existing confirmations is sufficient
-            // msg.sequence_number > lastProcessedMessageSequence // Temporarily remove or adjust this if checking confirmations is the primary method
-        );
-
-        for (const message of connectionRequests) {
-          // Update lastProcessedMessageSequence regardless of handling outcome to avoid re-checking handled/skipped messages in future loops
-          lastProcessedMessageSequence = Math.max(
-            lastProcessedMessageSequence,
-            message.sequence_number || 0 // Use 0 if sequence_number is undefined (though filter should prevent this)
-          );
-
-          const connectionRequestId = message.sequence_number;
-          if (!connectionRequestId) {
-             continue; // Skip if sequence number is missing
-          }
-
-          // --- Check if already handled ---
-          const alreadyHandled = allMessages.some(
-            (m) => m.op === 'connection_created' && m.connection_id === connectionRequestId
-          );
-
-          if (alreadyHandled) {
-            this.logger.debug(
-              `Connection request #${connectionRequestId} already handled (found connection_created). Skipping.`
-            );
-            continue; // Skip to the next request
-          }
-          // --- End Check ---
-
-          // Extract requesting account ID from the message's operator_id field (topic@account)
-          const senderOperatorId = message.operator_id || '';
-          const requestingAccountId = senderOperatorId.split('@')[1] || null;
-
-          if (!requestingAccountId) {
-            this.logger.warn(
-              `Could not determine requesting account ID from operator_id '${senderOperatorId}' for request #${connectionRequestId}. Skipping.`
-            );
-            continue;
-          }
-
-          if (processedRequestIds.has(connectionRequestId)) {
-            this.logger.info(
-              `Connection request #${connectionRequestId} already processed in this session. Skipping.`
-            );
-            continue;
-          }
-
-          this.logger.info(
-            `Processing connection request #${connectionRequestId} from account ${requestingAccountId}...`
-          );
-
-          try {
-            // Handle the connection request using the HCS10Client wrapper
-            const confirmation = await this.client.handleConnectionRequest(
-              inboundTopicId,
-              requestingAccountId,
-              connectionRequestId
-            );
-
-            processedRequestIds.add(connectionRequestId);
-            this.logger.info(
-              `Connection confirmed for request #${connectionRequestId}. New connection topic: ${confirmation.connectionTopicId}`
-            );
-
-            // Use stateManager to add connection
-            const newConnection: ActiveConnection = {
-              targetAccountId: requestingAccountId,
-              targetAgentName: `Agent ${requestingAccountId}`,
-              targetInboundTopicId: 'N/A',
-              connectionTopicId: confirmation.connectionTopicId,
-            };
-            this.stateManager.addActiveConnection(newConnection);
-            this.logger.info(
-              `Added new active connection to ${requestingAccountId} state.`
-            );
-          } catch (handleError) {
-            this.logger.error(
-              `Error handling connection request #${connectionRequestId} from ${requestingAccountId}:`,
-              handleError
-            );
-          }
-        }
-      } catch (error) {
-        this.logger.error(
-          `Error fetching or processing messages for topic ${inboundTopicId}:`,
-          error
-        );
-        // Implement backoff or error threshold if needed
-      }
-
-      // Wait before the next poll
-      await new Promise((resolve) => setTimeout(resolve, 5000)); // Poll every 5 seconds (adjust as needed)
-    }
-
-    this.logger.info(`Monitoring loop stopped for topic ${inboundTopicId}.`);
-    this.isMonitoring = false; // Ensure flag is reset when loop exits
-    this.monitoringTopic = null;
-  }
-
-  // Optional: Method to explicitly stop monitoring
-  public stopMonitoring(): void {
-    if (this.isMonitoring) {
-      this.logger.info(
-        `Stopping monitoring for topic ${this.monitoringTopic}...`
-      );
-      this.isMonitoring = false;
-      this.monitoringTopic = null;
-    } else {
-      this.logger.info('Monitor is not currently running.');
-    }
-  }
-}

package/src/tools/FindRegistrationsTool.ts

@@ -1,114 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import {
-  AIAgentCapability,
-  Logger,
-  RegistrationSearchOptions,
-} from '@hashgraphonline/standards-sdk';
-
-export interface FindRegistrationsToolParams extends ToolParams {
-  hcsClient: HCS10Client;
-}
-
-/**
- * A tool to search for registered HCS-10 agents using the configured registry.
- */
-export class FindRegistrationsTool extends StructuredTool {
-  name = 'find_registrations';
-  description =
-    'Searches the configured agent registry for HCS-10 agents. You can filter by account ID or tags. Returns basic registration info.';
-  schema = z.object({
-    accountId: z
-      .string()
-      .optional()
-      .describe(
-        'Optional: Filter registrations by a specific Hedera account ID (e.g., 0.0.12345).'
-      ),
-    tags: z
-      .array(z.nativeEnum(AIAgentCapability))
-      .optional()
-      .describe(
-        'Optional: Filter registrations by a list of tags (API filter only).'
-      ),
-  });
-
-  private hcsClient: HCS10Client;
-  private logger: Logger;
-
-  constructor({ hcsClient, ...rest }: FindRegistrationsToolParams) {
-    super(rest);
-    this.hcsClient = hcsClient;
-    this.logger = Logger.getInstance({ module: 'FindRegistrationsTool' });
-  }
-
-  protected async _call({
-    accountId,
-    tags,
-  }: z.infer<this['schema']>): Promise<string> {
-    this.logger.info(
-      'Searching registrations with filters - Account ID',
-      JSON.stringify({
-        accountId,
-        tags,
-      })
-    );
-
-    const options: RegistrationSearchOptions = {};
-    if (accountId) {
-      options.accountId = accountId;
-    }
-    if (tags && tags.length > 0) {
-      options.tags = tags;
-    }
-    options.network = this.hcsClient.getNetwork();
-
-    try {
-      if (!this.hcsClient.standardClient) {
-        throw new Error(
-          'Standard SDK client instance is not available in HCS10Client wrapper.'
-        );
-      }
-      const result = await this.hcsClient.standardClient.findRegistrations(
-        options
-      );
-
-      if (!result.success || result.error) {
-        return `Error finding registrations: ${
-          result.error || 'Unknown error'
-        }`;
-      }
-
-      if (!result.registrations || result.registrations.length === 0) {
-        return 'No registrations found matching the criteria.';
-      }
-
-      // Format the results based on available data from RegistrationSearchResult
-      let output = `Found ${result.registrations.length} registration(s):\n`;
-      result.registrations.forEach((reg, index: number) => {
-        const metadata = reg.metadata;
-        output += `${index + 1}. Name: ${metadata.alias || 'N/A'}\n`;
-        output += `Description: ${metadata.bio || 'N/A'}\n`;
-        output += `   Account ID: ${reg.accountId}\n`;
-        output += `   Status: ${reg.status}\n`;
-        output += `   Model: ${metadata.properties?.model || 'N/A'}\n`;
-        if (metadata.properties?.capabilities && metadata.properties.capabilities.length > 0) {
-          output += `   Capabilities: ${metadata.properties.capabilities.join(', ')}\n`;
-        }
-        if (metadata.properties) {
-          output += `   Properties: ${JSON.stringify(metadata.properties)}\n`;
-        }
-        output += `   Inbound Topic: ${reg.inboundTopicId}\n`;
-        output += `   Outbound Topic: ${reg.outboundTopicId}\n`;
-        output += `   Created At: ${reg.createdAt}\n`;
-      });
-
-      return output.trim();
-    } catch (error) {
-      this.logger.error(`Failed to execute findRegistrations: ${error}`);
-      return `Error searching registrations: ${
-        error instanceof Error ? error.message : String(error)
-      }`;
-    }
-  }
-}

package/src/tools/InitiateConnectionTool.ts

@@ -1,137 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager, ActiveConnection } from '../state/state-types';
-import { Logger } from '@hashgraphonline/standards-sdk';
-
-export interface InitiateConnectionToolParams extends ToolParams {
-  hcsClient: HCS10Client;
-  stateManager: IStateManager;
-}
-
-/**
- * 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, waits for confirmation, and stores the connection using the provided stateManager.
- * Use this tool ONLY to actively INITIATE an OUTGOING connection.
- */
-export class InitiateConnectionTool extends StructuredTool {
-  name = 'initiate_connection';
-  description =
-    'Actively STARTS a NEW HCS-10 connection TO a specific target agent identified by their account ID. Requires the targetAccountId parameter. Use this ONLY to INITIATE an OUTGOING connection request.';
-  schema = z.object({
-    targetAccountId: z
-      .string()
-      .describe(
-        'The Hedera account ID (e.g., 0.0.12345) of the agent you want to connect with.'
-      )
-  });
-
-  private hcsClient: HCS10Client;
-  private stateManager: IStateManager;
-  private logger: Logger;
-
-  constructor({
-    hcsClient,
-    stateManager,
-    ...rest
-  }: InitiateConnectionToolParams) {
-    super(rest);
-    this.hcsClient = hcsClient;
-    this.stateManager = stateManager;
-    this.logger = Logger.getInstance({ module: 'InitiateConnectionTool' });
-  }
-
-  protected async _call({
-    targetAccountId
-  }: z.infer<this['schema']>): Promise<string> {
-    const currentAgent = this.stateManager.getCurrentAgent();
-    if (!currentAgent) {
-      return 'Error: Cannot initiate connection. No agent is currently active. Please register or select an agent first.';
-    }
-
-    this.logger.info(
-      `Attempting connection from ${currentAgent.accountId} to ${targetAccountId}`
-    );
-
-    try {
-      this.logger.debug(`Retrieving profile for ${targetAccountId}...`);
-      const targetProfile = await this.hcsClient.getAgentProfile(
-        targetAccountId
-      );
-      if (!targetProfile?.topicInfo?.inboundTopic) {
-        return `Error: Could not retrieve profile or find inbound topic ID for target agent ${targetAccountId}. They might not be registered or have a public profile.`;
-      }
-      const targetInboundTopicId = targetProfile.topicInfo.inboundTopic;
-      const targetAgentName =
-        targetProfile.profile.name || `Agent ${targetAccountId}`;
-
-      const requestResult = await this.hcsClient.submitConnectionRequest(
-        targetInboundTopicId,
-        currentAgent.name
-      );
-      const sequenceNumberLong = requestResult?.topicSequenceNumber;
-      if (!sequenceNumberLong) {
-        throw new Error('Connection request sequence number not found.');
-      }
-      
-      let connectionRequestId: number;
-      try {
-        connectionRequestId = sequenceNumberLong.toNumber();
-        if (isNaN(connectionRequestId)) {
-          throw new Error('Converted sequence number is NaN.');
-        }
-      } catch (conversionError) {
-        throw new Error(
-          `Failed to convert connection request sequence number: ${conversionError}`
-        );
-      }
-
-      const confirmationTimeoutMs = 60000;
-      const delayMs = 2000;
-      const maxAttempts = Math.ceil(confirmationTimeoutMs / delayMs);
-
-      const confirmationResult =
-        await this.hcsClient.waitForConnectionConfirmation(
-          targetInboundTopicId,
-          connectionRequestId,
-          maxAttempts,
-          delayMs
-        );
-
-      if (!confirmationResult?.connectionTopicId) {
-        return `Error: Connection confirmation not received from ${targetAccountId} (for request ${connectionRequestId}) within ${
-          confirmationTimeoutMs / 1000
-        } seconds.`;
-      }
-
-      const connectionTopicId = confirmationResult.connectionTopicId;
-      this.logger.info(`Connection confirmed! Topic ID: ${connectionTopicId}`);
-
-      const newConnection: ActiveConnection = {
-        targetAccountId: targetAccountId,
-        targetAgentName: targetAgentName,
-        targetInboundTopicId: targetInboundTopicId,
-        connectionTopicId: connectionTopicId,
-      };
-      this.stateManager.addActiveConnection(newConnection);
-
-      const connections = this.stateManager.listConnections();
-      const addedEntry = connections.find(
-        (c) => c.connectionTopicId === connectionTopicId
-      );
-      const localConnectionId = addedEntry
-        ? connections.indexOf(addedEntry) + 1
-        : null;
-
-      const idString = localConnectionId ? `#${localConnectionId}` : '';
-
-      return `Successfully established connection ${idString} with ${targetAgentName} (${targetAccountId}). Connection Topic: ${connectionTopicId}. You can now send messages using this connection.`;
-    } catch (error) {
-      this.logger.error(`Connection initiation failed: ${error}`);
-      return `Error initiating connection with ${targetAccountId}: ${
-        error instanceof Error ? error.message : String(error)
-      }`;
-    }
-  }
-}

package/src/tools/ListConnectionsTool.ts

@@ -1,158 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { IStateManager, ActiveConnection } from '../state/state-types';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { Connection, Logger } from '@hashgraphonline/standards-sdk';
-
-export interface ListConnectionsToolParams extends ToolParams {
-  stateManager: IStateManager;
-  hcsClient?: HCS10Client;
-}
-
-/**
- * A tool to list currently active HCS-10 connections stored in the state manager.
- * Enhanced to show more details similar to moonscape's implementation.
- */
-export class ListConnectionsTool extends StructuredTool {
-  name = 'list_connections';
-  description =
-    'Lists the currently active HCS-10 connections with detailed information. Shows connection status, agent details, and recent activity. Use this to get a comprehensive view of all active connections.';
-  schema = z.object({
-    includeDetails: z
-      .boolean()
-      .optional()
-      .describe(
-        'Whether to include detailed information about each connection'
-      ),
-    showPending: z
-      .boolean()
-      .optional()
-      .describe('Whether to include pending connection requests'),
-  });
-
-  private stateManager: IStateManager;
-  private hcsClient?: HCS10Client;
-  private logger: Logger;
-
-  constructor({ stateManager, hcsClient, ...rest }: ListConnectionsToolParams) {
-    super(rest);
-    this.stateManager = stateManager;
-    this.hcsClient = hcsClient;
-    this.logger = new Logger({ module: 'ListConnectionsTool' });
-  }
-
-  protected async _call(args: z.infer<this['schema']>): Promise<string> {
-    const includeDetails = args.includeDetails ?? true;
-    const showPending = args.showPending ?? true;
-
-    const connections = await this.getEnhancedConnections();
-
-    if (connections.length === 0) {
-      return 'There are currently no active connections.';
-    }
-
-    const activeConnections = connections.filter(
-      (c) => c.status === 'established'
-    );
-
-    const pendingConnections = connections.filter((c) => c.isPending);
-
-    const needsConfirmation = connections.filter((c) => c.needsConfirmation);
-
-    let output = '';
-
-    if (activeConnections.length > 0) {
-      output += `🟢 Active Connections (${activeConnections.length}):\n`;
-      activeConnections.forEach((conn, index) => {
-        output += this.formatConnection(conn, index, includeDetails);
-      });
-      output += '\n';
-    }
-
-    if (showPending && needsConfirmation.length > 0) {
-      output += `🟠 Connections Needing Confirmation (${needsConfirmation.length}):\n`;
-      needsConfirmation.forEach((conn, index) => {
-        output += this.formatConnection(conn, index, includeDetails);
-      });
-      output += '\n';
-    }
-
-    if (showPending && pendingConnections.length > 0) {
-      output += `⚪ Pending Connection Requests (${pendingConnections.length}):\n`;
-      pendingConnections.forEach((conn, index) => {
-        output += this.formatConnection(conn, index, includeDetails);
-      });
-    }
-
-    return output.trim();
-  }
-
-  private formatConnection(
-    conn: Connection,
-    index: number,
-    includeDetails: boolean
-  ): string {
-    let output = `${index + 1}. ${
-      conn.profileInfo?.display_name || conn.targetAgentName || 'Unknown Agent'
-    } (${conn.targetAccountId})\n`;
-    const displayTopicId = conn.isPending
-      ? '(Pending Request)'
-      : conn.connectionTopicId;
-    output += `   Topic: ${displayTopicId}\n`;
-    const statusText = conn.status || 'unknown';
-    output += `   Status: ${statusText}\n`;
-
-    if (includeDetails) {
-      if (conn.profileInfo?.bio) {
-        output += `   Bio: ${conn.profileInfo.bio.substring(0, 100)}${
-          conn.profileInfo.bio.length > 100 ? '...' : ''
-        }\n`;
-      }
-
-      if (conn.created) {
-        const createdLabel = conn.isPending
-          ? 'Request sent'
-          : 'Connection established';
-        output += `   ${createdLabel}: ${conn.created.toLocaleString()}\n`;
-      }
-
-      if (conn.lastActivity) {
-        output += `   Last activity: ${conn.lastActivity.toLocaleString()}\n`;
-      }
-    }
-
-    return output;
-  }
-
-  private async getEnhancedConnections(): Promise<Connection[]> {
-    if (!this.hcsClient) {
-      return this.stateManager.listConnections() as Connection[];
-    }
-
-    try {
-      const { accountId } = this.hcsClient.getAccountAndSigner();
-      if (!accountId) {
-        return this.stateManager.listConnections() as Connection[];
-      }
-
-      const connectionManager = this.stateManager.getConnectionsManager();
-      if (!connectionManager) {
-        this.logger.error('ConnectionsManager not initialized');
-        return this.stateManager.listConnections() as Connection[];
-      }
-
-      const connections = await connectionManager.fetchConnectionData(
-        accountId
-      );
-
-      for (const connection of connections) {
-        this.stateManager.updateOrAddConnection(connection as ActiveConnection);
-      }
-
-      return connections;
-    } catch (error) {
-      console.error('Error fetching connection data:', error);
-      return this.stateManager.listConnections() as Connection[];
-    }
-  }
-}