@hashgraphonline/standards-sdk 0.1.146-chore-jsr-improvements.canary.01d3174.92 → 0.1.146-chore-jsr-improvements.canary.62a5b19.93

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

@@ -1,628 +1,89 @@
-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, searchResponseSchema, statsResponseSchema, registriesResponseSchema, additionalRegistryCatalogResponseSchema, popularResponseSchema, protocolsResponseSchema, detectProtocolResponseSchema, registrySearchByNamespaceSchema, vectorSearchResponseSchema, searchStatusResponseSchema, websocketStatsResponseSchema, metricsSummaryResponseSchema, searchFacetsResponseSchema } from "./standards-sdk.es150.js";
-import { DEFAULT_BASE_URL, normaliseBaseUrl, normaliseHeaderName, isBrowserRuntime, DEFAULT_USER_AGENT, JSON_CONTENT_TYPE, createAbortError, isJsonObject, DEFAULT_HISTORY_TOP_UP_HBAR, buildSearchQuery } from "./standards-sdk.es159.js";
-import { RegistryBrokerError, RegistryBrokerParseError } from "./standards-sdk.es135.js";
-class RegistryBrokerClient {
-  constructor(options = {}) {
-    this.encryptionBootstrapPromise = null;
-    const {
-      baseUrl = DEFAULT_BASE_URL,
-      fetchImplementation,
-      defaultHeaders,
-      apiKey,
-      ledgerApiKey,
-      registrationAutoTopUp,
-      historyAutoTopUp,
-      encryption
-    } = options;
-    this.baseUrl = normaliseBaseUrl(baseUrl);
-    this.fetchImpl = fetchImplementation ?? fetch;
-    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;
-      }
-    });
-    if (apiKey) {
-      this.defaultHeaders["x-api-key"] = apiKey;
-    }
-    if (ledgerApiKey) {
-      this.defaultHeaders["x-ledger-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 };
-  }
-  setApiKey(apiKey) {
-    this.setDefaultHeader("x-api-key", apiKey);
-  }
-  setLedgerApiKey(apiKey) {
-    this.setDefaultHeader("x-ledger-api-key", apiKey);
-  }
-  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);
+import { Logger } from "./standards-sdk.es105.js";
+class ContentResolverRegistryImpl {
+  constructor() {
+    this.resolver = null;
+    this.onUnavailableCallbacks = [];
+    this.logger = Logger.getInstance({ module: "ContentResolverRegistry" });
+  }
+  static getInstance() {
+    if (!ContentResolverRegistryImpl._instance) {
+      ContentResolverRegistryImpl._instance = new ContentResolverRegistryImpl();
+    }
+    return ContentResolverRegistryImpl._instance;
+  }
+  /**
+   * Register a content resolver (typically called by ContentStoreManager)
+   */
+  register(resolver) {
+    if (this.resolver) {
+      this.logger.warn("Resolver already registered, replacing existing");
+    }
+    this.resolver = resolver;
+    this.logger.info("Content resolver registered");
+  }
+  /**
+   * Get the registered content resolver
+   */
+  getResolver() {
+    return this.resolver;
+  }
+  /**
+   * Check if a resolver is available
+   */
+  isAvailable() {
+    return this.resolver !== null;
+  }
+  /**
+   * Unregister the current resolver
+   */
+  unregister() {
+    if (this.resolver) {
+      this.resolver = null;
+      this.logger.info("Content resolver unregistered");
+      this.onUnavailableCallbacks.forEach((callback) => {
+        try {
+          callback();
+        } catch (error) {
+          this.logger.error("Error in unavailable callback:", error);
+        }
       });
     }
-    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();
+  /**
+   * Register callback for when resolver becomes unavailable
+   */
+  onUnavailable(callback) {
+    this.onUnavailableCallbacks.push(callback);
   }
-  async getAgentFeedback(uaid, options = {}) {
-    const normalized = uaid.trim();
-    if (!normalized) {
-      throw new Error("uaid is required");
+  /**
+   * Remove unavailable callback
+   */
+  offUnavailable(callback) {
+    const index = this.onUnavailableCallbacks.indexOf(callback);
+    if (index !== -1) {
+      this.onUnavailableCallbacks.splice(index, 1);
     }
-    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 extractErrorBody(response) {
-    const contentType = response.headers?.get("content-type") ?? "";
-    if (JSON_CONTENT_TYPE.test(contentType)) {
+  /**
+   * Execute operation with resolver or fallback
+   */
+  async withResolver(operation, fallback) {
+    if (this.resolver) {
       try {
-        return await response.json();
+        return await operation(this.resolver);
       } 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
+        this.logger.warn("Resolver operation failed, using fallback:", error);
+        return await fallback();
       }
-    });
-  }
-  initializeEncryptionBootstrap(options) {
-    return this.bootstrapEncryptionOptions(options).then(() => void 0);
-  }
-  bootstrapEncryptionOptions(_options) {
-    return Promise.resolve(null);
-  }
-  async search(params = {}) {
-    const query = buildSearchQuery(params);
-    const raw = await this.requestJson(`/search${query}`, {
-      method: "GET"
-    });
-    return this.parseWithSchema(raw, searchResponseSchema, "search response");
-  }
-  async stats() {
-    const raw = await this.requestJson("/stats", { method: "GET" });
-    return this.parseWithSchema(raw, statsResponseSchema, "stats response");
-  }
-  async registries() {
-    const raw = await this.requestJson("/registries", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      registriesResponseSchema,
-      "registries response"
-    );
-  }
-  async getAdditionalRegistries() {
-    const raw = await this.requestJson(
-      "/register/additional-registries",
-      {
-        method: "GET"
-      }
-    );
-    return this.parseWithSchema(
-      raw,
-      additionalRegistryCatalogResponseSchema,
-      "additional registry catalog response"
-    );
-  }
-  async popularSearches() {
-    const raw = await this.requestJson("/popular", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      popularResponseSchema,
-      "popular searches response"
-    );
-  }
-  async listProtocols() {
-    const raw = await this.requestJson("/protocols", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      protocolsResponseSchema,
-      "protocols response"
-    );
-  }
-  async detectProtocol(message) {
-    const raw = await this.requestJson("/detect-protocol", {
-      method: "POST",
-      body: { message },
-      headers: { "content-type": "application/json" }
-    });
-    return this.parseWithSchema(
-      raw,
-      detectProtocolResponseSchema,
-      "detect protocol response"
-    );
-  }
-  async registrySearchByNamespace(registry, query) {
-    const params = new URLSearchParams();
-    if (query) {
-      params.set("q", query);
-    }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(
-      `/registries/${encodeURIComponent(registry)}/search${suffix}`,
-      {
-        method: "GET"
-      }
-    );
-    return this.parseWithSchema(
-      raw,
-      registrySearchByNamespaceSchema,
-      "registry search response"
-    );
-  }
-  async vectorSearch(request) {
-    try {
-      const raw = await this.requestJson("/search", {
-        method: "POST",
-        body: request,
-        headers: { "content-type": "application/json" }
-      });
-      return this.parseWithSchema(
-        raw,
-        vectorSearchResponseSchema,
-        "vector search response"
-      );
-    } catch (error) {
-      if (error instanceof RegistryBrokerError && error.status === 501) {
-        const fallbackParams = { q: request.query };
-        if (request.limit) fallbackParams.limit = request.limit;
-        if (request.filter?.registry) fallbackParams.registry = request.filter.registry;
-        if (request.filter?.protocols?.length) fallbackParams.protocols = [...request.filter.protocols];
-        const fallback = await this.search(fallbackParams);
-        return {
-          hits: fallback.hits.map((agent) => ({ agent, score: 0, highlights: {} })),
-          total: fallback.total,
-          took: 0,
-          totalAvailable: fallback.total,
-          visible: fallback.hits.length,
-          limited: fallback.total > fallback.limit,
-          credits_used: 0
-        };
-      }
-      throw error;
-    }
-  }
-  async searchStatus() {
-    const raw = await this.requestJson("/search/status", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      searchStatusResponseSchema,
-      "search status response"
-    );
-  }
-  async websocketStats() {
-    const raw = await this.requestJson("/websocket/stats", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      websocketStatsResponseSchema,
-      "websocket stats response"
-    );
-  }
-  async metricsSummary() {
-    const raw = await this.requestJson("/metrics", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      metricsSummaryResponseSchema,
-      "metrics summary response"
-    );
-  }
-  async facets(adapter) {
-    const params = new URLSearchParams();
-    if (adapter) {
-      params.set("adapter", adapter);
+    } else {
+      this.logger.warn("No resolver available, using fallback");
+      return await fallback();
     }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(`/search/facets${suffix}`, {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      searchFacetsResponseSchema,
-      "search facets response"
-    );
   }
 }
-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 ContentResolverRegistry = ContentResolverRegistryImpl.getInstance();
 export {
-  RegistryBrokerClient,
-  isPartialRegisterAgentResponse,
-  isPendingRegisterAgentResponse,
-  isSuccessRegisterAgentResponse
+  ContentResolverRegistry,
+  ContentResolverRegistryImpl
 };
 //# sourceMappingURL=standards-sdk.es134.js.map