@btst/stack 3.0.0-rc.2 → 3.0.0-rc.3

package/dist/packages/stack/src/plugins/ai-chat/client/components/chat-interface.mjs

@@ -1,23 +1,157 @@
 "use client";
 import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
 import { useChat } from '@ai-sdk/react';
-import { useMemo, useState, useRef, useEffect, useCallback } from 'react';
-import { useQueryClient } from '@tanstack/react-query';
+import { useId, useRef, useState, useMemo, useEffect, useCallback, useLayoutEffect } from 'react';
+import { useQueryClient, hashKey } from '@tanstack/react-query';
 import { ChatMessage } from './chat-message.mjs';
 import { ChatInput } from './chat-input.mjs';
 import { StackAttribution } from '../../../../../../ui/src/components/stack-attribution.mjs';
 import { ScrollArea } from '../../../../../../ui/src/components/scroll-area.mjs';
 import { DefaultChatTransport, lastAssistantMessageIsCompleteWithToolCalls } from 'ai';
 import { cn } from '../../../../../../ui/src/lib/utils.mjs';
-import { usePluginOverrides, useStack, useBasePath, useCan } from '@btst/stack/context';
+import { usePluginOverrides, useStack, PermissionCheck } from '@btst/stack/context';
+import { aiChatPermissions } from '../../../../../../../plugins/ai-chat/permissions.mjs';
+import { resolveAiChatApiUrl, resolveAiChatMode, resolveAiChatSiteLocation } from '../overrides.mjs';
 import { useAiChatTranslation } from '../localization/index.mjs';
 import { createApiClient } from '@btst/stack/plugins/client';
-import { createAiChatQueryKeys } from '../../../../../../../plugins/ai-chat/query-keys.mjs';
-import { useConversation, useConversations } from '../hooks/chat-hooks.mjs';
+import { aiChatIdentityKey, createAiChatQueryKeys } from '../../../../../../../plugins/ai-chat/query-keys.mjs';
+import { useAiChatIdentityPartition, useConversation, useConversations } from '../hooks/chat-hooks.mjs';
 import { usePageAIContext } from '../../../../../../../plugins/ai-chat/client/context/page-ai-context.mjs';
+import { navigateAiChatCrossOrigin } from '../navigation.mjs';
 
