@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

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

@@ -1,30 +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 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 declare class InitiateConnectionTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        targetAccountId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        targetAccountId?: string;
-    }, {
-        targetAccountId?: string;
-    }>;
-    private hcsClient;
-    private stateManager;
-    private logger;
-    constructor({ hcsClient, stateManager, ...rest }: InitiateConnectionToolParams);
-    protected _call({ targetAccountId }: z.infer<this['schema']>): Promise<string>;
-}

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

@@ -1,33 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { IStateManager } from '../state/state-types';
-import { HCS10Client } from '../hcs10/HCS10Client';
-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 declare class ListConnectionsTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        includeDetails: z.ZodOptional<z.ZodBoolean>;
-        showPending: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        includeDetails?: boolean;
-        showPending?: boolean;
-    }, {
-        includeDetails?: boolean;
-        showPending?: boolean;
-    }>;
-    private stateManager;
-    private hcsClient?;
-    private logger;
-    constructor({ stateManager, hcsClient, ...rest }: ListConnectionsToolParams);
-    protected _call(args: z.infer<this['schema']>): Promise<string>;
-    private formatConnection;
-    private getEnhancedConnections;
-}

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

@@ -1,41 +0,0 @@
-import { StructuredTool, ToolParams } from '@langchain/core/tools';
-import { z } from 'zod';
-import { IStateManager } from '../state/state-types';
-import { HCS10Client } from '../hcs10/HCS10Client';
-type ListPendingRequestsToolParams = ToolParams & {
-    hcsClient: HCS10Client;
-    stateManager: IStateManager;
-};
-export declare class ListUnapprovedConnectionRequestsTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        sortBy: z.ZodOptional<z.ZodEnum<["time_asc", "time_desc", "name_asc", "name_desc"]>>;
-        limit: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        sortBy?: "time_asc" | "time_desc" | "name_asc" | "name_desc";
-        limit?: number;
-    }, {
-        sortBy?: "time_asc" | "time_desc" | "name_asc" | "name_desc";
-        limit?: number;
-    }>;
-    private hcsClient;
-    private stateManager;
-    private logger;
-    constructor({ hcsClient, stateManager, ...rest }: ListPendingRequestsToolParams);
-    protected _call({ sortBy, limit, }: z.infer<this['schema']>): Promise<string>;
-    /**
-     * Processes the connection connectionMap to find all requests
-     * that are not fully established (incoming unapproved and outgoing pending).
-     */
-    private findAllPendingRequests;
-    /**
-     * Formats the list of pending requests for display.
-     */
-    private formatRequestsList;
-    /**
-     * Sorts connection requests based on the specified criteria.
-     */
-    private sortRequests;
-}
-export {};

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

@@ -1,38 +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 ManageConnectionRequestsToolParams extends ToolParams {
-    hcsClient: HCS10Client;
-    stateManager: IStateManager;
-}
-/**
- * A tool for managing incoming connection requests in a LangChain-compatible way.
- * This tool allows an agent to list, view details of, and accept/reject incoming connection requests.
- */
-export declare class ManageConnectionRequestsTool extends StructuredTool {
-    name: string;
-    description: string;
-    schema: z.ZodObject<{
-        action: z.ZodEnum<["list", "view", "reject"]>;
-        requestKey: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        action?: "list" | "view" | "reject";
-        requestKey?: string;
-    }, {
-        action?: "list" | "view" | "reject";
-        requestKey?: string;
-    }>;
-    private hcsClient;
-    private stateManager;
-    private logger;
-    private lastRefreshTime;
-    private refreshIntervalMs;
-    constructor({ hcsClient, stateManager, ...rest }: ManageConnectionRequestsToolParams);
-    protected _call({ action, requestKey, }: z.infer<this['schema']>): Promise<string>;
-    private refreshRequestsIfNeeded;
-    private refreshRequests;
-    private listRequests;
-    private viewRequest;
-    private rejectRequest;
-}

