@hol-org/rb-client 0.1.162 → 0.1.164

package/dist/index.js

@@ -1074,6 +1074,26 @@ var verificationVerifySenderResponseSchema = z2.object({
   ownerType: z2.string(),
   ownerId: z2.string()
 }).passthrough();
+var verificationDnsErrorSchema = z2.object({
+  code: z2.string(),
+  message: z2.string(),
+  details: z2.record(jsonValueSchema).optional()
+}).passthrough();
+var verificationDnsStatusResponseSchema = z2.object({
+  uaid: z2.string(),
+  verified: z2.boolean(),
+  profileId: z2.string(),
+  checkedAt: z2.string(),
+  nativeId: z2.string().optional(),
+  dnsName: z2.string().optional(),
+  verificationLevel: z2.string().optional(),
+  resolutionMode: z2.string().optional(),
+  reconstructedUaid: z2.string().optional(),
+  selectedFollowupProfile: z2.string().optional(),
+  error: verificationDnsErrorSchema.optional(),
+  source: z2.string().optional(),
+  persisted: z2.boolean().optional()
+}).passthrough();
 var registerStatusResponseSchema = z2.object({
   registered: z2.boolean(),
   agent: jsonValueSchema.optional()
@@ -1150,6 +1170,94 @@ var skillRegistryListResponseSchema = z2.object({
   items: z2.array(skillRegistryPublishSummarySchema),
   nextCursor: z2.string().nullable()
 }).passthrough();
+var skillCatalogChannelSchema = z2.enum([
+  "stable",
+  "prerelease",
+  "all"
+]);
+var skillCatalogSortBySchema = z2.enum([
+  "trending",
+  "upvotes",
+  "updated",
+  "name"
+]);
+var skillCatalogVersionSummarySchema = z2.object({
+  version: z2.string(),
+  publishedAt: z2.string(),
+  verified: z2.boolean().optional()
+}).passthrough();
+var skillCatalogItemSchema = z2.object({
+  name: z2.string(),
+  description: z2.string().optional(),
+  iconHcs1: z2.string().optional(),
+  category: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  latest: skillCatalogVersionSummarySchema,
+  latestStable: skillCatalogVersionSummarySchema.optional(),
+  recommended: skillCatalogVersionSummarySchema,
+  upvotes: z2.number().int(),
+  verified: z2.boolean(),
+  repoStamped: z2.boolean(),
+  trustScore: z2.number().optional(),
+  safetyScore: z2.number().optional()
+}).passthrough();
+var skillCatalogResponseSchema = z2.object({
+  items: z2.array(skillCatalogItemSchema),
+  nextCursor: z2.string().nullable()
+}).passthrough();
+var skillRecommendedVersionResponseSchema = z2.object({
+  name: z2.string(),
+  version: z2.string(),
+  updatedAt: z2.string(),
+  setBy: z2.string()
+}).passthrough();
+var skillDeprecationRecordSchema = z2.object({
+  name: z2.string(),
+  version: z2.string().optional(),
+  reason: z2.string(),
+  replacementRef: z2.string().optional(),
+  deprecatedAt: z2.string(),
+  deprecatedBy: z2.string()
+}).passthrough();
+var skillDeprecationsResponseSchema = z2.object({
+  name: z2.string(),
+  items: z2.array(skillDeprecationRecordSchema)
+}).passthrough();
+var skillBadgeMetricSchema = z2.enum([
+  "version",
+  "status",
+  "verification",
+  "repo_commit",
+  "manifest",
+  "domain",
+  "trust",
+  "safety",
+  "upvotes",
+  "updated"
+]);
+var skillBadgeStyleSchema = z2.enum([
+  "flat",
+  "flat-square",
+  "for-the-badge",
+  "plastic",
+  "social"
+]);
+var skillBadgeResponseSchema = z2.object({
+  schemaVersion: z2.number().int(),
+  label: z2.string(),
+  message: z2.string(),
+  color: z2.string(),
+  style: skillBadgeStyleSchema.optional(),
+  isError: z2.boolean().optional(),
+  cacheSeconds: z2.number().int().optional()
+}).passthrough();
+var skillRegistryTagsResponseSchema = z2.object({
+  tags: z2.array(z2.string())
+}).passthrough();
+var skillRegistryCategoriesResponseSchema = z2.object({
+  categories: z2.array(z2.string())
+}).passthrough();
+var skillResolverManifestResponseSchema = z2.record(jsonValueSchema);
 var skillRegistryQuoteFileBreakdownSchema = z2.object({
   name: z2.string(),
   mimeType: z2.string(),
@@ -1258,6 +1366,81 @@ var skillVerificationStatusSchema = z2.enum([
   "approved",
   "rejected"
 ]);
+var skillVerificationStatusLabelSchema = z2.enum([
+  "not_requested",
+  "pending",
+  "approved",
+  "rejected"
+]);
+var skillVerificationSignalFailureReasonSchema = z2.enum([
+  "missing_owner",
+  "missing_repo_or_commit",
+  "unsupported_repo",
+  "repo_fetch_failed",
+  "manifest_pointer_missing",
+  "manifest_fetch_failed",
+  "manifest_parse_failed",
+  "missing_file_hashes",
+  "missing_domain",
+  "challenge_invalid",
+  "challenge_expired",
+  "dns_lookup_failed",
+  "dns_record_missing",
+  "mismatch"
+]);
+var skillVerificationPublisherBoundSignalSchema = z2.object({
+  ok: z2.boolean(),
+  ownerAccountId: z2.string().nullable(),
+  ownerUserId: z2.string().nullable(),
+  checkedAt: z2.string(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationRepoCommitIntegrityMismatchSchema = z2.object({
+  path: z2.string(),
+  expectedSha256: z2.string(),
+  actualSha256: z2.string().optional(),
+  error: z2.string().optional()
+}).passthrough();
+var skillVerificationRepoCommitIntegritySignalSchema = z2.object({
+  ok: z2.boolean(),
+  repo: z2.string().nullable(),
+  commit: z2.string().nullable(),
+  checkedAt: z2.string(),
+  filesChecked: z2.number().int().min(0),
+  mismatches: z2.array(skillVerificationRepoCommitIntegrityMismatchSchema),
+  partial: z2.boolean().optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationManifestIntegrityShaMismatchSchema = z2.object({
+  path: z2.string(),
+  expectedSha256: z2.string(),
+  actualSha256: z2.string().optional()
+}).passthrough();
+var skillVerificationManifestIntegritySignalSchema = z2.object({
+  ok: z2.boolean(),
+  manifestHrl: z2.string().nullable(),
+  manifestSha256: z2.string().nullable(),
+  checkedAt: z2.string(),
+  missingFiles: z2.array(z2.string()),
+  shaMismatches: z2.array(skillVerificationManifestIntegrityShaMismatchSchema),
+  extraFiles: z2.array(z2.string()).optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationDomainProofSignalSchema = z2.object({
+  ok: z2.boolean(),
+  domain: z2.string().optional(),
+  method: z2.literal("dns_txt").optional(),
+  checkedAt: z2.string().optional(),
+  details: z2.string().optional(),
+  txtRecordName: z2.string().optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationSignalsSchema = z2.object({
+  publisherBound: skillVerificationPublisherBoundSignalSchema,
+  repoCommitIntegrity: skillVerificationRepoCommitIntegritySignalSchema,
+  manifestIntegrity: skillVerificationManifestIntegritySignalSchema,
+  domainProof: skillVerificationDomainProofSignalSchema.optional()
+}).passthrough();
 var skillVerificationRequestSchema = z2.object({
   id: z2.string(),
   network: z2.union([z2.literal("mainnet"), z2.literal("testnet")]),
@@ -1268,6 +1451,8 @@ var skillVerificationRequestSchema = z2.object({
   usdCents: z2.number(),
   creditsCharged: z2.number(),
   creditAccountId: z2.string().optional(),
+  signals: skillVerificationSignalsSchema.optional(),
+  reviewNotes: z2.string().optional(),
   requestedBy: z2.object({
     userId: z2.string().optional(),
     accountId: z2.string().optional(),
@@ -1278,6 +1463,11 @@ var skillVerificationRequestSchema = z2.object({
     email: z2.string().optional()
   }).optional(),
   approvedAt: z2.string().optional(),
+  rejectedBy: z2.object({
+    userId: z2.string().optional(),
+    email: z2.string().optional()
+  }).optional(),
+  rejectedAt: z2.string().optional(),
   createdAt: z2.string(),
   updatedAt: z2.string()
 }).passthrough();
@@ -1286,10 +1476,40 @@ var skillVerificationRequestCreateResponseSchema = z2.object({
 }).passthrough();
 var skillVerificationStatusResponseSchema = z2.object({
   name: z2.string(),
+  version: z2.string(),
+  status: skillVerificationStatusLabelSchema,
   verified: z2.boolean(),
   previouslyVerified: z2.boolean(),
+  signals: skillVerificationSignalsSchema.nullable().optional(),
+  reviewNotes: z2.string().nullable().optional(),
   pendingRequest: skillVerificationRequestSchema.nullable().optional()
 }).passthrough();
+var skillVerificationDomainProofChallengeRequestSchema = z2.object({
+  name: z2.string().min(1),
+  version: z2.string().min(1).optional(),
+  domain: z2.string().min(1).optional()
+}).passthrough();
+var skillVerificationDomainProofChallengeResponseSchema = z2.object({
+  challengeId: z2.string().min(1),
+  name: z2.string().min(1),
+  version: z2.string().min(1),
+  domain: z2.string().min(1),
+  method: z2.literal("dns_txt"),
+  txtRecordName: z2.string().min(1),
+  txtRecordValue: z2.string().min(1),
+  expiresAt: z2.string().min(1)
+}).passthrough();
+var skillVerificationDomainProofVerifyRequestSchema = z2.object({
+  name: z2.string().min(1),
+  version: z2.string().min(1).optional(),
+  domain: z2.string().min(1).optional(),
+  challengeToken: z2.string().min(1)
+}).passthrough();
+var skillVerificationDomainProofVerifyResponseSchema = z2.object({
+  name: z2.string().min(1),
+  version: z2.string().min(1),
+  signal: skillVerificationDomainProofSignalSchema
+}).passthrough();
 
 // ../../src/utils/is-browser.ts
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -3511,6 +3731,40 @@ async function verifySenderOwnership(client, uaid) {
     "verification sender response"
   );
 }
+async function verifyUaidDnsTxt(client, payload) {
+  const raw = await client.requestJson("/verification/dns/verify", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: {
+      uaid: payload.uaid,
+      ...payload.persist !== void 0 ? { persist: payload.persist } : {}
+    }
+  });
+  return client.parseWithSchema(
+    raw,
+    verificationDnsStatusResponseSchema,
+    "verification dns verify response"
+  );
+}
+async function getVerificationDnsStatus(client, uaid, query) {
+  const params = new URLSearchParams();
+  if (query?.refresh !== void 0) {
+    params.set("refresh", String(query.refresh));
+  }
+  if (query?.persist !== void 0) {
+    params.set("persist", String(query.persist));
+  }
+  const queryString = params.toString();
+  const path2 = `/verification/dns/status/${encodeURIComponent(uaid)}${queryString ? `?${queryString}` : ""}`;
+  const raw = await client.requestJson(path2, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    verificationDnsStatusResponseSchema,
+    "verification dns status response"
+  );
+}
 async function getRegisterStatus(client, uaid) {
   const raw = await client.requestJson(
     `/register/status/${encodeURIComponent(uaid)}`,
@@ -3575,6 +3829,24 @@ async function listSkills(client, params = {}) {
   if (params.accountId) {
     query.set("accountId", params.accountId);
   }
+  if (params.q) {
+    query.set("q", params.q);
+  }
+  if (params.tag) {
+    query.set("tag", params.tag);
+  }
+  if (params.category) {
+    query.set("category", params.category);
+  }
+  if (typeof params.featured === "boolean") {
+    query.set("featured", params.featured ? "true" : "false");
+  }
+  if (typeof params.verified === "boolean") {
+    query.set("verified", params.verified ? "true" : "false");
+  }
+  if (params.view) {
+    query.set("view", params.view);
+  }
   const suffix = query.size > 0 ? `?${query.toString()}` : "";
   const raw = await client.requestJson(`/skills${suffix}`, {
     method: "GET"
@@ -3585,6 +3857,47 @@ async function listSkills(client, params = {}) {
     "skill registry list response"
   );
 }
+async function getSkillsCatalog(client, params = {}) {
+  const query = new URLSearchParams();
+  if (params.q) {
+    query.set("q", params.q);
+  }
+  if (params.category) {
+    query.set("category", params.category);
+  }
+  params.tags?.forEach((tag) => {
+    if (tag.trim()) {
+      query.append("tag", tag.trim());
+    }
+  });
+  if (typeof params.featured === "boolean") {
+    query.set("featured", params.featured ? "true" : "false");
+  }
+  if (typeof params.verified === "boolean") {
+    query.set("verified", params.verified ? "true" : "false");
+  }
+  if (params.channel) {
+    query.set("channel", params.channel);
+  }
+  if (params.sortBy) {
+    query.set("sortBy", params.sortBy);
+  }
+  if (typeof params.limit === "number" && Number.isFinite(params.limit)) {
+    query.set("limit", String(Math.trunc(params.limit)));
+  }
+  if (params.cursor) {
+    query.set("cursor", params.cursor);
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(`/skills/catalog${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillCatalogResponseSchema,
+    "skill catalog response"
+  );
+}
 async function listSkillVersions(client, params) {
   const normalizedName = params.name.trim();
   if (!normalizedName) {
@@ -3704,6 +4017,169 @@ async function getSkillOwnership(client, params) {
     "skill registry ownership response"
   );
 }
+async function getRecommendedSkillVersion(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  const raw = await client.requestJson(
+    `/skills/recommended?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillRecommendedVersionResponseSchema,
+    "skill recommended version response"
+  );
+}
+async function setRecommendedSkillVersion(client, payload) {
+  const normalizedName = payload.name.trim();
+  const normalizedVersion = payload.version.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  if (!normalizedVersion) {
+    throw new Error("version is required");
+  }
+  const raw = await client.requestJson("/skills/recommended", {
+    method: "POST",
+    body: {
+      name: normalizedName,
+      version: normalizedVersion
+    },
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRecommendedVersionResponseSchema,
+    "skill recommended version response"
+  );
+}
+async function getSkillDeprecations(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  const raw = await client.requestJson(
+    `/skills/deprecations?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillDeprecationsResponseSchema,
+    "skill deprecations response"
+  );
+}
+async function setSkillDeprecation(client, payload) {
+  const normalizedName = payload.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const version = payload.version?.trim();
+  const reason = payload.reason.trim();
+  if (!reason) {
+    throw new Error("reason is required");
+  }
+  const replacementRef = payload.replacementRef?.trim();
+  const raw = await client.requestJson("/skills/deprecate", {
+    method: "POST",
+    body: {
+      name: normalizedName,
+      version,
+      reason,
+      replacementRef
+    },
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillDeprecationRecordSchema,
+    "skill deprecation response"
+  );
+}
+async function getSkillBadge(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.metric) {
+    query.set("metric", params.metric);
+  }
+  if (params.label?.trim()) {
+    query.set("label", params.label.trim());
+  }
+  if (params.style) {
+    query.set("style", params.style);
+  }
+  const raw = await client.requestJson(
+    `/skills/badge?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillBadgeResponseSchema,
+    "skill badge response"
+  );
+}
+async function listSkillTags(client) {
+  const raw = await client.requestJson("/skills/tags", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryTagsResponseSchema,
+    "skill tags response"
+  );
+}
+async function listSkillCategories(client) {
+  const raw = await client.requestJson("/skills/categories", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryCategoriesResponseSchema,
+    "skill categories response"
+  );
+}
+async function resolveSkillMarkdown(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const response = await client.request(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/SKILL.md`,
+    {
+      method: "GET",
+      headers: {
+        accept: "text/markdown, text/plain;q=0.9, */*;q=0.8"
+      }
+    }
+  );
+  return response.text();
+}
+async function resolveSkillManifest(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/manifest`,
+    {
+      method: "GET"
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillResolverManifestResponseSchema,
+    "skill resolver manifest response"
+  );
+}
 async function getSkillVoteStatus(client, params) {
   const normalizedName = params.name.trim();
   if (!normalizedName) {
@@ -3746,7 +4222,11 @@ async function requestSkillVerification(client, payload) {
     "/skills/verification/request",
     {
       method: "POST",
-      body: { name: normalizedName, tier: payload.tier },
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        tier: payload.tier
+      },
       headers: { "content-type": "application/json" }
     }
   );
@@ -3763,6 +4243,9 @@ async function getSkillVerificationStatus(client, params) {
   }
   const query = new URLSearchParams();
   query.set("name", normalizedName);
+  if (params.version) {
+    query.set("version", params.version);
+  }
   const raw = await client.requestJson(
     `/skills/verification/status?${query.toString()}`,
     { method: "GET" }
@@ -3773,6 +4256,57 @@ async function getSkillVerificationStatus(client, params) {
     "skill verification status response"
   );
 }
+async function createSkillDomainProofChallenge(client, payload) {
+  const normalizedName = payload.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const raw = await client.requestJson(
+    "/skills/verification/domain/challenge",
+    {
+      method: "POST",
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        domain: payload.domain
+      },
+      headers: { "content-type": "application/json" }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationDomainProofChallengeResponseSchema,
+    "skill domain proof challenge response"
+  );
+}
+async function verifySkillDomainProof(client, payload) {
+  const normalizedName = payload.name.trim();
+  const challengeToken = payload.challengeToken.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  if (!challengeToken) {
+    throw new Error("challengeToken is required");
+  }
+  const raw = await client.requestJson(
+    "/skills/verification/domain/verify",
+    {
+      method: "POST",
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        domain: payload.domain,
+        challengeToken
+      },
+      headers: { "content-type": "application/json" }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationDomainProofVerifyResponseSchema,
+    "skill domain proof verify response"
+  );
+}
 
 // ../../src/services/registry-broker/client/base-client.ts
 import { Buffer as Buffer5 } from "buffer";
@@ -4121,6 +4655,9 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async listSkills(options) {
     return listSkills(this, options);
   }
+  async getSkillsCatalog(options) {
+    return getSkillsCatalog(this, options);
+  }
   async listSkillVersions(params) {
     return listSkillVersions(this, params);
   }
@@ -4142,6 +4679,33 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   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 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);
   }
@@ -4154,6 +4718,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   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);
   }
@@ -4349,6 +4919,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hol-org/rb-client",
-  "version": "0.1.162",
+  "version": "0.1.164",
   "description": "Lightweight Registry Broker client for HOL registries.",
   "type": "module",
   "files": [
@@ -53,7 +53,7 @@
   "peerDependencies": {
     "@hashgraph/hedera-wallet-connect": "^2.0.4",
     "@hashgraph/sdk": "^2.77.0",
-    "axios": "*",
+    "axios": ">=1.13.6",
     "viem": "*",
     "x402": "*",
     "x402-axios": "*"