@hashgraphonline/standards-agent-kit 0.0.38 → 0.2.1

package/dist/cjs/tools/hcs10/RetrieveProfileTool.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { BaseHCS10QueryTool } from './base-hcs10-tools';
+import { HCS10QueryToolParams } from './hcs10-tool-params';
+declare const RetrieveProfileZodSchema: z.ZodObject<{
+    accountId: z.ZodString;
+    disableCache: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    accountId: string;
+    disableCache?: boolean | undefined;
+}, {
+    accountId: string;
+    disableCache?: boolean | undefined;
+}>;
+/**
+ * Tool to retrieve detailed profile information for a specific HCS-10 agent
+ */
+export declare class RetrieveProfileTool extends BaseHCS10QueryTool<typeof RetrieveProfileZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        accountId: z.ZodString;
+        disableCache: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        accountId: string;
+        disableCache?: boolean | undefined;
+    }, {
+        accountId: string;
+        disableCache?: boolean | undefined;
+    }>;
+    constructor(params: HCS10QueryToolParams);
+    protected executeQuery({ accountId, disableCache, }: z.infer<typeof RetrieveProfileZodSchema>): Promise<unknown>;
+}
+export {};

package/dist/cjs/tools/hcs10/SendMessageToConnectionTool.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 SendMessageToConnectionZodSchema: z.ZodObject<{
+    targetIdentifier: z.ZodString;
+    message: z.ZodString;
+    disableMonitoring: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    targetIdentifier: string;
+    disableMonitoring: boolean;
+}, {
+    message: string;
+    targetIdentifier: string;
+    disableMonitoring?: boolean | undefined;
+}>;
+/**
+ * A tool to send a message to an agent over an established HCS-10 connection.
+ */
+export declare class SendMessageToConnectionTool extends BaseHCS10TransactionTool<typeof SendMessageToConnectionZodSchema> {
+    name: string;
+    description: string;
+    specificInputSchema: z.ZodObject<{
+        targetIdentifier: z.ZodString;
+        message: z.ZodString;
+        disableMonitoring: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        targetIdentifier: string;
+        disableMonitoring: boolean;
+    }, {
+        message: string;
+        targetIdentifier: string;
+        disableMonitoring?: boolean | undefined;
+    }>;
+    constructor(params: HCS10TransactionToolParams);
+    protected callBuilderMethod(builder: BaseServiceBuilder, specificArgs: z.infer<typeof SendMessageToConnectionZodSchema>): Promise<void>;
+}
+export {};

package/dist/cjs/tools/hcs10/base-hcs10-tools.d.ts

@@ -0,0 +1,28 @@
+import { BaseHederaTransactionTool, BaseHederaQueryTool, BaseServiceBuilder } from 'hedera-agent-kit';
+import { HCS10Builder } from '../../builders/hcs10/hcs10-builder';
+import { HCS10TransactionToolParams, HCS10QueryToolParams } from './hcs10-tool-params';
+import { z } from 'zod';
+/**
+ * Base class for HCS10 transaction tools
+ */
+export declare abstract class BaseHCS10TransactionTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny> = z.ZodObject<z.ZodRawShape>> extends BaseHederaTransactionTool<T> {
+    protected hcs10Builder: HCS10Builder;
+    namespace: "hcs10";
+    constructor(params: HCS10TransactionToolParams);
+    /**
+     * Override to return the HCS10Builder
+     */
+    protected getServiceBuilder(): BaseServiceBuilder;
+}
+/**
+ * Base class for HCS10 query tools
+ */
+export declare abstract class BaseHCS10QueryTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, Record<string, unknown>, Record<string, unknown>> = z.ZodObject<z.ZodRawShape>> extends BaseHederaQueryTool<T> {
+    protected hcs10Builder: HCS10Builder;
+    namespace: "hcs10";
+    constructor(params: HCS10QueryToolParams);
+    /**
+     * Override to return the HCS10Builder
+     */
+    protected getServiceBuilder(): BaseServiceBuilder;
+}

package/dist/cjs/tools/hcs10/hcs10-tool-params.d.ts

@@ -0,0 +1,18 @@
+import { HederaAgentKit, BasePluginContext } from 'hedera-agent-kit';
+import { HCS10Builder } from '../../builders/hcs10/hcs10-builder';
+/**
+ * Parameters for HCS10 transaction tools
+ */
+export interface HCS10TransactionToolParams {
+    hederaKit: HederaAgentKit;
+    hcs10Builder: HCS10Builder;
+    logger?: BasePluginContext['logger'];
+}
+/**
+ * Parameters for HCS10 query tools
+ */
+export interface HCS10QueryToolParams {
+    hederaKit: HederaAgentKit;
+    hcs10Builder: HCS10Builder;
+    logger?: BasePluginContext['logger'];
+}

