@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

package/dist/es/tools/RegisterAgentTool.d.ts

@@ -1,188 +0,0 @@
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { StructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { IStateManager } from '../state/state-types';
-/**
- * RegisterAgentTool wraps the createAndRegisterAgent() function of HCS10Client.
- * It creates and registers an agent on Hedera using the HCS-10 standard SDK flow.
- * On success, returns a JSON string containing the new agent's details (including private key).
- */
-export declare class RegisterAgentTool extends StructuredTool {
-    name: string;
-    description: string;
-    private client;
-    private stateManager?;
-    schema: z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        type: z.ZodOptional<z.ZodEnum<["autonomous", "manual"]>>;
-        model: z.ZodOptional<z.ZodString>;
-        capabilities: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-        profilePicture: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
-            url: z.ZodString;
-            filename: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            url?: string;
-            filename?: string;
-        }, {
-            url?: string;
-            filename?: string;
-        }>, z.ZodObject<{
-            path: z.ZodString;
-            filename: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            path?: string;
-            filename?: string;
-        }, {
-            path?: string;
-            filename?: string;
-        }>]>>;
-        feeCollectorAccountId: z.ZodOptional<z.ZodString>;
-        hbarFee: z.ZodOptional<z.ZodNumber>;
-        tokenFee: z.ZodOptional<z.ZodObject<{
-            amount: z.ZodNumber;
-            tokenId: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            amount?: number;
-            tokenId?: string;
-        }, {
-            amount?: number;
-            tokenId?: string;
-        }>>;
-        hbarFees: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            amount: z.ZodNumber;
-            collectorAccount: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            amount?: number;
-            collectorAccount?: string;
-        }, {
-            amount?: number;
-            collectorAccount?: string;
-        }>, "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;
-        }, {
-            amount?: number;
-            tokenId?: string;
-            collectorAccount?: string;
-        }>, "many">>;
-        exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        setAsCurrent: z.ZodOptional<z.ZodBoolean>;
-        persistence: z.ZodOptional<z.ZodObject<{
-            prefix: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            prefix?: string;
-        }, {
-            prefix?: string;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        capabilities?: number[];
-        type?: "autonomous" | "manual";
-        name?: string;
-        description?: string;
-        model?: string;
-        profilePicture?: string | {
-            url?: string;
-            filename?: string;
-        } | {
-            path?: string;
-            filename?: string;
-        };
-        feeCollectorAccountId?: string;
-        hbarFee?: number;
-        tokenFee?: {
-            amount?: number;
-            tokenId?: string;
-        };
-        hbarFees?: {
-            amount?: number;
-            collectorAccount?: string;
-        }[];
-        tokenFees?: {
-            amount?: number;
-            tokenId?: string;
-            collectorAccount?: string;
-        }[];
-        exemptAccountIds?: string[];
-        setAsCurrent?: boolean;
-        persistence?: {
-            prefix?: string;
-        };
-    }, {
-        capabilities?: number[];
-        type?: "autonomous" | "manual";
-        name?: string;
-        description?: string;
-        model?: string;
-        profilePicture?: string | {
-            url?: string;
-            filename?: string;
-        } | {
-            path?: string;
-            filename?: string;
-        };
-        feeCollectorAccountId?: string;
-        hbarFee?: number;
-        tokenFee?: {
-            amount?: number;
-            tokenId?: string;
-        };
-        hbarFees?: {
-            amount?: number;
-            collectorAccount?: string;
-        }[];
-        tokenFees?: {
-            amount?: number;
-            tokenId?: string;
-            collectorAccount?: string;
-        }[];
-        exemptAccountIds?: string[];
-        setAsCurrent?: boolean;
-        persistence?: {
-            prefix?: string;
-        };
-    }>;
-    /**
-     * Creates a new RegisterAgentTool instance
-     * @param client - Instance of HCS10Client (already configured with operator/network)
-     * @param stateManager - Optional state manager to store agent details
-     */
-    constructor(client: HCS10Client, stateManager?: IStateManager);
-    /**
-     * Loads a profile picture from a local file or URL and returns a buffer
-     * @param profilePicture - Local file path or URL
-     * @returns Object containing buffer and filename
-     */
-    private loadProfilePicture;
-    /**
-     * Calls createAndRegisterAgent() with the provided metadata.
-     * Returns a JSON string with agent details on success, or an error string.
-     */
-    _call(input: z.infer<typeof this.schema>): Promise<string>;
-    /**
-     * Checks if the token fee configuration is valid
-     */
-    private hasValidTokenFee;
-    /**
-     * Processes the registration result and returns formatted output
-     */
-    private processRegistrationResult;
-    /**
-     * Ensures the agent has enough HBAR for operations
-     */
-    private ensureAgentHasFunds;
-    /**
-     * Validates that all required fields are present in the registration result
-     */
-    private validateRegistrationResult;
-    /**
-     * Creates a description of the fees configured for the agent
-     */
-    private createFeeDescription;
-}

