@multiplayer-app/ai-agent-node 0.0.1

package/src/processors/ChatProcessor.ts

@@ -0,0 +1,713 @@
+import type {AgentChatRepository, AgentMessageRepository} from '@multiplayer-app/ai-agent-db';
+import {
+  AgentArtifact,
+  AgentChat,
+  AgentChatResponse,
+  AgentAttachment,
+  AgentMessage,
+  AgentStatus,
+  AgentToolCallStatus,
+  ChatType,
+  MessageRole,
+  SendMessagePayload,
+  SortOrder,
+  StreamChunk,
+  StreamChunkType,
+  SendMessagePayloadWithApproval,
+  SendMessagePayloadWithContent,
+  AdditionalContext
+} from '@multiplayer-app/ai-agent-types';
+import { ArtifactStore } from '../store';
+import { socketService } from '../services';
+import { kafkaService } from '../services';
+import { AIHelper } from '../helpers';
+import { AgentProcessEventType, AgentProcessEvent, agentStore } from '../store';
+import { GenerateTextOptions } from '../services';
+import { ContextLimiter } from '../helpers';
+import { config } from '../config';
+import { PassThrough, pipeline } from 'stream';
+import { promisify } from 'util';
+import { logger } from '../libs/logger';
+
+const pipelineAsync = promisify(pipeline);
+
+
+export class ChatProcessor {
+  constructor(
+    private chatRepository: AgentChatRepository,
+    private messageRepository: AgentMessageRepository,
+    private artifactStore: ArtifactStore
+  ) { }
+
+  private getTemporaryTitle(contextKey: string): string {
+    return `${contextKey} session ${new Date().toISOString()}`;
+  }
+
+  async listChats(params?: {
+    contextKey?: string;
+    limit?: number;
+    userId?: string;
+    sortField?: string;
+    sortOrder?: SortOrder;
+  }): Promise<AgentChatResponse[]> {
+    // Build filter object from params
+    const filter: Partial<AgentChat> = {};
+    if (params?.userId) {
+      filter.userId = params.userId;
+    }
+    if (params?.contextKey) {
+      filter.contextKey = params.contextKey;
+    }
+
+    // Build query options for sort and limit with defaults
+    const options = {
+      sort: {
+        field: params?.sortField ?? 'updatedAt',
+        order: params?.sortOrder ?? SortOrder.Desc
+      },
+      limit: params?.limit
+    };
+
+    // Use aggregation to fetch chats with related messages
+    return this.chatRepository.findWithMessages(
+      filter,
+      options
+    );
+  }
+
+  async getChat(chatId: string): Promise<AgentChatResponse> {
+    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
+    };
+  }
+
+  async deleteChat(chatId: string): Promise<void> {
+    const deleted = await this.chatRepository.delete(chatId);
+    if (!deleted) {
+      throw new Error('Chat not found');
+    }
+    this.artifactStore.deleteArtifacts(chatId);
+  }
+
+  async upsertAndGetChat(payload: SendMessagePayload, excludeSocketId?: string) {
+    const targetUserId = payload.userId ?? 'guest';
+    let chat: AgentChat | null = null;
+
+    if (payload.chatId) {
+      chat = await this.chatRepository.findById(payload.chatId);
+      if (!chat) {
+        throw new Error('Chat not found');
+      }
+      // Ensure chat is associated with the caller's userId
+      if (chat.userId && chat.userId !== targetUserId) {
+        throw new Error('Chat does not belong to this user');
+      }
+    }
+
+    if (!chat) {
+      chat = await this.createChat(payload as SendMessagePayloadWithContent, excludeSocketId);
+    } else if ('model' in payload) {
+      chat.model = payload.model || undefined;
+      await this.chatRepository.update(chat.id, { model: chat.model });
+    }
+
+    return chat;
+  }
+
+  async getChatTitle(payload: {
+    chatId?: string;
+    content?: string;
+    contextKey: string;
+    userId?: string;
+  }): Promise<string> {
+    if (payload.chatId) {
+      const chat = await this.chatRepository.findById(payload.chatId);
+      if (chat && chat.title) {
+        return chat.title;
+      }
+    }
+
+    const content = payload.content;
+    if (!content) {
+      return this.getTemporaryTitle(payload.contextKey)
+    }
+    return AIHelper.generateTitleForMessage(payload.contextKey, [{
+      role: MessageRole.User,
+      content: content
+    }]);
+  }
+
+  async createMessage(chat: AgentChat, role: MessageRole, messageData: Pick<AgentMessage, 'content' | 'agentName'>, attachments?: AgentAttachment[], excludeSocketId?: string): Promise<AgentMessage> {
+    const message = await this.messageRepository.create({
+      chat: chat.id,
+      role,
+      content: messageData.content,
+      agentName: messageData.agentName,
+      attachments: attachments ?? [],
+      reasoning: "",
+      toolCalls: []
+    });
+    if (chat.userId) {
+      socketService.emitMessageUpdate(chat.userId, message, excludeSocketId);
+    }
+    return message;
+  }
+
+  async createChat(payload: SendMessagePayload, excludeSocketId?: string): Promise<AgentChat> {
+    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({
+      title: this.getTemporaryTitle(contextKey),
+      type: ChatType.Chat,
+      status: AgentStatus.Streaming,
+      contextKey,
+      userId: targetUserId,
+      metadata,
+      ...(payload.model ? { model: payload.model } : {})
+    });
+    await kafkaService.sendChatTitleGenerationEvent(chat.id);
+    const initialChatResponse: AgentChatResponse = {
+      ...chat,
+      messages: []
+    };
+    socketService.emitChatUpdate(targetUserId, initialChatResponse, excludeSocketId);
+
+    return chat;
+  }
+
+  /**
+   * Persist a client-side action against a tool call (generic mechanism).
+   * This updates the message containing the tool call and optionally appends a System message.
+   */
+  async recordToolCallAction(params: {
+    chatId: string;
+    toolCallId: string;
+    action: string;
+    data: Record<string, unknown>;
+    systemMessage?: string;
+    excludeSocketId?: string;
+  }): Promise<{ ok: true }> {
+    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) => (m.toolCalls ?? []).some((c) => c.id === params.toolCallId));
+    if (!message) {
+      throw new Error('Tool call not found');
+    }
+
+    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 = (target.output ?? {}) as Record<string, unknown>;
+    const mp = (output['_mp'] && typeof output['_mp'] === 'object' && !Array.isArray(output['_mp']))
+      ? (output['_mp'] as Record<string, unknown>)
+      : {};
+    const actions = Array.isArray(mp['actions']) ? (mp['actions'] as unknown[]) : [];
+
+    const nextMp = {
+      ...mp,
+      lastAction: {
+        action: params.action,
+        at: now,
+        data: params.data ?? {},
+      },
+      actions: [
+        ...actions,
+        {
+          action: params.action,
+          at: now,
+          data: params.data ?? {},
+        }
+      ]
+    };
+
+    target.output = {
+      ...output,
+      _mp: nextMp,
+    };
+
+    const updatedMessage: AgentMessage = {
+      ...message,
+      toolCalls,
+    };
+
+    await this.messageRepository.update(message.id, { toolCalls });
+    // Bump chat updatedAt so listChats ordering reflects the action.
+    await this.chatRepository.update(chat.id, { updatedAt: now } as any);
+    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);
+    }
+
+    return { ok: true };
+  }
+
+  private async streamMessageStep(params: { chat: AgentChat, assistantMessage: AgentMessage, existingMessages: AgentMessage[], signal: AbortSignal, excludeSocketId?: string, agentOptions: Omit<GenerateTextOptions, 'messages'> }): Promise<void> {
+    const { chat, assistantMessage, existingMessages, signal, excludeSocketId, agentOptions } = params;
+    if (signal.aborted) {
+      return;
+    }
+    const result = await 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 as Error });
+          assistantMessage.content = (chunk.error as Record<string, string>).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.chatRepository.update(chat.id, { status: AgentStatus.Aborted });
+          await this.messageRepository.update(assistantMessage.id, assistantMessage);
+          socketService.emitMessageUpdate(chat.userId, assistantMessage, excludeSocketId);
+
+          continue;
+        }
+        if (chunk.type === 'finish') {
+          const index = existingMessages.findIndex(({ id }) => id === assistantMessage.id);
+
+          if (index === -1){
+            existingMessages.push(assistantMessage)
+          } else {
+            existingMessages[index] = assistantMessage;
+          }
+          if (chunk.totalUsage && typeof chunk.totalUsage === 'object') {
+            const totalUsage = chunk.totalUsage as { promptTokens?: number; completionTokens?: number; totalTokens?: number };
+            assistantMessage.tokens = totalUsage.totalTokens ??
+              ((totalUsage.promptTokens ?? 0) + (totalUsage.completionTokens ?? 0));
+          }
+
+          await this.messageRepository.update(assistantMessage.id, { ...assistantMessage });
+          if (chunk.finishReason === 'stop') {
+            if (assistantMessage.toolCalls?.some(toolCall => toolCall.requiresConfirmation && toolCall.approvalId && !toolCall.output)) {
+              await this.chatRepository.update(chat.id, { status: AgentStatus.WaitingForUserAction });
+            } else if (!assistantMessage.content && assistantMessage.toolCalls?.length && assistantMessage.toolCalls[assistantMessage.toolCalls?.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 agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+            continue;
+          }
+          if (chunk.finishReason === 'tool-calls') {
+            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);
+            }
+            continue;
+          }
+          //todo: Handle other finish reasons // length, content, error, other, undefined
+          await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Finished, data: assistantMessage });
+          continue;
+        }
+        if (chunk.type === 'text-delta') {
+          assistantMessage.content += chunk.text;
+          const updatedMessage: AgentMessage = {
+            ...assistantMessage,
+            content: assistantMessage.content
+          };
+          socketService.emitMessageUpdate(chat.userId, updatedMessage, excludeSocketId);
+          await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Update, data: updatedMessage });
+          await this.messageRepository.update(assistantMessage.id, { content: assistantMessage.content });
+          continue;
+        }
+        if (chunk.type === 'tool-input-start') {
+          if (!assistantMessage.toolCalls) assistantMessage.toolCalls = [];
+          assistantMessage.toolCalls.push({
+            id: chunk.id,
+            name: chunk.toolName,
+            status: AgentToolCallStatus.Pending,
+            input: {},
+          });
+          continue;
+        }
+        if (chunk.type === 'tool-call') {//Todo possible place to handle user-approval
+          const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
+          if (toolCall) {
+            toolCall.status = AgentToolCallStatus.Running;
+            toolCall.input = chunk.input;
+          }
+          continue;
+        }
+        if (chunk.type === 'tool-error') {
+          const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
+          if (toolCall) {
+            toolCall.status = AgentToolCallStatus.Failed;
+            toolCall.error = JSON.stringify(chunk.error);
+          }
+          continue;
+        }
+        if (chunk.type === 'tool-approval-request') {
+          const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCall.toolCallId);
+
+          if (toolCall) {
+            toolCall.requiresConfirmation = true;
+            toolCall.approvalId = chunk.approvalId;
+          }
+          continue;
+        }
+        if (chunk.type === 'tool-result') {
+          const toolCall = assistantMessage.toolCalls?.find(toolCall => toolCall.id === chunk.toolCallId);
+
+          if (toolCall) {
+            if (chunk.output.requiresApproval) {
+              toolCall.requiresConfirmation = true;
+              continue;
+            }
+            toolCall.status = AgentToolCallStatus.Succeeded;
+            toolCall.output = chunk.output;
+          }
+          continue;
+        }
+        if (chunk.type === 'reasoning-delta') {
+          if (!assistantMessage.reasoning) assistantMessage.reasoning = ''
+          assistantMessage.reasoning += chunk.text;
+          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 });
+          continue;
+        }
+      }
+    } catch (streamError) {
+      if (streamError instanceof Error && streamError.name === 'AbortError') {
+        return;
+      }
+      await agentStore.shareAgentProcessEvent(chat.id, { type: AgentProcessEventType.Error, data: streamError as Error });
+      throw streamError;
+    }
+  }
+
+  private isApprovalPayload(payload: SendMessagePayload): payload is SendMessagePayloadWithApproval {
+    return 'approvalId' in payload;
+  }
+
+  private async processApprovalPayload(chat: AgentChat, payload: SendMessagePayloadWithApproval & { context?: AdditionalContext }) {
+    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({ 
+      agentName: assistantMessage.agentName, 
+      context: payload.context
+    });
+    const toolCall = assistantMessage.toolCalls?.find(tc => tc.approvalId === payload.approvalId);
+    if (!toolCall) {
+      // continue, tool is not found
+      return {
+        assistantMessage,
+        agentOptions,
+      }
+    }
+
+    toolCall.approved = payload.approved;
+    toolCall.reason = payload.reason;
+
+    if (!toolCall.approved) {
+      toolCall.output = {
+        type: 'execution-denied',
+        reason: toolCall.reason
+      }
+      toolCall.status = AgentToolCallStatus.Failed;
+    } else {
+      const executeFunction = agentOptions.tools?.[toolCall.name]?.execute;
+      if (executeFunction) {
+        try {
+          toolCall.output = await executeFunction(toolCall.input, {toolCallId: toolCall.id, messages: []})
+          toolCall.status = AgentToolCallStatus.Succeeded;
+        } catch(error) {
+          logger.error(error);
+          toolCall.status = AgentToolCallStatus.Failed;
+          toolCall.output = {
+            type: 'execution-denied',
+            reason: 'Tool failed with error'
+          }
+        }
+      } else {
+        toolCall.output = {
+          type: 'execution-denied',
+          reason: 'Tool was not found'
+        }
+        toolCall.status = AgentToolCallStatus.Failed;
+      }
+    }
+
+    await this.messageRepository.update(assistantMessage.id, assistantMessage);
+    return {
+      assistantMessage,
+      agentOptions,
+    }
+  }
+
+  async processNewUserMessage(chat: AgentChat, payload: SendMessagePayloadWithContent & { context?: AdditionalContext }, prevMessages: AgentMessage[], excludeSocketId?: string) {
+    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({
+      contextKey: chat.contextKey,
+      messages: await AIHelper.convertMessages([...prevMessages, userMessage], true),
+      context: payload.context,
+      agentName: undefined,
+      modelId: chat.model,
+    });
+
+    const assistantMessage = await this.createMessage(chat, MessageRole.Assistant, {content: ' ', agentName: agentOptions.name}, undefined, excludeSocketId);
+    assistantMessage.content = ''
+
+    return {
+      userMessage,
+      assistantMessage,
+      agentOptions,
+    }
+  }
+
+  async streamMessage(chat: AgentChat, payload: SendMessagePayload & { context?: AdditionalContext }, excludeSocketId?: string, onAgentStart?: () => void): Promise<void> {
+    try {
+      const abortController = agentStore.registerAgentProcess(chat.id);
+      onAgentStart?.()
+      let assistantMessage: AgentMessage;
+      let agentOptions: Omit<GenerateTextOptions, 'messages'>;
+
+      const existingMessages = await this.messageRepository.findByChatId(chat.id);
+
+      // Limit context to prevent exceeding token limits
+      const limitedMessages = ContextLimiter.limitContext(
+          existingMessages,
+          {
+            maxMessages: config.ai.maxContextMessages,
+            keepFirstUserMessage: true,
+            keepSystemMessages: true,
+          }
+      );
+
+      if (this.isApprovalPayload(payload)) {
+        const result = await this.processApprovalPayload(chat, payload);
+        assistantMessage = result.assistantMessage;
+        agentOptions = result.agentOptions;
+        const foundIndex = limitedMessages.findIndex(m => m.id === result.assistantMessage.id);
+        if(foundIndex === -1) {
+          limitedMessages.push(result.assistantMessage);
+        } else {
+          limitedMessages[foundIndex] = result.assistantMessage;
+        }
+      } else {
+        const result = await this.processNewUserMessage(chat, payload, limitedMessages, excludeSocketId);
+        assistantMessage = result.assistantMessage;
+        agentOptions = result.agentOptions;
+        limitedMessages.push(result.userMessage);
+      }
+
+      await this.streamMessageStep({
+        chat,
+        existingMessages: limitedMessages,
+        assistantMessage,
+        agentOptions,
+        excludeSocketId: excludeSocketId,
+        signal: abortController.signal,
+      })
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  listArtifacts(chatId: string): AgentArtifact[] {
+    return this.artifactStore.listArtifacts(chatId);
+  }
+
+  private eventToChunk(event: AgentProcessEvent): StreamChunk | null {
+    switch (event.type) {
+      case AgentProcessEventType.Update:
+        return {
+          type: StreamChunkType.Message,
+          message: event.data
+        };
+
+      case AgentProcessEventType.Error:
+        return {
+          type: StreamChunkType.Error,
+          error: event.data.message || 'Unknown error occurred'
+        };
+      case AgentProcessEventType.Finished:
+        return {
+          type: StreamChunkType.Message,
+          message: event.data
+        };
+      case AgentProcessEventType.Aborted:
+        // Aborted events don't produce chunks, they just signal stream end
+        return null;
+      case AgentProcessEventType.Stop:
+        // Stop events don't produce chunks
+        return null;
+      default:
+        return null;
+    }
+  }
+
+  getMessageStream(chatId: string): PassThrough {
+    const stream = new PassThrough();
+    let ended = false;
+
+    const endStream = (error?: unknown) => {
+      if (ended) return;
+      ended = true;
+
+      if (error) {
+        logger.error({ error }, 'Message stream error');
+      }
+
+      if (!stream.destroyed && !stream.writableEnded) {
+        try {
+          stream.write('data: [DONE]\n\n');
+          stream.end();
+        } catch (e) {
+          logger.error({ e }, 'Failed to end SSE stream');
+        }
+      }
+    };
+
+    const pushChunk = (chunk: StreamChunk) => {
+      if (ended || stream.destroyed || stream.writableEnded) return;
+      stream.write(`data: ${JSON.stringify(chunk)}\n\n`);
+    };
+
+    const listener = (event: AgentProcessEvent) => {
+      if (ended) return;
+
+      try {
+        const chunk = this.eventToChunk(event);
+        if (chunk) {
+          pushChunk(chunk);
+        }
+
+        if (
+          event.type === AgentProcessEventType.Finished ||
+          event.type === AgentProcessEventType.Error ||
+          event.type === AgentProcessEventType.Aborted
+        ) {
+          endStream();
+          agentStore.removeListener(chatId, listener);
+        }
+      } catch (err) {
+        pushChunk({
+          type: StreamChunkType.Error,
+          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);
+    };
+
+    const errorHandler = (err: Error) => {
+      logger.error({ err }, 'Readable stream error');
+      agentStore.removeListener(chatId, listener);
+      endStream(err);
+    };
+
+    stream.on('close', closeHandler);
+    stream.on('error', errorHandler);
+
+    const listenerAttached = agentStore.addListener(chatId, listener);
+    if (!listenerAttached) {
+      // Remove stream listeners if listener attachment failed to prevent memory leak
+      stream.removeListener('close', closeHandler);
+      stream.removeListener('error', errorHandler);
+      endStream(new Error('Listener could not be attached'));
+    }
+
+    return stream;
+  }
+
+
+  async createMessageStream(
+      payload: SendMessagePayload & { context?: AdditionalContext },
+      excludeSocketId?: string
+  ): Promise<PassThrough> {
+    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);
+    });
+
+    return stream;
+  }
+}