glirastes 0.3.2 → 0.5.0

package/dist/react/provider/ai-chat-provider.js

@@ -2,8 +2,21 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useState, useRef, useCallback, useMemo, useEffect, } from 'react';
 import { getThemeEffect, getThemeVars } from '../themes.js';
 import { ChatContext } from './chat-context.js';
-import { serializeMentionsForSend } from '../utils/mention-markup.js';
+import { normalizeMentionSlug, serializeMentionsForSend } from '../utils/mention-markup.js';
 import { mergePipelineSteps } from '../utils/merge-pipeline-steps.js';
+import { collectEntityNames } from '../utils/entity-names.js';
+import { createApprovalDescriptionGenerator } from '../utils/create-approval-description.js';
+import { languageLocale, parseToolPresentation, usePageLanguage } from '../utils/tool-presentation.js';
+import { resolveToolResultConfig } from '../utils/tool-result-config.js';
+import { extractTrailingFollowupSuggestions } from '../utils/followup-suggestions.js';
+import { clarificationAnswerMessage, findOpenClarification } from '../utils/clarification.js';
+import { createCompletionSearch } from '../completions/completion-search.js';
+import { toChatEntityItem } from '../interactions/definitions.js';
+import { createChatInteractionRegistry, } from '../interactions/registry.js';
+import { createToolResultRendererRegistry } from '../tool-renderers/registry.js';
+import { dispatchToolResultUiActions } from '../../browser/client-actions.js';
+import { getDefaultUiActionBus } from '../../browser/ui-action-bus.js';
+import { CLARIFICATION_MAX_ANSWER_LENGTH, parseClarificationAnswer, } from '../../contracts/clarification.js';
 export const DEFAULT_LOCALE = {
     placeholder: 'Type a message...',
     sendButton: 'Send',
@@ -20,6 +33,7 @@ export const DEFAULT_LOCALE = {
     dismissButton: 'Dismiss',
     cancelButton: 'Cancel',
     confirmButton: 'Confirm',
+    approvalPendingHint: 'Please approve or reject the open request first.',
     moreItemsLabel: 'more',
     allCountLabel: 'All {count}',
     pipelineTitle: 'Pipeline',
@@ -30,6 +44,12 @@ export const DEFAULT_LOCALE = {
     pipelineErrorLabel: 'Error',
     pipelineStepLabel: 'Step',
     pipelineApprovalPendingLabel: 'Approval pending',
+    activityWorkingLabel: 'Working',
+    activityWaitingLabel: 'Waiting for approval',
+    activityDoneLabel: '{count} steps done',
+    activityDoneOneLabel: '1 step done',
+    activityFailedLabel: '{count} failed',
+    planTitle: 'Plan',
     chatTitle: 'AI Assistant',
     closeChatAriaLabel: 'Close chat',
     clearChatAriaLabel: 'Clear conversation',
@@ -41,10 +61,23 @@ export const DEFAULT_LOCALE = {
     newChatLabel: 'New chat',
     noSessionsLabel: 'No conversations yet',
     sessionsLoadingLabel: 'Loading…',
+    untitledSessionLabel: 'Untitled',
     deleteSessionAriaLabel: 'Delete conversation',
     confirmDeleteSessionPrompt: 'Delete this conversation?',
+    sessionArchiveMessage: '"{title}" will be archived.',
     renameSessionAriaLabel: 'Rename conversation',
     renameSessionPlaceholder: 'Conversation title',
+    clarificationInputLabel: 'Your answer',
+    clarificationSubmitButton: 'Answer',
+    retryRecordingAriaLabel: 'Retry recording',
+    completionListLabel: 'Suggestions',
+    completionResultsLabel: '{count} suggestions',
+    commandArgumentsLabel: 'Details for {command}',
+    commandArgumentsSubmit: 'Run',
+    commandArgumentsInvalid: 'These values are too long.',
+    commandArgumentsIncomplete: 'Please complete: {fields}',
+    commandArgumentsAnyOption: 'Any',
+    commandArgumentsNoMatches: 'No matches',
 };
 // ============================================================================
 // Helpers
@@ -91,16 +124,6 @@ function getMentionTypesForTrigger(types, trigger) {
     }
     return types;
 }
-/** Default approval description — returns raw tool name and JSON args */
-function defaultApprovalDescription(toolName, approvalId, args) {
-    return {
-        id: approvalId,
-        toolName,
-        args: isRecord(args) ? args : {},
-        messageId: '',
-        description: toolName,
-    };
-}
 /**
  * Remove orphaned tool calls (approval-requested without response)
  * from message history to prevent AI_MissingToolResultsError.
@@ -229,7 +252,8 @@ function normalizePipelineState(data) {
     }
     if (data.stepLimitSource !== 'explicit' &&
         data.stepLimitSource !== 'module' &&
-        data.stepLimitSource !== 'safety') {
+        data.stepLimitSource !== 'safety' &&
+        data.stepLimitSource !== 'runtime-budget') {
         return null;
     }
     return {
@@ -273,28 +297,69 @@ function normalizePipelineState(data) {
  * }
  * ```
  */
-export function AiChatProvider({ transport, mentions, toolResults: userToolResults, voice: userVoice, session, classNames: userClassNames, components: userComponents, suggestions: userSuggestions, locale: userLocale, theme: userTheme, onToolResult, onBeforeSend, approvalDescription: userApprovalDescription, continueMessage = 'Please continue.', toolLabels: userToolLabels, pipelineMessageTranslator, stepSummaryFormatter, children, }) {
-    // Merge caller-supplied locale overrides with English defaults.
-    const locale = useMemo(() => ({ ...DEFAULT_LOCALE, ...(userLocale ?? {}) }), [userLocale]);
+export function AiChatProvider({ transport, mentions, completionProviders, completionContext, onCompletionProviderError, chatInteractions, toolRenderers, toolResults: userToolResults, voice: userVoice, session, classNames: userClassNames, components: userComponents, suggestions: userSuggestions, locale: userLocale, theme: userTheme, themeScope = 'inline', unstyled = false, onToolResult, uiActionBus, onBeforeSend, approvalDescription: userApprovalDescription, continueMessage = 'Please continue.', toolLabels: userToolLabels, pipelineMessageTranslator, stepSummaryFormatter, children, }) {
+    // What the chat turn says about its tools (label per model name, app
+    // language) and the language of the page: the defaults of a chat that
+    // configures neither `locale`, `toolLabels` nor `approvalDescription`.
+    const [toolPresentation, setToolPresentation] = useState(null);
+    const pageLanguage = usePageLanguage();
+    const language = toolPresentation?.locale ?? pageLanguage;
+    // English defaults, then the built-in texts of the app's language, then the caller's overrides.
+    const locale = useMemo(() => ({ ...DEFAULT_LOCALE, ...languageLocale(language), ...(userLocale ?? {}) }), [userLocale, language]);
     // Resolve `theme` prop → CSS variables spread onto widget roots.
-    const themeVars = useMemo(() => getThemeVars(userTheme), [userTheme]);
+    const themeVars = useMemo(() => (themeScope === 'inherit' || unstyled ? {} : getThemeVars(userTheme)), [userTheme, themeScope, unstyled]);
     const themeEffect = useMemo(() => getThemeEffect(userTheme), [userTheme]);
     const classNames = useMemo(() => userClassNames ?? {}, [userClassNames]);
     const components = useMemo(() => userComponents ?? {}, [userComponents]);
     const suggestionsConfig = useMemo(() => ({ enabled: true, count: 3, autoSuggest: true, ...userSuggestions }), [userSuggestions]);
-    const toolResultConfig = useMemo(() => ({ mode: 'default', allowlist: [], ...userToolResults }), [userToolResults]);
+    const toolResultConfig = useMemo(() => resolveToolResultConfig(userToolResults, Boolean(toolRenderers && toolRenderers.length > 0)), [userToolResults, toolRenderers]);
+    const toolRendererRegistry = useMemo(() => (toolRenderers && toolRenderers.length > 0
+        ? createToolResultRendererRegistry(toolRenderers)
+        : undefined), [toolRenderers]);
     const voiceConfig = useMemo(() => ({
         enabled: false,
         language: 'de',
         recordingBar: { enabled: true, variant: 'inline', ...(userVoice?.recordingBar ?? {}) },
         ...userVoice,
     }), [userVoice]);
-    const toolLabels = useMemo(() => userToolLabels ?? {}, [userToolLabels]);
-    const approvalDescriptionFn = userApprovalDescription ?? defaultApprovalDescription;
+    // The labels of the turn's tools, each used for one call and for several; the caller's labels win.
+    const toolLabels = useMemo(() => ({
+        labels: {
+            ...Object.fromEntries(Object.entries(toolPresentation?.labels ?? {})
+                .map(([name, label]) => [name, { singular: label, plural: label }])),
+            ...(userToolLabels?.labels ?? {}),
+        },
+    }), [toolPresentation, userToolLabels]);
+    // Without the app's own description, an approval names the action by its
+    // label and lists what the call states, instead of the raw tool name alone.
+    const derivedApprovalDescription = useMemo(() => {
+        const actions = Object.fromEntries(Object.entries(toolLabels.labels ?? {})
+            .map(([name, label]) => [name, label.singular]));
+        const describe = createApprovalDescriptionGenerator({ toolLabels: actions, dateLocale: language ?? 'en-US' });
+        return (toolName, approvalId, args, context) => {
+            const pending = describe(toolName, approvalId, args, context);
+            return actions[toolName] ? pending : { ...pending, description: toolName };
+        };
+    }, [toolLabels, language]);
+    const approvalDescriptionFn = userApprovalDescription ?? derivedApprovalDescription;
     // Approvals state (Map for O(1) lookup)
     const [pendingApprovalsMap, setPendingApprovalsMap] = useState(new Map());
-    const [processingApprovalId, setProcessingApprovalId] = useState(null);
+    // Set when the user sends while an approval waits; cleared once none waits.
+    const [approvalReminder, setApprovalReminder] = useState(false);
+    useEffect(() => {
+        if (pendingApprovalsMap.size === 0)
+            setApprovalReminder(false);
+    }, [pendingApprovalsMap]);
+    const [processingApprovalIds, setProcessingApprovalIds] = useState(new Set());
+    const [approvalError, setApprovalError] = useState(null);
     const [isInitialized, setIsInitialized] = useState(false);
+    // A completed load belongs to one session, not to the provider forever.
+    // Otherwise a render with a new id can persist the previous session's rows.
+    const [loadedSessionId, setLoadedSessionId] = useState(null);
+    const [sessionLoadFailure, setSessionLoadFailure] = useState(null);
+    const [sessionRestoreAttempt, setSessionRestoreAttempt] = useState(0);
+    const [isSessionMutating, setIsSessionMutating] = useState(false);
+    const sessionMutationRef = useRef(false);
     // ---------------------------------------------------------------------------
     // Multi-session state
     //
@@ -306,6 +371,9 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
     const [uncontrolledActiveId, setUncontrolledActiveId] = useState(() => session?.activeId ?? session?.defaultActiveId ?? 'default');
     const activeSessionId = session?.activeId ?? uncontrolledActiveId;
     const [sessions, setSessions] = useState([]);
+    const isBootstrapSentinel = activeSessionId === 'default'
+        && session?.list !== undefined && session.defaultActiveId === undefined
+        && session.activeId === undefined && !sessions.some((entry) => entry.id === 'default');
     const [isSessionsLoading, setIsSessionsLoading] = useState(false);
     const sessionsSupported = Boolean(session && session.list && session.create && session.remove);
     // Keep a ref so callbacks inside effects read the current session config
@@ -327,16 +395,40 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
     const [mentionResults, setMentionResults] = useState([]);
     const [activeMentions, setActiveMentions] = useState([]);
     const [isMentionSearching, setIsMentionSearching] = useState(false);
+    const onCompletionProviderErrorRef = useRef(onCompletionProviderError);
+    onCompletionProviderErrorRef.current = onCompletionProviderError;
+    // Declarative `@` entities and `/` commands join the app's own providers.
+    const interactionRegistry = useMemo(() => (chatInteractions
+        ? createChatInteractionRegistry({ ...chatInteractions, context: completionContext })
+        : undefined), [chatInteractions, completionContext]);
+    const allCompletionProviders = useMemo(() => [...(completionProviders ?? []), ...(interactionRegistry?.providers ?? [])], [completionProviders, interactionRegistry]);
+    const completionSearch = useMemo(() => (allCompletionProviders.length > 0
+        ? createCompletionSearch(allCompletionProviders, {
+            context: completionContext,
+            onProviderError: (providerId, error) => onCompletionProviderErrorRef.current?.(providerId, error),
+        })
+        : undefined), [allCompletionProviders, completionContext]);
+    const [pendingCommand, setPendingCommand] = useState(null);
+    const [composerMentions, setComposerMentions] = useState([]);
     // Refs for deduplication
     const processedToolCallsRef = useRef(new Set());
     const handledApprovalIdsRef = useRef(new Set());
     // Stable refs for callbacks to avoid re-creating transport
     const onToolResultRef = useRef(onToolResult);
     onToolResultRef.current = onToolResult;
+    const uiActionBusRef = useRef(uiActionBus);
+    uiActionBusRef.current = uiActionBus;
     const approvalDescriptionRef = useRef(approvalDescriptionFn);
     approvalDescriptionRef.current = approvalDescriptionFn;
     // Data part handler — processes pipeline and truncation events from any transport
     const handleDataPart = useCallback((dataPart) => {
+        if (dataPart.type === 'data-tool-presentation') {
+            const next = parseToolPresentation(dataPart.data);
+            // Every turn sends it again; keep the object while its content is the same.
+            if (next)
+                setToolPresentation((current) => (JSON.stringify(current) === JSON.stringify(next) ? current : next));
+            return;
+        }
         if (dataPart.type === 'data-truncation') {
             const data = dataPart.data;
             setTruncation({
@@ -370,8 +462,12 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
     useEffect(() => {
         return resolvedTransport.subscribeToData?.(handleDataPart);
     }, [resolvedTransport, handleDataPart]);
-    const { messages: rawMessages, sendMessage, status, error, stop: transportStop, setMessages, addToolApprovalResponse, } = resolvedTransport;
+    const { messages: rawMessages, sendMessage, status, error: transportError, stop: transportStop, setMessages, addToolApprovalResponse, } = resolvedTransport;
     const isLoading = status === 'submitted' || status === 'streaming';
+    const streamActiveRef = useRef(isLoading);
+    streamActiveRef.current = isLoading;
+    const sessionNotReady = Boolean(session?.load && loadedSessionId !== activeSessionId);
+    const error = transportError ?? (sessionLoadFailure?.id === activeSessionId ? sessionLoadFailure.error : null);
     useEffect(() => {
         if (!error)
             return;
@@ -382,7 +478,7 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
             maxSteps: prev?.maxSteps ?? 1,
             stepLimitSource: prev?.stepLimitSource ?? 'safety',
             updatedAt: new Date().toISOString(),
-            message: typeof error.message === 'string' ? error.message : 'Pipeline failed.',
+            message: 'Pipeline failed.',
         }));
     }, [error, pipelineSteps.length]);
     // Mark stored messages as already processed (prevents re-dispatching tool results)
@@ -411,11 +507,21 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
             }
         }
     }, []);
+    // An open approval belongs to the chat that asked for it. A host that owns
+    // the active id switches chats without switchSession(), so drop it here.
+    const approvalSessionRef = useRef(activeSessionId);
+    useEffect(() => {
+        if (approvalSessionRef.current === activeSessionId)
+            return;
+        approvalSessionRef.current = activeSessionId;
+        setPendingApprovalsMap(new Map());
+    }, [activeSessionId]);
     // Load messages from session whenever the active session changes.
     // Runs on mount and on every switchSession() call.
     useEffect(() => {
         const cfg = sessionRef.current;
         if (!cfg?.load) {
+            setLoadedSessionId(activeSessionId);
             if (!isInitialized)
                 setIsInitialized(true);
             return;
@@ -424,15 +530,15 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         // active — `'default'` is unlikely to be a valid session id in the
         // consumer's backend, and the auto-select effect (below) will switch
         // us to the first real session as soon as `list()` resolves.
-        const isBootstrapSentinel = activeSessionId === 'default' &&
-            cfg.list !== undefined &&
-            cfg.activeId === undefined;
         if (isBootstrapSentinel) {
             if (!isInitialized)
                 setIsInitialized(true);
             return;
         }
         let cancelled = false;
+        setLoadedSessionId(null);
+        setSessionLoadFailure(null);
+        setMessages([]);
         (async () => {
             try {
                 const loaded = await Promise.resolve(cfg.load(activeSessionId));
@@ -440,6 +546,9 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
                     return;
                 processedToolCallsRef.current.clear();
                 handledApprovalIdsRef.current.clear();
+                // The transport may still have held the previous chat's messages
+                // until now; an approval read from them is not this chat's.
+                setPendingApprovalsMap(new Map());
                 // Coerce wire-shape rows (with `content: string`) into SDK
                 // messages (with `parts: [...]`) so bridges don't have to.
                 const coerced = loaded ? coerceLoadedMessages(loaded) : [];
@@ -451,11 +560,13 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
                 else {
                     setMessages([]);
                 }
+                setLoadedSessionId(activeSessionId);
             }
-            catch (err) {
+            catch {
                 if (cancelled)
                     return;
-                console.warn(`[AiChatProvider] session.load("${activeSessionId}") failed:`, err);
+                console.warn('[AiChatProvider] session.load failed');
+                setSessionLoadFailure({ id: activeSessionId, error: new Error('Chat history could not be loaded. Reopen this chat to retry.') });
                 setMessages([]);
             }
             finally {
@@ -468,18 +579,20 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         };
         // rawMessages intentionally excluded — we only re-load on session switch.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [activeSessionId, setMessages, markStoredMessagesAsProcessed]);
+    }, [activeSessionId, setMessages, markStoredMessagesAsProcessed, sessionRestoreAttempt, isBootstrapSentinel]);
     // Save messages to session on change (scoped to the active session).
     useEffect(() => {
         if (!isInitialized)
             return;
+        if (loadedSessionId !== activeSessionId)
+            return;
         if (rawMessages.length === 0)
             return;
         const cfg = sessionRef.current;
         if (!cfg?.save)
             return;
         void Promise.resolve(cfg.save(activeSessionId, rawMessages));
-    }, [rawMessages, isInitialized, activeSessionId]);
+    }, [rawMessages, isInitialized, activeSessionId, loadedSessionId]);
     // Process tool results and approvals from streaming messages
     useEffect(() => {
         if (rawMessages.length === 0)
@@ -499,7 +612,7 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
                     toolPart.approval?.id &&
                     !handledApprovalIdsRef.current.has(toolPart.approval.id)) {
                     handledApprovalIdsRef.current.add(toolPart.approval.id);
-                    const pending = approvalDescriptionRef.current(toolName, toolPart.approval.id, toolPart.input);
+                    const pending = approvalDescriptionRef.current(toolName, toolPart.approval.id, toolPart.input, { names: collectEntityNames(rawMessages) });
                     setPendingApprovalsMap(prev => new Map(prev).set(toolPart.approval.id, pending));
                 }
                 // Tool result available — call onToolResult
@@ -508,12 +621,17 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
                     if (!processedToolCallsRef.current.has(toolCallId)) {
                         processedToolCallsRef.current.add(toolCallId);
                         onToolResultRef.current?.(toolName, toolPart.output);
+                        // Generated UI tools run in the browser through the app's bridge.
+                        void dispatchToolResultUiActions(toolPart.output, uiActionBusRef.current ?? getDefaultUiActionBus()).catch(() => {
+                            console.warn('[glirastes] A generated UI action failed');
+                        });
                     }
                 }
             }
         }
     }, [rawMessages]);
