@multiplayer-app/ai-agent-node 0.0.1 → 0.1.0-beta.2

package/src/processors/ChatProcessor.ts

@@ -1,713 +0,0 @@
-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;
-  }
-}