@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/client/conversation/attachmentFiles.js

@@ -0,0 +1,158 @@
+// Which files a drop, a paste or a file list carries, read from the browser's transfer objects, and the drop and
+// paste target that hands them to an upload queue.
+import { computed, ref } from "vue";
+import { useJskitText } from "../i18n.js";
+
+const { t } = useJskitText();
+
+function assistantAttachmentFiles(fileList) {
+  return Array.from(fileList || []).filter((file) => file && file.size >= 0);
+}
+
+function assistantAttachmentFilesFromTransferItems(items) {
+  return assistantAttachmentFiles(Array.from(items || [])
+    .map((item) => {
+      // readable-check: allow method-probe - platform object: a transfer item, or a caller's stand-in for one, may hold no file
+      if (item?.kind !== "file" || typeof item.getAsFile !== "function") {
+        return null;
+      }
+      return item.getAsFile();
+    }));
+}
+
+function assistantAttachmentFilesFromDropEvent(event) {
+  const dataTransfer = event?.dataTransfer;
+  const itemFiles = assistantAttachmentFilesFromTransferItems(dataTransfer?.items);
+  if (itemFiles.length > 0) {
+    return itemFiles;
+  }
+  return assistantAttachmentFiles(dataTransfer?.files);
+}
+
+function assistantAttachmentFilesFromPasteEvent(event) {
+  const clipboardData = event?.clipboardData;
+  const itemFiles = assistantAttachmentFilesFromTransferItems(clipboardData?.items);
+  if (itemFiles.length > 0) {
+    return itemFiles;
+  }
+  return assistantAttachmentFiles(clipboardData?.files);
+}
+
+function assistantAttachmentEventHasFiles(event) {
+  const dataTransfer = event?.dataTransfer;
+  return assistantAttachmentFilesFromDropEvent(event).length > 0 ||
+    Array.from(dataTransfer?.items || []).some((item) => item?.kind === "file") ||
+    Array.from(dataTransfer?.types || []).some((type) => (
+      type === "Files" ||
+      type === "application/x-moz-file"
+    ));
+}
+
+function assistantAttachmentClipboardText(event) {
+  // readable-check: allow method-probe - platform object: a paste event, or a caller's stand-in for one, may carry no clipboard text
+  if (typeof event?.clipboardData?.getData !== "function") {
+    return "";
+  }
+  return String(event.clipboardData.getData("text/plain") || "");
+}
+
+function assistantAttachmentClipboardLocalFileReference(event) {
+  const clipboardData = event?.clipboardData;
+  // readable-check: allow method-probe - platform object: a paste event, or a caller's stand-in for one, may carry no clipboard text
+  if (!clipboardData || typeof clipboardData.getData !== "function") {
+    return "";
+  }
+  const types = Array.from(clipboardData.types || []);
+  const text = [
+    clipboardData.getData("x-special/gnome-copied-files"),
+    clipboardData.getData("text/uri-list"),
+    clipboardData.getData("text/plain")
+  ].map((value) => String(value || "").trim()).filter(Boolean).join("\n");
+  if (
+    types.includes("Files") ||
+    types.includes("application/x-moz-file") ||
+    types.includes("x-special/gnome-copied-files") ||
+    /^file:/imu.test(text)
+  ) {
+    return text || "file://";
+  }
+  return "";
+}
+
+/**
+ * A drop zone and paste target that hands the files it receives to `uploadFiles`. Nested drag enters are counted, so
+ * the zone stays active until the drag leaves it.
+ * @param {{
+ *   uploadFiles: (files: File[]) => Promise<any[]>,
+ *   reportAttachmentError: (error: unknown) => string
+ * }} dependencies
+ */
+function useAttachmentDropTarget({ uploadFiles, reportAttachmentError }) {
+  const dragDepth = ref(0);
+  const dragActive = computed(() => dragDepth.value > 0);
+
+  function resetDragState() {
+    dragDepth.value = 0;
+  }
+
+  function handleDragEnter(event) {
+    if (!assistantAttachmentEventHasFiles(event)) {
+      return;
+    }
+    dragDepth.value += 1;
+    if (event?.dataTransfer) {
+      event.dataTransfer.dropEffect = "copy";
+    }
+  }
+
+  function handleDragOver(event) {
+    if (event?.dataTransfer) {
+      event.dataTransfer.dropEffect = "copy";
+    }
+  }
+
+  function handleDragLeave() {
+    dragDepth.value = Math.max(0, dragDepth.value - 1);
+  }
+
+  async function handleDrop(event) {
+    resetDragState();
+    return uploadFiles(assistantAttachmentFilesFromDropEvent(event));
+  }
+
+  async function handlePaste(event) {
+    const files = assistantAttachmentFilesFromPasteEvent(event);
+    if (files.length < 1) {
+      if (assistantAttachmentClipboardLocalFileReference(event)) {
+        reportAttachmentError(t("jskit.assistant.attachments.error.localFilePaste"));
+      }
+      return [];
+    }
+    if (!assistantAttachmentClipboardText(event)) {
+      // readable-check: allow optional-call - platform object: a paste event or a caller's stand-in for one
+      event?.preventDefault?.();
+    }
+    return uploadFiles(files);
+  }
+
+  return {
+    dragActive,
+    handleDragEnter,
+    handleDragLeave,
+    handleDragOver,
+    handleDrop,
+    handlePaste,
+    resetDragState
+  };
+}
+
+export {
+  assistantAttachmentClipboardLocalFileReference,
+  assistantAttachmentClipboardText,
+  assistantAttachmentEventHasFiles,
+  assistantAttachmentFiles,
+  assistantAttachmentFilesFromDropEvent,
+  assistantAttachmentFilesFromPasteEvent,
+  assistantAttachmentFilesFromTransferItems,
+  useAttachmentDropTarget
+};