-    // Extract suggestions from suggest_followups tool
+    // Extract suggestions from suggest_followups tool, with a strict text
+    // fallback for models that append a trailing Markdown suggestion section.
     useEffect(() => {
         if (rawMessages.length === 0)
             return;
@@ -523,6 +641,7 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
             const message = rawMessages[messageIndex];
             if (message.role !== 'assistant')
                 continue;
+            let structuredFollowups = null;
             for (const part of message.parts) {
                 if (!('type' in part))
                     continue;
@@ -538,7 +657,21 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
                     continue;
                 const followups = result.followups.filter((f) => typeof f === 'string' && f.trim().length > 0);
                 if (followups.length > 0) {
-                    latestFollowups = followups.slice(0, count);
+                    structuredFollowups = followups.slice(0, count);
+                }
+            }
+            if (structuredFollowups && structuredFollowups.length > 0) {
+                latestFollowups = structuredFollowups;
+            }
+            else {
+                for (const part of message.parts) {
+                    if (!isRecord(part) || part.type !== 'text' || typeof part.text !== 'string') {
+                        continue;
+                    }
+                    const extracted = extractTrailingFollowupSuggestions(part.text, count);
+                    if (extracted.suggestions.length > 0) {
+                        latestFollowups = extracted.suggestions;
+                    }
                 }
             }
             if (latestFollowups && latestFollowups.length > 0) {
@@ -601,21 +734,19 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         };
     }, [mentionQuery, mentionTrigger, mentions]);
     // Actions
