@arbidocs/react 0.5.111 → 0.5.112

package/dist/chat/conversation-cache.js

@@ -0,0 +1,676 @@
+import {
+  reduceOutputItem,
+  createIndexAssigner
+} from "@arbidocs/sdk/browser";
+import { arbiQueryKeys } from "../hooks.js";
+function getThreadsQueryKey(conversationId) {
+  return arbiQueryKeys.conversationThreads(conversationId);
+}
+const allConversationThreads = {
+  predicate: ({ queryKey }) => queryKey[0] === "arbi" && queryKey[1] === "conversations" && queryKey[3] === "threads"
+};
+function isMessageRunning(queryClient, conversationId, messageId) {
+  const data = queryClient.getQueryData(getThreadsQueryKey(conversationId));
+  return (data?.threads ?? []).some(
+    (t) => t.history.some(
+      (m) => m.external_id === messageId && (m.status === "in_progress" || m.status === "queued")
+    )
+  );
+}
+function addUserMessageToCache(queryClient, conversationId, userMessage, options) {
+  const { parentId, parentMessageId, currentParentMessageId } = options;
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) {
+        return {
+          conversation_ext_id: conversationId,
+          threads: [
+            {
+              history: [userMessage],
+              leaf_message_ext_id: userMessage.external_id
+            }
+          ]
+        };
+      }
+      const threads = [...oldData.threads || []];
+      const serverParentId = userMessage.parent_message_ext_id;
+      const serverParentKnown = !!serverParentId && threads.some((t) => t.history.some((msg) => msg.external_id === serverParentId));
+      const queuedLeafIndex = threads.findIndex(
+        (t) => t.history.some(
+          (msg) => msg.external_id === t.leaf_message_ext_id && msg.status === "queued"
+        )
+      );
+      const continueIndex = serverParentId && !serverParentKnown ? queuedLeafIndex : threads.findIndex((t) => t.leaf_message_ext_id === serverParentId);
+      if (serverParentId && continueIndex !== -1) {
+        threads[continueIndex] = {
+          ...threads[continueIndex],
+          history: [...threads[continueIndex].history, userMessage],
+          leaf_message_ext_id: userMessage.external_id
+        };
+        return { ...oldData, threads };
+      }
+      const branchFrom = serverParentKnown ? serverParentId : parentId;
+      const isBranching = serverParentKnown || parentId && parentId !== currentParentMessageId;
+      if (isBranching) {
+        let sharedHistory = [];
+        const parentThread = threads.find(
+          (thread) => thread.history.some((msg) => msg.external_id === branchFrom)
+        );
+        if (parentThread) {
+          const parentIndex = parentThread.history.findIndex(
+            (msg) => msg.external_id === branchFrom
+          );
+          if (parentIndex !== -1) {
+            sharedHistory = parentThread.history.slice(0, parentIndex + 1);
+          }
+        }
+        threads.push({
+          history: [...sharedHistory, userMessage],
+          leaf_message_ext_id: userMessage.external_id
+        });
+      } else if (parentMessageId) {
+        const threadIndex = threads.findIndex((t) => t.leaf_message_ext_id === parentMessageId);
+        if (threadIndex !== -1) {
+          threads[threadIndex] = {
+            ...threads[threadIndex],
+            history: [...threads[threadIndex].history, userMessage],
+            leaf_message_ext_id: userMessage.external_id
+          };
+        } else {
+          threads.push({
+            history: [userMessage],
+            leaf_message_ext_id: userMessage.external_id
+          });
+        }
+      } else {
+        if (threads.length > 0) {
+          threads[threads.length - 1] = {
+            ...threads[threads.length - 1],
+            history: [...threads[threads.length - 1].history, userMessage],
+            leaf_message_ext_id: userMessage.external_id
+          };
+        } else {
+          threads.push({
+            history: [userMessage],
+            leaf_message_ext_id: userMessage.external_id
+          });
+        }
+      }
+      return { ...oldData, threads };
+    }
+  );
+}
+function updateUserMessageInCache(queryClient, conversationId, userMessage) {
+  let found = false;
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      const updated = {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id === userMessage.external_id) {
+              found = true;
+              return { ...msg, ...userMessage };
+            }
+            return msg;
+          })
+        }))
+      };
+      return updated;
+    }
+  );
+  return found;
+}
+function updateUserMessageStateInCache(queryClient, conversationId, messageId, status, isLoading) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map(
+            (message) => message.external_id === messageId ? { ...message, status, isLoading } : message
+          )
+        }))
+      };
+    }
+  );
+}
+function completeQueuedUserMessageByContent(queryClient, conversationId, content) {
+  let completed = false;
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((message) => {
+            if (!completed && message.role === "user" && message.status === "queued" && message.content === content) {
+              completed = true;
+              return { ...message, status: "completed", isLoading: false };
+            }
+            return message;
+          })
+        }))
+      };
+    }
+  );
+  return completed;
+}
+function getInterjectionText(item) {
+  const candidate = item;
+  if (candidate?.type !== "reasoning" || candidate.arbi?.step !== "interjection" && candidate.arbi?.label !== "Your message") {
+    return null;
+  }
+  const text = Array.isArray(candidate.summary) ? candidate.summary.map((c) => c.text ?? "").join("") : "";
+  return text || null;
+}
+function threadEndingAtContains(queryClient, conversationId, leafId, messageId) {
+  const data = queryClient.getQueryData(getThreadsQueryKey(conversationId));
+  const thread = data?.threads?.find((t) => t.leaf_message_ext_id === leafId);
+  return !!thread?.history.some((m) => m.external_id === messageId);
+}
+function getRunStartedAt(queryClient, conversationId, messageId) {
+  const data = queryClient.getQueryData(getThreadsQueryKey(conversationId));
+  const message = data?.threads.flatMap((thread) => thread.history).find((m) => m.external_id === messageId);
+  const startedAt = message?.created_at ? Date.parse(message.created_at) : NaN;
+  return Number.isFinite(startedAt) ? Math.min(startedAt, Date.now()) : void 0;
+}
+function ensureAssistantMessageLoading(queryClient, conversationId, messageId) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      const exists = oldData.threads.some(
+        (t) => t.history.some((m) => m.external_id === messageId)
+      );
+      if (exists) {
+        return {
+          ...oldData,
+          threads: oldData.threads.map((thread) => ({
+            ...thread,
+            history: thread.history.map(
+              (msg) => msg.external_id === messageId ? { ...msg, isLoading: true } : msg
+            )
+          }))
+        };
+      }
+      const placeholder = {
+        role: "assistant",
+        content: "",
+        external_id: messageId,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        config_ext_id: null,
+        created_by_ext_id: "",
+        conversation_ext_id: conversationId,
+        tokens: 0,
+        status: "in_progress",
+        isLoading: true
+      };
+      return {
+        ...oldData,
+        threads: oldData.threads.map(
+          (thread, index) => index === oldData.threads.length - 1 ? {
+            ...thread,
+            history: [...thread.history, placeholder],
+            leaf_message_ext_id: placeholder.external_id
+          } : thread
+        )
+      };
+    }
+  );
+}
+function setMessageContent(queryClient, conversationId, messageId, content) {
+  discardStreamingTokensForMessage(conversationId, messageId);
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map(
+            (msg) => msg.external_id === messageId ? { ...msg, content } : msg
+          )
+        }))
+      };
+    }
+  );
+}
+function markNarrationSettled(queryClient, conversationId, messageId) {
+  flushStreamingTokens(queryClient);
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id !== messageId) return msg;
+            const settled = (msg.content ?? "").replace(/\s+$/, "");
+            if (!settled) return msg;
+            const content = `${settled}
+
+`;
+            return { ...msg, content, settledNarrationLength: content.length };
+          })
+        }))
+      };
+    }
+  );
+}
+function removeSettledNarration(queryClient, conversationId, messageId, itemContent) {
+  const text = Array.isArray(itemContent) ? itemContent.map((c) => c.text ?? "").join("") : "";
+  if (!text.trim()) return;
+  flushStreamingTokens(queryClient);
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id !== messageId) return msg;
+            const body = msg.content ?? "";
+            const at = body.lastIndexOf(text);
+            if (at === -1) return msg;
+            const rest = body.slice(0, at) + body.slice(at + text.length);
+            const content = rest.trim() ? rest : "";
+            const settled = Math.min(msg.settledNarrationLength ?? 0, content.length);
+            return { ...msg, content, settledNarrationLength: settled || void 0 };
+          })
+        }))
+      };
+    }
+  );
+}
+function addAssistantMessageToCache(queryClient, conversationId, assistantMessage, userMessageId) {
+  let placed = true;
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      const answerId = assistantMessage.external_id;
+      const stored = oldData.threads.some(
+        (t) => t.history.some((m) => m.external_id === answerId)
+      );
+      if (stored) {
+        return {
+          ...oldData,
+          threads: oldData.threads.map((thread) => ({
+            ...thread,
+            history: thread.history.map(
+              (m) => m.external_id === answerId ? { ...m, status: assistantMessage.status, isLoading: assistantMessage.isLoading } : m
+            )
+          }))
+        };
+      }
+      const leafIndex = userMessageId ? oldData.threads.findIndex((t) => t.leaf_message_ext_id === userMessageId) : -1;
+      let holderIndex = -1;
+      if (userMessageId && leafIndex === -1) {
+        oldData.threads.forEach((t, index) => {
+          if (t.history.some((m) => m.external_id === userMessageId)) holderIndex = index;
+        });
+      }
+      if (userMessageId && leafIndex === -1 && holderIndex === -1) placed = false;
+      const appendIndex = leafIndex !== -1 ? leafIndex : oldData.threads.length - 1;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread, index) => {
+          if (holderIndex !== -1) {
+            if (index !== holderIndex) return thread;
+            const at = thread.history.findIndex((m) => m.external_id === userMessageId);
+            const history = [...thread.history];
+            history.splice(at + 1, 0, assistantMessage);
+            return { ...thread, history };
+          }
+          if (index === appendIndex) {
+            return {
+              ...thread,
+              history: [...thread.history, assistantMessage],
+              leaf_message_ext_id: answerId
+            };
+          }
+          return thread;
+        })
+      };
+    }
+  );
+  return placed;
+}
+function applyTokenChunkToCache(queryClient, conversationId, messageId, chunk) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id === messageId) {
+              return { ...msg, content: msg.content + chunk };
+            }
+            return msg;
+          })
+        }))
+      };
+    }
+  );
+}
+const pendingTokens = /* @__PURE__ */ new Map();
+let rafHandle = null;
+let rafSchedule = null;
+let rafCancel = null;
+function getRafSchedule() {
+  if (rafSchedule) return rafSchedule;
+  if (typeof globalThis.requestAnimationFrame === "function") {
+    rafSchedule = (cb) => globalThis.requestAnimationFrame(cb);
+    rafCancel = (h) => globalThis.cancelAnimationFrame(h);
+  } else {
+    rafSchedule = (cb) => {
+      const id = setTimeout(cb, 16);
+      return id;
+    };
+    rafCancel = (h) => clearTimeout(h);
+  }
+  return rafSchedule;
+}
+function flushPendingTokens(queryClient) {
+  rafHandle = null;
+  if (pendingTokens.size === 0) return;
+  const entries = Array.from(pendingTokens.values());
+  pendingTokens.clear();
+  for (const entry of entries) {
+    if (entry.buffer.length === 0) continue;
+    applyTokenChunkToCache(queryClient, entry.conversationId, entry.messageId, entry.buffer);
+  }
+}
+function appendTokenToMessage(queryClient, conversationId, messageId, tokenContent) {
+  if (!tokenContent) return;
+  const key = `${conversationId}::${messageId}`;
+  const existing = pendingTokens.get(key);
+  if (existing) {
+    existing.buffer += tokenContent;
+  } else {
+    pendingTokens.set(key, { conversationId, messageId, buffer: tokenContent });
+  }
+  if (rafHandle === null) {
+    const schedule = getRafSchedule();
+    rafHandle = schedule(() => flushPendingTokens(queryClient));
+  }
+}
+function flushStreamingTokens(queryClient) {
+  if (rafHandle !== null && rafCancel) {
+    rafCancel(rafHandle);
+    rafHandle = null;
+  }
+  flushPendingTokens(queryClient);
+}
+function discardStreamingTokensForMessage(conversationId, messageId) {
+  pendingTokens.delete(`${conversationId}::${messageId}`);
+}
+function __resetStreamingTokenBufferForTests() {
+  if (rafHandle !== null && rafCancel) {
+    rafCancel(rafHandle);
+  }
+  rafHandle = null;
+  pendingTokens.clear();
+}
+const pendingFinalCommits = /* @__PURE__ */ new Map();
+const finalCommitKey = (conversationId, messageId) => `${conversationId}::${messageId}`;
+function hasPendingFinalCommit(conversationId, messageId) {
+  return pendingFinalCommits.has(finalCommitKey(conversationId, messageId));
+}
+function cancelPendingFinalCommit(conversationId, messageId) {
+  const key = finalCommitKey(conversationId, messageId);
+  const handle = pendingFinalCommits.get(key);
+  if (handle !== void 0) {
+    clearTimeout(handle);
+    pendingFinalCommits.delete(key);
+  }
+}
+function commitFinalMessage(queryClient, conversationId, messageId, metadata, notBefore = 0) {
+  cancelPendingFinalCommit(conversationId, messageId);
+  cancelPendingFinalCommit(conversationId, metadata.external_id);
+  const delay = Math.max(0, notBefore - Date.now());
+  if (delay === 0) {
+    updateMessageWithMetadata(queryClient, conversationId, messageId, metadata);
+    return;
+  }
+  flushStreamingTokens(queryClient);
+  const key = finalCommitKey(conversationId, metadata.external_id);
+  applyMetadata(queryClient, conversationId, messageId, metadata, { holdBody: true });
+  pendingFinalCommits.set(
+    key,
+    setTimeout(() => {
+      pendingFinalCommits.delete(key);
+      swapInFinalBody(queryClient, conversationId, metadata.external_id, metadata.content ?? "");
+    }, delay)
+  );
+}
+function swapInFinalBody(queryClient, conversationId, messageId, content) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map(
+            (msg) => msg.external_id === messageId ? { ...msg, content, isLoading: false } : msg
+          )
+        }))
+      };
+    }
+  );
+}
+function __resetPendingFinalCommitsForTests() {
+  for (const handle of pendingFinalCommits.values()) clearTimeout(handle);
+  pendingFinalCommits.clear();
+}
+function updateMessageWithMetadata(queryClient, conversationId, streamingMessageId, metadata) {
+  applyMetadata(queryClient, conversationId, streamingMessageId, metadata, { holdBody: false });
+}
+function applyMetadata(queryClient, conversationId, streamingMessageId, metadata, { holdBody }) {
+  if (!holdBody) discardStreamingTokensForMessage(conversationId, streamingMessageId);
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      const serverAssistantId = metadata.external_id;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id === streamingMessageId) {
+              return {
+                ...metadata,
+                isLoading: holdBody ? true : false,
+                content: holdBody ? msg.content : metadata.content,
+                agentSteps: msg.agentSteps,
+                pendingUserInput: msg.pendingUserInput,
+                // While the body is held for the narration dwell, the dimmed
+                // prose must stay dimmed: dropping the boundary here would
+                // un-fade it a beat before the swap, splitting the one resolving
+                // reflow in two.
+                settledNarrationLength: msg.settledNarrationLength
+              };
+            }
+            return msg;
+          }),
+          leaf_message_ext_id: thread.leaf_message_ext_id === streamingMessageId ? serverAssistantId : thread.leaf_message_ext_id
+        }))
+      };
+    }
+  );
+}
+function markMessageAsFailed(queryClient, conversationId, messageId) {
+  flushStreamingTokens(queryClient);
+  cancelPendingFinalCommit(conversationId, messageId);
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map(
+            (msg) => msg.external_id === messageId ? { ...msg, status: "failed", isLoading: false } : msg
+          )
+        }))
+      };
+    }
+  );
+}
+function clearLoadingState(queryClient, conversationId) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map(
+            (msg) => msg.isLoading && !hasPendingFinalCommit(conversationId, msg.external_id ?? "") ? { ...msg, isLoading: false } : msg
+          )
+        }))
+      };
+    }
+  );
+}
+function applyOutputItemToMessage(queryClient, conversationId, messageId, ev) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id !== messageId) return msg;
+            const existing = msg.agentSteps || [];
+            const { assign, resolve } = createIndexAssigner(existing);
+            const updated = reduceOutputItem(existing, ev, assign, resolve);
+            return updated === existing ? msg : { ...msg, agentSteps: updated };
+          })
+        }))
+      };
+    }
+  );
+  const arbi = ev.item?.arbi;
+  if ((arbi?.subagent_status === "done" || arbi?.subagent_status === "failed") && arbi.task_message_ext_id) {
+    queryClient.invalidateQueries({ queryKey: getThreadsQueryKey(conversationId) });
+  }
+}
+function applyFinalContextToMessage(queryClient, conversationId, messageId, context) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map(
+            (msg) => msg.external_id === messageId ? { ...msg, finalContextUsage: context } : msg
+          )
+        }))
+      };
+    }
+  );
+}
+function setUserInputRequest(queryClient, conversationId, messageId, request) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id === messageId) {
+              return { ...msg, pendingUserInput: request };
+            }
+            return msg;
+          })
+        }))
+      };
+    }
+  );
+}
+function resetMessageContent(queryClient, conversationId, messageId) {
+  setMessageContent(queryClient, conversationId, messageId, "");
+}
+function clearUserInputRequest(queryClient, conversationId, messageId) {
+  queryClient.setQueryData(
+    getThreadsQueryKey(conversationId),
+    (oldData) => {
+      if (!oldData) return oldData;
+      return {
+        ...oldData,
+        threads: oldData.threads.map((thread) => ({
+          ...thread,
+          history: thread.history.map((msg) => {
+            if (msg.external_id === messageId) {
+              return { ...msg, pendingUserInput: null };
+            }
+            return msg;
+          })
+        }))
+      };
+    }
+  );
+}
+export {
+  __resetPendingFinalCommitsForTests,
+  __resetStreamingTokenBufferForTests,
+  addAssistantMessageToCache,
+  addUserMessageToCache,
+  allConversationThreads,
+  appendTokenToMessage,
+  applyFinalContextToMessage,
+  applyOutputItemToMessage,
+  clearLoadingState,
+  clearUserInputRequest,
+  commitFinalMessage,
+  completeQueuedUserMessageByContent,
+  discardStreamingTokensForMessage,
+  ensureAssistantMessageLoading,
+  flushStreamingTokens,
+  getInterjectionText,
+  getRunStartedAt,
+  getThreadsQueryKey,
+  hasPendingFinalCommit,
+  isMessageRunning,
+  markMessageAsFailed,
+  markNarrationSettled,
+  removeSettledNarration,
+  resetMessageContent,
+  setMessageContent,
+  setUserInputRequest,
+  threadEndingAtContains,
+  updateMessageWithMetadata,
+  updateUserMessageInCache,
+  updateUserMessageStateInCache
+};
+//# sourceMappingURL=conversation-cache.js.map