@hashgraphonline/standards-sdk 0.1.161 → 0.1.162

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

@@ -1,896 +1,84 @@
-import { Buffer } from "buffer";
-import { randomBytes, createHash, createCipheriv, createDecipheriv } from "crypto";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { ZodError } from "zod";
-import { agentFeedbackResponseSchema, agentFeedbackIndexResponseSchema, agentFeedbackEntriesIndexResponseSchema, agentFeedbackEligibilityResponseSchema, agentFeedbackSubmissionResponseSchema, registerAgentResponseSchema } from "./standards-sdk.es139.js";
-import { fetchHistorySnapshot, attachDecryptedHistory, registerConversationContextForEncryption, resolveDecryptionContext, decryptHistoryEntryFromContext } from "./standards-sdk.es174.js";
-import { createChatApi, createSession, startChat, startConversation, acceptConversation, compactHistory, fetchEncryptionStatus, postEncryptionHandshake, sendMessage, endSession, createPlaintextConversationHandle } from "./standards-sdk.es175.js";
-import { EncryptedChatManager } from "./standards-sdk.es176.js";
-import { createEncryptionApi, generateEncryptionKeyPair, bootstrapEncryptionOptions } from "./standards-sdk.es167.js";
-import { adapters, adaptersDetailed, adapterRegistryCategories, adapterRegistryAdapters, createAdapterRegistryCategory, submitAdapterRegistryAdapter, adapterRegistrySubmissionStatus } from "./standards-sdk.es170.js";
-import { resolveUaid, getRegistrationQuote, updateAgent, getRegistrationProgress, waitForRegistrationCompletion, validateUaid, getUaidConnectionStatus, closeUaidConnection, dashboardStats } from "./standards-sdk.es172.js";
-import { getRegisterStatus, registerOwnedMoltbookAgent, getVerificationStatus, createVerificationChallenge, getVerificationChallenge, verifyVerificationChallenge, getVerificationOwnership, verifySenderOwnership } from "./standards-sdk.es177.js";
-import { purchaseCreditsWithHbar, getX402Minimums, purchaseCreditsWithX402, buyCreditsWithX402 } from "./standards-sdk.es171.js";
-import { createLedgerChallenge, verifyLedgerChallenge, authenticateWithLedger, authenticateWithLedgerCredentials } from "./standards-sdk.es173.js";
-import { search, stats, registries, getAdditionalRegistries, popularSearches, listProtocols, detectProtocol, registrySearchByNamespace, vectorSearch, searchStatus, websocketStats, metricsSummary, facets } from "./standards-sdk.es168.js";
-import { skillsConfig, listSkills, listSkillVersions, listMySkills, getMySkillsList, quoteSkillPublish, publishSkill, getSkillPublishJob, getSkillOwnership, getSkillVoteStatus, setSkillVote, requestSkillVerification, getSkillVerificationStatus } from "./standards-sdk.es166.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.es169.js";
-import { RegistryBrokerError, RegistryBrokerParseError } from "./standards-sdk.es140.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
-      );
-    }
-  }
-  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;
-  }
-  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}`;
-  }
-  async request(path, 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");
-      }
-    }
-    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 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 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 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 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 publishSkill(payload) {
-    return publishSkill(this, payload);
-  }
-  async getSkillPublishJob(jobId, params) {
-    return getSkillPublishJob(this, jobId, params);
-  }
-  async getSkillOwnership(params) {
-    return getSkillOwnership(this, params);
-  }
-  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 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 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 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 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);
-  }
-  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`);
-    }
-  }
-  createEphemeralKeyPair() {
-    this.assertNodeRuntime("generateEphemeralKeyPair");
-    const privateKeyBytes = randomBytes(32);
-    const publicKey = secp256k1.getPublicKey(privateKeyBytes, true);
-    return {
-      privateKey: Buffer.from(privateKeyBytes).toString("hex"),
-      publicKey: Buffer.from(publicKey).toString("hex")
-    };
-  }
-  deriveSharedSecret(options) {
-    this.assertNodeRuntime("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) {
-    this.assertNodeRuntime("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) {
-    this.assertNodeRuntime("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);
+import { optionalImportSync, optionalImport } from "./standards-sdk.es158.js";
+const unsupported = (method) => new Error(`${method} is not supported by the in-memory signer`);
+let cachedSdk = null;
+const loadHashgraphSdk = () => {
+  if (cachedSdk) {
+    return cachedSdk;
+  }
+  const resolved = optionalImportSync("@hashgraph/sdk");
+  if (resolved) {
+    cachedSdk = resolved;
+    return resolved;
+  }
+  const message = "@hashgraph/sdk is required for ledger signing. Install it as a dependency to enable createPrivateKeySigner.";
+  throw new Error(message);
+};
+const loadHashgraphSdkAsync = async () => {
+  if (cachedSdk) {
+    return cachedSdk;
   }
-  bootstrapEncryptionOptions(options) {
-    return bootstrapEncryptionOptions(this, options);
+  const resolved = await optionalImport("@hashgraph/sdk");
+  if (resolved) {
+    cachedSdk = resolved;
+    return resolved;
   }
-}
-const isPendingRegisterAgentResponse = (response) => response.status === "pending";
-const isPartialRegisterAgentResponse = (response) => response.status === "partial" && response.success === false;
-const isSuccessRegisterAgentResponse = (response) => response.success === true && response.status !== "pending";
+  const message = "@hashgraph/sdk is required for ledger signing. Install it as a dependency to enable createPrivateKeySigner.";
+  throw new Error(message);
+};
+const buildSigner = (sdk, options) => {
+  const { AccountId, LedgerId, PrivateKey, SignerSignature } = sdk;
+  if (!options.privateKey) {
+    throw new Error("privateKey is required to create a ledger signer.");
+  }
+  if (!options.accountId) {
+    throw new Error("accountId is required to create a ledger signer.");
+  }
+  const accountId = AccountId.fromString(options.accountId);
+  const privateKey = PrivateKey.fromString(options.privateKey);
+  const ledgerId = LedgerId.fromString(options.network);
+  return {
+    getLedgerId: () => ledgerId,
+    getAccountId: () => accountId,
+    getAccountKey: () => privateKey.publicKey,
+    getNetwork: () => ({}),
+    getMirrorNetwork: () => [],
+    sign: async (messages) => Promise.all(
+      messages.map(async (message) => {
+        const signature = await privateKey.sign(message);
+        return new SignerSignature({
+          publicKey: privateKey.publicKey,
+          signature,
+          accountId
+        });
+      })
+    ),
+    getAccountBalance: async () => {
+      throw unsupported("getAccountBalance");
+    },
+    getAccountInfo: async () => {
+      throw unsupported("getAccountInfo");
+    },
+    getAccountRecords: async () => {
+      throw unsupported("getAccountRecords");
+    },
+    signTransaction: async (_) => {
+      throw unsupported("signTransaction");
+    },
+    checkTransaction: async (_) => {
+      throw unsupported("checkTransaction");
+    },
+    populateTransaction: async (_) => {
+      throw unsupported("populateTransaction");
+    },
+    call: async (_request) => {
+      throw unsupported("call");
+    }
+  };
+};
+const createPrivateKeySigner = (options) => buildSigner(loadHashgraphSdk(), options);
+const createPrivateKeySignerAsync = async (options) => buildSigner(await loadHashgraphSdkAsync(), options);
 export {
-  RegistryBrokerClient,
-  isPartialRegisterAgentResponse,
-  isPendingRegisterAgentResponse,
-  isSuccessRegisterAgentResponse
+  createPrivateKeySigner,
+  createPrivateKeySignerAsync
 };
 //# sourceMappingURL=standards-sdk.es143.js.map