@hashgraphonline/standards-sdk 0.1.187 → 0.1.188

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

@@ -1,262 +1,386 @@
-import { dashboardStatsResponseSchema, registrationProgressResponseSchema, registrationQuoteResponseSchema, uaidConnectionStatusSchema, resolveResponseSchema, registerAgentResponseSchema, uaidValidationResponseSchema } from "./standards-sdk.es157.js";
-import { purchaseCreditsWithHbar } from "./standards-sdk.es204.js";
-import { serialiseAgentRegistrationRequest, DEFAULT_PROGRESS_INTERVAL_MS, DEFAULT_PROGRESS_TIMEOUT_MS, createAbortError, MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS } from "./standards-sdk.es208.js";
-import { RegistryBrokerError } from "./standards-sdk.es151.js";
-async function performRegisterAgent(client, payload) {
-  const raw = await client.requestJson("/register", {
-    method: "POST",
-    body: serialiseAgentRegistrationRequest(payload),
-    headers: { "content-type": "application/json" }
-  });
-  return client.parseWithSchema(
-    raw,
-    registerAgentResponseSchema,
-    "register agent response"
+import { z } from "zod";
+import { RegistryBrokerParseError } from "./standards-sdk.es151.js";
+const agentNetworkProviderSchema = z.enum([
+  "openclaw",
+  "dot",
+  "grok",
+  "muse",
+  "generic"
+]);
+const agentConnectionStateSchema = z.enum([
+  "unavailable",
+  "pending_pairing",
+  "interactive_verified",
+  "receive_unverified",
+  "receive_verified",
+  "paused",
+  "revoked",
+  "needs_reconnect"
+]);
+const agentRegistrationStateSchema = z.enum([
+  "unregistered",
+  "pending",
+  "registered",
+  "linked",
+  "failed"
+]);
+const agentReceiveModeSchema = z.enum(["none", "poll", "push", "events"]);
+const agentRequestStateSchema = z.enum([
+  "accepted",
+  "awaiting_consent",
+  "queued",
+  "processing",
+  "completed",
+  "rejected",
+  "failed",
+  "expired",
+  "canceled"
+]);
+const agentDeliveryStateSchema = z.enum([
+  "pending",
+  "notifying",
+  "provider_accepted",
+  "acknowledged",
+  "retry_scheduled",
+  "permanently_failed"
+]);
+const agentMessageKindSchema = z.enum(["request", "response", "event"]);
+const isoDate = z.string();
+const agentRuntimeViewSchema = z.object({
+  runtimeId: z.string().uuid(),
+  uaid: z.string().nullable(),
+  ownerType: z.string(),
+  ownerId: z.string(),
+  declaredProvider: agentNetworkProviderSchema,
+  connectionState: agentConnectionStateSchema,
+  registrationState: agentRegistrationStateSchema,
+  registrationAttemptId: z.string().nullable(),
+  receiveMode: agentReceiveModeSchema,
+  gatewayUrl: z.string().nullable(),
+  paused: z.boolean(),
+  allowedPeerUaids: z.array(z.string()).nullable(),
+  capabilities: z.array(z.string()),
+  lastActivityAt: isoDate.nullable(),
+  createdAt: isoDate
+});
+const agentRuntimeQuoteSchema = z.object({
+  quoteId: z.string(),
+  expiresAt: isoDate,
+  registrationFeeCredits: z.number().nullable(),
+  gatewayUrl: z.string()
+});
+const agentPairingStartSchema = z.object({
+  grantId: z.string().uuid(),
+  pairingCode: z.string(),
+  expiresAt: isoDate
+});
+const agentPairingCompleteSchema = z.object({
+  grantId: z.string().uuid(),
+  runtimeId: z.string().uuid(),
+  token: z.string(),
+  scopes: z.array(z.string())
+});
+const agentMessageViewSchema = z.object({
+  messageId: z.string().uuid(),
+  conversationId: z.string().uuid(),
+  schemaVersion: z.number().optional(),
+  kind: agentMessageKindSchema,
+  senderUaid: z.string(),
+  recipientUaid: z.string(),
+  inReplyTo: z.string().uuid().nullable(),
+  content: z.object({ type: z.literal("text"), text: z.string() }),
+  requestState: agentRequestStateSchema,
+  createdAt: isoDate,
+  expiresAt: isoDate,
+  traceId: z.string()
+});
+const agentMessageAcceptedSchema = z.object({
+  messageId: z.string().uuid(),
+  conversationId: z.string().uuid(),
+  requestState: agentRequestStateSchema,
+  createdAt: isoDate,
+  expiresAt: isoDate,
+  deduplicated: z.boolean()
+});
+const agentLeaseViewSchema = z.object({
+  leaseId: z.string().uuid(),
+  messageId: z.string().uuid(),
+  fencingToken: z.number().int(),
+  expiresAt: isoDate
+});
+const agentClaimedMessageSchema = z.object({
+  message: agentMessageViewSchema,
+  lease: agentLeaseViewSchema
+});
+const agentInboxItemSchema = z.object({
+  messageId: z.string().uuid(),
+  conversationId: z.string().uuid(),
+  kind: agentMessageKindSchema,
+  senderUaid: z.string(),
+  content: z.object({ type: z.literal("text"), text: z.string() }),
+  requestState: agentRequestStateSchema,
+  deliveryState: agentDeliveryStateSchema,
+  acknowledged: z.boolean(),
+  leaseId: z.string().uuid().nullable(),
+  fencingToken: z.number().int().nullable(),
+  createdAt: isoDate,
+  expiresAt: isoDate
+});
+const agentInboxListSchema = z.object({
+  items: z.array(agentInboxItemSchema),
+  nextCursor: z.string().nullable()
+});
+const agentConversationViewSchema = z.object({
+  conversationId: z.string().uuid(),
+  state: z.enum(["active", "canceled", "expired"]),
+  participants: z.array(z.object({ uaid: z.string() })),
+  messages: z.array(agentMessageViewSchema),
+  nextCursor: z.string().nullable()
+});
+const agentReplyResultSchema = z.object({
+  request: agentMessageViewSchema,
+  response: agentMessageViewSchema
+});
+const agentRuntimeRegistrationResultSchema = z.object({
+  runtime: agentRuntimeViewSchema,
+  registration: agentRegistrationStateSchema
+});
+const agentProbeResultSchema = z.object({
+  nonce: z.string(),
+  issuedAt: isoDate
+});
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+  const t = setTimeout(resolve, ms);
+  signal?.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(t);
+      reject(new Error("waitForReply aborted"));
+    },
+    { once: true }
   );
