@hashgraphonline/standards-sdk 0.1.146-chore-jsr-improvements.canary.46c0c0f.91 → 0.1.146-chore-jsr-improvements.canary.62a5b19.93

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

@@ -1,180 +1,649 @@
-import * as path from "path";
 import { Buffer } from "buffer";
-import { randomBytes } from "crypto";
+import { randomBytes, createHash, createCipheriv, createDecipheriv } from "crypto";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { registerEncryptionKeyResponseSchema } from "./standards-sdk.es149.js";
-import { optionalImport } from "./standards-sdk.es153.js";
-import { RegistryBrokerClient } from "./standards-sdk.es135.js";
-const getFs = async () => {
-  const fsModule = await optionalImport("node:fs");
-  if (fsModule && typeof fsModule.existsSync === "function" && typeof fsModule.readFileSync === "function" && typeof fsModule.writeFileSync === "function" && typeof fsModule.appendFileSync === "function") {
-    return fsModule;
-  }
-  return null;
-};
-async function registerEncryptionKey(client, payload) {
-  const raw = await client.requestJson("/encryption/keys", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: payload
-  });
-  return client.parseWithSchema(
-    raw,
-    registerEncryptionKeyResponseSchema,
-    "register encryption key response"
-  );
-}
-function normalizeAutoRegisterIdentity(config) {
-  const identity = {};
-  if (config.uaid) {
-    identity.uaid = config.uaid;
+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.es139.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.es152.js";
+import { RegistryBrokerError, RegistryBrokerParseError } from "./standards-sdk.es128.js";
+class RegistryBrokerClient {
+  constructor(options = {}) {
+    this.encryptionBootstrapPromise = null;
+    this.encryption = {
+      ensureAgentKey: async (_options) => {
+        throw new Error(
+          "Encryption not available in JSR version. Use npm: @hashgraphonline/standards-sdk"
+        );
+      },
+      registerKey: async (_payload) => {
+        throw new Error(
+          "Encryption not available in JSR version. Use npm: @hashgraphonline/standards-sdk"
+        );
+      }
+    };
+    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
+      );
+    }
   }
-  if (config.ledgerAccountId) {
-    identity.ledgerAccountId = config.ledgerAccountId;
-    if (config.ledgerNetwork) {
-      identity.ledgerNetwork = config.ledgerNetwork;
+  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 };
   }
-  if (config.email) {
-    identity.email = config.email;
+  setApiKey(apiKey) {
+    this.setDefaultHeader("x-api-key", apiKey);
   }
-  if (identity.uaid || identity.ledgerAccountId || identity.email) {
-    return identity;
+  setLedgerApiKey(apiKey) {
+    this.setDefaultHeader("x-ledger-api-key", apiKey);
   }
-  return null;
-}
-function derivePublicKeyFromPrivateKey(client, privateKey) {
-  const normalized = client.hexToBuffer(privateKey);
-  const publicKey = secp256k1.getPublicKey(normalized, true);
-  return Buffer.from(publicKey).toString("hex");
-}
-async function resolveAutoRegisterKeyMaterial(client, config) {
-  if (config.publicKey?.trim()) {
-    return { publicKey: config.publicKey.trim() };
-  }
-  let privateKey = config.privateKey?.trim();
-  const envVar = config.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {
-    privateKey = process.env[envVar]?.trim();
-  }
-  if (!privateKey && config.generateIfMissing) {
-    const pair = await client.generateEncryptionKeyPair({
-      keyType: config.keyType ?? "secp256k1",
-      envVar,
-      envPath: config.envPath,
-      overwrite: config.overwriteEnv
+  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 (envVar) {
-      process.env[envVar] = pair.privateKey;
+    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);
     }
-    return { publicKey: pair.publicKey, privateKey: pair.privateKey };
+    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
+    });
   }
-  if (privateKey) {
-    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);
-    return { publicKey, privateKey };
+  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();
   }
-  return null;
-}
-async function autoRegisterEncryptionKey(client, config) {
-  const identity = normalizeAutoRegisterIdentity(config);
-  if (!identity) {
-    throw new Error(
-      "Auto-registration requires uaid, ledgerAccountId, or email"
+  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"
     );
   }
-  const material = await resolveAutoRegisterKeyMaterial(client, config);
-  if (!material) {
-    throw new Error(
-      "Unable to resolve encryption public key for auto-registration"
+  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"
     );
   }
-  await registerEncryptionKey(client, {
-    keyType: config.keyType ?? "secp256k1",
-    publicKey: material.publicKey,
-    ...identity
-  });
-  return material;
-}
-async function ensureAgentEncryptionKey(client, options) {
-  return autoRegisterEncryptionKey(client, {
-    ...options,
-    uaid: options.uaid
-  });
-}
-const encryptionApis = /* @__PURE__ */ new WeakMap();
-Object.defineProperty(RegistryBrokerClient.prototype, "encryption", {
-  get() {
-    const existing = encryptionApis.get(this);
-    if (existing) {
-      return existing;
-    }
-    const api = {
-      registerKey: (payload) => registerEncryptionKey(this, payload),
-      generateEphemeralKeyPair: () => this.createEphemeralKeyPair(),
-      deriveSharedSecret: (options) => this.deriveSharedSecret(options),
-      encryptCipherEnvelope: (options) => this.buildCipherEnvelope(options),
-      decryptCipherEnvelope: (options) => this.openCipherEnvelope(options),
-      ensureAgentKey: (options) => ensureAgentEncryptionKey(this, options)
-    };
-    encryptionApis.set(this, api);
-    return api;
+  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"
+    );
   }
-});
-RegistryBrokerClient.prototype.bootstrapEncryptionOptions = async function(options) {
-  if (!options?.autoRegister || options.autoRegister.enabled === false) {
-    return null;
+  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"
+    );
   }