-    const send = useCallback(async (message) => {
+    // The shared tail of every send: transport hygiene, then the transport.
+    const deliver = useCallback(async (processedMessage) => {
+        // An open approval is decided on its card. A typed "yes" must not count as
+        // approval, and rejecting it on send dropped requests the user wanted.
+        if (pendingApprovalsMap.size > 0) {
+            setApprovalReminder(true);
+            return;
+        }
         // Clear truncation and suggestion chips on new message
         setTruncation(null);
         setSuggestionChips([]);
         setPipelineSteps([]);
         setPipelineState(null);
-        // Preprocess message
-        let processedMessage = message;
-        const mentionSerializeConfig = mentions?.serialize;
-        if (mentionSerializeConfig?.enabled !== false) {
-            processedMessage = serializeMentionsForSend(processedMessage, activeMentions, mentionSerializeConfig);
-        }
-        if (onBeforeSend) {
-            processedMessage = onBeforeSend(processedMessage, activeMentions);
-        }
         // Sanitize messages before sending to prevent AI_MissingToolResultsError
         const currentMessages = rawMessages;
         const sanitized = sanitizeMessages(currentMessages);
@@ -623,18 +754,6 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
             setMessages(sanitized);
             setPendingApprovalsMap(new Map());
         }
-        // Auto-reject pending approvals when user sends new message
-        if (pendingApprovalsMap.size > 0) {
-            const approvalIds = Array.from(pendingApprovalsMap.keys());
-            setPendingApprovalsMap(new Map());
-            for (const approvalId of approvalIds) {
-                await addToolApprovalResponse({
-                    id: approvalId,
-                    approved: false,
-                    reason: 'Auto-rejected: user sent a new message.',
-                });
-            }
-        }
         await sendMessage({ text: processedMessage });
         setActiveMentions([]);
         setMentionQuery('');
@@ -645,12 +764,114 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         rawMessages,
         setMessages,
         sendMessage,
-        addToolApprovalResponse,
         pendingApprovalsMap,
+    ]);
+    const dispatchSend = useCallback(async (message, sendOptions) => {
+        const mentionsForSend = sendOptions?.mentions ?? activeMentions;
+        // A `/` command alone runs without the model; missing arguments open its form.
+        const plan = interactionRegistry?.planMessage(message, mentionsForSend);
+        if (plan?.status === 'needs-args') {
+            setPendingCommand(plan.request);
+            return;
+        }
+        if (plan?.status === 'send') {
+            setPendingCommand(null);
+            await deliver(plan.text);
+            return;
+        }
+        // Preprocess message
+        let processedMessage = plan?.status === 'prompt' ? plan.text : message;
+        const mentionSerializeConfig = mentions?.serialize;
+        if (mentionSerializeConfig?.enabled !== false) {
+            processedMessage = serializeMentionsForSend(processedMessage, mentionsForSend, mentionSerializeConfig);
+        }
+        if (onBeforeSend) {
+            processedMessage = onBeforeSend(processedMessage, mentionsForSend);
+        }
+        // Typing into the composer while a clarification is open answers it, so
+        // the server resumes the original request instead of starting over.
+        const openClarification = findOpenClarification(rawMessages);
+        if (openClarification?.request.allowFreeText
+            && processedMessage.trim().length > 0
+            && processedMessage.length <= CLARIFICATION_MAX_ANSWER_LENGTH
+            && !parseClarificationAnswer(processedMessage)) {
+            processedMessage = clarificationAnswerMessage({
+                toolCallId: openClarification.toolCallId,
+                answer: processedMessage,
+            });
+        }
+        await deliver(processedMessage);
+    }, [
+        rawMessages,
+        deliver,
+        interactionRegistry,
         mentions,
         onBeforeSend,
         activeMentions,
     ]);
+    // Decides synchronously whether the message is taken, so any composer can
+    // keep the typed text when it is not.
+    const send = useCallback((message, sendOptions) => {
+        if (sessionNotReady || sessionMutationRef.current)
+            return false;
+        if (pendingApprovalsMap.size > 0) {
+            setApprovalReminder(true);
+            return false;
+        }
+        void dispatchSend(message, sendOptions);
+        return true;
+    }, [sessionNotReady, pendingApprovalsMap, dispatchSend]);
+    const submitPendingCommand = useCallback((values, valueLabels) => {
+        if (!pendingCommand || !interactionRegistry || sessionNotReady || sessionMutationRef.current)
+            return false;
+        const plan = interactionRegistry.completeCommand(pendingCommand, values, valueLabels);
+        if (plan.status !== 'send') {
+            setPendingCommand(plan.status === 'needs-args' ? plan.request : null);
+            return plan.status !== 'needs-args';
+        }
+        setPendingCommand(null);
+        void deliver(plan.text);
+        return true;
+    }, [pendingCommand, interactionRegistry, sessionNotReady, deliver]);
+    const cancelPendingCommand = useCallback(() => setPendingCommand(null), []);
+    const runEntityAction = useCallback((entity, actionId) => {
+        if (sessionNotReady || sessionMutationRef.current)
+            return;
+        const plan = interactionRegistry?.planAction(entity, actionId);
+        if (!plan)
+            return;
+        if (plan.status === 'needs-args') {
+            setPendingCommand(plan.request);
+            return;
+        }
+        setPendingCommand(null);
+        void deliver(plan.text);
+    }, [interactionRegistry, sessionNotReady, deliver]);
+    const mentionEntity = useCallback(async (type, id) => {
+        const entity = interactionRegistry?.entity(type);
+        if (!entity?.resolve)
+            return false;
+        let item;
+        try {
+            item = toChatEntityItem(await entity.resolve(id));
+        }
+        catch {
+            return false;
+        }
+        if (!item)
+            return false;
+        const resolved = item;
+        setComposerMentions((previous) => [...previous, {
+                id: resolved.id,
+                type,
+                label: resolved.label,
+                displayName: resolved.label,
+                prefix: '@',
+                slug: normalizeMentionSlug(resolved.label),
+            }]);
+        return true;
+    }, [interactionRegistry]);
+    const consumeComposerMentions = useCallback(() => setComposerMentions([]), []);
     const stop = useCallback(() => {
         setPipelineState((prev) => ({
             status: 'aborted',
@@ -678,6 +899,7 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         setMentionResults([]);
         setActiveMentions([]);
         setIsMentionSearching(false);
+        setPendingCommand(null);
         setSuggestionChips(suggestionsConfig.staticChips ?? []);
     }, [setMessages, activeSessionId, suggestionsConfig.staticChips]);
     // ---------------------------------------------------------------------------
@@ -700,17 +922,17 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
             setSessions(list);
             // Auto-select the first session if we're still on the bootstrap
             // sentinel and the consumer doesn't control `activeId` externally.
-            if (list.length > 0 &&
+            if (!streamActiveRef.current &&
+                list.length > 0 &&
                 cfg.activeId === undefined &&
-                (uncontrolledActiveIdRef.current === 'default' ||
-                    !list.some((s) => s.id === uncontrolledActiveIdRef.current))) {
+                !list.some((s) => s.id === uncontrolledActiveIdRef.current)) {
                 const next = list[0].id;
                 setUncontrolledActiveId(next);
                 cfg.onActiveIdChange?.(next);
             }
         }
-        catch (err) {
-            console.warn('[AiChatProvider] session.list failed:', err);
+        catch {
+            console.warn('[AiChatProvider] session.list failed');
         }
         finally {
             setIsSessionsLoading(false);
@@ -739,8 +961,13 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         wasLoadingRef.current = isLoading;
     }, [isLoading, sessionsSupported, refreshSessions]);
     const switchSession = useCallback(async (id) => {
-        if (id === activeSessionId)
+        if (streamActiveRef.current)
+            return;
+        if (id === activeSessionId) {
+            if (sessionLoadFailure?.id === id)
+                setSessionRestoreAttempt((attempt) => attempt + 1);
             return;
+        }
         // Reset transient UI state before loading new session
         setPendingApprovalsMap(new Map());
         setTruncation(null);
@@ -749,38 +976,58 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         setSuggestionChips(suggestionsConfig.staticChips ?? []);
         setVisibleMessageCount(30);
         applyActiveId(id);
-    }, [activeSessionId, applyActiveId, suggestionsConfig.staticChips]);
+    }, [activeSessionId, applyActiveId, suggestionsConfig.staticChips, isLoading, sessionLoadFailure]);
     const createSession = useCallback(async (opts) => {
+        if (streamActiveRef.current || sessionMutationRef.current)
+            return null;
         const cfg = sessionRef.current;
         if (!cfg?.create)
             return null;
-        const created = await cfg.create(opts);
-        await refreshSessions();
-        await switchSession(created.id);
-        return created;
-    }, [refreshSessions, switchSession]);
+        sessionMutationRef.current = true;
+        setIsSessionMutating(true);
+        try {
+            const created = await cfg.create(opts);
+            await refreshSessions();
+            await switchSession(created.id);
+            return created;
+        }
+        finally {
+            sessionMutationRef.current = false;
+            setIsSessionMutating(false);
+        }
+    }, [refreshSessions, switchSession, isLoading]);
     const removeSession = useCallback(async (id) => {
+        if (streamActiveRef.current || sessionMutationRef.current)
+            return;
         const cfg = sessionRef.current;
         if (!cfg?.remove)
             return;
-        await cfg.remove(id);
-        // Re-fetch first so the fallback target reflects reality
-        const cfgList = cfg.list ? await cfg.list() : [];
-        setSessions(cfgList);
-        if (id === activeSessionId) {
-            const next = cfgList.find((s) => s.id !== id);
-            if (next) {
-                await switchSession(next.id);
-            }
-            else if (cfg.create) {
-                // No sessions left — spin up a fresh one
-                const created = await cfg.create();
-                const refreshed = cfg.list ? await cfg.list() : [created];
-                setSessions(refreshed);
-                await switchSession(created.id);
+        sessionMutationRef.current = true;
+        setIsSessionMutating(true);
+        try {
+            await cfg.remove(id);
+            // Re-fetch first so the fallback target reflects reality
+            const cfgList = cfg.list ? await cfg.list() : [];
+            setSessions(cfgList);
+            if (id === activeSessionId) {
+                const next = cfgList.find((s) => s.id !== id);
+                if (next) {
+                    await switchSession(next.id);
+                }
+                else if (cfg.create) {
+                    // No sessions left — spin up a fresh one
+                    const created = await cfg.create();
+                    const refreshed = cfg.list ? await cfg.list() : [created];
+                    setSessions(refreshed);
+                    await switchSession(created.id);
+                }
             }
         }
-    }, [activeSessionId, switchSession]);
+        finally {
+            sessionMutationRef.current = false;
+            setIsSessionMutating(false);
+        }
+    }, [activeSessionId, switchSession, isLoading]);
     const renameSession = useCallback(async (id, title) => {
         const cfg = sessionRef.current;
         if (!cfg?.rename)
@@ -800,28 +1047,52 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
     }, []);
     // Approval handlers
     const approve = useCallback(async (id) => {
-        setProcessingApprovalId(id);
-        setPendingApprovalsMap(prev => {
-            const next = new Map(prev);
-            next.delete(id);
-            return next;
-        });
-        await addToolApprovalResponse({ id, approved: true });
-        setProcessingApprovalId(null);
+        setApprovalError(null);
+        setProcessingApprovalIds((prev) => new Set(prev).add(id));
+        try {
+            await addToolApprovalResponse({ id, approved: true });
+            setPendingApprovalsMap((prev) => {
+                const next = new Map(prev);
+                next.delete(id);
+                return next;
+            });
+        }
+        catch {
+            setApprovalError(new Error('Tool approval response failed.'));
+        }
+        finally {
+            setProcessingApprovalIds((prev) => {
+                const next = new Set(prev);
+                next.delete(id);
+                return next;
+            });
+        }
     }, [addToolApprovalResponse]);
     const reject = useCallback(async (id) => {
-        setProcessingApprovalId(id);
-        setPendingApprovalsMap(prev => {
-            const next = new Map(prev);
-            next.delete(id);
-            return next;
-        });
-        await addToolApprovalResponse({
-            id,
-            approved: false,
-            reason: 'Rejected by user.',
-        });
-        setProcessingApprovalId(null);
+        setApprovalError(null);
+        setProcessingApprovalIds((prev) => new Set(prev).add(id));
+        try {
+            await addToolApprovalResponse({
+                id,
+                approved: false,
+                reason: 'Rejected by user.',
+            });
+            setPendingApprovalsMap((prev) => {
+                const next = new Map(prev);
+                next.delete(id);
+                return next;
+            });
+        }
+        catch {
+            setApprovalError(new Error('Tool approval response failed.'));
+        }
+        finally {
+            setProcessingApprovalIds((prev) => {
+                const next = new Set(prev);
+                next.delete(id);
+                return next;
+            });
+        }
     }, [addToolApprovalResponse]);
     // Truncation
     const continueTruncation = useCallback(async () => {
@@ -911,16 +1182,19 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         locale,
         themeVars,
         themeEffect,
+        unstyled,
         suggestions: suggestionsConfig,
         toolLabels,
         toolResults: toolResultConfig,
+        toolRendererRegistry,
         voice: voiceConfig,
         mentionConfig: mentions,
         pipelineMessageTranslator,
         stepSummaryFormatter,
         messages: visibleMessages,
-        isLoading,
-        error: error ?? null,
+        isLoading: isLoading || isSessionMutating || sessionNotReady,
+        isSessionChangeBlocked: isLoading || isSessionMutating,
+        error: error ?? approvalError,
         send,
         stop,
         clear,
@@ -929,9 +1203,10 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         pipelineSteps,
         pipelineState,
         pendingApprovals,
+        approvalReminder,
         approve,
         reject,
-        isProcessingApproval: processingApprovalId !== null,
+        isProcessingApproval: processingApprovalIds.size > 0,
         approvalDescription: approvalDescriptionRef.current,
         truncation,
         continueTruncation,
@@ -948,6 +1223,16 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         clearActiveMentions,
         isMentionSearching,
         hasMentions: !!mentions,
+        completionSearch,
+        hasCompletions: completionSearch !== undefined,
+        interactions: interactionRegistry,
+        pendingCommand,
+        submitPendingCommand,
+        cancelPendingCommand,
+        runEntityAction,
+        mentionEntity,
+        composerMentions,
+        consumeComposerMentions,
         suggestionChips,
         selectSuggestion,
         refreshSuggestions,
@@ -967,16 +1252,22 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         locale,
         themeVars,
         themeEffect,
+        unstyled,
         suggestionsConfig,
         toolLabels,
         toolResultConfig,
+        toolRendererRegistry,
         voiceConfig,
         mentions,
         pipelineMessageTranslator,
         stepSummaryFormatter,
         visibleMessages,
         isLoading,
+        sessionNotReady,
+        isSessionMutating,
+        isBootstrapSentinel,
         error,
+        approvalError,
         send,
         stop,
         clear,
@@ -985,9 +1276,10 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         pipelineSteps,
         pipelineState,
         pendingApprovals,
+        approvalReminder,
         approve,
         reject,
-        processingApprovalId,
+        processingApprovalIds,
         truncation,
         continueTruncation,
         dismissTruncation,
@@ -1002,6 +1294,15 @@ export function AiChatProvider({ transport, mentions, toolResults: userToolResul
         removeActiveMention,
         clearActiveMentions,
         isMentionSearching,
+        completionSearch,
+        interactionRegistry,
+        pendingCommand,
+        submitPendingCommand,
+        cancelPendingCommand,
+        runEntityAction,
+        mentionEntity,
+        composerMentions,
+        consumeComposerMentions,
         suggestionChips,
         selectSuggestion,
         refreshSuggestions,