package/dist/es/tools/RetrieveProfileTool.d.ts

@@ -1,34 +0,0 @@
-import { StructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-/**
- * Tool for retrieving the HCS-11 profile associated with a Hedera account ID.
- * Utilizes the HCS10Client's retrieveProfile method, which handles fetching.
- */
-export declare class RetrieveProfileTool extends StructuredTool {
-    name: string;
-    description: string;
-    private client;
-    private logger;
-    schema: z.ZodObject<{
-        accountId: z.ZodOptional<z.ZodString>;
-        disableCache: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        accountId?: string;
-        disableCache?: boolean;
-    }, {
-        accountId?: string;
-        disableCache?: boolean;
-    }>;
-    /**
-     * Creates a new RetrieveProfileTool instance.
-     * @param client - An instance of HCS10Client.
-     */
-    constructor(client: HCS10Client);
-    /**
-     * Executes the profile retrieval.
-     * @param input - The input object containing accountId and optional disableCache flag.
-     * @returns A JSON string of the profile on success, or an error message string.
-     */
-    _call(input: z.infer<typeof this.schema>): Promise<string>;
-}

package/dist/es/tools/SendMessageToConnectionTool.d.ts

@@ -1,34 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/state-types';
-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 declare class SendMessageToConnectionTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        targetIdentifier: z.ZodString;
-        message: z.ZodString;
-        disableMonitoring: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        message?: string;
-        disableMonitoring?: boolean;
-        targetIdentifier?: string;
-    }, {
-        message?: string;
-        disableMonitoring?: boolean;
-        targetIdentifier?: string;
-    }>;
-    private hcsClient;
-    private stateManager;
-    private logger;
-    constructor({ hcsClient, stateManager, ...rest }: SendMessageToConnectionToolParams);
-    protected _call({ targetIdentifier, message, disableMonitoring, }: z.infer<this['schema']>): Promise<string>;
-    private monitorResponses;
-}

package/dist/es/tools/SendMessageTool.d.ts