package/src/client/conversation/attachmentQueueItems.js

@@ -0,0 +1,121 @@
+// How the attachment queue shows each item: its key, name, phase, progress, status text, icon and colour.
+import { mdiAlertCircleOutline, mdiCheckCircleOutline, mdiFileOutline } from "@mdi/js";
+import { useJskitText } from "../i18n.js";
+import { attachmentSizeText } from "./attachmentSize.js";
+
+const { t } = useJskitText();
+
+const activePhases = new Set(["queued", "preparing", "uploading", "delivering"]);
+
+function itemKey(item = {}) {
+  return String(item.clientId || item.id || item.attachmentId || item.fileName || "attachment");
+}
+
+function itemName(item = {}) {
+  return String(item.fileName || item.file?.name || t("jskit.assistant.attachments.unnamed"));
+}
+
+function itemPhase(item = {}) {
+  return String(item.phase || item.status || "queued");
+}
+
+function itemPercent(item = {}) {
+  if (itemPhase(item) === "ready") {
+    return 100;
+  }
+  if (itemPhase(item) === "delivering") {
+    return 100;
+  }
+  if (itemPhase(item) === "queued") {
+    return 0;
+  }
+  const progressValue = item.percent ?? item.progress;
+  const directPercent = progressValue === null || progressValue === undefined || progressValue === ""
+    ? null
+    : Number(progressValue);
+  if (directPercent !== null && Number.isFinite(directPercent)) {
+    return Math.min(100, Math.max(0, Math.round(directPercent)));
+  }
+  const size = Number(item.size) || 0;
+  return size > 0 && Number(item.bytesSent) > 0
+    ? Math.min(100, Math.max(0, Math.round(((Number(item.bytesSent) || 0) / size) * 100)))
+    : null;
+}
+
+function itemProgressVisible(item = {}) {
+  return activePhases.has(itemPhase(item));
+}
+
+function itemProgressIndeterminate(item = {}) {
+  return itemProgressVisible(item) && itemPercent(item) === null;
+}
+
+function itemProgressValue(item = {}) {
+  return itemPercent(item) ?? 0;
+}
+
+function itemBytesLabel(item = {}) {
+  const size = Math.max(0, Number(item.size) || 0);
+  const sent = Math.min(Math.max(0, Number(item.bytesSent) || 0), size);
+  const percent = itemPercent(item);
+  return percent === null
+    ? t("jskit.assistant.attachments.bytes", { sent: attachmentSizeText(sent), size: attachmentSizeText(size) })
+    : t("jskit.assistant.attachments.bytesPercent", { sent: attachmentSizeText(sent), size: attachmentSizeText(size), percent });
+}
+
+function itemStatusLabel(item = {}) {
+  const labels = {
+    cancelled: "jskit.assistant.attachments.status.cancelled",
+    delivering: "jskit.assistant.attachments.status.delivering",
+    failed: item.failureStage === "preparing"
+      ? "jskit.assistant.attachments.status.preparationFailed"
+      : item.failureStage === "handoff"
+        ? "jskit.assistant.attachments.status.sendingFailed"
+        : "jskit.assistant.attachments.status.uploadFailed",
+    preparing: "jskit.assistant.attachments.status.preparing",
+    queued: "jskit.assistant.attachments.status.queued",
+    ready: "jskit.assistant.attachments.status.ready",
+    uploading: "jskit.assistant.attachments.status.uploading"
+  };
+  return t(Object.hasOwn(labels, itemPhase(item)) ? labels[itemPhase(item)] : "jskit.assistant.attachments.status.queued");
+}
+
+function itemCancelable(item = {}) {
+  return ["preparing", "queued", "uploading"].includes(itemPhase(item));
+}
+
+function itemIcon(item = {}) {
+  if (itemPhase(item) === "ready") {
+    return mdiCheckCircleOutline;
+  }
+  if (itemPhase(item) === "failed") {
+    return mdiAlertCircleOutline;
+  }
+  return mdiFileOutline;
+}
+
+function itemColor(item = {}) {
+  if (itemPhase(item) === "ready") {
+    return "success";
+  }
+  if (itemPhase(item) === "failed") {
+    return "error";
+  }
+  return "primary";
+}
+
+export {
+  activePhases,
+  itemBytesLabel,
+  itemCancelable,
+  itemColor,
+  itemIcon,
+  itemKey,
+  itemName,
+  itemPercent,
+  itemPhase,
+  itemProgressIndeterminate,
+  itemProgressValue,
+  itemProgressVisible,
+  itemStatusLabel
+};

