@hashgraphonline/standards-agent-kit 0.0.1 → 0.0.4

package/dist/src/demo-state.d.ts

@@ -0,0 +1,31 @@
+export interface RegisteredAgent {
+    name: string;
+    accountId: string;
+    inboundTopicId: string;
+    outboundTopicId: string;
+    profileTopicId?: string;
+}
+export interface ActiveConnection {
+    targetAccountId: string;
+    targetAgentName: string;
+    targetInboundTopicId: string;
+    connectionTopicId: string;
+}
+/**
+ * Holds the shared state for the interactive demo.
+ * Tools will need access to this instance to read/update state.
+ */
+export declare class DemoState {
+    currentAgent: RegisteredAgent | null;
+    activeConnections: ActiveConnection[];
+    connectionMessageTimestamps: {
+        [connectionTopicId: string]: number;
+    };
+    setCurrentAgent(agent: RegisteredAgent | null): void;
+    getCurrentAgent(): RegisteredAgent | null;
+    addActiveConnection(connection: ActiveConnection): void;
+    listConnections(): ActiveConnection[];
+    getConnectionByIdentifier(identifier: string): ActiveConnection | undefined;
+    getLastTimestamp(connectionTopicId: string): number;
+    updateTimestamp(connectionTopicId: string, timestampNanos: number): void;
+}

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

@@ -1,6 +1,6 @@
 import { TransactionReceipt, PrivateKey } from '@hashgraph/sdk';
