@hashgraphonline/standards-agent-kit 0.0.13 → 0.0.15

package/dist/src/index.d.ts

@@ -2,14 +2,3 @@ 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

@@ -1,23 +1,59 @@
-import { HCS10Client } from './hcs10/HCS10Client';
+import { HCS10Client, StandardNetworkType } 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 {
+import { IStateManager } from './state/state-types';
+import { FindRegistrationsTool } from './tools/FindRegistrationsTool';
+import { InitiateConnectionTool } from './tools/InitiateConnectionTool';
+import { ListConnectionsTool } from './tools/ListConnectionsTool';
+import { SendMessageToConnectionTool } from './tools/SendMessageToConnectionTool';
+import { CheckMessagesTool } from './tools/CheckMessagesTool';
+import { ConnectionMonitorTool } from './tools/ConnectionMonitorTool';
+import { ManageConnectionRequestsTool } from './tools/ManageConnectionRequestsTool';
+import { AcceptConnectionRequestTool } from './tools/AcceptConnectionRequestTool';
+import { RetrieveProfileTool } from './tools/RetrieveProfileTool';
+import { ListUnapprovedConnectionRequestsTool } from './tools/ListUnapprovedConnectionRequestsTool';
+export interface HCS10ClientConfig {
+    operatorId?: string;
+    operatorKey?: string;
+    network?: StandardNetworkType;
     useEncryption?: boolean;
     registryUrl?: string;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+}
+export interface HCS10InitializationOptions {
+    clientConfig?: HCS10ClientConfig;
     stateManager?: IStateManager;
+    createAllTools?: boolean;
+    monitoringClient?: boolean;
+}
+/**
+ * Tool collection containing all available tools from the standards-agent-kit
+ */
+export interface HCS10Tools {
+    registerAgentTool: RegisterAgentTool;
+    findRegistrationsTool: FindRegistrationsTool;
+    retrieveProfileTool: RetrieveProfileTool;
+    initiateConnectionTool: InitiateConnectionTool;
+    listConnectionsTool: ListConnectionsTool;
+    sendMessageToConnectionTool: SendMessageToConnectionTool;
+    checkMessagesTool: CheckMessagesTool;
+    sendMessageTool: SendMessageTool;
+    connectionTool: ConnectionTool;
+    connectionMonitorTool: ConnectionMonitorTool;
+    manageConnectionRequestsTool: ManageConnectionRequestsTool;
+    acceptConnectionRequestTool: AcceptConnectionRequestTool;
+    listUnapprovedConnectionRequestsTool: ListUnapprovedConnectionRequestsTool;
 }
 /**
  * Initializes the HCS10 client and returns pre-registered LangChain tools.
  *
- * @param options - Optional settings including useEncryption, registryUrl, and stateManager.
+ * @param options - Initialization options
+ * @returns Object containing hcs10Client and requested tools
  */
 export declare function initializeHCS10Client(options?: HCS10InitializationOptions): Promise<{
     hcs10Client: HCS10Client;
-    tools: {
-        registerAgentTool: RegisterAgentTool;
-        sendMessageTool: SendMessageTool;
-        connectionTool: ConnectionTool;
-    };
+    monitoringClient?: HCS10Client;
+    tools: Partial<HCS10Tools>;
+    stateManager: IStateManager;
 }>;

package/dist/src/state/index.d.ts

@@ -1 +1,2 @@
 export * from './open-convai-state';
+export * from './state-types';

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

@@ -1,100 +1,4 @@
-export interface RegisteredAgent {
-    name: string;
-    accountId: string;
-    inboundTopicId: string;
-    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;
-}
+import { RegisteredAgent, ActiveConnection, ConnectionRequestInfo, IStateManager, AgentPersistenceOptions } from './state-types';
 /**
  * Implementation of the IStateManager interface for the OpenConvai system.
  * Manages agent state and connection information with thread safety and
@@ -105,6 +9,16 @@ export declare class OpenConvaiState implements IStateManager {
     private activeConnections;
     private connectionMessageTimestamps;
     private connectionRequests;
+    private defaultEnvFilePath?;
+    private defaultPrefix;
+    /**
+     * Creates a new OpenConvaiState instance
+     * @param options - Options for environment variable persistence
+     */
+    constructor(options?: {
+        defaultEnvFilePath?: string;
+        defaultPrefix?: string;
+    });
     /**
      * Sets the current active agent and clears any previous connection data.
      * This should be called when switching between agents.
@@ -161,4 +75,10 @@ export declare class OpenConvaiState implements IStateManager {
     getConnectionRequestById(requestId: number): ConnectionRequestInfo | undefined;
     removeConnectionRequest(requestId: number): void;
     clearConnectionRequests(): void;
+    /**
+     * Persists agent data to environment variables
+     * @param agent - The agent data to persist
+     * @param options - Environment file persistence options
+     */
+    persistAgentData(agent: RegisteredAgent, options?: AgentPersistenceOptions): Promise<void>;
 }

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