package/dist/umd/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/umd/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/umd/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/umd/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/src/agents/index.ts

@@ -1 +0,0 @@
-// Export all agent implementations 

package/src/plugins/BasePlugin.ts

@@ -1,37 +0,0 @@
-import { IPlugin, BasePluginContext } from './PluginInterface';
-import { StructuredTool } from '@langchain/core/tools';
-
-/**
- * Base class for plugins to simplify implementation
- */
-export 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
-   */
-  async initialize(context: T): Promise<void> {
-    this.context = context;
-  }
-
-  /**
-   * 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
-   */
-  async cleanup(): Promise<void> {
-    // Default implementation does nothing
-  }
-}

package/src/plugins/GenericPlugin.ts

@@ -1,19 +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 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 override getTools(): StructuredTool[];
-}

package/src/plugins/HCS10Plugin.ts

@@ -1,14 +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 abstract class HCS10Plugin extends BasePlugin<PluginContext> {
-  /**
-   * Get the tools provided by this plugin
-   * @returns Array of tools provided by this plugin
-   */
-  abstract override getTools(): StructuredTool[];
-}

package/src/plugins/PluginLoader.ts

@@ -1,121 +0,0 @@
-import { PluginContext } from './PluginInterface';
-import * as fs from 'fs';
-import * as path from 'path';
-import { 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 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 async loadFromDirectory(
-    directory: string,
-    context: PluginContext,
-    options: PluginLoadOptions = { initialize: true }
-  ): Promise<IPlugin> {
-    const manifestPath = path.join(directory, 'plugin.json');
-
-    if (!fs.existsSync(manifestPath)) {
-      throw new Error(`Plugin manifest not found at ${manifestPath}`);
-    }
-
-    try {
-      const manifestContent = fs.readFileSync(manifestPath, 'utf8');
-      const manifest = JSON.parse(manifestContent);
-
-      // Validate manifest
-      if (!manifest.id || !manifest.main) {
-        throw new Error('Invalid plugin manifest: missing required fields (id, main)');
-      }
-
-      // Load the plugin module
-      const mainPath = path.join(directory, manifest.main);
-      if (!fs.existsSync(mainPath)) {
-        throw new Error(`Plugin main file not found at ${mainPath}`);
-      }
-
-      // Import the plugin module
-      const pluginModule = await import(mainPath);
-      const PluginClass = pluginModule.default || pluginModule[manifest.id];
-
-      if (!PluginClass) {
-        throw new Error(`Could not find plugin class in ${mainPath}`);
-      }
-
-      // Create an instance of the plugin
-      const plugin = new PluginClass();
-
-      // Validate that it implements the IPlugin interface
-      if (!this.isValidPlugin(plugin)) {
-        throw new Error(`Plugin does not implement the IPlugin interface correctly`);
-      }
-
-      // Initialize the plugin if requested
-      if (options.initialize) {
-        await plugin.initialize(context);
-      }
-
-      return plugin;
-    } catch (error) {
-      throw new Error(`Failed to load plugin from directory ${directory}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  /**
-   * 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 async loadFromPackage(
-    packageName: string,
-    context: PluginContext,
-    options: PluginLoadOptions = { initialize: true }
-  ): Promise<IPlugin> {
-    try {
-      // Resolve the package path
-      const packagePath = require.resolve(packageName);
-      const packageDir = path.dirname(packagePath);
-
-      return this.loadFromDirectory(packageDir, context, options);
-    } catch (error) {
-      throw new Error(`Failed to load plugin from package ${packageName}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  /**
-   * 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(obj: any): obj is IPlugin {
-    return (
-      obj &&
-      typeof obj.id === 'string' &&
-      typeof obj.name === 'string' &&
-      typeof obj.description === 'string' &&
-      typeof obj.version === 'string' &&
-      typeof obj.author === 'string' &&
-      typeof obj.initialize === 'function' &&
-      typeof obj.getTools === 'function'
-    );
-  }
-}