@hashgraphonline/standards-sdk 0.1.187 → 0.1.188

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

@@ -1,520 +1,142 @@
-import { createSessionResponseSchema, chatSessionResumeResponseSchema, chatReadinessResponseSchema, chatHistoryCompactionResponseSchema, sessionEncryptionStatusResponseSchema, encryptionHandshakeResponseSchema, sendMessageResponseSchema, chatSessionEndResponseSchema } from "./standards-sdk.es157.js";
-import { serialiseAuthConfig, toJsonObject } from "./standards-sdk.es208.js";
-import { EncryptionUnavailableError } from "./standards-sdk.es200.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 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,
-    chatReadinessResponseSchema,
-    "chat readiness response"
-  );
-}
-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,
-    chatSessionResumeResponseSchema,
-    "chat session resume response"
-  );
-}
-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
-    });
+import { Buffer } from "buffer";
+import { chatHistorySnapshotResponseSchema } from "./standards-sdk.es158.js";
+function identitiesMatch(a, b) {
+  if (!a && !b) {
+    return true;
   }
-  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 }
-    );
+  if (!a || !b) {
+    return false;
   }
-  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 (a.uaid && b.uaid && a.uaid.toLowerCase() === b.uaid.toLowerCase()) {
+    return true;
   }
-  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 (a.ledgerAccountId && b.ledgerAccountId && a.ledgerAccountId.toLowerCase() === b.ledgerAccountId.toLowerCase()) {
+    return true;
   }
-}
-async function acceptConversation(client, encryptedManager, options) {
-  const preference = options.encryption?.preference ?? "preferred";
-  if (preference === "disabled") {
-    return createPlaintextConversationHandle(client, options.sessionId, null);
-  }
-  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 (a.userId && b.userId && a.userId === b.userId) {
+    return true;
   }
-  const body = {};
-  if (typeof payload.preserveEntries === "number" && Number.isFinite(payload.preserveEntries) && payload.preserveEntries >= 0) {
-    body.preserveEntries = Math.floor(payload.preserveEntries);
+  if (a.email && b.email && a.email.toLowerCase() === b.email.toLowerCase()) {
+    return true;
   }
-  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"
-  );
+  return false;
 }