@@ -1,40 +0,0 @@
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { StructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-/**
- * SendMessageTool wraps the sendMessage() function of HCS10Client.
- * It sends a message to a specified Hedera topic and monitors for responses.
- */
-export declare class SendMessageTool extends StructuredTool {
-    name: string;
-    description: string;
-    private client;
-    private lastProcessedTimestamp;
-    private logger;
-    schema: z.ZodObject<{
-        topicId: z.ZodString;
-        message: z.ZodString;
-        disableMonitoring: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        message?: string;
-        topicId?: string;
-        disableMonitoring?: boolean;
-    }, {
-        message?: string;
-        topicId?: string;
-        disableMonitoring?: boolean;
-    }>;
-    /**
-     * @param client - Instance of HCS10Client.
-     */
-    constructor(client: HCS10Client);
-    /**
-     * Calls sendMessage() with the provided parameters.
-     */
-    _call(input: {
-        topicId: string;
-        message: string;
-        disableMonitoring: boolean;
-    }): Promise<string>;
-    private monitorResponses;
-}

package/dist/umd/plugins/BasePlugin.d.ts

@@ -1,28 +0,0 @@
-import { IPlugin, BasePluginContext } from './PluginInterface';
-import { StructuredTool } from '@langchain/core/tools';
-/**
- * Base class for plugins to simplify implementation
- */
-export declare abstract class BasePlugin<T extends BasePluginContext = BasePluginContext> implements IPlugin<T> {
-    abstract id: string;
-    abstract name: string;
-    abstract description: string;
-    abstract version: string;
-    abstract author: string;
-    protected context: T;
-    /**
-     * 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
-     */
-    abstract getTools(): StructuredTool[];
-    /**
-     * Clean up resources when the plugin is unloaded
-     * Default implementation does nothing
-     */
-    cleanup(): Promise<void>;
-}

package/dist/umd/plugins/GenericPlugin.d.ts

@@ -1,17 +0,0 @@
-import { BasePlugin } from './BasePlugin';
-import { GenericPluginContext } from './PluginInterface';
-import { StructuredTool } from '@langchain/core/tools';
-/**
- * Base class for platform-agnostic plugins that can be used across different implementations
- */
-export declare abstract class GenericPlugin extends BasePlugin<GenericPluginContext> {
-    /**
-     * Namespace for the plugin, used for organizing and categorizing plugins
-     */
-    abstract namespace: string;
-    /**
-     * Get the tools provided by this plugin
-     * @returns Array of tools provided by this plugin
-     */
-    abstract getTools(): StructuredTool[];
-}

package/dist/umd/plugins/HCS10Plugin.d.ts

@@ -1,13 +0,0 @@
-import { BasePlugin } from './BasePlugin';
-import { PluginContext } from './PluginInterface';
-import { StructuredTool } from '@langchain/core/tools';
-/**
- * Base class for plugins that require HCS10 specific functionality
- */
-export declare abstract class HCS10Plugin extends BasePlugin<PluginContext> {
-    /**
-     * Get the tools provided by this plugin
-     * @returns Array of tools provided by this plugin
-     */
-    abstract getTools(): StructuredTool[];
-}

package/dist/umd/plugins/PluginLoader.d.ts

@@ -1,38 +0,0 @@
-import { PluginContext, IPlugin } from './PluginInterface';
-/**
- * Configuration for loading a plugin
- */
-export interface PluginLoadOptions {
-    /**
-     * Whether to initialize the plugin after loading
-     * @default true
-     */
-    initialize?: boolean;
-}
-/**
- * Utility for loading plugins from different sources
- */
-export declare class PluginLoader {
-    /**
-     * Load a plugin from a directory
-     * @param directory Path to the directory containing the plugin
-     * @param context Context to provide to the plugin during initialization
-     * @param options Options for loading the plugin
-     * @returns The loaded plugin instance
-     */
-    static loadFromDirectory(directory: string, context: PluginContext, options?: PluginLoadOptions): Promise<IPlugin>;
-    /**
-     * Load a plugin from an npm package
-     * @param packageName Name of the npm package containing the plugin
-     * @param context Context to provide to the plugin during initialization
-     * @param options Options for loading the plugin
-     * @returns The loaded plugin instance
-     */
-    static loadFromPackage(packageName: string, context: PluginContext, options?: PluginLoadOptions): Promise<IPlugin>;
-    /**
-     * Check if an object implements the IPlugin interface
-     * @param obj Object to check
-     * @returns true if the object implements IPlugin, false otherwise
-     */
-    private static isValidPlugin;
-}

package/dist/umd/plugins/openconvai/OpenConvAIPlugin.d.ts

@@ -1,23 +0,0 @@
-import { GenericPlugin } from '../GenericPlugin';
-import { GenericPluginContext } from '../PluginInterface';
-import { StructuredTool } from '@langchain/core/tools';
-/**
- * OpenConvAI Plugin that provides all the tools from standards-agent-kit
- * This plugin enables full HCS-10 agent functionality including registration,
- * connection management, and messaging capabilities.
- */
-export declare class OpenConvAIPlugin extends GenericPlugin {
-    id: string;
-    name: string;
-    description: string;
-    version: string;
-    author: string;
-    namespace: string;
-    private hcs10Client?;
-    private stateManager?;
-    private tools;
-    initialize(context: GenericPluginContext): Promise<void>;
-    private initializeTools;
-    getTools(): StructuredTool[];
-    cleanup(): Promise<void>;
-}

package/dist/umd/plugins/openconvai/index.d.ts

@@ -1 +0,0 @@
-export * from './OpenConvAIPlugin';

package/dist/umd/tools/AcceptConnectionRequestTool.d.ts

@@ -1,33 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/state-types';
-export interface AcceptConnectionRequestToolParams extends ToolParams {
-    hcsClient: HCS10Client;
-    stateManager: IStateManager;
-}
-/**
- * A tool specifically for accepting incoming connection requests.
- */
-export declare class AcceptConnectionRequestTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        requestKey: z.ZodString;
-        hbarFee: z.ZodOptional<z.ZodNumber>;
-        exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        hbarFee?: number;
-        exemptAccountIds?: string[];
-        requestKey?: string;
-    }, {
-        hbarFee?: number;
-        exemptAccountIds?: string[];
-        requestKey?: string;
-    }>;
-    private hcsClient;
-    private stateManager;
-    private logger;
-    constructor({ hcsClient, stateManager, ...rest }: AcceptConnectionRequestToolParams);
-    protected _call({ requestKey, hbarFee, exemptAccountIds, }: z.infer<this['schema']>): Promise<string>;
-}

package/dist/umd/tools/CheckMessagesTool.d.ts

