@hashgraphonline/standards-agent-kit 0.0.11 → 0.0.13

package/dist/src/hcs10/HCS10Client.d.ts

@@ -1,6 +1,9 @@
 import { TransactionReceipt, PrivateKey } from '@hashgraph/sdk';
-import { HCS10Client as StandardSDKClient, AgentRegistrationResult, WaitForConnectionConfirmationResponse, ProfileResponse, HCSMessage, LogLevel } from '@hashgraphonline/standards-sdk';
+import { HCS10Client as StandardSDKClient, AgentRegistrationResult, WaitForConnectionConfirmationResponse, ProfileResponse as SDKProfileResponse, HCSMessage, LogLevel, Logger, FeeConfigBuilderInterface } from '@hashgraphonline/standards-sdk';
 import { AgentMetadata, AgentChannels } from './types';
+type StandardHandleConnectionRequest = InstanceType<typeof StandardSDKClient>['handleConnectionRequest'];
+type HandleConnectionRequestResponse = Awaited<ReturnType<StandardHandleConnectionRequest>>;
+export type StandardNetworkType = 'mainnet' | 'testnet';
 export interface HCSMessageWithTimestamp extends HCSMessage {
     timestamp: number;
     data: string;
@@ -9,11 +12,8 @@ export interface HCSMessageWithTimestamp extends HCSMessage {
 export interface ExtendedAgentMetadata extends AgentMetadata {
     pfpBuffer?: Buffer;
     pfpFileName?: string;
+    feeConfig?: FeeConfigBuilderInterface;
 }
-type StandardHandleConnectionRequest = InstanceType<typeof StandardSDKClient>['handleConnectionRequest'];
-type FeeConfigBuilderInterface = Parameters<StandardHandleConnectionRequest>[3];
-type HandleConnectionRequestResponse = Awaited<ReturnType<StandardHandleConnectionRequest>>;
-export type StandardNetworkType = 'mainnet' | 'testnet';
 /**
  * HCS10Client wraps the HCS-10 functionalities using the @hashgraphonline/standards-sdk.
  * - Creates and registers agents using the standard SDK flow.
@@ -25,6 +25,7 @@ export declare class HCS10Client {
     private useEncryption;
     agentChannels?: AgentChannels;
     guardedRegistryBaseUrl: string;
+    logger: Logger;
     constructor(operatorId: string, operatorPrivateKey: string, network: StandardNetworkType, options?: {
         useEncryption?: boolean;
         registryUrl?: string;
@@ -34,9 +35,9 @@ export declare class HCS10Client {
     getNetwork(): StandardNetworkType;
     handleConnectionRequest(inboundTopicId: string, requestingAccountId: string, connectionRequestId: number, feeConfig?: FeeConfigBuilderInterface): Promise<HandleConnectionRequestResponse>;
     /**
-     * Exposes the standard SDK's retrieveProfile method.
+     * Retrieves the profile for a given account ID using the standard SDK.
      */
-    retrieveProfile(accountId: string): Promise<ProfileResponse>;
+    getAgentProfile(accountId: string): Promise<SDKProfileResponse>;
     /**
      * Exposes the standard SDK's submitConnectionRequest method.
      */
@@ -44,12 +45,18 @@ export declare class HCS10Client {
     /**
      * Exposes the standard SDK's waitForConnectionConfirmation method.
      */
-    waitForConnectionConfirmation(outboundTopicId: string, // Changed from inboundTopicId based on demo usage
-    connectionRequestId: number, maxAttempts?: number, delayMs?: number): Promise<WaitForConnectionConfirmationResponse>;
+    waitForConnectionConfirmation(outboundTopicId: string, connectionRequestId: number, maxAttempts?: number, delayMs?: number): Promise<WaitForConnectionConfirmationResponse>;
     /**
      * Creates and registers an agent using the standard SDK's HCS10Client.
      * This handles account creation, key generation, topic setup, and registration.
-     * @param metadata - The agent's metadata, potentially including pfpBuffer and pfpFileName.
+     *
+     * When metadata includes fee configuration:
+     * 1. The properties.feeConfig will be passed to the AgentBuilder
+     * 2. The properties.inboundTopicType will be set to FEE_BASED
+     * 3. The SDK's createAndRegisterAgent will apply the fees to the agent's inbound topic
+     *
+     * @param metadata - The agent's metadata, potentially including pfpBuffer, pfpFileName,
+     *                   and fee configuration in properties.feeConfig
      * @returns The registration result from the standard SDK, containing accountId, keys, topics etc.
      */
     createAndRegisterAgent(metadata: ExtendedAgentMetadata): Promise<AgentRegistrationResult>;
@@ -64,7 +71,7 @@ export declare class HCS10Client {
      * @param submitKey - Optional private key for topics requiring specific submit keys.
      * @returns A confirmation status string from the transaction receipt.
      */
-    sendMessage(topicId: string, data: string, memo?: string, submitKey?: PrivateKey): Promise<number | undefined>;
+    sendMessage(topicId: string, data: string, memo?: string, submitKey?: any): Promise<number | undefined>;
     /**
      * Retrieves messages from a topic using the standard SDK client.
      *
@@ -90,6 +97,21 @@ export declare class HCS10Client {
      * @throws {Error} If the operator ID cannot be determined or the profile/topic cannot be retrieved.
      */
     getInboundTopicId(): Promise<string>;
+    /**
+     * Retrieves the configured operator account ID and private key.
+     * Required by tools needing to identify the current agent instance.
+     */
+    getAccountAndSigner(): {
+        accountId: string;
+        signer: PrivateKey;
+    };
+    /**
+     * Retrieves the outbound topic ID for the current operator.
+     * Fetches the operator's profile if necessary.
+     * @returns The outbound topic ID string.
+     * @throws If the outbound topic cannot be determined.
+     */
+    getOutboundTopicId(): Promise<string>;
     setClient(accountId: string, privateKey: string): StandardSDKClient;
 }
 export {};

package/dist/src/hcs10/types.d.ts

@@ -1,3 +1,4 @@
+import { FeeConfigBuilderInterface } from '@hashgraphonline/standards-sdk';
 /**
  * Agent metadata interface used during registration.
  */
@@ -10,6 +11,9 @@ export interface AgentMetadata {
     capabilities?: number[];
     social?: Record<string, string>;
     properties?: Record<string, unknown>;
+    socials?: Record<string, string>;
+    creator?: string;
+    feeConfig?: FeeConfigBuilderInterface;
 }
 /**
  * AgentChannels represents the communication topics for an agent.

package/dist/src/index.d.ts

@@ -1,26 +1,15 @@
-import { HCS10Client } from './hcs10/HCS10Client';
-import { RegisterAgentTool } from './tools/RegisterAgentTool';
-import { SendMessageTool } from './tools/SendMessageTool';
-import { ConnectionTool } from './tools/ConnectionTool';
-import { IStateManager } from './state/open-convai-state';
-export interface HCS10InitializationOptions {
-    useEncryption?: boolean;
-    registryUrl?: string;
-    stateManager?: IStateManager;
-}
-/**
- * Initializes the HCS10 client and returns pre-registered LangChain tools.
- *
- * @param options - Optional settings including useEncryption, registryUrl, and stateManager.
- */
-export declare function initializeHCS10Client(options?: HCS10InitializationOptions): Promise<{
-    hcs10Client: HCS10Client;
-    tools: {
-        registerAgentTool: RegisterAgentTool;
-        sendMessageTool: SendMessageTool;
-        connectionTool: ConnectionTool;
-    };
-}>;
 export * from './hcs10';
 export * from './tools';
 export * from './state';
+export * from './init';
+export { ConnectionTool } from './tools/ConnectionTool';
+export { ConnectionMonitorTool } from './tools/ConnectionMonitorTool';
+export { ManageConnectionRequestsTool } from './tools/ManageConnectionRequestsTool';
+export { AcceptConnectionRequestTool } from './tools/AcceptConnectionRequestTool';
+export { InitiateConnectionTool } from './tools/InitiateConnectionTool';
+export { ListConnectionsTool } from './tools/ListConnectionsTool';
+export { CheckMessagesTool } from './tools/CheckMessagesTool';
+export { FindRegistrationsTool } from './tools/FindRegistrationsTool';
+export { SendMessageTool } from './tools/SendMessageTool';
+export { SendMessageToConnectionTool } from './tools/SendMessageToConnectionTool';
+export { ListUnapprovedConnectionRequestsTool } from './tools/ListUnapprovedConnectionRequestsTool';

package/dist/src/init.d.ts

@@ -0,0 +1,23 @@
+import { HCS10Client } from './hcs10/HCS10Client';
+import { RegisterAgentTool } from './tools/RegisterAgentTool';
+import { SendMessageTool } from './tools/SendMessageTool';
+import { ConnectionTool } from './tools/ConnectionTool';
+import { IStateManager } from './state/open-convai-state';
+export interface HCS10InitializationOptions {
+    useEncryption?: boolean;
+    registryUrl?: string;
+    stateManager?: IStateManager;
+}
+/**
+ * Initializes the HCS10 client and returns pre-registered LangChain tools.
+ *
+ * @param options - Optional settings including useEncryption, registryUrl, and stateManager.
+ */
+export declare function initializeHCS10Client(options?: HCS10InitializationOptions): Promise<{
+    hcs10Client: HCS10Client;
+    tools: {
+        registerAgentTool: RegisterAgentTool;
+        sendMessageTool: SendMessageTool;
+        connectionTool: ConnectionTool;
+    };
+}>;

package/dist/src/state/open-convai-state.d.ts

@@ -5,36 +5,160 @@ export interface RegisteredAgent {
     outboundTopicId: string;
     profileTopicId?: string;
 }
+export type ConnectionStatus = 'established' | 'pending' | 'needs confirmation' | 'unknown';
+export interface AgentProfileInfo {
+    name?: string;
+    bio?: string;
+    avatar?: string;
+    type?: string;
+}
+export interface ConnectionRequestInfo {
+    id: number;
+    requestorId: string;
+    requestorName: string;
+    timestamp: Date;
+    memo?: string;
+    profile?: AgentProfileInfo;
+}
 export interface ActiveConnection {
     targetAccountId: string;
     targetAgentName: string;
     targetInboundTopicId: string;
     connectionTopicId: string;
+    status?: ConnectionStatus;
+    created?: Date;
+    lastActivity?: Date;
+    isPending?: boolean;
+    needsConfirmation?: boolean;
+    profileInfo?: AgentProfileInfo;
 }
+/**
+ * Core state management interface for the standards agent toolkit.
+ * All tools that need to maintain state should use an implementation of this interface.
+ */
 export interface IStateManager {
+    /**
+     * Sets the current active agent, clearing any previous connections.
+     */
     setCurrentAgent(agent: RegisteredAgent | null): void;
+    /**
+     * Gets the current active agent.
+     */
     getCurrentAgent(): RegisteredAgent | null;
+    /**
+     * Adds a new active connection to the state.
+     * Will not add duplicates based on connectionTopicId.
+     */
     addActiveConnection(connection: ActiveConnection): void;
+    /**
+     * Updates an existing connection or adds it if not found.
+     * Preserves existing properties when updating.
+     */
+    updateOrAddConnection(connection: ActiveConnection): void;
+    /**
+     * Lists all active connections for the current agent.
+     */
     listConnections(): ActiveConnection[];
+    /**
+     * Finds a connection by identifier, which can be:
+     * - A 1-based index number as shown in the connection list
+     * - A target account ID
+     * - A connection topic ID
+     */
     getConnectionByIdentifier(identifier: string): ActiveConnection | undefined;
+    /**
+     * Gets the last processed message timestamp for a connection.
+     */
     getLastTimestamp(connectionTopicId: string): number;
+    /**
+     * Updates the last processed message timestamp for a connection.
+     */
     updateTimestamp(connectionTopicId: string, timestampNanos: number): void;
+    /**
+     * Stores a connection request in the state.
+     */
+    addConnectionRequest(request: ConnectionRequestInfo): void;
+    /**
+     * Lists all pending connection requests.
+     */
+    listConnectionRequests(): ConnectionRequestInfo[];
+    /**
+     * Finds a connection request by its ID.
+     */
+    getConnectionRequestById(requestId: number): ConnectionRequestInfo | undefined;
+    /**
+     * Removes a connection request from the state.
+     */
+    removeConnectionRequest(requestId: number): void;
+    /**
+     * Clears all connection requests from the state.
+     */
+    clearConnectionRequests(): void;
 }
 /**
- * An example implementation of the `IStateManager` interface.
- * All tools should have a state manager instance.
+ * Implementation of the IStateManager interface for the OpenConvai system.
+ * Manages agent state and connection information with thread safety and
+ * proper timestamp tracking.
  */
 export declare class OpenConvaiState implements IStateManager {
-    currentAgent: RegisteredAgent | null;
-    activeConnections: ActiveConnection[];
-    connectionMessageTimestamps: {
-        [connectionTopicId: string]: number;
-    };
+    private currentAgent;
+    private activeConnections;
+    private connectionMessageTimestamps;
+    private connectionRequests;
+    /**
+     * Sets the current active agent and clears any previous connection data.
+     * This should be called when switching between agents.
+     */
     setCurrentAgent(agent: RegisteredAgent | null): void;
+    /**
+     * Returns the currently active agent or null if none is set.
+     */
     getCurrentAgent(): RegisteredAgent | null;
+    /**
+     * Adds a new connection to the active connections list.
+     * Ensures no duplicates are added based on connectionTopicId.
+     * Initializes timestamp tracking for the connection.
+     */
     addActiveConnection(connection: ActiveConnection): void;
+    /**
+     * Updates an existing connection or adds it if not found.
+     * Preserves existing properties when updating by merging objects.
+     */
+    updateOrAddConnection(connection: ActiveConnection): void;
+    /**
+     * Returns a copy of all active connections.
+     */
     listConnections(): ActiveConnection[];
+    /**
+     * Finds a connection by its identifier, which can be:
+     * - A 1-based index as displayed in the connection list
+     * - A target account ID string
+     * - A connection topic ID string
+     */
     getConnectionByIdentifier(identifier: string): ActiveConnection | undefined;
+    /**
+     * Gets the last processed message timestamp for a connection.
+     * Returns 0 if no timestamp has been recorded.
+     */
     getLastTimestamp(connectionTopicId: string): number;
+    /**
+     * Updates the last processed message timestamp for a connection,
+     * but only if the new timestamp is more recent than the existing one.
+     */
     updateTimestamp(connectionTopicId: string, timestampNanos: number): void;
+    /**
+     * Helper method to find a connection's index by its topic ID.
+     * Returns -1 if not found.
+     */
+    private findConnectionIndex;
+    /**
+     * Helper method to initialize timestamp tracking for a connection
+     * if it doesn't already exist.
+     */
+    private initializeTimestampIfNeeded;
+    addConnectionRequest(request: ConnectionRequestInfo): void;
+    listConnectionRequests(): ConnectionRequestInfo[];
+    getConnectionRequestById(requestId: number): ConnectionRequestInfo | undefined;
+    removeConnectionRequest(requestId: number): void;
+    clearConnectionRequests(): void;
 }

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

@@ -0,0 +1,33 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { HCS10Client } from '../hcs10/HCS10Client';
+import { IStateManager } from '../state/open-convai-state';
+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<{
+        requestId: z.ZodNumber;
+        hbarFee: z.ZodOptional<z.ZodNumber>;
+        exemptAccountIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        requestId: number;
+        hbarFee?: number | undefined;
+        exemptAccountIds?: string[] | undefined;
+    }, {
+        requestId: number;
+        hbarFee?: number | undefined;
+        exemptAccountIds?: string[] | undefined;
+    }>;
+    private hcsClient;
+    private stateManager;
+    private logger;
+    constructor({ hcsClient, stateManager, ...rest }: AcceptConnectionRequestToolParams);
+    protected _call({ requestId, hbarFee, exemptAccountIds, }: z.infer<this['schema']>): Promise<string>;
+}

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

@@ -0,0 +1,96 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { HCS10Client } from '../hcs10/HCS10Client';
+import { IStateManager } from '../state/open-convai-state';
+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 | undefined;
+        }, {
+            amount: number;
+            collectorAccount?: string | undefined;
+        }>, "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 | undefined;
+        }, {
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string | undefined;
+        }>, "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 | undefined;
+        }[] | undefined;
+        tokenFees?: {
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string | undefined;
+        }[] | undefined;
+        exemptAccountIds?: string[] | undefined;
+        targetAccountId?: string | undefined;
+        acceptAll?: boolean | undefined;
+        monitorDurationSeconds?: number | undefined;
+        defaultCollectorAccount?: string | undefined;
+    }, {
+        hbarFees?: {
+            amount: number;
+            collectorAccount?: string | undefined;
+        }[] | undefined;
+        tokenFees?: {
+            amount: number;
+            tokenId: string;
+            collectorAccount?: string | undefined;
+        }[] | undefined;
+        exemptAccountIds?: string[] | undefined;
+        targetAccountId?: string | undefined;
+        acceptAll?: boolean | undefined;
+        monitorDurationSeconds?: number | undefined;
+        defaultCollectorAccount?: string | undefined;
+    }>;
+    private hcsClient;
+    private stateManager;
+    private logger;
+    private isMonitoring;
+    private listConnectionsTool;
+    private static processedRequests;
+    constructor({ hcsClient, stateManager, ...rest }: ConnectionMonitorToolParams);
+    updateClient(newClient: HCS10Client): void;
+    call(args: z.infer<this['schema']>): Promise<string>;
+    protected _call({ acceptAll, targetAccountId, hbarFees, tokenFees, exemptAccountIds, monitorDurationSeconds, defaultCollectorAccount, }: z.infer<this['schema']>): Promise<string>;
+    private createFeeConfig;
+    private extractAccountId;
+    private acceptConnectionRequest;
+    private formatFeeString;
+}

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

