libre-webui 0.21.3 → 0.22.1

package/backend/dist/routes/chat.js

@@ -15,7 +15,9 @@
  * limitations under the License.
  */
 import express from 'express';
-import rateLimit from 'express-rate-limit';
+import { randomUUID } from 'node:crypto';
+import rateLimit from '../middleware/sharedRateLimit.js';
+import { isChatCancellationSafetyRequest } from '../middleware/chatCancellationAdmission.js';
 import chatService from '../services/chatService.js';
 import ollamaService from '../services/ollamaService.js';
 import pluginService from '../services/pluginService.js';
@@ -36,7 +38,55 @@ import { buildChatDocumentContext, EMPTY_CHAT_DOCUMENT_CONTEXT, } from '../utils
 import { ChatProviderSelectionError } from '../utils/chatProviderSelection.js';
 import { formatPluginStreamToolCalls } from '../utils/pluginStreaming.js';
 import { ResourcePolicyError } from '../utils/resourceLimits.js';
+import { abortChatGenerationOnResponseClose, isChatGenerationCancelled, throwIfChatGenerationCancelled, } from '../utils/chatCancellation.js';
+import { getDurableEventGateway } from '../platform/events/index.js';
+import { chatGenerationIdempotencyScope } from '../platform/jobs/domainJobContracts.js';
+import { getDurableJobRuntime } from '../platform/jobs/durableJobRuntime.js';
+import { durableEventId } from '../platform/jobs/durableEventIdentity.js';
+import { getPlatformRuntimeConfig } from '../platform/coordination/service.js';
 const logger = createLogger('routes:chat');
+const CHAT_EVENT_MAX_FRAME_BYTES = 128 * 1024;
+const CHAT_EVENT_DRAIN_TIMEOUT_MS = 15000;
+const chatStreamId = (sessionId) => `chat:${sessionId}`;
+const cancelChatGenerationByIdentity = async (userId, sessionId, assistantMessageId) => {
+    return getDurableJobRuntime().service.requestChatCancellation({
+        actorUserId: userId,
+        sessionId,
+        assistantMessageId,
+    });
+};
+const writeChatSseFrame = async (res, cursor, payload) => {
+    const frame = `id: ${cursor}\ndata: ${JSON.stringify(payload)}\n\n`;
+    if (Buffer.byteLength(frame, 'utf8') > CHAT_EVENT_MAX_FRAME_BYTES) {
+        throw new Error('Chat event frame exceeds the delivery bound.');
+    }
+    if (res.writableEnded || res.destroyed)
+        return;
+    if (res.write(frame))
+        return;
+    await new Promise((resolve, reject) => {
+        const cleanup = () => {
+            clearTimeout(timeout);
+            res.off('drain', drained);
+            res.off('close', closed);
+        };
+        const drained = () => {
+            cleanup();
+            resolve();
+        };
+        const closed = () => {
+            cleanup();
+            reject(new Error('Chat event stream closed during backpressure.'));
+        };
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error('Chat event stream backpressure timed out.'));
+        }, CHAT_EVENT_DRAIN_TIMEOUT_MS);
+        timeout.unref?.();
+        res.once('drain', drained);
+        res.once('close', closed);
+    });
+};
 function sendSessionFolderError(res, error, fallback) {
     if (error instanceof ResourcePolicyError) {
         res.status(error.statusCode).json({ success: false, error: error.message });
@@ -48,6 +98,16 @@ function sendSessionFolderError(res, error, fallback) {
     });
 }
 const router = express.Router();
