@hashgraphonline/standards-sdk 0.1.184 → 0.1.186

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

@@ -1,90 +1,1160 @@
-const normalise = (value) => value.trim().toLowerCase();
-const HEDERA_NETWORK_ALIASES = /* @__PURE__ */ new Map([
-  ["hedera:mainnet", { canonical: "hedera:mainnet", hederaNetwork: "mainnet" }],
-  ["mainnet", { canonical: "hedera:mainnet", hederaNetwork: "mainnet" }],
-  ["hedera-mainnet", { canonical: "hedera:mainnet", hederaNetwork: "mainnet" }],
-  ["hedera_mainnet", { canonical: "hedera:mainnet", hederaNetwork: "mainnet" }],
-  ["hedera:testnet", { canonical: "hedera:testnet", hederaNetwork: "testnet" }],
-  ["testnet", { canonical: "hedera:testnet", hederaNetwork: "testnet" }],
-  ["hedera-testnet", { canonical: "hedera:testnet", hederaNetwork: "testnet" }],
-  ["hedera_testnet", { canonical: "hedera:testnet", hederaNetwork: "testnet" }]
-]);
-const EVM_NETWORK_CHAIN_IDS = {
-  abstract: 2741,
-  "abstract-testnet": 11124,
-  base: 8453,
-  "base-sepolia": 84532,
-  avalanche: 43114,
-  "avalanche-fuji": 43113,
-  iotex: 4689,
-  sei: 1329,
-  "sei-testnet": 1328,
-  polygon: 137,
-  "polygon-amoy": 80002,
-  peaq: 3338
-};
-const CHAIN_ID_TO_ALIAS = new Map(
-  Object.entries(EVM_NETWORK_CHAIN_IDS).map(([alias, id]) => [id, alias])
-);
-const parseChainId = (value) => {
-  if (/^eip155:\d+$/i.test(value)) {
-    return Number.parseInt(value.split(":")[1], 10);
+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.es157.js";
+import { fetchHistorySnapshot, attachDecryptedHistory, registerConversationContextForEncryption, resolveDecryptionContext, decryptHistoryEntryFromContext } from "./standards-sdk.es198.js";
+import { createChatApi, createSession, resumeSession, checkChatReadiness, startChat, startConversation, acceptConversation, compactHistory, fetchEncryptionStatus, postEncryptionHandshake, sendMessage, retryMessage, cancelSession, endSession, createPlaintextConversationHandle } from "./standards-sdk.es199.js";
+import { EncryptedChatManager } from "./standards-sdk.es200.js";
+import { generateEncryptionKeyPair, bootstrapEncryptionOptions, createEncryptionApi } from "./standards-sdk.es201.js";
+import { adapters, adaptersDetailed, adapterRegistryCategories, adapterRegistryAdapters, createAdapterRegistryCategory, submitAdapterRegistryAdapter, adapterRegistrySubmissionStatus } from "./standards-sdk.es202.js";
+import { resolveUaid, getRegistrationQuote, updateAgent, getRegistrationProgress, waitForRegistrationCompletion, validateUaid, getUaidConnectionStatus, closeUaidConnection, dashboardStats } from "./standards-sdk.es152.js";
+import { getRegisterStatus, registerOwnedMoltbookAgent, getVerificationStatus, createVerificationChallenge, getVerificationChallenge, verifyVerificationChallenge, getVerificationOwnership, verifySenderOwnership, verifyUaidDnsTxt, getVerificationDnsStatus } from "./standards-sdk.es203.js";
+import { getCreditsBalance, getCreditProviders, createHbarPurchaseIntent, purchaseCreditsWithHbar, getX402Minimums, purchaseCreditsWithX402, buyCreditsWithX402 } from "./standards-sdk.es204.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.es205.js";
+import { createLedgerChallenge, verifyLedgerChallenge, authenticateWithLedger, authenticateWithLedgerCredentials } from "./standards-sdk.es206.js";
+import { search, delegate, stats, registries, getAdditionalRegistries, popularSearches, listProtocols, detectProtocol, registrySearchByNamespace, vectorSearch, searchStatus, websocketStats, metricsSummary, facets } from "./standards-sdk.es207.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.es186.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.es208.js";
+import { RegistryBrokerError, RegistryBrokerParseError } from "./standards-sdk.es151.js";
+import { optionalImportSync } from "./standards-sdk.es187.js";
+class RegistryBrokerClient {
+  constructor(options = {}) {
+    this.encryptionBootstrapPromise = null;
+    this.chatApi = 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;
+      }
+    });
+    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.registrationAutoTopUp = registrationAutoTopUp;
+    this.historyAutoTopUp = historyAutoTopUp;
+    this.encryptionOptions = encryption;
+    if (this.encryptionOptions) {
+      this.encryptionBootstrapPromise = this.initializeEncryptionBootstrap(
+        this.encryptionOptions
+      );
+    }
   }
