@hashgraphonline/standards-sdk 0.1.184 → 0.1.185

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

@@ -1,122 +1,520 @@
-import { adaptersResponseSchema, adapterDetailsResponseSchema, adapterRegistryCategoriesResponseSchema, adapterRegistryAdaptersResponseSchema, adapterRegistryCreateCategoryResponseSchema, adapterRegistrySubmitAdapterAcceptedResponseSchema, adapterRegistrySubmissionStatusResponseSchema } from "./standards-sdk.es152.js";
-import { toJsonObject } from "./standards-sdk.es186.js";
-async function adapters(client) {
-  const raw = await client.requestJson("/adapters", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    adaptersResponseSchema,
-    "adapters response"
-  );
+import { createSessionResponseSchema, chatSessionResumeResponseSchema, chatReadinessResponseSchema, chatHistoryCompactionResponseSchema, sessionEncryptionStatusResponseSchema, encryptionHandshakeResponseSchema, sendMessageResponseSchema, chatSessionEndResponseSchema } from "./standards-sdk.es155.js";
+import { serialiseAuthConfig, toJsonObject } from "./standards-sdk.es189.js";
+import { EncryptionUnavailableError } from "./standards-sdk.es181.js";
+function createChatApi(client, encryptedManager) {
+  return {
+    start: (options) => client.startChat(options),
+    readiness: (payload) => client.checkChatReadiness(payload),
+    createSession: (payload) => client.createSession(payload),
+    resumeSession: (sessionId) => client.resumeSession(sessionId),
+    sendMessage: (payload) => client.sendMessage(payload),
+    retryMessage: (messageId, payload) => client.retryMessage(messageId, payload),
+    cancelSession: (sessionId) => client.cancelSession(sessionId),
+    endSession: (sessionId) => client.endSession(sessionId),
+    getHistory: (sessionId, options) => client.fetchHistorySnapshot(sessionId, options),
+    compactHistory: (payload) => client.compactHistory(payload),
+    getEncryptionStatus: (sessionId) => client.fetchEncryptionStatus(sessionId),
+    submitEncryptionHandshake: (sessionId, payload) => client.postEncryptionHandshake(sessionId, payload),
+    startConversation: (options) => client.startConversation(options),
+    acceptConversation: (options) => client.acceptConversation(options),
+    createEncryptedSession: (options) => encryptedManager.startSession(options),
+    acceptEncryptedSession: (options) => encryptedManager.acceptSession(options)
+  };
 }
-async function adaptersDetailed(client) {
-  const raw = await client.requestJson("/adapters/details", {
-    method: "GET"
+async function checkChatReadiness(client, payload) {
+  const body = {};
+  const uaid = "uaid" in payload ? payload.uaid?.trim() : void 0;
+  const agentUrl = "agentUrl" in payload ? payload.agentUrl?.trim() : void 0;
+  if (!uaid && !agentUrl) {
+    throw new Error("uaid or agentUrl is required to check chat readiness");
+  }
+  if (uaid) {
+    body.uaid = uaid;
+  }
+  if (agentUrl) {
+    body.agentUrl = agentUrl;
+  }
+  if (payload.forceRefresh !== void 0) {
+    body.forceRefresh = payload.forceRefresh;
+  }
+  const raw = await client.requestJson("/chat/readiness", {
+    method: "POST",
+    body,
+    headers: { "content-type": "application/json" }
   });
   return client.parseWithSchema(
     raw,
-    adapterDetailsResponseSchema,
-    "adapter details response"
+    chatReadinessResponseSchema,
+    "chat readiness response"
   );
 }
-async function adapterRegistryCategories(client) {
-  const raw = await client.requestJson(
-    "/adapters/registry/categories",
-    {
-      method: "GET"
+async function createSession(client, payload, allowHistoryAutoTopUp = true) {
+  const body = {};
+  if ("uaid" in payload && payload.uaid) {
+    body.uaid = payload.uaid;
+  }
+  if ("agentUrl" in payload && payload.agentUrl) {
+    body.agentUrl = payload.agentUrl;
+  }
+  if (payload.auth) {
+    body.auth = serialiseAuthConfig(payload.auth);
+  }
+  if (payload.historyTtlSeconds !== void 0) {
+    body.historyTtlSeconds = payload.historyTtlSeconds;
+  }
+  if (payload.encryptionRequested !== void 0) {
+    body.encryptionRequested = payload.encryptionRequested;
+  }
+  if (payload.senderUaid) {
+    body.senderUaid = payload.senderUaid;
+  }
+  if (payload.visibility) {
+    body.visibility = payload.visibility;
+  }
+  if (payload.idempotencyKey) {
+    body.idempotencyKey = payload.idempotencyKey;
+  }
+  try {
+    const raw = await client.requestJson("/chat/session", {
+      method: "POST",
+      body,
+      headers: { "content-type": "application/json" }
+    });
+    return client.parseWithSchema(
+      raw,
+      createSessionResponseSchema,
+      "chat session response"
+    );
+  } catch (error) {
+    const maybeError = error instanceof Error ? error : null;
+    if (allowHistoryAutoTopUp && client.shouldAutoTopUpHistory(payload, maybeError)) {
+      await client.executeHistoryAutoTopUp("chat.session");
+      return createSession(client, payload, false);
     }
+    throw error;
+  }
+}
+async function resumeSession(client, sessionId) {
+  const normalized = sessionId.trim();
+  if (!normalized) {
+    throw new Error("sessionId is required to resume a chat session");
+  }
+  const raw = await client.requestJson(
+    `/chat/session/${encodeURIComponent(normalized)}/resume`,
+    { method: "GET" }
   );
   return client.parseWithSchema(
     raw,
-    adapterRegistryCategoriesResponseSchema,
-    "adapter registry categories response"
+    chatSessionResumeResponseSchema,
+    "chat session resume response"
   );
 }
-async function adapterRegistryAdapters(client, filters = {}) {
-  const params = new URLSearchParams();
-  if (filters.category) {
-    params.set("category", filters.category);
+async function startChat(client, encryptedManager, options) {
+  if ("uaid" in options && options.uaid) {
+    return startConversation(client, encryptedManager, {
+      uaid: options.uaid,
+      senderUaid: options.senderUaid,
+      historyTtlSeconds: options.historyTtlSeconds,
+      auth: options.auth,
+      encryption: options.encryption,
+      onSessionCreated: options.onSessionCreated
+    });
+  }
+  if ("agentUrl" in options && options.agentUrl) {
+    const session = await createSession(client, {
+      agentUrl: options.agentUrl,
+      auth: options.auth,
+      historyTtlSeconds: options.historyTtlSeconds,
+      senderUaid: options.senderUaid
+    });
+    options.onSessionCreated?.(session.sessionId);
+    return createPlaintextConversationHandle(
+      client,
+      session.sessionId,
+      session.encryption ?? null,
+      options.auth,
+      { agentUrl: options.agentUrl, uaid: options.uaid }
+    );
+  }
+  throw new Error("startChat requires either uaid or agentUrl");
+}
+async function startConversation(client, encryptedManager, options) {
+  const preference = options.encryption?.preference ?? "preferred";
+  const requestEncryption = preference !== "disabled";
+  if (!requestEncryption) {
+    const session = await createSession(client, {
+      uaid: options.uaid,
+      auth: options.auth,
+      historyTtlSeconds: options.historyTtlSeconds,
+      senderUaid: options.senderUaid,
+      encryptionRequested: false
+    });
+    options.onSessionCreated?.(session.sessionId);
+    return createPlaintextConversationHandle(
+      client,
+      session.sessionId,
+      session.encryption ?? null,
+      options.auth,
+      { uaid: options.uaid }
+    );
   }
-  if (filters.entity) {
-    params.set("entity", filters.entity);
+  try {
+    const handle = await encryptedManager.startSession({
+      uaid: options.uaid,
+      senderUaid: options.senderUaid,
+      historyTtlSeconds: options.historyTtlSeconds,
+      handshakeTimeoutMs: options.encryption?.handshakeTimeoutMs,
+      pollIntervalMs: options.encryption?.pollIntervalMs,
+      onSessionCreated: (sessionId) => {
+        options.onSessionCreated?.(sessionId);
+      },
+      auth: options.auth
+    });
+    return handle;
+  } catch (error) {
+    if (error instanceof EncryptionUnavailableError) {
+      if (preference === "required") {
+        throw error;
+      }
+      return createPlaintextConversationHandle(
+        client,
+        error.sessionId,
+        error.summary ?? null,
+        options.auth,
+        { uaid: options.uaid }
+      );
+    }
+    throw error;
   }
-  if (filters.keywords?.length) {
-    params.set("keywords", filters.keywords.join(","));
+}
+async function acceptConversation(client, encryptedManager, options) {
+  const preference = options.encryption?.preference ?? "preferred";
+  if (preference === "disabled") {
+    return createPlaintextConversationHandle(client, options.sessionId, null);
   }
-  if (filters.query) {
-    params.set("query", filters.query);
+  try {
+    const handle = await encryptedManager.acceptSession({
+      sessionId: options.sessionId,
+      responderUaid: options.responderUaid,
+      handshakeTimeoutMs: options.encryption?.handshakeTimeoutMs,
+      pollIntervalMs: options.encryption?.pollIntervalMs
+    });
+    return handle;
+  } catch (error) {
+    if (error instanceof EncryptionUnavailableError && preference !== "required") {
+      return createPlaintextConversationHandle(
+        client,
+        options.sessionId,
+        null,
+        void 0,
+        { uaid: options.responderUaid }
+      );
+    }
+    throw error;
+  }
+}
+function createPlaintextConversationHandle(client, sessionId, summary, defaultAuth, context) {
+  const uaid = context?.uaid?.trim();
+  const agentUrl = context?.agentUrl?.trim();
+  const fetchHistory = async (options) => {
+    const snapshot = await client.fetchHistorySnapshot(sessionId, options);
+    if (snapshot.decryptedHistory) {
+      return snapshot.decryptedHistory;
+    }
+    return snapshot.history.map((entry) => ({
+      entry,
+      plaintext: entry.content
+    }));
+  };
+  return {
+    sessionId,
+    mode: "plaintext",
+    summary: summary ?? null,
+    send: async (options) => {
+      const plaintext = options.plaintext;
+      if (!plaintext || plaintext.trim().length === 0) {
+        throw new Error("plaintext is required for chat messages");
+      }
+      const message = options.message ?? plaintext;
+      return sendMessage(client, {
+        sessionId,
+        message,
+        streaming: options.streaming,
+        auth: options.auth ?? defaultAuth,
+        uaid,
+        agentUrl
+      });
+    },
+    decryptHistoryEntry: (entry) => entry.content,
+    fetchHistory
+  };
+}
+async function compactHistory(client, payload) {
+  if (!payload.sessionId || payload.sessionId.trim().length === 0) {
+    throw new Error("sessionId is required to compact chat history");
   }
-  if (typeof filters.limit === "number") {
-    params.set("limit", String(filters.limit));
+  const body = {};
+  if (typeof payload.preserveEntries === "number" && Number.isFinite(payload.preserveEntries) && payload.preserveEntries >= 0) {
+    body.preserveEntries = Math.floor(payload.preserveEntries);
   }
-  if (typeof filters.offset === "number") {
-    params.set("offset", String(filters.offset));
+  const raw = await client.requestJson(
+    `/chat/session/${encodeURIComponent(payload.sessionId)}/compact`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    chatHistoryCompactionResponseSchema,
+    "chat history compaction response"
+  );
+}
+async function fetchEncryptionStatus(client, sessionId) {
+  if (!sessionId || sessionId.trim().length === 0) {
+    throw new Error("sessionId is required for encryption status");
   }
-  const suffix = params.size > 0 ? `?${params.toString()}` : "";
   const raw = await client.requestJson(
-    `/adapters/registry/adapters${suffix}`,
+    `/chat/session/${encodeURIComponent(sessionId)}/encryption`,
     {
       method: "GET"
     }
   );
   return client.parseWithSchema(
     raw,
-    adapterRegistryAdaptersResponseSchema,
-    "adapter registry adapters response"
+    sessionEncryptionStatusResponseSchema,
+    "session encryption status response"
   );
 }
-async function createAdapterRegistryCategory(client, payload) {
+async function postEncryptionHandshake(client, sessionId, payload) {
+  if (!sessionId || sessionId.trim().length === 0) {
+    throw new Error("sessionId is required for encryption handshake");
+  }
   const raw = await client.requestJson(
-    "/adapters/registry/categories",
+    `/chat/session/${encodeURIComponent(sessionId)}/encryption-handshake`,
     {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: toJsonObject(payload)
+      body: {
+        role: payload.role,
+        keyType: payload.keyType,
+        ephemeralPublicKey: payload.ephemeralPublicKey,
+        longTermPublicKey: payload.longTermPublicKey,
+        signature: payload.signature,
+        uaid: payload.uaid,
+        userId: payload.userId,
+        ledgerAccountId: payload.ledgerAccountId,
+        metadata: payload.metadata
+      }
     }
   );
-  const parsed = client.parseWithSchema(
+  const response = client.parseWithSchema(
     raw,
-    adapterRegistryCreateCategoryResponseSchema,
-    "adapter registry create category response"
+    encryptionHandshakeResponseSchema,
+    "encryption handshake response"
   );
-  return parsed.category;
+  return response.handshake;
 }
-async function submitAdapterRegistryAdapter(client, payload) {
+async function sendMessage(client, payload) {
+  const body = {
+    message: payload.message
+  };
+  if (payload.streaming !== void 0) {
+    body.streaming = payload.streaming;
+  }
+  if (payload.idempotencyKey) {
+    body.idempotencyKey = payload.idempotencyKey;
+  }
+  if (payload.senderUaid) {
+    body.senderUaid = payload.senderUaid;
+  }
+  if (payload.transport) {
+    body.transport = payload.transport;
+  }
+  if (payload.auth) {
+    body.auth = serialiseAuthConfig(payload.auth);
+  }
+  if ("uaid" in payload) {
+    body.uaid = payload.uaid;
+  }
+  if ("sessionId" in payload && payload.sessionId) {
+    body.sessionId = payload.sessionId;
+  }
+  if ("agentUrl" in payload && payload.agentUrl) {
+    body.agentUrl = payload.agentUrl;
+  }
+  let cipherEnvelope = payload.cipherEnvelope ?? null;
+  if (payload.encryption) {
+    const sessionIdForEncryption = payload.encryption.sessionId ?? (typeof body.sessionId === "string" ? body.sessionId : void 0);
+    if (!sessionIdForEncryption) {
+      throw new Error(
+        "sessionId is required when using encrypted chat payloads"
+      );
+    }
+    if (!payload.encryption.recipients?.length) {
+      throw new Error("recipients are required for encrypted chat payloads");
+    }
+    cipherEnvelope = client.encryption.encryptCipherEnvelope({
+      ...payload.encryption,
+      sessionId: sessionIdForEncryption
+    });
+  }
+  if (cipherEnvelope) {
+    body.cipherEnvelope = toJsonObject(cipherEnvelope);
+  }
+  const raw = await client.requestJson("/chat/message", {
+    method: "POST",
+    body,
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    sendMessageResponseSchema,
+    "chat message response"
+  );
+}
+async function endSession(client, sessionId) {
+  const normalizedSessionId = sessionId?.trim();
+  if (!normalizedSessionId) {
+    throw new Error("sessionId is required to end a chat session");
+  }
+  const response = await client.request(
+    `/chat/session/${encodeURIComponent(normalizedSessionId)}`,
+    { method: "DELETE" }
+  );
+  if (response.status === 204) {
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
+    };
+  }
+  const contentType = response.headers?.get("content-type") ?? "";
+  if (!contentType.toLowerCase().includes("json")) {
+    await response.text();
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
+    };
+  }
+  const responseBody = await response.text();
+  if (responseBody.trim().length === 0) {
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
+    };
+  }
+  const raw = JSON.parse(responseBody);
+  return client.parseWithSchema(
+    raw,
+    chatSessionEndResponseSchema,
+    "chat session end response"
+  );
+}
+async function cancelSession(client, sessionId) {
+  const normalizedSessionId = sessionId?.trim();
+  if (!normalizedSessionId) {
+    throw new Error("sessionId is required to cancel a chat session");
+  }
   const raw = await client.requestJson(
-    "/adapters/registry/adapters",
+    `/chat/session/${encodeURIComponent(normalizedSessionId)}/cancel`,
     {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: toJsonObject(payload)
+      method: "POST"
     }
   );
   return client.parseWithSchema(
     raw,
-    adapterRegistrySubmitAdapterAcceptedResponseSchema,
-    "adapter registry submit adapter response"
+    chatSessionEndResponseSchema,
+    "chat session cancel response"
   );
 }
-async function adapterRegistrySubmissionStatus(client, submissionId) {
+async function retryMessage(client, messageId, payload) {
+  const normalizedMessageId = messageId?.trim();
+  const normalizedSessionId = payload.sessionId?.trim();
+  const normalizedMessage = payload.message?.trim();
+  if (!normalizedMessageId) {
+    throw new Error("messageId is required to retry a message");
+  }
+  if (!normalizedSessionId) {
+    throw new Error("sessionId is required to retry a message");
+  }
+  if (!normalizedMessage) {
+    throw new Error("message is required to retry a message");
+  }
+  const body = {
+    sessionId: normalizedSessionId,
+    message: payload.message
+  };
+  if (payload.streaming !== void 0) {
+    body.streaming = payload.streaming;
+  }
+  if (payload.transport) {
+    body.transport = payload.transport;
+  }
+  const uaid = payload.uaid?.trim();
+  const agentUrl = payload.agentUrl?.trim();
+  const idempotencyKey = payload.idempotencyKey?.trim();
+  const senderUaid = payload.senderUaid?.trim();
+  if (uaid) {
+    body.uaid = uaid;
+  }
+  if (agentUrl) {
+    body.agentUrl = agentUrl;
+  }
+  if (idempotencyKey) {
+    body.idempotencyKey = idempotencyKey;
+  }
+  if (senderUaid) {
+    body.senderUaid = senderUaid;
+  }
+  if (payload.auth) {
+    body.auth = serialiseAuthConfig(payload.auth);
+  }
+  let cipherEnvelope = payload.cipherEnvelope ?? null;
+  if (payload.encryption) {
+    if (!payload.encryption.recipients?.length) {
+      throw new Error("recipients are required for encrypted chat payloads");
+    }
+    cipherEnvelope = client.encryption.encryptCipherEnvelope({
+      ...payload.encryption,
+      sessionId: payload.encryption.sessionId ?? normalizedSessionId
+    });
+  }
+  if (cipherEnvelope) {
+    body.cipherEnvelope = toJsonObject(cipherEnvelope);
+  }
   const raw = await client.requestJson(
-    `/adapters/registry/submissions/${encodeURIComponent(submissionId)}`,
+    `/chat/message/${encodeURIComponent(normalizedMessageId)}/retry`,
     {
-      method: "GET"
+      method: "POST",
+      body,
+      headers: { "content-type": "application/json" }
     }
   );
   return client.parseWithSchema(
     raw,
-    adapterRegistrySubmissionStatusResponseSchema,
-    "adapter registry submission status response"
+    sendMessageResponseSchema,
+    "chat retry response"
   );
 }
 export {
-  adapterRegistryAdapters,
-  adapterRegistryCategories,
-  adapterRegistrySubmissionStatus,
-  adapters,
-  adaptersDetailed,
-  createAdapterRegistryCategory,
-  submitAdapterRegistryAdapter
+  acceptConversation,
+  cancelSession,
+  checkChatReadiness,
+  compactHistory,
+  createChatApi,
+  createPlaintextConversationHandle,
+  createSession,
+  endSession,
+  fetchEncryptionStatus,
+  postEncryptionHandshake,
+  resumeSession,
+  retryMessage,
+  sendMessage,
+  startChat,
+  startConversation
 };
 //# sourceMappingURL=standards-sdk.es180.js.map