+const rejectProcessLocalTeamGeneration = (res) => {
+    if (getPlatformRuntimeConfig().mode !== 'team')
+        return false;
+    res.status(409).json({
+        success: false,
+        error: 'This compatibility endpoint is unavailable in team mode. Queue the generation through /generations and resume it through /events.',
+        code: 'DURABLE_CHAT_REQUIRED',
+    });
+    return true;
+};
 const titleGenerationService = new TitleGenerationService({
     chatService,
     chatGenerationService,
@@ -67,6 +127,7 @@ const followUpService = new FollowUpService({
 });
 // Rate limiter for chat routes: 60 requests per minute (reasonable for chat)
 const chatRateLimiter = rateLimit({
+    keyPrefix: 'chat-routes',
     windowMs: 1 * 60 * 1000, // 1 minute
     max: 60, // limit each IP to 60 requests per minute
     message: {
@@ -75,6 +136,7 @@ const chatRateLimiter = rateLimit({
     },
     standardHeaders: true,
     legacyHeaders: false,
+    skip: isChatCancellationSafetyRequest,
 });
 // Apply rate limiter to all chat routes
 router.use(chatRateLimiter);
@@ -84,7 +146,7 @@ router.use(authenticate);
 router.get('/sessions', async (req, res) => {
     try {
         const userId = req.user?.userId || 'default';
-        const sessions = chatService.getAllSessions(userId);
+        const sessions = await chatService.getAllSessions(userId);
         res.json({
             success: true,
             data: sessions,
@@ -132,7 +194,7 @@ router.get('/sessions/:sessionId', async (req, res) => {
     try {
         const sessionId = req.params.sessionId;
         const userId = req.user?.userId || 'default';
-        const session = chatService.getSession(sessionId, userId);
+        const session = await chatService.getSession(sessionId, userId);
         if (!session) {
             res.status(404).json({
                 success: false,
@@ -185,7 +247,7 @@ router.put('/sessions/:sessionId/messages/:messageId', async (req, res) => {
         const messageId = req.params.messageId;
         const updates = req.body;
         const userId = req.user?.userId || 'default';
-        const updatedMessage = chatService.updateMessage(sessionId, messageId, updates, userId);
+        const updatedMessage = await chatService.updateMessage(sessionId, messageId, updates, userId);
         if (!updatedMessage) {
             res.status(404).json({
                 success: false,
@@ -210,7 +272,7 @@ router.delete('/sessions/:sessionId', async (req, res) => {
     try {
         const sessionId = req.params.sessionId;
         const userId = req.user?.userId || 'default';
-        const deleted = chatService.deleteSession(sessionId, userId);
+        const deleted = await chatService.deleteSession(sessionId, userId);
         if (!deleted) {
             res.status(404).json({
                 success: false,
@@ -234,7 +296,7 @@ router.delete('/sessions/:sessionId', async (req, res) => {
 router.delete('/sessions', async (req, res) => {
     try {
         const userId = req.user?.userId || 'default';
-        chatService.clearAllSessions(userId);
+        await chatService.clearAllSessions(userId);
         res.json({
             success: true,
             message: 'All chat sessions cleared successfully',
@@ -260,7 +322,7 @@ router.post('/sessions/:sessionId/messages', async (req, res) => {
             return;
         }
         const userId = req.user?.userId || 'default';
-        const session = chatService.getSession(sessionId, userId);
+        const session = await chatService.getSession(sessionId, userId);
         if (!session) {
             res.status(404).json({
                 success: false,
@@ -268,7 +330,7 @@ router.post('/sessions/:sessionId/messages', async (req, res) => {
             });
             return;
         }
-        const message = chatService.addMessage(sessionId, {
+        const message = await chatService.addMessage(sessionId, {
             role,
             content,
             model,
@@ -295,6 +357,10 @@ router.post('/sessions/:sessionId/messages', async (req, res) => {
 });
 // Generate a chat response
 router.post('/sessions/:sessionId/generate', async (req, res) => {
+    if (rejectProcessLocalTeamGeneration(res))
+        return;
+    const { controller, cleanup } = abortChatGenerationOnResponseClose(res);
+    const signal = controller.signal;
     try {
         const sessionId = req.params.sessionId;
         const { message, options = {} } = req.body;
@@ -306,7 +372,7 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
             return;
         }
         const userId = req.user?.userId || 'default';
-        const session = chatService.getSession(sessionId, userId);
+        const session = await chatService.getSession(sessionId, userId);
         if (!session) {
             res.status(404).json({
                 success: false,
@@ -315,7 +381,7 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
             return;
         }
         // Add user message to session
-        const userMessage = chatService.addMessage(sessionId, {
+        const userMessage = await chatService.addMessage(sessionId, {
             role: 'user',
             content: message,
         }, userId);
@@ -328,9 +394,10 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
         }
         let documentContext = EMPTY_CHAT_DOCUMENT_CONTEXT(message);
         try {
-            documentContext = await buildChatDocumentContext(message, sessionId, userId);
+            documentContext = await buildChatDocumentContext(message, sessionId, userId, signal);
         }
         catch (error) {
+            throwIfChatGenerationCancelled(signal);
             logger.error('Error during document search:', error);
         }
         // Requested web search composes on top of any document context; a
@@ -339,10 +406,10 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
         let enhancedContent = documentContext.enhancedContent;
         let hasRelevantContext = documentContext.hasRelevantContext;
         if (req.body?.webSearch === true &&
-            isWebSearchAvailable() &&
-            userCanUseWebSearch(userModel.getUserById(userId))) {
+            (await isWebSearchAvailable()) &&
+            (await userCanUseWebSearch(await userModel.getUserById(userId)))) {
             try {
-                const results = await runWebSearch(message);
+                const results = await runWebSearch(message, undefined, signal);
                 if (results.length > 0) {
                     enhancedContent = buildWebSearchEnhancedContent(enhancedContent, results, message);
                     hasRelevantContext = true;
@@ -353,6 +420,7 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
                 }
             }
             catch (error) {
+                throwIfChatGenerationCancelled(signal);
                 logger.error('Web search failed; answering without it:', error);
             }
         }
@@ -360,10 +428,11 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
             session,
             userId,
             options,
-            persistedMessages: chatService.getMessagesForContext(sessionId),
+            persistedMessages: await chatService.getMessagesForContext(sessionId, userId),
             content: message,
             hasRelevantContext,
             enhancedContent,
+            signal,
         });
         const generationResult = await chatGenerationService.executeNonStreaming({
             target: preparedGeneration.target,
@@ -371,13 +440,15 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
             pluginMessages: preparedGeneration.pluginMessages,
             userId,
             pluginFallbackPolicy: 'allow',
+            signal,
         });
+        throwIfChatGenerationCancelled(signal);
         if (generationResult.pluginError) {
             logger.error('Plugin failed, falling back to Ollama:', generationResult.pluginError);
         }
         // Add assistant response to session with statistics
         const statistics = extractStatistics(generationResult.response);
-        const assistantMessage = chatService.addMessage(sessionId, {
+        const assistantMessage = await chatService.addMessage(sessionId, {
             role: 'assistant',
             content: generationResult.assistantContent,
             thinking: generationResult.assistantThinking,
@@ -392,7 +463,9 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
                         : {}),
                 }
                 : generationResult.response.message.providerMetadata,
-        }, userId);
+        }, userId, {
+            assertPersistenceAllowed: () => throwIfChatGenerationCancelled(signal),
+        });
         if (!assistantMessage) {
             res.status(500).json({
                 success: false,
@@ -406,14 +479,285 @@ router.post('/sessions/:sessionId/generate', async (req, res) => {
         });
     }
     catch (error) {
+        if (isChatGenerationCancelled(error, signal)) {
+            if (!res.writableEnded)
+                res.status(499).end();
+            return;
+        }
         res.status(error instanceof ChatProviderSelectionError ? 400 : 500).json({
             success: false,
             error: getErrorMessage(error, 'Failed to generate response'),
         });
     }
+    finally {
+        cleanup();
+    }
+});
+// Resume any persisted chat stream from any application replica. SQL is the
+// ordered source of truth; Redis only wakes the subscriber after a commit.
+router.post('/sessions/:sessionId/generations', async (req, res) => {
+    const sessionId = String(req.params.sessionId || '').trim();
+    const userId = req.user?.userId || 'default';
+    const message = typeof req.body?.message === 'string' ? req.body.message : '';
+    const images = Array.isArray(req.body?.images)
+        ? req.body.images.filter((image) => typeof image === 'string' && image.length > 0)
+        : undefined;
+    const userMessageId = typeof req.body?.userMessageId === 'string'
+        ? req.body.userMessageId.trim()
+        : randomUUID();
+    const assistantMessageId = typeof req.body?.assistantMessageId === 'string'
+        ? req.body.assistantMessageId.trim()
+        : randomUUID();
+    const options = req.body?.options &&
+        typeof req.body.options === 'object' &&
+        !Array.isArray(req.body.options)
+        ? req.body.options
+        : {};
+    const regenerate = req.body?.regenerate === true;
+    const originalMessageId = typeof req.body?.originalMessageId === 'string'
+        ? req.body.originalMessageId.trim()
+        : undefined;
+    if (!sessionId ||
+        (!message.trim() && !images?.length) ||
+        !userMessageId ||
+        !assistantMessageId ||
+        (regenerate && !originalMessageId)) {
+        res.status(400).json({
+            success: false,
+            error: 'Session, message, and message identifiers are required',
+        });
+        return;
+    }
+    let responseFinished = false;
+    let prematureClose = req.aborted || res.destroyed;
+    let queuedJobId;
+    let disconnectCancellation;
+    const cancelCommittedJob = () => {
+        if (disconnectCancellation)
+            return disconnectCancellation;
+        disconnectCancellation = cancelChatGenerationByIdentity(userId, sessionId, assistantMessageId);
+        return disconnectCancellation;
+    };
+    const onPrematureClose = () => {
+        if (responseFinished)
+            return;
+        prematureClose = true;
+        if (queuedJobId) {
+            void cancelCommittedJob().catch(error => logger.error('Failed to cancel disconnected chat generation:', error));
+        }
+    };
+    const cleanupCloseFence = () => {
+        req.off('aborted', onPrematureClose);
+        req.socket.off('close', onPrematureClose);
+        res.off('close', onPrematureClose);
+        res.off('finish', onResponseFinished);
+    };
+    const onResponseFinished = () => {
+        responseFinished = true;
+        cleanupCloseFence();
+    };
+    // Arm before enqueue: the SQL transaction may commit while the client
+    // closes before receiving its 202. That close becomes cancellation intent
+    // against the exact deterministic generation identity.
+    req.once('aborted', onPrematureClose);
+    req.socket.once('close', onPrematureClose);
+    res.once('close', onPrematureClose);
+    res.once('finish', onResponseFinished);
+    try {
+        const queued = await chatService.queueDurableGeneration({
+            sessionId,
+            userId,
+            userMessageId,
+            assistantMessageId,
+            message,
+            images,
+            options,
+            webSearch: req.body?.webSearch === true,
+            regenerate,
+            originalMessageId,
+        });
+        if (!queued) {
+            cleanupCloseFence();
+            res.status(404).json({ success: false, error: 'Session not found' });
+            return;
+        }
+        queuedJobId = queued.jobId;
+        if (prematureClose ||
+            req.aborted ||
+            req.socket.destroyed ||
+            res.destroyed) {
+            prematureClose = true;
+            await cancelCommittedJob();
+            cleanupCloseFence();
+            return;
+        }
+        res.status(202).json({
+            success: true,
+            data: {
+                jobId: queued.jobId,
+                userMessage: queued.userMessage,
+                assistantMessageId,
+                eventStream: `/api/chat/sessions/${encodeURIComponent(sessionId)}/events?generation=${encodeURIComponent(assistantMessageId)}`,
+            },
+        });
+    }
+    catch (error) {
+        if (prematureClose ||
+            req.aborted ||
+            req.socket.destroyed ||
+            res.destroyed) {
+            prematureClose = true;
+            await cancelCommittedJob().catch(cancellationError => logger.error('Failed to resolve disconnected chat generation:', cancellationError));
+            cleanupCloseFence();
+            return;
+        }
+        res.status(409).json({
+            success: false,
+            error: getErrorMessage(error, 'Unable to queue chat generation'),
+        });
+    }
+});
+router.post('/sessions/:sessionId/generations/:assistantMessageId/cancel', async (req, res) => {
+    const sessionId = String(req.params.sessionId || '').trim();
+    const assistantMessageId = String(req.params.assistantMessageId || '').trim();
+    const userId = req.user?.userId || 'default';
+    if (!sessionId || !assistantMessageId) {
+        res.status(400).json({ success: false, error: 'Generation is required' });
+        return;
+    }
+    if (!(await chatService.getSession(sessionId, userId))) {
+        res.status(404).json({ success: false, error: 'Session not found' });
+        return;
+    }
+    // This is one SQL decision: completion already committed, or cancellation
+    // intent plus any existing natural-key job cancellation commit together.
+    // When the job is not present yet, enqueue consumes the durable intent and
+    // creates it directly in a terminal cancelled state.
+    const decision = await cancelChatGenerationByIdentity(userId, sessionId, assistantMessageId);
+    res.status(202).json({
+        success: true,
+        data: decision.outcome === 'completion-won'
+            ? { completed: true }
+            : decision.job
+                ? { jobId: decision.job.id, state: decision.job.state }
+                : { pending: true },
+    });
+});
+router.get('/sessions/:sessionId/events', async (req, res) => {
+    const sessionId = String(req.params.sessionId || '').trim();
+    const userId = req.user?.userId || 'default';
+    const generationId = typeof req.query.generation === 'string'
+        ? req.query.generation.trim()
+        : undefined;
+    const afterValue = req.query.after ??
+        (typeof req.get('Last-Event-ID') === 'string'
+            ? req.get('Last-Event-ID')
+            : undefined) ??
+        0;
+    const afterCursor = Number(afterValue);
+    if (!Number.isSafeInteger(afterCursor) || afterCursor < 0) {
+        res.status(400).json({ success: false, error: 'Invalid event cursor' });
+        return;
+    }
+    if (!(await chatService.getSession(sessionId, userId))) {
+        res.status(404).json({ success: false, error: 'Session not found' });
+        return;
+    }
+    const generationJob = generationId
+        ? await getDurableJobRuntime().service.getByIdempotency(userId, chatGenerationIdempotencyScope(sessionId), generationId)
+        : null;
+    if (generationId && !generationJob) {
+        res.status(404).json({ success: false, error: 'Generation not found' });
+        return;
+    }
+    res.status(200);
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+    const abort = new AbortController();
+    let subscription;
+    let heartbeat;
+    let heartbeatBusy = false;
+    let terminal = false;
+    const close = () => {
+        abort.abort();
+        if (heartbeat)
+            clearInterval(heartbeat);
+        void subscription?.close();
+        if (!res.writableEnded && !res.destroyed)
+            res.end();
+    };
+    res.once('close', close);
+    try {
+        subscription = await getDurableEventGateway().subscribe({
+            afterCursor,
+            streamId: chatStreamId(sessionId),
+            ...(generationId ? { subjectId: generationId } : {}),
+            batchSize: 100,
+            maxReplayEvents: 10000,
+            signal: abort.signal,
+            authorize: async () => Boolean(await chatService.getSession(sessionId, userId)),
+            onEvent: async (event) => {
+                if (generationId && event.subjectId !== generationId)
+                    return;
+                await writeChatSseFrame(res, event.cursor, event.payload);
+                terminal =
+                    event.eventType === 'chat.done.v1' ||
+                        event.eventType === 'chat.error.v1';
+                if (terminal)
+                    queueMicrotask(close);
+            },
+            onError: () => close(),
+        });
+        if (terminal) {
+            close();
+            return;
+        }
+        heartbeat = setInterval(() => {
+            if (res.writableEnded || res.destroyed) {
+                close();
+                return;
+            }
+            if (heartbeatBusy)
+                return;
+            heartbeatBusy = true;
+            void (async () => {
+                if (generationJob) {
+                    const current = await getDurableJobRuntime().service.getMetadata(generationJob.id);
+                    if (current?.state === 'cancelled' ||
+                        current?.state === 'dead_letter') {
+                        await writeChatSseFrame(res, subscription?.cursor ?? afterCursor, {
+                            type: 'error',
+                            error: current.state === 'cancelled'
+                                ? 'Chat generation was cancelled'
+                                : current.errorSummary || 'Chat generation failed',
+                        });
+                        close();
+                        return;
+                    }
+                }
+                res.write(`: heartbeat ${Date.now()}\n\n`);
+            })()
+                .catch(close)
+                .finally(() => {
+                heartbeatBusy = false;
+            });
+        }, 15000);
+        heartbeat.unref?.();
+    }
+    catch {
+        close();
+    }
 });
 // Generate a chat response with streaming
 router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
+    if (rejectProcessLocalTeamGeneration(res))
+        return;
+    const { controller, cleanup } = abortChatGenerationOnResponseClose(res);
+    const signal = controller.signal;
+    let emitDurable;
     try {
         const sessionId = req.params.sessionId;
         const { message, options = {} } = req.body;
@@ -425,7 +769,7 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
             return;
         }
         const userId = req.user?.userId || 'default';
-        const session = chatService.getSession(sessionId, userId);
+        const session = await chatService.getSession(sessionId, userId);
         if (!session) {
             res.status(404).json({
                 success: false,
@@ -438,13 +782,57 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
         res.setHeader('Cache-Control', 'no-cache');
         res.setHeader('Connection', 'keep-alive');
         res.setHeader('Access-Control-Allow-Origin', '*');
+        // Event identity is a per-request nonce plus a monotonic sequence.
+        // Deriving it from payload content silently deduplicated repeated
+        // identical deltas out of the durable log and rejected payloads over
+        // the identity component bound.
+        let eventTail = Promise.resolve(undefined);
+        let eventFailure;
+        const requestNonce = randomUUID();
+        let eventSequence = 0;
+        emitDurable = async (payload) => {
+            if (eventFailure)
+                throw eventFailure;
+            const type = payload.type === 'done'
+                ? 'chat.done.v1'
+                : payload.type === 'error'
+                    ? 'chat.error.v1'
+                    : 'chat.stream.v1';
+            const occurrence = String(++eventSequence);
+            const operation = eventTail.then(() => getDurableEventGateway().append({
+                eventId: durableEventId('legacy-chat-route', sessionId, requestNonce, occurrence),
+                streamId: chatStreamId(sessionId),
+                eventType: type,
+                subjectId: sessionId,
+                actorUserId: userId,
+                payload: { mode: 'encrypted', value: payload },
+            }));
+            eventTail = operation.catch(error => {
+                eventFailure = error;
+                return undefined;
+            });
+            if (type === 'chat.stream.v1') {
+                // The direct response is the transport of record for this route;
+                // the durable append continues behind it so a slow event write
+                // cannot throttle delivery.
+                await writeChatSseFrame(res, 0, payload);
+                return;
+            }
+            // Terminal events commit durably before the response settles so
+            // `/events` replay consumers always observe an ordered terminal.
+            const appended = await operation;
+            await writeChatSseFrame(res, appended.cursor, payload);
+        };
         // Add user message to session
-        const userMessage = chatService.addMessage(sessionId, {
+        const userMessage = await chatService.addMessage(sessionId, {
             role: 'user',
             content: message,
         }, userId);
         if (!userMessage) {
-            res.write(`data: ${JSON.stringify({ error: 'Failed to add user message' })}\n\n`);
+            await emitDurable({
+                type: 'error',
+                error: 'Failed to add user message',
+            });
             res.end();
             return;
         }
@@ -452,9 +840,10 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
         // paths; search composes on top of it.
         let documentContext = EMPTY_CHAT_DOCUMENT_CONTEXT(message);
         try {
-            documentContext = await buildChatDocumentContext(message, sessionId, userId);
+            documentContext = await buildChatDocumentContext(message, sessionId, userId, signal);
         }
         catch (contextError) {
+            throwIfChatGenerationCancelled(signal);
             logger.error('Error during document search:', contextError);
         }
         // Requested web search runs before generation and reports its own
@@ -463,11 +852,11 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
         let webSearchSources;
         let searchEnhancedContent;
         if (req.body?.webSearch === true &&
-            isWebSearchAvailable() &&
-            userCanUseWebSearch(userModel.getUserById(userId))) {
-            res.write(`data: ${JSON.stringify({ type: 'search', status: 'searching' })}\n\n`);
+            (await isWebSearchAvailable()) &&
+            (await userCanUseWebSearch(await userModel.getUserById(userId)))) {
+            await emitDurable({ type: 'search', status: 'searching' });
             try {
-                const results = await runWebSearch(message);
+                const results = await runWebSearch(message, undefined, signal);
                 if (results.length > 0) {
                     searchEnhancedContent = buildWebSearchEnhancedContent(documentContext.enhancedContent, results, message);
                     webSearchSources = results.map(({ title, url }) => ({
@@ -475,19 +864,20 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
                         url,
                     }));
                 }
-                res.write(`data: ${JSON.stringify({
+                await emitDurable({
                     type: 'search',
                     status: 'done',
                     sources: webSearchSources ?? [],
-                })}\n\n`);
+                });
             }
             catch (searchError) {
+                throwIfChatGenerationCancelled(signal);
                 logger.error('Web search failed; answering without it:', searchError);
-                res.write(`data: ${JSON.stringify({
+                await emitDurable({
                     type: 'search',
                     status: 'failed',
                     error: getErrorMessage(searchError, 'Web search failed.'),
-                })}\n\n`);
+                });
             }
         }
         const withSearchSources = (metadata) => {
@@ -506,11 +896,13 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
             session,
             userId,
             options,
-            persistedMessages: chatService.getMessagesForContext(sessionId),
+            persistedMessages: await chatService.getMessagesForContext(sessionId, userId),
             content: message,
             enhancedContent: searchEnhancedContent ?? documentContext.enhancedContent,
             hasRelevantContext: Boolean(searchEnhancedContent ?? documentContext.hasRelevantContext),
+            signal,
         });
+        throwIfChatGenerationCancelled(signal);
         const { target, actualModelName, mergedOptions, activePlugin, ollamaMessages, pluginMessages, shouldStreamPlugin, } = preparedGeneration;
         const chatRequest = {
             model: actualModelName,
@@ -522,59 +914,62 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
         let fullThinking = '';
         let assistantProviderMetadata;
         if (target.providerType === 'agent' && target.providerId) {
-            for await (const chunk of agentCliService.executeAgentStreamRequest(target.providerId, pluginMessages, userId, { model: target.actualModelName })) {
+            for await (const chunk of agentCliService.executeAgentStreamRequest(target.providerId, pluginMessages, userId, { model: target.actualModelName, signal })) {
                 if (chunk.type === 'content' && chunk.content) {
                     fullResponse += chunk.content;
-                    res.write(`data: ${JSON.stringify({
+                    await emitDurable({
                         type: 'chunk',
                         content: chunk.content,
                         done: false,
-                    })}\n\n`);
+                    });
                 }
                 else if (chunk.type === 'reasoning' && chunk.content) {
                     fullThinking += chunk.content;
-                    res.write(`data: ${JSON.stringify({
+                    await emitDurable({
                         type: 'reasoning',
                         content: chunk.content,
                         done: false,
-                    })}\n\n`);
+                    });
                 }
                 else if (chunk.type === 'done' && chunk.providerMetadata) {
                     assistantProviderMetadata = chunk.providerMetadata;
                 }
             }
+            throwIfChatGenerationCancelled(signal);
             if (fullResponse || fullThinking) {
-                chatService.addMessage(sessionId, {
+                await chatService.addMessage(sessionId, {
                     role: 'assistant',
                     content: fullResponse,
                     thinking: fullThinking || undefined,
                     model: session.model,
                     providerMetadata: withSearchSources(assistantProviderMetadata),
-                }, userId);
+                }, userId, {
+                    assertPersistenceAllowed: () => throwIfChatGenerationCancelled(signal),
+                });
             }
-            res.write(`data: ${JSON.stringify({ type: 'done' })}\n\n`);
+            await emitDurable({ type: 'done' });
             res.end();
             return;
         }
         if (activePlugin) {
             if (shouldStreamPlugin) {
                 const toolCalls = [];
-                for await (const chunk of pluginService.executePluginStreamRequest(actualModelName, pluginMessages, mergedOptions, userId, activePlugin.id)) {
+                for await (const chunk of pluginService.executePluginStreamRequest(actualModelName, pluginMessages, mergedOptions, userId, activePlugin.id, signal)) {
                     if (chunk.type === 'content' && chunk.content) {
                         fullResponse += chunk.content;
-                        res.write(`data: ${JSON.stringify({
+                        await emitDurable({
                             type: 'chunk',
                             content: chunk.content,
                             done: false,
-                        })}\n\n`);
+                        });
                     }
                     else if (chunk.type === 'reasoning' && chunk.content) {
                         fullThinking += chunk.content;
-                        res.write(`data: ${JSON.stringify({
+                        await emitDurable({
                             type: 'reasoning',
                             content: chunk.content,
                             done: false,
-                        })}\n\n`);
+                        });
                     }
                     else if (chunk.type === 'tool_call' && chunk.toolCall) {
                         toolCalls.push(chunk.toolCall);
@@ -592,14 +987,15 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
                             : assistantProviderMetadata;
                     }
                 }
+                throwIfChatGenerationCancelled(signal);
                 const toolContent = formatPluginStreamToolCalls(toolCalls);
                 if (toolContent) {
                     fullResponse += toolContent;
-                    res.write(`data: ${JSON.stringify({
+                    await emitDurable({
                         type: 'chunk',
                         content: toolContent,
                         done: false,
-                    })}\n\n`);
+                    });
                 }
             }
             else {
@@ -609,34 +1005,38 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
                     pluginMessages,
                     userId,
                     pluginFallbackPolicy: 'allow',
+                    signal,
                 });
                 fullResponse = generationResult.assistantContent;
                 fullThinking = generationResult.assistantThinking || '';
                 assistantProviderMetadata =
                     generationResult.response.message.providerMetadata;
                 if (fullThinking) {
-                    res.write(`data: ${JSON.stringify({
+                    await emitDurable({
                         type: 'reasoning',
                         content: fullThinking,
                         done: false,
-                    })}\n\n`);
+                    });
                 }
-                res.write(`data: ${JSON.stringify({
+                await emitDurable({
                     type: 'chunk',
                     content: fullResponse,
                     done: false,
-                })}\n\n`);
+                });
             }
+            throwIfChatGenerationCancelled(signal);
             if (fullResponse || fullThinking) {
-                chatService.addMessage(sessionId, {
+                await chatService.addMessage(sessionId, {
                     role: 'assistant',
                     content: fullResponse,
                     thinking: fullThinking || undefined,
                     model: session.model,
                     providerMetadata: withSearchSources(assistantProviderMetadata),
-                }, userId);
+                }, userId, {
+                    assertPersistenceAllowed: () => throwIfChatGenerationCancelled(signal),
+                });
             }
-            res.write(`data: ${JSON.stringify({ type: 'done' })}\n\n`);
+            await emitDurable({ type: 'done' });
             res.end();
             return;
         }
@@ -645,41 +1045,64 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
             const thinkingDelta = chunk.message.thinking || '';
             if (thinkingDelta) {
                 fullThinking += thinkingDelta;
-                res.write(`data: ${JSON.stringify({
+                void emitDurable({
                     type: 'reasoning',
                     content: thinkingDelta,
                     done: false,
-                })}\n\n`);
+                }).catch(() => controller.abort());
             }
-            // Send chunk to client
-            res.write(`data: ${JSON.stringify({
+            void emitDurable({
                 type: 'chunk',
                 content: chunk.message.content || '',
                 done: chunk.done,
-            })}\n\n`);
+            }).catch(() => controller.abort());
             // Accumulate response content
             if (chunk.message.content) {
                 fullResponse += chunk.message.content;
             }
         }, error => {
-            res.write(`data: ${JSON.stringify({ type: 'error', error: error.message })}\n\n`);
-            res.end();
+            if (signal.aborted || res.writableEnded)
+                return;
+            void emitDurable({ type: 'error', error: error.message })
+                .catch(() => undefined)
+                .finally(() => res.end());
         }, () => {
-            // Add complete assistant response to session
-            if (fullResponse || fullThinking) {
-                chatService.addMessage(sessionId, {
-                    role: 'assistant',
-                    content: fullResponse,
-                    thinking: fullThinking || undefined,
-                    model: session.model,
-                    providerMetadata: withSearchSources(undefined),
-                }, userId);
-            }
-            res.write(`data: ${JSON.stringify({ type: 'done' })}\n\n`);
-            res.end();
-        }, undefined, { userId });
+            if (signal.aborted || res.writableEnded)
+                return;
+            void (async () => {
+                if (fullResponse || fullThinking) {
+                    await chatService.addMessage(sessionId, {
+                        role: 'assistant',
+                        content: fullResponse,
+                        thinking: fullThinking || undefined,
+                        model: session.model,
+                        providerMetadata: withSearchSources(undefined),
+                    }, userId, {
+                        assertPersistenceAllowed: () => throwIfChatGenerationCancelled(signal),
+                    });
+                }
+                if (signal.aborted || res.writableEnded)
+                    return;
+                await emitDurable({ type: 'done' });
+                res.end();
+            })().catch(error => {
+                if (signal.aborted || res.writableEnded)
+                    return;
+                void emitDurable({
+                    type: 'error',
+                    error: getErrorMessage(error, 'Failed to save response'),
+                })
+                    .catch(() => undefined)
+                    .finally(() => res.end());
+            });
+        }, signal, { userId });
     }
     catch (error) {
+        if (isChatGenerationCancelled(error, signal)) {
+            if (!res.writableEnded)
+                res.end();
+            return;
+        }
         if (!res.headersSent) {
             res
                 .status(error instanceof ChatProviderSelectionError ? 400 : 500)
@@ -689,9 +1112,17 @@ router.post('/sessions/:sessionId/generate/stream', async (req, res) => {
             });
             return;
         }
-        res.write(`data: ${JSON.stringify({ type: 'error', error: getErrorMessage(error, 'Failed to generate stream response') })}\n\n`);
+        if (emitDurable) {
+            await emitDurable({
+                type: 'error',
+                error: getErrorMessage(error, 'Failed to generate stream response'),
+            }).catch(() => undefined);
+        }
         res.end();
     }
+    finally {
+        cleanup();
+    }
 });
 // Generate a title for a chat session based on the first message
 router.post('/sessions/:sessionId/generate-title', async (req, res) => {
@@ -745,10 +1176,13 @@ router.post('/sessions/:sessionId/generate-title', async (req, res) => {
     }
 });
 // Session folders
-router.get('/folders', (req, res) => {
+router.get('/folders', async (req, res) => {
     try {
         const userId = req.user?.userId || 'default';
-        res.json({ success: true, data: chatService.getSessionFolders(userId) });
+        res.json({
+            success: true,
+            data: await chatService.getSessionFolders(userId),
+        });
     }
     catch (error) {
         res.status(500).json({
@@ -757,24 +1191,24 @@ router.get('/folders', (req, res) => {
         });
     }
 });
-router.post('/folders', (req, res) => {
+router.post('/folders', async (req, res) => {
     try {
         const { name } = req.body;
         const userId = req.user?.userId || 'default';
         res.json({
             success: true,
-            data: chatService.createSessionFolder(name, userId),
+            data: await chatService.createSessionFolder(name, userId),
         });
     }
     catch (error) {
         sendSessionFolderError(res, error, 'Failed to create folder');
     }
 });
-router.put('/folders/:folderId', (req, res) => {
+router.put('/folders/:folderId', async (req, res) => {
     try {
         const { name } = req.body;
         const userId = req.user?.userId || 'default';
-        const folder = chatService.renameSessionFolder(req.params.folderId, name, userId);
+        const folder = await chatService.renameSessionFolder(req.params.folderId, name, userId);
         if (!folder) {
             res.status(404).json({ success: false, error: 'Folder not found' });
             return;
@@ -785,10 +1219,10 @@ router.put('/folders/:folderId', (req, res) => {
         sendSessionFolderError(res, error, 'Failed to rename folder');
     }
 });
-router.delete('/folders/:folderId', (req, res) => {
+router.delete('/folders/:folderId', async (req, res) => {
     try {
         const userId = req.user?.userId || 'default';
-        const deleted = chatService.deleteSessionFolder(req.params.folderId, userId);
+        const deleted = await chatService.deleteSessionFolder(req.params.folderId, userId);
         if (!deleted) {
             res.status(404).json({ success: false, error: 'Folder not found' });
             return;
@@ -844,7 +1278,7 @@ router.post('/sessions/:sessionId/messages/:messageId/branch', authenticate, cha
             });
             return;
         }
-        const updatedMessage = chatService.switchMessageBranch(sessionId, messageId, branchIndex, userId);
+        const updatedMessage = await chatService.switchMessageBranch(sessionId, messageId, branchIndex, userId);
         if (!updatedMessage) {
             res.status(404).json({
                 success: false,
@@ -853,7 +1287,7 @@ router.post('/sessions/:sessionId/messages/:messageId/branch', authenticate, cha
             return;
         }
         // Return the updated session
-        const session = chatService.getSession(sessionId, userId);
+        const session = await chatService.getSession(sessionId, userId);
         res.json({
             success: true,
             data: session,
@@ -876,7 +1310,7 @@ router.get('/sessions/:sessionId/messages/:messageId/branches', authenticate, ch
         const sessionId = req.params.sessionId;
         const messageId = req.params.messageId;
         const userId = req.user?.userId || 'default';
-        const branches = chatService.getMessageBranches(sessionId, messageId, userId);
+        const branches = await chatService.getMessageBranches(sessionId, messageId, userId);
         res.json({
             success: true,
             data: branches,
@@ -907,7 +1341,7 @@ router.post('/sessions/:sessionId/messages/:messageId/branches', authenticate, c
             });
             return;
         }
-        const newBranch = chatService.createMessageBranch(sessionId, messageId, messageData, userId);
+        const newBranch = await chatService.createMessageBranch(sessionId, messageId, messageData, userId);
         if (!newBranch) {
             res.status(404).json({
                 success: false,