@@ -26,5 +26,5 @@ export declare class InitiateConnectionTool extends StructuredTool {
     private stateManager;
     private logger;
     constructor({ hcsClient, stateManager, ...rest }: InitiateConnectionToolParams);
-    protected _call({ targetAccountId, }: z.infer<this['schema']>): Promise<string>;
+    protected _call({ targetAccountId }: z.infer<this['schema']>): Promise<string>;
 }

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

@@ -1,17 +1,33 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
 import { IStateManager } from '../state/open-convai-state';
+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<{}, "strip", z.ZodTypeAny, {}, {}>;
+    schema: z.ZodObject<{
+        includeDetails: z.ZodOptional<z.ZodBoolean>;
+        showPending: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        includeDetails?: boolean | undefined;
+        showPending?: boolean | undefined;
+    }, {
+        includeDetails?: boolean | undefined;
+        showPending?: boolean | undefined;
+    }>;
     private stateManager;
-    constructor({ stateManager, ...rest }: ListConnectionsToolParams);
-    protected _call(_: z.infer<this['schema']>): Promise<string>;
+    private hcsClient?;
+    constructor({ stateManager, hcsClient, ...rest }: ListConnectionsToolParams);
+    protected _call(args: z.infer<this['schema']>): Promise<string>;
+    private formatConnection;
+    private enhanceConnectionInfo;
+    private fetchOutboundMessages;
 }

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

