@hashgraphonline/standards-sdk 0.0.64 → 0.0.66

package/dist/es/standards-sdk.es10.js

@@ -1,1084 +1,152 @@
-import Buffer from "./standards-sdk.es19.js";
-import { KeyList, TopicCreateTransaction, Transaction, TopicMessageSubmitTransaction, Hbar } from "@hashgraph/sdk";
+import { InboundTopicType } from "./standards-sdk.es13.js";
 import { Logger } from "./standards-sdk.es14.js";
-import { InscriptionSDK } from "./standards-sdk.es22.js";
-import { HCS10BaseClient, Hcs10MemoType } from "./standards-sdk.es8.js";
-import { m as mimeTypesExports } from "./standards-sdk.es20.js";
-import { HCS11Client } from "./standards-sdk.es13.js";
-import { ProgressReporter } from "./standards-sdk.es16.js";
-const isBrowser = typeof window !== "undefined";
-class BrowserHCSClient extends HCS10BaseClient {
-  constructor(config) {
-    super({
-      network: config.network,
-      logLevel: config.logLevel,
-      prettyPrint: config.prettyPrint,
-      feeAmount: config.feeAmount
-    });
-    this.hcs11Client = null;
-    this.hwc = config.hwc;
-    this.guardedRegistryBaseUrl = config.guardedRegistryBaseUrl || "https://moonscape.tech";
+class AgentBuilder {
+  constructor() {
+    this.config = {};
     this.logger = Logger.getInstance({
-      level: config.logLevel || "info",
-      module: "HCS-Browser",
-      prettyPrint: config.prettyPrint
+      module: "AgentBuilder"
     });
-    if (isBrowser) {
-      try {
-        const { accountId, signer } = this.getAccountAndSigner();
-        this.hcs11Client = new HCS11Client({
-          network: config.network,
-          auth: {
-            operatorId: accountId,
-            signer
-          },
-          logLevel: config.logLevel
-        });
-      } catch (err) {
-        this.logger.warn(`Failed to initialize HCS11Client: ${err}`);
-      }
-    } else {
-      this.logger.error(
-        "BrowserHCSClient initialized in server environment - browser-specific features will not be available. Use HCS10Client instead."
-      );
-    }
   }
-  async sendMessage(connectionTopicId, data, memo, submitKey) {
-    this.logger.info("Sending message");
-    const operatorId = await this.getOperatorId();
-    const payload = {
-      p: "hcs-10",
-      op: "message",
-      operator_id: operatorId,
-      data,
-      m: memo
-    };
-    const submissionCheck = await this.canSubmitToTopic(
-      connectionTopicId,
-      this.hwc.getAccountInfo().accountId
-    );
-    const payloadString = JSON.stringify(payload);
-    const isLargePayload = Buffer.from(payloadString).length > 1e3;
-    if (isLargePayload) {
-      this.logger.info(
-        "Message payload exceeds 1000 bytes, storing via inscription"
-      );
-      try {
-        const contentBuffer = Buffer.from(data);
-        const fileName = `message-${Date.now()}.json`;
-        const inscriptionResult = await this.inscribeFile(
-          contentBuffer,
-          fileName
-        );
-        if (inscriptionResult?.topic_id) {
-          payload.data = `hcs://1/${inscriptionResult.topic_id}`;
-          this.logger.info(
-            `Large message inscribed with topic ID: ${inscriptionResult.topic_id}`
-          );
-        } else {
-          throw new Error("Failed to inscribe large message content");
-        }
-      } catch (error) {
-        this.logger.error("Error inscribing large message:", error);
-        throw new Error(
-          `Failed to handle large message: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
-    }
-    return await this.submitPayload(
-      connectionTopicId,
-      payload,
-      submitKey,
-      submissionCheck.requiresFee
-    );
+  setName(name) {
+    this.config.name = name;
+    return this;
   }
-  async submitConnectionRequest(inboundTopicId, memo) {
-    this.logger.info("Submitting connection request");
-    const accountResponse = this.getAccountAndSigner();
-    if (!accountResponse.accountId) {
-      throw new Error("Failed to retrieve user account ID");
-    }
-    const operatorId = await this.getOperatorId();
-    const accountId = accountResponse.accountId;
-    const connectionRequestMessage = {
-      p: "hcs-10",
-      op: "connection_request",
-      operator_id: operatorId,
-      m: memo
-    };
-    const response = await this.submitPayload(
-      inboundTopicId,
-      connectionRequestMessage
-    );
-    this.logger.info(
-      `Submitted connection request to topic ID: ${inboundTopicId}`
-    );
-    const outboundTopic = await this.retrieveOutboundConnectTopic(accountId);
-    if (!outboundTopic?.outboundTopic) {
-      this.logger.error(
-        `Failed to retrieve outbound topic for account ID: ${accountId}`
-      );
-      throw new Error(
-        `Failed to retrieve outbound topic for account ID: ${accountId}`
-      );
-    }
-    this.logger.info(
-      `Retrieved outbound topic ID: ${outboundTopic.outboundTopic} for account ID: ${accountId}`
-    );
-    const responseSequenceNumber = response?.topicSequenceNumber?.toNumber();
-    if (!responseSequenceNumber) {
-      throw new Error("Failed to get response sequence number");
-    }
-    await this.submitPayload(outboundTopic.outboundTopic, {
-      ...connectionRequestMessage,
-      outbound_topic_id: inboundTopicId,
-      connection_request_id: responseSequenceNumber
-    });
-    return response;
+  setAlias(alias) {
+    this.config.alias = alias;
+    return this;
   }
-  async getPublicKey(accountId) {
-    return await this.mirrorNode.getPublicKey(accountId);
+  setBio(bio) {
+    this.config.bio = bio;
+    return this;
   }
-  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionId, connectionMemo = "Connection accepted. Looking forward to collaborating!", ttl = 60) {
-    this.logger.info("Handling connection request");
-    const userAccountId = this.hwc.getAccountInfo().accountId;
-    if (!userAccountId) {
-      throw new Error("Failed to retrieve user account ID");
-    }
-    const requesterKey = await this.mirrorNode.getPublicKey(
-      requestingAccountId
-    );
-    const accountKey = await this.mirrorNode.getPublicKey(userAccountId);
-    if (!accountKey) {
-      throw new Error("Failed to retrieve public key");
-    }
-    const thresholdKey = new KeyList([accountKey, requesterKey], 1);
-    const memo = this._generateHcs10Memo(Hcs10MemoType.CONNECTION, {
-      ttl,
-      inboundTopicId,
-      connectionId
-    });
-    const transaction = new TopicCreateTransaction().setTopicMemo(memo).setAdminKey(thresholdKey).setSubmitKey(thresholdKey);
-    this.logger.debug("Executing topic creation transaction");
-    const txResponse = await this.hwc.executeTransactionWithErrorHandling(
-      transaction,
-      false
-    );
-    if (txResponse.error) {
-      this.logger.error(txResponse.error);
-      throw new Error(txResponse.error);
-    }
-    const resultReceipt = txResponse.result;
-    if (!resultReceipt?.topicId) {
-      this.logger.error("Failed to create topic: topicId is null");
-      throw new Error("Failed to create topic: topicId is null");
-    }
-    const connectionTopicId = resultReceipt.topicId.toString();
-    const operatorId = `${inboundTopicId}@${userAccountId}`;
-    const confirmedConnectionSequenceNumber = await this.confirmConnection(
-      inboundTopicId,
-      connectionTopicId,
-      requestingAccountId,
-      connectionId,
-      operatorId,
-      connectionMemo
-    );
-    return {
-      connectionTopicId,
-      confirmedConnectionSequenceNumber,
-      operatorId
-    };
+  /**
+   * @deprecated Use setBio instead
+   */
+  setDescription(description) {
+    this.config.bio = description;
+    return this;
   }
-  async confirmConnection(inboundTopicId, connectionTopicId, connectedAccountId, connectionId, operatorId, memo) {
-    this.logger.info("Confirming connection");
-    const payload = {
-      p: "hcs-10",
-      op: "connection_created",
-      connection_topic_id: connectionTopicId,
-      connected_account_id: connectedAccountId,
-      operator_id: operatorId,
-      connection_id: connectionId,
-      m: memo
-    };
-    const transactionResponse = await this.submitPayload(
-      inboundTopicId,
-      payload
-    );
-    if (!transactionResponse?.topicSequenceNumber) {
-      this.logger.error(
-        "Failed to confirm connection: sequence number is null"
-      );
-      throw new Error("Failed to confirm connection: sequence number is null");
-    }
-    return transactionResponse.topicSequenceNumber.toNumber();
+  setCapabilities(capabilities) {
+    this.config.capabilities = capabilities;
+    return this;
   }
   /**
-   * Creates an agent directly, but does not register.
-   * We highly recommend calling createAndRegisterAgent instead.
-   *
-   * @param pfpBuffer - The buffer containing the PFP image.
-   * @param pfpFileName - The name of the file containing the PFP image.
-   * @param agentName - The name of the agent.
-   * @param agentDescription - The description of the agent.
-   * @param capabilities - The capabilities of the agent.
-   * @param metadata - The metadata of the agent.
-   * @param existingPfpTopicId - The topic ID of the existing PFP.
-   * @param options - Optional configuration options.
-   * @returns A promise that resolves to the agent creation state.
+   * @deprecated Use setType instead
    */
-  async createAgent(pfpBuffer, pfpFileName, agentName, agentDescription, capabilities, metadata, existingPfpTopicId, options) {
-    try {
-      const progressCallback = options?.progressCallback;
-      const progressReporter = new ProgressReporter({
-        module: "AgentCreate",
-        logger: this.logger,
-        callback: progressCallback
-      });
-      let state = options?.existingState || {
-        currentStage: "init",
-        completedPercentage: 0,
-        createdResources: []
-      };
-      if (!state.outboundTopicId) {
-        state.currentStage = "topics";
-        progressReporter.preparing("Creating agent outbound topic", 0, {
-          state
-        });
-        const outboundMemo = this._generateHcs10Memo(Hcs10MemoType.OUTBOUND, {
-          ttl: options?.ttl
-        });
-        const outboundResult = await this.createTopic(outboundMemo, true, true);
-        if (!outboundResult.success || !outboundResult.topicId) {
-          state.error = outboundResult.error || "Failed to create outbound topic";
-          progressReporter.failed(
-            `Failed to create outbound topic: ${state.error}`,
-            { state }
-          );
-          return {
-            outboundTopicId: "",
-            inboundTopicId: "",
-            pfpTopicId: "",
-            profileTopicId: "",
-            success: false,
-            error: state.error,
-            state
-          };
-        }
-        state.outboundTopicId = outboundResult.topicId;
-        if (state.createdResources) {
-          state.createdResources.push(`outbound:${state.outboundTopicId}`);
-        }
-        progressReporter.preparing("Outbound topic created", 20, { state });
-      } else {
-        progressReporter.preparing("Using existing outbound topic", 20, {
-          state
-        });
-      }
-      const accountId = this.hwc.getAccountInfo().accountId;
-      if (!accountId) {
-        throw new Error("Failed to retrieve user account ID");
-      }
-      if (!state.inboundTopicId) {
-        const inboundMemo = this._generateHcs10Memo(Hcs10MemoType.INBOUND, {
-          accountId,
-          ttl: options?.ttl
-        });
-        const inboundResult = await this.createTopic(inboundMemo, true, true);
-        if (!inboundResult.success || !inboundResult.topicId) {
-          state.error = inboundResult.error || "Failed to create inbound topic";
-          progressReporter.failed(
-            `Failed to create inbound topic: ${state.error}`,
-            { state }
-          );
-          return {
-            outboundTopicId: state.outboundTopicId || "",
-            inboundTopicId: "",
-            pfpTopicId: "",
-            profileTopicId: "",
-            success: false,
-            error: state.error,
-            state
-          };
-        }
-        state.inboundTopicId = inboundResult.topicId;
-        if (state.createdResources) {
-          state.createdResources.push(`inbound:${state.inboundTopicId}`);
-        }
-        progressReporter.preparing("Inbound topic created", 40, { state });
-      } else {
-        progressReporter.preparing("Using existing inbound topic", 40, {
-          state
-        });
-      }
-      if (!state.pfpTopicId && !existingPfpTopicId) {
-        state.currentStage = "pfp";
-        progressReporter.preparing("Creating agent profile picture", 40, {
-          state
-        });
-        const pfpProgress = progressReporter.createSubProgress({
-          minPercent: 40,
-          maxPercent: 60,
-          logPrefix: "PFP"
-        });
-        const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName, {
-          progressCallback: (data) => {
-            pfpProgress.report({
-              stage: data.stage,
-              message: data.message,
-              progressPercent: data.progressPercent || 0,
-              details: { ...data.details, state }
-            });
-          }
-        });
-        if (!pfpResult.success) {
-          state.error = pfpResult.error || "Failed to inscribe profile picture";
-          progressReporter.failed(
-            `Failed to inscribe profile picture: ${state.error}`,
-            { state }
-          );
-          return {
-            outboundTopicId: state.outboundTopicId || "",
-            inboundTopicId: state.inboundTopicId || "",
-            pfpTopicId: "",
-            profileTopicId: "",
-            success: false,
-            error: state.error,
-            state
-          };
-        }
-        state.pfpTopicId = pfpResult.pfpTopicId;
-        state.completedPercentage = 60;
-        if (state.createdResources) {
-          state.createdResources.push(`pfp:${state.pfpTopicId}`);
-        }
-        progressReporter.preparing("Profile picture created", 60, { state });
-      } else {
-        state.pfpTopicId = existingPfpTopicId || state.pfpTopicId;
-        progressReporter.preparing(
-          `Using existing profile picture: ${state.pfpTopicId}`,
-          60,
-          {
-            state
-          }
-        );
-      }
-      if (!state.profileTopicId) {
-        state.currentStage = "profile";
-        progressReporter.preparing("Creating agent profile", 60, { state });
-        const profileProgress = progressReporter.createSubProgress({
-          minPercent: 60,
-          maxPercent: 100,
-          logPrefix: "Profile"
-        });
-        if (!this.hcs11Client) {
-          state.error = "HCS11Client is not available in this environment";
-          progressReporter.failed(state.error, { state });
-          return {
-            outboundTopicId: state.outboundTopicId || "",
-            inboundTopicId: state.inboundTopicId || "",
-            pfpTopicId: state.pfpTopicId || "",
-            profileTopicId: "",
-            success: false,
-            error: state.error,
-            state
-          };
-        }
-        const storeProfileResult = await this.storeHCS11Profile(
-          agentName,
-          agentDescription,
-          state.inboundTopicId,
-          state.outboundTopicId,
-          capabilities,
-          metadata,
-          void 0,
-          void 0,
-          state.pfpTopicId,
-          {
-            progressCallback: (data) => {
-              profileProgress.report({
-                stage: data.stage,
-                message: data.message,
-                progressPercent: data.progressPercent || 0,
-                details: { ...data.details, state }
-              });
-            }
-          }
-        );
-        if (!storeProfileResult.success) {
-          state.error = storeProfileResult.error || "Failed to store agent profile";
-          progressReporter.failed(
-            `Failed to store agent profile: ${state.error}`,
-            { state }
-          );
-          return {
-            outboundTopicId: state.outboundTopicId || "",
-            inboundTopicId: state.inboundTopicId || "",
-            pfpTopicId: state.pfpTopicId || "",
-            profileTopicId: "",
-            success: false,
-            error: state.error,
-            state
-          };
-        }
-        state.profileTopicId = storeProfileResult.profileTopicId;
-        if (state.createdResources) {
-          state.createdResources.push(`profile:${state.profileTopicId}`);
-        }
-        state.currentStage = "complete";
-        state.completedPercentage = 100;
-      } else {
-        progressReporter.preparing("Using existing agent profile", 100, {
-          state
-        });
-        if (state.currentStage !== "complete") {
-          state.currentStage = "complete";
-          state.completedPercentage = 100;
-        }
-      }
-      progressReporter.completed("Agent successfully created", {
-        inboundTopicId: state.inboundTopicId,
-        outboundTopicId: state.outboundTopicId,
-        pfpTopicId: state.pfpTopicId,
-        profileTopicId: state.profileTopicId,
-        state
-      });
-      return {
-        outboundTopicId: state.outboundTopicId || "",
-        inboundTopicId: state.inboundTopicId || "",
-        pfpTopicId: state.pfpTopicId || "",
-        profileTopicId: state.profileTopicId || "",
-        success: true,
-        state
-      };
-    } catch (error) {
-      this.logger.error(`Error creating agent: ${error.message}`);
-      return {
-        outboundTopicId: "",
-        inboundTopicId: "",
-        pfpTopicId: "",
-        profileTopicId: "",
-        success: false,
-        error: `Error creating agent: ${error.message}`,
-        state: {
-          currentStage: "init",
-          completedPercentage: 0,
-          error: error.message
-        }
-      };
+  setAgentType(type) {
+    if (!this.config.metadata) {
+      this.config.metadata = { type };
+    } else {
+      this.config.metadata.type = type;
     }
+    return this;
   }
-  initializeRegistrationState(inboundTopicId, existingState) {
-    const state = existingState || {
-      inboundTopicId,
-      currentStage: "registration",
-      completedPercentage: 0,
-      createdResources: []
-    };
-    if (state.currentStage !== "registration" && state.currentStage !== "complete") {
-      state.currentStage = "registration";
+  setType(type) {
+    if (!this.config.metadata) {
+      this.config.metadata = { type };
+    } else {
+      this.config.metadata.type = type;
     }
-    return state;
+    return this;
   }
-  updateStateForCompletedRegistration(state, inboundTopicId) {
-    state.currentStage = "complete";
-    state.completedPercentage = 100;
-    if (state.createdResources) {
-      state.createdResources.push(`registration:${inboundTopicId}`);
+  setModel(model) {
+    if (!this.config.metadata) {
+      this.config.metadata = { type: "manual" };
     }
+    this.config.metadata.model = model;
+    return this;
   }
-  async registerAgentWithGuardedRegistry(accountId, network = this.network, options) {
-    try {
-      this.logger.info("Registering agent with guarded registry");
-      const agentProfile = await this.retrieveProfile(accountId);
-      const inboundTopicId = agentProfile.topicInfo.inboundTopic;
-      const state = this.initializeRegistrationState(
-        inboundTopicId,
-        options?.existingState
-      );
-      const progressReporter = new ProgressReporter({
-        module: "AgentRegistration",
-        logger: this.logger,
-        callback: options?.progressCallback
-      });
-      progressReporter.preparing("Preparing agent registration", 10, {
-        inboundTopicId,
-        accountId
-      });
-      const registrationResult = await this.executeRegistration(
-        accountId,
-        network,
-        this.guardedRegistryBaseUrl,
-        this.logger
-      );
-      if (!registrationResult.success) {
-        return {
-          ...registrationResult,
-          state
-        };
-      }
-      progressReporter.submitting("Submitting registration to registry", 30, {
-        transactionId: registrationResult.transactionId
-      });
-      if (registrationResult.transaction) {
-        const transaction = Transaction.fromBytes(
-          Buffer.from(registrationResult.transaction, "base64")
-        );
-        this.logger.info(`Processing registration transaction`);
-        const txResult = await this.hwc.executeTransactionWithErrorHandling(
-          transaction,
-          true
-        );
-        if (txResult.error) {
-          return {
-            ...registrationResult,
-            error: txResult.error,
-            success: false,
-            state
-          };
-        }
-        this.logger.info(`Successfully processed registration transaction`);
-      }
-      progressReporter.confirming("Confirming registration transaction", 60, {
-        accountId,
-        inboundTopicId,
-        transactionId: registrationResult.transactionId
-      });
-      const maxAttempts = options?.maxAttempts ?? 60;
-      const delayMs = options?.delayMs ?? 2e3;
-      const confirmed = await this.waitForRegistrationConfirmation(
-        registrationResult.transactionId,
-        network,
-        this.guardedRegistryBaseUrl,
-        maxAttempts,
-        delayMs,
-        this.logger
-      );
-      this.updateStateForCompletedRegistration(state, inboundTopicId);
-      progressReporter.completed("Agent registration complete", {
-        transactionId: registrationResult.transactionId,
-        inboundTopicId,
-        state,
-        confirmed
-      });
-      return {
-        ...registrationResult,
-        confirmed,
-        state
-      };
-    } catch (error) {
-      this.logger.error(`Registration error: ${error.message}`);
-      return {
-        error: `Error during registration: ${error.message}`,
-        success: false,
-        state: {
-          currentStage: "registration",
-          completedPercentage: 0,
-          error: error.message
-        }
-      };
+  setCreator(creator) {
+    if (!this.config.metadata) {
+      this.config.metadata = { type: "manual" };
     }
+    this.config.metadata.creator = creator;
+    return this;
   }
-  async createAndRegisterAgent(builder, options) {
-    try {
-      const config = builder.build();
-      const progressCallback = options?.progressCallback;
-      const progressReporter = new ProgressReporter({
-        module: "AgentCreateRegister",
-        logger: this.logger,
-        callback: progressCallback
-      });
-      let state = options?.existingState || {
-        currentStage: "init",
-        completedPercentage: 0,
-        createdResources: []
-      };
-      state.agentMetadata = config.metadata;
-      progressReporter.preparing("Starting agent creation process", 0, {
-        state
-      });
-      if (state.currentStage !== "complete" || !state.inboundTopicId || !state.outboundTopicId || !state.profileTopicId) {
-        const agentResult = await this.createAgent(
-          config.pfpBuffer || Buffer.from([]),
-          config.pfpFileName || "default.png",
-          config.name,
-          config.description,
-          config.capabilities,
-          config.metadata,
-          config.existingPfpTopicId,
-          {
-            progressCallback: (progress) => {
-              const adjustedPercent = (progress.progressPercent || 0) * 0.3;
-              progressReporter.report({
-                stage: progress.stage,
-                message: progress.message,
-                progressPercent: adjustedPercent,
-                details: {
-                  ...progress.details,
-                  state: progress.details?.state || state
-                }
-              });
-            },
-            existingState: state
-          }
-        );
-        if (!agentResult.success) {
-          throw new Error(
-            agentResult.error || "Failed to create agent with topics"
-          );
-        }
-        state = agentResult.state;
-        state.agentMetadata = config.metadata;
-      }
-      progressReporter.preparing(
-        `Agent creation status: ${state.currentStage}, ${state.completedPercentage}%`,
-        30,
-        { state }
-      );
-      const { accountId } = this.getAccountAndSigner();
-      if (state.currentStage !== "complete" || !state.createdResources?.includes(
-        `registration:${state.inboundTopicId}`
-      )) {
-        if (options?.baseUrl) {
-          this.guardedRegistryBaseUrl = options.baseUrl;
-        }
-        const registrationResult = await this.registerAgentWithGuardedRegistry(
-          accountId,
-          config.network,
-          {
-            progressCallback: (progress) => {
-              const adjustedPercent = 30 + (progress.progressPercent || 0) * 0.7;
-              progressReporter.report({
-                stage: progress.stage,
-                message: progress.message,
-                progressPercent: adjustedPercent,
-                details: {
-                  ...progress.details,
-                  state: progress.details?.state || state
-                }
-              });
-            },
-            maxAttempts: options?.maxAttempts,
-            delayMs: options?.delayMs,
-            existingState: state
-          }
-        );
-        if (!registrationResult.success) {
-          throw new Error(
-            registrationResult.error || "Failed to register agent with registry"
-          );
-        }
-        state = registrationResult.state;
-      }
-      progressReporter.completed("Agent creation and registration complete", {
-        state
-      });
-      return {
-        success: true,
-        state,
-        metadata: {
-          accountId,
-          operatorId: `${state.inboundTopicId}@${accountId}`,
-          inboundTopicId: state.inboundTopicId,
-          outboundTopicId: state.outboundTopicId,
-          profileTopicId: state.profileTopicId,
-          pfpTopicId: state.pfpTopicId,
-          privateKey: null,
-          ...state.agentMetadata
-        }
-      };
-    } catch (error) {
-      throw new Error(`Failed to create and register agent: ${error.message}`);
+  addSocial(platform, handle) {
+    if (!this.config.metadata) {
+      this.config.metadata = { type: "manual" };
     }
-  }
-  async storeHCS11Profile(agentName, agentDescription, inboundTopicId, outboundTopicId, capabilities = [], metadata = {}, pfpBuffer, pfpFileName, existingPfpTopicId, options) {
-    try {
-      const progressCallback = options?.progressCallback;
-      const progressReporter = new ProgressReporter({
-        module: "StoreHCS11Profile",
-        logger: this.logger,
-        callback: progressCallback
-      });
-      progressReporter.preparing("Preparing agent profile data", 0);
-      let pfpTopicId = existingPfpTopicId;
-      if (!pfpTopicId && pfpBuffer && pfpFileName) {
-        const pfpProgress = progressReporter.createSubProgress({
-          minPercent: 0,
-          maxPercent: 60,
-          logPrefix: "PFP"
-        });
-        const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName, {
-          progressCallback: (data) => {
-            pfpProgress.report({
-              stage: data.stage,
-              message: data.message,
-              progressPercent: data.progressPercent || 0,
-              details: data.details
-            });
-          }
-        });
-        if (!pfpResult.success) {
-          progressReporter.failed(
-            "Failed to inscribe profile picture, continuing without PFP"
-          );
-        } else {
-          pfpTopicId = pfpResult.pfpTopicId;
-        }
-      } else if (existingPfpTopicId) {
-        progressReporter.preparing(
-          `Using existing profile picture: ${existingPfpTopicId}`,
-          30
-        );
-      } else {
-        progressReporter.preparing("No profile picture provided", 30);
-      }
-      const agentType = this.hcs11Client?.getAgentTypeFromMetadata({
-        type: metadata.type || "autonomous"
-      });
-      progressReporter.preparing("Building agent profile", 65);
-      const formattedSocials = [];
-      if (metadata.socials) {
-        if (metadata.socials.twitter) {
-          formattedSocials.push({
-            platform: "twitter",
-            handle: metadata.socials.twitter
-          });
-        }
-        if (metadata.socials.discord) {
-          formattedSocials.push({
-            platform: "discord",
-            handle: metadata.socials.discord
-          });
-        }
-        if (metadata.socials.github) {
-          formattedSocials.push({
-            platform: "github",
-            handle: metadata.socials.github
-          });
-        }
-        if (metadata.socials.website) {
-          formattedSocials.push({
-            platform: "website",
-            handle: metadata.socials.website
-          });
-        }
-        if (metadata.socials.x) {
-          formattedSocials.push({
-            platform: "twitter",
-            handle: metadata.socials.x
-          });
-        }
-        if (metadata.socials.linkedin) {
-          formattedSocials.push({
-            platform: "linkedin",
-            handle: metadata.socials.linkedin
-          });
-        }
-        if (metadata.socials.youtube) {
-          formattedSocials.push({
-            platform: "youtube",
-            handle: metadata.socials.youtube
-          });
-        }
-        if (metadata.socials.telegram) {
-          formattedSocials.push({
-            platform: "telegram",
-            handle: metadata.socials.telegram
-          });
-        }
-      }
-      if (!this.hcs11Client) {
-        progressReporter.failed(
-          "HCS11Client is not available in this environment"
-        );
-        return {
-          profileTopicId: "",
-          success: false,
-          error: "HCS11Client is not available in this environment",
-          transactionId: ""
-        };
-      }
-      const profile = this.hcs11Client.createAIAgentProfile(
-        agentName,
-        agentType,
-        capabilities,
-        metadata.model || "unknown",
-        {
-          alias: agentName.toLowerCase().replace(/\s+/g, "_"),
-          bio: agentDescription,
-          profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
-          socials: formattedSocials.length > 0 ? formattedSocials : void 0,
-          properties: {
-            description: agentDescription,
-            version: metadata.version || "1.0.0",
-            creator: metadata.creator || "Unknown",
-            supported_languages: metadata.supported_languages || ["en"],
-            permissions: metadata.permissions || [],
-            model_details: metadata.model_details,
-            training: metadata.training,
-            capabilities_description: metadata.capabilities_description,
-            ...metadata
-          },
-          inboundTopicId,
-          outboundTopicId,
-          creator: metadata.creator
-        }
-      );
-      const profileProgress = progressReporter.createSubProgress({
-        minPercent: 65,
-        maxPercent: 100,
-        logPrefix: "Profile"
-      });
-      const profileResult = await this.hcs11Client.createAndInscribeProfile(
-        profile,
-        true,
-        {
-          progressCallback: (profileData) => {
-            profileProgress.report({
-              stage: profileData.stage,
-              message: profileData.message,
-              progressPercent: profileData.progressPercent || 0,
-              details: profileData.details
-            });
-          }
-        }
-      );
-      if (!profileResult.success) {
-        progressReporter.failed("Failed to inscribe profile");
-        return {
-          profileTopicId: "",
-          success: false,
-          error: profileResult.error || "Failed to inscribe profile",
-          transactionId: profileResult.transactionId || ""
-        };
-      }
-      progressReporter.completed("Profile stored successfully", {
-        profileTopicId: profileResult.profileTopicId
-      });
-      return {
-        profileTopicId: profileResult.profileTopicId,
-        pfpTopicId,
-        success: true,
-        transactionId: profileResult.transactionId || ""
-      };
-    } catch (error) {
-      this.logger.error(`Error storing HCS11 profile: ${error.message}`);
-      return {
-        profileTopicId: "",
-        success: false,
-        error: error.message,
-        transactionId: ""
-      };
+    if (!this.config.metadata.socials) {
+      this.config.metadata.socials = {};
     }
+    this.config.metadata.socials[platform] = handle;
+    return this;
   }
-  async createTopic(memo, adminKey, submitKey) {
-    this.logger.info("Creating topic");
-    const { accountId, signer } = this.getAccountAndSigner();
-    const transaction = new TopicCreateTransaction().setTopicMemo(memo);
-    const publicKey = await this.mirrorNode.getPublicKey(accountId);
-    if (adminKey && publicKey) {
-      transaction.setAdminKey(publicKey);
-      transaction.setAutoRenewAccountId(accountId);
-    }
-    if (submitKey && publicKey) {
-      transaction.setSubmitKey(publicKey);
+  addProperty(key, value) {
+    if (!this.config.metadata) {
+      this.config.metadata = { type: "manual" };
     }
-    const transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
-      transaction,
-      false
-    );
-    const error = transactionResponse.error;
-    if (error) {
-      this.logger.error(error);
-      return {
-        success: false,
-        error
-      };
+    if (!this.config.metadata.properties) {
+      this.config.metadata.properties = {};
     }
-    const resultReceipt = transactionResponse.result;
-    if (!resultReceipt?.topicId) {
-      this.logger.error("Failed to create topic: topicId is null");
-      return {
-        success: false,
-        error: "Failed to create topic: topicId is null"
-      };
-    }
-    return {
-      success: true,
-      topicId: resultReceipt.topicId.toString()
-    };
+    this.config.metadata.properties[key] = value;
+    return this;
   }
-  async submitPayload(topicId, payload, submitKey, requiresFee) {
-    this.logger.debug(`Submitting payload to topic ${topicId}`);
-    let message;
-    if (typeof payload === "string") {
-      message = payload;
-    } else {
-      message = JSON.stringify(payload);
-    }
-    const transaction = new TopicMessageSubmitTransaction().setTopicId(topicId).setMessage(message);
-    let transactionResponse;
-    if (requiresFee) {
-      this.logger.info(
-        "Topic requires fee payment, setting max transaction fee"
-      );
-      transaction.setMaxTransactionFee(new Hbar(this.feeAmount));
-      transaction.setTransactionMemo("HIP-991 Fee Payment");
+  setMetadata(metadata) {
+    this.config.metadata = metadata;
+    return this;
+  }
+  setProfilePicture(pfpBuffer, pfpFileName) {
+    this.config.pfpBuffer = pfpBuffer;
+    this.config.pfpFileName = pfpFileName;
+    return this;
+  }
+  setExistingProfilePicture(pfpTopicId) {
+    this.config.existingPfpTopicId = pfpTopicId;
+    return this;
+  }
+  setNetwork(network) {
+    this.config.network = network;
+    return this;
+  }
+  setInboundTopicType(inboundTopicType) {
+    this.config.inboundTopicType = inboundTopicType;
+    return this;
+  }
+  setFeeConfig(feeConfigBuilder) {
+    this.config.feeConfig = feeConfigBuilder;
+    return this;
+  }
+  setConnectionFeeConfig(feeConfigBuilder) {
+    this.config.connectionFeeConfig = feeConfigBuilder;
+    return this;
+  }
+  setExistingAccount(accountId, privateKey) {
+    this.config.existingAccount = { accountId, privateKey };
+    return this;
+  }
+  build() {
+    if (!this.config.name) {
+      throw new Error("Agent display name is required");
     }
-    if (submitKey) {
-      const { accountId, signer } = this.getAccountAndSigner();
-      transaction.freezeWithSigner(signer);
-      const signedTransaction = await transaction.sign(submitKey);
-      transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
-        signedTransaction,
-        true
-      );
-    } else {
-      transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
-        transaction,
-        false
-      );
+    if (!this.config.bio) {
+      this.logger?.warn("Agent description is not set");
     }
-    if (transactionResponse?.error) {
-      this.logger.error(
-        `Failed to submit payload: ${transactionResponse.error}`
-      );
-      throw new Error(`Failed to submit payload: ${transactionResponse.error}`);
+    if (!this.config.pfpBuffer && !this.config.existingPfpTopicId) {
+      this.logger.warn("No profile picture provided or referenced.");
     }
-    if (!transactionResponse?.result) {
-      this.logger.error(
-        "Failed to submit message: receipt is null or undefined"
-      );
-      throw new Error("Failed to submit message: receipt is null or undefined");
+    if (!this.config.network) {
+      throw new Error("Network is required");
     }
-    this.logger.debug("Payload submitted successfully via HWC");
-    return transactionResponse.result;
-  }
-  async inscribeFile(buffer, fileName) {
-    const { accountId, signer } = this.getAccountAndSigner();
-    const mimeType = mimeTypesExports.lookup(fileName) || "application/octet-stream";
-    const sdk = await InscriptionSDK.createWithAuth({
-      type: "client",
-      accountId,
-      signer,
-      network: this.network
-    });
-    const result = await sdk.inscribe(
-      {
-        file: {
-          type: "base64",
-          base64: buffer.toString("base64"),
-          fileName,
-          mimeType
-        },
-        holderId: accountId.toString(),
-        mode: "file",
-        network: this.network
-      },
-      signer
-    );
-    if (!result.transactionId || !result.jobId) {
-      this.logger.error("Failed to inscribe, no transaction ID or job ID.");
-      throw new Error("Failed to inscribe, no transaction ID or job ID.");
+    if (!this.config.inboundTopicType) {
+      this.config.inboundTopicType = InboundTopicType.PUBLIC;
     }
-    if (result.transactionId && result.jobId) {
-      this.logger.info(
-        `Transaction ID: ${result.transactionId}, Job ID: ${result.jobId}`
-      );
+    if (!this.config.capabilities) {
+      this.config.capabilities = [];
     }
-    const status = await sdk.waitForInscription(result.jobId, 30, 4e3, true);
-    return status;
-  }
-  getAccountAndSigner() {
-    const accountInfo = this.hwc.getAccountInfo();
-    const accountId = accountInfo.accountId.toString();
-    const signer = this.hwc.dAppConnector.signers.find((s) => {
-      return s.getAccountId().toString() === accountId;
-    });
-    if (!signer) {
-      this.logger.error("Failed to find signer");
-      throw new Error("Failed to find signer");
+    if (!this.config.metadata) {
+      this.config.metadata = { type: "manual" };
+    } else if (!this.config.metadata.type) {
+      this.config.metadata.type = "manual";
     }
-    return { accountId, signer };
-  }
-  /**
-   * Inscribes a profile picture (PFP) on HCS-11.
-   *
-   * @param buffer - The buffer containing the PFP image.
-   * @param fileName - The name of the file containing the PFP image.
-   * @param options - Optional configuration options.
-   * @returns A promise that resolves to the topic ID of the inscribed PFP.
-   */
-  async inscribePfp(buffer, fileName, options) {
-    try {
-      const progressCallback = options?.progressCallback;
-      const progressReporter = new ProgressReporter({
-        module: "PFP-Inscription",
-        logger: this.logger,
-        callback: progressCallback
-      });
-      if (!this.hcs11Client) {
-        progressReporter.failed(
-          "HCS11Client is not available in this environment"
-        );
-        return {
-          pfpTopicId: "",
-          success: false,
-          error: "HCS11Client is not available in this environment",
-          transactionId: ""
-        };
-      }
-      progressReporter.preparing("Preparing to inscribe profile picture", 10);
-      this.logger.info("Inscribing profile picture using HCS-11 client");
-      const wrappedProgressCallback = (data) => {
-        progressReporter.report({
-          stage: data.stage || "confirming",
-          message: data.message || "Processing PFP inscription",
-          progressPercent: data.progressPercent || 50,
-          details: data.details
-        });
-      };
-      const imageResult = await this.hcs11Client.inscribeImage(
-        buffer,
-        fileName,
-        { progressCallback: wrappedProgressCallback }
-      );
-      if (!imageResult.success) {
-        progressReporter.failed(
-          `Failed to inscribe profile picture: ${imageResult.error}`
-        );
-        this.logger.error(
-          `Failed to inscribe profile picture: ${imageResult.error}`
-        );
-        return {
-          pfpTopicId: "",
-          success: false,
-          error: imageResult.error || "Failed to inscribe profile picture",
-          transactionId: imageResult.transactionId || ""
-        };
-      }
-      progressReporter.completed("Successfully inscribed profile picture", {
-        pfpTopicId: imageResult.imageTopicId
-      });
-      this.logger.info(
-        `Successfully inscribed profile picture with topic ID: ${imageResult.imageTopicId}`
-      );
-      return {
-        pfpTopicId: imageResult.imageTopicId,
-        success: true,
-        transactionId: imageResult.transactionId || ""
-      };
-    } catch (error) {
-      this.logger.error(`Error inscribing profile picture: ${error.message}`);
-      return {
-        pfpTopicId: "",
-        success: false,
-        error: error.message,
-        transactionId: ""
-      };
+    if (this.config.inboundTopicType === InboundTopicType.FEE_BASED && !this.config.feeConfig) {
+      throw new Error("Fee configuration is required for fee-based topics");
     }
+    return this.config;
   }
 }
 export {
-  BrowserHCSClient
+  AgentBuilder
 };
 //# sourceMappingURL=standards-sdk.es10.js.map