@multiplayer-app/ai-agent-node 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/esm/processors/ChatProcessor.js

@@ -1,54 +1,86 @@
 import { AgentStatus, AgentToolCallStatus, ChatType, MessageRole, SortOrder, StreamChunkType } from '@multiplayer-app/ai-agent-types';
-import { socketService } from '../services/index.js';
-import { kafkaService } from '../services/index.js';
-import { AIHelper } from '../helpers/index.js';
-import { AgentProcessEventType, agentStore } from '../store/index.js';
-import { ContextLimiter } from '../helpers/index.js';
-import { config } from '../config.js';
-import { PassThrough, pipeline } from 'stream';
-import { promisify } from 'util';
-import { logger } from '../libs/logger/index.js';
-const pipelineAsync = promisify(pipeline);
+import { AIHelper, FileHelper } from '../helpers';
+import { AgentProcessEventType } from '../store';
+import { ContextLimiter } from '../helpers';
+import { PassThrough } from 'stream';
+import { logger } from '../libs/logger';
 export class ChatProcessor {
-    constructor(chatRepository, messageRepository, artifactStore) {
-        this.chatRepository = chatRepository;
-        this.messageRepository = messageRepository;
-        this.artifactStore = artifactStore;
+    aiHelper;
+    chatRepository;
+    messageRepository;
+    artifactStore;
+    config;
+    socketService;
+    agentStore;
+    constructor(params) {
+        this.chatRepository = params.chatRepository;
+        this.messageRepository = params.messageRepository;
+        this.artifactStore = params.artifactStore;
+        this.config = params.config;
+        this.socketService = params.socketService;
+        this.agentStore = params.agentStore;
+        const fileHelper = new FileHelper(params.s3Lib, this.config);
+        this.aiHelper = new AIHelper(fileHelper, this.config);
     }
     getTemporaryTitle(contextKey) {
         return `${contextKey} session ${new Date().toISOString()}`;
     }
+    isTemporaryTitle(title) {
+        // Matches pattern: "{contextKey} session {ISO_DATE_STRING}"
+        // Example: "default session 2026-01-23T10:30:45.123Z"
+        // toISOString() always includes milliseconds, so we require them
+        const pattern = /^.+ session \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+        return pattern.test(title);
+    }
     async listChats(params) {
-        var _a, _b;
         // Build filter object from params
         const filter = {};
-        if (params === null || params === void 0 ? void 0 : params.userId) {
+        if (params?.userId) {
             filter.userId = params.userId;
         }
-        if (params === null || params === void 0 ? void 0 : params.contextKey) {
+        if (params?.contextKey) {
             filter.contextKey = params.contextKey;
         }
-        // Build query options for sort and limit with defaults
+        // Build query options for sort and limit with defaults.
         const options = {
             sort: {
-                field: (_a = params === null || params === void 0 ? void 0 : params.sortField) !== null && _a !== void 0 ? _a : 'updatedAt',
-                order: (_b = params === null || params === void 0 ? void 0 : params.sortOrder) !== null && _b !== void 0 ? _b : SortOrder.Desc
+                field: params?.sortField ?? 'updatedAt',
+                order: params?.sortOrder ?? SortOrder.Desc
             },
-            limit: params === null || params === void 0 ? void 0 : params.limit
+            skip: params?.skip,
+            limit: params?.limit
+        };
+        const [total, data] = await Promise.all([
+            this.chatRepository.count(filter),
+            this.chatRepository.find(filter, options)
+        ]);
+        return {
+            cursor: {
+                ...(params?.skip != null ? { skip: params.skip } : {}),
+                ...(params?.limit != null ? { limit: params.limit } : {}),
+                total
+            },
+            data
         };
-        // Use aggregation to fetch chats with related messages
-        return this.chatRepository.findWithMessages(filter, options);
     }
     async getChat(chatId) {
         const chat = await this.chatRepository.findById(chatId);
         if (!chat) {
             throw new Error('Chat not found');
         }
-        const messages = await this.messageRepository.findByChatId(chatId);
-        return {
-            ...chat,
-            messages
-        };
+        return chat;
+    }
+    /**
+     * Get messages for a chat with optional cursor pagination.
+     * When limit is omitted, returns all messages (backward compatible).
+     * Messages are returned in chronological order (oldest → newest).
+     */
+    async getMessages(chatId, options) {
+        const chat = await this.chatRepository.findById(chatId);
+        if (!chat) {
+            throw new Error('Chat not found');
+        }
+        return this.messageRepository.findByChatIdPaginated(chatId, options);
     }
     async deleteChat(chatId) {
         const deleted = await this.chatRepository.delete(chatId);
@@ -58,8 +90,7 @@ export class ChatProcessor {
         this.artifactStore.deleteArtifacts(chatId);
     }
     async upsertAndGetChat(payload, excludeSocketId) {
-        var _a;
-        const targetUserId = (_a = payload.userId) !== null && _a !== void 0 ? _a : 'guest';
+        const targetUserId = payload.userId ?? 'guest';
         let chat = null;
         if (payload.chatId) {
             chat = await this.chatRepository.findById(payload.chatId);
@@ -91,7 +122,7 @@ export class ChatProcessor {
         if (!content) {
             return this.getTemporaryTitle(payload.contextKey);
         }
-        return AIHelper.generateTitleForMessage(payload.contextKey, [{
+        return this.aiHelper.generateTitleForMessage(payload.contextKey, [{
                 role: MessageRole.User,
                 content: content
             }]);
@@ -102,18 +133,17 @@ export class ChatProcessor {
             role,
             content: messageData.content,
             agentName: messageData.agentName,
-            attachments: attachments !== null && attachments !== void 0 ? attachments : [],
+            attachments: attachments ?? [],
             reasoning: "",
             toolCalls: []
         });
         if (chat.userId) {
-            socketService.emitMessageUpdate(chat.userId, message, excludeSocketId);
+            this.socketService.emitMessageUpdate(chat.userId, message, excludeSocketId);
         }
         return message;
     }
     async createChat(payload, excludeSocketId) {
-        var _a;
-        const targetUserId = (_a = payload.userId) !== null && _a !== void 0 ? _a : 'guest';
+        const targetUserId = payload.userId ?? 'guest';
         const contextKey = 'contextKey' in payload ? payload.contextKey : 'default';
         const metadata = 'metadata' in payload ? payload.metadata : {};
         const chat = await this.chatRepository.create({
@@ -125,12 +155,7 @@ export class ChatProcessor {
             metadata,
             ...(payload.model ? { model: payload.model } : {})
         });
-        await kafkaService.sendChatTitleGenerationEvent(chat.id);
-        const initialChatResponse = {
-            ...chat,
-            messages: []
-        };
-        socketService.emitChatUpdate(targetUserId, initialChatResponse, excludeSocketId);
+        this.socketService.emitChatUpdate(targetUserId, chat, excludeSocketId);
         return chat;
     }
     /**
@@ -138,23 +163,22 @@ export class ChatProcessor {
      * This updates the message containing the tool call and optionally appends a System message.
      */
     async recordToolCallAction(params) {
-        var _a, _b, _c, _d;
         const chat = await this.chatRepository.findById(params.chatId);
         if (!chat) {
             throw new Error('Chat not found');
         }
         const messages = await this.messageRepository.findByChatId(params.chatId);
-        const message = messages.find((m) => { var _a; return ((_a = m.toolCalls) !== null && _a !== void 0 ? _a : []).some((c) => c.id === params.toolCallId); });
+        const message = messages.find((m) => (m.toolCalls ?? []).some((c) => c.id === params.toolCallId));
         if (!message) {
             throw new Error('Tool call not found');
         }
-        const toolCalls = (_a = message.toolCalls) !== null && _a !== void 0 ? _a : [];
+        const toolCalls = message.toolCalls ?? [];
         const target = toolCalls.find((c) => c.id === params.toolCallId);
         if (!target) {
             throw new Error('Tool call not found');
         }
         const now = new Date().toISOString();
-        const output = ((_b = target.output) !== null && _b !== void 0 ? _b : {});
+        const output = (target.output ?? {});
         const mp = (output['_mp'] && typeof output['_mp'] === 'object' && !Array.isArray(output['_mp']))
             ? output['_mp']
             : {};
@@ -164,14 +188,14 @@ export class ChatProcessor {
             lastAction: {
                 action: params.action,
                 at: now,
-                data: (_c = params.data) !== null && _c !== void 0 ? _c : {},
+                data: params.data ?? {},
             },
             actions: [
                 ...actions,
                 {
                     action: params.action,
                     at: now,
-                    data: (_d = params.data) !== null && _d !== void 0 ? _d : {},
+                    data: params.data ?? {},
                 }
             ]
         };
@@ -186,7 +210,7 @@ export class ChatProcessor {
         await this.messageRepository.update(message.id, { toolCalls });
         // Bump chat updatedAt so listChats ordering reflects the action.
         await this.chatRepository.update(chat.id, { updatedAt: now });
-        socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
+        this.socketService.emitMessageUpdate(chat.userId, updatedMessage, params.excludeSocketId);
         if (params.systemMessage) {
             //todo discuss support for system messages
             //await this.createMessage(chat, MessageRole.System, params.systemMessage, undefined, params.excludeSocketId);
@@ -194,26 +218,25 @@ export class ChatProcessor {
         return { ok: true };
     }
     async streamMessageStep(params) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const { chat, assistantMessage, existingMessages, signal, excludeSocketId, agentOptions } = params;
         if (signal.aborted) {
             return;
         }
-        const result = await AIHelper.streamAssistantResponse(existingMessages, signal, agentOptions);
+        const result = await this.aiHelper.streamAssistantResponse(existingMessages, signal, agentOptions);
         try {
             for await (const chunk of result.fullStream) {
                 if (chunk.type === 'error') {
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: chunk.error });
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: chunk.error });
                     assistantMessage.content = chunk.error.message || 'Sorry, I cannot process you request due to the error';
                     await this.messageRepository.update(assistantMessage.id, assistantMessage);
                     await this.chatRepository.update(chat.id, { status: AgentStatus.Error });
                     continue;
                 }
                 if (chunk.type === 'abort') {
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Aborted, data: undefined });
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Aborted, data: undefined });
                     await this.chatRepository.update(chat.id, { status: AgentStatus.Aborted });
                     await this.messageRepository.update(assistantMessage.id, assistantMessage);
-                    socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
                     continue;
                 }
                 if (chunk.type === 'finish') {
@@ -226,41 +249,27 @@ export class ChatProcessor {
                     }
                     if (chunk.totalUsage && typeof chunk.totalUsage === 'object') {
                         const totalUsage = chunk.totalUsage;
-                        assistantMessage.tokens = (_a = totalUsage.totalTokens) !== null && _a !== void 0 ? _a : (((_b = totalUsage.promptTokens) !== null && _b !== void 0 ? _b : 0) + ((_c = totalUsage.completionTokens) !== null && _c !== void 0 ? _c : 0));
+                        assistantMessage.tokens = totalUsage.totalTokens ??
+                            ((totalUsage.promptTokens ?? 0) + (totalUsage.completionTokens ?? 0));
                     }
                     await this.messageRepository.update(assistantMessage.id, { ...assistantMessage });
                     if (chunk.finishReason === 'stop') {
-                        if ((_d = assistantMessage.toolCalls) === null || _d === void 0 ? void 0 : _d.some(toolCall => toolCall.requiresConfirmation && toolCall.approvalId && !toolCall.output)) {
-                            await this.chatRepository.update(chat.id, { status: AgentStatus.WaitingForUserAction });
-                        }
-                        else if (!assistantMessage.content && ((_e = assistantMessage.toolCalls) === null || _e === void 0 ? void 0 : _e.length) && assistantMessage.toolCalls[((_f = assistantMessage.toolCalls) === null || _f === void 0 ? void 0 : _f.length) - 1].output) {
-                            // handle tool-calls stop, openrouter provider does not return valid type
-                            await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
-                            await this.streamMessageStep(params);
-                            continue;
-                        }
-                        else {
-                            await this.chatRepository.update(chat.id, { status: AgentStatus.Finished });
+                        await this.chatRepository.update(chat.id, { status: AgentStatus.Finished });
+                        if (chat.title && this.isTemporaryTitle(chat.title)) {
+                            const title = await this.aiHelper.generateTitleForMessage(chat.contextKey, existingMessages);
+                            await this.chatRepository.update(chat.id, { title });
+                            this.socketService.emitChatUpdate(chat.userId, { ...chat, title });
                         }
-                        await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
-                        continue;
                     }
                     if (chunk.finishReason === 'tool-calls') {
-                        if ((_g = assistantMessage.toolCalls) === null || _g === void 0 ? void 0 : _g.some(toolCall => toolCall.requiresConfirmation && toolCall.approvalId && !toolCall.output)) {
+                        if (assistantMessage.toolCalls?.some(toolCall => toolCall.requiresConfirmation && toolCall.approvalId && !toolCall.output)) {
                             await this.chatRepository.update(chat.id, { status: AgentStatus.WaitingForUserAction });
-                            await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
-                        }
-                        else {
-                            await agentStore.shareAgentProcessEvent(chat.id, {
-                                type: AgentProcessEventType.Update,
-                                data: assistantMessage
-                            });
-                            await this.streamMessageStep(params);
+                            await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+                            continue;
                         }
-                        continue;
                     }
                     //todo: Handle other finish reasons // length, content, error, other, undefined
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
                     continue;
                 }
                 if (chunk.type === 'text-delta') {
@@ -269,8 +278,8 @@ export class ChatProcessor {
                         ...assistantMessage,
                         content: assistantMessage.content
                     };
-                    socketService.emitMessageUpdate(chat.userId, updatedMessage, excludeSocketId);
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: updatedMessage });
+                    this.socketService.emitMessageUpdate(chat.userId, updatedMessage, excludeSocketId);
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: updatedMessage });
                     await this.messageRepository.update(assistantMessage.id, { content: assistantMessage.content });
                     continue;
                 }
@@ -285,8 +294,8 @@ export class ChatProcessor {
                     });
                     continue;
                 }
-                if (chunk.type === 'tool-call') { //Todo possible place to handle user-approval
-                    const toolCall = (_h = assistantMessage.toolCalls) === null || _h === void 0 ? void 0 : _h.find(toolCall => toolCall.id === chunk.toolCallId);
+                if (chunk.type === 'tool-call') {
+                    const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
                     if (toolCall) {
                         toolCall.status = AgentToolCallStatus.Running;
                         toolCall.input = chunk.input;
@@ -294,15 +303,15 @@ export class ChatProcessor {
                     continue;
                 }
                 if (chunk.type === 'tool-error') {
-                    const toolCall = (_j = assistantMessage.toolCalls) === null || _j === void 0 ? void 0 : _j.find(toolCall => toolCall.id === chunk.toolCallId);
+                    const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
                     if (toolCall) {
                         toolCall.status = AgentToolCallStatus.Failed;
-                        toolCall.error = JSON.stringify(chunk.error);
+                        toolCall.error = chunk.error.message || JSON.stringify(chunk.error);
                     }
                     continue;
                 }
                 if (chunk.type === 'tool-approval-request') {
-                    const toolCall = (_k = assistantMessage.toolCalls) === null || _k === void 0 ? void 0 : _k.find(toolCall => toolCall.id === chunk.toolCall.toolCallId);
+                    const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCall.toolCallId);
                     if (toolCall) {
                         toolCall.requiresConfirmation = true;
                         toolCall.approvalId = chunk.approvalId;
@@ -310,7 +319,7 @@ export class ChatProcessor {
                     continue;
                 }
                 if (chunk.type === 'tool-result') {
-                    const toolCall = (_l = assistantMessage.toolCalls) === null || _l === void 0 ? void 0 : _l.find(toolCall => toolCall.id === chunk.toolCallId);
+                    const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
                     if (toolCall) {
                         if (chunk.output.requiresApproval) {
                             toolCall.requiresConfirmation = true;
@@ -325,9 +334,9 @@ export class ChatProcessor {
                     if (!assistantMessage.reasoning)
                         assistantMessage.reasoning = '';
                     assistantMessage.reasoning += chunk.text;
-                    socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+                    this.socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
                     await this.messageRepository.update(assistantMessage.id, { reasoning: assistantMessage.reasoning });
-                    await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
+                    await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: assistantMessage });
                     continue;
                 }
             }
@@ -336,7 +345,7 @@ export class ChatProcessor {
             if (streamError instanceof Error && streamError.name === 'AbortError') {
                 return;
             }
-            await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: streamError });
+            await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: streamError });
             throw streamError;
         }
     }
@@ -344,16 +353,15 @@ export class ChatProcessor {
         return 'approvalId' in payload;
     }
     async processApprovalPayload(chat, payload) {
-        var _a, _b, _c;
         const assistantMessage = await this.messageRepository.findById(payload.messageId);
         if (!assistantMessage || assistantMessage.chat !== chat.id) {
             throw new Error(`Assistant message with id ${payload.messageId} not found`);
         }
-        const agentOptions = await AIHelper.getAgentOptions({
+        const agentOptions = await this.aiHelper.getAgentOptions({
             agentName: assistantMessage.agentName,
             context: payload.context
         });
-        const toolCall = (_a = assistantMessage.toolCalls) === null || _a === void 0 ? void 0 : _a.find(tc => tc.approvalId === payload.approvalId);
+        const toolCall = assistantMessage.toolCalls?.find(tc => tc.approvalId === payload.approvalId);
         if (!toolCall) {
             // continue, tool is not found
             return {
@@ -371,7 +379,7 @@ export class ChatProcessor {
             toolCall.status = AgentToolCallStatus.Failed;
         }
         else {
-            const executeFunction = (_c = (_b = agentOptions.tools) === null || _b === void 0 ? void 0 : _b[toolCall.name]) === null || _c === void 0 ? void 0 : _c.execute;
+            const executeFunction = agentOptions.tools?.[toolCall.name]?.execute;
             if (executeFunction) {
                 try {
                     toolCall.output = await executeFunction(toolCall.input, { toolCallId: toolCall.id, messages: [] });
@@ -402,15 +410,15 @@ export class ChatProcessor {
     }
     async processNewUserMessage(chat, payload, prevMessages, excludeSocketId) {
         const userMessage = await this.createMessage(chat, MessageRole.User, { content: payload.content, agentName: undefined }, payload.attachments);
-        await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: userMessage });
-        const agentOptions = await AIHelper.getAgentOptions({
+        await this.agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: userMessage });
+        const agentOptions = await this.aiHelper.getAgentOptions({
             contextKey: chat.contextKey,
-            messages: await AIHelper.convertMessages([...prevMessages, userMessage], true),
+            messages: [...prevMessages, userMessage],
             context: payload.context,
             agentName: undefined,
             modelId: chat.model,
         });
-        const assistantMessage = await this.createMessage(chat, MessageRole.Assistant, { content: ' ', agentName: agentOptions.name }, undefined, excludeSocketId);
+        const assistantMessage = await this.createMessage(chat, MessageRole.Assistant, { content: '', agentName: agentOptions.name }, undefined, excludeSocketId);
         assistantMessage.content = '';
         return {
             userMessage,
@@ -420,14 +428,14 @@ export class ChatProcessor {
     }
     async streamMessage(chat, payload, excludeSocketId, onAgentStart) {
         try {
-            const abortController = agentStore.registerAgentProcess(chat.id);
-            onAgentStart === null || onAgentStart === void 0 ? void 0 : onAgentStart();
+            const abortController = this.agentStore.registerAgentProcess(chat.id);
+            onAgentStart?.();
             let assistantMessage;
             let agentOptions;
             const existingMessages = await this.messageRepository.findByChatId(chat.id);
             // Limit context to prevent exceeding token limits
             const limitedMessages = ContextLimiter.limitContext(existingMessages, {
-                maxMessages: config.ai.maxContextMessages,
+                maxMessages: this.config.ai.maxContextMessages,
                 keepFirstUserMessage: true,
                 keepSystemMessages: true,
             });
@@ -492,7 +500,7 @@ export class ChatProcessor {
                 return null;
         }
     }
-    getMessageStream(chatId) {
+    getMessageStream(chatId, signal) {
         const stream = new PassThrough();
         let ended = false;
         const endStream = (error) => {
@@ -513,13 +521,15 @@ export class ChatProcessor {
             }
         };
         const pushChunk = (chunk) => {
-            if (ended || stream.destroyed || stream.writableEnded)
+            if (ended || stream.destroyed || stream.writableEnded || signal?.aborted)
                 return;
             stream.write(`data: ${JSON.stringify(chunk)}\n\n`);
         };
         const listener = (event) => {
-            if (ended)
+            if (signal?.aborted) {
+                endStream();
                 return;
+            }
             try {
                 const chunk = this.eventToChunk(event);
                 if (chunk) {
@@ -529,7 +539,6 @@ export class ChatProcessor {
                     event.type === AgentProcessEventType.Error ||
                     event.type === AgentProcessEventType.Aborted) {
                     endStream();
-                    agentStore.removeListener(chatId, listener);
                 }
             }
             catch (err) {
@@ -538,21 +547,18 @@ export class ChatProcessor {
                     error: err instanceof Error ? err.message : 'Unknown error occurred',
                 });
                 endStream(err);
-                agentStore.removeListener(chatId, listener);
             }
         };
-        // Cleanup on consumer side closing
         const closeHandler = () => {
-            agentStore.removeListener(chatId, listener);
+            this.agentStore.removeListener(chatId, listener);
         };
         const errorHandler = (err) => {
-            logger.error({ err }, 'Readable stream error');
-            agentStore.removeListener(chatId, listener);
+            signal?.removeEventListener('abort', endStream);
             endStream(err);
         };
         stream.on('close', closeHandler);
         stream.on('error', errorHandler);
-        const listenerAttached = agentStore.addListener(chatId, listener);
+        const listenerAttached = this.agentStore.addListener(chatId, listener);
         if (!listenerAttached) {
             // Remove stream listeners if listener attachment failed to prevent memory leak
             stream.removeListener('close', closeHandler);
@@ -561,50 +567,27 @@ export class ChatProcessor {
         }
         return stream;
     }
-    async createMessageStream(payload, excludeSocketId) {
+    async createMessageStream(payload, excludeSocketId, signal) {
         const stream = new PassThrough();
-        (async () => {
-            try {
-                const chat = await this.upsertAndGetChat(payload, excludeSocketId);
-                // Send chat metadata first
-                if (!('chatId' in payload) && !('messageId' in payload) && chat) {
-                    stream.write(`data: ${JSON.stringify({
-                        type: StreamChunkType.Chat,
-                        chatId: chat.id,
-                        chat,
-                    })}\n\n`);
-                }
-                await this.streamMessage(chat, payload, excludeSocketId, async () => {
-                    if (stream.destroyed || stream.writableEnded) {
-                        return;
-                    }
-                    const messageStream = this.getMessageStream(chat.id);
-                    // If client disconnects, destroy inner stream
-                    stream.on('close', () => {
-                        if (!messageStream.destroyed) {
-                            messageStream.destroy();
-                        }
-                    });
-                    await pipelineAsync(messageStream, stream);
-                });
-            }
-            catch (error) {
-                logger.error({ error }, 'createMessageStream failed');
-                if (!stream.destroyed && !stream.writableEnded) {
-                    stream.write(`data: ${JSON.stringify({
-                        type: StreamChunkType.Error,
-                        error: error instanceof Error ? error.message : 'Unknown error occurred',
-                    })}\n\n`);
-                    stream.write('data: [DONE]\n\n');
-                    stream.end();
-                }
-            }
-        })().catch((err) => {
-            logger.error({ err }, 'Unhandled stream task error');
-            if (!stream.destroyed)
-                stream.destroy(err);
+        this.runMessageStream(stream, payload, excludeSocketId, signal)
+            .catch(err => {
+            logger.error({ err }, 'Stream task failed');
         });
         return stream;
     }
+    async runMessageStream(stream, payload, excludeSocketId, signal) {
+        const chat = await this.upsertAndGetChat(payload, excludeSocketId);
+        if (!('chatId' in payload) && !('messageId' in payload) && chat) {
+            stream.write(`data: ${JSON.stringify({
+                type: StreamChunkType.Chat,
+                chatId: chat.id,
+                chat,
+            })}\n\n`);
+        }
+        await this.streamMessage(chat, payload, excludeSocketId, () => {
+            const messageStream = this.getMessageStream(chat.id, signal);
+            messageStream.pipe(stream);
+        });
+    }
 }
 //# sourceMappingURL=ChatProcessor.js.map