-  if (/^\d+$/.test(value)) {
-    return Number.parseInt(value, 10);
+  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 };
   }
-  return void 0;
-};
-const normaliseEvmNetwork = (value) => {
-  const trimmed = normalise(value);
-  let chainId = parseChainId(trimmed);
-  let alias;
-  if (chainId === void 0) {
-    const mapped = EVM_NETWORK_CHAIN_IDS[trimmed];
-    if (mapped !== void 0) {
-      chainId = mapped;
-      alias = trimmed;
-    }
-  } else if (CHAIN_ID_TO_ALIAS.has(chainId)) {
-    alias = CHAIN_ID_TO_ALIAS.get(chainId);
-  }
-  if (chainId === void 0) {
-    throw new Error(
-      'Unsupported EVM ledger network. Provide an alias like "base-sepolia" or a canonical eip155:<chainId> string.'
-    );
-  }
-  return {
-    canonical: `eip155:${chainId}`,
-    kind: "evm",
-    chainId,
-    legacyName: alias
-  };
-};
-const normaliseHederaNetwork = (value) => {
-  const trimmed = normalise(value);
-  const mapping = HEDERA_NETWORK_ALIASES.get(trimmed);
-  if (!mapping) {
-    throw new Error(
-      'Unsupported Hedera network. Use hedera:mainnet or hedera:testnet (legacy "mainnet"/"testnet" also accepted).'
-    );
-  }
-  return {
-    canonical: mapping.canonical,
-    kind: "hedera",
-    hederaNetwork: mapping.hederaNetwork
-  };
-};
-const canonicalizeLedgerNetwork = (network) => {
-  if (typeof network !== "string" || network.trim().length === 0) {
-    throw new Error("Ledger network is required.");
+  get chat() {
+    if (this.chatApi) {
+      return this.chatApi;
+    }
+    const api = createChatApi(this, this.getEncryptedChatManager());
+    this.chatApi = api;
+    return api;
   }
-  const trimmed = normalise(network);
-  if (trimmed.startsWith("hedera:") || trimmed.includes("hedera-") || trimmed.includes("hedera_") || trimmed === "mainnet" || trimmed === "testnet") {
-    return normaliseHederaNetwork(trimmed);
+  get encryption() {
+    if (this.encryptionApi) {
+      return this.encryptionApi;
+    }
+    const api = createEncryptionApi(this);
+    this.encryptionApi = api;
+    return api;
   }
-  return normaliseEvmNetwork(trimmed);
-};
+  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");
+      }
+    }
+    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" }
+      }
+    );
+    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" }
+      }
+    );
+    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}`]
+      }
+    });
+  }
+  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);
+  }
+  async adapterRegistryAdapters(filters) {
+    return adapterRegistryAdapters(this, filters);
+  }
+  async createAdapterRegistryCategory(payload) {
+    return createAdapterRegistryCategory(this, payload);
+  }
+  async submitAdapterRegistryAdapter(payload) {
+    return submitAdapterRegistryAdapter(this, payload);
+  }
+  async adapterRegistrySubmissionStatus(submissionId) {
+    return adapterRegistrySubmissionStatus(this, submissionId);
+  }
+  async resolveUaid(uaid) {
+    return resolveUaid(this, uaid);
+  }
+  async performRegisterAgent(payload) {
+    const raw = await this.requestJson("/register", {
+      method: "POST",
+      body: serialiseAgentRegistrationRequest(payload),
+      headers: { "content-type": "application/json" }
+    });
+    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
+      );
+      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;
+      }
+    }
+  }
+  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;
+    }
+    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)) {
+      try {
+        return await response.json();
+      } catch (error) {
+        return { parseError: String(error) };
+      }
+    }
+    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
+      );
+    }
+  }
+  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 });
+      }
+    });
+  }
+  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;
+  }
+  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");
+  }
+  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
+      }
+    });
+  }
+  initializeEncryptionBootstrap(options) {
+    return this.bootstrapEncryptionOptions(options).then(() => void 0);
+  }
+  bootstrapEncryptionOptions(options) {
+    return bootstrapEncryptionOptions(this, options);
+  }
+}
+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 {
-  canonicalizeLedgerNetwork
+  RegistryBrokerClient,
+  isPartialRegisterAgentResponse,
+  isPendingRegisterAgentResponse,
+  isSuccessRegisterAgentResponse
 };
 //# sourceMappingURL=standards-sdk.es150.js.map