package/src/client/conversation/attachmentUploadRows.js

@@ -0,0 +1,265 @@
+import { reactive } from "vue";
+import { useJskitText } from "../i18n.js";
+
+const { t } = useJskitText();
+
+function attachmentUploadError(attachment) {
+  return attachment?.error || attachment?.errors?.[0]?.message || "";
+}
+
+function attachmentIdentity(attachment) {
+  return String(
+    attachment?.clientId ||
+    attachment?.attachmentId ||
+    attachment?.path ||
+    attachment?.fileName ||
+    ""
+  );
+}
+
+// readable-check: allow module-state - shared resource: every queue on the page draws client ids from one sequence, so no two queues hand out the same id
+let attachmentClientSequence = 0;
+
+function nextAttachmentClientId() {
+  attachmentClientSequence += 1;
+  return `attachment-${Date.now().toString(36)}-${attachmentClientSequence.toString(36)}`;
+}
+
+function attachmentFileName(file) {
+  return String(file?.name || "attachment");
+}
+
+/** The upload's promise and its cancel, whichever of the documented shapes the application's upload returned. */
+// readable-check: allow method-probe - input validation: an application's upload returns a promise, or { promise } with abort() or cancel()
+function attachmentUploadResult(upload = null) {
+  if (upload && typeof upload.then === "function") {
+    return {
+      cancel: typeof upload.cancel === "function" ? () => upload.cancel() : null,
+      promise: upload
+    };
+  }
+  if (upload?.promise && typeof upload.promise.then === "function") {
+    const cancel = typeof upload.abort === "function"
+      ? () => upload.abort()
+      : typeof upload.cancel === "function"
+        ? () => upload.cancel()
+        : null;
+    return {
+      cancel,
+      promise: upload.promise
+    };
+  }
+  return {
+    cancel: null,
+    promise: Promise.resolve(upload)
+  };
+}
+
+function attachmentProgress(progress = {}, possibleTotal, fallbackTotal = 0) {
+  const directNumericProgress = typeof progress === "number" ? progress : null;
+  const progressObject = progress && typeof progress === "object" ? progress : {};
+  const totalBytes = Math.max(0, Number(
+    progressObject.totalBytes ??
+    progressObject.total ??
+    possibleTotal ??
+    fallbackTotal
+  ) || 0);
+  const bytesValue = progressObject.bytesSent ??
+    progressObject.loaded ??
+    progressObject.uploadedBytes ??
+    directNumericProgress;
+  const bytesKnown = bytesValue !== null && bytesValue !== undefined && bytesValue !== "";
+  let bytesSent = bytesKnown ? Number(bytesValue) || 0 : 0;
+  const directPercent = progressObject.percent;
+  let percent = directPercent !== null && directPercent !== undefined && directPercent !== ""
+    ? Number(directPercent)
+    : null;
+  const progressValue = progressObject.progress;
+  if (!Number.isFinite(percent) && progressValue !== null && progressValue !== undefined && progressValue !== "") {
+    const numericProgressValue = Number(progressValue);
+    if (Number.isFinite(numericProgressValue)) {
+      percent = numericProgressValue <= 1 ? numericProgressValue * 100 : numericProgressValue;
+    }
+  }
+  if (!Number.isFinite(percent)) {
+    percent = bytesKnown && totalBytes > 0 ? (bytesSent / totalBytes) * 100 : null;
+  }
+  if (percent !== null) {
+    percent = Math.max(0, Math.min(100, percent));
+  }
+  if (totalBytes > 0) {
+    const inferredBytes = percent === null ? 0 : totalBytes * percent / 100;
+    bytesSent = Math.max(0, Math.min(totalBytes, bytesSent || inferredBytes));
+  } else {
+    bytesSent = Math.max(0, bytesSent);
+  }
+  return {
+    bytesSent,
+    percent,
+    totalBytes
+  };
+}
+
+function attachmentReceipt(row, uploaded) {
+  return {
+    ...uploaded,
+    attachmentId: String(uploaded?.attachmentId || ""),
+    clientId: row.clientId,
+    fileName: String(uploaded?.fileName || row.fileName),
+    sessionId: row.sessionId,
+    size: Number(uploaded?.size ?? row.size) || 0
+  };
+}
+
+function createWaiter(row) {
+  let resolve = null;
+  const promise = new Promise((currentResolve) => {
+    resolve = currentResolve;
+  });
+  row.waiter = {
+    promise,
+    resolve,
+    settled: false
+  };
+  return row.waiter;
+}
+
+function settleWaiter(row, value = null, waiter = row.waiter) {
+  if (!waiter || waiter.settled) {
+    return;
+  }
+  waiter.settled = true;
+  waiter.resolve(value);
+}
+
+
+function updateRowProgress(row, progress, total) {
+  if (!row.retained || row.phase !== "uploading") {
+    return;
+  }
+  const next = attachmentProgress(progress, total, row.totalBytes);
+  row.bytesSent = Math.max(row.bytesSent, next.bytesSent);
+  row.totalBytes = next.totalBytes || row.totalBytes;
+  if (next.percent !== null) {
+    row.progress = Math.max(Number(row.progress) || 0, next.percent);
+  }
+}
+
+/** A new queue row for one file, or for a file a producer is still preparing. */
+function buildQueueRow({
+  currentSessionId,
+  file = null,
+  fileName = "attachment",
+  phase = "queued",
+  producer = null,
+  size = 0
+} = {}) {
+  const normalizedSize = Number(file?.size ?? size) || 0;
+  return reactive({
+    activeHandoffToken: null,
+    activeToken: null,
+    attachmentId: "",
+    bytesSent: 0,
+    clientId: nextAttachmentClientId(),
+    error: "",
+    failureStage: "",
+    file,
+    fileName: file ? attachmentFileName(file) : String(fileName || "attachment"),
+    path: "",
+    phase,
+    producer,
+    producerAbortController: null,
+    producerToken: null,
+    progress: null,
+    receipt: null,
+    retained: true,
+    sessionId: currentSessionId,
+    size: normalizedSize,
+    totalBytes: normalizedSize,
+    waiter: null
+  });
+}
+
+/**
+ * Deletes an uploaded file that no message will send, once per receipt, and waits for the deletions under way.
+ * A failed deletion is reported and resolves false.
+ * @param {{
+ *   deleteAttachment?: import("../types.js").AssistantAttachmentDeletion,
+ *   deletesUnsentUploads: boolean,
+ *   reportAttachmentError: (error: unknown, fallbackMessage: string) => string
+ * }} dependencies
+ */
+function createReceiptCleanup({ deleteAttachment, deletesUnsentUploads, reportAttachmentError }) {
+  const cleanupTasks = new Set();
+  const receiptCleanupById = new Map();
+  const cleanedReceiptIds = new Set();
+
+  function trackCleanup(task) {
+    const cleanup = Promise.resolve(task).catch((error) => {
+      reportAttachmentError(error, t("jskit.assistant.attachments.error.cleanupFailed"));
+      return false;
+    });
+    cleanupTasks.add(cleanup);
+    cleanup.finally(() => cleanupTasks.delete(cleanup));
+    return cleanup;
+  }
+
+  async function deleteUploadedAttachment(currentSessionId, attachment) {
+    const attachmentId = String(attachment?.attachmentId || "").trim();
+    if (!attachmentId || !deletesUnsentUploads) {
+      return false;
+    }
+    const response = await deleteAttachment(currentSessionId, attachmentId);
+    if (response?.ok === false) {
+      throw new Error(attachmentUploadError(response) || t("jskit.assistant.attachments.error.cleanupFailed"));
+    }
+    return true;
+  }
+
+  function cleanupReceipt(currentSessionId, receipt) {
+    const attachmentId = String(receipt?.attachmentId || "").trim();
+    const cleanupId = `${currentSessionId}:${attachmentId}`;
+    if (!attachmentId) {
+      return Promise.resolve(false);
+    }
+    if (cleanedReceiptIds.has(cleanupId)) {
+      return Promise.resolve(false);
+    }
+    if (receiptCleanupById.has(cleanupId)) {
+      return receiptCleanupById.get(cleanupId);
+    }
+    const cleanup = trackCleanup(deleteUploadedAttachment(currentSessionId, receipt)).then((deleted) => {
+      if (deleted) {
+        cleanedReceiptIds.add(cleanupId);
+      }
+      return deleted;
+    });
+    receiptCleanupById.set(cleanupId, cleanup);
+    cleanup.finally(() => receiptCleanupById.delete(cleanupId));
+    return cleanup;
+  }
+
+  async function waitForAttachmentCleanup() {
+    while (cleanupTasks.size > 0) {
+      await Promise.allSettled([...cleanupTasks]);
+    }
+  }
+
+  return Object.freeze({
+    cleanupReceipt,
+    waitForAttachmentCleanup
+  });
+}
+
+export {
+  attachmentFileName,
+  attachmentIdentity,
+  attachmentReceipt,
+  attachmentUploadError,
+  attachmentUploadResult,
+  buildQueueRow,
+  createReceiptCleanup,
+  createWaiter,
+  settleWaiter,
+  updateRowProgress
+};

