@hashgraphonline/standards-sdk 0.1.188 → 0.1.190

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

@@ -1,1169 +1,163 @@
-import { Buffer } from "buffer";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { ZodError } from "zod";
-import { agentFeedbackResponseSchema, agentFeedbackIndexResponseSchema, agentFeedbackEntriesIndexResponseSchema, agentFeedbackEligibilityResponseSchema, agentFeedbackSubmissionResponseSchema, registerAgentResponseSchema } from "./standards-sdk.es158.js";
-import { fetchHistorySnapshot, attachDecryptedHistory, registerConversationContextForEncryption, resolveDecryptionContext, decryptHistoryEntryFromContext } from "./standards-sdk.es199.js";
-import { createAgentNetworkApi } from "./standards-sdk.es152.js";
-import { createChatApi, createSession, resumeSession, checkChatReadiness, startChat, startConversation, acceptConversation, compactHistory, fetchEncryptionStatus, postEncryptionHandshake, sendMessage, retryMessage, cancelSession, endSession, createPlaintextConversationHandle } from "./standards-sdk.es200.js";
-import { EncryptedChatManager } from "./standards-sdk.es201.js";
-import { generateEncryptionKeyPair, bootstrapEncryptionOptions, createEncryptionApi } from "./standards-sdk.es202.js";
-import { adapters, adaptersDetailed, adapterRegistryCategories, adapterRegistryAdapters, createAdapterRegistryCategory, submitAdapterRegistryAdapter, adapterRegistrySubmissionStatus } from "./standards-sdk.es203.js";
-import { resolveUaid, getRegistrationQuote, updateAgent, getRegistrationProgress, waitForRegistrationCompletion, validateUaid, getUaidConnectionStatus, closeUaidConnection, dashboardStats } from "./standards-sdk.es153.js";
-import { getRegisterStatus, registerOwnedMoltbookAgent, getVerificationStatus, createVerificationChallenge, getVerificationChallenge, verifyVerificationChallenge, getVerificationOwnership, verifySenderOwnership, verifyUaidDnsTxt, getVerificationDnsStatus } from "./standards-sdk.es204.js";
-import { getCreditsBalance, getCreditProviders, createHbarPurchaseIntent, purchaseCreditsWithHbar, getX402Minimums, purchaseCreditsWithX402, buyCreditsWithX402 } from "./standards-sdk.es205.js";
-import { getGuardSession, getGuardEntitlements, getGuardBillingBalance, getGuardFeed, getGuardOverview, getGuardTrustByHash, resolveGuardTrust, getGuardRevocations, fetchGuardAdvisories, fetchGuardPolicy, getGuardInventory, getGuardReceiptHistory, getGuardArtifactTimeline, getGuardInventoryDiff, exportGuardAbom, exportGuardArtifactAbom, exportGuardReceipts, getGuardDevices, getGuardAlertPreferences, updateGuardAlertPreferences, getGuardExceptions, getGuardWatchlist, lookupGuardWatchlist, getGuardPainSignals, getGuardAggregatedPainSignals, getGuardPreInstallVerdict, getGuardPreExecutionVerdict, addGuardWatchlistItem, removeGuardWatchlistItem, addGuardException, requestGuardException, removeGuardException, ingestGuardPainSignals, syncGuardReceipts, syncGuardInventory, submitGuardReceipts, getGuardTeamPolicyPack, updateGuardTeamPolicyPack } from "./standards-sdk.es206.js";
-import { createLedgerChallenge, verifyLedgerChallenge, authenticateWithLedger, authenticateWithLedgerCredentials } from "./standards-sdk.es207.js";
-import { search, delegate, stats, registries, getAdditionalRegistries, popularSearches, listProtocols, detectProtocol, registrySearchByNamespace, vectorSearch, searchStatus, websocketStats, metricsSummary, facets } from "./standards-sdk.es208.js";
-import { skillsConfig, listSkills, getSkillsCatalog, listSkillVersions, listMySkills, getMySkillsList, quoteSkillPublish, quoteSkillPublishPreview, publishSkill, getSkillPublishJob, getSkillOwnership, getRecommendedSkillVersion, setRecommendedSkillVersion, getSkillDeprecations, setSkillDeprecation, getSkillBadge, getSkillStatus, getSkillSecurityBreakdown, getSkillStatusByRepo, getSkillConversionSignalsByRepo, uploadSkillPreviewFromGithubOidc, getSkillPreview, getSkillPreviewByRepo, getSkillPreviewById, getSkillInstall, recordSkillInstallCopy, listSkillTags, listSkillCategories, resolveSkillMarkdown, resolveSkillManifest, getSkillVoteStatus, setSkillVote, requestSkillVerification, getSkillVerificationStatus, createSkillDomainProofChallenge, verifySkillDomainProof } from "./standards-sdk.es191.js";
-import { DEFAULT_BASE_URL, normaliseBaseUrl, normaliseHeaderName, isBrowserRuntime, DEFAULT_USER_AGENT, JSON_CONTENT_TYPE, serialiseAgentRegistrationRequest, MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS, createAbortError, isJsonObject, DEFAULT_HISTORY_TOP_UP_HBAR } from "./standards-sdk.es209.js";
-import { RegistryBrokerError, RegistryBrokerParseError } from "./standards-sdk.es151.js";
-import { optionalImportSync } from "./standards-sdk.es187.js";
-class RegistryBrokerClient {
+import { Logger } from "./standards-sdk.es147.js";
+class ProgressReporter {
   constructor(options = {}) {
-    this.encryptionBootstrapPromise = null;
-    this.chatApi = null;
-    this.agentNetworkApi = null;
-    this.encryptedChatManager = null;
-    this.encryptionApi = null;
-    this.conversationContexts = /* @__PURE__ */ new Map();
-    const {
-      baseUrl = DEFAULT_BASE_URL,
-      fetchImplementation,
-      defaultHeaders,
-      apiKey,
-      accountId,
-      ledgerApiKey,
-      registrationAutoTopUp,
-      historyAutoTopUp,
-      encryption
-    } = options;
-    this.baseUrl = normaliseBaseUrl(baseUrl);
-    const resolvedFetch = fetchImplementation ?? (typeof globalThis.fetch === "function" ? globalThis.fetch : null);
-    if (!resolvedFetch) {
-      throw new Error(
-        "A fetch implementation is required for RegistryBrokerClient"
-      );
-    }
-    this.fetchImpl = resolvedFetch;
-    this.defaultHeaders = {
-      ...defaultHeaders ?? {}
-    };
-    Object.entries(this.defaultHeaders).forEach(([key, value]) => {
-      const headerName = normaliseHeaderName(key);
-      if (headerName !== key) {
-        delete this.defaultHeaders[key];
-        this.defaultHeaders[headerName] = value;
-      }
+    this.module = options.module || "Progress";
+    this.callback = options.callback;
+    this.logger = options.logger || new Logger({
+      level: "info",
+      module: "ProgressReporter"
     });
-    const existingLedgerHeader = this.defaultHeaders["x-ledger-api-key"]?.trim();
-    if (!this.defaultHeaders["x-api-key"] && existingLedgerHeader) {
-      this.defaultHeaders["x-api-key"] = existingLedgerHeader;
-    }
-    if (apiKey) {
-      this.defaultHeaders["x-api-key"] = apiKey;
-    }
-    if (typeof accountId === "string" && accountId.trim().length > 0) {
-      this.defaultHeaders["x-account-id"] = accountId.trim();
-    }
-    if (ledgerApiKey) {
-      if (!this.defaultHeaders["x-api-key"]) {
-        this.defaultHeaders["x-api-key"] = ledgerApiKey;
+    this.logProgress = options.logProgress ?? true;
+    this.minPercent = options.minPercent ?? 0;
+    this.maxPercent = options.maxPercent ?? 100;
+    this.lastReportedPercent = -1;
+    this.lastReportedTime = 0;
+    this.throttleMs = 100;
+  }
+  static getInstance(options = {}) {
+    if (!ProgressReporter.instance) {
+      ProgressReporter.instance = new ProgressReporter(options);
+    } else {
+      if (options.callback) {
+        ProgressReporter.instance.setCallback(options.callback);
       }
-    }
-    this.registrationAutoTopUp = registrationAutoTopUp;
-    this.historyAutoTopUp = historyAutoTopUp;
-    this.encryptionOptions = encryption;
-    if (this.encryptionOptions) {
-      this.encryptionBootstrapPromise = this.initializeEncryptionBootstrap(
-        this.encryptionOptions
-      );
-    }
-  }
-  static async initializeAgent(options) {
-    const { uaid, ensureEncryptionKey = true, ...clientOptions } = options;
-    const client = new RegistryBrokerClient(clientOptions);
-    let encryption = null;
-    if (ensureEncryptionKey) {
-      const ensureOptions = typeof ensureEncryptionKey === "object" ? ensureEncryptionKey : { generateIfMissing: true };
-      encryption = await client.encryption.ensureAgentKey({
-        uaid,
-        ...ensureOptions
-      });
-    }
-    return { client, encryption };
-  }
-  get chat() {
-    if (this.chatApi) {
-      return this.chatApi;
-    }
-    const api = createChatApi(this, this.getEncryptedChatManager());
-    this.chatApi = api;
-    return api;
-  }
-  /** Owner + bot mailbox surface; see ./agent-network.ts. */
-  get agentNetwork() {
-    if (!this.agentNetworkApi) {
-      this.agentNetworkApi = createAgentNetworkApi(this);
-    }
-    return this.agentNetworkApi;
-  }
-  get encryption() {
-    if (this.encryptionApi) {
-      return this.encryptionApi;
-    }
-    const api = createEncryptionApi(this);
-    this.encryptionApi = api;
-    return api;
-  }
-  setApiKey(apiKey) {
-    this.setDefaultHeader("x-api-key", apiKey);
-  }
-  setLedgerApiKey(apiKey) {
-    this.setDefaultHeader("x-api-key", apiKey);
-    delete this.defaultHeaders["x-ledger-api-key"];
-  }
-  setDefaultHeader(name, value) {
-    if (!name || name.trim().length === 0) {
-      return;
-    }
-    const headerName = normaliseHeaderName(name);
-    if (!value || value.trim().length === 0) {
-      delete this.defaultHeaders[headerName];
-      return;
-    }
-    this.defaultHeaders[headerName] = value.trim();
-  }
-  getDefaultHeaders() {
-    return { ...this.defaultHeaders };
-  }
-  async encryptionReady() {
-    if (!this.encryptionBootstrapPromise) {
-      return;
-    }
-    await this.encryptionBootstrapPromise;
-  }
-  buildUrl(path) {
-    const normalisedPath = path.startsWith("/") ? path : `/${path}`;
-    return `${this.baseUrl}${normalisedPath}`;
-  }
-  buildRequestInit(config) {
-    const headers = new Headers();
-    Object.entries(this.defaultHeaders).forEach(([key, value]) => {
-      headers.set(key, value);
-    });
-    if (config.headers) {
-      Object.entries(config.headers).forEach(([key, value]) => {
-        headers.set(key, value);
-      });
-    }
-    if (!headers.has("accept")) {
-      headers.set("accept", "application/json");
-    }
-    if (!headers.has("user-agent") && !isBrowserRuntime()) {
-      headers.set("user-agent", DEFAULT_USER_AGENT);
-    }
-    const init = {
-      method: config.method ?? "GET",
-      headers
-    };
-    if (config.body !== void 0) {
-      init.body = JSON.stringify(config.body);
-      if (!headers.has("content-type")) {
-        headers.set("content-type", "application/json");
+      if (options.module) {
+        ProgressReporter.instance.setModule(options.module);
       }
-    }
-    return init;
-  }
-  async request(path, config) {
-    const init = this.buildRequestInit(config);
-    const response = await this.fetchImpl(this.buildUrl(path), init);
-    if (response.ok) {
-      return response;
-    }
-    const errorBody = await this.extractErrorBody(response);
-    throw new RegistryBrokerError("Registry broker request failed", {
-      status: response.status,
-      statusText: response.statusText,
-      body: errorBody
-    });
-  }
-  async requestAbsolute(url, config) {
-    const init = this.buildRequestInit(config);
-    const response = await this.fetchImpl(url, init);
-    if (response.ok) {
-      return response;
-    }
-    const errorBody = await this.extractErrorBody(response);
-    throw new RegistryBrokerError("Registry broker request failed", {
-      status: response.status,
-      statusText: response.statusText,
-      body: errorBody
-    });
-  }
-  async requestJson(path, config) {
-    const response = await this.request(path, config);
-    const contentType = response.headers?.get("content-type") ?? "";
-    if (!JSON_CONTENT_TYPE.test(contentType)) {
-      const body = await response.text();
-      throw new RegistryBrokerParseError(
-        "Expected JSON response from registry broker",
-        body
-      );
-    }
-    return await response.json();
-  }
-  async requestAbsoluteJson(url, config) {
-    const response = await this.requestAbsolute(url, config);
-    const contentType = response.headers?.get("content-type") ?? "";
-    if (!JSON_CONTENT_TYPE.test(contentType)) {
-      const body = await response.text();
-      throw new RegistryBrokerParseError(
-        "Expected JSON response from registry broker",
-        body
-      );
-    }
-    return await response.json();
-  }
-  async getAgentFeedback(uaid, options = {}) {
-    const normalized = uaid.trim();
-    if (!normalized) {
-      throw new Error("uaid is required");
-    }
-    const query = options.includeRevoked === true ? "?includeRevoked=true" : "";
-    const raw = await this.requestJson(
-      `/agents/${encodeURIComponent(normalized)}/feedback${query}`,
-      { method: "GET" }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackResponseSchema,
-      "agent feedback response"
-    );
-  }
-  async listAgentFeedbackIndex(options = {}) {
-    const params = new URLSearchParams();
-    if (typeof options.page === "number" && Number.isFinite(options.page)) {
-      params.set("page", String(Math.trunc(options.page)));
-    }
-    if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
-      params.set("limit", String(Math.trunc(options.limit)));
-    }
-    if (options.registries?.length) {
-      params.set("registry", options.registries.join(","));
-    }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(`/agents/feedback${suffix}`, {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackIndexResponseSchema,
-      "agent feedback index response"
-    );
-  }
-  async listAgentFeedbackEntriesIndex(options = {}) {
-    const params = new URLSearchParams();
-    if (typeof options.page === "number" && Number.isFinite(options.page)) {
-      params.set("page", String(Math.trunc(options.page)));
-    }
-    if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
-      params.set("limit", String(Math.trunc(options.limit)));
-    }
-    if (options.registries?.length) {
-      params.set("registry", options.registries.join(","));
-    }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(
-      `/agents/feedback/entries${suffix}`,
-      { method: "GET" }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackEntriesIndexResponseSchema,
-      "agent feedback entries index response"
-    );
-  }
-  async checkAgentFeedbackEligibility(uaid, payload) {
-    const normalized = uaid.trim();
-    if (!normalized) {
-      throw new Error("uaid is required");
-    }
-    const raw = await this.requestJson(
-      `/agents/${encodeURIComponent(normalized)}/feedback/eligibility`,
-      {
-        method: "POST",
-        body: payload,
-        headers: { "content-type": "application/json" }
+      if (options.logger) {
+        ProgressReporter.instance.setLogger(options.logger);
       }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackEligibilityResponseSchema,
-      "agent feedback eligibility response"
-    );
-  }
-  async submitAgentFeedback(uaid, payload) {
-    const normalized = uaid.trim();
-    if (!normalized) {
-      throw new Error("uaid is required");
-    }
-    const raw = await this.requestJson(
-      `/agents/${encodeURIComponent(normalized)}/feedback`,
-      {
-        method: "POST",
-        body: payload,
-        headers: { "content-type": "application/json" }
+      if (options.minPercent !== void 0) {
+        ProgressReporter.instance.setMinPercent(options.minPercent);
       }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackSubmissionResponseSchema,
-      "agent feedback submission response"
-    );
-  }
-  async search(params = {}) {
-    return search(this, params);
-  }
-  async delegate(request) {
-    return delegate(this, request);
-  }
-  async searchErc8004ByAgentId(params) {
-    const chainId = Math.floor(params.chainId);
-    if (!Number.isFinite(chainId) || chainId <= 0) {
-      throw new Error("chainId must be a positive integer");
-    }
-    const rawAgentId = typeof params.agentId === "bigint" ? params.agentId.toString() : String(params.agentId);
-    const agentId = rawAgentId.trim();
-    if (!agentId) {
-      throw new Error("agentId is required");
-    }
-    const nativeId = `${chainId}:${agentId}`;
-    return search(this, {
-      registries: ["erc-8004"],
-      limit: params.limit ?? 1,
-      ...typeof params.page === "number" ? { page: params.page } : {},
-      ...typeof params.sortBy === "string" ? { sortBy: params.sortBy } : {},
-      ...typeof params.sortOrder === "string" ? { sortOrder: params.sortOrder } : {},
-      metadata: {
-        nativeId: [nativeId],
-        networkKey: [`eip155:${chainId}`]
+      if (options.maxPercent !== void 0) {
+        ProgressReporter.instance.setMaxPercent(options.maxPercent);
       }
-    });
-  }
-  async stats() {
-    return stats(this);
-  }
-  async registries() {
-    return registries(this);
-  }
-  async getAdditionalRegistries() {
-    return getAdditionalRegistries(this);
-  }
-  async popularSearches() {
-    return popularSearches(this);
-  }
-  async listProtocols() {
-    return listProtocols(this);
-  }
-  async detectProtocol(message) {
-    return detectProtocol(this, message);
-  }
-  async registrySearchByNamespace(registry, query) {
-    return registrySearchByNamespace(this, registry, query);
-  }
-  async vectorSearch(request) {
-    return vectorSearch(this, request);
-  }
-  async searchStatus() {
-    return searchStatus(this);
-  }
-  async websocketStats() {
-    return websocketStats(this);
-  }
-  async metricsSummary() {
-    return metricsSummary(this);
-  }
-  async facets(adapter) {
-    return facets(this, adapter);
-  }
-  async adapters() {
-    return adapters(this);
-  }
-  async skillsConfig() {
-    return skillsConfig(this);
-  }
-  async listSkills(options) {
-    return listSkills(this, options);
-  }
-  async getSkillsCatalog(options) {
-    return getSkillsCatalog(this, options);
-  }
-  async listSkillVersions(params) {
-    return listSkillVersions(this, params);
-  }
-  async listMySkills(params) {
-    return listMySkills(this, params);
-  }
-  async getMySkillsList(params) {
-    return getMySkillsList(this, params);
-  }
-  async quoteSkillPublish(payload) {
-    return quoteSkillPublish(this, payload);
-  }
-  async quoteSkillPublishPreview(payload) {
-    return quoteSkillPublishPreview(this, payload);
-  }
-  async publishSkill(payload) {
-    return publishSkill(this, payload);
-  }
-  async getSkillPublishJob(jobId, params) {
-    return getSkillPublishJob(this, jobId, params);
-  }
-  async getSkillOwnership(params) {
-    return getSkillOwnership(this, params);
-  }
-  async getRecommendedSkillVersion(params) {
-    return getRecommendedSkillVersion(this, params);
-  }
-  async setRecommendedSkillVersion(payload) {
-    return setRecommendedSkillVersion(this, payload);
-  }
-  async getSkillDeprecations(params) {
-    return getSkillDeprecations(this, params);
-  }
-  async setSkillDeprecation(payload) {
-    return setSkillDeprecation(this, payload);
-  }
-  async getSkillBadge(params) {
-    return getSkillBadge(this, params);
-  }
-  async getSkillStatus(params) {
-    return getSkillStatus(this, params);
-  }
-  async getSkillSecurityBreakdown(params) {
-    return getSkillSecurityBreakdown(this, params);
-  }
-  async getSkillStatusByRepo(params) {
-    return getSkillStatusByRepo(this, params);
-  }
-  async getSkillConversionSignalsByRepo(params) {
-    return getSkillConversionSignalsByRepo(this, params);
-  }
-  async uploadSkillPreviewFromGithubOidc(payload) {
-    return uploadSkillPreviewFromGithubOidc(this, payload);
-  }
-  async getSkillPreview(params) {
-    return getSkillPreview(this, params);
-  }
-  async getSkillPreviewByRepo(params) {
-    return getSkillPreviewByRepo(this, params);
-  }
-  async getSkillPreviewById(previewId) {
-    return getSkillPreviewById(this, previewId);
-  }
-  async getSkillInstall(skillRef) {
-    return getSkillInstall(this, skillRef);
-  }
-  async recordSkillInstallCopy(skillRef, payload) {
-    return recordSkillInstallCopy(this, skillRef, payload);
-  }
-  async listSkillTags() {
-    return listSkillTags(this);
-  }
-  async listSkillCategories() {
-    return listSkillCategories(this);
-  }
-  async resolveSkillMarkdown(skillRef) {
-    return resolveSkillMarkdown(this, skillRef);
-  }
-  async resolveSkillManifest(skillRef) {
-    return resolveSkillManifest(this, skillRef);
-  }
-  async getSkillVoteStatus(params) {
-    return getSkillVoteStatus(this, params);
-  }
-  async setSkillVote(payload) {
-    return setSkillVote(this, payload);
-  }
-  async requestSkillVerification(payload) {
-    return requestSkillVerification(this, payload);
-  }
-  async getSkillVerificationStatus(params) {
-    return getSkillVerificationStatus(this, params);
-  }
-  async createSkillDomainProofChallenge(payload) {
-    return createSkillDomainProofChallenge(this, payload);
-  }
-  async verifySkillDomainProof(payload) {
-    return verifySkillDomainProof(this, payload);
-  }
-  async adaptersDetailed() {
-    return adaptersDetailed(this);
-  }
-  async adapterRegistryCategories() {
-    return adapterRegistryCategories(this);
+    }
+    return ProgressReporter.instance;
   }
-  async adapterRegistryAdapters(filters) {
-    return adapterRegistryAdapters(this, filters);
+  setCallback(callback) {
+    this.callback = callback;
   }
-  async createAdapterRegistryCategory(payload) {
-    return createAdapterRegistryCategory(this, payload);
+  setModule(module) {
+    this.module = module;
   }
-  async submitAdapterRegistryAdapter(payload) {
-    return submitAdapterRegistryAdapter(this, payload);
+  setLogger(logger) {
+    this.logger = logger;
   }
-  async adapterRegistrySubmissionStatus(submissionId) {
-    return adapterRegistrySubmissionStatus(this, submissionId);
+  setMinPercent(minPercent) {
+    this.minPercent = minPercent;
   }
-  async resolveUaid(uaid) {
-    return resolveUaid(this, uaid);
+  setMaxPercent(maxPercent) {
+    this.maxPercent = maxPercent;
   }
-  async performRegisterAgent(payload) {
-    const raw = await this.requestJson("/register", {
-      method: "POST",
-      body: serialiseAgentRegistrationRequest(payload),
-      headers: { "content-type": "application/json" }
+  createSubProgress(options) {
+    const subReporter = new ProgressReporter({
+      module: this.module,
+      logger: this.logger,
+      logProgress: this.logProgress,
+      minPercent: options.minPercent,
+      maxPercent: options.maxPercent
     });
-    return this.parseWithSchema(
-      raw,
-      registerAgentResponseSchema,
-      "register agent response"
-    );
-  }
-  calculateHbarAmount(creditsToPurchase, creditsPerHbar) {
-    if (creditsPerHbar <= 0) {
-      throw new Error("creditsPerHbar must be positive");
-    }
-    if (creditsToPurchase <= 0) {
-      throw new Error("creditsToPurchase must be positive");
-    }
-    const rawHbar = creditsToPurchase / creditsPerHbar;
-    const tinybars = Math.ceil(rawHbar * 1e8);
-    return tinybars / 1e8;
-  }
-  resolveCreditsToPurchase(shortfallCredits) {
-    if (!Number.isFinite(shortfallCredits) || shortfallCredits <= 0) {
-      return 0;
-    }
-    return Math.max(
-      Math.ceil(shortfallCredits),
-      MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS
-    );
-  }
-  async ensureCreditsForRegistration(payload, autoTopUp) {
-    const details = autoTopUp ?? null;
-    if (!details) {
-      return;
-    }
-    if (!details.accountId || !details.accountId.trim()) {
-      throw new Error("autoTopUp.accountId is required");
-    }
-    if (!details.privateKey || !details.privateKey.trim()) {
-      throw new Error("autoTopUp.privateKey is required");
-    }
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-      const quote = await this.getRegistrationQuote(payload);
-      const shortfall = quote.shortfallCredits ?? 0;
-      if (shortfall <= 0) {
-        return;
-      }
-      const creditsToPurchase = this.resolveCreditsToPurchase(shortfall);
-      if (creditsToPurchase <= 0) {
-        return;
-      }
-      const creditsPerHbar = quote.creditsPerHbar ?? null;
-      if (!creditsPerHbar || creditsPerHbar <= 0) {
-        throw new Error("Unable to determine credits per HBAR for auto top-up");
-      }
-      const hbarAmount = this.calculateHbarAmount(
-        creditsToPurchase,
-        creditsPerHbar
+    const logPrefix = options.logPrefix || "";
+    subReporter.setCallback((data) => {
+      const scaledPercent = this.scalePercent(
+        data.progressPercent,
+        options.minPercent,
+        options.maxPercent
       );
-      await this.purchaseCreditsWithHbar({
-        accountId: details.accountId.trim(),
-        privateKey: details.privateKey.trim(),
-        hbarAmount,
-        memo: details.memo ?? "Registry Broker auto top-up",
-        metadata: {
-          shortfallCredits: shortfall,
-          requiredCredits: quote.requiredCredits,
-          purchasedCredits: creditsToPurchase
-        }
-      });
-    }
-    const finalQuote = await this.getRegistrationQuote(payload);
-    if ((finalQuote.shortfallCredits ?? 0) > 0) {
-      throw new Error("Unable to purchase sufficient credits for registration");
-    }
-  }
-  async registerAgent(payload, options) {
-    const autoTopUp = options?.autoTopUp ?? this.registrationAutoTopUp;
-    if (!autoTopUp) {
-      return this.performRegisterAgent(payload);
-    }
-    await this.ensureCreditsForRegistration(payload, autoTopUp);
-    let retried = false;
-    while (true) {
-      try {
-        return await this.performRegisterAgent(payload);
-      } catch (error) {
-        const shortfall = this.extractInsufficientCreditsDetails(error);
-        if (shortfall && !retried) {
-          await this.ensureCreditsForRegistration(payload, autoTopUp);
-          retried = true;
-          continue;
-        }
-        throw error;
+      let formattedMessage = data.message;
+      if (logPrefix && !formattedMessage.startsWith(logPrefix)) {
+        formattedMessage = `${logPrefix}: ${formattedMessage}`;
       }
+      this.report({
+        stage: data.stage,
+        message: formattedMessage,
+        progressPercent: scaledPercent,
+        details: data.details
+      });
+    });
+    return subReporter;
+  }
+  report(data) {
+    const rawPercent = data.progressPercent;
+    const percent = Math.max(0, Math.min(100, rawPercent));
+    const scaledPercent = this.scalePercent(percent, 0, 100);
+    const now = Date.now();
+    if (scaledPercent === this.lastReportedPercent && now - this.lastReportedTime < this.throttleMs && data.stage !== "completed" && data.stage !== "failed") {
+      return;
     }
-  }
-  async getRegistrationQuote(payload) {
-    return getRegistrationQuote(this, payload);
-  }
-  async updateAgent(uaid, payload) {
-    return updateAgent(this, uaid, payload);
-  }
-  async getRegisterStatus(uaid) {
-    return getRegisterStatus(this, uaid);
-  }
-  async registerOwnedMoltbookAgent(uaid, payload) {
-    return registerOwnedMoltbookAgent(this, uaid, payload);
-  }
-  async getRegistrationProgress(attemptId) {
-    return getRegistrationProgress(this, attemptId);
-  }
-  async waitForRegistrationCompletion(attemptId, options) {
-    return waitForRegistrationCompletion(this, attemptId, options);
-  }
-  async validateUaid(uaid) {
-    return validateUaid(this, uaid);
-  }
-  async getUaidConnectionStatus(uaid) {
-    return getUaidConnectionStatus(this, uaid);
-  }
-  async closeUaidConnection(uaid) {
-    return closeUaidConnection(this, uaid);
-  }
-  async dashboardStats() {
-    return dashboardStats(this);
-  }
-  async getCreditsBalance(params = {}) {
-    return getCreditsBalance(this, params);
-  }
-  async getCreditProviders() {
-    return getCreditProviders(this);
-  }
-  async getGuardSession() {
-    return getGuardSession(this);
-  }
-  async getGuardEntitlements() {
-    return getGuardEntitlements(this);
-  }
-  async getGuardBillingBalance() {
-    return getGuardBillingBalance(this);
-  }
-  async getGuardFeed(limit) {
-    return getGuardFeed(this, limit);
-  }
-  async getGuardOverview() {
-    return getGuardOverview(this);
-  }
-  async getGuardTrustByHash(sha256) {
-    return getGuardTrustByHash(this, sha256);
-  }
-  async resolveGuardTrust(query) {
-    return resolveGuardTrust(this, query);
-  }
-  async getGuardRevocations() {
-    return getGuardRevocations(this);
-  }
-  async fetchGuardAdvisories() {
-    return fetchGuardAdvisories(this);
-  }
-  async fetchGuardPolicy() {
-    return fetchGuardPolicy(this);
-  }
-  async getGuardInventory() {
-    return getGuardInventory(this);
-  }
-  async getGuardReceiptHistory() {
-    return getGuardReceiptHistory(this);
-  }
-  async getGuardArtifactTimeline(artifactId) {
-    return getGuardArtifactTimeline(this, artifactId);
-  }
-  async getGuardInventoryDiff() {
-    return getGuardInventoryDiff(this);
-  }
-  async exportGuardAbom() {
-    return exportGuardAbom(this);
-  }
-  async exportGuardArtifactAbom(artifactId) {
-    return exportGuardArtifactAbom(this, artifactId);
-  }
-  async exportGuardReceipts() {
-    return exportGuardReceipts(this);
-  }
-  async getGuardDevices() {
-    return getGuardDevices(this);
-  }
-  async getGuardAlertPreferences() {
-    return getGuardAlertPreferences(this);
-  }
-  async updateGuardAlertPreferences(payload) {
-    return updateGuardAlertPreferences(this, payload);
-  }
-  async getGuardExceptions() {
-    return getGuardExceptions(this);
-  }
-  async getGuardWatchlist() {
-    return getGuardWatchlist(this);
-  }
-  async lookupGuardWatchlist(payload) {
-    return lookupGuardWatchlist(this, payload);
-  }
-  async getGuardPainSignals() {
-    return getGuardPainSignals(this);
-  }
-  async getGuardAggregatedPainSignals() {
-    return getGuardAggregatedPainSignals(this);
-  }
-  async getGuardPreInstallVerdict(payload) {
-    return getGuardPreInstallVerdict(this, payload);
-  }
-  async getGuardPreExecutionVerdict(payload) {
-    return getGuardPreExecutionVerdict(this, payload);
-  }
-  async addGuardWatchlistItem(payload) {
-    return addGuardWatchlistItem(this, payload);
-  }
-  async removeGuardWatchlistItem(artifactId) {
-    return removeGuardWatchlistItem(this, artifactId);
-  }
-  async addGuardException(payload) {
-    return addGuardException(this, payload);
-  }
-  async requestGuardException(payload) {
-    return requestGuardException(this, payload);
-  }
-  async removeGuardException(exceptionId) {
-    return removeGuardException(this, exceptionId);
-  }
-  async ingestGuardPainSignals(items) {
-    return ingestGuardPainSignals(this, items);
-  }
-  async syncGuardReceipts(payload) {
-    return syncGuardReceipts(this, payload);
-  }
-  async syncGuardInventory(payload) {
-    return syncGuardInventory(this, payload);
-  }
-  async submitGuardReceipts(payload) {
-    return submitGuardReceipts(this, payload);
-  }
-  async getGuardTeamPolicyPack() {
-    return getGuardTeamPolicyPack(this);
-  }
-  async updateGuardTeamPolicyPack(payload) {
-    return updateGuardTeamPolicyPack(this, payload);
-  }
-  async createHbarPurchaseIntent(payload) {
-    return createHbarPurchaseIntent(this, payload);
-  }
-  async purchaseCreditsWithHbar(params) {
-    return purchaseCreditsWithHbar(this, params);
-  }
-  async getX402Minimums() {
-    return getX402Minimums(this);
-  }
-  async purchaseCreditsWithX402(params) {
-    return purchaseCreditsWithX402(this, params);
-  }
-  async buyCreditsWithX402(params) {
-    return buyCreditsWithX402(this, params);
-  }
-  async generateEncryptionKeyPair(options = {}) {
-    return generateEncryptionKeyPair(this, options);
-  }
-  async createLedgerChallenge(payload) {
-    return createLedgerChallenge(this, payload);
-  }
-  async verifyLedgerChallenge(payload) {
-    return verifyLedgerChallenge(this, payload);
-  }
-  async authenticateWithLedger(options) {
-    return authenticateWithLedger(this, options);
-  }
-  async authenticateWithLedgerCredentials(options) {
-    return authenticateWithLedgerCredentials(this, options);
-  }
-  async getVerificationStatus(uaid) {
-    return getVerificationStatus(this, uaid);
-  }
-  async createVerificationChallenge(uaid) {
-    return createVerificationChallenge(this, uaid);
-  }
-  async getVerificationChallenge(challengeId) {
-    return getVerificationChallenge(this, challengeId);
-  }
-  async verifyVerificationChallenge(params) {
-    return verifyVerificationChallenge(this, params);
-  }
-  async getVerificationOwnership(uaid) {
-    return getVerificationOwnership(this, uaid);
-  }
-  async verifySenderOwnership(uaid) {
-    return verifySenderOwnership(this, uaid);
-  }
-  async verifyUaidDnsTxt(payload) {
-    return verifyUaidDnsTxt(this, payload);
-  }
-  async getVerificationDnsStatus(uaid, query) {
-    return getVerificationDnsStatus(this, uaid, query);
-  }
-  async fetchHistorySnapshot(sessionId, options) {
-    return fetchHistorySnapshot(
-      this.conversationContexts,
-      this,
-      sessionId,
-      options
-    );
-  }
-  attachDecryptedHistory(sessionId, snapshot, options) {
-    return attachDecryptedHistory(
-      this.conversationContexts,
-      this,
-      sessionId,
-      snapshot,
-      options
-    );
-  }
-  registerConversationContextForEncryption(context) {
-    registerConversationContextForEncryption(
-      this.conversationContexts,
-      context
-    );
-  }
-  resolveDecryptionContext(sessionId, options) {
-    return resolveDecryptionContext(
-      this.conversationContexts,
-      this,
-      sessionId,
-      options
-    );
-  }
-  decryptHistoryEntryFromContext(_sessionId, entry, context) {
-    return decryptHistoryEntryFromContext(this, entry, context);
-  }
-  async createSession(payload, allowHistoryAutoTopUp = true) {
-    return createSession(this, payload, allowHistoryAutoTopUp);
-  }
-  async resumeSession(sessionId) {
-    return resumeSession(this, sessionId);
-  }
-  async checkChatReadiness(payload) {
-    return checkChatReadiness(this, payload);
-  }
-  async startChat(options) {
-    return startChat(this, this.getEncryptedChatManager(), options);
-  }
-  async startConversation(options) {
-    return startConversation(this, this.getEncryptedChatManager(), options);
-  }
-  async acceptConversation(options) {
-    return acceptConversation(
-      this,
-      this.getEncryptedChatManager(),
-      options
-    );
-  }
-  compactHistory(payload) {
-    return compactHistory(this, payload);
-  }
-  fetchEncryptionStatus(sessionId) {
-    return fetchEncryptionStatus(this, sessionId);
-  }
-  postEncryptionHandshake(sessionId, payload) {
-    return postEncryptionHandshake(this, sessionId, payload);
-  }
-  sendMessage(payload) {
-    return sendMessage(this, payload);
-  }
-  retryMessage(messageId, payload) {
-    return retryMessage(this, messageId, payload);
-  }
-  cancelSession(sessionId) {
-    return cancelSession(this, sessionId);
-  }
-  endSession(sessionId) {
-    return endSession(this, sessionId);
-  }
-  createPlaintextConversationHandle(sessionId, summary, defaultAuth, context) {
-    return createPlaintextConversationHandle(
-      this,
-      sessionId,
-      summary,
-      defaultAuth,
-      context
-    );
-  }
-  getEncryptedChatManager() {
-    if (this.encryptedChatManager) {
-      return this.encryptedChatManager;
+    this.lastReportedPercent = scaledPercent;
+    this.lastReportedTime = now;
+    const progressData = {
+      ...data,
+      progressPercent: scaledPercent
+    };
+    if (this.logProgress) {
+      this.logger.debug(
+        `[${this.module}] [${data.stage.toUpperCase()}] ${data.message} (${scaledPercent.toFixed(1)}%)`,
+        data.details
+      );
     }
-    const manager = new EncryptedChatManager(this);
-    this.encryptedChatManager = manager;
-    return manager;
-  }
-  async extractErrorBody(response) {
-    const contentType = response.headers?.get("content-type") ?? "";
-    if (JSON_CONTENT_TYPE.test(contentType)) {
+    if (this.callback) {
       try {
-        return await response.json();
-      } catch (error) {
-        return { parseError: String(error) };
+        this.callback(progressData);
+      } catch (err) {
+        this.logger.warn(`Error in progress callback: ${err}`);
       }
     }
-    try {
-      return await response.text();
-    } catch (error) {
-      return { parseError: String(error) };
-    }
   }
-  parseWithSchema(value, schema, context) {
-    try {
-      return schema.parse(value);
-    } catch (error) {
-      throw new RegistryBrokerParseError(
-        `Failed to parse ${context}`,
-        error instanceof ZodError || error instanceof Error ? error : String(error),
-        value
-      );
-    }
+  scalePercent(percent, sourceMin, sourceMax) {
+    const range = this.maxPercent - this.minPercent;
+    const sourceRange = sourceMax - sourceMin;
+    const scaleFactor = range / sourceRange;
+    return this.minPercent + (percent - sourceMin) * scaleFactor;
   }
-  async delay(ms, signal) {
-    if (ms <= 0) {
-      if (signal?.aborted) {
-        throw createAbortError();
-      }
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (signal) {
-          signal.removeEventListener("abort", onAbort);
-        }
-        resolve();
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", onAbort);
-        reject(createAbortError());
-      };
-      if (signal) {
-        if (signal.aborted) {
-          clearTimeout(timer);
-          reject(createAbortError());
-          return;
-        }
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
+  preparing(message, percent, details) {
+    this.report({
+      stage: "preparing",
+      message,
+      progressPercent: percent,
+      details
     });
   }
-  assertNodeRuntime(feature) {
-    if (typeof process === "undefined" || !process.versions?.node) {
-      throw new Error(`${feature} is only available in Node.js environments`);
-    }
-  }
-  getNodeCrypto(feature) {
-    this.assertNodeRuntime(feature);
-    const nodeCrypto = optionalImportSync("node:crypto") ?? optionalImportSync("crypto");
-    if (!nodeCrypto) {
-      throw new Error(`${feature} requires the Node.js crypto module`);
-    }
-    return nodeCrypto;
-  }
-  getSecureRandomBytes(size, feature) {
-    const webCrypto = globalThis.crypto;
-    if (webCrypto && typeof webCrypto.getRandomValues === "function") {
-      const bytes = new Uint8Array(size);
-      webCrypto.getRandomValues(bytes);
-      return bytes;
-    }
-    return this.getNodeCrypto(feature).randomBytes(size);
-  }
-  createEphemeralKeyPair() {
-    const privateKeyBytes = this.getSecureRandomBytes(
-      32,
-      "generateEphemeralKeyPair"
-    );
-    const publicKey = secp256k1.getPublicKey(privateKeyBytes, true);
-    return {
-      privateKey: Buffer.from(privateKeyBytes).toString("hex"),
-      publicKey: Buffer.from(publicKey).toString("hex")
-    };
-  }
-  deriveSharedSecret(options) {
-    const { createHash } = this.getNodeCrypto("deriveSharedSecret");
-    const privateKey = this.hexToBuffer(options.privateKey);
-    const peerPublicKey = this.hexToBuffer(options.peerPublicKey);
-    const shared = secp256k1.getSharedSecret(privateKey, peerPublicKey, true);
-    return createHash("sha256").update(Buffer.from(shared)).digest();
-  }
-  buildCipherEnvelope(options) {
-    const { createCipheriv, randomBytes } = this.getNodeCrypto(
-      "encryptCipherEnvelope"
-    );
-    const sharedSecret = this.normalizeSharedSecret(options.sharedSecret);
-    const iv = randomBytes(12);
-    const cipher = createCipheriv("aes-256-gcm", sharedSecret, iv);
-    const aadSource = options.associatedData ?? options.sessionId;
-    const associatedDataEncoded = aadSource ? Buffer.from(aadSource, "utf8").toString("base64") : void 0;
-    if (aadSource) {
-      cipher.setAAD(Buffer.from(aadSource, "utf8"));
-    }
-    const ciphertext = Buffer.concat([
-      cipher.update(Buffer.from(options.plaintext, "utf8")),
-      cipher.final()
-    ]);
-    const tag = cipher.getAuthTag();
-    const payload = Buffer.concat([ciphertext, tag]);
-    return {
-      algorithm: "aes-256-gcm",
-      ciphertext: payload.toString("base64"),
-      nonce: iv.toString("base64"),
-      associatedData: associatedDataEncoded,
-      keyLocator: {
-        sessionId: options.sessionId,
-        revision: options.revision ?? 1
-      },
-      recipients: options.recipients.map((recipient) => ({
-        ...recipient,
-        encryptedShare: ""
-      }))
-    };
-  }
-  openCipherEnvelope(options) {
-    const { createDecipheriv } = this.getNodeCrypto("decryptCipherEnvelope");
-    const sharedSecret = this.normalizeSharedSecret(options.sharedSecret);
-    const payload = Buffer.from(options.envelope.ciphertext, "base64");
-    const nonce = Buffer.from(options.envelope.nonce, "base64");
-    const ciphertext = payload.slice(0, payload.length - 16);
-    const tag = payload.slice(payload.length - 16);
-    const decipher = createDecipheriv("aes-256-gcm", sharedSecret, nonce);
-    if (options.envelope.associatedData) {
-      decipher.setAAD(Buffer.from(options.envelope.associatedData, "base64"));
-    }
-    decipher.setAuthTag(tag);
-    const plaintext = Buffer.concat([
-      decipher.update(ciphertext),
-      decipher.final()
-    ]);
-    return plaintext.toString(options.encoding ?? "utf8");
-  }
-  normalizeSharedSecret(input) {
-    if (Buffer.isBuffer(input)) {
-      return Buffer.from(input);
-    }
-    if (input instanceof Uint8Array) {
-      return Buffer.from(input);
-    }
-    if (typeof input === "string") {
-      return this.bufferFromString(input);
-    }
-    throw new Error("Unsupported shared secret input");
-  }
-  bufferFromString(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      throw new Error("sharedSecret string cannot be empty");
-    }
-    const normalized = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
-    if (/^[0-9a-fA-F]+$/.test(normalized) && normalized.length % 2 === 0) {
-      return Buffer.from(normalized, "hex");
-    }
-    return Buffer.from(trimmed, "base64");
-  }
-  hexToBuffer(value) {
-    const normalized = value.startsWith("0x") ? value.slice(2) : value;
-    if (!/^[0-9a-fA-F]+$/.test(normalized) || normalized.length % 2 !== 0) {
-      throw new Error("Expected hex-encoded value");
-    }
-    return Buffer.from(normalized, "hex");
-  }
-  extractInsufficientCreditsDetails(error) {
-    if (!(error instanceof RegistryBrokerError) || error.status !== 402) {
-      return null;
-    }
-    const body = error.body;
-    if (!body || typeof body !== "object" || Array.isArray(body)) {
-      return null;
-    }
-    const maybeShortfall = body["shortfallCredits"];
-    if (typeof maybeShortfall !== "number" || maybeShortfall <= 0) {
-      return null;
-    }
-    return { shortfallCredits: maybeShortfall };
-  }
-  extractErrorMessage(body) {
-    if (typeof body === "string") {
-      return body;
-    }
-    if (isJsonObject(body) && typeof body.error === "string") {
-      return body.error;
-    }
-    if (isJsonObject(body) && typeof body.message === "string") {
-      return body.message;
-    }
-    return void 0;
+  submitting(message, percent, details) {
+    this.report({
+      stage: "submitting",
+      message,
+      progressPercent: percent,
+      details
+    });
   }
-  shouldAutoTopUpHistory(payload, error) {
-    if (!this.historyAutoTopUp || payload.historyTtlSeconds === void 0) {
-      return false;
-    }
-    if (!(error instanceof RegistryBrokerError)) {
-      return false;
-    }
-    if (error.status !== 402) {
-      return false;
-    }
-    const message = this.extractErrorMessage(error.body);
-    if (!message) {
-      return true;
-    }
-    const normalised = message.toLowerCase();
-    return normalised.includes("history") || normalised.includes("chat history");
+  confirming(message, percent, details) {
+    this.report({
+      stage: "confirming",
+      message,
+      progressPercent: percent,
+      details
+    });
   }
-  async executeHistoryAutoTopUp(reason) {
-    if (!this.historyAutoTopUp) {
-      return;
-    }
-    const hbarAmount = this.historyAutoTopUp.hbarAmount && this.historyAutoTopUp.hbarAmount > 0 ? this.historyAutoTopUp.hbarAmount : DEFAULT_HISTORY_TOP_UP_HBAR;
-    await this.purchaseCreditsWithHbar({
-      accountId: this.historyAutoTopUp.accountId,
-      privateKey: this.historyAutoTopUp.privateKey,
-      hbarAmount,
-      memo: this.historyAutoTopUp.memo ?? "registry-broker-client:chat-history-topup",
-      metadata: {
-        purpose: "chat-history",
-        reason
-      }
+  verifying(message, percent, details) {
+    this.report({
+      stage: "verifying",
+      message,
+      progressPercent: percent,
+      details
     });
   }
-  initializeEncryptionBootstrap(options) {
-    return this.bootstrapEncryptionOptions(options).then(() => void 0);
+  completed(message, details) {
+    this.report({ stage: "completed", message, progressPercent: 100, details });
   }
-  bootstrapEncryptionOptions(options) {
-    return bootstrapEncryptionOptions(this, options);
+  failed(message, details) {
+    this.report({
+      stage: "failed",
+      message,
+      progressPercent: this.lastReportedPercent,
+      details
+    });
   }
 }
-const isPendingRegisterAgentResponse = (response) => response.status === "pending";
-const isPartialRegisterAgentResponse = (response) => response.status === "partial" && response.success === false;
-const isSuccessRegisterAgentResponse = (response) => response.success === true && response.status !== "pending";
 export {
-  RegistryBrokerClient,
-  isPartialRegisterAgentResponse,
-  isPendingRegisterAgentResponse,
-  isSuccessRegisterAgentResponse
+  ProgressReporter
 };
 //# sourceMappingURL=standards-sdk.es150.js.map