@hashgraphonline/standards-sdk 0.1.186 → 0.1.188

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

@@ -1,262 +1,520 @@
-class EncryptionUnavailableError extends Error {
-  constructor(sessionId, summary) {
-    super("Encryption is not enabled for this session");
-    this.sessionId = sessionId;
-    this.summary = summary;
+import { createSessionResponseSchema, chatSessionResumeResponseSchema, chatReadinessResponseSchema, chatHistoryCompactionResponseSchema, sessionEncryptionStatusResponseSchema, encryptionHandshakeResponseSchema, sendMessageResponseSchema, chatSessionEndResponseSchema } from "./standards-sdk.es158.js";
+import { serialiseAuthConfig, toJsonObject } from "./standards-sdk.es209.js";
+import { EncryptionUnavailableError } from "./standards-sdk.es201.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"
+  );
 }
-class EncryptedChatManager {
-  constructor(client) {
-    this.client = client;
+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;
   }
-  registerConversationContext(context) {
-    this.client.registerConversationContextForEncryption(context);
+}
+async function resumeSession(client, sessionId) {
+  const normalized = sessionId.trim();
+  if (!normalized) {
+    throw new Error("sessionId is required to resume a chat session");
   }
-  async startSession(options) {
-    await this.client.encryptionReady();
-    const session = await this.client.chat.createSession({
+  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,
-      encryptionRequested: true,
       historyTtlSeconds: options.historyTtlSeconds,
-      auth: options.auth
+      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);
-    const summary = session.encryption;
-    if (!summary?.enabled) {
-      throw new EncryptionUnavailableError(
-        session.sessionId,
-        session.encryption ?? null
-      );
-    }
-    const handle = await this.establishRequesterContext({
-      sessionId: session.sessionId,
-      summary,
+    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,
-      handshakeTimeoutMs: options.handshakeTimeoutMs,
-      pollIntervalMs: options.pollIntervalMs
+      encryptionRequested: false
+    });
+    options.onSessionCreated?.(session.sessionId);
+    return createPlaintextConversationHandle(
+      client,
+      session.sessionId,
+      session.encryption ?? null,
+      options.auth,
+      { uaid: options.uaid }
+    );
+  }
+  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;
   }
-  async acceptSession(options) {
-    await this.client.encryptionReady();
-    const summary = await this.waitForEncryptionSummary(
-      options.sessionId,
-      options.handshakeTimeoutMs,
-      options.pollIntervalMs
-    );
-    const handle = await this.establishResponderContext({
+}
+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,
-      summary,
       responderUaid: options.responderUaid,
-      handshakeTimeoutMs: options.handshakeTimeoutMs,
-      pollIntervalMs: options.pollIntervalMs
+      handshakeTimeoutMs: options.encryption?.handshakeTimeoutMs,
+      pollIntervalMs: options.encryption?.pollIntervalMs
     });
     return handle;
-  }
-  async establishRequesterContext(params) {
-    const keyPair = this.client.encryption.generateEphemeralKeyPair();
-    await this.client.chat.submitEncryptionHandshake(params.sessionId, {
-      role: "requester",
-      keyType: "secp256k1",
-      ephemeralPublicKey: keyPair.publicKey,
-      uaid: params.senderUaid ?? params.summary.requester?.uaid ?? void 0
-    });
-    const { summary, record } = await this.waitForHandshakeCompletion(
-      params.sessionId,
-      params.handshakeTimeoutMs,
-      params.pollIntervalMs
-    );
-    const responderKey = record.responder?.ephemeralPublicKey;
-    if (!responderKey) {
-      throw new Error("Responder handshake was not completed in time");
+  } catch (error) {
+    if (error instanceof EncryptionUnavailableError && preference !== "required") {
+      return createPlaintextConversationHandle(
+        client,
+        options.sessionId,
+        null,
+        void 0,
+        { uaid: options.responderUaid }
+      );
     }
-    const sharedSecret = this.client.encryption.deriveSharedSecret({
-      privateKey: keyPair.privateKey,
-      peerPublicKey: responderKey
-    }).subarray();
-    const recipients = this.buildRecipients(summary);
-    return this.createHandle({
-      sessionId: params.sessionId,
-      sharedSecret,
-      summary,
-      recipients,
-      identity: summary.requester ?? void 0
-    });
+    throw error;
   }
-  async establishResponderContext(params) {
-    const keyPair = this.client.encryption.generateEphemeralKeyPair();
-    await this.client.chat.submitEncryptionHandshake(params.sessionId, {
-      role: "responder",
-      keyType: "secp256k1",
-      ephemeralPublicKey: keyPair.publicKey,
-      uaid: params.responderUaid ?? params.summary.responder?.uaid ?? void 0
-    });
-    const { summary, record } = await this.waitForHandshakeCompletion(
-      params.sessionId,
-      params.handshakeTimeoutMs,
-      params.pollIntervalMs
-    );
-    const requesterKey = record.requester?.ephemeralPublicKey;
-    if (!requesterKey) {
-      throw new Error("Requester handshake was not detected in time");
+}
+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;
     }
-    const sharedSecret = this.client.encryption.deriveSharedSecret({
-      privateKey: keyPair.privateKey,
-      peerPublicKey: requesterKey
-    }).subarray();
-    const recipients = this.buildRecipients(summary);
-    return this.createHandle({
-      sessionId: params.sessionId,
-      sharedSecret,
-      summary,
-      recipients,
-      identity: summary.responder ?? void 0
-    });
-  }
-  async waitForHandshakeCompletion(sessionId, timeoutMs = 3e4, pollIntervalMs = 1e3) {
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-      const status = await this.client.chat.getEncryptionStatus(sessionId);
-      const summary = status.encryption;
-      const record = summary?.handshake;
-      if (summary && record && record.status === "complete") {
-        return { summary, record };
+    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");
       }
-      if (Date.now() >= deadline) {
-        throw new Error("Timed out waiting for encrypted handshake completion");
-      }
-      await this.delay(pollIntervalMs);
+      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");
+  }
+  const body = {};
+  if (typeof payload.preserveEntries === "number" && Number.isFinite(payload.preserveEntries) && payload.preserveEntries >= 0) {
+    body.preserveEntries = Math.floor(payload.preserveEntries);
+  }
+  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");
   }