-async function fetchEncryptionStatus(client, sessionId) {
+async function fetchHistorySnapshot(conversationContexts, client, sessionId, options) {
   if (!sessionId || sessionId.trim().length === 0) {
-    throw new Error("sessionId is required for encryption status");
+    throw new Error("sessionId is required to fetch chat history");
   }
   const raw = await client.requestJson(
-    `/chat/session/${encodeURIComponent(sessionId)}/encryption`,
+    `/chat/session/${encodeURIComponent(sessionId)}/history`,
     {
       method: "GET"
     }
   );
-  return client.parseWithSchema(
+  const snapshot = client.parseWithSchema(
     raw,
-    sessionEncryptionStatusResponseSchema,
-    "session encryption status response"
+    chatHistorySnapshotResponseSchema,
+    "chat history snapshot response"
   );
-}
-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(
-    `/chat/session/${encodeURIComponent(sessionId)}/encryption-handshake`,
-    {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      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 response = client.parseWithSchema(
-    raw,
-    encryptionHandshakeResponseSchema,
-    "encryption handshake response"
-  );
-  return response.handshake;
-}
-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"
+  return attachDecryptedHistory(
+    conversationContexts,
+    client,
+    sessionId,
+    snapshot,
+    options
   );
 }
-async function endSession(client, sessionId) {
-  const normalizedSessionId = sessionId?.trim();
-  if (!normalizedSessionId) {
-    throw new Error("sessionId is required to end a chat session");
+function attachDecryptedHistory(conversationContexts, client, sessionId, snapshot, options) {
+  const shouldDecrypt = options?.decrypt !== void 0 ? options.decrypt : client.encryptionOptions?.autoDecryptHistory === true;
+  if (!shouldDecrypt) {
+    return snapshot;
   }
-  const response = await client.request(
-    `/chat/session/${encodeURIComponent(normalizedSessionId)}`,
-    { method: "DELETE" }
+  const requiresContext = snapshot.history.some(
+    (entry) => Boolean(entry.cipherEnvelope)
   );
-  if (response.status === 204) {
+  if (!requiresContext) {
     return {
-      message: "Session ended",
-      sessionId: normalizedSessionId,
-      state: "ended"
+      ...snapshot,
+      decryptedHistory: snapshot.history.map((entry) => ({
+        entry,
+        plaintext: entry.content
+      }))
     };
   }
-  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"
+  const context = resolveDecryptionContext(
+    conversationContexts,
+    client,
+    sessionId,
+    options
   );
-}
-async function cancelSession(client, sessionId) {
-  const normalizedSessionId = sessionId?.trim();
-  if (!normalizedSessionId) {
-    throw new Error("sessionId is required to cancel a chat session");
+  if (!context) {
+    throw new Error(
+      "Unable to decrypt chat history: encryption context unavailable"
+    );
   }
-  const raw = await client.requestJson(
-    `/chat/session/${encodeURIComponent(normalizedSessionId)}/cancel`,
-    {
-      method: "POST"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    chatSessionEndResponseSchema,
-    "chat session cancel response"
-  );
+  const decryptedHistory = snapshot.history.map((entry) => ({
+    entry,
+    plaintext: decryptHistoryEntryFromContext(client, entry, context)
+  }));
+  return { ...snapshot, decryptedHistory };
 }
-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
+function registerConversationContextForEncryption(conversationContexts, context) {
+  const normalized = {
+    sessionId: context.sessionId,
+    sharedSecret: Buffer.from(context.sharedSecret),
+    identity: context.identity ? { ...context.identity } : void 0
   };
-  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;
+  const entries = conversationContexts.get(context.sessionId) ?? [];
+  const existingIndex = entries.findIndex(
+    (existing) => identitiesMatch(existing.identity, normalized.identity)
+  );
+  if (existingIndex >= 0) {
+    entries[existingIndex] = normalized;
+  } else {
+    entries.push(normalized);
   }
-  if (agentUrl) {
-    body.agentUrl = agentUrl;
+  conversationContexts.set(context.sessionId, entries);
+}
+function resolveDecryptionContext(conversationContexts, client, sessionId, options) {
+  if (options?.sharedSecret) {
+    return {
+      sessionId,
+      sharedSecret: client.normalizeSharedSecret(options.sharedSecret),
+      identity: options.identity
+    };
   }
-  if (idempotencyKey) {
-    body.idempotencyKey = idempotencyKey;
+  const contexts = conversationContexts.get(sessionId);
+  if (!contexts || contexts.length === 0) {
+    return null;
   }
-  if (senderUaid) {
-    body.senderUaid = senderUaid;
+  if (options?.identity) {
+    const match = contexts.find(
+      (context) => identitiesMatch(context.identity, options.identity)
+    );
+    if (match) {
+      return match;
+    }
   }
-  if (payload.auth) {
-    body.auth = serialiseAuthConfig(payload.auth);
+  return contexts[0];
+}
+function decryptHistoryEntryFromContext(client, entry, context) {
+  const envelope = entry.cipherEnvelope;
+  if (!envelope) {
+    return entry.content;
   }
-  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
+  const secret = Buffer.from(context.sharedSecret);
+  try {
+    return client.encryption.decryptCipherEnvelope({
+      envelope,
+      sharedSecret: secret
     });
+  } catch (_error) {
+    return null;
   }
-  if (cipherEnvelope) {
-    body.cipherEnvelope = toJsonObject(cipherEnvelope);
-  }
-  const raw = await client.requestJson(
-    `/chat/message/${encodeURIComponent(normalizedMessageId)}/retry`,
-    {
-      method: "POST",
-      body,
-      headers: { "content-type": "application/json" }
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    sendMessageResponseSchema,
-    "chat retry response"
-  );
 }
 export {
-  acceptConversation,
-  cancelSession,
-  checkChatReadiness,
-  compactHistory,
-  createChatApi,
-  createPlaintextConversationHandle,
-  createSession,
-  endSession,
-  fetchEncryptionStatus,
-  postEncryptionHandshake,
-  resumeSession,
-  retryMessage,
-  sendMessage,
-  startChat,
-  startConversation
+  attachDecryptedHistory,
+  decryptHistoryEntryFromContext,
+  fetchHistorySnapshot,
+  registerConversationContextForEncryption,
+  resolveDecryptionContext
 };
 //# sourceMappingURL=standards-sdk.es199.js.map