@hashgraphonline/standards-agent-kit 0.0.37 → 0.2.0

package/dist/es/standards-agent-kit.es3.js

@@ -1,394 +1,332 @@
-import { Logger, AIAgentCapability, FeeConfigBuilder } from "@hashgraphonline/standards-sdk";
-import { ensureAgentHasEnoughHbar } from "./standards-agent-kit.es26.js";
-import { StructuredTool } from "@langchain/core/tools";
-import { z } from "zod";
-import fs__default from "fs";
-import path__default from "path";
-import axios from "axios";
-class RegisterAgentTool extends StructuredTool {
-  /**
-   * 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, stateManager) {
-    super();
-    this.name = "register_agent";
-    this.description = "Creates and registers the AI agent on the Hedera network. Returns JSON string with agent details (accountId, privateKey, topics) on success. Optionally supports fee configuration for the agent's inbound topic using HBAR or specific tokens.";
-    this.schema = z.object({
-      name: z.string().describe("The name of the agent to register"),
-      description: z.string().optional().describe("Optional description of the agent"),
-      type: z.enum(["autonomous", "manual"]).optional().describe("Optional agent type (default: autonomous)"),
-      model: z.string().optional().describe("Optional model identifier for the agent"),
-      capabilities: z.array(z.number()).optional().describe(
-        "Optional array of AIAgentCapability enum values (0-18). If not provided, defaults to just TEXT_GENERATION (0)"
-      ),
-      profilePicture: z.union([
-        z.string().describe("Path to a local image file or URL to an image"),
-        z.object({
-          url: z.string().describe("URL to an image file"),
-          filename: z.string().describe("Filename to use for the image")
-        }),
-        z.object({
-          path: z.string().describe("Path to a local image file"),
-          filename: z.string().optional().describe("Optional custom filename")
-        })
-      ]).optional().describe(
-        "Optional profile picture for the agent (local file path or URL)"
-      ),
-      feeCollectorAccountId: z.string().optional().describe(
-        "The account ID to collect fees. If not specified, the new agent's account ID will be used. Required if any fee is specified."
-      ),
-      hbarFee: z.number().optional().describe(
-        "Optional: The fee amount in HBAR to charge per message on the inbound topic (e.g., 0.5). If specified, inboundTopicType will be set to FEE_BASED."
-      ),
-      tokenFee: z.object({
-        amount: z.number(),
-        tokenId: z.string()
-      }).optional().describe(
-        'Optional: The fee amount and token ID to charge per message on the inbound topic (e.g., { amount: 10, tokenId: "0.0.12345" }). If specified, inboundTopicType will be set to FEE_BASED.'
-      ),
-      hbarFees: z.array(
-        z.object({
-          amount: z.number(),
-          collectorAccount: z.string().optional()
-        })
-      ).optional().describe(
-        "Optional: Array of HBAR fees with different collectors. If specified, inboundTopicType will be set to FEE_BASED."
-      ),
-      tokenFees: z.array(
-        z.object({
-          amount: z.number(),
-          tokenId: z.string(),
-          collectorAccount: z.string().optional()
-        })
-      ).optional().describe(
-        "Optional: Array of token fees with different collectors. If specified, inboundTopicType will be set to FEE_BASED."
-      ),
-      exemptAccountIds: z.array(z.string()).optional().describe(
-        "Optional: Array of account IDs to exempt from ALL fees set for this agent."
-      ),
-      setAsCurrent: z.boolean().optional().describe(
-        "Optional: Whether to set the newly registered agent as the current active agent in the state manager. Default: true"
-      ),
-      persistence: z.object({
-        prefix: z.string().optional()
-      }).optional().describe(
-        "Optional: Configuration for persisting agent data to environment variables. The prefix will determine the environment variable names (e.g., PREFIX_ACCOUNT_ID). Defaults to TODD if not specified."
-      )
+import { HCS10Client as HCS10Client$1, Logger, AgentBuilder, AIAgentCapability, InboundTopicType } from "@hashgraphonline/standards-sdk";
+import { encryptMessage } from "./standards-agent-kit.es20.js";
+class HCS10Client {
+  constructor(operatorId, operatorPrivateKey, network, options) {
+    this.standardClient = new HCS10Client$1({
+      network,
+      operatorId,
+      operatorPrivateKey,
+      guardedRegistryBaseUrl: options?.registryUrl,
+      logLevel: options?.logLevel
     });
-    this.client = client;
-    this.stateManager = stateManager;
-  }
-  /**
-   * 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
-   */
-  async loadProfilePicture(profilePicture) {
-    const logger = Logger.getInstance({
-      level: "debug"
+    this.guardedRegistryBaseUrl = options?.registryUrl || "";
+    this.useEncryption = options?.useEncryption || false;
+    const shouldSilence = process.env.DISABLE_LOGGING === "true";
+    this.logger = new Logger({
+      level: options?.logLevel || "info",
+      silent: shouldSilence
     });
+  }
+  getOperatorId() {
+    const operator = this.standardClient.getClient().operatorAccountId;
+    if (!operator) {
+      throw new Error("Operator Account ID not configured in standard client.");
+    }
+    return operator.toString();
+  }
+  getNetwork() {
+    return this.standardClient.getNetwork();
+  }
+  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionRequestId, feeConfig) {
     try {
-      if (!profilePicture) {
-        return null;
-      }
-      if (typeof profilePicture === "string") {
-        const isUrl = profilePicture.startsWith("http://") || profilePicture.startsWith("https://");
-        if (isUrl) {
-          logger.info(`Loading profile picture from URL: ${profilePicture}`);
-          const response = await axios.get(profilePicture, {
-            responseType: "arraybuffer"
-          });
-          const buffer = Buffer.from(response.data);
-          const urlPathname = new URL(profilePicture).pathname;
-          const filename = path__default.basename(urlPathname) || "profile.png";
-          return { buffer, filename };
-        } else {
-          if (!fs__default.existsSync(profilePicture)) {
-            logger.warn(`Profile picture file not found: ${profilePicture}`);
-            return null;
-          }
-          logger.info(`Loading profile picture from file: ${profilePicture}`);
-          const buffer = fs__default.readFileSync(profilePicture);
-          const filename = path__default.basename(profilePicture);
-          return { buffer, filename };
-        }
-      }
-      if ("url" in profilePicture) {
-        logger.info(`Loading profile picture from URL: ${profilePicture.url}`);
-        const response = await axios.get(profilePicture.url, {
-          responseType: "arraybuffer"
-        });
-        const buffer = Buffer.from(response.data);
-        const filename = profilePicture.filename || "profile.png";
-        return { buffer, filename };
-      }
-      if ("path" in profilePicture) {
-        if (!fs__default.existsSync(profilePicture.path)) {
-          logger.warn(`Profile picture file not found: ${profilePicture.path}`);
-          return null;
-        }
-        logger.info(
-          `Loading profile picture from file: ${profilePicture.path}`
-        );
-        const buffer = fs__default.readFileSync(profilePicture.path);
-        const filename = profilePicture.filename || path__default.basename(profilePicture.path);
-        return { buffer, filename };
-      }
-      return null;
+      const result = await this.standardClient.handleConnectionRequest(
+        inboundTopicId,
+        requestingAccountId,
+        connectionRequestId,
+        feeConfig
+      );
+      return result;
     } catch (error) {
-      logger.error("Failed to load profile picture:", error);
-      return null;
+      this.logger.error(
+        `Error handling connection request #${connectionRequestId} for topic ${inboundTopicId}:`,
+        error
+      );
+      throw new Error(
+        `Failed to handle connection request: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
-   * Calls createAndRegisterAgent() with the provided metadata.
-   * Returns a JSON string with agent details on success, or an error string.
+   * Retrieves the profile for a given account ID using the standard SDK.
    */
-  async _call(input) {
-    const logger = Logger.getInstance({
-      level: "debug"
-    });
-    const metadata = {
-      name: input.name,
-      description: input.description,
-      type: input.type,
-      model: input.model,
-      capabilities: input.capabilities || [AIAgentCapability.TEXT_GENERATION],
-      properties: {}
-    };
-    let profilePictureSource = "";
-    if (input.profilePicture) {
-      const profilePictureData = await this.loadProfilePicture(
-        input.profilePicture
-      );
-      if (profilePictureData) {
-        const { buffer, filename } = profilePictureData;
-        metadata.pfpBuffer = buffer;
-        metadata.pfpFileName = filename;
-        if (typeof input.profilePicture === "string") {
-          profilePictureSource = input.profilePicture;
-        } else if ("url" in input.profilePicture) {
-          profilePictureSource = input.profilePicture.url;
-        } else if ("path" in input.profilePicture) {
-          profilePictureSource = input.profilePicture.path;
-        }
-      }
+  async getAgentProfile(accountId) {
+    return this.standardClient.retrieveProfile(accountId);
+  }
+  /**
+   * Exposes the standard SDK's submitConnectionRequest method.
+   */
+  async submitConnectionRequest(inboundTopicId, memo) {
+    return this.standardClient.submitConnectionRequest(
+      inboundTopicId,
+      memo
+    );
+  }
+  /**
+   * Exposes the standard SDK's waitForConnectionConfirmation method.
+   */
+  async waitForConnectionConfirmation(outboundTopicId, connectionRequestId, maxAttempts = 60, delayMs = 2e3) {
+    return this.standardClient.waitForConnectionConfirmation(
+      outboundTopicId,
+      connectionRequestId,
+      maxAttempts,
+      delayMs
+    );
+  }
+  /**
+   * Creates and registers an agent using the standard SDK's HCS10Client.
+   * This handles account creation, key generation, topic setup, and registration.
+   *
+   * 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.
+   */
+  async createAndRegisterAgent(metadata) {
+    const builder = new AgentBuilder().setName(metadata.name).setBio(metadata.description || "").setCapabilities(
+      metadata.capabilities ? metadata.capabilities : [AIAgentCapability.TEXT_GENERATION]
+    ).setType(metadata.type || "autonomous").setModel(metadata.model || "agent-model-2024").setNetwork(this.getNetwork()).setInboundTopicType(InboundTopicType.PUBLIC);
+    if (metadata?.feeConfig) {
+      builder.setInboundTopicType(InboundTopicType.FEE_BASED);
+      builder.setFeeConfig(metadata.feeConfig);
     }
-    const hasHbarFee = input.hbarFee !== void 0 && input.hbarFee > 0;
-    const hasTokenFee = this.hasValidTokenFee(input.tokenFee);
-    const hasHbarFees = input.hbarFees && input.hbarFees.length > 0;
-    const hasTokenFees = input.tokenFees && input.tokenFees.length > 0;
-    if (hasHbarFee || hasTokenFee || hasHbarFees || hasTokenFees) {
-      const { accountId: operatorAccountId } = this.client.getAccountAndSigner();
-      const collectorId = input.feeCollectorAccountId || operatorAccountId;
-      if (!collectorId) {
-        return "Error: Fee collector account ID is required when specifying fees and could not be determined.";
+    if (metadata.pfpBuffer && metadata.pfpFileName) {
+      if (metadata.pfpBuffer.byteLength === 0) {
+        this.logger.warn(
+          "Provided PFP buffer is empty. Skipping profile picture."
+        );
+      } else {
+        this.logger.info(
+          `Setting profile picture: ${metadata.pfpFileName} (${metadata.pfpBuffer.byteLength} bytes)`
+        );
+        builder.setProfilePicture(metadata.pfpBuffer, metadata.pfpFileName);
       }
-      const feeConfigBuilder = new FeeConfigBuilder({
-        network: this.client.getNetwork(),
-        logger
+    } else {
+      this.logger.warn(
+        "Profile picture not provided in metadata. Agent creation might fail if required by the underlying SDK builder."
+      );
+    }
+    if (metadata.social) {
+      Object.entries(metadata.social).forEach(([platform, handle]) => {
+        builder.addSocial(platform, handle);
+      });
+    }
+    if (metadata.properties) {
+      Object.entries(metadata.properties).forEach(([key, value]) => {
+        builder.addProperty(key, value);
       });
-      try {
-        const exemptAccountIds = input.exemptAccountIds?.filter(
-          (id) => id !== collectorId && id.startsWith("0.0")
-        ) || [];
-        let updatedFeeConfig = feeConfigBuilder;
-        if (hasHbarFee) {
-          logger.info(
-            `Adding HBAR fee: ${input.hbarFee} HBAR to be collected by ${collectorId}`
-          );
-          updatedFeeConfig = updatedFeeConfig.addHbarFee(
-            input.hbarFee,
-            collectorId,
-            exemptAccountIds
-          );
-        }
-        if (hasHbarFees) {
-          for (const fee of input.hbarFees) {
-            const feeCollector = fee.collectorAccount || collectorId;
-            logger.info(
-              `Adding HBAR fee: ${fee.amount} HBAR to be collected by ${feeCollector}`
-            );
-            updatedFeeConfig = updatedFeeConfig.addHbarFee(
-              fee.amount,
-              feeCollector,
-              exemptAccountIds
-            );
-          }
-        }
-        if (hasTokenFee) {
-          logger.info(
-            `Adding token fee: ${input.tokenFee.amount} of token ${input.tokenFee.tokenId} to be collected by ${collectorId}`
-          );
-          updatedFeeConfig = await updatedFeeConfig.addTokenFee(
-            input.tokenFee.amount,
-            input.tokenFee.tokenId,
-            collectorId,
-            void 0,
-            exemptAccountIds
-          );
-        }
-        if (hasTokenFees) {
-          for (const fee of input.tokenFees) {
-            const feeCollector = fee.collectorAccount || collectorId;
-            logger.info(
-              `Adding token fee: ${fee.amount} of token ${fee.tokenId} to be collected by ${feeCollector}`
-            );
-            updatedFeeConfig = await updatedFeeConfig.addTokenFee(
-              fee.amount,
-              fee.tokenId,
-              feeCollector,
-              void 0,
-              exemptAccountIds
-            );
-          }
-        }
-        metadata.feeConfig = updatedFeeConfig;
-        logger.info("FeeConfigBuilder created successfully");
-      } catch (error) {
-        return `Error: Failed to configure fees. Reason: ${error instanceof Error ? error.message : String(error)}`;
-      }
     }
     try {
-      logger.info("Registering agent with metadata");
-      const result = await this.client.createAndRegisterAgent(
-        metadata
+      const hasFees = Boolean(metadata?.feeConfig);
+      const result = await this.standardClient.createAndRegisterAgent(builder, {
+        initialBalance: hasFees ? 50 : void 0
+      });
+      if (result?.metadata?.inboundTopicId && result?.metadata?.outboundTopicId) {
+        this.agentChannels = {
+          inboundTopicId: result.metadata.inboundTopicId,
+          outboundTopicId: result.metadata.outboundTopicId
+        };
+      }
+      return result;
+    } catch (error) {
+      this.logger.error("Error during agent creation/registration:", error);
+      throw new Error(
+        `Failed to create/register agent: ${error instanceof Error ? error.message : String(error)}`
       );
-      return this.processRegistrationResult(
-        result,
-        input,
-        profilePictureSource
+    }
+  }
+  /**
+   * Sends a structured HCS-10 message to the specified topic using the standard SDK client.
+   * Handles potential inscription for large messages.
+   *
+   * @param topicId - The target topic ID (likely a connection topic).
+   * @param operatorId - The operator ID string (e.g., "inboundTopic@accountId").
+   * @param data - The actual message content/data.
+   * @param memo - Optional memo for the message.
+   * @param submitKey - Optional private key for topics requiring specific submit keys.
+   * @returns A confirmation status string from the transaction receipt.
+   */
+  async sendMessage(topicId, data, memo, submitKey) {
+    if (this.useEncryption) {
+      data = encryptMessage(data);
+    }
+    try {
+      const messageResponse = await this.standardClient.sendMessage(
+        topicId,
+        data,
+        memo,
+        submitKey
       );
+      return messageResponse.topicSequenceNumber?.toNumber();
     } catch (error) {
-      return `Error: Failed to create/register agent "${input.name}". Reason: ${error instanceof Error ? error.message : String(error)}`;
+      this.logger.error(`Error sending message to topic ${topicId}:`, error);
+      throw new Error(
+        `Failed to send message: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
-   * Checks if the token fee configuration is valid
+   * Retrieves messages from a topic using the standard SDK client.
+   *
+   * @param topicId - The topic ID to get messages from.
+   * @returns Messages from the topic, mapped to the expected format.
    */
-  hasValidTokenFee(tokenFee) {
-    return !!(tokenFee && tokenFee.amount > 0 && tokenFee.tokenId && tokenFee.tokenId.trim() !== "");
+  async getMessages(topicId) {
+    try {
+      const result = await this.standardClient.getMessages(topicId);
+      const mappedMessages = result.messages.map((sdkMessage) => {
+        const timestamp = sdkMessage?.created?.getTime() || 0;
+        return {
+          ...sdkMessage,
+          timestamp,
+          data: sdkMessage.data,
+          sequence_number: sdkMessage.sequence_number
+        };
+      });
+      mappedMessages.sort(
+        (a, b) => a.timestamp - b.timestamp
+      );
+      return { messages: mappedMessages };
+    } catch (error) {
+      this.logger.error(`Error getting messages from topic ${topicId}:`, error);
+      return { messages: [] };
+    }
+  }
+  async getMessageStream(topicId) {
+    const result = this.standardClient.getMessageStream(topicId);
+    return result;
   }
   /**
-   * Processes the registration result and returns formatted output
+   * 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.
    */
-  async processRegistrationResult(result, input, profilePictureSource = "") {
-    const newAgentAccountId = result?.metadata?.accountId || "";
-    const inboundTopicId = result?.metadata?.inboundTopicId || "";
-    const outboundTopicId = result?.metadata?.outboundTopicId || "";
-    const profileTopicId = result?.metadata?.profileTopicId || "";
-    const privateKey = result?.metadata?.privateKey || "";
-    const pfpTopicId = result?.metadata?.pfpTopicId;
-    this.validateRegistrationResult(
-      newAgentAccountId,
-      inboundTopicId,
-      outboundTopicId,
-      privateKey
-    );
-    if (this.stateManager && privateKey && newAgentAccountId && inboundTopicId && outboundTopicId && (input.setAsCurrent === void 0 || input.setAsCurrent)) {
-      const agent = {
-        name: input.name,
-        accountId: newAgentAccountId,
-        inboundTopicId,
-        outboundTopicId,
-        profileTopicId,
-        privateKey,
-        pfpTopicId
-      };
-      this.stateManager.setCurrentAgent(agent);
-      if (this.stateManager.persistAgentData && input.persistence) {
-        try {
-          const persistenceOptions = {
-            type: "env-file",
-            prefix: input.persistence.prefix
-          };
-          await this.stateManager.persistAgentData(agent, persistenceOptions);
-        } catch (error) {
-          Logger.getInstance().warn("Failed to persist agent data", error);
-        }
-      }
-    }
-    await this.ensureAgentHasFunds(newAgentAccountId, input.name);
-    const feeDescription = this.createFeeDescription(input);
-    const feeMessage = feeDescription ? ` with ${feeDescription} fee on inbound topic` : "";
-    const registrationDetails = {
-      success: true,
-      message: `Successfully registered agent '${input.name}'${feeMessage}.`,
-      name: input.name,
-      accountId: newAgentAccountId,
-      privateKey,
-      inboundTopicId,
-      outboundTopicId,
-      profileTopicId: profileTopicId || "N/A",
-      capabilities: input.capabilities || [AIAgentCapability.TEXT_GENERATION],
-      hasFees: !!(input.hbarFee || this.hasValidTokenFee(input.tokenFee)),
-      hbarFee: input.hbarFee || 0,
-      tokenFee: input.tokenFee || null
-    };
-    if (pfpTopicId || profilePictureSource) {
-      registrationDetails.profilePicture = {
-        source: profilePictureSource,
-        topicId: pfpTopicId
-      };
+  async getMessageContent(inscriptionIdOrData) {
+    try {
+      const content = await this.standardClient.getMessageContent(
+        inscriptionIdOrData
+      );
+      return content;
+    } catch (error) {
+      this.logger.error(
+        `Error retrieving message content for: ${inscriptionIdOrData}`,
+        error
+      );
+      throw new Error(
+        `Failed to retrieve message content: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
-    return JSON.stringify(registrationDetails);
   }
   /**
-   * Ensures the agent has enough HBAR for operations
+   * 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.
    */
-  async ensureAgentHasFunds(accountId, agentName) {
+  async getInboundTopicId() {
     try {
-      await ensureAgentHasEnoughHbar(
-        Logger.getInstance({
-          module: "RegisterAgentTool"
-        }),
-        this.client.standardClient,
-        accountId,
-        agentName
+      const operatorId = this.getOperatorId();
+      this.logger.info(
+        `[HCS10Client] Retrieving profile for operator ${operatorId} to find inbound topic...`
       );
+      const profileResponse = await this.getAgentProfile(operatorId);
+      if (profileResponse.success && profileResponse.topicInfo?.inboundTopic) {
+        this.logger.info(
+          `[HCS10Client] Found inbound topic for operator ${operatorId}: ${profileResponse.topicInfo.inboundTopic}`
+        );
+        return profileResponse.topicInfo.inboundTopic;
+      } else {
+        throw new Error(
+          `Could not retrieve inbound topic from profile for ${operatorId}. Profile success: ${profileResponse.success}, Error: ${profileResponse.error}`
+        );
+      }
     } catch (error) {
-      Logger.getInstance().error("Failed to auto fund agent", error);
+      this.logger.error(
+        `[HCS10Client] Error fetching operator's inbound topic ID (${this.getOperatorId()}):`,
+        error
+      );
+      const operatorId = this.getOperatorId();
+      let detailedMessage = `Failed to get inbound topic ID for operator ${operatorId}.`;
+      if (error instanceof Error && error.message.includes("does not have a valid HCS-11 memo")) {
+        detailedMessage += ` The account profile may not exist or is invalid. Please ensure this operator account (${operatorId}) is registered as an HCS-10 agent. You might need to register it first (e.g., using the 'register_agent' tool or SDK function).`;
+      } else if (error instanceof Error) {
+        detailedMessage += ` Reason: ${error.message}`;
+      } else {
+        detailedMessage += ` Unexpected error: ${String(error)}`;
+      }
+      throw new Error(detailedMessage);
     }
   }
   /**
-   * Validates that all required fields are present in the registration result
+   * Retrieves the configured operator account ID and private key.
+   * Required by tools needing to identify the current agent instance.
+   */
+  getAccountAndSigner() {
+    const result = this.standardClient.getAccountAndSigner();
+    return {
+      accountId: result.accountId,
+      signer: result.signer
+    };
+  }
+  /**
+   * 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.
    */
-  validateRegistrationResult(accountId, inboundTopicId, outboundTopicId, privateKey) {
-    if (!accountId || !inboundTopicId || !outboundTopicId || !privateKey) {
-      const missingFields = [
-        !accountId && "accountId",
-        !inboundTopicId && "inboundTopicId",
-        !outboundTopicId && "outboundTopicId",
-        !privateKey && "privateKey"
-      ].filter(Boolean).join(", ");
+  async getOutboundTopicId() {
+    const operatorId = this.getOperatorId();
+    const profile = await this.getAgentProfile(operatorId);
+    if (profile.success && profile.topicInfo?.outboundTopic) {
+      return profile.topicInfo.outboundTopic;
+    } else {
       throw new Error(
-        `Registration failed. The HCS client returned incomplete details (Missing: ${missingFields}).`
+        `Could not retrieve outbound topic from profile for ${operatorId}. Profile success: ${profile.success}, Error: ${profile.error}`
       );
     }
   }
+  setClient(accountId, privateKey) {
+    this.standardClient = new HCS10Client$1({
+      network: this.getNetwork(),
+      operatorId: accountId,
+      operatorPrivateKey: privateKey,
+      guardedRegistryBaseUrl: this.guardedRegistryBaseUrl
+    });
+    return this.standardClient;
+  }
   /**
-   * Creates a description of the fees configured for the agent
+   * Validates that the operator account exists and has proper access for agent operations
    */
-  createFeeDescription(input) {
-    const hasHbarFee = input.hbarFee && input.hbarFee > 0;
-    const hasTokenFee = this.hasValidTokenFee(input.tokenFee);
-    if (!hasHbarFee && !hasTokenFee) {
-      return "";
-    }
-    let description = "";
-    if (hasHbarFee) {
-      description += `${input.hbarFee} HBAR`;
+  async validateOperator(options) {
+    try {
+      this.setClient(options.accountId, options.privateKey);
+      const operatorId = this.getOperatorId();
+      return {
+        isValid: true,
+        operator: { accountId: operatorId }
+      };
+    } catch (error) {
+      this.logger.error(`Validation error: ${error}`);
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    if (hasTokenFee && input.tokenFee) {
-      const tokenFeeText = `${input.tokenFee.amount} of token ${input.tokenFee.tokenId}`;
-      description += description ? ` and ${tokenFeeText}` : tokenFeeText;
+  }
+  async initializeWithValidation(options) {
+    const validationResult = await this.validateOperator(options);
+    if (validationResult.isValid) {
+      if (options.stateManager) {
+        options.stateManager.initializeConnectionsManager(this.standardClient);
+      }
     }
-    return description;
+    return validationResult;
   }
 }
 export {
-  RegisterAgentTool
+  HCS10Client
 };
 //# sourceMappingURL=standards-agent-kit.es3.js.map