@dbx-tools/ui-mastra 0.9.129 → 0.9.132

package/src/react/mastra-chat.tsx

@@ -1,6 +1,7 @@
 import { errorUtils, hash, log } from "@dbx-tools/shared-core";
 import { isStaleMastraResumeError } from "@dbx-tools/shared-mastra/resume";
 import type { ReasoningEffort } from "@dbx-tools/shared-model";
+import { getAuthStatus } from "@dbx-tools/ui/auth/react";
 import { useBrand } from "@dbx-tools/ui/branding/react";
 import type { FileUIPart, UIMessage } from "ai";
 import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from "react";
@@ -9,7 +10,7 @@ import { useChatApprovals } from "./chat-approvals.ts";
 import { useChatFeedback } from "./chat-feedback.ts";
 import { useChatHistory } from "./chat-history.ts";
 import { useChatSessions } from "./chat-sessions.ts";
-import { useChatStream } from "./chat-stream.ts";
+import { useChatStream, waitForTerminalChunk } from "./chat-stream.ts";
 import { ChatView } from "./chat-view.tsx";
 import { dedupeSuggestions } from "./suggestions.ts";
 import type { ChatViewProps, ThreadPlacement, ThreadSummary } from "./types.ts";
@@ -20,8 +21,10 @@ import {
   storeActiveRun,
 } from "../support/active-runs.ts";
 import type { EmbedResolver, ExportFormat } from "../support/export.ts";