package/dist/cjs/tools/hcs10/index.d.ts

@@ -0,0 +1,13 @@
+export * from './base-hcs10-tools';
+export * from './hcs10-tool-params';
+export * from './RegisterAgentTool';
+export * from './SendMessageToConnectionTool';
+export * from './InitiateConnectionTool';
+export * from './ListConnectionsTool';
+export * from './CheckMessagesTool';
+export * from './FindRegistrationsTool';
+export * from './ConnectionMonitorTool';
+export * from './ManageConnectionRequestsTool';
+export * from './AcceptConnectionRequestTool';
+export * from './RetrieveProfileTool';
+export * from './ListUnapprovedConnectionRequestsTool';

package/dist/cjs/tools/index.d.ts

@@ -1,13 +1 @@
-export * from './RegisterAgentTool';
-export * from './SendMessageTool';
-export * from './ConnectionTool';
-export * from './SendMessageToConnectionTool';
-export * from './InitiateConnectionTool';
-export * from './ListConnectionsTool';
-export * from './CheckMessagesTool';
-export * from './FindRegistrationsTool';
-export * from './ConnectionMonitorTool';
-export * from './ManageConnectionRequestsTool';
-export * from './AcceptConnectionRequestTool';
-export * from './RetrieveProfileTool';
-export * from './ListUnapprovedConnectionRequestsTool';
+export * from './hcs10';

package/dist/es/builders/hcs10/hcs10-builder.d.ts