-import { HCS10Client as StandardSDKClient } from '@hashgraphonline/standards-sdk';
-import { AgentMetadata, AgentChannels } from './types.js';
+import { HCS10Client as StandardSDKClient, AgentRegistrationResult, WaitForConnectionConfirmationResponse, ProfileResponse, HCSMessage } from '@hashgraphonline/standards-sdk';
+import { AgentMetadata, AgentChannels } from './types';
 export interface ExtendedAgentMetadata extends AgentMetadata {
     pfpBuffer?: Buffer;
     pfpFileName?: string;
@@ -8,7 +8,7 @@ export interface ExtendedAgentMetadata extends AgentMetadata {
 type StandardHandleConnectionRequest = InstanceType<typeof StandardSDKClient>['handleConnectionRequest'];
 type FeeConfigBuilderInterface = Parameters<StandardHandleConnectionRequest>[3];
 type HandleConnectionRequestResponse = Awaited<ReturnType<StandardHandleConnectionRequest>>;
-type StandardNetworkType = 'mainnet' | 'testnet';
+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.
@@ -16,9 +16,10 @@ type StandardNetworkType = 'mainnet' | 'testnet';
  * - Sends messages on Hedera topics (currently manual, potential for standard SDK integration).
  */
 export declare class HCS10Client {
-    private standardClient;
+    standardClient: StandardSDKClient;
     private useEncryption;
     agentChannels?: AgentChannels;
+    guardedRegistryBaseUrl: string;
     constructor(operatorId: string, operatorPrivateKey: string, network: StandardNetworkType, options?: {
         useEncryption?: boolean;
         registryUrl?: string;
@@ -29,23 +30,23 @@ export declare class HCS10Client {
     /**
      * Exposes the standard SDK's retrieveProfile method.
      */
-    retrieveProfile(accountId: string): Promise<any>;
+    retrieveProfile(accountId: string): Promise<ProfileResponse>;
     /**
      * Exposes the standard SDK's submitConnectionRequest method.
      */
-    submitConnectionRequest(inboundTopicId: string, requestingAccountId: string, operatorId: string, memo: string): Promise<TransactionReceipt>;
+    submitConnectionRequest(inboundTopicId: string, memo: string): Promise<TransactionReceipt>;
     /**
-    * Exposes the standard SDK's waitForConnectionConfirmation method.
-    */
+     * Exposes the standard SDK's waitForConnectionConfirmation method.
+     */
     waitForConnectionConfirmation(outboundTopicId: string, // Changed from inboundTopicId based on demo usage
-    connectionRequestId: number, maxAttempts?: number, delayMs?: number): Promise<any>;
+    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.
      * @returns The registration result from the standard SDK, containing accountId, keys, topics etc.
      */
-    createAndRegisterAgent(metadata: ExtendedAgentMetadata): Promise<any>;
+    createAndRegisterAgent(metadata: ExtendedAgentMetadata): Promise<AgentRegistrationResult>;
     /**
      * Sends a structured HCS-10 message to the specified topic using the standard SDK client.
      * Handles potential inscription for large messages.
@@ -57,7 +58,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, operatorId: string, data: string, memo?: string, submitKey?: PrivateKey): Promise<string>;
+    sendMessage(topicId: string, data: string, memo?: string, submitKey?: PrivateKey): Promise<string>;
     /**
      * Retrieves messages from a topic using the standard SDK client.
      *
@@ -71,11 +72,22 @@ export declare class HCS10Client {
             sequence_number: number;
         }>;
     }>;
+    getMessageStream(topicId: string): Promise<{
+        messages: HCSMessage[];
+    }>;
     /**
      * Retrieves content from an inscribed message using the standard SDK client.
      * @param inscriptionIdOrData - The inscription ID (hcs://...) or potentially raw data string.
      * @returns The resolved message content.
      */
     getMessageContent(inscriptionIdOrData: string): Promise<string>;
+    /**
+     * Retrieves the inbound topic ID associated with the current operator.
+     * This typically involves fetching the operator's own HCS-10 profile.
+     * @returns A promise that resolves to the operator's inbound topic ID.
+     * @throws {Error} If the operator ID cannot be determined or the profile/topic cannot be retrieved.
+     */
+    getInboundTopicId(): Promise<string>;
+    setClient(accountId: string, privateKey: string): StandardSDKClient;
 }
 export {};

package/dist/src/index.d.ts

@@ -1,16 +1,19 @@
-import { HCS10Client } from './hcs10/HCS10Client.js';
-import { RegisterAgentTool } from './tools/RegisterAgentTool.js';
-import { SendMessageTool } from './tools/SendMessageTool.js';
-import { ConnectionTool } from './tools/ConnectionTool.js';
+import { HCS10Client } from './hcs10/HCS10Client';
+import { RegisterAgentTool } from './tools/RegisterAgentTool';
+import { SendMessageTool } from './tools/SendMessageTool';
+import { ConnectionTool } from './tools/ConnectionTool';
+import { DemoState } from './demo-state';
+export interface HCS10InitializationOptions {
+    useEncryption?: boolean;
+    registryUrl?: string;
+    demoState?: DemoState;
+}
 /**
  * Initializes the HCS10 client and returns pre-registered LangChain tools.
  *
- * @param options - Optional settings such as useEncryption flag and registryUrl.
+ * @param options - Optional settings including useEncryption, registryUrl, and demoState.
  */
-export declare function initializeHCS10Client(options?: {
-    useEncryption?: boolean;
-    registryUrl?: string;
-}): Promise<{
+export declare function initializeHCS10Client(options?: HCS10InitializationOptions): Promise<{
     hcs10Client: HCS10Client;
     tools: {
         registerAgentTool: RegisterAgentTool;
@@ -18,7 +21,7 @@ export declare function initializeHCS10Client(options?: {
         connectionTool: ConnectionTool;
     };
 }>;
-export * from './hcs10/HCS10Client.js';
-export * from './tools/RegisterAgentTool.js';
-export * from './tools/SendMessageTool.js';
-export * from './tools/ConnectionTool.js';
+export * from './hcs10/HCS10Client';
+export * from './tools/RegisterAgentTool';
+export * from './tools/SendMessageTool';
+export * from './tools/ConnectionTool';

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

@@ -0,0 +1,27 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { HCS10Client } from '../hcs10/HCS10Client';
+import { DemoState } from '../demo-state';
+export interface CheckMessagesToolParams extends ToolParams {
+    hcsClient: HCS10Client;
+    demoState: DemoState;
+}
+/**
+ * A tool to check for new messages on an active HCS-10 connection topic.
+ */
+export declare class CheckMessagesTool extends StructuredTool {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        targetIdentifier: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        targetIdentifier: string;
+    }, {
+        targetIdentifier: string;
+    }>;
+    private hcsClient;
+    private demoState;
+    private logger;
+    constructor({ hcsClient, demoState, ...rest }: CheckMessagesToolParams);
+    protected _call({ targetIdentifier }: z.infer<this['schema']>): Promise<string>;
+}

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

@@ -1,30 +1,34 @@
-import { HCS10Client } from '../hcs10/HCS10Client.js';
-import { StructuredTool } from '@langchain/core/tools';
+import { HCS10Client } from '../hcs10/HCS10Client';
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
+import { DemoState } from '../demo-state';
+export interface ConnectionToolParams extends ToolParams {
+    client: HCS10Client;
+    demoState: DemoState;
+}
 /**
- * ConnectionTool monitors an agent's inbound topic for connection requests
+ * 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;
     private client;
     private logger;
+    private demoState;
     private isMonitoring;
     private monitoringTopic;
-    schema: z.ZodObject<{
-        inboundTopicId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        inboundTopicId: string;
-    }, {
-        inboundTopicId: string;
-    }>;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
     /**
-     * @param client - Instance of HCS10Client (already configured with operator/network).
+     * @param client - Instance of HCS10Client.
+     * @param demoState - Instance of DemoState for shared state management.
      */
-    constructor(client: HCS10Client);
+    constructor({ client, demoState, ...rest }: ConnectionToolParams);
     /**
      * Initiates the connection request monitoring process in the background.
+     * Gets the inbound topic ID from the configured client.
      */
     _call(input: z.infer<typeof this.schema>): Promise<string>;
     /**

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

@@ -0,0 +1,30 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { HCS10Client } from '../hcs10/HCS10Client';
+import { DemoState } from '../demo-state';
+export interface InitiateConnectionToolParams extends ToolParams {
+    hcsClient: HCS10Client;
+    demoState: DemoState;
+}
+/**
+ * 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.
+ * 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 demoState;
+    private logger;
+    constructor({ hcsClient, demoState, ...rest }: InitiateConnectionToolParams);
+    protected _call({ targetAccountId, }: z.infer<this['schema']>): Promise<string>;
+}

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

@@ -0,0 +1,17 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { DemoState } from '../demo-state';
+export interface ListConnectionsToolParams extends ToolParams {
+    demoState: DemoState;
+}
+/**
+ * A tool to list currently active HCS-10 connections stored in the DemoState.
+ */
+export declare class ListConnectionsTool extends StructuredTool {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    private demoState;
+    constructor({ demoState, ...rest }: ListConnectionsToolParams);
+    protected _call(_: z.infer<this['schema']>): Promise<string>;
+}

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

@@ -1,9 +1,10 @@
-import { HCS10Client } from '../hcs10/HCS10Client.js';
+import { HCS10Client } from '../hcs10/HCS10Client';
 import { StructuredTool } from '@langchain/core/tools';
 import { z } from 'zod';
 /**
  * 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;
@@ -31,6 +32,7 @@ export declare class RegisterAgentTool extends StructuredTool {
     constructor(client: HCS10Client);
     /**
      * 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>;
 }

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

@@ -0,0 +1,30 @@
+import { StructuredTool, ToolParams } from '@langchain/core/tools';
+import { z } from 'zod';
+import { HCS10Client } from '../hcs10/HCS10Client';
+import { DemoState } from '../demo-state';
+export interface SendMessageToConnectionToolParams extends ToolParams {
+    hcsClient: HCS10Client;
+    demoState: DemoState;
+}
+/**
+ * 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;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        targetIdentifier: string;
+    }, {
+        message: string;
+        targetIdentifier: string;
+    }>;
+    private hcsClient;
+    private demoState;
+    private logger;
+    constructor({ hcsClient, demoState, ...rest }: SendMessageToConnectionToolParams);
+    protected _call({ targetIdentifier, message, }: z.infer<this['schema']>): Promise<string>;
+}

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

@@ -1,4 +1,4 @@
-import { HCS10Client } from '../hcs10/HCS10Client.js';
+import { HCS10Client } from '../hcs10/HCS10Client';
 import { StructuredTool } from '@langchain/core/tools';
 import { z } from 'zod';
 /**

package/dist/src/utils/HederaClient.d.ts

@@ -1,5 +1,5 @@
 import { Client } from '@hashgraph/sdk';
-import { HCS10Message } from '../hcs10/types.js';
+import { HCS10Message } from '../hcs10/types';
 /**
  * Creates and returns a Hedera Client based on environment variables.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hashgraphonline/standards-agent-kit",
-  "version": "0.0.1",
-  "description": "An Agent Kit which implements Hashgraph OnlineStandards",
+  "version": "0.0.4",
+  "description": "An Agents implementation of Hashgraph Online's Standards SDK",
   "type": "module",
   "main": "./dist/index.es.js",
   "types": "dist/index.d.ts",
@@ -12,11 +12,13 @@
     "build": "vite build",
     "test": "jest",
     "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
     "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "release": "npm publish --access public",
     "cli-demo": "tsx examples/cli-demo.ts",
     "interactive-demo": "tsx examples/interactive-demo.ts",
-    "langchain-demo": "tsx examples/langchain-demo.ts",
-    "release": "npm publish --access public"
+    "langchain-demo": "tsx examples/langchain-demo.js"
   },
   "keywords": [
     "hedera",
@@ -25,11 +27,11 @@
     "sdk",
     "ai-agent"
   ],
-  "author": "Your Name",
+  "author": "Hashgraph Online",
   "license": "Apache-2.0",
   "dependencies": {
     "@hashgraph/sdk": "^2.39.0",
-    "@hashgraphonline/standards-sdk": "^0.0.50",
+    "@hashgraphonline/standards-sdk": "0.0.61",
     "@langchain/community": "^0.3.37",
     "@langchain/openai": "^0.5.1",
     "dotenv": "^16.4.1",
@@ -45,7 +47,8 @@
     "@typescript-eslint/parser": "^6.20.0",
     "eslint": "^8.56.0",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
+    "@swc/core": "^1.11.16",
+    "@swc/jest": "^0.2.36",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
     "tsx": "^4.19.3",

package/dist/tests/tools/Tools.test.d.ts

@@ -1 +0,0 @@
-export {};