@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/plugins/openconvai/index.d.ts

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

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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>;
-}

package/dist/cjs/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/cjs/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/cjs/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/cjs/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;
-}