-}
-function calculateHbarAmount(creditsToPurchase, creditsPerHbar) {
-  if (creditsPerHbar <= 0) {
-    throw new Error("creditsPerHbar must be positive");
-  }
-  if (creditsToPurchase <= 0) {
-    throw new Error("creditsToPurchase must be positive");
-  }
-  const rawHbar = creditsToPurchase / creditsPerHbar;
-  const tinybars = Math.ceil(rawHbar * 1e8);
-  return tinybars / 1e8;
-}
-function resolveCreditsToPurchase(shortfallCredits) {
-  if (!Number.isFinite(shortfallCredits) || shortfallCredits <= 0) {
-    return 0;
-  }
-  return Math.max(
-    Math.ceil(shortfallCredits),
-    MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS
-  );
-}
-async function ensureCreditsForRegistration(client, payload, autoTopUp) {
-  const details = autoTopUp ?? null;
-  if (!details) {
-    return;
-  }
-  if (!details.accountId || !details.accountId.trim()) {
-    throw new Error("autoTopUp.accountId is required");
+});
+const bearerHeaders = (token) => ({
+  authorization: `Bearer ${token}`
+});
+const encodePath = (value) => encodeURIComponent(value);
+const qs = (params) => {
+  const query = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) query.set(k, String(v));
   }