@@ -0,0 +1,53 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { IStateManager } from '../state/open-convai-state';
+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" | undefined;
+        limit?: number | undefined;
+    }, {
+        sortBy?: "time_asc" | "time_desc" | "name_asc" | "name_desc" | undefined;
+        limit?: number | undefined;
+    }>;
+    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;
+    /**
+     * Helper to attempt extracting target account ID from outbound request message.
+     */
+    private extractTargetAccountIdFromOutbound;
+    /**
+     * Maps HCS11Profile to the AgentProfileInfo used in state/display.
+     */
+    private mapSDKProfileToInfo;
+    /**
+     * Extracts the account ID from relevant fields in an HCSMessage.
+     */
+    private extractAccountIdFromMessage;
+    /**
+     * Formats the list of pending requests for display.
+     */
+    private formatRequestsList;
+    /**
+     * Sorts connection requests based on the specified criteria.
+     */
+    private sortRequests;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { HCS10Client } from '../hcs10/HCS10Client';
+import { IStateManager } from '../state/open-convai-state';
+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"]>;
+        requestId: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        action: "list" | "view" | "reject";
+        requestId?: number | undefined;
+    }, {
+        action: "list" | "view" | "reject";
+        requestId?: number | undefined;
+    }>;
+    private hcsClient;
+    private stateManager;
+    private logger;
+    private lastRefreshTime;
+    private refreshIntervalMs;
+    constructor({ hcsClient, stateManager, ...rest }: ManageConnectionRequestsToolParams);
+    protected _call({ action, requestId, }: z.infer<this['schema']>): Promise<string>;
+    private refreshRequestsIfNeeded;
+    private refreshRequests;
+    private listRequests;
+    private viewRequest;
+    private rejectRequest;
+    private extractAccountId;
+}