@@ -0,0 +1,143 @@
+/**
+ * Basic registered agent information
+ */
+export interface RegisteredAgent {
+    name: string;
+    accountId: string;
+    inboundTopicId: string;
+    outboundTopicId: string;
+    profileTopicId?: string;
+    privateKey?: string;
+}
+/**
+ * Connection status types
+ */
+export type ConnectionStatus = 'established' | 'pending' | 'needs confirmation' | 'unknown';
+/**
+ * Basic agent profile information
+ */
+export interface AgentProfileInfo {
+    name?: string;
+    bio?: string;
+    avatar?: string;
+    type?: string;
+}
+/**
+ * Information about a connection request
+ */
+export interface ConnectionRequestInfo {
+    id: number;
+    requestorId: string;
+    requestorName: string;
+    timestamp: Date;
+    memo?: string;
+    profile?: AgentProfileInfo;
+}
+/**
+ * Information about an active connection
+ */
+export interface ActiveConnection {
+    targetAccountId: string;
+    targetAgentName: string;
+    targetInboundTopicId: string;
+    connectionTopicId: string;
+    status?: ConnectionStatus;
+    created?: Date;
+    lastActivity?: Date;
+    isPending?: boolean;
+    needsConfirmation?: boolean;
+    profileInfo?: AgentProfileInfo;
+}
+/**
+ * Options for environment variable persistence
+ */
+export interface EnvPersistenceOptions {
+    prefix?: string;
+    envFilePath?: string;
+}
+/**
+ * Base persistence options interface
+ */
+export interface PersistenceOptions {
+    type: string;
+}
+/**
+ * Environment file persistence options
+ */
+export interface EnvFilePersistenceOptions extends PersistenceOptions {
+    type: 'env-file';
+    prefix?: string;
+    envFilePath?: string;
+}
+/**
+ * Persistence options union type
+ */
+export type AgentPersistenceOptions = EnvFilePersistenceOptions;
+/**
+ * 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;
+    /**
+     * Persists agent data to storage
+     * Implementation may vary depending on the state manager
+     */
+    persistAgentData?(agent: RegisteredAgent, options?: AgentPersistenceOptions): Promise<void>;
+}

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