-  return autoRegisterEncryptionKey(this, options.autoRegister);
-};
-RegistryBrokerClient.prototype.generateEncryptionKeyPair = async function(options = {}) {
-  this.assertNodeRuntime("generateEncryptionKeyPair");
-  const keyType = options.keyType ?? "secp256k1";
-  if (keyType !== "secp256k1") {
-    throw new Error("Only secp256k1 key generation is supported currently");
-  }
-  const privateKeyBytes = randomBytes(32);
-  const privateKey = Buffer.from(privateKeyBytes).toString("hex");
-  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
-  const publicKey = Buffer.from(publicKeyBytes).toString("hex");
-  const envVar = options.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-  const resolvedPath = options.envPath ? path.resolve(options.envPath) : void 0;
-  if (resolvedPath) {
-    const fsModule = await getFs();
-    if (!fsModule) {
-      throw new Error(
-        "File system module is not available; cannot write encryption key env file"
+  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)) {
+      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
       );
     }
-    const envLine = `${envVar}=${privateKey}`;
-    if (fsModule.existsSync(resolvedPath)) {
-      const content = fsModule.readFileSync(resolvedPath, "utf-8");
-      const lineRegex = new RegExp(`^${envVar}=.*$`, "m");
-      if (lineRegex.test(content)) {
-        if (!options.overwrite) {
-          throw new Error(
-            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`
-          );
+  }
+  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);
         }
-        const updated = content.replace(lineRegex, envLine);
-        fsModule.writeFileSync(resolvedPath, updated);
-      } else {
-        const needsNewline = !content.endsWith("\n");
-        fsModule.appendFileSync(
-          resolvedPath,
-          `${needsNewline ? "\n" : ""}${envLine}
-`
-        );
+        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
       }
-    } else {
-      fsModule.writeFileSync(resolvedPath, `${envLine}
-`);
+    });
+  }
+  initializeEncryptionBootstrap(options) {
+    return this.bootstrapEncryptionOptions(options).then(() => void 0);
+  }
+  bootstrapEncryptionOptions(_options) {
+    return Promise.resolve(null);
+  }
+  /**
+   * Purchase credits with HBAR - stub implementation
+   * Full credits support available in npm version
+   */
+  async purchaseCreditsWithHbar(_options) {
+    throw new Error(
+      "Credits not available in JSR version. Use npm: @hashgraphonline/standards-sdk"
+    );
+  }
+  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"
+    );
   }
-  return {
-    privateKey,
-    publicKey,
-    envPath: resolvedPath,
-    envVar
-  };
+  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);
+    }
+    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";
+export {
+  RegistryBrokerClient,
+  isPartialRegisterAgentResponse,
+  isPendingRegisterAgentResponse,
+  isSuccessRegisterAgentResponse
 };
 //# sourceMappingURL=standards-sdk.es127.js.map