@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

package/src/builders/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './hcs10/hcs10-builder';

package/src/builders/types.ts

@@ -0,0 +1,11 @@
+import { TransactionReceipt } from '@hashgraph/sdk';
+
+export interface ExecuteResult {
+  success: boolean;
+  receipt?: TransactionReceipt;
+  scheduleId?: string;
+  error?: string;
+  transactionId?: string | undefined;
+  rawResult?: unknown;
+  notes?: string[];
+}

package/src/hcs10/HCS10Client.ts

@@ -313,7 +313,7 @@ export class HCS10Client {
         (a: { timestamp: number }, b: { timestamp: number }) =>
           a.timestamp - b.timestamp
       );
-      return { messages: mappedMessages };
+      return { messages: mappedMessages as HCSMessageWithTimestamp[] };
     } catch (error) {
       this.logger.error(`Error getting messages from topic ${topicId}:`, error);
       return { messages: [] };
@@ -323,7 +323,8 @@ export class HCS10Client {
   public async getMessageStream(topicId: string): Promise<{
     messages: HCSMessage[];
   }> {
-    return this.standardClient.getMessageStream(topicId);
+    const result = this.standardClient.getMessageStream(topicId);
+    return result as Promise<{ messages: HCSMessage[] }>;
   }
 
   /**

package/src/index.ts

@@ -1,5 +1,7 @@
-export * from './hcs10';
 export * from './tools';
 export * from './state';
 export * from './init';
-export * from './plugins';
+export * from './plugins';
+export { HCS10Builder } from './builders';
+export type { ExecuteResult } from './builders';
+export { HCS10Client } from './hcs10';

package/src/init/init.ts

@@ -1,26 +1,25 @@
-import { HCS10Client, StandardNetworkType } from '../hcs10/HCS10Client';
-import { RegisterAgentTool } from '../tools/RegisterAgentTool';
-import { SendMessageTool } from '../tools/SendMessageTool';
-import { ConnectionTool } from '../tools/ConnectionTool';
+import { HederaAgentKit, ServerSigner } from 'hedera-agent-kit';
+import { HCS10Builder } from '../builders/hcs10/hcs10-builder';
+import { RegisterAgentTool } from '../tools/hcs10/RegisterAgentTool';
+import { FindRegistrationsTool } from '../tools/hcs10/FindRegistrationsTool';
+import { InitiateConnectionTool } from '../tools/hcs10/InitiateConnectionTool';
+import { ListConnectionsTool } from '../tools/hcs10/ListConnectionsTool';
+import { SendMessageToConnectionTool } from '../tools/hcs10/SendMessageToConnectionTool';
+import { CheckMessagesTool } from '../tools/hcs10/CheckMessagesTool';
+import { ConnectionMonitorTool } from '../tools/hcs10/ConnectionMonitorTool';
+import { ManageConnectionRequestsTool } from '../tools/hcs10/ManageConnectionRequestsTool';
+import { AcceptConnectionRequestTool } from '../tools/hcs10/AcceptConnectionRequestTool';
+import { RetrieveProfileTool } from '../tools/hcs10/RetrieveProfileTool';
+import { ListUnapprovedConnectionRequestsTool } from '../tools/hcs10/ListUnapprovedConnectionRequestsTool';
 import { IStateManager } from '../state/state-types';
 import { OpenConvaiState } from '../state/open-convai-state';
-import { FindRegistrationsTool } from '../tools/FindRegistrationsTool';
-import { InitiateConnectionTool } from '../tools/InitiateConnectionTool';
-import { ListConnectionsTool } from '../tools/ListConnectionsTool';
-import { SendMessageToConnectionTool } from '../tools/SendMessageToConnectionTool';
-import { CheckMessagesTool } from '../tools/CheckMessagesTool';
-import { ConnectionMonitorTool } from '../tools/ConnectionMonitorTool';
-import { ManageConnectionRequestsTool } from '../tools/ManageConnectionRequestsTool';
-import { AcceptConnectionRequestTool } from '../tools/AcceptConnectionRequestTool';
-import { RetrieveProfileTool } from '../tools/RetrieveProfileTool';
-import { ListUnapprovedConnectionRequestsTool } from '../tools/ListUnapprovedConnectionRequestsTool';
 import { Logger } from '@hashgraphonline/standards-sdk';
 import { ENV_FILE_PATH } from '../utils/state-tools';
 
 export interface HCS10ClientConfig {
   operatorId?: string;
   operatorKey?: string;
-  network?: StandardNetworkType;
+  network?: 'mainnet' | 'testnet';
   useEncryption?: boolean;
   registryUrl?: string;
   logLevel?: 'debug' | 'info' | 'warn' | 'error';
@@ -44,8 +43,6 @@ export interface HCS10Tools {
   listConnectionsTool: ListConnectionsTool;
   sendMessageToConnectionTool: SendMessageToConnectionTool;
   checkMessagesTool: CheckMessagesTool;
-  sendMessageTool: SendMessageTool;
-  connectionTool: ConnectionTool;
   connectionMonitorTool: ConnectionMonitorTool;
   manageConnectionRequestsTool: ManageConnectionRequestsTool;
   acceptConnectionRequestTool: AcceptConnectionRequestTool;
@@ -56,16 +53,18 @@ export interface HCS10Tools {
  * Initializes the HCS10 client and returns pre-registered LangChain tools.
  *
  * @param options - Initialization options
- * @returns Object containing hcs10Client and requested tools
+ * @returns Object containing hederaKit, hcs10Builder and requested tools
  */
-export const initializeStandardsAgentKit = (
+export const initializeStandardsAgentKit = async (
   options?: HCS10InitializationOptions
-): {
-  hcs10Client: HCS10Client;
-  monitoringClient?: HCS10Client;
+): Promise<{
+  hederaKit: HederaAgentKit;
+  hcs10Builder: HCS10Builder;
+  monitoringHederaKit?: HederaAgentKit;
+  monitoringHcs10Builder?: HCS10Builder;
   tools: Partial<HCS10Tools>;
   stateManager: IStateManager;
-} => {
+}> => {
   const config = options?.clientConfig || {};
 
   const operatorId = config.operatorId || process.env.HEDERA_OPERATOR_ID;
@@ -74,7 +73,7 @@ export const initializeStandardsAgentKit = (
 
   const networkEnv = config.network || process.env.HEDERA_NETWORK || 'testnet';
 
-  let network: StandardNetworkType;
+  let network: 'mainnet' | 'testnet';
   if (networkEnv === 'mainnet') {
     network = 'mainnet';
   } else if (networkEnv === 'testnet') {
@@ -106,82 +105,105 @@ export const initializeStandardsAgentKit = (
     });
   logger.info('State manager initialized');
 
-  const hcs10Client = new HCS10Client(operatorId, operatorPrivateKey, network, {
+  // Create HederaAgentKit
+  const signer = new ServerSigner(operatorId, operatorPrivateKey, network);
+  const hederaKit = new HederaAgentKit(signer);
+  await hederaKit.initialize();
+  logger.info(`HederaAgentKit initialized for ${operatorId} on ${network}`);
+
+  // Create HCS10Builder
+  const hcs10Builder = new HCS10Builder(hederaKit, stateManager, {
     useEncryption: config.useEncryption,
     registryUrl: config.registryUrl,
+    logLevel: config.logLevel,
   });
-  logger.info(`HCS10Client initialized for ${operatorId} on ${network}`);
 
-  let monitoringClient: HCS10Client | undefined;
+  let monitoringHederaKit: HederaAgentKit | undefined;
+  let monitoringHcs10Builder: HCS10Builder | undefined;
+
   if (options?.monitoringClient) {
-    monitoringClient = new HCS10Client(
-      operatorId,
-      operatorPrivateKey,
-      network,
-      {
-        useEncryption: config.useEncryption,
-        registryUrl: config.registryUrl,
-        logLevel: 'error',
-      }
-    );
+    const monitoringSigner = new ServerSigner(operatorId, operatorPrivateKey, network);
+    monitoringHederaKit = new HederaAgentKit(monitoringSigner);
+    await monitoringHederaKit.initialize();
+    monitoringHcs10Builder = new HCS10Builder(monitoringHederaKit, stateManager, {
+      useEncryption: config.useEncryption,
+      registryUrl: config.registryUrl,
+      logLevel: 'error',
+    });
     logger.info('Monitoring client initialized');
   }
 
   const tools: Partial<HCS10Tools> = {};
 
-  tools.registerAgentTool = new RegisterAgentTool(hcs10Client, stateManager);
-  tools.sendMessageTool = new SendMessageTool(hcs10Client);
-  tools.connectionTool = new ConnectionTool({
-    client: monitoringClient || hcs10Client,
-    stateManager,
+  // Always create RegisterAgentTool
+  tools.registerAgentTool = new RegisterAgentTool({
+    hederaKit,
+    hcs10Builder,
+    logger: undefined,
   });
 
   if (options?.createAllTools) {
     tools.findRegistrationsTool = new FindRegistrationsTool({
-      hcsClient: hcs10Client,
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
+    });
+    tools.retrieveProfileTool = new RetrieveProfileTool({
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
     });
-    tools.retrieveProfileTool = new RetrieveProfileTool(hcs10Client);
     tools.initiateConnectionTool = new InitiateConnectionTool({
-      hcsClient: hcs10Client,
-      stateManager,
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
     });
     tools.listConnectionsTool = new ListConnectionsTool({
-      hcsClient: hcs10Client,
-      stateManager,
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
     });
     tools.sendMessageToConnectionTool = new SendMessageToConnectionTool({
-      hcsClient: hcs10Client,
-      stateManager,
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
     });
     tools.checkMessagesTool = new CheckMessagesTool({
-      hcsClient: hcs10Client,
-      stateManager,
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
     });
     tools.connectionMonitorTool = new ConnectionMonitorTool({
-      hcsClient: monitoringClient || hcs10Client,
-      stateManager,
+      hederaKit: monitoringHederaKit || hederaKit,
+      hcs10Builder: monitoringHcs10Builder || hcs10Builder,
+      logger: undefined,
     });
     tools.manageConnectionRequestsTool = new ManageConnectionRequestsTool({
-      hcsClient: hcs10Client,
-      stateManager,
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
     });
     tools.acceptConnectionRequestTool = new AcceptConnectionRequestTool({
-      hcsClient: hcs10Client,
-      stateManager,
+      hederaKit,
+      hcs10Builder,
+      logger: undefined,
     });
     tools.listUnapprovedConnectionRequestsTool =
       new ListUnapprovedConnectionRequestsTool({
-        stateManager,
-        hcsClient: hcs10Client,
+        hederaKit,
+        hcs10Builder,
+        logger: undefined,
       });
 
     logger.info('All tools initialized');
   }
 
   return {
-    hcs10Client,
-    monitoringClient,
+    hederaKit,
+    hcs10Builder,
+    monitoringHederaKit,
+    monitoringHcs10Builder,
     tools,
     stateManager,
   };
-};
+};

package/src/plugins/PluginInterface.ts

@@ -1,56 +1,24 @@
-import { StructuredTool } from '@langchain/core/tools';
+// Re-export plugin interfaces from hedera-agent-kit for consistency
+export { BasePlugin } from 'hedera-agent-kit';
+export type {
+  IPlugin,
+  BasePluginContext,
+  GenericPluginContext,
+  PluginContext,
+  IPluginClient,
+  IPluginStateManager,
+  HederaTool,
+} from 'hedera-agent-kit';
+
+// Extended context for HCS10-specific functionality
 import { HCS10Client } from '../hcs10/HCS10Client';
 import { IStateManager } from '../state/state-types';
-import { Logger } from '@hashgraphonline/standards-sdk';
-
-/**
- * Basic client interface required by plugins
- */
-export interface IPluginClient {
-  getNetwork(): string;
-}
-
-/**
- * Basic state manager interface required by plugins
- */
-export interface IPluginStateManager {
-  getCurrentAgent?(): unknown;
-}
-
-/**
- * Base context provided to all plugins during initialization
- */
-export interface BasePluginContext {
-  /**
-   * Logger instance
-   */
-  logger: Logger;
-
-  /**
-   * Configuration options
-   */
-  config: Record<string, unknown>;
-}
-
-/**
- * Context provided to platform-agnostic plugins during initialization
- */
-export interface GenericPluginContext extends BasePluginContext {
-  /**
-   * Generic client interface
-   */
-  client: IPluginClient;
-
-  /**
-   * Optional generic state manager
-   */
-  stateManager?: IPluginStateManager;
-}
+import { BasePluginContext } from 'hedera-agent-kit';
 
 /**
  * Context provided to HCS10-specific plugins during initialization
  */
-export interface PluginContext extends BasePluginContext {
+export interface HCS10PluginContext extends BasePluginContext {
   /**
    * The HCS10Client instance
    */
@@ -61,50 +29,3 @@ export interface PluginContext extends BasePluginContext {
    */
   stateManager?: IStateManager;
 }
-
-/**
- * Standard interface that all plugins must implement
- */
-export interface IPlugin<T extends BasePluginContext = BasePluginContext> {
-  /**
-   * Unique identifier for the plugin
-   */
-  id: string;
-
-  /**
-   * Human-readable name of the plugin
-   */
-  name: string;
-
-  /**
-   * Description of what the plugin does
-   */
-  description: string;
-
-  /**
-   * Version of the plugin
-   */
-  version: string;
-
-  /**
-   * Author of the plugin
-   */
-  author: string;
-
-  /**
-   * Initialize the plugin with the provided context
-   * @param context The context containing shared resources
-   */
-  initialize(context: T): Promise<void>;
-
-  /**
-   * Get the tools provided by this plugin
-   * @returns Array of tools provided by this plugin
-   */
-  getTools(): StructuredTool[];
-
-  /**
-   * Clean up resources when the plugin is unloaded
-   */
-  cleanup?(): Promise<void>;
-}

package/src/plugins/PluginRegistry.ts

@@ -1,98 +1,2 @@
-import { IPlugin, PluginContext } from './PluginInterface';
-import { StructuredTool } from '@langchain/core/tools';
-import { Logger } from '@hashgraphonline/standards-sdk';
-
-/**
- * Registry for managing plugins in the Standards Agent Kit
- */
-export class PluginRegistry {
-  private plugins: Map<string, IPlugin> = new Map();
-  private context: PluginContext;
-  private logger: Logger;
-  
-  /**
-   * Creates a new PluginRegistry instance
-   * @param context The context to provide to plugins during initialization
-   */
-  constructor(context: PluginContext) {
-    this.context = context;
-    this.logger = context.logger;
-  }
-  
-  /**
-   * Register a plugin with the registry
-   * @param plugin The plugin to register
-   * @throws Error if a plugin with the same ID is already registered
-   */
-  async registerPlugin(plugin: IPlugin): Promise<void> {
-    if (this.plugins.has(plugin.id)) {
-      throw new Error(`Plugin with ID ${plugin.id} is already registered`);
-    }
-    
-    await plugin.initialize(this.context);
-    this.plugins.set(plugin.id, plugin);
-    this.logger.info(`Plugin registered: ${plugin.name} (${plugin.id}) v${plugin.version}`);
-  }
-  
-  /**
-   * Get a plugin by ID
-   * @param id The ID of the plugin to retrieve
-   * @returns The plugin, or undefined if not found
-   */
-  getPlugin(id: string): IPlugin | undefined {
-    return this.plugins.get(id);
-  }
-  
-  /**
-   * Get all registered plugins
-   * @returns Array of all registered plugins
-   */
-  getAllPlugins(): IPlugin[] {
-    return Array.from(this.plugins.values());
-  }
-  
-  /**
-   * Get all tools from all registered plugins
-   * @returns Array of all tools provided by registered plugins
-   */
-  getAllTools(): StructuredTool[] {
-    return this.getAllPlugins().flatMap(plugin => plugin.getTools());
-  }
-  
-  /**
-   * Unregister a plugin
-   * @param id The ID of the plugin to unregister
-   * @returns true if the plugin was unregistered, false if it wasn't found
-   */
-  async unregisterPlugin(id: string): Promise<boolean> {
-    const plugin = this.plugins.get(id);
-    if (!plugin) {
-      return false;
-    }
-    
-    if (plugin.cleanup) {
-      try {
-        await plugin.cleanup();
-      } catch (error) {
-        this.logger.error(`Error during plugin cleanup: ${error}`);
-      }
-    }
-    
-    const result = this.plugins.delete(id);
-    if (result) {
-      this.logger.info(`Plugin unregistered: ${plugin.name} (${plugin.id})`);
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Unregister all plugins
-   */
-  async unregisterAllPlugins(): Promise<void> {
-    const pluginIds = Array.from(this.plugins.keys());
-    for (const id of pluginIds) {
-      await this.unregisterPlugin(id);
-    }
-  }
-}
+// Re-export PluginRegistry from hedera-agent-kit
+export { PluginRegistry } from 'hedera-agent-kit';

package/src/plugins/defi/index.ts

@@ -1,129 +1,42 @@
-import { HCS10Plugin } from '../../../src/plugins/HCS10Plugin';
-import { StructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import axios from 'axios';
-import { HCS10Client } from '../../../src/hcs10/HCS10Client';
-
-/**
- * Tool for getting token price information using CoinGecko
- */
-class GetTokenPriceTool extends StructuredTool {
-  name = 'get_token_price';
-  description = 'Get the current price of a token on Hedera';
-  
-  schema = z.object({
-    tokenId: z.string().describe('The Hedera token ID (e.g., 0.0.12345)'),
-  });
-  
-  constructor(private client: HCS10Client) {
-    super();
-  }
-  
-  async _call(input: z.infer<typeof this.schema>): Promise<string> {
-    try {
-      // In a real implementation, this would map Hedera token IDs to CoinGecko IDs
-      // This is a simplified mock implementation
-      const mockCoinGeckoIds: Record<string, string> = {
-        '0.0.1234': 'hbar',
-        '0.0.5678': 'ethereum',
-        '0.0.9012': 'bitcoin',
-      };
-      
-      const coinGeckoId = mockCoinGeckoIds[input.tokenId] || 'hbar';
-      
-      // Use CoinGecko's public API (no API key required)
-      const response = await axios.get(`https://api.coingecko.com/api/v3/simple/price?ids=${coinGeckoId}&vs_currencies=usd`);
-      
-      const price = response.data[coinGeckoId]?.usd || 0;
-      
-      return `Current price of token ${input.tokenId}: $${price.toFixed(4)} USD`;
-    } catch (error) {
-      return `Error fetching token price: ${error instanceof Error ? error.message : String(error)}`;
-    }
-  }
-}
-
-/**
- * Tool for swapping tokens
- */
-class SwapTokensTool extends StructuredTool {
-  name = 'swap_tokens';
-  description = 'Swap one token for another on Hedera';
-  
-  schema = z.object({
-    fromTokenId: z.string().describe('The ID of the token to swap from (e.g., 0.0.12345)'),
-    toTokenId: z.string().describe('The ID of the token to swap to (e.g., 0.0.67890)'),
-    amount: z.number().positive().describe('The amount of the source token to swap'),
-  });
-  
-  constructor(private client: HCS10Client) {
-    super();
-  }
-  
-  async _call(input: z.infer<typeof this.schema>): Promise<string> {
-    try {
-      // In a real implementation, this would interact with a DEX contract
-      // This is a simplified mock implementation
-      const { accountId } = this.client.getAccountAndSigner();
-      
-      // Mock exchange rate
-      const exchangeRate = Math.random() * 2;
-      const receivedAmount = input.amount * exchangeRate;
-      
-      return `Simulated swap of ${input.amount} tokens (${input.fromTokenId}) for ${receivedAmount.toFixed(4)} tokens (${input.toTokenId}).\n\nNote: This is a mock implementation. In a real implementation, this would execute the swap through a DEX on Hedera.`;
-    } catch (error) {
-      return `Error performing token swap: ${error instanceof Error ? error.message : String(error)}`;
-    }
-  }
-}
-
-/**
- * Tool for checking token balance
- */
-class CheckTokenBalanceTool extends StructuredTool {
-  name = 'check_token_balance';
-  description = 'Check the balance of a token for an account on Hedera';
-  
-  schema = z.object({
-    tokenId: z.string().describe('The Hedera token ID (e.g., 0.0.12345)'),
-    accountId: z.string().optional().describe('The account ID to check (defaults to the operator account)'),
-  });
-  
-  constructor(private client: HCS10Client) {
-    super();
-  }
-  
-  async _call(input: z.infer<typeof this.schema>): Promise<string> {
-    try {
-      const { accountId: operatorId } = this.client.getAccountAndSigner();
-      const accountToCheck = input.accountId || operatorId;
-      
-      // In a real implementation, this would query the account's token balance
-      // This is a simplified mock implementation
-      const mockBalance = Math.floor(Math.random() * 10000);
-      
-      return `Token balance for account ${accountToCheck}:\n${mockBalance} tokens of ${input.tokenId}\n\nNote: This is a mock implementation. In a real implementation, this would query the actual token balance from the Hedera network.`;
-    } catch (error) {
-      return `Error checking token balance: ${error instanceof Error ? error.message : String(error)}`;
-    }
-  }
-}
+import { BasePlugin, GenericPluginContext, HederaTool, HederaAgentKit } from 'hedera-agent-kit';
+import {
+  HederaGetTokenInfoTool,
+  HederaTransferTokensTool,
+  HederaGetAccountTokensTool,
+  HederaAssociateTokensTool
+} from 'hedera-agent-kit';
 
 /**
  * DeFi Integration Plugin for the Standards Agent Kit
+ * Uses built-in Hedera token tools from hedera-agent-kit
  */
-export default class DeFiPlugin extends HCS10Plugin {
+export default class DeFiPlugin extends BasePlugin<GenericPluginContext> {
   id = 'defi-integration';
   name = 'DeFi Integration Plugin';
-  description = 'Provides tools to interact with DeFi protocols on Hedera';
+  description = 'Provides tools to interact with DeFi protocols on Hedera using built-in Hedera tools';
   version = '1.0.0';
   author = 'Hashgraph Online';
-  
-  getTools(): StructuredTool[] {
-    return [
-      new GetTokenPriceTool(this.context.client),
-      new SwapTokensTool(this.context.client),
-      new CheckTokenBalanceTool(this.context.client)
+
+  private tools: HederaTool[] = [];
+
+  override async initialize(context: GenericPluginContext): Promise<void> {
+    await super.initialize(context);
+    this.initializeTools();
+  }
+
+  private initializeTools(): void {
+    const hederaKit = this.context.config.hederaKit as HederaAgentKit;
+    const logger = this.context.logger;
+
+    this.tools = [
+      new HederaGetTokenInfoTool({ hederaKit, logger }),
+      new HederaTransferTokensTool({ hederaKit, logger }),
+      new HederaGetAccountTokensTool({ hederaKit, logger }),
+      new HederaAssociateTokensTool({ hederaKit, logger })
     ];
   }
+
+  getTools(): HederaTool[] {
+    return this.tools;
+  }
 }