-  if (!details.privateKey || !details.privateKey.trim()) {
-    throw new Error("autoTopUp.privateKey is required");
-  }
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    const quote = await getRegistrationQuote(client, payload);
-    const shortfall = quote.shortfallCredits ?? 0;
-    if (shortfall <= 0) {
-      return;
-    }
-    const creditsToPurchase = resolveCreditsToPurchase(shortfall);
-    if (creditsToPurchase <= 0) {
-      return;
-    }
-    const creditsPerHbar = quote.creditsPerHbar ?? null;
-    if (!creditsPerHbar || creditsPerHbar <= 0) {
-      throw new Error("Unable to determine credits per HBAR for auto top-up");
-    }
-    const hbarAmount = calculateHbarAmount(creditsToPurchase, creditsPerHbar);
-    await purchaseCreditsWithHbar(client, {
-      accountId: details.accountId.trim(),
-      privateKey: details.privateKey.trim(),
-      hbarAmount,
-      memo: details.memo ?? "Registry Broker auto top-up",
-      metadata: {
-        shortfallCredits: shortfall,
-        requiredCredits: quote.requiredCredits,
-        purchasedCredits: creditsToPurchase
-      }
+  const s = query.toString();
+  return s ? `?${s}` : "";
+};
+function createAgentNetworkApi(client) {
+  const json = async (path, schema, init) => {
+    const raw = await client.requestJson(`${path}`, {
+      method: init.method ?? "GET",
+      body: init.body,
+      headers: init.token ? bearerHeaders(init.token) : void 0
     });
-  }
-  const finalQuote = await getRegistrationQuote(client, payload);
-  if ((finalQuote.shortfallCredits ?? 0) > 0) {
-    throw new Error("Unable to purchase sufficient credits for registration");
-  }
-}
-async function resolveUaid(client, uaid) {
-  const raw = await client.requestJson(
-    `/resolve/${encodeURIComponent(uaid)}`,
-    {
-      method: "GET"
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success) {
+      throw new RegistryBrokerParseError(
+        "Unexpected agent-network response shape",
+        JSON.stringify(raw).slice(0, 500)
+      );
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    resolveResponseSchema,
-    "resolve UAID response"
-  );
-}
-async function registerAgent(client, payload, options) {
-  const autoTopUp = options?.autoTopUp ?? client.registrationAutoTopUp;
-  if (!autoTopUp) {
-    return performRegisterAgent(client, payload);
-  }
-  await ensureCreditsForRegistration(client, payload, autoTopUp);
-  let retried = false;
-  while (true) {
-    try {
-      return await performRegisterAgent(client, payload);
-    } catch (error) {
-      const shortfall = client.extractInsufficientCreditsDetails(error);
-      if (shortfall && !retried) {
-        await ensureCreditsForRegistration(client, payload, autoTopUp);
-        retried = true;
-        continue;
+    return parsed.data;
+  };
+  const bot204 = async (path, token, body) => {
+    const response = await client.request(`${path}`, {
+      method: "POST",
+      body,
+      headers: bearerHeaders(token)
+    });
+    return response.status === 204 ? null : response.json();
+  };
+  return {
+    quoteRuntime: () => json("/agent-runtimes/quote", agentRuntimeQuoteSchema, {
+      method: "POST"
+    }),
+    registerRuntime: (input) => json("/agent-runtimes/register", agentRuntimeRegistrationResultSchema, {
+      method: "POST",
+      body: input
+    }),
+    listRuntimes: async () => {
+      const raw = await client.requestJson("/agent-runtimes", {});
+      const parsed = z.object({ runtimes: z.array(agentRuntimeViewSchema) }).safeParse(raw);
+      if (!parsed.success) {
+        throw new RegistryBrokerParseError(
+          "Unexpected runtime list shape",
+          JSON.stringify(raw).slice(0, 500)
+        );
       }
-      throw error;
-    }
-  }
-}
-async function getRegistrationQuote(client, payload) {
-  const raw = await client.requestJson("/register/quote", {
-    method: "POST",
-    body: serialiseAgentRegistrationRequest(payload),
-    headers: { "content-type": "application/json" }
-  });
-  return client.parseWithSchema(
-    raw,
-    registrationQuoteResponseSchema,
-    "registration quote response"
-  );
-}
-async function updateAgent(client, uaid, payload) {
-  const raw = await client.requestJson(
-    `/register/${encodeURIComponent(uaid)}`,
-    {
-      method: "PUT",
-      body: serialiseAgentRegistrationRequest(payload),
-      headers: { "content-type": "application/json" }
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    registerAgentResponseSchema,
-    "update agent response"
-  );
-}
-async function getRegistrationProgress(client, attemptId) {
-  const normalisedAttemptId = attemptId.trim();
-  if (!normalisedAttemptId) {
-    throw new Error("attemptId is required");
-  }
-  try {
-    const raw = await client.requestJson(
-      `/register/progress/${encodeURIComponent(normalisedAttemptId)}`,
-      { method: "GET" }
-    );
-    const parsed = client.parseWithSchema(
-      raw,
-      registrationProgressResponseSchema,
-      "registration progress response"
-    );
-    return parsed.progress;
-  } catch (error) {
-    if (error instanceof RegistryBrokerError && error.status === 404) {
-      return null;
-    }
-    throw error;
-  }
-}
-async function waitForRegistrationCompletion(client, attemptId, options = {}) {
-  const normalisedAttemptId = attemptId.trim();
-  if (!normalisedAttemptId) {
-    throw new Error("attemptId is required");
-  }
-  const interval = Math.max(
-    250,
-    options.intervalMs ?? DEFAULT_PROGRESS_INTERVAL_MS
-  );
-  const timeoutMs = options.timeoutMs ?? DEFAULT_PROGRESS_TIMEOUT_MS;
-  const throwOnFailure = options.throwOnFailure ?? true;
-  const signal = options.signal;
-  const startedAt = Date.now();
-  while (true) {
-    if (signal?.aborted) {
-      throw createAbortError();
-    }
-    const progress = await client.getRegistrationProgress(normalisedAttemptId);
-    if (progress) {
-      options.onProgress?.(progress);
-      if (progress.status === "completed") {
-        return progress;
+      return parsed.data.runtimes;
+    },
+    updateRuntimePolicy: (runtimeId, input) => json(
+      `/agent-runtimes/${encodePath(runtimeId)}`,
+      agentRuntimeViewSchema,
+      { method: "PATCH", body: input }
+    ),
+    probeRuntime: async (runtimeId) => await json(
+      `/agent-runtimes/${encodePath(runtimeId)}/probe`,
+      agentProbeResultSchema,
+      { method: "POST" }
+    ),
+    startAgentConnection: (runtimeId) => json("/agent-connections", agentPairingStartSchema, {
+      method: "POST",
+      body: { runtimeId }
+    }),
+    completeAgentPairing: (pairingCode) => json("/agent-connections/pair", agentPairingCompleteSchema, {
+      method: "POST",
+      body: { pairingCode }
+    }),
+    revokeAgentConnection: async (grantId) => {
+      await client.request(`/agent-connections/${encodePath(grantId)}`, {
+        method: "DELETE"
+      });
+    },
+    agentMe: async (token) => {
+      const raw = await client.requestJson(
+        "/agent-runtimes/me",
+        { headers: bearerHeaders(token) }
+      );
+      const parsed = z.object({ runtime: agentRuntimeViewSchema }).safeParse(raw);
+      if (!parsed.success) {
+        throw new RegistryBrokerParseError(
+          "Unexpected agent-runtimes/me shape",
+          JSON.stringify(raw).slice(0, 500)
+        );
+      }
+      return parsed.data.runtime;
+    },
+    sendAgentMessage: (token, input) => json("/agent-messages", agentMessageAcceptedSchema, {
+      method: "POST",
+      body: input,
+      token
+    }),
+    getAgentMessage: (token, messageId) => json(
+      `/agent-messages/${encodePath(messageId)}`,
+      agentMessageViewSchema,
+      { token }
+    ),
+    getAgentConversation: (token, conversationId, query) => json(
+      `/agent-conversations/${encodePath(conversationId)}${qs({
+        cursor: query?.cursor,
+        limit: query?.limit
+      })}`,
+      agentConversationViewSchema,
+      { token }
+    ),
+    listAgentInbox: (token, query) => json(
+      `/agent-inbox${qs({
+        cursor: query?.cursor,
+        limit: query?.limit,
+        includeAcknowledged: query?.includeAcknowledged
+      })}`,
+      agentInboxListSchema,
+      { token }
+    ),
+    claimAgentMessage: async (token) => {
+      const raw = await bot204("/agent-inbox/leases", token, {});
+      if (raw === null) {
+        return null;
+      }
+      const parsed = agentClaimedMessageSchema.safeParse(raw);
+      if (!parsed.success) {
+        throw new RegistryBrokerParseError(
+          "Unexpected claim response shape",
+          JSON.stringify(raw).slice(0, 500)
+        );
       }
-      if (progress.status === "partial" || progress.status === "failed") {
-        if (throwOnFailure) {
-          throw new RegistryBrokerError(
-            "Registration did not complete successfully",
-            {
-              status: 409,
-              statusText: progress.status,
-              body: progress
-            }
+      return parsed.data;
+    },
+    acknowledgeAgentMessage: (token, messageId, lease) => json(
+      `/agent-inbox/${encodePath(messageId)}/ack`,
+      agentMessageViewSchema,
+      { method: "POST", body: lease, token }
+    ),
+    renewAgentMessageLease: (token, messageId, input) => json(
+      `/agent-inbox/${encodePath(messageId)}/lease/renew`,
+      agentLeaseViewSchema,
+      { method: "POST", body: input, token }
+    ),
+    replyToAgentMessage: (token, messageId, input) => json(
+      `/agent-messages/${encodePath(messageId)}/reply`,
+      agentReplyResultSchema,
+      { method: "POST", body: input, token }
+    ),
+    rejectAgentMessage: (token, messageId, input) => json(
+      `/agent-messages/${encodePath(messageId)}/reject`,
+      agentMessageViewSchema,
+      { method: "POST", body: input, token }
+    ),
+    cancelAgentConversation: async (token, conversationId) => {
+      const raw = await client.requestJson(
+        `/agent-conversations/${encodePath(conversationId)}/cancel`,
+        { method: "POST", body: {}, headers: bearerHeaders(token) }
+      );
+      const parsed = z.object({
+        conversationId: z.string().uuid(),
+        canceledMessages: z.number()
+      }).safeParse(raw);
+      if (!parsed.success) {
+        throw new RegistryBrokerParseError(
+          "Unexpected cancel response shape",
+          JSON.stringify(raw).slice(0, 500)
+        );
+      }
+      return parsed.data;
+    },
+    waitForAgentReply: async (token, messageId, options) => {
+      const timeoutMs = options?.timeoutMs ?? 6e4;
+      const interval = Math.max(250, options?.pollIntervalMs ?? 2e3);
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const message = await json(
+          `/agent-messages/${encodePath(messageId)}`,
+          agentMessageViewSchema,
+          { token }
+        );
+        if (message.requestState === "completed") {
+          const conversation = await json(
+            `/agent-conversations/${encodePath(message.conversationId)}`,
+            agentConversationViewSchema,
+            { token }
           );
+          return conversation.messages.find(
+            (m) => m.inReplyTo === messageId && m.kind === "response"
+          ) ?? null;
+        }
+        if (message.requestState === "rejected" || message.requestState === "failed" || message.requestState === "expired" || message.requestState === "canceled") {
+          return null;
         }
-        return progress;
+        await sleep(Math.min(interval, deadline - Date.now()), options?.signal);
       }
+      return null;
     }
-    if (Date.now() - startedAt >= timeoutMs) {
-      throw new Error(
-        `Registration progress polling timed out after ${timeoutMs}ms`
-      );
-    }
-    await client.delay(interval, signal);
-  }
-}
-async function validateUaid(client, uaid) {
-  const raw = await client.requestJson(
-    `/uaids/validate/${encodeURIComponent(uaid)}`,
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    uaidValidationResponseSchema,
-    "UAID validation response"
-  );
-}
-async function getUaidConnectionStatus(client, uaid) {
-  const raw = await client.requestJson(
-    `/uaids/connections/${encodeURIComponent(uaid)}/status`,
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    uaidConnectionStatusSchema,
-    "UAID connection status"
-  );
-}
-async function closeUaidConnection(client, uaid) {
-  await client.request(`/uaids/connections/${encodeURIComponent(uaid)}`, {
-    method: "DELETE"
-  });
-}
-async function dashboardStats(client) {
-  const raw = await client.requestJson("/dashboard/stats", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    dashboardStatsResponseSchema,
-    "dashboard stats response"
-  );
+  };
 }
 export {
-  closeUaidConnection,
-  dashboardStats,
-  getRegistrationProgress,
-  getRegistrationQuote,
-  getUaidConnectionStatus,
-  registerAgent,
-  resolveUaid,
-  updateAgent,
-  validateUaid,
-  waitForRegistrationCompletion
+  agentClaimedMessageSchema,
+  agentConnectionStateSchema,
+  agentConversationViewSchema,
+  agentDeliveryStateSchema,
+  agentInboxItemSchema,
+  agentInboxListSchema,
+  agentLeaseViewSchema,
+  agentMessageAcceptedSchema,
+  agentMessageKindSchema,
+  agentMessageViewSchema,
+  agentNetworkProviderSchema,
+  agentPairingCompleteSchema,
+  agentPairingStartSchema,
+  agentProbeResultSchema,
+  agentReceiveModeSchema,
+  agentRegistrationStateSchema,
+  agentReplyResultSchema,
+  agentRequestStateSchema,
+  agentRuntimeQuoteSchema,
+  agentRuntimeRegistrationResultSchema,
+  agentRuntimeViewSchema,
+  createAgentNetworkApi
 };
 //# sourceMappingURL=standards-sdk.es152.js.map