@hashgraphonline/standards-agent-kit 0.0.32 → 0.0.34

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

@@ -1,331 +1,394 @@
-import { HCS10Client as HCS10Client$1, Logger, AgentBuilder, AIAgentCapability, InboundTopicType } from "@hashgraphonline/standards-sdk";
-import { encryptMessage } from "./standards-agent-kit.es25.js";
-class HCS10Client {
-  constructor(operatorId, operatorPrivateKey, network, options) {
-    this.standardClient = new HCS10Client$1({
-      network,
-      operatorId,
-      operatorPrivateKey,
-      guardedRegistryBaseUrl: options?.registryUrl,
-      logLevel: options?.logLevel
-    });
-    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 {
-      const result = await this.standardClient.handleConnectionRequest(
-        inboundTopicId,
-        requestingAccountId,
-        connectionRequestId,
-        feeConfig
-      );
-      return result;
-    } catch (error) {
-      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)}`
-      );
-    }
-  }
-  /**
-   * Retrieves the profile for a given account ID using the standard SDK.
-   */
-  async getAgentProfile(accountId) {
-    return this.standardClient.retrieveProfile(accountId);
-  }
+import { Logger, AIAgentCapability, FeeConfigBuilder } from "@hashgraphonline/standards-sdk";
+import { ensureAgentHasEnoughHbar } from "./standards-agent-kit.es24.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 {
   /**
-   * Exposes the standard SDK's submitConnectionRequest method.
+   * Creates a new RegisterAgentTool instance
+   * @param client - Instance of HCS10Client (already configured with operator/network)
+   * @param stateManager - Optional state manager to store agent details
    */
-  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
-    );
+  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."
+      )
+    });
+    this.client = client;
+    this.stateManager = stateManager;
   }
   /**
-   * 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.
+   * 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 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);
-    }
-    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);
-      }
-    } 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);
-      });
-    }
+  async loadProfilePicture(profilePicture) {
+    const logger = Logger.getInstance({
+      level: "debug"
+    });
     try {
-      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
-        };
+      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 result;
+      return null;
     } 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)}`
-      );
+      logger.error("Failed to load profile picture:", error);
+      return null;
     }
   }
   /**
-   * 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.
+   * Calls createAndRegisterAgent() with the provided metadata.
+   * Returns a JSON string with agent details on success, or an error string.
    */
-  async sendMessage(topicId, data, memo, submitKey) {
-    if (this.useEncryption) {
-      data = encryptMessage(data);
+  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;
+        }
+      }
+    }
+    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.";
+      }
+      const feeConfigBuilder = new FeeConfigBuilder({
+        network: this.client.getNetwork(),
+        logger
+      });
+      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 {
-      const messageResponse = await this.standardClient.sendMessage(
-        topicId,
-        data,
-        memo,
-        submitKey
+      logger.info("Registering agent with metadata");
+      const result = await this.client.createAndRegisterAgent(
+        metadata
       );
-      return messageResponse.topicSequenceNumber?.toNumber();
-    } catch (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)}`
+      return this.processRegistrationResult(
+        result,
+        input,
+        profilePictureSource
       );
+    } catch (error) {
+      return `Error: Failed to create/register agent "${input.name}". Reason: ${error instanceof Error ? error.message : String(error)}`;
     }
   }
   /**
-   * 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.
+   * Checks if the token fee configuration is valid
    */
-  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) {
-    return this.standardClient.getMessageStream(topicId);
+  hasValidTokenFee(tokenFee) {
+    return !!(tokenFee && tokenFee.amount > 0 && tokenFee.tokenId && tokenFee.tokenId.trim() !== "");
   }
   /**
-   * 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.
+   * Processes the registration result and returns formatted output
    */
-  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)}`
-      );
+  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
+      };
     }
+    return JSON.stringify(registrationDetails);
   }
   /**
-   * 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.
+   * Ensures the agent has enough HBAR for operations
    */
-  async getInboundTopicId() {
+  async ensureAgentHasFunds(accountId, agentName) {
     try {
-      const operatorId = this.getOperatorId();
-      this.logger.info(
-        `[HCS10Client] Retrieving profile for operator ${operatorId} to find inbound topic...`
+      await ensureAgentHasEnoughHbar(
+        Logger.getInstance({
+          module: "RegisterAgentTool"
+        }),
+        this.client.standardClient,
+        accountId,
+        agentName
       );
-      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) {
-      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);
+      Logger.getInstance().error("Failed to auto fund agent", error);
     }
   }
   /**
-   * 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.
+   * Validates that all required fields are present in the registration result
    */
-  async getOutboundTopicId() {
-    const operatorId = this.getOperatorId();
-    const profile = await this.getAgentProfile(operatorId);
-    if (profile.success && profile.topicInfo?.outboundTopic) {
-      return profile.topicInfo.outboundTopic;
-    } else {
+  validateRegistrationResult(accountId, inboundTopicId, outboundTopicId, privateKey) {
+    if (!accountId || !inboundTopicId || !outboundTopicId || !privateKey) {
+      const missingFields = [
+        !accountId && "accountId",
+        !inboundTopicId && "inboundTopicId",
+        !outboundTopicId && "outboundTopicId",
+        !privateKey && "privateKey"
+      ].filter(Boolean).join(", ");
       throw new Error(
-        `Could not retrieve outbound topic from profile for ${operatorId}. Profile success: ${profile.success}, Error: ${profile.error}`
+        `Registration failed. The HCS client returned incomplete details (Missing: ${missingFields}).`
       );
     }
   }
-  setClient(accountId, privateKey) {
-    this.standardClient = new HCS10Client$1({
-      network: this.getNetwork(),
-      operatorId: accountId,
-      operatorPrivateKey: privateKey,
-      guardedRegistryBaseUrl: this.guardedRegistryBaseUrl
-    });
-    return this.standardClient;
-  }
   /**
-   * Validates that the operator account exists and has proper access for agent operations
+   * Creates a description of the fees configured for the agent
    */
-  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)
-      };
+  createFeeDescription(input) {
+    const hasHbarFee = input.hbarFee && input.hbarFee > 0;
+    const hasTokenFee = this.hasValidTokenFee(input.tokenFee);
+    if (!hasHbarFee && !hasTokenFee) {
+      return "";
     }
-  }
-  async initializeWithValidation(options) {
-    const validationResult = await this.validateOperator(options);
-    if (validationResult.isValid) {
-      if (options.stateManager) {
-        options.stateManager.initializeConnectionsManager(this.standardClient);
-      }
+    let description = "";
+    if (hasHbarFee) {
+      description += `${input.hbarFee} HBAR`;
+    }
+    if (hasTokenFee && input.tokenFee) {
+      const tokenFeeText = `${input.tokenFee.amount} of token ${input.tokenFee.tokenId}`;
+      description += description ? ` and ${tokenFeeText}` : tokenFeeText;
     }
-    return validationResult;
+    return description;
   }
 }
 export {
-  HCS10Client
+  RegisterAgentTool
 };
 //# sourceMappingURL=standards-agent-kit.es3.js.map