package/src/client/conversation/conversationDisplay.js

@@ -0,0 +1,54 @@
+// What the transcript shows of a conversation: its saved turns, with the reply still streaming, the delivery's
+// unconfirmed messages and the application's unsent previews laid over them.
+
+/**
+ * The transcript's props for an adapter's conversation.
+ * @param {import("../types.js").AssistantConversationAdapter} adapter
+ */
+function displayedConversation(adapter) {
+  const saved = adapter.conversation;
+  if (!adapter.delivery && !saved.previewMessage && !saved.previewMessages?.length && !saved.interimReply) return saved;
+  const { previewMessage, previewMessages, interimReply, ...display } = saved;
+  let turns = adapter.delivery ? adapter.delivery.turns(saved.turns || []) : saved.turns || [];
+  if (interimReply?.text && interimReply.turnId) {
+    const assistant = { ...interimReply, messageId: interimReply.id, role: "assistant" };
+    turns = turns.map(turn => turn.turnId !== interimReply.turnId ? turn : {
+      ...turn, assistant,
+      commentary: (turn.commentary || []).filter(message =>
+        (message.outputId || message.messageId) !== (interimReply.outputId || interimReply.id)),
+      ...(Array.isArray(turn.messages) ? { messages: turn.messages.filter(message =>
+        message.role !== "assistant" &&
+        (message.outputId || message.messageId) !== (interimReply.outputId || interimReply.id)).concat(assistant) } : {})
+    });
+  }
+  // This list projects existing capture/pending owners; it never queues delivery.
+  const previews = Array.isArray(previewMessages) ? previewMessages : previewMessage ? [previewMessage] : [];
+  for (const preview of previews) {
+    const messageId = String(preview?.messageId || preview?.id || "").trim();
+    const localDelivery = messageId && adapter.delivery?.find(messageId);
+    if ((!localDelivery || localDelivery.status === "failed") && preview?.actions?.send) {
+      // Keep one unadmitted bubble and its real status until explicit Edit/discard.
+      // A receipt:false user row is not acknowledgement of the pending words.
+      turns = turns.map(turn => {
+        const failed = turn.optimistic?.id === messageId && turn.optimistic.status === "failed";
+        const unadmitted = turn.user?.receipt === false && String(turn.user.messageId || turn.user.id || "") === messageId;
+        if (!failed && !unadmitted) return turn;
+        return { ...turn, preview: true, previewMessage: preview, user: { ...turn.user, text: String(preview.text || "") } };
+      });
+    }
+    const alreadyShown = messageId && (localDelivery || turns.some(turn => [
+      turn.system, turn.user, turn.assistant, ...(turn.thinking || []), ...(turn.commentary || []), ...(turn.messages || [])
+    ].some(message => String(message?.messageId || message?.id || "") === messageId &&
+      (message.receipt !== false || turn.preview))));
+    if (messageId && (preview?.text || preview?.actions?.editing) && !alreadyShown) {
+      const user = { messageId, role: "user", text: String(preview.text || "") };
+      turns = [...turns, { turnId: messageId, user, messages: [user], preview: true, previewMessage: preview,
+        optimistic: { id: messageId, status: "pending" } }];
+    }
+  }
+  // Transcription and interim replies are display only. The receipt watcher
+  // receives canonical turns, never these presentation or delivery overlays.
+  return { ...display, turns, welcomeMessage: turns.length ? "" : saved.welcomeMessage };
+}
+
+export { displayedConversation };