+function reconcilePersistedMessageIds(messages, persistedMessages) {
+  const userMessages = messages.filter((message) => message.role === "user");
+  const persistedUserMessages = persistedMessages.filter(
+    (message) => message.role === "user"
+  );
+  if (persistedUserMessages.length !== userMessages.length) return null;
+  const persistedIds = /* @__PURE__ */ new Map();
+  for (let index = 0; index < userMessages.length; index++) {
+    const message = userMessages[index];
+    const persisted = persistedUserMessages[index];
+    if (!message || !persisted) return null;
+    const serializedParts = JSON.stringify(message.parts);
+    const legacyText = message.parts.length === 1 && message.parts[0]?.type === "text" ? message.parts[0].text : void 0;
+    if (persisted.content !== serializedParts && persisted.content !== legacyText) {
+      return null;
+    }
+    persistedIds.set(message, persisted.id);
+  }
+  return messages.map((message) => ({
+    ...message,
+    id: persistedIds.get(message) ?? message.id
+  }));
+}
+function persistedMessagesToUiMessages(messages) {
+  return messages.filter((message) => message.role !== "data").map((message) => {
+    let parts;
+    try {
+      const parsed = JSON.parse(message.content);
+      parts = Array.isArray(parsed) ? parsed : [{ type: "text", text: message.content }];
+    } catch {
+      parts = [{ type: "text", text: message.content }];
+    }
+    return {
+      id: message.id,
+      role: message.role,
+      parts
+    };
+  });
+}
+function ChatActionCheck({
+  publicMode,
+  action,
+  conversationId,
+  ownerId,
+  messageId,
+  toolNames = [],
+  routeName,
+  children
+}) {
+  if (publicMode) return /* @__PURE__ */ jsx(Fragment, { children: children(true) });
+  const base = {
+    ...conversationId ? { conversationId } : {},
+    ...ownerId ? { ownerId } : {}
+  };
+  const streamPermission = aiChatPermissions.stream.start({
+    ...base,
+    createsConversation: !conversationId,
+    intent: action
+  });
+  const messagePermission = action === "send" ? aiChatPermissions.message.send({
+    ...base,
+    createsConversation: !conversationId
+  }) : action === "edit" && conversationId && messageId ? aiChatPermissions.message.edit({
+    conversationId,
+    ...ownerId ? { ownerId } : {},
+    messageId
+  }) : action === "retry" && conversationId && messageId ? aiChatPermissions.message.retry({
+    conversationId,
+    ...ownerId ? { ownerId } : {},
+    messageId
+  }) : null;
+  if (!messagePermission) return /* @__PURE__ */ jsx(Fragment, { children: children(false) });
+  return /* @__PURE__ */ jsx(PermissionCheck, { permission: streamPermission, children: (streamState) => /* @__PURE__ */ jsx(PermissionCheck, { permission: messagePermission, children: (messageState) => {
+    const baseAllowed = streamState.can && !streamState.isPending && !streamState.error && messageState.can && !messageState.isPending && !messageState.error;
+    const renderToolCheck = (allowed) => {
+      if (!allowed || toolNames.length === 0) return children(allowed);
+      return /* @__PURE__ */ jsx(
+        PermissionCheck,
+        {
+          permission: aiChatPermissions.tool.activate({
+            ...base,
+            ...routeName ? { routeName } : {},
+            toolNames: [...toolNames]
+          }),
+          children: (toolState) => children(
+            toolState.can && !toolState.isPending && !toolState.error
+          )
+        }
+      );
+    };
+    if (action !== "send" || conversationId) {
+      return renderToolCheck(Boolean(baseAllowed));
+    }
+    return /* @__PURE__ */ jsx(
+      PermissionCheck,
+      {
+        permission: aiChatPermissions.conversation.create(),
+        children: (createState) => renderToolCheck(
+          Boolean(baseAllowed) && createState.can && !createState.isPending && !createState.error
+        )
+      }
+    );
+  } }) });
+}
+function PermissionedChatMessage({
+  publicMode,
+  action,
+  conversationId,
+  ownerId,
+  messageId,
+  ...messageProps
+}) {
+  if (!action) return /* @__PURE__ */ jsx(ChatMessage, { ...messageProps });
+  return /* @__PURE__ */ jsx(
+    ChatActionCheck,
+    {
+      publicMode,
+      action,
+      conversationId,
+      ownerId,
+      messageId,
+      children: (allowed) => /* @__PURE__ */ jsx(
+        ChatMessage,
+        {
+          ...messageProps,
+          onRetry: allowed ? messageProps.onRetry : void 0,
+          onEdit: allowed ? messageProps.onEdit : void 0
+        }
+      )
+    }
+  );
+}
 function ChatInterface({
-  apiPath = "/api/chat",
   initialMessages,
   id,
   variant = "full",
@@ -26,39 +160,63 @@ function ChatInterface({
 }) {
   const {
     localization: customLocalization,
-    headers,
-    mode,
     showAttribution,
     chatSuggestions
   } = usePluginOverrides(
-    "ai-chat",
+    "aiChat",
     { showAttribution: true }
   );
-  const { api, router } = useStack();
-  const apiBaseURL = api?.baseURL;
-  const apiBasePath = api?.basePath;
-  router?.navigate;
-  const basePath = useBasePath();
+  const {
+    api,
+    basePath: stackBasePath,
+    plugins,
+    queryClient: stackQueryClient
+  } = useStack();
+  const aiChatApi = plugins?.aiChat?.api;
+  const apiBaseURL = aiChatApi?.baseURL ?? api?.baseURL;
+  const apiBasePath = aiChatApi?.basePath ?? api?.basePath;
+  const browserHeaders = aiChatApi?.browserHeaders;
+  const credentials = aiChatApi?.credentials;
+  const resolvedApiPath = resolveAiChatApiUrl(apiBaseURL, apiBasePath);
+  const mode = resolveAiChatMode(plugins?.aiChat?.config);
+  const siteBaseURL = plugins?.aiChat?.site.baseURL;
+  const siteBasePath = plugins?.aiChat?.site.basePath ?? stackBasePath;
   const isPublicMode = mode === "public";
   const pageAIContext = usePageAIContext();
   const tr = useAiChatTranslation(customLocalization);
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient(stackQueryClient);
+  const identityPartition = useAiChatIdentityPartition();
+  const chatInstanceId = useId();
+  const identityPartitionKey = hashKey([aiChatIdentityKey(identityPartition)]);
+  const latestIdentityPartitionKey = useRef(identityPartitionKey);
+  const identitySessionGeneration = useRef(0);
+  const [identitySessionVersion, setIdentitySessionVersion] = useState(0);
+  const activeStreamPartitionKey = useRef(void 0);
+  const nextStreamRequestGeneration = useRef(0);
+  const latestStreamRequestGeneration = useRef(0);
+  const pendingStreamRequests = useRef([]);
+  const latestMessages = useRef([]);
   const conversationsListQueryKey = useMemo(() => {
     if (isPublicMode) return ["ai-chat", "disabled"];
     const client = createApiClient({
       baseURL: apiBaseURL,
-      basePath: apiBasePath
+      basePath: apiBasePath,
+      credentials
     });
-    const queries = createAiChatQueryKeys(client, headers);
-    return queries.conversations.list().queryKey;
-  }, [apiBaseURL, apiBasePath, headers, isPublicMode]);
+    const queries = createAiChatQueryKeys(client, browserHeaders);
+    return queries.conversations.list(identityPartition).queryKey;
+  }, [
+    apiBaseURL,
+    apiBasePath,
+    browserHeaders,
+    credentials,
+    identityPartition,
+    isPublicMode
+  ]);
+  const latestIdentityPartition = useRef(identityPartition);
+  const latestConversationsListQueryKey = useRef(conversationsListQueryKey);
+  const latestHeaders = useRef(browserHeaders);
   const [currentConversationId, setCurrentConversationId] = useState(isPublicMode ? void 0 : id);
-  const { can: canPersistConversation, isPending: isPermissionPending } = useCan({
-    resource: "ai-chat:conversation",
-    action: currentConversationId ? "update" : "create",
-    params: currentConversationId ? { id: currentConversationId } : void 0
-  });
-  const canWrite = isPublicMode || !isPermissionPending && canPersistConversation;
   const isFirstMessageSentRef = useRef(false);
   const hasNavigatedRef = useRef(false);
   useEffect(() => {
@@ -74,6 +232,7 @@ function ChatInterface({
     { enabled: !!id && !isPublicMode }
   );
   const { conversations } = useConversations({ enabled: !isPublicMode });
+  const currentConversationOwnerId = conversation?.userId ?? conversations.find((item) => item.id === currentConversationId)?.userId ?? (!isPublicMode && currentConversationId && typeof identityPartition === "object" ? identityPartition.id : void 0);
   const conversationIdRef = useRef(
     isPublicMode ? void 0 : id
   );
@@ -90,23 +249,56 @@ function ChatInterface({
       !initialMessages || initialMessages.length === 0
     )
   );
+  const [input, setInput] = useState("");
+  const [attachedFiles, setAttachedFiles] = useState([]);
+  const [pendingEdit, setPendingEdit] = useState(null);
+  const [historySyncError, setHistorySyncError] = useState(null);
+  const [isHistorySyncRetrying, setIsHistorySyncRetrying] = useState(false);
+  useEffect(() => {
+    setHistorySyncError(null);
+    setIsHistorySyncRetrying(false);
+  }, [id, isPublicMode]);
   const pageAIContextRef = useRef(pageAIContext);
   useEffect(() => {
     pageAIContextRef.current = pageAIContext;
   }, [pageAIContext]);
-  const transport = useMemo(
-    () => new DefaultChatTransport({
-      api: apiPath,
+  const transport = useMemo(() => {
+    const trackedFetch = Object.assign(
+      async (request, init) => {
+        const requestIdentityPartitionKey = latestIdentityPartitionKey.current;
+        const requestGeneration = latestStreamRequestGeneration.current;
+        const response = await globalThis.fetch(request, init);
+        if (!isPublicMode && requestIdentityPartitionKey === latestIdentityPartitionKey.current && requestGeneration === latestStreamRequestGeneration.current) {
+          const conversationId = response.headers.get("x-conversation-id");
+          if (conversationId) conversationIdRef.current = conversationId;
+        }
+        return response;
+      },
+      globalThis.fetch
+    );
+    return new DefaultChatTransport({
+      api: resolvedApiPath,
+      headers: browserHeaders,
+      credentials,
+      fetch: trackedFetch,
       // In public mode, don't send conversationId
       body: isPublicMode ? void 0 : () => ({ conversationId: conversationIdRef.current }),
       // Handle edit operations and inject page context
       prepareSendMessagesRequest: ({ messages: hookMessages }) => {
+        if (!isPublicMode) {
+          const generation = ++nextStreamRequestGeneration.current;
+          latestStreamRequestGeneration.current = generation;
+          const request = {
+            generation,
+            identityPartitionKey: latestIdentityPartitionKey.current
+          };
+          pendingStreamRequests.current.push(request);
+          activeStreamPartitionKey.current = request.identityPartitionKey;
+        }
         const currentPageContext = pageAIContextRef.current;
         const pageContextBody = currentPageContext?.pageDescription ? {
           pageContext: currentPageContext.pageDescription,
-          availableTools: Object.keys(
-            currentPageContext.clientTools ?? {}
-          ),
+          availableTools: Object.keys(currentPageContext.clientTools ?? {}),
           routeName: currentPageContext.routeName
         } : {};
         if (editMessagesRef.current !== null) {
@@ -132,9 +324,8 @@ function ChatInterface({
           }
         };
       }
-    }),
-    [apiPath, isPublicMode]
-  );
+    });
+  }, [browserHeaders, credentials, isPublicMode, resolvedApiPath]);
   const addToolOutputRef = useRef(null);
   const {
     messages,
@@ -143,23 +334,34 @@ function ChatInterface({
     error,
     setMessages,
     regenerate,
-    addToolOutput
+    addToolOutput,
+    stop
   } = useChat({
+    id: `${chatInstanceId}:${isPublicMode ? "public" : identitySessionVersion}`,
     transport,
     // Automatically resubmit after all client-side tool results are provided
-    sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithToolCalls,
+    sendAutomaticallyWhen: (options) => (isPublicMode || identitySessionVersion === identitySessionGeneration.current) && lastAssistantMessageIsCompleteWithToolCalls(options),
     onToolCall: async ({ toolCall }) => {
+      const toolRequest = pendingStreamRequests.current.at(-1);
+      if (!isPublicMode && (identitySessionVersion !== identitySessionGeneration.current || !toolRequest || toolRequest.identityPartitionKey !== latestIdentityPartitionKey.current || toolRequest.generation !== latestStreamRequestGeneration.current || activeStreamPartitionKey.current !== toolRequest.identityPartitionKey)) {
+        return;
+      }
+      const toolIdentityPartitionKey = toolRequest?.identityPartitionKey ?? latestIdentityPartitionKey.current;
+      const toolStreamRequestGeneration = toolRequest?.generation ?? latestStreamRequestGeneration.current;
+      const toolRequestIsCurrent = () => isPublicMode || identitySessionVersion === identitySessionGeneration.current && toolIdentityPartitionKey === latestIdentityPartitionKey.current && toolStreamRequestGeneration === latestStreamRequestGeneration.current;
       const toolName = toolCall.toolName;
       const handler = pageAIContextRef.current?.clientTools?.[toolName];
       if (handler) {
         try {
           const result = await handler(toolCall.input);
+          if (!toolRequestIsCurrent()) return;
           addToolOutputRef.current?.({
             tool: toolName,
             toolCallId: toolCall.toolCallId,
             output: result
           });
         } catch (err) {
+          if (!toolRequestIsCurrent()) return;
           addToolOutputRef.current?.({
             tool: toolName,
             toolCallId: toolCall.toolCallId,
@@ -187,41 +389,251 @@ function ChatInterface({
     },
     onError: (err) => {
       console.error("useChat onError:", err);
-      if (!id && !hasNavigatedRef.current) {
-        isFirstMessageSentRef.current = false;
+      if (!isPublicMode && identitySessionVersion !== identitySessionGeneration.current) {
+        return;
+      }
+      const failedRequest = pendingStreamRequests.current[0];
+      const failedPartitionKey = failedRequest?.identityPartitionKey ?? activeStreamPartitionKey.current;
+      if (!isPublicMode && failedPartitionKey !== latestIdentityPartitionKey.current) {
+        return;
       }
     },
     onFinish: async () => {
-      if (isPublicMode) return;
-      await queryClient.invalidateQueries({
-        queryKey: conversationsListQueryKey
-      });
-      if (isFirstMessageSentRef.current && !id && !hasNavigatedRef.current) {
-        hasNavigatedRef.current = true;
-        await queryClient.refetchQueries({
-          queryKey: conversationsListQueryKey
+      if (isPublicMode) {
+        activeStreamPartitionKey.current = void 0;
+        return;
+      }
+      if (identitySessionVersion !== identitySessionGeneration.current) {
+        return;
+      }
+      const finishedRequest = pendingStreamRequests.current.shift();
+      const finishingPartitionKey = finishedRequest?.identityPartitionKey ?? activeStreamPartitionKey.current;
+      if (finishingPartitionKey !== latestIdentityPartitionKey.current) {
+        return;
+      }
+      if (!finishedRequest || finishedRequest.generation === latestStreamRequestGeneration.current) {
+        activeStreamPartitionKey.current = void 0;
+      }
+      const identityIsCurrent = () => finishingPartitionKey === latestIdentityPartitionKey.current && (!finishedRequest || finishedRequest.generation === latestStreamRequestGeneration.current);
+      const finishingIdentityPartition = latestIdentityPartition.current;
+      const finishingConversationsListQueryKey = latestConversationsListQueryKey.current;
+      const finishingHeaders = latestHeaders.current;
+      try {
+        await queryClient.invalidateQueries({
+          queryKey: finishingConversationsListQueryKey
         });
-        const cachedConversations = queryClient.getQueryData(conversationsListQueryKey);
-        if (cachedConversations && cachedConversations.length > 0) {
-          const newConversation = cachedConversations[0];
-          if (newConversation) {
-            setCurrentConversationId(newConversation.id);
-            conversationIdRef.current = newConversation.id;
+        if (!identityIsCurrent()) return;
+        if (isFirstMessageSentRef.current && !hasNavigatedRef.current) {
+          const discoveredConversationId = conversationIdRef.current;
+          if (discoveredConversationId) {
+            hasNavigatedRef.current = true;
+            setCurrentConversationId(discoveredConversationId);
+            conversationIdRef.current = discoveredConversationId;
             if (variant === "full") {
-              const newUrl = `${basePath}/chat/${newConversation.id}`;
+              const newLocation = resolveAiChatSiteLocation(
+                { baseURL: siteBaseURL, basePath: siteBasePath },
+                typeof window === "undefined" ? void 0 : window.location.origin,
+                "chat",
+                discoveredConversationId
+              );
               if (typeof window !== "undefined") {
-                window.history.replaceState(
-                  { ...window.history.state },
-                  "",
-                  newUrl
-                );
+                if (newLocation.crossOrigin) {
+                  navigateAiChatCrossOrigin(newLocation.href, {
+                    replace: true
+                  });
+                } else {
+                  window.history.replaceState(
+                    { ...window.history.state },
+                    "",
+                    newLocation.path
+                  );
+                }
               }
             }
           }
         }
+        const persistedConversationId = conversationIdRef.current;
+        if (!persistedConversationId || !identityIsCurrent()) {
+          if (isFirstMessageSentRef.current) {
+            isFirstMessageSentRef.current = false;
+            hasNavigatedRef.current = false;
+            throw new Error(
+              "The persisted conversation id could not be discovered."
+            );
+          }
+          return;
+        }
+        const client = createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath,
+          credentials
+        });
+        const detailQuery = createAiChatQueryKeys(
+          client,
+          finishingHeaders
+        ).conversations.detail(
+          persistedConversationId,
+          finishingIdentityPartition
+        );
+        await queryClient.cancelQueries({
+          queryKey: detailQuery.queryKey,
+          exact: true
+        });
+        if (!identityIsCurrent()) return;
+        queryClient.removeQueries({
+          queryKey: detailQuery.queryKey,
+          exact: true
+        });
+        const persistedConversation = await queryClient.fetchQuery({
+          ...detailQuery,
+          staleTime: 0
+        });
+        if (!identityIsCurrent() || !persistedConversation) return;
+        const reconciled = reconcilePersistedMessageIds(
+          latestMessages.current,
+          persistedConversation.messages
+        );
+        if (!reconciled) {
+          throw new Error(
+            "Persisted chat history did not match the streamed transcript."
+          );
+        }
+        setMessages(reconciled);
+        setHistorySyncError(null);
+      } catch (error2) {
+        if (!identityIsCurrent()) return;
+        const syncError = error2 instanceof Error ? error2 : new Error(String(error2));
+        console.error("Failed to reconcile persisted chat history:", syncError);
+        setHistorySyncError(syncError);
+        setMessages([]);
       }
     }
   });
+  const handleHistorySyncRetry = useCallback(async () => {
+    if (isPublicMode || isHistorySyncRetrying) return;
+    const retryConversationId = conversationIdRef.current;
+    if (!retryConversationId) {
+      setHistorySyncError(null);
+      return;
+    }
+    const retryPartitionKey = latestIdentityPartitionKey.current;
+    const retrySessionGeneration = identitySessionGeneration.current;
+    const retryIsCurrent = () => retryPartitionKey === latestIdentityPartitionKey.current && retrySessionGeneration === identitySessionGeneration.current && retryConversationId === conversationIdRef.current;
+    setIsHistorySyncRetrying(true);
+    try {
+      const client = createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath,
+        credentials
+      });
+      const detailQuery = createAiChatQueryKeys(
+        client,
+        latestHeaders.current
+      ).conversations.detail(
+        retryConversationId,
+        latestIdentityPartition.current
+      );
+      await queryClient.cancelQueries({
+        queryKey: detailQuery.queryKey,
+        exact: true
+      });
+      if (!retryIsCurrent()) return;
+      queryClient.removeQueries({
+        queryKey: detailQuery.queryKey,
+        exact: true
+      });
+      const persistedConversation = await queryClient.fetchQuery({
+        ...detailQuery,
+        staleTime: 0
+      });
+      if (!retryIsCurrent() || !persistedConversation) return;
+      if (isFirstMessageSentRef.current && !hasNavigatedRef.current) {
+        hasNavigatedRef.current = true;
+        setCurrentConversationId(retryConversationId);
+        if (variant === "full" && typeof window !== "undefined") {
+          const newLocation = resolveAiChatSiteLocation(
+            { baseURL: siteBaseURL, basePath: siteBasePath },
+            window.location.origin,
+            "chat",
+            retryConversationId
+          );
+          if (newLocation.crossOrigin) {
+            navigateAiChatCrossOrigin(newLocation.href, { replace: true });
+          } else {
+            window.history.replaceState(
+              { ...window.history.state },
+              "",
+              newLocation.path
+            );
+          }
+        }
+      }
+      setMessages(
+        persistedMessagesToUiMessages(persistedConversation.messages)
+      );
+      setHistorySyncError(null);
+    } catch (error2) {
+      if (!retryIsCurrent()) return;
+      const syncError = error2 instanceof Error ? error2 : new Error(String(error2));
+      console.error("Failed to reload persisted chat history:", syncError);
+      setHistorySyncError(syncError);
+    } finally {
+      if (retryIsCurrent()) setIsHistorySyncRetrying(false);
+    }
+  }, [
+    apiBasePath,
+    apiBaseURL,
+    credentials,
+    isHistorySyncRetrying,
+    isPublicMode,
+    queryClient,
+    setMessages,
+    siteBasePath,
+    siteBaseURL,
+    variant
+  ]);
+  useLayoutEffect(() => {
+    latestMessages.current = messages;
+  }, [messages]);
+  const previousIdentityPartition = useRef(identityPartitionKey);
+  useLayoutEffect(() => {
+    const nextPartition = identityPartitionKey;
+    latestIdentityPartitionKey.current = nextPartition;
+    latestIdentityPartition.current = identityPartition;
+    latestConversationsListQueryKey.current = conversationsListQueryKey;
+    latestHeaders.current = browserHeaders;
+    if (isPublicMode) return;
+    if (previousIdentityPartition.current === nextPartition) return;
+    previousIdentityPartition.current = nextPartition;
+    activeStreamPartitionKey.current = void 0;
+    pendingStreamRequests.current = [];
+    identitySessionGeneration.current += 1;
+    setIdentitySessionVersion(identitySessionGeneration.current);
+    latestStreamRequestGeneration.current = ++nextStreamRequestGeneration.current;
+    void stop();
+    setMessages([]);
+    setInput("");
+    setAttachedFiles([]);
+    setPendingEdit(null);
+    setHistorySyncError(null);
+    setIsHistorySyncRetrying(false);
+    editMessagesRef.current = null;
+    isEditInProgressRef.current = false;
+    setIsMessagesInitialized(true);
+    setCurrentConversationId(id);
+    conversationIdRef.current = id;
+    isFirstMessageSentRef.current = false;
+    hasNavigatedRef.current = false;
+  }, [
+    conversationsListQueryKey,
+    browserHeaders,
+    id,
+    identityPartition,
+    identityPartitionKey,
+    isPublicMode,
+    setMessages,
+    stop
+  ]);
   useEffect(() => {
     addToolOutputRef.current = addToolOutput;
   }, [addToolOutput]);
@@ -230,35 +642,15 @@ function ChatInterface({
       return;
     }
     if (conversation?.messages && conversation.messages.length > 0 && messages.length === 0) {
-      const uiMessages = conversation.messages.filter((m) => m.role !== "data").map((m) => {
-        let parts;
-        try {
-          const parsed = JSON.parse(m.content);
-          if (Array.isArray(parsed)) {
-            parts = parsed;
-          } else {
-            parts = [{ type: "text", text: m.content }];
-          }
-        } catch {
-          parts = [{ type: "text", text: m.content }];
-        }
-        return {
-          id: m.id,
-          role: m.role,
-          parts
-        };
-      });
-      setMessages(uiMessages);
+      setMessages(persistedMessagesToUiMessages(conversation.messages));
     }
   }, [conversation, messages.length, setMessages]);
   useEffect(() => {
-    if (initialMessages && initialMessages.length > 0 && messages.length === 0) {
+    if (!isMessagesInitialized && initialMessages && initialMessages.length > 0 && messages.length === 0) {
       setMessages(initialMessages);
       setIsMessagesInitialized(true);
     }
-  }, [initialMessages, setMessages, messages.length]);
-  const [input, setInput] = useState("");
-  const [attachedFiles, setAttachedFiles] = useState([]);
+  }, [initialMessages, isMessagesInitialized, setMessages, messages.length]);
   const scrollRef = useRef(null);
   const userHasScrolledRef = useRef(false);
   const prevStatusRef = useRef(status);
@@ -302,7 +694,6 @@ function ChatInterface({
   };
   const handleSubmit = async (e, files) => {
     e.preventDefault();
-    if (!canWrite) return;
     const text = input.trim();
     if (!text && (!files || files.length === 0)) return;
     if (!isPublicMode && !id && messages.length === 0) {
@@ -311,10 +702,14 @@ function ChatInterface({
     userHasScrolledRef.current = false;
     const savedInput = input;
     const savedFiles = files ? [...files] : [];
+    const sendIdentityPartitionKey = latestIdentityPartitionKey.current;
+    const sendIdentitySessionGeneration = identitySessionGeneration.current;
     const messageCountBeforeSend = messages.length;
     setInput("");
     setAttachedFiles([]);
+    setHistorySyncError(null);
     try {
+      activeStreamPartitionKey.current = latestIdentityPartitionKey.current;
       if (files && files.length > 0) {
         const fileUIParts = files.map((file) => ({
           type: "file",
@@ -322,15 +717,23 @@ function ChatInterface({
           url: file.url,
           filename: file.filename
         }));
-        await sendMessage({
+        const request = sendMessage({
           text: text || "",
           // AI SDK requires text, even if empty
           files: fileUIParts
         });
+        await request;
       } else {
-        await sendMessage({ text });
+        const request = sendMessage({ text });
+        await request;
       }
     } catch (error2) {
+      if (activeStreamPartitionKey.current === sendIdentityPartitionKey && sendIdentitySessionGeneration === identitySessionGeneration.current) {
+        activeStreamPartitionKey.current = void 0;
+      }
+      if (!isPublicMode && (sendIdentityPartitionKey !== latestIdentityPartitionKey.current || sendIdentitySessionGeneration !== identitySessionGeneration.current)) {
+        return;
+      }
       setInput(savedInput);
       setAttachedFiles(savedFiles);
       if (isFirstMessageSentRef.current && !hasNavigatedRef.current) {
@@ -342,19 +745,22 @@ function ChatInterface({
   };
   const isLoading = status === "streaming" || status === "submitted";
   const handleRetry = useCallback(() => {
+    setHistorySyncError(null);
+    activeStreamPartitionKey.current = latestIdentityPartitionKey.current;
     regenerate();
   }, [regenerate]);
-  const [pendingEdit, setPendingEdit] = useState(null);
   useEffect(() => {
-    if (pendingEdit && messages.length === pendingEdit.expectedLength) {
+    if (pendingEdit && pendingEdit.identityPartitionKey === latestIdentityPartitionKey.current && pendingEdit.streamRequestGeneration === latestStreamRequestGeneration.current && messages.length === pendingEdit.expectedLength) {
       const textToSend = pendingEdit.text;
       setPendingEdit(null);
       isEditInProgressRef.current = false;
+      activeStreamPartitionKey.current = latestIdentityPartitionKey.current;
       sendMessage({ text: textToSend });
     }
   }, [messages.length, pendingEdit, sendMessage]);
   const handleEditMessage = useCallback(
     (messageId, newText) => {
+      setHistorySyncError(null);
       const messageIndex = messages.findIndex((m) => m.id === messageId);
       if (messageIndex === -1) return;
       const messageToEdit = messages[messageIndex];
@@ -362,7 +768,12 @@ function ChatInterface({
       const truncatedMessages = messages.slice(0, messageIndex);
       isEditInProgressRef.current = true;
       editMessagesRef.current = truncatedMessages;
-      setPendingEdit({ text: newText, expectedLength: messageIndex });
+      setPendingEdit({
+        text: newText,
+        expectedLength: messageIndex,
+        identityPartitionKey: latestIdentityPartitionKey.current,
+        streamRequestGeneration: latestStreamRequestGeneration.current
+      });
       setMessages(truncatedMessages);
     },
     [messages, setMessages]
@@ -399,7 +810,7 @@ function ChatInterface({
                     ...pageSuggestions,
                     ...chatSuggestions ?? []
                   ];
-                  return canWrite && allSuggestions.length > 0 ? /* @__PURE__ */ jsx("div", { className: "flex flex-wrap justify-center gap-2 pb-4 max-w-md mx-auto", children: allSuggestions.map((suggestion, index) => /* @__PURE__ */ jsx(
+                  return allSuggestions.length > 0 ? /* @__PURE__ */ jsx("div", { className: "flex flex-wrap justify-center gap-2 pb-4 max-w-md mx-auto", children: allSuggestions.map((suggestion, index) => /* @__PURE__ */ jsx(
                     "button",
                     {
                       type: "button",
@@ -411,61 +822,96 @@ function ChatInterface({
                   )) }) : null;
                 })()
               ] }) : messages.map((m, index) => /* @__PURE__ */ jsx(
-                ChatMessage,
+                PermissionedChatMessage,
                 {
+                  publicMode: isPublicMode,
+                  action: m.role === "user" ? "edit" : m.role === "assistant" && index === messages.length - 1 ? "retry" : void 0,
+                  conversationId: currentConversationId,
+                  ownerId: currentConversationOwnerId,
+                  messageId: m.role === "assistant" ? [...messages].slice(0, index).reverse().find((message) => message.role === "user")?.id : m.id,
                   message: m,
                   isStreaming: status === "streaming" && m.id === messages[messages.length - 1]?.id && m.role === "assistant",
                   variant: isWidget ? "compact" : "default",
                   onRetry: (
                     // Only show retry on the last assistant message
-                    m.role === "assistant" && index === messages.length - 1 ? canWrite ? handleRetry : void 0 : void 0
+                    m.role === "assistant" && index === messages.length - 1 ? handleRetry : void 0
                   ),
                   onEdit: (
                     // Allow editing user messages
-                    m.role === "user" ? canWrite ? (newText) => handleEditMessage(m.id, newText) : void 0 : void 0
+                    m.role === "user" ? (newText) => handleEditMessage(m.id, newText) : void 0
                   ),
                   isRetrying: isLoading && m.role === "assistant"
                 },
                 m.id || `msg-${index}`
               )),
               isLoading && messages[messages.length - 1]?.role !== "assistant" && /* @__PURE__ */ jsx("div", { className: "flex items-center gap-2 text-muted-foreground text-sm py-4", children: /* @__PURE__ */ jsx("div", { className: "animate-pulse", children: tr("CHAT_LOADING", "aiChat.chat.loading", "Thinking...") }) }),
-              error && /* @__PURE__ */ jsx("div", { className: "flex items-center gap-2 text-destructive text-sm py-4 px-3 bg-destructive/10 rounded-md", children: /* @__PURE__ */ jsx("span", { children: tr(
-                "CHAT_ERROR",
-                "aiChat.chat.error",
-                "Something went wrong. Please try again."
-              ) }) })
+              (error || historySyncError) && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-destructive text-sm py-4 px-3 bg-destructive/10 rounded-md", children: [
+                /* @__PURE__ */ jsx("span", { className: "flex-1", children: tr(
+                  "CHAT_ERROR",
+                  "aiChat.chat.error",
+                  "Something went wrong. Please try again."
+                ) }),
+                historySyncError && /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    "data-testid": "chat-history-retry",
+                    onClick: () => void handleHistorySyncRetry(),
+                    disabled: isHistorySyncRetrying,
+                    className: "rounded-md border border-destructive/30 px-2.5 py-1 font-medium hover:bg-destructive/10 disabled:cursor-not-allowed disabled:opacity-50",
+                    children: tr("CHAT_RETRY", "aiChat.chat.retry", "Retry")
+                  }
+                )
+              ] })
             ]
           }
         ) })
       }
     ) }),
-    canWrite && /* @__PURE__ */ jsx(
-      "div",
+    /* @__PURE__ */ jsx(
+      ChatActionCheck,
       {
-        className: cn(
-          "border-t bg-background p-4",
-          isWidget ? "px-3 py-3" : "px-4"
-        ),
-        children: /* @__PURE__ */ jsxs("div", { className: cn(!isWidget && "max-w-3xl mx-auto"), children: [
-          /* @__PURE__ */ jsx(
-            ChatInput,
-            {
-              input,
-              handleInputChange,
-              handleSubmit,
-              isLoading,
-              placeholder: tr(
-                "CHAT_PLACEHOLDER",
-                "aiChat.chat.placeholder",
-                "Type a message..."
+        publicMode: isPublicMode,
+        action: "send",
+        conversationId: currentConversationId,
+        ownerId: currentConversationOwnerId,
+        toolNames: Object.keys(pageAIContext?.clientTools ?? {}),
+        routeName: pageAIContext?.routeName,
+        children: (allowed) => allowed && !historySyncError ? /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              "border-t bg-background p-4",
+              isWidget ? "px-3 py-3" : "px-4"
+            ),
+            children: /* @__PURE__ */ jsxs("div", { className: cn(!isWidget && "max-w-3xl mx-auto"), children: [
+              /* @__PURE__ */ jsx(
+                ChatInput,
+                {
+                  input,
+                  handleInputChange,
+                  handleSubmit,
+                  isLoading,
+                  placeholder: tr(
+                    "CHAT_PLACEHOLDER",
+                    "aiChat.chat.placeholder",
+                    "Type a message..."
+                  ),
+                  variant: isWidget ? "compact" : "default",
+                  onFilesAttached: setAttachedFiles,
+                  attachedFiles,
+                  allowAttachments: !isPublicMode,
+                  attachmentPermissionFacts: {
+                    ...currentConversationId ? { conversationId: currentConversationId } : {},
+                    ...currentConversationOwnerId ? { ownerId: currentConversationOwnerId } : {}
+                  }
+                },
+                isPublicMode ? "public" : identityPartitionKey
               ),
-              variant: isWidget ? "compact" : "default",
-              onFilesAttached: setAttachedFiles,
-              attachedFiles
-            }
-          ),
-          showAttribution && /* @__PURE__ */ jsx(StackAttribution, {})
-        ] })
+              showAttribution && /* @__PURE__ */ jsx(StackAttribution, {})
+            ] })
+          }
+        ) : null
       }
     )
   ] });