@@ -0,0 +1,262 @@
+import { BaseServiceBuilder, HederaAgentKit } from 'hedera-agent-kit';
+import { PrivateKey, TransactionReceipt } from '@hashgraph/sdk';
+import { IStateManager } from '../../state/state-types';
+import { ExecuteResult } from '../types';
+import { FeeConfigBuilderInterface, HCS10Client, ProfileResponse as SDKProfileResponse, HCSMessage, LogLevel, HandleConnectionRequestResponse } from '@hashgraphonline/standards-sdk';
+/**
+ * Message response with timestamp
+ */
+export interface HCSMessageWithTimestamp extends Omit<HCSMessage, 'op'> {
+    timestamp: number;
+    data?: string;
+    sequence_number: number;
+    op?: HCSMessage['op'] | string;
+    operator_id?: string;
+    created?: Date;
+    m?: string;
+}
+/**
+ * Network type for HCS-10
+ */
+export type StandardNetworkType = 'mainnet' | 'testnet';
+/**
+ * Parameters for agent registration
+ */
+export interface RegisterAgentParams {
+    name: string;
+    bio?: string;
+    alias?: string;
+    type?: 'autonomous' | 'manual';
+    model?: string;
+    capabilities?: number[];
+    creator?: string;
+    socials?: Record<string, string>;
+    properties?: Record<string, unknown>;
+    profilePicture?: string | {
+        url?: string;
+        path?: string;
+        filename?: string;
+    };
+    existingProfilePictureTopicId?: string;
+    initialBalance?: number;
+    userAccountId?: string;
+    hbarFee?: number;
+    tokenFees?: Array<{
+        amount: number;
+        tokenId: string;
+    }>;
+    exemptAccountIds?: string[];
+}
+/**
+ * Parameters for initiating a connection
+ */
+export interface InitiateConnectionParams {
+    targetAccountId: string;
+    disableMonitor?: boolean;
+    memo?: string;
+}
+/**
+ * Parameters for accepting a connection request
+ */
+export interface AcceptConnectionParams {
+    requestKey: string;
+    hbarFee?: number | undefined;
+    exemptAccountIds?: string[] | undefined;
+}
+/**
+ * Parameters for sending a message
+ */
+export interface SendMessageParams {
+    topicId: string;
+    message: string;
+    disableMonitoring?: boolean;
+}
+/**
+ * Parameters for sending a message to a connected account
+ */
+export interface SendMessageToConnectionParams {
+    targetIdentifier: string;
+    message: string;
+    disableMonitoring?: boolean;
+}
+/**
+ * HCS10Builder facilitates HCS-10 protocol operations for agent communication
+ * This builder incorporates all HCS10Client functionality directly
+ */
+export declare class HCS10Builder extends BaseServiceBuilder {
+    private standardClient;
+    private stateManager;
+    private executeResult?;
+    private useEncryption;
+    private guardedRegistryBaseUrl;
+    private network;
+    private sdkLogger;
+    constructor(hederaKit: HederaAgentKit, stateManager?: IStateManager, options?: {
+        useEncryption?: boolean;
+        registryUrl?: string;
+        logLevel?: LogLevel;
+    });
+    /**
+     * Get the operator account ID
+     */
+    getOperatorId(): string;
+    /**
+     * Get the network type
+     */
+    getNetwork(): StandardNetworkType;
+    /**
+     * Get account and signer information
+     */
+    getAccountAndSigner(): {
+        accountId: string;
+        signer: PrivateKey;
+    };
+    /**
+     * Get the inbound topic ID for the current operator
+     */
+    getInboundTopicId(): Promise<string>;
+    /**
+     * Get agent profile
+     */
+    getAgentProfile(accountId: string): Promise<SDKProfileResponse>;
+    /**
+     * Submit connection request
+     */
+    submitConnectionRequest(inboundTopicId: string, memo: string): Promise<TransactionReceipt>;
+    /**
+     * Handle connection request
+     */
+    handleConnectionRequest(inboundTopicId: string, requestingAccountId: string, connectionRequestId: number, feeConfig?: FeeConfigBuilderInterface): Promise<HandleConnectionRequestResponse>;
+    /**
+     * Send message to a topic
+     */
+    sendMessage(topicId: string, data: string, memo?: string): Promise<{
+        sequenceNumber: number | undefined;
+        receipt: TransactionReceipt;
+        transactionId: string | undefined;
+    }>;
+    /**
+     * Get messages from a topic
+     */
+    getMessages(topicId: string): Promise<{
+        messages: HCSMessageWithTimestamp[];
+    }>;
+    /**
+     * Get message stream from a topic
+     */
+    getMessageStream(topicId: string): Promise<{
+        messages: HCSMessage[];
+    }>;
+    /**
+     * Get message content
+     */
+    getMessageContent(inscriptionIdOrData: string): Promise<string>;
+    /**
+     * Get the standard client instance (for compatibility)
+     */
+    getStandardClient(): HCS10Client;
+    /**
+     * Load profile picture from URL or file path
+     */
+    private loadProfilePicture;
+    /**
+     * Create and register an agent
+     */
+    private createAndRegisterAgent;
+    /**
+     * Register a new HCS-10 agent
+     * Note: This performs multiple transactions and requires directExecution mode
+     */
+    registerAgent(params: RegisterAgentParams): Promise<this>;
+    /**
+     * Initiate a connection to another agent
+     */
+    initiateConnection(params: InitiateConnectionParams): Promise<this>;
+    /**
+     * Accept a connection request
+     * Note: This performs multiple transactions and requires directExecution mode
+     */
+    acceptConnection(params: AcceptConnectionParams): Promise<this>;
+    /**
+     * Send a message using HCS (for operations that need direct topic access)
+     */
+    sendHCS10Message(params: SendMessageParams): Promise<this>;
+    /**
+     * Send a message to a connected account with optional response monitoring
+     */
+    sendMessageToConnection(params: SendMessageToConnectionParams): Promise<this>;
+    /**
+     * Monitor responses on a topic after sending a message
+     */
+    private monitorResponses;
+    /**
+     * Start passive monitoring for incoming connection requests
+     * This method monitors continuously in the background
+     */
+    startPassiveConnectionMonitoring(): Promise<this>;
+    /**
+     * Monitor for incoming connection requests
+     */
+    monitorConnections(params: {
+        acceptAll?: boolean;
+        targetAccountId?: string;
+        monitorDurationSeconds?: number;
+        hbarFees?: Array<{
+            amount: number;
+            collectorAccount?: string;
+        }>;
+        tokenFees?: Array<{
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string;
+        }>;
+        exemptAccountIds?: string[];
+        defaultCollectorAccount?: string;
+    }): Promise<this>;
+    /**
+     * Manage connection requests (list, view, or reject)
+     */
+    manageConnectionRequests(params: {
+        action: 'list' | 'view' | 'reject';
+        requestKey?: string;
+    }): Promise<this>;
+    /**
+     * List unapproved connection requests
+     */
+    listUnapprovedConnectionRequests(): Promise<this>;
+    /**
+     * List connections with enhanced details
+     */
+    listConnections(params?: {
+        includeDetails?: boolean;
+        showPending?: boolean;
+    }): Promise<this>;
+    private formatConnection;
+    private getEnhancedConnections;
+    /**
+     * Check messages on a connection
+     */
+    checkMessages(params: {
+        targetIdentifier: string;
+        fetchLatest?: boolean;
+        lastMessagesCount?: number;
+    }): Promise<this>;
+    /**
+     * Find registrations using the configured registry
+     */
+    findRegistrations(params: {
+        accountId?: string;
+        tags?: number[];
+    }): Promise<this>;
+    /**
+     * Retrieve detailed profile information for an agent
+     */
+    retrieveProfile(params: {
+        accountId: string;
+        disableCache?: boolean;
+    }): Promise<this>;
+    /**
+     * Override execute to return stored HCS10 operation results
+     */
+    execute(): Promise<ExecuteResult>;
+}

