@hashgraphonline/standards-sdk 0.1.189 → 0.1.191

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

@@ -1,454 +1,205 @@
-import { z } from "zod";
-import { RegistryBrokerParseError } from "./standards-sdk.es151.js";
-const agentNetworkProviderSchema = z.enum([
-  "openclaw",
-  "grok",
-  "dot",
-  "muse",
-  "api",
-  "other"
-]);
-const agentConnectionStateSchema = z.enum([
-  "unavailable",
-  "pending_pairing",
-  "interactive_verified",
-  "polling_verified",
-  "push_verified",
-  "needs_reconnect",
-  "paused",
-  "degraded"
-]);
-const agentRegistrationStateSchema = z.enum([
-  "unregistered",
-  "quote_issued",
-  "pending",
-  "registered",
-  "failed"
-]);
-const agentRegistrationResultStateSchema = z.enum([
-  "registered",
-  "pending",
-  "linked",
-  "unregistered"
-]);
-const agentReceiveModeSchema = z.enum(["none", "poll", "push"]);
-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.literal("hol-agent-message/1"),
-  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: agentRegistrationResultStateSchema
-});
-const agentProbeResultSchema = z.object({
-  nonce: z.string(),
-  issuedAt: isoDate
-});
-const agentSubscriptionEventTypeSchema = z.enum([
-  "notify_request",
-  "notify_event",
-  "notify_response"
-]);
-const agentSubscriptionViewSchema = z.object({
-  subscriptionId: z.string().uuid(),
-  runtimeId: z.string().uuid(),
-  eventType: agentSubscriptionEventTypeSchema,
-  callbackUrl: z.string().nullable(),
-  state: z.string(),
-  expiresAt: isoDate.nullable(),
-  createdAt: isoDate
-});
-const agentSubscriptionListSchema = z.object({
-  subscriptions: z.array(agentSubscriptionViewSchema)
-});
-const agentSubscriptionCreatedSchema = z.object({
-  subscription: agentSubscriptionViewSchema
-});
-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 }
-  );
-});
-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));
+import axios from "axios";
+import { Logger } from "./standards-sdk.es148.js";
+import { HederaMirrorNode } from "./standards-sdk.es169.js";
+import "buffer";
+import "@noble/curves/secp256k1.js";
+import "zod";
+import "./standards-sdk.es178.js";
+import "./standards-sdk.es172.js";
+import "./standards-sdk.es176.js";
+class HRLResolver {
+  constructor(logLevel = "info") {
+    this.defaultEndpoint = "https://kiloscribe.com/api/inscription-cdn";
+    this.logger = Logger.getInstance({
+      level: logLevel,
+      module: "HRLResolver"
+    });
+  }
+  /**
+   * Determines if a MIME type represents binary content
+   */
+  isBinaryContentType(mimeType) {
+    const binaryTypes = [
+      "image/",
+      "audio/",
+      "video/",
+      "application/octet-stream",
+      "application/pdf",
+      "application/zip",
+      "application/gzip",
+      "application/x-binary",
+      "application/vnd.ms-",
+      "application/x-msdownload",
+      "application/x-shockwave-flash",
+      "font/",
+      "application/wasm"
+    ];
+    return binaryTypes.some((prefix) => mimeType.startsWith(prefix));
+  }
+  /**
+   * Parses an HRL string into its components
+   */
+  parseHRL(hrl) {
+    if (!hrl) {
+      return null;
     }
+    const hrlPattern = /^hcs:\/\/(\d+)\/([0-9]+\.[0-9]+\.[0-9]+)$/;
+    const match = hrl.match(hrlPattern);
+    if (!match) {
+      return null;
+    }
+    return {
+      standard: match[1],
+      topicId: match[2]
+    };
   }
-  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 parsed = schema.safeParse(raw);
-    if (!parsed.success) {
-      throw new RegistryBrokerParseError(
-        "Unexpected agent-network response shape",
-        JSON.stringify(raw).slice(0, 500)
-      );
+  /**
+   * Validates if a string is a valid HRL
+   */
+  isValidHRL(hrl) {
+    if (!hrl || typeof hrl !== "string") {
+      return false;
     }
-    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)
-        );
+    const parsed = this.parseHRL(hrl);
+    if (!parsed) {
+      return false;
+    }
+    const topicIdPattern = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+    if (!topicIdPattern.test(parsed.topicId)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Validates if a string is a valid topic ID
+   */
+  isValidTopicId(topicId) {
+    const topicIdPattern = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+    return topicIdPattern.test(topicId);
+  }
+  /**
+   * Resolves content from either an HRL or a topic ID
+   * If a topic ID is provided, it queries the topic memo to determine the HCS standard
+   */
+  async resolve(hrlOrTopicId, options) {
+    if (this.isValidHRL(hrlOrTopicId)) {
+      return this.resolveHRL(hrlOrTopicId, options);
+    }
+    if (!this.isValidTopicId(hrlOrTopicId)) {
+      throw new Error(`Invalid HRL or topic ID format: ${hrlOrTopicId}`);
+    }
+    try {
+      const mirrorNode = new HederaMirrorNode(options.network, this.logger);
+      const topicInfo = await mirrorNode.getTopicInfo(hrlOrTopicId);
+      const memo = topicInfo?.memo || "";
+      let standard = "1";
+      if (memo) {
+        const hcsMatch = memo.match(/^hcs-(\d+)/);
+        if (hcsMatch && hcsMatch[1]) {
+          standard = hcsMatch[1];
+        }
       }
-      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"
-      });
-    },
-    listRuntimeInbox: (runtimeId, query) => json(
-      `/agent-runtimes/${encodePath(runtimeId)}/inbox${qs({
-        cursor: query?.cursor,
-        limit: query?.limit,
-        includeAcknowledged: query?.includeAcknowledged
-      })}`,
-      agentInboxListSchema,
-      {}
-    ),
-    getRuntimeConversation: (runtimeId, conversationId, query) => json(
-      `/agent-runtimes/${encodePath(runtimeId)}/conversations/${encodePath(
-        conversationId
-      )}${qs({ cursor: query?.cursor, limit: query?.limit })}`,
-      agentConversationViewSchema,
-      {}
-    ),
-    createAgentSubscription: async (runtimeId, input) => (await json(
-      `/agent-runtimes/${encodePath(runtimeId)}/subscriptions`,
-      agentSubscriptionCreatedSchema,
-      { method: "POST", body: input }
-    )).subscription,
-    listAgentSubscriptions: async (runtimeId) => (await json(
-      `/agent-runtimes/${encodePath(runtimeId)}/subscriptions`,
-      agentSubscriptionListSchema,
-      {}
-    )).subscriptions,
-    revokeAgentSubscription: async (runtimeId, subscriptionId) => {
-      await client.request(
-        `/agent-runtimes/${encodePath(runtimeId)}/subscriptions/${encodePath(
-          subscriptionId
-        )}`,
-        { method: "DELETE" }
-      );
-    },
-    agentMe: async (token) => {
-      const raw = await client.requestJson(
-        "/agent-runtimes/me",
-        { headers: bearerHeaders(token) }
+      const hrl = `hcs://${standard}/${hrlOrTopicId}`;
+      return this.resolveHRL(hrl, options);
+    } catch (error) {
+      this.logger.error(
+        `Failed to get topic info for ${hrlOrTopicId}: ${error.message}`
       );
-      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 hrl = `hcs://1/${hrlOrTopicId}`;
+      return this.resolveHRL(hrl, options);
+    }
+  }
+  async getContentWithType(hrl, options) {
+    if (!this.isValidHRL(hrl)) {
+      return {
+        content: hrl,
+        contentType: "text/plain",
+        isBinary: false
+      };
+    }
+    try {
+      const result = await this.resolveHRL(hrl, options);
+      return {
+        content: result.content,
+        contentType: result.contentType,
+        isBinary: result.isBinary
+      };
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error resolving HRL for content and type: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
+  /**
+   * Resolves HRL content with proper content type detection
+   */
+  async resolveHRL(hrl, options) {
+    const parsed = this.parseHRL(hrl);
+    if (!parsed) {
+      throw new Error(`Invalid HRL format: ${hrl}`);
+    }
+    const { standard, topicId } = parsed;
+    this.logger.debug(
+      `Resolving HRL reference: standard=${standard}, topicId=${topicId}`
+    );
+    try {
+      const cdnEndpoint = options.cdnEndpoint || this.defaultEndpoint;
+      const cdnUrl = `${cdnEndpoint}/${topicId}?network=${options.network}`;
+      this.logger.debug(`Fetching content from CDN: ${cdnUrl}`);
+      const headResponse = await axios.head(cdnUrl);
+      const contentType = headResponse.headers["content-type"] || "";
+      const isBinary = this.isBinaryContentType(contentType);
+      if (isBinary || options.returnRaw) {
+        const response2 = await axios.get(cdnUrl, {
+          responseType: "arraybuffer"
+        });
+        return {
+          content: response2.data,
+          contentType,
+          topicId,
+          isBinary: true
+        };
       }
-      const parsed = agentClaimedMessageSchema.safeParse(raw);
-      if (!parsed.success) {
-        throw new RegistryBrokerParseError(
-          "Unexpected claim response shape",
-          JSON.stringify(raw).slice(0, 500)
-        );
+      if (contentType === "application/json") {
+        const response2 = await axios.get(cdnUrl, {
+          responseType: "json"
+        });
+        if (!response2.data) {
+          throw new Error(`Failed to fetch content from topic: ${topicId}`);
+        }
+        return {
+          content: response2.data,
+          contentType,
+          topicId,
+          isBinary: false
+        };
       }
-      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)
-        );
+      const response = await axios.get(cdnUrl);
+      if (!response.data) {
+        throw new Error(`Failed to fetch content from topic: ${topicId}`);
       }
-      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;
-        }
-        await sleep(Math.min(interval, deadline - Date.now()), options?.signal);
+      let content;
+      if (typeof response.data === "object") {
+        content = response.data.content || response.data.text || JSON.stringify(response.data);
+      } else {
+        content = response.data;
       }
-      return null;
+      return {
+        content,
+        contentType,
+        topicId,
+        isBinary: false
+      };
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error resolving HRL reference: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
     }
-  };
+  }
 }
 export {
-  agentClaimedMessageSchema,
-  agentConnectionStateSchema,
-  agentConversationViewSchema,
-  agentDeliveryStateSchema,
-  agentInboxItemSchema,
-  agentInboxListSchema,
-  agentLeaseViewSchema,
-  agentMessageAcceptedSchema,
-  agentMessageKindSchema,
-  agentMessageViewSchema,
-  agentNetworkProviderSchema,
-  agentPairingCompleteSchema,
-  agentPairingStartSchema,
-  agentProbeResultSchema,
-  agentReceiveModeSchema,
-  agentRegistrationResultStateSchema,
-  agentRegistrationStateSchema,
-  agentReplyResultSchema,
-  agentRequestStateSchema,
-  agentRuntimeQuoteSchema,
-  agentRuntimeRegistrationResultSchema,
-  agentRuntimeViewSchema,
-  agentSubscriptionCreatedSchema,
-  agentSubscriptionEventTypeSchema,
-  agentSubscriptionListSchema,
-  agentSubscriptionViewSchema,
-  createAgentNetworkApi
+  HRLResolver
 };
 //# sourceMappingURL=standards-sdk.es152.js.map