@@ -1,34 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/state-types';
-export interface CheckMessagesToolParams extends ToolParams {
-    hcsClient: HCS10Client;
-    stateManager: IStateManager;
-}
-/**
- * A tool to check for new messages on an active HCS-10 connection topic,
- * or optionally fetch the latest messages regardless of timestamp.
- */
-export declare class CheckMessagesTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: 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;
-    }, {
-        targetIdentifier?: string;
-        fetchLatest?: boolean;
-        lastMessagesCount?: number;
-    }>;
-    hcsClient: HCS10Client;
-    private stateManager;
-    private logger;
-    constructor({ hcsClient, stateManager, ...rest }: CheckMessagesToolParams);
-    protected _call({ targetIdentifier, fetchLatest, lastMessagesCount, }: z.infer<this['schema']>): Promise<string>;
-}

package/dist/umd/tools/ConnectionMonitorTool.d.ts

@@ -1,100 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/state-types';
-export interface FeeDefinition {
-    amount: number;
-    collectorAccount?: string;
-}
-export interface TokenFeeDefinition extends FeeDefinition {
-    tokenId: string;
-}
-export interface ConnectionMonitorToolParams extends ToolParams {
-    hcsClient: HCS10Client;
-    stateManager: IStateManager;
-}
-/**
- * A tool for monitoring incoming connection requests and accepting them with optional fee settings.
- */
-export declare class ConnectionMonitorTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: 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;
-        }, {
-            amount?: number;
-            collectorAccount?: string;
-        }>, "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;
-        }, {
-            amount?: number;
-            tokenId?: string;
-            collectorAccount?: string;
-        }>, "many">>;
-        exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        monitorDurationSeconds: z.ZodOptional<z.ZodNumber>;
-        defaultCollectorAccount: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        hbarFees?: {
-            amount?: number;
-            collectorAccount?: string;
-        }[];
-        tokenFees?: {
-            amount?: number;
-            tokenId?: string;
-            collectorAccount?: string;
-        }[];
-        exemptAccountIds?: string[];
-        targetAccountId?: string;
-        acceptAll?: boolean;
-        monitorDurationSeconds?: number;
-        defaultCollectorAccount?: string;
-    }, {
-        hbarFees?: {
-            amount?: number;
-            collectorAccount?: string;
-        }[];
-        tokenFees?: {
-            amount?: number;
-            tokenId?: string;
-            collectorAccount?: string;
-        }[];
-        exemptAccountIds?: string[];
-        targetAccountId?: string;
-        acceptAll?: boolean;
-        monitorDurationSeconds?: number;
-        defaultCollectorAccount?: string;
-    }>;
-    private hcsClient;
-    private stateManager;
-    private logger;
-    private isMonitoring;
-    private listConnectionsTool;
-    constructor({ hcsClient, stateManager, ...rest }: ConnectionMonitorToolParams);
-    updateClient(newClient: HCS10Client): void;
-    protected _call({ acceptAll, targetAccountId, hbarFees, tokenFees, exemptAccountIds, monitorDurationSeconds, defaultCollectorAccount, }: z.infer<this['schema']>): Promise<string>;
-    private createFeeConfig;
-    private extractAccountId;
-    private acceptConnectionRequest;
-    private formatFeeString;
-    /**
-     * Updates the ConnectionsManager with latest connection data
-     * This method is meant to be called when changes to connections happen
-     * outside this tool's monitoring process
-     */
-    update(): void;
-}

package/dist/umd/tools/ConnectionTool.d.ts

@@ -1,40 +0,0 @@
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { Logger } from '@hashgraphonline/standards-sdk';
-import { IStateManager } from '../state/state-types';
-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 declare class ConnectionTool extends StructuredTool {
-    name: string;
-    description: string;
-    client: HCS10Client;
-    logger: Logger;
-    private stateManager;
-    private isMonitoring;
-    private monitoringTopic;
-    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    /**
-     * @param client - Instance of HCS10Client.
-     * @param stateManager - Instance of StateManager for shared state management.
-     */
-    constructor({ client, stateManager, ...rest }: ConnectionToolParams);
-    /**
-     * Initiates the connection request monitoring process in the background.
-     * Gets the inbound topic ID from the configured client.
-     */
-    _call(): Promise<string>;
-    /**
-     * The core monitoring loop.
-     */
-    private monitorIncomingRequests;
-    stopMonitoring(): void;
-}

package/dist/umd/tools/FindRegistrationsTool.d.ts

@@ -1,28 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { HCS10Client } from '../hcs10/HCS10Client';
-import { AIAgentCapability } 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 declare class FindRegistrationsTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        accountId: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof AIAgentCapability>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        accountId?: string;
-        tags?: AIAgentCapability[];
-    }, {
-        accountId?: string;
-        tags?: AIAgentCapability[];
-    }>;
-    private hcsClient;
-    private logger;
-    constructor({ hcsClient, ...rest }: FindRegistrationsToolParams);
-    protected _call({ accountId, tags, }: z.infer<this['schema']>): Promise<string>;
-}