package/dist/es/builders/index.d.ts

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

package/dist/es/builders/types.d.ts

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

package/dist/es/index.d.ts

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

package/dist/es/init/init.d.ts

@@ -1,22 +1,21 @@
-import { HCS10Client, StandardNetworkType } from '../hcs10/HCS10Client';
-import { RegisterAgentTool } from '../tools/RegisterAgentTool';
-import { SendMessageTool } from '../tools/SendMessageTool';
-import { ConnectionTool } from '../tools/ConnectionTool';
+import { HederaAgentKit } 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 { 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';
 export interface HCS10ClientConfig {
     operatorId?: string;
     operatorKey?: string;
-    network?: StandardNetworkType;
+    network?: 'mainnet' | 'testnet';
     useEncryption?: boolean;
     registryUrl?: string;
     logLevel?: 'debug' | 'info' | 'warn' | 'error';
@@ -38,8 +37,6 @@ export interface HCS10Tools {
     listConnectionsTool: ListConnectionsTool;
     sendMessageToConnectionTool: SendMessageToConnectionTool;
     checkMessagesTool: CheckMessagesTool;
-    sendMessageTool: SendMessageTool;
-    connectionTool: ConnectionTool;
     connectionMonitorTool: ConnectionMonitorTool;
     manageConnectionRequestsTool: ManageConnectionRequestsTool;
     acceptConnectionRequestTool: AcceptConnectionRequestTool;
@@ -49,11 +46,13 @@ 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 declare const initializeStandardsAgentKit: (options?: HCS10InitializationOptions) => {
-    hcs10Client: HCS10Client;
-    monitoringClient?: HCS10Client;
+export declare const initializeStandardsAgentKit: (options?: HCS10InitializationOptions) => Promise<{
+    hederaKit: HederaAgentKit;
+    hcs10Builder: HCS10Builder;
+    monitoringHederaKit?: HederaAgentKit;
+    monitoringHcs10Builder?: HCS10Builder;
     tools: Partial<HCS10Tools>;
     stateManager: IStateManager;
-};
+}>;

package/dist/es/plugins/PluginInterface.d.ts

@@ -1,49 +1,12 @@
-import { StructuredTool } from '@langchain/core/tools';
 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';
+export { BasePlugin } from 'hedera-agent-kit';
+export type { IPlugin, BasePluginContext, GenericPluginContext, PluginContext, IPluginClient, IPluginStateManager, HederaTool, } 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
      */
@@ -53,42 +16,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/dist/es/plugins/PluginRegistry.d.ts

@@ -1,47 +1 @@
-import { IPlugin, PluginContext } from './PluginInterface';
-import { StructuredTool } from '@langchain/core/tools';
-/**
- * Registry for managing plugins in the Standards Agent Kit
- */
-export declare class PluginRegistry {
-    private plugins;
-    private context;
-    private logger;
-    /**
-     * Creates a new PluginRegistry instance
-     * @param context The context to provide to plugins during initialization
-     */
-    constructor(context: PluginContext);
-    /**
-     * Register a plugin with the registry
-     * @param plugin The plugin to register
-     * @throws Error if a plugin with the same ID is already registered
-     */
-    registerPlugin(plugin: IPlugin): Promise<void>;
-    /**
-     * 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;
-    /**
-     * Get all registered plugins
-     * @returns Array of all registered plugins
-     */
-    getAllPlugins(): IPlugin[];
-    /**
-     * Get all tools from all registered plugins
-     * @returns Array of all tools provided by registered plugins
-     */
-    getAllTools(): StructuredTool[];
-    /**
-     * 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
-     */
-    unregisterPlugin(id: string): Promise<boolean>;
-    /**
-     * Unregister all plugins
-     */
-    unregisterAllPlugins(): Promise<void>;
-}
+export { PluginRegistry } from 'hedera-agent-kit';

package/dist/es/plugins/defi/index.d.ts

@@ -1,13 +1,16 @@
-import { HCS10Plugin } from '../../../src/plugins/HCS10Plugin';
-import { StructuredTool } from '@langchain/core/tools';
+import { BasePlugin, GenericPluginContext, HederaTool } 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: string;
     name: string;
     description: string;
     version: string;
     author: string;
-    getTools(): StructuredTool[];
+    private tools;
+    initialize(context: GenericPluginContext): Promise<void>;
+    private initializeTools;
+    getTools(): HederaTool[];
 }