@@ -1,7 +1,7 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
 import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 export interface AcceptConnectionRequestToolParams extends ToolParams {
     hcsClient: HCS10Client;
     stateManager: IStateManager;

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

@@ -1,7 +1,7 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
 import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 export interface CheckMessagesToolParams extends ToolParams {
     hcsClient: HCS10Client;
     stateManager: IStateManager;

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

@@ -1,7 +1,7 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
 import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 export interface FeeDefinition {
     amount: number;
     collectorAccount?: string;

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

@@ -2,7 +2,7 @@ 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/open-convai-state';
+import { IStateManager } from '../state/state-types';
 export interface ConnectionToolParams extends ToolParams {
     client: HCS10Client;
     stateManager: IStateManager;

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

@@ -1,7 +1,7 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
 import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 export interface InitiateConnectionToolParams extends ToolParams {
     hcsClient: HCS10Client;
     stateManager: IStateManager;

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

@@ -1,6 +1,6 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 import { HCS10Client } from '../hcs10/HCS10Client';
 export interface ListConnectionsToolParams extends ToolParams {
     stateManager: IStateManager;

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

@@ -1,6 +1,6 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 import { HCS10Client } from '../hcs10/HCS10Client';
 type ListPendingRequestsToolParams = ToolParams & {
     hcsClient: HCS10Client;

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

@@ -1,7 +1,7 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
 import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 export interface ManageConnectionRequestsToolParams extends ToolParams {
     hcsClient: HCS10Client;
     stateManager: IStateManager;
@@ -31,7 +31,7 @@ export declare class ManageConnectionRequestsTool extends StructuredTool {
     constructor({ hcsClient, stateManager, ...rest }: ManageConnectionRequestsToolParams);
     protected _call({ action, requestId, }: z.infer<this['schema']>): Promise<string>;
     private refreshRequestsIfNeeded;
-    private refreshRequests;
+    refreshRequests(): Promise<void>;
     private listRequests;
     private viewRequest;
     private rejectRequest;

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

@@ -1,6 +1,7 @@
 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.
@@ -10,12 +11,32 @@ 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 | undefined;
+        }, {
+            path: string;
+            filename?: string | undefined;
+        }>]>>;
         feeCollectorAccountId: z.ZodOptional<z.ZodString>;
         hbarFee: z.ZodOptional<z.ZodNumber>;
         tokenFee: z.ZodOptional<z.ZodObject<{
@@ -52,12 +73,27 @@ export declare class RegisterAgentTool extends StructuredTool {
             collectorAccount?: string | undefined;
         }>, "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 | undefined;
+        }, {
+            prefix?: string | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         capabilities?: number[] | undefined;
         description?: string | undefined;
         type?: "autonomous" | "manual" | undefined;
         model?: string | undefined;
+        profilePicture?: string | {
+            url: string;
+            filename: string;
+        } | {
+            path: string;
+            filename?: string | undefined;
+        } | undefined;
         feeCollectorAccountId?: string | undefined;
         hbarFee?: number | undefined;
         tokenFee?: {
@@ -74,12 +110,23 @@ export declare class RegisterAgentTool extends StructuredTool {
             collectorAccount?: string | undefined;
         }[] | undefined;
         exemptAccountIds?: string[] | undefined;
+        setAsCurrent?: boolean | undefined;
+        persistence?: {
+            prefix?: string | undefined;
+        } | undefined;
     }, {
         name: string;
         capabilities?: number[] | undefined;
         description?: string | undefined;
         type?: "autonomous" | "manual" | undefined;
         model?: string | undefined;
+        profilePicture?: string | {
+            url: string;
+            filename: string;
+        } | {
+            path: string;
+            filename?: string | undefined;
+        } | undefined;
         feeCollectorAccountId?: string | undefined;
         hbarFee?: number | undefined;
         tokenFee?: {
@@ -96,12 +143,23 @@ export declare class RegisterAgentTool extends StructuredTool {
             collectorAccount?: string | undefined;
         }[] | undefined;
         exemptAccountIds?: string[] | undefined;
+        setAsCurrent?: boolean | undefined;
+        persistence?: {
+            prefix?: string | undefined;
+        } | undefined;
     }>;
     /**
      * 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);
+    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.
@@ -115,10 +173,6 @@ export declare class RegisterAgentTool extends StructuredTool {
      * Processes the registration result and returns formatted output
      */
     private processRegistrationResult;
-    /**
-     * Updates the environment file with the new agent details
-     */
-    private updateEnvironmentFile;
     /**
      * Ensures the agent has enough HBAR for operations
      */

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

@@ -0,0 +1,34 @@
+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 | undefined;
+        disableCache?: boolean | undefined;
+    }, {
+        accountId?: string | undefined;
+        disableCache?: boolean | undefined;
+    }>;
+    /**
+     * 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/src/tools/SendMessageToConnectionTool.d.ts

@@ -1,7 +1,7 @@
 import { StructuredTool, ToolParams } from '@langchain/core/tools';
 import { z } from 'zod';
 import { HCS10Client } from '../hcs10/HCS10Client';
-import { IStateManager } from '../state/open-convai-state';
+import { IStateManager } from '../state/state-types';
 export interface SendMessageToConnectionToolParams extends ToolParams {
     hcsClient: HCS10Client;
     stateManager: IStateManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraphonline/standards-agent-kit",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "A modular SDK for building on-chain autonomous agents using Hashgraph Online Standards, including HCS-10 for agent discovery and communication.",
   "type": "module",
   "main": "./dist/index.es.js",
@@ -68,7 +68,7 @@
   },
   "dependencies": {
     "@hashgraph/sdk": "^2.62.0",
-    "@hashgraphonline/standards-sdk": "0.0.72",
+    "@hashgraphonline/standards-sdk": "0.0.73",
     "@langchain/community": "^0.3.37",
     "@langchain/openai": "^0.5.1",
     "dotenv": "^16.4.1",