@hashgraphonline/standards-sdk 0.1.185 → 0.1.186

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

@@ -1,10 +1,2550 @@
-var CustomFeeType = /* @__PURE__ */ ((CustomFeeType2) => {
-  CustomFeeType2["FIXED_FEE"] = "FIXED_FEE";
-  CustomFeeType2["FRACTIONAL_FEE"] = "FRACTIONAL_FEE";
-  CustomFeeType2["ROYALTY_FEE"] = "ROYALTY_FEE";
-  return CustomFeeType2;
-})(CustomFeeType || {});
+import { z } from "zod";
+import { adapterDeclarationSchema } from "./standards-sdk.es86.js";
+var AIAgentType = /* @__PURE__ */ ((AIAgentType2) => {
+  AIAgentType2[AIAgentType2["MANUAL"] = 0] = "MANUAL";
+  AIAgentType2[AIAgentType2["AUTONOMOUS"] = 1] = "AUTONOMOUS";
+  return AIAgentType2;
+})(AIAgentType || {});
+var AIAgentCapability = /* @__PURE__ */ ((AIAgentCapability2) => {
+  AIAgentCapability2[AIAgentCapability2["TEXT_GENERATION"] = 0] = "TEXT_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["IMAGE_GENERATION"] = 1] = "IMAGE_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["AUDIO_GENERATION"] = 2] = "AUDIO_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["VIDEO_GENERATION"] = 3] = "VIDEO_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["CODE_GENERATION"] = 4] = "CODE_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["LANGUAGE_TRANSLATION"] = 5] = "LANGUAGE_TRANSLATION";
+  AIAgentCapability2[AIAgentCapability2["SUMMARIZATION_EXTRACTION"] = 6] = "SUMMARIZATION_EXTRACTION";
+  AIAgentCapability2[AIAgentCapability2["KNOWLEDGE_RETRIEVAL"] = 7] = "KNOWLEDGE_RETRIEVAL";
+  AIAgentCapability2[AIAgentCapability2["DATA_INTEGRATION"] = 8] = "DATA_INTEGRATION";
+  AIAgentCapability2[AIAgentCapability2["MARKET_INTELLIGENCE"] = 9] = "MARKET_INTELLIGENCE";
+  AIAgentCapability2[AIAgentCapability2["TRANSACTION_ANALYTICS"] = 10] = "TRANSACTION_ANALYTICS";
+  AIAgentCapability2[AIAgentCapability2["SMART_CONTRACT_AUDIT"] = 11] = "SMART_CONTRACT_AUDIT";
+  AIAgentCapability2[AIAgentCapability2["GOVERNANCE_FACILITATION"] = 12] = "GOVERNANCE_FACILITATION";
+  AIAgentCapability2[AIAgentCapability2["SECURITY_MONITORING"] = 13] = "SECURITY_MONITORING";
+  AIAgentCapability2[AIAgentCapability2["COMPLIANCE_ANALYSIS"] = 14] = "COMPLIANCE_ANALYSIS";
+  AIAgentCapability2[AIAgentCapability2["FRAUD_DETECTION"] = 15] = "FRAUD_DETECTION";
+  AIAgentCapability2[AIAgentCapability2["MULTI_AGENT_COORDINATION"] = 16] = "MULTI_AGENT_COORDINATION";
+  AIAgentCapability2[AIAgentCapability2["API_INTEGRATION"] = 17] = "API_INTEGRATION";
+  AIAgentCapability2[AIAgentCapability2["WORKFLOW_AUTOMATION"] = 18] = "WORKFLOW_AUTOMATION";
+  return AIAgentCapability2;
+})(AIAgentCapability || {});
+const capabilitySchema = z.nativeEnum(AIAgentCapability);
+const capabilityValueSchema = z.union([z.number(), z.string()]);
+const jsonPrimitiveSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null()
+]);
+const jsonValueSchema = z.lazy(
+  () => z.union([
+    jsonPrimitiveSchema,
+    z.array(jsonValueSchema),
+    z.record(jsonValueSchema)
+  ])
+);
+const agentProfileSchema = z.object({
+  version: z.string(),
+  type: z.number(),
+  display_name: z.string(),
+  alias: z.string().optional(),
+  bio: z.string().optional(),
+  socials: z.array(jsonValueSchema).optional(),
+  aiAgent: z.object({
+    type: z.nativeEnum(AIAgentType),
+    creator: z.string().optional(),
+    model: z.string().optional(),
+    capabilities: z.array(z.union([capabilitySchema, z.number()])).optional()
+  }).optional(),
+  uaid: z.string().optional()
+}).catchall(jsonValueSchema);
+const cipherEnvelopeRecipientSchema = z.object({
+  uaid: z.string().optional(),
+  ledgerAccountId: z.string().optional(),
+  userId: z.string().optional(),
+  email: z.string().optional(),
+  encryptedShare: z.string()
+});
+const cipherEnvelopeSchema = z.object({
+  algorithm: z.string(),
+  ciphertext: z.string(),
+  nonce: z.string(),
+  associatedData: z.string().optional(),
+  keyLocator: z.object({
+    sessionId: z.string().optional(),
+    revision: z.number().optional()
+  }).optional(),
+  recipients: z.array(cipherEnvelopeRecipientSchema)
+});
+const peerSummarySchema = z.object({
+  keyType: z.string(),
+  publicKey: z.string(),
+  uaid: z.string().optional(),
+  ledgerAccountId: z.string().optional(),
+  userId: z.string().optional(),
+  email: z.string().optional()
+});
+const handshakeParticipantSchema = z.object({
+  role: z.enum(["requester", "responder"]),
+  uaid: z.string().optional(),
+  userId: z.string().optional(),
+  ledgerAccountId: z.string().optional(),
+  keyType: z.string(),
+  longTermPublicKey: z.string().optional(),
+  ephemeralPublicKey: z.string(),
+  signature: z.string().optional(),
+  metadata: z.record(jsonValueSchema).optional(),
+  submittedAt: z.string()
+});
+const encryptionHandshakeRecordSchema = z.object({
+  sessionId: z.string(),
+  algorithm: z.string(),
+  createdAt: z.string(),
+  expiresAt: z.number(),
+  status: z.enum(["pending", "complete"]),
+  requester: handshakeParticipantSchema.optional(),
+  responder: handshakeParticipantSchema.optional()
+});
+const sessionEncryptionSummarySchema = z.object({
+  enabled: z.boolean(),
+  algorithm: z.string(),
+  requireCiphertext: z.boolean(),
+  requester: peerSummarySchema.nullable().optional(),
+  responder: peerSummarySchema.nullable().optional(),
+  handshake: encryptionHandshakeRecordSchema.nullable().optional()
+});
+const chatHistoryEntrySchema = z.object({
+  messageId: z.string(),
+  role: z.enum([
+    "user",
+    "agent",
+    "system",
+    "tool",
+    "payment",
+    "delivery",
+    "error"
+  ]),
+  content: z.string(),
+  timestamp: z.string(),
+  cipherEnvelope: cipherEnvelopeSchema.optional(),
+  metadata: z.record(jsonValueSchema).optional()
+});
+const chatDeliveryStateSchema = z.enum([
+  "draft",
+  "queued",
+  "persisted",
+  "delivered",
+  "streaming",
+  "responded",
+  "failed",
+  "timeout",
+  "cancelled"
+]);
+const chatAttachmentStateSchema = z.object({
+  supported: z.boolean(),
+  status: z.enum([
+    "unsupported",
+    "available",
+    "selected",
+    "uploading",
+    "scanning",
+    "ready",
+    "failed",
+    "rejected"
+  ]),
+  maxBytes: z.number().nullable().optional(),
+  acceptedMimeTypes: z.array(z.string()).optional(),
+  reason: z.string().optional()
+});
+const chatTimelineEntrySchema = z.object({
+  messageId: z.string(),
+  kind: z.enum([
+    "user",
+    "assistant",
+    "system",
+    "tool",
+    "payment",
+    "delivery",
+    "error"
+  ]),
+  content: z.string(),
+  timestamp: z.string(),
+  deliveryState: chatDeliveryStateSchema.optional(),
+  errorCode: z.string().optional(),
+  metadata: z.record(jsonValueSchema).optional(),
+  attachment: chatAttachmentStateSchema.optional()
+});
+const chatReadinessStatusSchema = z.enum([
+  "responsive",
+  "delivery_only",
+  "degraded",
+  "blocked",
+  "unknown"
+]);
+const chatReplyModeSchema = z.enum([
+  "direct",
+  "stream",
+  "poll",
+  "delivery_only",
+  "none"
+]);
+const chatRouteTypeSchema = z.enum([
+  "a2a",
+  "hcs-10",
+  "mcp",
+  "openrouter",
+  "acp",
+  "xmtp",
+  "moltbook",
+  "agentverse",
+  "nanda",
+  "http",
+  "erc-8004",
+  "x402",
+  "unknown"
+]);
+const chatSessionStateSchema = z.enum([
+  "connecting",
+  "ready",
+  "blocked",
+  "ended",
+  "expired"
+]);
+const chatErrorCodeSchema = z.enum([
+  "AUTH_REQUIRED",
+  "CREDITS_REQUIRED",
+  "PAYMENT_REQUIRED",
+  "AGENT_UNRESPONSIVE",
+  "ROUTE_UNAVAILABLE",
+  "PROTOCOL_UNSUPPORTED",
+  "BROKER_NOT_EXECUTABLE",
+  "NETWORK_TIMEOUT",
+  "STREAM_STALLED",
+  "HISTORY_UNAVAILABLE",
+  "ENCRYPTION_REQUIRED",
+  "RATE_LIMITED",
+  "VALIDATION_ERROR",
+  "UNKNOWN_ERROR"
+]);
+const chatRouteSummarySchema = z.object({
+  type: chatRouteTypeSchema,
+  replyMode: chatReplyModeSchema,
+  transport: z.string(),
+  endpoint: z.string().optional()
+});
+const chatPaymentStateSchema = z.object({
+  required: z.boolean(),
+  provider: z.enum(["credits", "x402", "acp", "openrouter"]).optional(),
+  status: z.enum([
+    "not_required",
+    "preflight",
+    "required",
+    "approved",
+    "paid",
+    "failed"
+  ]),
+  estimatedCredits: z.number().nullable().optional(),
+  estimatedUsd: z.number().nullable().optional()
+});
+const chatReadinessResponseSchema = z.object({
+  status: chatReadinessStatusSchema,
+  routeType: chatRouteTypeSchema,
+  replyMode: chatReplyModeSchema,
+  transport: z.string(),
+  endpoint: z.string().optional(),
+  checkedAt: z.string(),
+  cachedUntil: z.string(),
+  latencyMs: z.number().nullable().optional(),
+  lastSuccessfulReplyAt: z.string().nullable().optional(),
+  lastDeliveryConfirmationAt: z.string().nullable().optional(),
+  lastFailureCode: chatErrorCodeSchema.nullable().optional(),
+  supportsStreaming: z.boolean(),
+  supportsHistory: z.boolean(),
+  supportsEncryption: z.boolean(),
+  supportsPayments: z.boolean(),
+  supportsAttachments: z.boolean(),
+  requiresAuth: z.boolean(),
+  operatorActionRequired: z.boolean(),
+  issue: z.object({
+    code: z.string(),
+    message: z.string(),
+    details: z.string().optional()
+  }).optional()
+});
+const chatSessionResumeResponseSchema = z.object({
+  sessionId: z.string(),
+  uaid: z.string().nullable().optional(),
+  agentUrl: z.string().nullable().optional(),
+  route: chatRouteSummarySchema,
+  transport: z.string(),
+  history: z.array(chatHistoryEntrySchema),
+  historyTtlSeconds: z.number().optional(),
+  visibility: z.enum(["private", "public"]).optional(),
+  state: chatSessionStateSchema
+});
+const metadataFacetSchema = z.record(
+  z.union([
+    z.array(jsonValueSchema),
+    z.record(jsonValueSchema),
+    jsonValueSchema
+  ])
+).optional();
+const searchHitSchema = z.object({
+  id: z.string(),
+  uaid: z.string(),
+  registry: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  capabilities: z.array(capabilityValueSchema),
+  endpoints: z.union([z.record(jsonValueSchema), z.array(z.string())]).optional(),
+  metadata: z.record(jsonValueSchema).optional(),
+  metadataFacet: metadataFacetSchema,
+  profile: agentProfileSchema.optional(),
+  protocols: z.array(z.string()).optional(),
+  adapter: z.string().optional(),
+  originalId: z.string().optional(),
+  communicationSupported: z.boolean().optional(),
+  routingSupported: z.boolean().optional(),
+  available: z.boolean().optional(),
+  availabilityStatus: z.string().optional(),
+  availabilityCheckedAt: z.string().optional(),
+  availabilitySource: z.string().optional(),
+  availabilityLatencyMs: z.number().optional(),
+  availabilityScore: z.number().optional(),
+  capabilityLabels: z.array(z.string()).optional(),
+  capabilityTokens: z.array(z.string()).optional(),
+  image: z.string().optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+  lastSeen: z.string().optional(),
+  lastIndexed: z.string().optional()
+}).passthrough();
+const searchResponseSchema = z.object({
+  hits: z.array(searchHitSchema),
+  total: z.number(),
+  page: z.number(),
+  limit: z.number()
+});
+const statsResponseSchema = z.object({
+  totalAgents: z.number(),
+  registries: z.record(z.number()),
+  capabilities: z.record(z.number()),
+  lastUpdate: z.string(),
+  status: z.string()
+});
+const registriesResponseSchema = z.object({
+  registries: z.array(z.string())
+});
+const popularResponseSchema = z.object({
+  searches: z.array(z.string())
+});
+const resolveResponseSchema = z.object({
+  agent: searchHitSchema
+});
+const delegationPlanCandidateSchema = z.object({
+  uaid: z.string(),
+  score: z.number(),
+  displayName: z.string().optional(),
+  summary: z.string().optional(),
+  protocols: z.array(z.string()).optional(),
+  surfaces: z.array(z.string()).optional(),
+  languages: z.array(z.string()).optional(),
+  artifacts: z.array(z.string()).optional(),
+  availability: z.boolean().optional(),
+  explanation: z.string().optional()
+}).passthrough();
+const delegationOpportunitySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  reason: z.string(),
+  role: z.string(),
+  type: z.enum(["ai-agents", "mcp-servers"]),
+  suggestedMode: z.enum(["best-match", "fallback", "parallel"]),
+  searchQueries: z.array(z.string()),
+  protocols: z.array(z.string()).optional(),
+  surfaces: z.array(z.string()).optional(),
+  languages: z.array(z.string()).optional(),
+  artifacts: z.array(z.string()).optional(),
+  candidates: z.array(delegationPlanCandidateSchema)
+}).passthrough();
+const delegationRecommendationSchema = z.object({
+  action: z.enum(["delegate-now", "review-shortlist", "handle-locally"]),
+  confidence: z.number(),
+  reason: z.string(),
+  opportunityId: z.string().optional(),
+  candidate: delegationPlanCandidateSchema.optional()
+}).passthrough();
+const delegationPlanResponseSchema = z.object({
+  task: z.string(),
+  context: z.string().optional(),
+  summary: z.string().optional(),
+  intents: z.array(z.string()),
+  protocols: z.array(z.string()),
+  surfaces: z.array(z.string()),
+  languages: z.array(z.string()).optional(),
+  artifacts: z.array(z.string()).optional(),
+  shouldDelegate: z.boolean(),
+  localFirstReason: z.string().optional(),
+  recommendation: delegationRecommendationSchema.optional(),
+  opportunities: z.array(delegationOpportunitySchema)
+}).passthrough();
+const agentFeedbackSummarySchema = z.object({
+  averageScore: z.number(),
+  totalFeedbacks: z.number(),
+  registry: z.string().optional(),
+  network: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+const agentFeedbackEntrySchema = z.object({
+  registry: z.string(),
+  network: z.string().optional(),
+  agentId: z.number(),
+  client: z.string(),
+  score: z.number(),
+  tag1: z.string().nullable().optional(),
+  tag2: z.string().nullable().optional(),
+  revoked: z.boolean(),
+  feedbackIndex: z.number().nullable().optional(),
+  fileUri: z.string().nullable().optional(),
+  fileHash: z.string().nullable().optional(),
+  createdAt: z.string().nullable().optional()
+});
+const agentFeedbackResponseSchema = z.object({
+  uaid: z.string(),
+  summary: agentFeedbackSummarySchema,
+  entries: z.array(agentFeedbackEntrySchema)
+});
+const agentFeedbackEligibilityResponseSchema = z.object({
+  uaid: z.string(),
+  sessionId: z.string(),
+  eligible: z.boolean(),
+  messageCount: z.number(),
+  minimumMessages: z.number(),
+  reason: z.string().optional(),
+  onchain: z.object({
+    eligible: z.boolean(),
+    reason: z.string().optional(),
+    estimatedCredits: z.number().optional(),
+    usdEstimate: z.number().optional(),
+    nativeFeeEstimate: z.number().optional()
+  }).optional()
+});
+const agentFeedbackSubmissionResponseSchema = z.object({
+  uaid: z.string(),
+  registry: z.string(),
+  network: z.string().optional(),
+  agentId: z.number(),
+  score: z.number(),
+  tag1: z.string().nullable().optional(),
+  tag2: z.string().nullable().optional(),
+  fileUri: z.string().nullable().optional(),
+  fileHash: z.string().nullable().optional(),
+  feedbackIndex: z.number().nullable().optional(),
+  transactionHash: z.string().nullable().optional(),
+  signature: z.string().nullable().optional(),
+  submittedAt: z.string()
+});
+const agentFeedbackIndexResponseSchema = z.object({
+  page: z.number(),
+  limit: z.number(),
+  total: z.number(),
+  items: z.array(
+    z.object({
+      uaid: z.string(),
+      registry: z.string(),
+      network: z.string().optional(),
+      agentId: z.number().nullable().optional(),
+      summary: agentFeedbackSummarySchema.nullable(),
+      trustScore: z.number().nullable().optional()
+    })
+  )
+});
+const agentFeedbackEntriesIndexResponseSchema = z.object({
+  page: z.number(),
+  limit: z.number(),
+  total: z.number(),
+  items: z.array(
+    z.object({
+      uaid: z.string(),
+      entry: agentFeedbackEntrySchema
+    })
+  )
+});
+const createSessionResponseSchema = z.object({
+  sessionId: z.string(),
+  uaid: z.string().nullable().optional(),
+  agent: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    capabilities: z.record(jsonValueSchema).nullable().optional(),
+    skills: z.array(z.string()).optional()
+  }),
+  history: z.array(chatHistoryEntrySchema).optional().default([]),
+  historyTtlSeconds: z.number().nullable().optional(),
+  encryption: sessionEncryptionSummarySchema.nullable().optional(),
+  route: chatRouteSummarySchema.optional(),
+  transport: z.string().optional(),
+  senderUaid: z.string().nullable().optional(),
+  visibility: z.enum(["private", "public"]).optional(),
+  payment: chatPaymentStateSchema.optional(),
+  readiness: chatReadinessResponseSchema.optional(),
+  state: chatSessionStateSchema.optional(),
+  traceId: z.string().optional(),
+  expiresAt: z.string().nullable().optional()
+});
+const sendMessageResponseSchema = z.object({
+  sessionId: z.string(),
+  uaid: z.string().nullable().optional(),
+  message: z.string(),
+  timestamp: z.string(),
+  rawResponse: jsonValueSchema.optional(),
+  content: z.string().optional(),
+  ops: z.array(z.record(jsonValueSchema)).optional(),
+  history: z.array(chatHistoryEntrySchema).optional(),
+  historyTtlSeconds: z.number().nullable().optional(),
+  encrypted: z.boolean().optional(),
+  messageId: z.string().optional(),
+  assistantMessageId: z.string().nullable().optional(),
+  deliveryState: chatDeliveryStateSchema.optional(),
+  replyMode: chatReplyModeSchema.optional(),
+  deliveryConfirmation: z.boolean().optional(),
+  idempotent: z.boolean().optional(),
+  metadata: z.record(jsonValueSchema).optional(),
+  errorCode: chatErrorCodeSchema.optional()
+});
+const chatSessionEndResponseSchema = z.object({
+  message: z.string(),
+  sessionId: z.string(),
+  state: chatSessionStateSchema.optional()
+});
+const chatHistorySnapshotResponseSchema = z.object({
+  sessionId: z.string(),
+  history: z.array(chatHistoryEntrySchema),
+  historyTtlSeconds: z.number()
+});
+z.object({
+  preserveEntries: z.number().int().min(0).optional()
+}).strict();
+const chatHistoryCompactionResponseSchema = z.object({
+  sessionId: z.string(),
+  history: z.array(chatHistoryEntrySchema),
+  summaryEntry: chatHistoryEntrySchema,
+  preservedEntries: z.array(chatHistoryEntrySchema),
+  historyTtlSeconds: z.number(),
+  creditsDebited: z.number(),
+  metadata: z.record(jsonValueSchema).optional()
+});
+const sessionEncryptionStatusResponseSchema = z.object({
+  sessionId: z.string(),
+  encryption: sessionEncryptionSummarySchema.nullable()
+});
+const encryptionHandshakeResponseSchema = z.object({
+  sessionId: z.string(),
+  handshake: encryptionHandshakeRecordSchema
+});
+const registerEncryptionKeyResponseSchema = z.object({
+  id: z.string(),
+  keyType: z.string(),
+  publicKey: z.string(),
+  uaid: z.string().nullable(),
+  ledgerAccountId: z.string().nullable(),
+  ledgerNetwork: z.string().nullable().optional(),
+  userId: z.string().nullable().optional(),
+  email: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+const ledgerChallengeResponseSchema = z.object({
+  challengeId: z.string(),
+  message: z.string(),
+  expiresAt: z.string()
+});
+const ledgerApiKeySummarySchema = z.object({
+  id: z.string(),
+  label: z.string().optional(),
+  prefix: z.string(),
+  lastFour: z.string(),
+  createdAt: z.string(),
+  lastUsedAt: z.string().nullable().optional(),
+  ownerType: z.literal("ledger"),
+  ledgerAccountId: z.string().optional(),
+  ledgerNetwork: z.string().optional(),
+  ledgerNetworkCanonical: z.string().optional()
+});
+const ledgerVerifyResponseSchema = z.object({
+  key: z.string(),
+  apiKey: ledgerApiKeySummarySchema,
+  accountId: z.string(),
+  network: z.string(),
+  networkCanonical: z.string().optional()
+});
+const protocolsResponseSchema = z.object({
+  protocols: z.array(z.string())
+});
+const detectProtocolResponseSchema = z.object({
+  protocol: z.string().nullable()
+});
+const registrySearchByNamespaceSchema = z.object({
+  hits: z.array(searchHitSchema),
+  total: z.number(),
+  page: z.number().optional(),
+  limit: z.number().optional()
+});
+const capabilityFilterValueSchema = z.union([z.string(), z.number()]);
+const vectorSearchFilterSchema = z.object({
+  capabilities: z.array(capabilityFilterValueSchema).optional(),
+  type: z.enum(["ai-agents", "mcp-servers"]).optional(),
+  registry: z.string().optional(),
+  protocols: z.array(z.string()).optional(),
+  adapter: z.array(z.string()).optional()
+}).strict();
+z.object({
+  query: z.string(),
+  filter: vectorSearchFilterSchema.optional(),
+  limit: z.number().int().min(1).max(100).optional(),
+  offset: z.number().int().min(0).optional()
+}).strict();
+const vectorSearchHitSchema = z.object({
+  agent: searchHitSchema,
+  score: z.number().optional(),
+  highlights: z.record(z.array(z.string())).optional()
+});
+const vectorSearchResponseSchema = z.object({
+  hits: z.array(vectorSearchHitSchema),
+  total: z.number(),
+  took: z.number(),
+  totalAvailable: z.number().optional(),
+  visible: z.number().optional(),
+  limited: z.boolean().optional(),
+  credits_used: z.number().optional()
+});
+const vectorStatusSchema = z.object({
+  enabled: z.boolean(),
+  healthy: z.boolean(),
+  mode: z.enum(["disabled", "initializing", "healthy", "degraded", "error"]),
+  lastUpdated: z.string(),
+  details: z.record(z.any()).optional(),
+  lastError: z.object({
+    message: z.string(),
+    stack: z.string().optional(),
+    timestamp: z.string().optional()
+  }).optional()
+});
+const searchStatusResponseSchema = z.object({
+  storageMode: z.string(),
+  vectorStatus: vectorStatusSchema
+});
+const websocketStatsResponseSchema = z.object({
+  clients: z.number(),
+  stats: z.object({
+    totalClients: z.number().optional(),
+    clientsByRegistry: z.record(z.number()).optional(),
+    clientsByEventType: z.record(z.number()).optional()
+  }).passthrough()
+});
+const durationStatsSchema = z.object({
+  p50: z.number(),
+  p90: z.number(),
+  p95: z.number(),
+  p99: z.number()
+});
+const metricsSummaryResponseSchema = z.object({
+  http: z.object({
+    requestsTotal: z.number(),
+    activeConnections: z.number(),
+    requestDuration: durationStatsSchema
+  }),
+  search: z.object({
+    queriesTotal: z.number(),
+    queryDuration: durationStatsSchema
+  }),
+  indexing: z.object({ agentsTotal: z.number(), crawlErrors: z.number() }),
+  registration: z.object({
+    total: z.number(),
+    failures: z.number(),
+    duration: durationStatsSchema
+  }),
+  cache: z.object({
+    hits: z.number(),
+    misses: z.number(),
+    hitRate: z.number()
+  }),
+  websocket: z.object({ connections: z.number() })
+});
+const uaidValidationResponseSchema = z.object({
+  uaid: z.string(),
+  valid: z.boolean(),
+  formats: z.array(z.string())
+});
+const adapterConnectionSchema = z.object({
+  id: z.string(),
+  agentId: z.string(),
+  protocol: z.string(),
+  endpoint: z.string(),
+  status: z.enum(["connected", "disconnected", "error"]),
+  metadata: z.record(jsonPrimitiveSchema).optional(),
+  createdAt: z.string()
+});
+const uaidConnectionStatusSchema = z.object({
+  connected: z.boolean(),
+  connection: adapterConnectionSchema.optional(),
+  adapter: z.string().optional(),
+  agentId: z.string().optional()
+});
+const dashboardStatsResponseSchema = z.object({
+  operatorId: z.string().optional(),
+  adapters: z.array(
+    z.object({
+      name: z.string(),
+      version: z.string(),
+      status: z.string(),
+      agentCount: z.number(),
+      lastDiscovery: z.string(),
+      registryType: z.string(),
+      health: z.string()
+    })
+  ).optional(),
+  totalAgents: z.number().optional(),
+  elasticsearchDocumentCount: z.number().optional(),
+  agentsByAdapter: z.record(z.number()).optional(),
+  agentsByRegistry: z.record(z.number()).optional(),
+  systemInfo: z.object({
+    uptime: z.number().optional(),
+    version: z.string().optional(),
+    network: z.string().optional()
+  }).optional()
+});
+const registrationAgentSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.string(),
+  endpoint: z.string().optional(),
+  capabilities: z.array(capabilityValueSchema),
+  registry: z.string().optional(),
+  protocol: z.string().optional(),
+  profile: agentProfileSchema.optional(),
+  nativeId: z.string().optional(),
+  metadata: z.record(jsonValueSchema).optional()
+});
+const registrationProfileInfoSchema = z.object({
+  tId: z.string().nullable(),
+  sizeBytes: z.number().optional()
+});
+const profileRegistrySchema = z.object({
+  topicId: z.string().optional(),
+  sequenceNumber: z.number().optional(),
+  profileReference: z.string().optional(),
+  profileTopicId: z.string().optional()
+}).passthrough().nullable().optional();
+const additionalRegistryResultSchema = z.object({
+  registry: z.string(),
+  status: z.enum([
+    "created",
+    "duplicate",
+    "skipped",
+    "error",
+    "updated",
+    "pending"
+  ]),
+  agentId: z.string().nullable().optional(),
+  agentUri: z.string().nullable().optional(),
+  error: z.string().optional(),
+  metadata: z.record(jsonValueSchema).optional(),
+  registryKey: z.string().optional(),
+  networkId: z.string().optional(),
+  networkName: z.string().optional(),
+  chainId: z.number().optional(),
+  estimatedCredits: z.number().nullable().optional(),
+  gasEstimateCredits: z.number().nullable().optional(),
+  gasEstimateUsd: z.number().nullable().optional(),
+  gasPriceGwei: z.number().nullable().optional(),
+  gasLimit: z.number().nullable().optional(),
+  creditMode: z.enum(["fixed", "gas"]).nullable().optional(),
+  minCredits: z.number().nullable().optional(),
+  consumedCredits: z.number().nullable().optional(),
+  cost: z.object({
+    credits: z.number(),
+    usd: z.number(),
+    eth: z.number(),
+    gasUsedWei: z.string(),
+    effectiveGasPriceWei: z.string().nullable().optional(),
+    transactions: z.array(
+      z.object({
+        hash: z.string(),
+        gasUsedWei: z.string(),
+        effectiveGasPriceWei: z.string().nullable().optional(),
+        costWei: z.string()
+      })
+    ).optional()
+  }).optional()
+});
+const registrationCreditsSchema = z.object({
+  base: z.number(),
+  additional: z.number(),
+  total: z.number()
+});
+const hcs10RegistrySchema = z.object({
+  status: z.string(),
+  uaid: z.string().optional(),
+  transactionId: z.string().optional(),
+  consensusTimestamp: z.string().optional(),
+  registryTopicId: z.string().optional(),
+  topicSequenceNumber: z.number().optional(),
+  payloadHash: z.string().optional(),
+  profileReference: z.string().optional(),
+  tId: z.string().optional(),
+  profileSizeBytes: z.number().optional(),
+  error: z.string().optional()
+}).passthrough();
+const additionalRegistryNetworkSchema = z.object({
+  key: z.string(),
+  registryId: z.string().optional(),
+  networkId: z.string().optional(),
+  name: z.string().optional(),
+  chainId: z.number().optional(),
+  label: z.string().optional(),
+  estimatedCredits: z.number().nullable().optional(),
+  baseCredits: z.number().nullable().optional(),
+  gasPortionCredits: z.number().nullable().optional(),
+  gasPortionUsd: z.number().nullable().optional(),
+  gasEstimateCredits: z.number().nullable().optional(),
+  gasEstimateUsd: z.number().nullable().optional(),
+  gasPriceGwei: z.number().nullable().optional(),
+  gasLimit: z.number().nullable().optional(),
+  minCredits: z.number().nullable().optional(),
+  creditMode: z.string().nullable().optional()
+}).passthrough();
+const additionalRegistryDescriptorSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  networks: z.array(additionalRegistryNetworkSchema)
+});
+const additionalRegistryCatalogResponseSchema = z.object({
+  registries: z.array(additionalRegistryDescriptorSchema)
+});
+const registerAgentSuccessResponse = z.object({
+  success: z.literal(true),
+  status: z.enum(["created", "duplicate", "updated"]).optional(),
+  uaid: z.string(),
+  agentId: z.string(),
+  message: z.string().optional(),
+  registry: z.string().optional(),
+  attemptId: z.string().nullable().optional(),
+  agent: registrationAgentSchema,
+  openConvAI: z.object({
+    compatible: z.boolean(),
+    hcs11Profile: agentProfileSchema.optional(),
+    bridgeEndpoint: z.string().optional()
+  }).optional(),
+  profile: registrationProfileInfoSchema.optional(),
+  profileRegistry: profileRegistrySchema.nullable().optional(),
+  hcs10Registry: hcs10RegistrySchema.nullable().optional(),
+  credits: registrationCreditsSchema.optional(),
+  additionalRegistries: z.array(additionalRegistryResultSchema).optional(),
+  additionalRegistryCredits: z.array(additionalRegistryResultSchema).optional(),
+  additionalRegistryCostPerRegistry: z.number().optional(),
+  additionalRegistrySecrets: z.record(z.string(), z.record(jsonValueSchema)).optional()
+});
+const registerAgentPendingResponse = z.object({
+  success: z.literal(true),
+  status: z.literal("pending"),
+  message: z.string(),
+  uaid: z.string(),
+  agentId: z.string(),
+  registry: z.string().optional(),
+  attemptId: z.string().nullable(),
+  agent: registrationAgentSchema,
+  openConvAI: z.object({
+    compatible: z.boolean(),
+    hcs11Profile: agentProfileSchema.optional(),
+    bridgeEndpoint: z.string().optional()
+  }).optional(),
+  profile: registrationProfileInfoSchema.optional(),
+  profileRegistry: profileRegistrySchema.nullable().optional(),
+  hcs10Registry: hcs10RegistrySchema.nullable().optional(),
+  credits: registrationCreditsSchema,
+  additionalRegistries: z.array(additionalRegistryResultSchema),
+  additionalRegistryCredits: z.array(additionalRegistryResultSchema).optional(),
+  additionalRegistryCostPerRegistry: z.number().optional(),
+  additionalRegistrySecrets: z.record(z.string(), z.record(jsonValueSchema)).optional()
+});
+const registerAgentPartialResponse = z.object({
+  success: z.literal(false),
+  status: z.literal("partial"),
+  message: z.string(),
+  uaid: z.string(),
+  agentId: z.string(),
+  registry: z.string().optional(),
+  attemptId: z.string().nullable().optional(),
+  agent: registrationAgentSchema,
+  openConvAI: z.object({
+    compatible: z.boolean(),
+    hcs11Profile: agentProfileSchema.optional(),
+    bridgeEndpoint: z.string().optional()
+  }).optional(),
+  profile: registrationProfileInfoSchema.optional(),
+  profileRegistry: profileRegistrySchema.nullable().optional(),
+  hcs10Registry: hcs10RegistrySchema.nullable().optional(),
+  credits: registrationCreditsSchema.optional(),
+  additionalRegistries: z.array(additionalRegistryResultSchema).optional(),
+  additionalRegistryCredits: z.array(additionalRegistryResultSchema).optional(),
+  additionalRegistryCostPerRegistry: z.number().optional(),
+  additionalRegistrySecrets: z.record(z.string(), z.record(jsonValueSchema)).optional(),
+  errors: z.array(
+    z.object({
+      registry: z.string(),
+      registryKey: z.string().nullable().optional(),
+      error: z.string()
+    })
+  ).min(1)
+});
+const registerAgentResponseSchema = z.union([
+  registerAgentSuccessResponse,
+  registerAgentPendingResponse,
+  registerAgentPartialResponse
+]);
+const registrationProgressAdditionalEntry = z.object({
+  registryId: z.string(),
+  registryKey: z.string(),
+  networkId: z.string().optional(),
+  networkName: z.string().optional(),
+  chainId: z.number().optional(),
+  label: z.string().optional(),
+  status: z.enum(["pending", "in_progress", "completed", "failed"]),
+  error: z.string().optional(),
+  credits: z.number().nullable().optional(),
+  agentId: z.string().nullable().optional(),
+  agentUri: z.string().nullable().optional(),
+  metadata: z.record(jsonValueSchema).optional(),
+  lastUpdated: z.string()
+});
+const registrationProgressRecord = z.object({
+  attemptId: z.string(),
+  mode: z.enum(["register", "update"]),
+  status: z.enum(["pending", "partial", "completed", "failed"]),
+  uaid: z.string().optional(),
+  agentId: z.string().optional(),
+  registryNamespace: z.string(),
+  accountId: z.string().optional(),
+  startedAt: z.string(),
+  completedAt: z.string().optional(),
+  primary: z.object({
+    status: z.enum(["pending", "completed", "failed"]),
+    finishedAt: z.string().optional(),
+    error: z.string().optional()
+  }),
+  additionalRegistries: z.record(
+    z.string(),
+    registrationProgressAdditionalEntry
+  ),
+  errors: z.array(z.string()).optional()
+});
+const registrationProgressResponseSchema = z.object({
+  progress: registrationProgressRecord
+});
+const registrationQuoteResponseSchema = z.object({
+  accountId: z.string().nullable().optional(),
+  registry: z.string().optional(),
+  protocol: z.string().optional(),
+  requiredCredits: z.number(),
+  availableCredits: z.number().nullable().optional(),
+  shortfallCredits: z.number().nullable().optional(),
+  creditsPerHbar: z.number().nullable().optional(),
+  estimatedHbar: z.number().nullable().optional()
+});
+const creditPurchaseResponseSchema = z.object({
+  success: z.boolean().optional(),
+  purchaser: z.string(),
+  credits: z.number(),
+  hbarAmount: z.number(),
+  transactionId: z.string(),
+  consensusTimestamp: z.string().nullable().optional()
+});
+const creditProviderSummarySchema = z.object({
+  name: z.string(),
+  publishableKey: z.string().optional(),
+  currency: z.string().optional(),
+  centsPerHbar: z.number().nullable().optional()
+});
+const creditProvidersResponseSchema = z.object({
+  providers: z.array(creditProviderSummarySchema)
+});
+const creditBalanceResponseSchema = z.object({
+  accountId: z.string(),
+  balance: z.number(),
+  balanceRecord: jsonValueSchema.optional(),
+  timestamp: z.string().optional()
+});
+const guardPlanIdSchema = z.enum(["free", "pro", "team", "enterprise"]);
+const guardBucketBalanceSchema = z.object({
+  bucketId: z.enum([
+    "registry_credits",
+    "chat_credits",
+    "guard_credits",
+    "org_policy_credits"
+  ]),
+  label: z.string(),
+  availableCredits: z.number(),
+  includedMonthlyCredits: z.number().nullable().optional()
+});
+const guardPrincipalSchema = z.object({
+  signedIn: z.boolean(),
+  principalType: z.enum(["user", "service"]).default("user"),
+  userId: z.string().optional(),
+  email: z.string().optional(),
+  accountId: z.string().optional(),
+  stripeCustomerId: z.string().optional(),
+  serviceId: z.string().optional(),
+  workspaceId: z.string().optional(),
+  serviceLabel: z.string().optional(),
+  roles: z.array(z.string())
+});
+const guardEntitlementsSchema = z.object({
+  planId: guardPlanIdSchema,
+  includedMonthlyCredits: z.number(),
+  deviceLimit: z.number(),
+  retentionDays: z.number(),
+  syncEnabled: z.boolean(),
+  premiumFeedsEnabled: z.boolean(),
+  teamPolicyEnabled: z.boolean()
+});
+const guardSessionResponseSchema = z.object({
+  principal: guardPrincipalSchema,
+  entitlements: guardEntitlementsSchema,
+  balance: z.object({
+    accountId: z.string(),
+    availableCredits: z.number()
+  }).nullable(),
+  bucketingMode: z.enum(["shared-ledger", "product-bucketed"]),
+  buckets: z.array(guardBucketBalanceSchema)
+});
+const guardBalanceResponseSchema = z.object({
+  generatedAt: z.string(),
+  bucketingMode: z.enum(["shared-ledger", "product-bucketed"]),
+  buckets: z.array(guardBucketBalanceSchema)
+});
+const guardFeedItemSchema = z.object({
+  id: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  slug: z.string(),
+  name: z.string(),
+  href: z.string(),
+  ecosystem: z.string().optional(),
+  safetyScore: z.number().nullable().optional(),
+  trustScore: z.number().nullable().optional(),
+  verified: z.boolean(),
+  recommendation: z.enum(["monitor", "review", "block"]),
+  updatedAt: z.string()
+});
+const guardFeedSummarySchema = z.object({
+  total: z.number(),
+  monitorCount: z.number(),
+  reviewCount: z.number(),
+  blockCount: z.number()
+});
+const guardFeedResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardFeedItemSchema),
+  summary: guardFeedSummarySchema
+});
+const guardIntegrationSchema = z.object({
+  id: z.enum(["openclaw", "hermes"]),
+  name: z.string(),
+  status: z.enum(["available", "planned"]),
+  href: z.string().nullable(),
+  summary: z.string()
+});
+const guardActionItemSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  href: z.string()
+});
+const guardOverviewResponseSchema = z.object({
+  generatedAt: z.string(),
+  principal: guardPrincipalSchema,
+  entitlements: guardEntitlementsSchema,
+  balance: z.object({
+    accountId: z.string(),
+    availableCredits: z.number()
+  }).nullable(),
+  trustFeed: guardFeedResponseSchema,
+  integrations: z.array(guardIntegrationSchema),
+  actionItems: z.array(guardActionItemSchema)
+});
+const guardPolicySchema = z.object({
+  mode: z.enum(["observe", "prompt", "enforce"]),
+  defaultAction: z.enum(["allow", "warn", "block"]),
+  unknownPublisherAction: z.enum(["review", "block", "allow"]),
+  changedHashAction: z.enum(["allow", "warn", "require-reapproval", "block"]),
+  newNetworkDomainAction: z.enum(["allow", "warn", "block"]),
+  subprocessAction: z.enum(["allow", "warn", "block"]),
+  telemetryEnabled: z.boolean(),
+  syncEnabled: z.boolean(),
+  updatedAt: z.string()
+});
+const guardTrustMatchSchema = z.object({
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  artifactSlug: z.string(),
+  recommendation: z.enum(["monitor", "review", "block"]),
+  verified: z.boolean(),
+  safetyScore: z.number().nullable().optional(),
+  trustScore: z.number().nullable().optional(),
+  href: z.string().optional(),
+  ecosystem: z.string().optional()
+});
+const guardTrustByHashResponseSchema = z.object({
+  generatedAt: z.string(),
+  query: z.object({
+    sha256: z.string()
+  }),
+  match: guardTrustMatchSchema.nullable(),
+  evidence: z.array(z.string())
+});
+const guardTrustResolveResponseSchema = z.object({
+  generatedAt: z.string(),
+  query: z.object({
+    ecosystem: z.string().optional(),
+    name: z.string().optional(),
+    version: z.string().optional()
+  }),
+  items: z.array(guardTrustMatchSchema)
+});
+const guardRevocationSchema = z.object({
+  id: z.string(),
+  artifactId: z.string(),
+  artifactName: z.string(),
+  reason: z.string(),
+  severity: z.enum(["low", "medium", "high"]),
+  publishedAt: z.string(),
+  confidence: z.number().optional(),
+  remediation: z.string().nullable().optional(),
+  scope: z.enum(["artifact", "publisher", "domain", "workspace", "ecosystem"]).optional(),
+  source: z.string().optional(),
+  firstSeenAt: z.string().optional(),
+  lastUpdatedAt: z.string().optional()
+});
+const guardRevocationResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardRevocationSchema)
+});
+const guardReceiptSchema = z.object({
+  receiptId: z.string(),
+  capturedAt: z.string(),
+  harness: z.string(),
+  deviceId: z.string(),
+  deviceName: z.string(),
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  artifactSlug: z.string(),
+  artifactHash: z.string(),
+  policyDecision: z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  recommendation: z.enum(["monitor", "review", "block"]),
+  changedSinceLastApproval: z.boolean(),
+  publisher: z.string().optional(),
+  capabilities: z.array(z.string()),
+  summary: z.string()
+});
+const guardHistoryArtifactSchema = z.object({
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  artifactSlug: z.string(),
+  publisher: z.string().optional(),
+  harnesses: z.array(z.string()),
+  eventCount: z.number(),
+  firstSeenAt: z.string(),
+  lastSeenAt: z.string(),
+  latestDecision: z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  latestRecommendation: z.enum(["monitor", "review", "block"])
+});
+const guardReceiptHistoryResponseSchema = z.object({
+  generatedAt: z.string(),
+  artifacts: z.array(guardHistoryArtifactSchema)
+});
+const guardInventoryArtifactSchema = z.object({
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  artifactSlug: z.string(),
+  publisher: z.string().optional(),
+  harnesses: z.array(z.string()),
+  devices: z.array(z.string()),
+  eventCount: z.number(),
+  firstSeenAt: z.string(),
+  lastSeenAt: z.string(),
+  latestDecision: z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  latestRecommendation: z.enum(["monitor", "review", "block"]),
+  latestHash: z.string(),
+  latestSummary: z.string()
+});
+const guardInventoryDiffEntrySchema = z.object({
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  changeType: z.enum(["new", "changed", "removed"]),
+  previousHash: z.string().nullable(),
+  currentHash: z.string().nullable()
+});
+const guardInventoryDiffResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardInventoryDiffEntrySchema)
+});
+const guardReceiptSyncResponseSchema = z.object({
+  syncedAt: z.string(),
+  receiptsStored: z.number(),
+  inventoryStored: z.number().optional(),
+  inventoryDiff: guardInventoryDiffResponseSchema.optional(),
+  advisories: z.array(guardRevocationSchema).optional(),
+  policy: guardPolicySchema.optional(),
+  alertPreferences: z.lazy(() => guardAlertPreferencesSchema).optional(),
+  exceptions: z.array(z.lazy(() => guardExceptionItemSchema)).optional(),
+  teamPolicyPack: z.lazy(() => guardTeamPolicyPackSchema).optional()
+});
+const guardInventoryResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardInventoryArtifactSchema)
+});
+const guardAbomSummarySchema = z.object({
+  totalArtifacts: z.number(),
+  totalDevices: z.number(),
+  totalHarnesses: z.number(),
+  blockedArtifacts: z.number(),
+  reviewArtifacts: z.number()
+});
+const guardAbomResponseSchema = z.object({
+  generatedAt: z.string(),
+  summary: guardAbomSummarySchema,
+  items: z.array(guardInventoryArtifactSchema)
+});
+const guardTimelineEventSchema = z.object({
+  receiptId: z.string(),
+  capturedAt: z.string(),
+  harness: z.string(),
+  deviceId: z.string(),
+  deviceName: z.string(),
+  artifactHash: z.string(),
+  policyDecision: z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  recommendation: z.enum(["monitor", "review", "block"]),
+  changedSinceLastApproval: z.boolean(),
+  summary: z.string(),
+  capabilities: z.array(z.string()),
+  publisher: z.string().optional()
+});
+const guardArtifactTimelineResponseSchema = z.object({
+  generatedAt: z.string(),
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  artifactSlug: z.string(),
+  events: z.array(guardTimelineEventSchema)
+});
+const guardReceiptExportSummarySchema = z.object({
+  totalReceipts: z.number(),
+  blockedCount: z.number(),
+  reviewCount: z.number(),
+  approvedCount: z.number()
+});
+const guardExportSignatureSchema = z.object({
+  algorithm: z.enum(["hmac-sha256", "none"]),
+  digest: z.string()
+});
+const guardReceiptExportResponseSchema = z.object({
+  generatedAt: z.string(),
+  summary: guardReceiptExportSummarySchema,
+  provenanceSummary: z.array(z.string()),
+  items: z.array(guardReceiptSchema),
+  signature: guardExportSignatureSchema
+});
+const guardAlertPreferencesSchema = z.object({
+  emailEnabled: z.boolean(),
+  digestMode: z.enum(["immediate", "daily", "weekly"]),
+  watchlistEnabled: z.boolean(),
+  advisoriesEnabled: z.boolean(),
+  repeatedWarningsEnabled: z.boolean(),
+  teamAlertsEnabled: z.boolean(),
+  updatedAt: z.string()
+});
+const guardWatchlistItemSchema = z.object({
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  artifactSlug: z.string(),
+  reason: z.string(),
+  source: z.enum(["manual", "synced", "team-policy"]),
+  createdAt: z.string()
+});
+const guardWatchlistResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardWatchlistItemSchema)
+});
+const guardWatchlistLookupMatchSchema = z.object({
+  artifactId: z.string().nullable(),
+  publisher: z.string().nullable(),
+  domain: z.string().nullable(),
+  source: z.enum(["watchlist", "team-policy"]),
+  reason: z.string()
+});
+const guardWatchlistLookupResponseSchema = z.object({
+  generatedAt: z.string(),
+  matched: z.boolean(),
+  scope: z.enum(["artifact", "publisher", "domain", "none"]),
+  item: guardWatchlistLookupMatchSchema.nullable()
+});
+const guardPainSignalSchema = z.object({
+  signalId: z.string(),
+  signalName: z.string(),
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  harness: z.string(),
+  latestSummary: z.string(),
+  firstSeenAt: z.string(),
+  lastSeenAt: z.string(),
+  count: z.number(),
+  source: z.literal("scanner"),
+  publisher: z.string().optional()
+});
+const guardPainSignalListResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardPainSignalSchema)
+});
+const guardPainSignalAggregateSchema = z.object({
+  artifactId: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  signalName: z.string(),
+  latestSummary: z.string(),
+  firstSeenAt: z.string(),
+  lastSeenAt: z.string(),
+  totalCount: z.number(),
+  consumerCount: z.number(),
+  harnesses: z.array(z.string()),
+  publishers: z.array(z.string())
+});
+const guardPainSignalAggregateResponseSchema = z.object({
+  generatedAt: z.string(),
+  summary: z.object({
+    totalSignals: z.number(),
+    uniqueArtifacts: z.number(),
+    uniqueConsumers: z.number()
+  }),
+  items: z.array(guardPainSignalAggregateSchema)
+});
+const guardExceptionItemSchema = z.object({
+  exceptionId: z.string(),
+  scope: z.enum(["artifact", "publisher", "harness", "global"]),
+  harness: z.string().nullable(),
+  artifactId: z.string().nullable(),
+  publisher: z.string().nullable(),
+  reason: z.string(),
+  owner: z.string(),
+  source: z.enum(["manual", "team-policy"]),
+  expiresAt: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+const guardExceptionListResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardExceptionItemSchema)
+});
+const guardPreflightEvidenceSchema = z.object({
+  category: z.enum([
+    "policy",
+    "trust",
+    "watchlist",
+    "team-policy",
+    "exception"
+  ]),
+  source: z.string(),
+  detail: z.string()
+});
+z.object({
+  harness: z.string(),
+  artifactName: z.string(),
+  artifactType: z.enum(["skill", "plugin"]),
+  artifactId: z.string().optional(),
+  artifactSlug: z.string().optional(),
+  artifactHash: z.string().optional(),
+  publisher: z.string().optional(),
+  domain: z.string().optional(),
+  launchSummary: z.string().optional(),
+  capabilities: z.array(z.string()).optional(),
+  workspacePath: z.string().optional()
+});
+const guardPreflightVerdictResponseSchema = z.object({
+  generatedAt: z.string(),
+  principal: guardPrincipalSchema,
+  decision: z.enum(["allow", "review", "block"]),
+  recommendation: z.enum(["monitor", "review", "block"]),
+  rationale: z.string(),
+  category: z.enum(["exception", "team-policy", "watchlist", "trust", "policy"]).optional(),
+  confidence: z.number().optional(),
+  freshnessTimestamp: z.string().optional(),
+  evidenceSources: z.array(z.string()).optional(),
+  scope: z.enum(["artifact", "publisher", "domain", "policy"]),
+  matchedEvidence: z.array(guardPreflightEvidenceSchema),
+  matchedException: guardExceptionItemSchema.nullable(),
+  trustMatch: guardTrustMatchSchema.nullable()
+});
+const guardTeamPolicyAuditItemSchema = z.object({
+  changedAt: z.string(),
+  actor: z.string(),
+  change: z.enum(["created", "updated"]),
+  summary: z.string()
+});
+const guardTeamPolicyPackSchema = z.object({
+  name: z.string(),
+  sharedHarnessDefaults: z.record(
+    z.string(),
+    z.enum(["observe", "prompt", "enforce"])
+  ),
+  allowedPublishers: z.array(z.string()),
+  blockedPublishers: z.array(z.string()).optional(),
+  blockedDomains: z.array(z.string()).optional(),
+  blockedArtifacts: z.array(z.string()),
+  alertChannel: z.enum(["email", "slack", "teams", "webhook"]),
+  updatedAt: z.string(),
+  auditTrail: z.array(guardTeamPolicyAuditItemSchema)
+});
+const guardDeviceSchema = z.object({
+  deviceId: z.string(),
+  deviceName: z.string(),
+  harnesses: z.array(z.string()),
+  receiptCount: z.number(),
+  lastSeenAt: z.string()
+});
+const guardDeviceListResponseSchema = z.object({
+  generatedAt: z.string(),
+  items: z.array(guardDeviceSchema)
+});
+const hbarPurchaseIntentResponseSchema = z.object({
+  transaction: z.string(),
+  transactionId: z.string(),
+  network: z.enum(["mainnet", "testnet"]),
+  accountId: z.string(),
+  treasuryAccountId: z.string(),
+  hbarAmount: z.number(),
+  credits: z.number(),
+  tinybarAmount: z.number(),
+  memo: z.string(),
+  centsPerHbar: z.number(),
+  validStart: z.string(),
+  validDurationSeconds: z.number(),
+  requiresManualSubmit: z.literal(true),
+  purchaseId: z.string()
+});
+const x402SettlementSchema = z.object({
+  success: z.boolean().optional(),
+  transaction: z.string().optional(),
+  network: z.string().optional(),
+  payer: z.string().optional(),
+  errorReason: z.string().optional()
+}).strict();
+const x402CreditPurchaseResponseSchema = z.object({
+  success: z.boolean(),
+  accountId: z.string(),
+  creditedCredits: z.number(),
+  usdAmount: z.number(),
+  balance: z.number(),
+  payment: z.object({
+    payer: z.string().optional(),
+    requirement: z.record(jsonValueSchema).optional(),
+    settlement: x402SettlementSchema.optional()
+  }).optional()
+});
+const x402MinimumsResponseSchema = z.object({
+  minimums: z.record(
+    z.object({
+      network: z.string().optional(),
+      gasLimit: z.number().optional(),
+      gasPriceWei: z.string().optional(),
+      gasUsd: z.number().optional(),
+      minUsd: z.number().optional(),
+      ethUsd: z.number().optional(),
+      fetchedAt: z.string().optional(),
+      source: z.string().optional()
+    })
+  ).optional(),
+  creditUnitUsd: z.number().optional()
+});
+const adaptersResponseSchema = z.object({
+  adapters: z.array(z.string())
+});
+const adapterRegistryCategorySchema = z.object({
+  id: z.number().int(),
+  network: z.string(),
+  type: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  topicId: z.string(),
+  versionTopicId: z.string(),
+  registryTransactionId: z.string().nullable().optional(),
+  versionTransactionId: z.string().nullable().optional(),
+  metadataPointer: z.string().nullable().optional(),
+  metadataSequence: z.number().int().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  metadata: jsonValueSchema.optional().nullable()
+});
+const adapterRegistryCategoriesResponseSchema = z.object({
+  categories: z.array(adapterRegistryCategorySchema)
+});
+const adapterRegistryAdapterSchema = z.object({
+  id: z.union([z.string(), z.number()]).optional(),
+  network: z.string().optional(),
+  categoryId: z.union([z.string(), z.number()]).nullable().optional(),
+  operation: z.string().optional(),
+  adapterId: z.string(),
+  adapterName: z.string(),
+  entity: z.string(),
+  manifestPointer: z.string().nullable().optional(),
+  manifestSequence: z.number().int().nullable().optional(),
+  packageRegistry: z.string().nullable().optional(),
+  packageName: z.string().nullable().optional(),
+  packageVersion: z.string().nullable().optional(),
+  packageIntegrity: z.string().nullable().optional(),
+  stateModel: z.string().nullable().optional(),
+  config: jsonValueSchema.nullable().optional(),
+  signature: z.string().nullable().optional(),
+  manifest: jsonValueSchema.nullable().optional(),
+  keywords: z.array(z.string()).optional(),
+  searchText: z.string().nullable().optional(),
+  creditAccountId: z.string().nullable().optional(),
+  registeredByUserId: z.string().nullable().optional(),
+  registeredByEmail: z.string().nullable().optional(),
+  totalCostHbar: z.number().nullable().optional(),
+  totalCostCredits: z.number().nullable().optional(),
+  consensusTimestamp: z.string().nullable().optional(),
+  sequenceNumber: z.number().int().nullable().optional(),
+  payerAccountId: z.string().nullable().optional(),
+  mirrorNodePayload: jsonValueSchema.nullable().optional(),
+  versionTopicId: z.string().nullable().optional(),
+  declarationTopicId: z.string().nullable().optional(),
+  categoryEntrySequence: z.number().int().nullable().optional(),
+  categoryEntryTransactionId: z.string().nullable().optional(),
+  versionPointerSequence: z.number().int().nullable().optional(),
+  versionPointerTransactionId: z.string().nullable().optional(),
+  transactionId: z.string().nullable().optional(),
+  createdAt: z.string().optional(),
+  category: adapterRegistryCategorySchema.optional()
+}).passthrough();
+const adapterRegistryAdaptersResponseSchema = z.object({
+  network: z.string(),
+  adapters: z.array(adapterRegistryAdapterSchema)
+});
+const adapterRegistryCreateCategoryResponseSchema = z.object({
+  category: adapterRegistryCategorySchema
+});
+z.object({
+  adapter: z.record(jsonValueSchema),
+  declaration: adapterDeclarationSchema,
+  transactionId: z.string().optional().nullable(),
+  category: adapterRegistryCategorySchema
+});
+const adapterRegistrySubmitAdapterAcceptedResponseSchema = z.object({
+  submissionId: z.string(),
+  status: z.string().optional(),
+  network: z.string().optional(),
+  message: z.string().optional()
+}).passthrough();
+const adapterRegistrySubmissionStatusResponseSchema = z.object({
+  submission: z.object({
+    id: z.string(),
+    network: z.string(),
+    status: z.enum(["pending", "running", "completed", "failed"]),
+    adapterId: z.string(),
+    categorySlug: z.string().nullable().optional(),
+    creditAccountId: z.string().nullable().optional(),
+    registeredByUserId: z.string().nullable().optional(),
+    registeredByEmail: z.string().nullable().optional(),
+    requestPayload: jsonValueSchema.optional(),
+    resultPayload: jsonValueSchema.nullable().optional(),
+    error: z.string().nullable().optional(),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+    startedAt: z.string().nullable().optional(),
+    completedAt: z.string().nullable().optional()
+  }).passthrough()
+});
+const adapterChatProfileSchema = z.object({
+  supportsChat: z.boolean(),
+  delivery: z.string().optional(),
+  transport: z.string().optional(),
+  streaming: z.boolean().optional(),
+  requiresAuth: z.array(z.string()).optional(),
+  notes: z.string().optional()
+});
+const adapterCapabilitiesSchema = z.object({
+  discovery: z.boolean(),
+  routing: z.boolean(),
+  communication: z.boolean(),
+  translation: z.boolean(),
+  protocols: z.array(z.string())
+});
+const adapterDescriptorSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  description: z.string(),
+  supportedProtocols: z.array(z.string()),
+  registryType: z.enum(["web2", "web3", "hybrid"]),
+  chatProfile: adapterChatProfileSchema.optional(),
+  capabilities: adapterCapabilitiesSchema,
+  enabled: z.boolean(),
+  priority: z.number(),
+  status: z.enum(["running", "stopped"])
+});
+const adapterDetailsResponseSchema = z.object({
+  adapters: z.array(adapterDescriptorSchema)
+});
+const metadataFacetOptionSchema = z.object({
+  value: z.union([z.string(), z.number(), z.boolean()]),
+  label: z.string()
+});
+const searchFacetSchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+  type: z.enum(["string", "boolean", "number"]),
+  adapters: z.array(z.string()).optional(),
+  options: z.array(metadataFacetOptionSchema).optional()
+});
+const searchFacetsResponseSchema = z.object({
+  facets: z.array(searchFacetSchema)
+});
+const verificationExistingOwnershipSchema = z.object({
+  ownerType: z.string(),
+  ownerId: z.string(),
+  ownerHandle: z.string().optional(),
+  verifiedAt: z.string().optional(),
+  method: z.string().optional()
+}).passthrough();
+const verificationChallengeResponseSchema = z.object({
+  challengeId: z.string(),
+  code: z.string(),
+  expiresAt: z.string(),
+  expectedHandle: z.string(),
+  instructions: z.string(),
+  existingOwnership: verificationExistingOwnershipSchema.optional()
+}).passthrough();
+const verificationChallengeDetailsResponseSchema = z.object({
+  challengeId: z.string(),
+  uaid: z.string(),
+  code: z.string(),
+  expiresAt: z.string(),
+  status: z.string(),
+  message: z.string().optional()
+}).passthrough();
+const verificationVerifyResponseSchema = z.object({
+  verified: z.boolean(),
+  uaid: z.string(),
+  ownerType: z.string(),
+  ownerId: z.string(),
+  ownerHandle: z.string().optional(),
+  method: z.string().optional(),
+  verificationPostUrl: z.string().optional()
+}).passthrough();
+const verificationOwnershipResponseSchema = z.object({
+  uaid: z.string(),
+  ownerType: z.string(),
+  ownerId: z.string(),
+  ownerHandle: z.string().optional(),
+  chain: z.string(),
+  verifiedAt: z.string(),
+  method: z.string()
+}).passthrough();
+const verificationStatusResponseSchema = z.object({
+  uaid: z.string(),
+  verified: z.boolean(),
+  chain: z.string().nullable()
+}).passthrough();
+const verificationVerifySenderResponseSchema = z.object({
+  verified: z.boolean(),
+  uaid: z.string(),
+  ownerType: z.string(),
+  ownerId: z.string()
+}).passthrough();
+const verificationDnsErrorSchema = z.object({
+  code: z.string(),
+  message: z.string(),
+  details: z.record(jsonValueSchema).optional()
+}).passthrough();
+const verificationDnsStatusResponseSchema = z.object({
+  uaid: z.string(),
+  verified: z.boolean(),
+  profileId: z.string(),
+  checkedAt: z.string(),
+  nativeId: z.string().optional(),
+  dnsName: z.string().optional(),
+  verificationLevel: z.string().optional(),
+  resolutionMode: z.string().optional(),
+  reconstructedUaid: z.string().optional(),
+  selectedFollowupProfile: z.string().optional(),
+  error: verificationDnsErrorSchema.optional(),
+  source: z.string().optional(),
+  persisted: z.boolean().optional()
+}).passthrough();
+const registerStatusResponseSchema = z.object({
+  registered: z.boolean(),
+  agent: jsonValueSchema.optional()
+}).passthrough();
+const moltbookOwnerRegistrationUpdateResponseSchema = z.object({
+  ok: z.boolean(),
+  uaid: z.string(),
+  registered: z.boolean(),
+  registeredAt: z.string().optional(),
+  agent: jsonValueSchema.optional(),
+  warning: z.string().optional()
+}).passthrough();
+const skillRegistryFileRoleSchema = z.union([
+  z.literal("skill-md"),
+  z.literal("skill-json"),
+  z.literal("skill-icon"),
+  z.literal("file")
+]);
+const trustScoreBreakdownSchema = z.record(z.number()).refine(
+  (record) => typeof record.total === "number" && Number.isFinite(record.total),
+  { message: "trustScores.total is required" }
+);
+const skillSafetyLabelSchema = z.enum(["safe", "review", "caution", "unsafe"]);
+const skillSafetySummarySchema = z.object({
+  score: z.number(),
+  label: skillSafetyLabelSchema,
+  findingsTotal: z.number().int(),
+  highFindings: z.number().int(),
+  scriptsTotal: z.number().int(),
+  permissionsMissing: z.array(z.string())
+}).passthrough();
+const skillSafetyFindingSeveritySchema = z.enum(["low", "medium", "high"]);
+const skillSafetyFindingSchema = z.object({
+  ruleId: z.string(),
+  severity: skillSafetyFindingSeveritySchema,
+  file: z.string(),
+  message: z.string()
+}).passthrough();
+const skillRegistryFileDescriptorSchema = z.object({
+  name: z.string(),
+  mimeType: z.string(),
+  role: skillRegistryFileRoleSchema,
+  topicId: z.string().optional(),
+  hrl: z.string().optional(),
+  packageSequenceNumber: z.number().int().optional()
+}).passthrough();
+const skillRegistryPublishSummarySchema = z.object({
+  jobId: z.string(),
+  network: z.union([z.literal("mainnet"), z.literal("testnet")]),
+  name: z.string(),
+  version: z.string(),
+  description: z.string().optional(),
+  createdAt: z.string(),
+  directoryTopicId: z.string(),
+  skillUid: z.number().int().optional(),
+  directorySequenceNumber: z.number().int().optional(),
+  versionRegistryTopicId: z.string().optional(),
+  packageTopicId: z.string(),
+  manifestHrl: z.string().optional(),
+  skillJsonHrl: z.string(),
+  iconHcs1: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  category: z.string().optional(),
+  featured: z.boolean().optional(),
+  verified: z.boolean().optional(),
+  upvotes: z.number().int().optional(),
+  trustScore: z.number().optional(),
+  trustScores: trustScoreBreakdownSchema.optional(),
+  safety: skillSafetySummarySchema.optional(),
+  safetyFindings: z.array(skillSafetyFindingSchema).optional(),
+  files: z.array(skillRegistryFileDescriptorSchema).optional()
+}).passthrough();
+const skillRegistryListResponseSchema = z.object({
+  items: z.array(skillRegistryPublishSummarySchema),
+  nextCursor: z.string().nullable()
+}).passthrough();
+z.enum([
+  "stable",
+  "prerelease",
+  "all"
+]);
+z.enum([
+  "trending",
+  "upvotes",
+  "updated",
+  "name"
+]);
+const skillCatalogVersionSummarySchema = z.object({
+  version: z.string(),
+  publishedAt: z.string(),
+  verified: z.boolean().optional()
+}).passthrough();
+const skillCatalogItemSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  iconHcs1: z.string().optional(),
+  category: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  latest: skillCatalogVersionSummarySchema,
+  latestStable: skillCatalogVersionSummarySchema.optional(),
+  recommended: skillCatalogVersionSummarySchema,
+  upvotes: z.number().int(),
+  verified: z.boolean(),
+  repoStamped: z.boolean(),
+  trustScore: z.number().optional(),
+  safetyScore: z.number().optional()
+}).passthrough();
+const skillCatalogResponseSchema = z.object({
+  items: z.array(skillCatalogItemSchema),
+  nextCursor: z.string().nullable()
+}).passthrough();
+const skillRecommendedVersionResponseSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  updatedAt: z.string(),
+  setBy: z.string()
+}).passthrough();
+const skillDeprecationRecordSchema = z.object({
+  name: z.string(),
+  version: z.string().optional(),
+  reason: z.string(),
+  replacementRef: z.string().optional(),
+  deprecatedAt: z.string(),
+  deprecatedBy: z.string()
+}).passthrough();
+const skillDeprecationsResponseSchema = z.object({
+  name: z.string(),
+  items: z.array(skillDeprecationRecordSchema)
+}).passthrough();
+const skillSecurityBreakdownResponseSchema = z.object({
+  jobId: z.string(),
+  score: z.number().nullable().optional(),
+  findings: z.array(jsonValueSchema).optional(),
+  summary: jsonValueSchema.optional(),
+  generatedAt: z.string().nullable().optional(),
+  scannerVersion: z.string().nullable().optional()
+}).passthrough();
+const skillBadgeMetricSchema = z.enum([
+  "version",
+  "version_verification",
+  "status",
+  "verification",
+  "repo_commit",
+  "manifest",
+  "domain",
+  "trust",
+  "tier",
+  "safety",
+  "upvotes",
+  "updated"
+]);
+const skillBadgeStyleSchema = z.enum([
+  "flat",
+  "flat-square",
+  "for-the-badge",
+  "plastic",
+  "social"
+]);
+const skillBadgeResponseSchema = z.object({
+  schemaVersion: z.number().int(),
+  label: z.string(),
+  message: z.string(),
+  color: z.string(),
+  style: skillBadgeStyleSchema.optional(),
+  isError: z.boolean().optional(),
+  cacheSeconds: z.number().int().optional()
+}).passthrough();
+const skillRegistryTagsResponseSchema = z.object({
+  tags: z.array(z.string())
+}).passthrough();
+const skillRegistryCategoriesResponseSchema = z.object({
+  categories: z.array(z.string())
+}).passthrough();
+const skillResolverManifestResponseSchema = z.record(jsonValueSchema);
+const skillRegistryQuoteFileBreakdownSchema = z.object({
+  name: z.string(),
+  mimeType: z.string(),
+  estimatedCostHbar: z.number()
+}).passthrough();
+const skillRegistryQuoteResponseSchema = z.object({
+  quoteId: z.string(),
+  name: z.string(),
+  version: z.string(),
+  directoryTopicId: z.string(),
+  estimatedCostHbar: z.number(),
+  credits: z.number(),
+  usdCents: z.number(),
+  expiresAt: z.string(),
+  files: z.array(skillRegistryQuoteFileBreakdownSchema)
+}).passthrough();
+const skillRegistryJobStatusSchema = z.union([
+  z.literal("pending"),
+  z.literal("in_progress"),
+  z.literal("completed"),
+  z.literal("failed")
+]);
+const skillRegistryPublishResponseSchema = z.object({
+  jobId: z.string(),
+  status: skillRegistryJobStatusSchema,
+  credits: z.number().nullable().optional(),
+  usdCents: z.number().nullable().optional(),
+  quoteId: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  network: z.union([z.literal("mainnet"), z.literal("testnet")])
+}).passthrough();
+const skillRegistryJobStatusResponseSchema = z.object({
+  jobId: z.string(),
+  status: skillRegistryJobStatusSchema,
+  network: z.union([z.literal("mainnet"), z.literal("testnet")]),
+  name: z.string(),
+  version: z.string(),
+  directoryTopicId: z.string(),
+  skillUid: z.number().int().nullable().optional(),
+  directorySequenceNumber: z.number().int().nullable().optional(),
+  versionRegistryTopicId: z.string().nullable().optional(),
+  packageTopicId: z.string().nullable().optional(),
+  manifestHrl: z.string().nullable().optional(),
+  skillJsonHrl: z.string().nullable().optional(),
+  iconHcs1: z.string().nullable().optional(),
+  tags: z.array(z.string()).nullable().optional(),
+  category: z.string().nullable().optional(),
+  files: z.array(skillRegistryFileDescriptorSchema).nullable().optional(),
+  quoteCredits: z.number().nullable().optional(),
+  quoteUsdCents: z.number().nullable().optional(),
+  safety: skillSafetySummarySchema.nullable().optional(),
+  reservationId: z.string().nullable().optional(),
+  totalCostHbar: z.number().nullable().optional(),
+  totalCostCredits: z.number().nullable().optional(),
+  failureReason: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+}).passthrough();
+const skillRegistryVersionItemSchema = z.object({
+  jobId: z.string(),
+  version: z.string(),
+  createdAt: z.string(),
+  verified: z.boolean().optional()
+}).passthrough();
+const skillRegistryVersionsResponseSchema = z.object({
+  name: z.string(),
+  items: z.array(skillRegistryVersionItemSchema)
+}).passthrough();
+const skillRegistryMineItemSchema = z.object({
+  name: z.string(),
+  latestVersion: z.string(),
+  latestCreatedAt: z.string(),
+  verified: z.boolean().optional(),
+  iconHcs1: z.string().optional(),
+  versions: z.array(z.string())
+}).passthrough();
+const skillRegistryMineResponseSchema = z.object({
+  items: z.array(skillRegistryMineItemSchema)
+}).passthrough();
+const skillRegistryMyListResponseSchema = z.object({
+  owned: skillRegistryMineResponseSchema,
+  upvoted: skillRegistryListResponseSchema
+}).passthrough();
+const skillRegistryConfigResponseSchema = z.object({
+  enabled: z.boolean(),
+  directoryTopicId: z.string().nullable().optional(),
+  maxFiles: z.number().int().nullable().optional(),
+  maxTotalSizeBytes: z.number().int().nullable().optional(),
+  allowedMimeTypes: z.array(z.string()).nullable().optional(),
+  network: z.union([z.literal("mainnet"), z.literal("testnet")]).nullable().optional(),
+  publisher: z.object({
+    cliPackageUrl: z.string(),
+    cliCommand: z.string(),
+    actionMarketplaceUrl: z.string(),
+    repositoryUrl: z.string(),
+    guideUrl: z.string().nullable().optional(),
+    docsUrl: z.string().nullable().optional(),
+    submitUrl: z.string().nullable().optional(),
+    skillsIndexUrl: z.string().nullable().optional(),
+    quickstartCommands: z.array(
+      z.object({
+        id: z.string(),
+        label: z.string(),
+        description: z.string(),
+        command: z.string(),
+        href: z.string().nullable().optional()
+      }).passthrough()
+    ).optional().default([]),
+    templatePresets: z.array(
+      z.object({
+        presetId: z.string(),
+        label: z.string(),
+        description: z.string(),
+        recommendedFor: z.string(),
+        command: z.string()
+      }).passthrough()
+    ).optional().default([])
+  }).nullable().optional()
+}).passthrough();
+const skillRegistryOwnershipResponseSchema = z.object({
+  name: z.string(),
+  exists: z.boolean(),
+  isOwner: z.boolean()
+}).passthrough();
+const skillRegistryVoteStatusResponseSchema = z.object({
+  name: z.string(),
+  upvotes: z.number().int(),
+  hasUpvoted: z.boolean()
+}).passthrough();
+const skillTrustTierSchema = z.enum([
+  "unclaimed",
+  "validated",
+  "published",
+  "verified",
+  "hardened"
+]);
+const skillStatusNextStepSchema = z.object({
+  kind: z.enum([
+    "setup_validate",
+    "publish_first_release",
+    "verify_domain",
+    "harden_workflow",
+    "share_status"
+  ]),
+  priority: z.number().int(),
+  id: z.string(),
+  label: z.string(),
+  description: z.string(),
+  url: z.string().nullable().optional(),
+  href: z.string().nullable().optional(),
+  command: z.string().nullable().optional()
+}).passthrough();
+const skillPreviewSuggestedNextStepSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  description: z.string(),
+  command: z.string().optional(),
+  href: z.string().optional()
+}).passthrough();
+const skillPreviewReportSchema = z.object({
+  schema_version: z.literal("skill-preview.v1"),
+  tool_version: z.string(),
+  preview_id: z.string(),
+  repo_url: z.string(),
+  repo_owner: z.string(),
+  repo_name: z.string(),
+  default_branch: z.string(),
+  commit_sha: z.string(),
+  ref: z.string(),
+  event_name: z.string(),
+  workflow_run_url: z.string(),
+  skill_dir: z.string(),
+  name: z.string(),
+  version: z.string(),
+  validation_status: z.literal("passed"),
+  findings: z.array(z.unknown()),
+  package_summary: z.record(z.string(), z.unknown()),
+  suggested_next_steps: z.array(skillPreviewSuggestedNextStepSchema),
+  generated_at: z.string()
+}).passthrough();
+const skillPreviewRecordSchema = z.object({
+  id: z.string(),
+  previewId: z.string(),
+  source: z.literal("github-oidc"),
+  report: skillPreviewReportSchema,
+  generatedAt: z.string(),
+  expiresAt: z.string(),
+  statusUrl: z.string(),
+  authoritative: z.boolean()
+}).passthrough();
+const skillPreviewLookupResponseSchema = z.object({
+  found: z.boolean(),
+  authoritative: z.boolean(),
+  preview: skillPreviewRecordSchema.nullable(),
+  statusUrl: z.string().nullable(),
+  expiresAt: z.string().nullable()
+}).passthrough();
+const skillStatusPreviewMetadataSchema = z.object({
+  previewId: z.string(),
+  repoUrl: z.string(),
+  repoOwner: z.string(),
+  repoName: z.string(),
+  commitSha: z.string(),
+  ref: z.string(),
+  eventName: z.string(),
+  skillDir: z.string(),
+  generatedAt: z.string(),
+  expiresAt: z.string(),
+  statusUrl: z.string()
+}).passthrough();
+const skillStatusChecksSchema = z.object({
+  repoCommitIntegrity: z.boolean(),
+  manifestIntegrity: z.boolean(),
+  domainProof: z.boolean()
+}).passthrough();
+const skillStatusVerificationSignalsSchema = z.object({
+  publisherBound: z.boolean(),
+  domainProof: z.boolean(),
+  verifiedDomain: z.boolean(),
+  previewValidated: z.boolean()
+}).passthrough();
+const skillStatusProvenanceSignalsSchema = z.object({
+  repoCommitIntegrity: z.boolean(),
+  manifestIntegrity: z.boolean(),
+  canonicalRelease: z.boolean(),
+  previewAvailable: z.boolean(),
+  previewAuthoritative: z.boolean()
+}).passthrough();
+const skillStatusResponseSchema = z.object({
+  name: z.string(),
+  version: z.string().nullable(),
+  published: z.boolean(),
+  verifiedDomain: z.boolean(),
+  trustTier: skillTrustTierSchema,
+  badgeMetric: skillBadgeMetricSchema,
+  checks: skillStatusChecksSchema,
+  nextSteps: z.array(skillStatusNextStepSchema),
+  verificationSignals: skillStatusVerificationSignalsSchema,
+  provenanceSignals: skillStatusProvenanceSignalsSchema,
+  publisher: skillRegistryConfigResponseSchema.shape.publisher,
+  preview: skillStatusPreviewMetadataSchema.nullable().optional(),
+  statusUrl: z.string().nullable().optional()
+}).passthrough();
+const skillQuotePreviewRangeSchema = z.object({
+  min: z.number(),
+  max: z.number()
+}).passthrough();
+const skillQuotePreviewResponseSchema = z.object({
+  estimatedCredits: skillQuotePreviewRangeSchema,
+  estimatedHbar: skillQuotePreviewRangeSchema,
+  pricingVersion: z.string(),
+  assumptions: z.array(z.string()),
+  purchaseUrl: z.string().nullable(),
+  publishUrl: z.string().nullable(),
+  verificationUrl: z.string().nullable()
+}).passthrough();
+const skillConversionSignalsResponseSchema = z.object({
+  repoUrl: z.string(),
+  skillDir: z.string(),
+  trustTier: skillTrustTierSchema,
+  actionInstalled: z.boolean(),
+  previewUploaded: z.boolean(),
+  previewId: z.string().nullable(),
+  lastValidateSuccessAt: z.string().nullable(),
+  stalePreviewAgeDays: z.number().nullable(),
+  published: z.boolean(),
+  verified: z.boolean(),
+  publishReady: z.boolean(),
+  publishBlockedByMissingAuth: z.boolean(),
+  statusUrl: z.string().nullable(),
+  purchaseUrl: z.string().nullable(),
+  publishUrl: z.string().nullable(),
+  verificationUrl: z.string().nullable(),
+  nextSteps: z.array(skillStatusNextStepSchema)
+}).passthrough();
+const skillInstallArtifactDescriptorSchema = z.object({
+  url: z.string(),
+  pointer: z.string().nullable(),
+  sha256: z.string().nullable()
+}).passthrough();
+const skillInstallResolverDescriptorSchema = z.object({
+  skillRef: z.string(),
+  skillMdUrl: z.string(),
+  manifestUrl: z.string()
+}).passthrough();
+const skillInstallBadgeDescriptorSchema = z.object({
+  apiUrl: z.string(),
+  imageUrl: z.string(),
+  markdown: z.string(),
+  html: z.string()
+}).passthrough();
+const skillInstallShareDescriptorSchema = z.object({
+  canonicalUrl: z.string().nullable(),
+  latestUrl: z.string().nullable(),
+  markdownLink: z.string().nullable(),
+  htmlLink: z.string().nullable(),
+  badge: skillInstallBadgeDescriptorSchema.nullable()
+}).passthrough();
+const skillInstallSnippetSetSchema = z.object({
+  cli: z.string(),
+  claude: z.string(),
+  cursor: z.string(),
+  codex: z.string(),
+  openclaw: z.string()
+}).passthrough();
+const skillInstallResponseSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  skillRef: z.string(),
+  network: z.union([z.literal("mainnet"), z.literal("testnet")]),
+  detailUrl: z.string().nullable(),
+  artifacts: z.object({
+    skillMd: skillInstallArtifactDescriptorSchema,
+    manifest: skillInstallArtifactDescriptorSchema
+  }).passthrough(),
+  resolvers: z.object({
+    pinned: skillInstallResolverDescriptorSchema,
+    latest: skillInstallResolverDescriptorSchema
+  }).passthrough(),
+  share: skillInstallShareDescriptorSchema,
+  snippets: skillInstallSnippetSetSchema
+}).passthrough();
+const skillInstallCopyTelemetryResponseSchema = z.object({
+  accepted: z.boolean()
+}).passthrough();
+const skillVerificationTierSchema = z.enum(["basic", "express"]);
+const skillVerificationStatusSchema = z.enum([
+  "pending",
+  "approved",
+  "rejected"
+]);
+const skillVerificationStatusLabelSchema = z.enum([
+  "not_requested",
+  "pending",
+  "approved",
+  "rejected"
+]);
+const skillVerificationSignalFailureReasonSchema = z.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"
+]);
+const skillVerificationPublisherBoundSignalSchema = z.object({
+  ok: z.boolean(),
+  ownerAccountId: z.string().nullable(),
+  ownerUserId: z.string().nullable(),
+  checkedAt: z.string(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+const skillVerificationRepoCommitIntegrityMismatchSchema = z.object({
+  path: z.string(),
+  expectedSha256: z.string(),
+  actualSha256: z.string().optional(),
+  error: z.string().optional()
+}).passthrough();
+const skillVerificationRepoCommitIntegritySignalSchema = z.object({
+  ok: z.boolean(),
+  repo: z.string().nullable(),
+  commit: z.string().nullable(),
+  checkedAt: z.string(),
+  filesChecked: z.number().int().min(0),
+  mismatches: z.array(skillVerificationRepoCommitIntegrityMismatchSchema),
+  partial: z.boolean().optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+const skillVerificationManifestIntegrityShaMismatchSchema = z.object({
+  path: z.string(),
+  expectedSha256: z.string(),
+  actualSha256: z.string().optional()
+}).passthrough();
+const skillVerificationManifestIntegritySignalSchema = z.object({
+  ok: z.boolean(),
+  manifestHrl: z.string().nullable(),
+  manifestSha256: z.string().nullable(),
+  checkedAt: z.string(),
+  missingFiles: z.array(z.string()),
+  shaMismatches: z.array(skillVerificationManifestIntegrityShaMismatchSchema),
+  extraFiles: z.array(z.string()).optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+const skillVerificationDomainProofSignalSchema = z.object({
+  ok: z.boolean(),
+  domain: z.string().optional(),
+  method: z.literal("dns_txt").optional(),
+  checkedAt: z.string().optional(),
+  details: z.string().optional(),
+  txtRecordName: z.string().optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+const skillVerificationSignalsSchema = z.object({
+  publisherBound: skillVerificationPublisherBoundSignalSchema,
+  repoCommitIntegrity: skillVerificationRepoCommitIntegritySignalSchema,
+  manifestIntegrity: skillVerificationManifestIntegritySignalSchema,
+  domainProof: skillVerificationDomainProofSignalSchema.optional()
+}).passthrough();
+const skillVerificationRequestSchema = z.object({
+  id: z.string(),
+  network: z.union([z.literal("mainnet"), z.literal("testnet")]),
+  name: z.string(),
+  version: z.string().optional(),
+  tier: skillVerificationTierSchema,
+  status: skillVerificationStatusSchema,
+  usdCents: z.number(),
+  creditsCharged: z.number(),
+  creditAccountId: z.string().optional(),
+  signals: skillVerificationSignalsSchema.optional(),
+  reviewNotes: z.string().optional(),
+  requestedBy: z.object({
+    userId: z.string().optional(),
+    accountId: z.string().optional(),
+    email: z.string().optional()
+  }).optional(),
+  approvedBy: z.object({
+    userId: z.string().optional(),
+    email: z.string().optional()
+  }).optional(),
+  approvedAt: z.string().optional(),
+  rejectedBy: z.object({
+    userId: z.string().optional(),
+    email: z.string().optional()
+  }).optional(),
+  rejectedAt: z.string().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+}).passthrough();
+const skillVerificationRequestCreateResponseSchema = z.object({
+  request: skillVerificationRequestSchema
+}).passthrough();
+const skillVerificationStatusResponseSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  status: skillVerificationStatusLabelSchema,
+  verified: z.boolean(),
+  previouslyVerified: z.boolean(),
+  signals: skillVerificationSignalsSchema.nullable().optional(),
+  reviewNotes: z.string().nullable().optional(),
+  pendingRequest: skillVerificationRequestSchema.nullable().optional()
+}).passthrough();
+z.object({
+  name: z.string().min(1),
+  version: z.string().min(1).optional(),
+  domain: z.string().min(1).optional()
+}).passthrough();
+const skillVerificationDomainProofChallengeResponseSchema = z.object({
+  challengeId: z.string().min(1),
+  name: z.string().min(1),
+  version: z.string().min(1),
+  domain: z.string().min(1),
+  method: z.literal("dns_txt"),
+  txtRecordName: z.string().min(1),
+  txtRecordValue: z.string().min(1),
+  expiresAt: z.string().min(1)
+}).passthrough();
+z.object({
+  name: z.string().min(1),
+  version: z.string().min(1).optional(),
+  domain: z.string().min(1).optional(),
+  challengeToken: z.string().min(1)
+}).passthrough();
+const skillVerificationDomainProofVerifyResponseSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  signal: skillVerificationDomainProofSignalSchema
+}).passthrough();
 export {
-  CustomFeeType
+  AIAgentCapability,
+  AIAgentType,
+  adapterChatProfileSchema,
+  adapterDescriptorSchema,
+  adapterDetailsResponseSchema,
+  adapterRegistryAdapterSchema,
+  adapterRegistryAdaptersResponseSchema,
+  adapterRegistryCategoriesResponseSchema,
+  adapterRegistryCategorySchema,
+  adapterRegistryCreateCategoryResponseSchema,
+  adapterRegistrySubmissionStatusResponseSchema,
+  adapterRegistrySubmitAdapterAcceptedResponseSchema,
+  adaptersResponseSchema,
+  additionalRegistryCatalogResponseSchema,
+  agentFeedbackEligibilityResponseSchema,
+  agentFeedbackEntriesIndexResponseSchema,
+  agentFeedbackIndexResponseSchema,
+  agentFeedbackResponseSchema,
+  agentFeedbackSubmissionResponseSchema,
+  chatDeliveryStateSchema,
+  chatErrorCodeSchema,
+  chatHistoryCompactionResponseSchema,
+  chatHistorySnapshotResponseSchema,
+  chatPaymentStateSchema,
+  chatReadinessResponseSchema,
+  chatReadinessStatusSchema,
+  chatReplyModeSchema,
+  chatRouteSummarySchema,
+  chatRouteTypeSchema,
+  chatSessionEndResponseSchema,
+  chatSessionResumeResponseSchema,
+  chatSessionStateSchema,
+  chatTimelineEntrySchema,
+  createSessionResponseSchema,
+  creditBalanceResponseSchema,
+  creditProviderSummarySchema,
+  creditProvidersResponseSchema,
+  creditPurchaseResponseSchema,
+  dashboardStatsResponseSchema,
+  delegationPlanResponseSchema,
+  detectProtocolResponseSchema,
+  encryptionHandshakeResponseSchema,
+  guardAbomResponseSchema,
+  guardAbomSummarySchema,
+  guardActionItemSchema,
+  guardAlertPreferencesSchema,
+  guardArtifactTimelineResponseSchema,
+  guardBalanceResponseSchema,
+  guardBucketBalanceSchema,
+  guardDeviceListResponseSchema,
+  guardDeviceSchema,
+  guardEntitlementsSchema,
+  guardExceptionItemSchema,
+  guardExceptionListResponseSchema,
+  guardExportSignatureSchema,
+  guardFeedItemSchema,
+  guardFeedResponseSchema,
+  guardFeedSummarySchema,
+  guardHistoryArtifactSchema,
+  guardIntegrationSchema,
+  guardInventoryArtifactSchema,
+  guardInventoryDiffEntrySchema,
+  guardInventoryDiffResponseSchema,
+  guardInventoryResponseSchema,
+  guardOverviewResponseSchema,
+  guardPainSignalAggregateResponseSchema,
+  guardPainSignalAggregateSchema,
+  guardPainSignalListResponseSchema,
+  guardPainSignalSchema,
+  guardPlanIdSchema,
+  guardPolicySchema,
+  guardPreflightEvidenceSchema,
+  guardPreflightVerdictResponseSchema,
+  guardPrincipalSchema,
+  guardReceiptExportResponseSchema,
+  guardReceiptExportSummarySchema,
+  guardReceiptHistoryResponseSchema,
+  guardReceiptSchema,
+  guardReceiptSyncResponseSchema,
+  guardRevocationResponseSchema,
+  guardRevocationSchema,
+  guardSessionResponseSchema,
+  guardTeamPolicyAuditItemSchema,
+  guardTeamPolicyPackSchema,
+  guardTimelineEventSchema,
+  guardTrustByHashResponseSchema,
+  guardTrustMatchSchema,
+  guardTrustResolveResponseSchema,
+  guardWatchlistItemSchema,
+  guardWatchlistLookupMatchSchema,
+  guardWatchlistLookupResponseSchema,
+  guardWatchlistResponseSchema,
+  hbarPurchaseIntentResponseSchema,
+  ledgerChallengeResponseSchema,
+  ledgerVerifyResponseSchema,
+  metricsSummaryResponseSchema,
+  moltbookOwnerRegistrationUpdateResponseSchema,
+  popularResponseSchema,
+  protocolsResponseSchema,
+  registerAgentResponseSchema,
+  registerEncryptionKeyResponseSchema,
+  registerStatusResponseSchema,
+  registrationProgressResponseSchema,
+  registrationQuoteResponseSchema,
+  registriesResponseSchema,
+  registrySearchByNamespaceSchema,
+  resolveResponseSchema,
+  searchFacetsResponseSchema,
+  searchResponseSchema,
+  searchStatusResponseSchema,
+  sendMessageResponseSchema,
+  sessionEncryptionStatusResponseSchema,
+  skillBadgeMetricSchema,
+  skillBadgeResponseSchema,
+  skillBadgeStyleSchema,
+  skillCatalogItemSchema,
+  skillCatalogResponseSchema,
+  skillCatalogVersionSummarySchema,
+  skillConversionSignalsResponseSchema,
+  skillDeprecationRecordSchema,
+  skillDeprecationsResponseSchema,
+  skillInstallArtifactDescriptorSchema,
+  skillInstallBadgeDescriptorSchema,
+  skillInstallCopyTelemetryResponseSchema,
+  skillInstallResolverDescriptorSchema,
+  skillInstallResponseSchema,
+  skillInstallShareDescriptorSchema,
+  skillInstallSnippetSetSchema,
+  skillPreviewLookupResponseSchema,
+  skillPreviewRecordSchema,
+  skillPreviewReportSchema,
+  skillPreviewSuggestedNextStepSchema,
+  skillQuotePreviewRangeSchema,
+  skillQuotePreviewResponseSchema,
+  skillRecommendedVersionResponseSchema,
+  skillRegistryCategoriesResponseSchema,
+  skillRegistryConfigResponseSchema,
+  skillRegistryFileDescriptorSchema,
+  skillRegistryJobStatusResponseSchema,
+  skillRegistryListResponseSchema,
+  skillRegistryMineItemSchema,
+  skillRegistryMineResponseSchema,
+  skillRegistryMyListResponseSchema,
+  skillRegistryOwnershipResponseSchema,
+  skillRegistryPublishResponseSchema,
+  skillRegistryPublishSummarySchema,
+  skillRegistryQuoteFileBreakdownSchema,
+  skillRegistryQuoteResponseSchema,
+  skillRegistryTagsResponseSchema,
+  skillRegistryVersionItemSchema,
+  skillRegistryVersionsResponseSchema,
+  skillRegistryVoteStatusResponseSchema,
+  skillResolverManifestResponseSchema,
+  skillSecurityBreakdownResponseSchema,
+  skillStatusChecksSchema,
+  skillStatusNextStepSchema,
+  skillStatusPreviewMetadataSchema,
+  skillStatusProvenanceSignalsSchema,
+  skillStatusResponseSchema,
+  skillStatusVerificationSignalsSchema,
+  skillTrustTierSchema,
+  skillVerificationDomainProofChallengeResponseSchema,
+  skillVerificationDomainProofVerifyResponseSchema,
+  skillVerificationRequestCreateResponseSchema,
+  skillVerificationStatusResponseSchema,
+  statsResponseSchema,
+  uaidConnectionStatusSchema,
+  uaidValidationResponseSchema,
+  vectorSearchResponseSchema,
+  verificationChallengeDetailsResponseSchema,
+  verificationChallengeResponseSchema,
+  verificationDnsStatusResponseSchema,
+  verificationOwnershipResponseSchema,
+  verificationStatusResponseSchema,
+  verificationVerifyResponseSchema,
+  verificationVerifySenderResponseSchema,
+  websocketStatsResponseSchema,
+  x402CreditPurchaseResponseSchema,
+  x402MinimumsResponseSchema
 };
 //# sourceMappingURL=standards-sdk.es157.js.map