+import { GenieChatClient } from "../support/genie-client.ts";
 import {
   useMastraClient,
+  useMastraConfig,
   useMastraDefaultModel,
   useMastraMlflowExperiment,
   useMastraModels,
@@ -42,10 +45,13 @@ import {
   type MastraRequestContextSnapshot,
   type MastraRequestContextSource,
 } from "../support/request-context.ts";
+import { threadStorageKey } from "../support/thread-persistence.ts";
 import {
   DEFAULT_THREAD_SESSION_KEY,
   enqueueSteer,
+  interruptedTurnMessages,
   isSessionRunning,
+  lastUserMessage,
   removeSteer as removeSteerFromQueue,
   reorderSteers as reorderSteerQueue,
 } from "../support/thread-sessions.ts";
@@ -53,11 +59,13 @@ import {
 const _loadChatExport = () => import("../support/export.ts");
 const EMPTY_REASONING_EFFORTS: readonly ReasoningEffort[] = [];
 
-// Self-contained drop-in chat. `useMastraChat` drives the conversation
-// over `@mastra/client-js`: `agent.stream()` returns a Response
-// augmented with `processDataStream()`, which pushes typed Mastra
-// chunks that `@mastra/ai-sdk` projects into native AI SDK `UIMessage`
-// parts for `ChatView` to render.
+/** Why the active managed thread changed. */
+export type ThreadIdChangeReason = "hydrate" | "select" | "new" | "delete" | "missing" | "resolve";
+
+// Self-contained drop-in chat. `useMastraChat` consumes native AI SDK
+// `UIMessage` streams through one client contract: Mastra agents use the
+// official chat route and direct Genie projects its events onto that wire.
+// `ChatView` and the thread session state are transport-agnostic.
 //
 // Approval gates ride the same channel: a paused `requireApproval: true`
 // tool call emits a `tool-call-approval` chunk carrying
@@ -102,14 +110,6 @@ const deriveThreadTitle = (text: string): string => {
   return clean.length > TITLE_PREVIEW_MAX ? `${clean.slice(0, TITLE_PREVIEW_MAX - 1)}…` : clean;
 };
 
-/**
- * `localStorage` key the active thread id is persisted under, namespaced
- * by plugin mount + agent so two agents (or two apps on one origin)
- * don't clobber each other's "current conversation".
- */
-const threadStorageKey = (basePath: string, agentId: string): string =>
-  `dbx-mastra-thread:${basePath}:${agentId}`;
-
 /** Read the persisted active thread id, tolerating storage being unavailable. */
 const readStoredThreadId = (key: string): string | undefined => {
   try {
@@ -162,9 +162,19 @@ export interface UseMastraChatOptions<
 > {
   /**
    * Agent to converse with. Defaults to the Mastra plugin's registered
-   * default agent (`clientConfig().defaultAgent`).
+   * default agent (`clientConfig().defaultAgent`). Ignored when
+   * {@link genieSpace} is set.
    */
   agentId?: string;
+  /**
+   * Converse with this Genie space alias directly instead of an agent. Every
+   * turn is one Genie message streamed as an `ask_genie` tool call, so pills,
+   * thoughts, suggestions, and embeds render exactly as in an agent chat.
+   * Genie owns the state: its conversations are the threads and its messages
+   * are the history; nothing is stored in Mastra Memory. Conversations cannot
+   * be renamed, turns take no attachments, and feedback is unavailable.
+   */
+  genieSpace?: string;
   /**
    * Surface the built-in model picker in the header, letting the user
    * override the serving endpoint per turn (via `X-Mastra-Model`).
@@ -202,6 +212,17 @@ export interface UseMastraChatOptions<
    * chat's own width, so an embedded panel decides on its own space).
    */
   threadPlacement?: ThreadPlacement;
+  /**
+   * Host-selected managed thread id. Use this to restore a thread from a URL
+   * or another external state owner. Changes after mount switch the active
+   * conversation without remounting the chat.
+   */
+  threadId?: string;
+  /**
+   * Receives every chat-owned thread change. Missing externally selected
+   * threads are replaced with a new local thread and reported as `"missing"`.
+   */
+  onThreadIdChange?: (threadId: string, reason: ThreadIdChangeReason) => void;
   /**
    * Enable chat export. Off by default (opt-in). When on, the header
    * shows an "Export" menu for the whole conversation and each assistant
@@ -251,9 +272,20 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
   // stable across renders (memoized on `basePath` / `defaultAgent`) so
   // using it as a hook dep doesn't refire the initial-history fetch on
   // every parent render.
-  const mastraClient = useMastraClient();
-  const agentId = options.agentId ?? mastraClient.defaultAgent;
-  const showModelPicker = Boolean(options.showModelPicker);
+  const pluginClient = useMastraClient();
+  const mastraConfig = useMastraConfig();
+  const genieSpace = options.genieSpace?.trim() || undefined;
+  const genieClient = useMemo(
+    () => (genieSpace ? new GenieChatClient(mastraConfig, genieSpace) : undefined),
+    // Same scalars `useMastraClient` keys on; `mastraConfig` identity churns.
+    [genieSpace, mastraConfig.basePath, mastraConfig.defaultAgent],
+  );
+  const mastraClient = genieClient ?? pluginClient;
+  // Genie chats key persisted state (active thread, sidebar) by space alias.
+  const agentId = genieSpace
+    ? `genie:${genieSpace}`
+    : (options.agentId ?? mastraClient.defaultAgent);
+  const showModelPicker = Boolean(options.showModelPicker) && !genieSpace;
   const modelKey = modelStorageKey(mastraClient.basePath, agentId);
   const [model, setModel] = useState(() => (showModelPicker ? readStoredModel(modelKey) : ""));
   const [reasoningEffort, setReasoningEffort] = useState<ReasoningEffort | undefined>();
@@ -299,21 +331,89 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
   const enableFeedback = options.enableFeedback !== false;
   const feedbackAvailable = enableFeedback && mastraClient.feedbackEnabled;
   const { url: mlflowExperimentUrl } = useMastraMlflowExperiment(feedbackAvailable);
-  const threadKey = threadStorageKey(mastraClient.basePath, agentId);
-  const activeRunsKey = activeRunStorageKey(mastraClient.basePath, agentId);
-  const [activeThreadId, setActiveThreadId] = useState<string>(() =>
-    enableThreads ? (readStoredThreadId(threadKey) ?? hash.id()) : hash.id(),
+  const [resourceScope, setResourceScope] = useState<string | null>(null);
+  useEffect(() => {
+    let cancelled = false;
+    void getAuthStatus()
+      .then((status) => {
+        if (cancelled) return;
+        setResourceScope(
+          status.enabled && status.authenticated ? (status.email?.trim().toLowerCase() ?? "") : "",
+        );
+      })
+      .catch(() => {
+        if (!cancelled) setResourceScope("");
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const persistenceReady = resourceScope !== null;
+  const threadKey = persistenceReady
+    ? threadStorageKey(mastraClient.basePath, agentId, resourceScope || undefined)
+    : undefined;
+  const activeRunsKey = activeRunStorageKey(
+    mastraClient.basePath,
+    agentId,
+    persistenceReady ? resourceScope || undefined : "pending",
   );
+  const requestedThreadId = options.threadId?.trim() || undefined;
+  const localThreadIdsRef = useRef(new Set<string>());
+  const emittedThreadIdRef = useRef<string | undefined>(undefined);
+  const threadIdChangeRef = useRef(options.onThreadIdChange);
+  threadIdChangeRef.current = options.onThreadIdChange;
+  const [activeThreadId, setActiveThreadId] = useState<string>(() => {
+    const id = requestedThreadId ?? hash.id();
+    if (!requestedThreadId) localThreadIdsRef.current.add(id);
+    return id;
+  });
+  const mintThreadId = useCallback(() => {
+    const id = hash.id();
+    localThreadIdsRef.current.add(id);
+    return id;
+  }, []);
+  const activateThread = useCallback((threadId: string, reason: ThreadIdChangeReason) => {
+    emittedThreadIdRef.current = threadId;
+    setActiveThreadId(threadId);
+    threadIdChangeRef.current?.(threadId, reason);
+  }, []);
+  const initializedThreadKeyRef = useRef<string | undefined>(undefined);
+  const [hydratedThreadKey, setHydratedThreadKey] = useState<string | undefined>(undefined);
+  useEffect(() => {
+    if (!enableThreads || !threadKey || initializedThreadKeyRef.current === threadKey) return;
+    initializedThreadKeyRef.current = threadKey;
+    const storedThreadId = readStoredThreadId(threadKey);
+    const threadId = requestedThreadId ?? storedThreadId ?? mintThreadId();
+    setActiveThreadId(threadId);
+    threadIdChangeRef.current?.(threadId, "hydrate");
+    setHydratedThreadKey(threadKey);
+  }, [enableThreads, mintThreadId, requestedThreadId, threadKey]);
+  useEffect(() => {
+    if (
+      enableThreads &&
+      hydratedThreadKey === threadKey &&
+      requestedThreadId &&
+      requestedThreadId !== activeThreadId
+    ) {
+      if (emittedThreadIdRef.current === activeThreadId) return;
+      setActiveThreadId(requestedThreadId);
+    } else if (requestedThreadId === activeThreadId) {
+      emittedThreadIdRef.current = undefined;
+    }
+  }, [activeThreadId, enableThreads, hydratedThreadKey, requestedThreadId, threadKey]);
   const {
     threads,
     loading: isLoadingThreads,
+    error: threadsError,
     refresh: refreshThreads,
-  } = useMastraThreads(options.agentId, enableThreads);
+  } = useMastraThreads(options.agentId, enableThreads, genieClient);
   // Persist the active thread id so a reload reopens the same
   // conversation. Best-effort; storage may be unavailable.
   useEffect(() => {
-    if (enableThreads && activeThreadId) storeStoredThreadId(threadKey, activeThreadId);
-  }, [enableThreads, threadKey, activeThreadId]);
+    if (enableThreads && threadKey && hydratedThreadKey === threadKey && activeThreadId) {
+      storeStoredThreadId(threadKey, activeThreadId);
+    }
+  }, [enableThreads, threadKey, hydratedThreadKey, activeThreadId]);
   // Conversation sidebar show/hide, persisted so the user's choice
   // sticks across reloads. The view exposes a header toggle wired to
   // `onToggleSidebar`; defaults open the first time.
@@ -409,6 +509,7 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
   const { questions: genieSuggestions } = useMastraSuggestions(
     options.agentId,
     explicitSuggestions === undefined,
+    genieClient,
   );
   const suggestions = useMemo(
     () => explicitSuggestions ?? dedupeSuggestions(genieSuggestions),
@@ -418,12 +519,46 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
     activeKey,
     activeSession,
     getSession,
+    moveSession,
     removeSession,
     resetSession,
     streamingThreadIds,
     updateSession,
     writeMessages,
   } = useChatSessions(activeThreadId);
+  useEffect(() => {
+    if (
+      !enableThreads ||
+      hydratedThreadKey !== threadKey ||
+      !requestedThreadId ||
+      activeThreadId !== requestedThreadId ||
+      isLoadingThreads ||
+      threadsError ||
+      localThreadIdsRef.current.has(requestedThreadId) ||
+      optimisticThreads[requestedThreadId] ||
+      threads.some((thread) => thread.id === requestedThreadId) ||
+      readStoredActiveRuns(activeRunsKey).some((run) => run.threadId === requestedThreadId)
+    ) {
+      return;
+    }
+    const replacement = mintThreadId();
+    resetSession(replacement, true);
+    activateThread(replacement, "missing");
+  }, [
+    activateThread,
+    activeRunsKey,
+    activeThreadId,
+    enableThreads,
+    hydratedThreadKey,
+    isLoadingThreads,
+    mintThreadId,
+    optimisticThreads,
+    requestedThreadId,
+    resetSession,
+    threadKey,
+    threads,
+    threadsError,
+  ]);
   const historyAvailability = isLoadingThreads
     ? "loading"
     : threads.some((thread) => thread.id === activeThreadId) || optimisticThreads[activeThreadId]
@@ -451,6 +586,33 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
   // stale-closure hazard (assigned each render, same pattern as `loadMoreRef`).
   const drainQueueRef = useRef<(threadId: string) => void>(() => {});
 
+  const activeThreadIdRef = useRef(activeThreadId);
+  activeThreadIdRef.current = activeThreadId;
+  // Adopt the server-assigned id of a thread that streamed under a local id
+  // (a new Genie conversation): move its session and sidebar overlays, then
+  // switch to it when it is still the active thread.
+  const adoptThreadId = useCallback(
+    (localId: string, assignedId: string) => {
+      moveSession(localId, assignedId);
+      localThreadIdsRef.current.delete(localId);
+      localThreadIdsRef.current.add(assignedId);
+      setOptimisticThreads((prev) => {
+        const row = prev[localId];
+        if (!row) return prev;
+        const { [localId]: _drop, ...rest } = prev;
+        return { ...rest, [assignedId]: { ...row, id: assignedId } };
+      });
+      setProvisionalTitles((prev) => {
+        const title = prev[localId];
+        if (title === undefined) return prev;
+        const { [localId]: _drop, ...rest } = prev;
+        return { ...rest, [assignedId]: title };
+      });
+      if (activeThreadIdRef.current === localId) activateThread(assignedId, "resolve");
+    },
+    [activateThread, moveSession],
+  );
+
   const processStream = useChatStream({ getSession, updateSession, writeMessages });
   const driveStream = useCallback(
     async (
@@ -474,10 +636,20 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
         };
       });
       const runIdRef = { current: getSession(threadId).runId };
+      // The session's key; changes when the server assigns the thread its id.
+      let sessionThreadId = threadId;
+      let openedStream: MastraStreamResponse | undefined;
+      const adoptAssignedThreadId = () => {
+        const assigned = openedStream?.threadId?.();
+        if (!assigned || assigned === sessionThreadId) return;
+        adoptThreadId(sessionThreadId, assigned);
+        sessionThreadId = assigned;
+      };
       try {
         try {
-          const stream = await open(controller.signal);
-          await processStream(threadId, stream, assistantId, runIdRef, controller.signal);
+          openedStream = await open(controller.signal);
+          await processStream(threadId, openedStream, assistantId, runIdRef, controller.signal);
+          adoptAssignedThreadId();
         } catch (initialError) {
           const runId = runIdRef.current;
           if (
@@ -512,7 +684,7 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
             throw reconnectError;
           }
         }
-        updateSession(threadId, (session) => {
+        updateSession(sessionThreadId, (session) => {
           if (session.runToken !== token) return session;
           return {
             ...session,
@@ -522,14 +694,17 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
             runId: runIdRef.current,
           };
         });
-        if (getSession(threadId).runToken === token) {
+        if (getSession(sessionThreadId).runToken === token) {
           const completedRunId = runIdRef.current;
           if (completedRunId) removeStoredActiveRun(activeRunsKey, completedRunId);
           refreshThreadsSoon();
           // Turn finished on its own: start the oldest queued steer, if any.
-          drainQueueRef.current(threadId);
+          drainQueueRef.current(sessionThreadId);
         }
       } catch (caught) {
+        // A failed turn may still have created its server-side thread.
+        adoptAssignedThreadId();
+        const threadId = sessionThreadId;
         if (getSession(threadId).runToken !== token) return;
         if (isStaleMastraResumeError(caught)) {
           logger.warn("ignored stale mastra resume", {
@@ -567,6 +742,7 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
       }
     },
     [
+      adoptThreadId,
       agentId,
       activeRunsKey,
       getSession,
@@ -579,16 +755,25 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
   );
 
   const runStream = useCallback(
-    (threadId: string, message: UIMessage, requestContext?: MastraRequestContextSnapshot) => {
+    (
+      threadId: string,
+      messages: UIMessage | UIMessage[],
+      requestContext?: MastraRequestContextSnapshot,
+    ) => {
+      const turnMessages = Array.isArray(messages) ? messages : [messages];
+      const userMessage = lastUserMessage(turnMessages);
+      if (!userMessage) throw new Error("A Mastra chat turn requires a user message");
       const assistantId = hash.id();
       const runId = hash.id();
-      storeActiveRun(activeRunsKey, {
-        threadId,
-        runId,
-        assistantId,
-        userMessage: message,
-        startedAt: Date.now(),
-      });
+      if (mastraClient.backgroundTurns) {
+        storeActiveRun(activeRunsKey, {
+          threadId,
+          runId,
+          assistantId,
+          userMessage,
+          startedAt: Date.now(),
+        });
+      }
       updateSession(threadId, (session) => ({
         ...session,
         assistantId,
@@ -612,7 +797,7 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
       return driveStream(threadId, assistantId, (signal) => {
         return mastraClient.streamAgent({
           agentId,
-          messages: [message],
+          messages: turnMessages,
           runId,
           threadId: streamThreadId,
           model,
@@ -627,7 +812,19 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
 
   const recoveredRunsKeyRef = useRef<string | undefined>(undefined);
   useEffect(() => {
-    if (!mastraClient.backgroundTurns || recoveredRunsKeyRef.current === activeRunsKey) return;
+    if (!persistenceReady || mastraClient.backgroundTurns) return;
+    for (const run of readStoredActiveRuns(activeRunsKey)) {
+      removeStoredActiveRun(activeRunsKey, run.runId);
+    }
+  }, [activeRunsKey, mastraClient.backgroundTurns, persistenceReady]);
+  useEffect(() => {
+    if (
+      !persistenceReady ||
+      !mastraClient.backgroundTurns ||
+      recoveredRunsKeyRef.current === activeRunsKey
+    ) {
+      return;
+    }
     recoveredRunsKeyRef.current = activeRunsKey;
     for (const run of readStoredActiveRuns(activeRunsKey)) {
       const session = getSession(run.threadId);
@@ -664,7 +861,16 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
         if (history) writeMessages(run.threadId, toChronologicalUiMessages(history));
       });
     }
-  }, [activeRunsKey, agentId, driveStream, getSession, mastraClient, updateSession, writeMessages]);
+  }, [
+    activeRunsKey,
+    agentId,
+    driveStream,
+    getSession,
+    mastraClient,
+    persistenceReady,
+    updateSession,
+    writeMessages,
+  ]);
 
   // Start the oldest queued steer as the next turn (FIFO drain). Called from
   // `driveStream` when a turn ends normally; a no-op when the queue is empty.
@@ -734,6 +940,56 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
     updateSession,
   });
 
+  /** Abort the active run and wait until its durable stream reaches a terminal event. */
+  const interruptActiveRun = useCallback(
+    async (threadId: string): Promise<void> => {
+      const current = getSession(threadId);
+      if (!isSessionRunning(current)) return;
+      const streamThreadId = threadId === DEFAULT_THREAD_SESSION_KEY ? undefined : threadId;
+      const runId = current.runId;
+      const settlement =
+        mastraClient.backgroundTurns && runId
+          ? mastraClient
+              .observeAgentStream({ agentId, runId, threadId: streamThreadId })
+              .then((stream) => waitForTerminalChunk(stream.stream))
+              .catch((error: unknown) => {
+                logger.warn("failed to observe interrupted background run", {
+                  runId,
+                  error: errorUtils.toError(error),
+                });
+              })
+          : undefined;
+      const serverAbort =
+        mastraClient.backgroundTurns && runId
+          ? mastraClient
+              .abortAgentRun({ agentId, runId, threadId: streamThreadId })
+              .then((aborted) => {
+                if (aborted) removeStoredActiveRun(activeRunsKey, runId);
+              })
+              .catch((error: unknown) => {
+                logger.warn("failed to abort interrupted background run", {
+                  runId,
+                  error: errorUtils.toError(error),
+                });
+              })
+          : undefined;
+      current.abortController?.abort();
+      updateSession(threadId, (session) => {
+        if (!isSessionRunning(session)) return session;
+        return {
+          ...session,
+          abortController: null,
+          runToken: session.runToken + 1,
+          error: null,
+          status: "submitted",
+        };
+      });
+      await serverAbort;
+      await settlement;
+    },
+    [activeRunsKey, agentId, getSession, mastraClient, updateSession],
+  );
+
   // Append a user message to a thread's transcript, update thread activity,
   // and derive a provisional title for a brand-new thread.
   const appendUserMessage = useCallback(
@@ -800,17 +1056,25 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
   const sendSteerNow = useCallback(
     (steerId: string) => {
       const threadId = activeKey;
-      const steer = getSession(threadId).queuedSteers.find((s) => s.id === steerId);
+      const current = getSession(threadId);
+      const steer = current.queuedSteers.find((s) => s.id === steerId);
       if (!steer) return;
       updateSession(threadId, (session) => ({
         ...session,
         queuedSteers: removeSteerFromQueue(session.queuedSteers, steerId),
       }));
       logger.info("steer:send-now", { threadId });
-      const { message } = appendUserMessage(threadId, steer.text ?? "", steer.files);
-      void runStream(threadId, message, steer.requestContext);
+      void (async () => {
+        await interruptActiveRun(threadId);
+        const { message } = appendUserMessage(threadId, steer.text ?? "", steer.files);
+        void runStream(
+          threadId,
+          interruptedTurnMessages(current.messages, message),
+          steer.requestContext,
+        );
+      })();
     },
-    [activeKey, appendUserMessage, getSession, runStream, updateSession],
+    [activeKey, appendUserMessage, getSession, interruptActiveRun, runStream, updateSession],
   );
 
   // Drop a queued steer without sending it.
@@ -870,16 +1134,16 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
   const selectThread = useCallback(
     (threadId: string) => {
       if (threadId === activeThreadId) return;
-      setActiveThreadId(threadId);
+      activateThread(threadId, "select");
     },
-    [activeThreadId],
+    [activateThread, activeThreadId],
   );
 
   const newThread = useCallback(() => {
-    const id = hash.id();
+    const id = mintThreadId();
     resetSession(id, true);
-    setActiveThreadId(id);
-  }, [resetSession]);
+    activateThread(id, "new");
+  }, [activateThread, mintThreadId, resetSession]);
 
   const deleteThread = useCallback(
     async (threadId: string) => {
@@ -896,9 +1160,9 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
         return rest;
       });
       if (threadId === activeThreadId) {
-        const id = hash.id();
+        const id = mintThreadId();
         resetSession(id, true);
-        setActiveThreadId(id);
+        activateThread(id, "delete");
       }
       try {
         await mastraClient.removeThread(threadId, { agentId });
@@ -917,7 +1181,16 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
         });
       }
     },
-    [activeThreadId, agentId, mastraClient, refreshThreads, removeSession, resetSession],
+    [
+      activateThread,
+      activeThreadId,
+      agentId,
+      mastraClient,
+      mintThreadId,
+      refreshThreads,
+      removeSession,
+      resetSession,
+    ],
   );
 
   /**
@@ -1011,6 +1284,7 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
     () => ({
       chart: (id) => mastraClient.chart(id),
       statement: (id) => mastraClient.statement(id),
+      visualization: (id) => mastraClient.visualization(id),
     }),
     [mastraClient],
   );
@@ -1185,7 +1459,8 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
     onLoadMore: loadOlderHistory,
     isLoadingMore,
     hasMore: activeSession.hasMoreHistory,
-    isLoadingHistory,
+    isLoadingHistory: !persistenceReady || isLoadingHistory,
+    ...(mastraClient.attachments ? {} : { allowAttachments: false }),
     ...(enableClear ? { onClear: handleClear } : {}),
     threadPlacement,
     // Conversation management: hand ChatView the thread list + handlers
@@ -1200,7 +1475,7 @@ export const useMastraChat = <TValues extends Record<string, unknown> = Record<s
           onSelectThread: selectThread,
           onNewThread: newThread,
           onDeleteThread: deleteThread,
-          onRenameThread: renameThread,
+          ...(mastraClient.threadRename ? { onRenameThread: renameThread } : {}),
           // Cancel a background thread's run from the sidebar without
           // switching to it.
           onCancelThread: stop,

package/src/react/types.ts

@@ -207,6 +207,8 @@ export type ChatViewProps = {
    * footer, after Upload and before Export and Clear.
    */
   composerLeadingActions?: ReactNode;
+  /** Whether the composer accepts image attachments. Defaults to true. */
+  allowAttachments?: boolean;
   /**
    * Optional infinite-scroll-up handler. Fired when the user scrolls
    * within `TOP_LOAD_MORE_THRESHOLD_PX` of the top of the

package/src/support/active-runs.ts

@@ -37,8 +37,14 @@ const StoredActiveRunFileSchema = z
 type StorageLike = Pick<Storage, "getItem" | "setItem" | "removeItem">;
 
 /** Build the browser storage key for one Mastra agent's active runs. */
-export const activeRunStorageKey = (basePath: string, agentId: string): string =>
-  `dbx-mastra-active-runs:${basePath}:${agentId}`;
+export const activeRunStorageKey = (
+  basePath: string,
+  agentId: string,
+  resourceScope?: string,
+): string => {
+  const prefix = `dbx-mastra-active-runs:${basePath}:${agentId}`;
+  return resourceScope ? `${prefix}:${encodeURIComponent(resourceScope)}` : prefix;
+};
 
 function browserStorage(): StorageLike | undefined {
   try {