-  async waitForEncryptionSummary(sessionId, _timeoutMs = 3e4, _pollIntervalMs = 1e3) {
-    const status = await this.client.chat.getEncryptionStatus(sessionId);
-    if (!status.encryption?.enabled) {
-      throw new EncryptionUnavailableError(
-        sessionId,
-        status.encryption ?? null
-      );
+  const raw = await client.requestJson(
+    `/chat/session/${encodeURIComponent(sessionId)}/encryption`,
+    {
+      method: "GET"
     }
-    return status.encryption;
+  );
+  return client.parseWithSchema(
+    raw,
+    sessionEncryptionStatusResponseSchema,
+    "session encryption status response"
+  );
+}
+async function postEncryptionHandshake(client, sessionId, payload) {
+  if (!sessionId || sessionId.trim().length === 0) {
+    throw new Error("sessionId is required for encryption handshake");
   }
-  buildRecipients(summary) {
-    const candidates = [summary.requester, summary.responder].filter(Boolean);
-    const normalized = candidates.map((candidate) => {
-      if (!candidate) {
-        return null;
+  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 recipient = {};
-      if (candidate.uaid) {
-        recipient.uaid = candidate.uaid;
-      }
-      if (candidate.ledgerAccountId) {
-        recipient.ledgerAccountId = candidate.ledgerAccountId;
-      }
-      if (candidate.userId) {
-        recipient.userId = candidate.userId;
-      }
-      if (candidate.email) {
-        recipient.email = candidate.email;
-      }
-      return recipient;
-    }).filter(
-      (entry) => Boolean(
-        entry?.uaid || entry?.ledgerAccountId || entry?.userId || entry?.email
-      )
-    );
-    if (normalized.length > 0) {
-      return normalized;
-    }
-    if (summary.responder?.uaid) {
-      return [{ uaid: summary.responder.uaid }];
     }
-    return [];
-  }
-  createHandle(context) {
-    const sharedSecret = context.sharedSecret;
-    const uaid = context.summary.requester?.uaid ?? context.summary.responder?.uaid ?? context.identity?.uaid;
-    const decryptHistoryEntry = (entry) => this.decryptEntry(entry, context.identity, sharedSecret);
-    const fetchHistory = async (options) => {
-      const snapshot = await this.client.fetchHistorySnapshot(
-        context.sessionId,
-        options
+  );
+  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 (snapshot.decryptedHistory) {
-        return snapshot.decryptedHistory;
-      }
-      return snapshot.history.map((entry) => ({
-        entry,
-        plaintext: decryptHistoryEntry(entry)
-      }));
+    }
+    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 handle = {
-      sessionId: context.sessionId,
-      mode: "encrypted",
-      summary: context.summary,
-      send: async (options) => {
-        const recipients = options.recipients ?? context.recipients;
-        return this.client.chat.sendMessage({
-          sessionId: context.sessionId,
-          message: options.message ?? "[ciphertext omitted]",
-          streaming: options.streaming,
-          auth: options.auth,
-          uaid,
-          encryption: {
-            plaintext: options.plaintext,
-            sharedSecret: Buffer.from(sharedSecret),
-            recipients
-          }
-        });
-      },
-      decryptHistoryEntry,
-      fetchHistory
+  }
+  const contentType = response.headers?.get("content-type") ?? "";
+  if (!contentType.toLowerCase().includes("json")) {
+    await response.text();
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
     };
-    this.registerConversationContext({
-      sessionId: context.sessionId,
-      sharedSecret,
-      identity: context.identity
-    });
-    return handle;
   }
-  decryptEntry(entry, identity, fallbackSecret) {
-    const envelope = entry.cipherEnvelope;
-    if (!envelope) {
-      return null;
-    }
-    const secret = Buffer.from(fallbackSecret);
-    try {
-      return this.client.encryption.decryptCipherEnvelope({
-        envelope,
-        sharedSecret: secret
-      });
-    } catch (_error) {
-      return null;
-    }
+  const responseBody = await response.text();
+  if (responseBody.trim().length === 0) {
+    return {
+      message: "Session ended",
+      sessionId: normalizedSessionId,
+      state: "ended"
+    };
   }
-  recipientMatches(candidate, target) {
-    if (target.uaid && candidate.uaid?.toLowerCase() === target.uaid.toLowerCase()) {
-      return true;
-    }
-    if (target.ledgerAccountId && candidate.ledgerAccountId?.toLowerCase() === target.ledgerAccountId.toLowerCase()) {
-      return true;
-    }
-    if (target.userId && candidate.userId === target.userId) {
-      return true;
-    }
-    if (target.email && candidate.email?.toLowerCase() === target.email.toLowerCase()) {
-      return true;
+  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(
+    `/chat/session/${encodeURIComponent(normalizedSessionId)}/cancel`,
+    {
+      method: "POST"
     }
-    return false;
+  );
+  return client.parseWithSchema(
+    raw,
+    chatSessionEndResponseSchema,
+    "chat session cancel response"
+  );
+}
+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;
   }
-  async delay(ms) {
-    if (ms <= 0) {
-      return;
+  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");
     }
-    await new Promise((resolve) => setTimeout(resolve, ms));
+    cipherEnvelope = client.encryption.encryptCipherEnvelope({
+      ...payload.encryption,
+      sessionId: payload.encryption.sessionId ?? normalizedSessionId
+    });
+  }
+  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 {
-  EncryptedChatManager,
-  EncryptionUnavailableError
+  acceptConversation,
+  cancelSession,
+  checkChatReadiness,
+  compactHistory,
+  createChatApi,
+  createPlaintextConversationHandle,
+  createSession,
+  endSession,
+  fetchEncryptionStatus,
+  postEncryptionHandshake,
+  resumeSession,
+  retryMessage,
+  sendMessage,
+  startChat,
+  startConversation
 };
 //# sourceMappingURL=standards-sdk.es200.js.map