package/src/client/conversation/messageDelivery.js

@@ -1,18 +1,17 @@
 import { reactive, toRaw, toValue, watch } from "vue";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { useJskitText } from "../i18n.js";
 
 const { serverMessage, t } = useJskitText();
 
-const messageText = value => String(value || "").trim();
-
 function turnMatchesOptimisticMessage(turn = {}, optimistic = {}) {
   const authored = optimistic.origin === "application" ? turn.system : turn.user;
-  const canonicalMessageId = messageText(authored?.messageId);
-  const optimisticMessageId = messageText(optimistic.id);
+  const canonicalMessageId = normalizeText(authored?.messageId);
+  const optimisticMessageId = normalizeText(optimistic.id);
   if (canonicalMessageId && optimisticMessageId) {
     return canonicalMessageId === optimisticMessageId;
   }
-  if (messageText(authored?.text) !== optimistic.text) {
+  if (normalizeText(authored?.text) !== optimistic.text) {
     return false;
   }
   const userAtMs = Date.parse(String(authored?.at || ""));
@@ -36,8 +35,11 @@ function unmatchedOptimisticMessages(turns = [], optimisticMessages = [], { rece
   });
 }
 
-// One delivery state per conversation. The caller owns transport and receipts;
-// the shared assistant element renders pending, failed and uncertain turns.
+/**
+ * One delivery state per conversation. The caller owns transport and receipts; the shared assistant element renders
+ * pending, failed and uncertain turns. A delivery made without `deliver` takes one with each `send()`.
+ * @param {{ deliver?: (payload: object) => unknown }} [options]
+ */
 function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
   const state = reactive({ messages: [], sending: false });
   const acceptanceCallbacks = new WeakMap();
@@ -118,7 +120,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     queue = false
   } = {}) {
     if ((state.sending && !queue) || pendingSends.has(messageId) || find(messageId)?.status === "uncertain" ||
-        find(messageId)?.cancelling || (!messageText(payload?.message) && !payload?.displayAttachments?.length)) return false;
+        find(messageId)?.cancelling || (!normalizeText(payload?.message) && !payload?.displayAttachments?.length)) return false;
     if (typeof deliver !== "function") throw new TypeError("Message delivery requires a deliver function.");
     const snapshot = JSON.parse(JSON.stringify(payload));
     const previous = find(messageId);
@@ -178,6 +180,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
       fail(messageId, error, uncertainOnError || error?.status === "uncertain" ? "uncertain" : "failed");
       throw error;
     } finally {
+      // readable-check: allow optional-call - optional operation: a send without receiptTurns starts no receipt watcher
       stopReceipt?.();
       ownerPendingSends.delete(messageId);
       if (pendingSends === ownerPendingSends) {
@@ -206,6 +209,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
       const entry = toRaw(message);
       const acknowledge = acceptanceCallbacks.get(entry);
       acceptanceCallbacks.delete(entry);
+      // readable-check: allow optional-call - optional operation: a message restored from history has no acceptance callback
       acknowledge?.();
     }
   }
@@ -223,7 +227,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
   }
 
   function restoreUncertain(request, savedTurns = []) {
-    const messageId = messageText(request?.messageId);
+    const messageId = normalizeText(request?.messageId);
     if (!messageId || savedTurns.some(turn => (turn.user || turn.system)?.messageId === messageId &&
         (turn.user || turn.system).receipt !== false) ||
         find(messageId)?.status === "accepted") return false;