fix(core): Enhanced chat streaming and error handling across providers

ts/provider.anthropic.ts

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type { ChatOptions, ChatResponse, ChatMessage } from './abstract.classes.multimodal.js';
 
 export interface IAnthropicProviderOptions {
   anthropicToken: string;
@@ -23,39 +24,109 @@ export class AnthropicProvider extends MultiModalModel {
 
   async stop() {}
 
-  public async chatStream(input: ReadableStream<string>): Promise<ReadableStream<string>> {
-    // TODO: implement for OpenAI
+  public async chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>> {
+    // Create a TextDecoder to handle incoming chunks
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let currentMessage: { role: string; content: string; } | null = null;
 
-    const returnStream = new ReadableStream();
-    return returnStream;
+    // Create a TransformStream to process the input
+    const transform = new TransformStream<Uint8Array, string>({
+      async transform(chunk, controller) {
+        buffer += decoder.decode(chunk, { stream: true });
+
+        // Try to parse complete JSON messages from the buffer
+        while (true) {
+          const newlineIndex = buffer.indexOf('\n');
+          if (newlineIndex === -1) break;
+
+          const line = buffer.slice(0, newlineIndex);
+          buffer = buffer.slice(newlineIndex + 1);
+
+          if (line.trim()) {
+            try {
+              const message = JSON.parse(line);
+              currentMessage = {
+                role: message.role || 'user',
+                content: message.content || '',
+              };
+            } catch (e) {
+              console.error('Failed to parse message:', e);
+            }
+          }
+        }
+
+        // If we have a complete message, send it to Anthropic
+        if (currentMessage) {
+          const stream = await this.anthropicApiClient.messages.create({
+            model: 'claude-3-opus-20240229',
+            messages: [{ role: currentMessage.role, content: currentMessage.content }],
+            system: '',
+            stream: true,
+            max_tokens: 4000,
+          });
+
+          // Process each chunk from Anthropic
+          for await (const chunk of stream) {
+            const content = chunk.delta?.text;
+            if (content) {
+              controller.enqueue(content);
+            }
+          }
+
+          currentMessage = null;
+        }
+      },
+
+      flush(controller) {
+        if (buffer) {
+          try {
+            const message = JSON.parse(buffer);
+            controller.enqueue(message.content || '');
+          } catch (e) {
+            console.error('Failed to parse remaining buffer:', e);
+          }
+        }
+      }
+    });
+
+    // Connect the input to our transform stream
+    return input.pipeThrough(transform);
   }
 
   // Implementing the synchronous chat interaction
-  public async chat(optionsArg: {
-    systemMessage: string;
-    userMessage: string;
-    messageHistory: {
-      role: 'assistant' | 'user';
-      content: string;
-    }[];
-  }) {
+  public async chat(optionsArg: ChatOptions): Promise<ChatResponse> {
+    // Convert message history to Anthropic format
+    const messages = optionsArg.messageHistory.map(msg => ({
+      role: msg.role === 'assistant' ? 'assistant' as const : 'user' as const,
+      content: msg.content
+    }));
+
     const result = await this.anthropicApiClient.messages.create({
       model: 'claude-3-opus-20240229',
       system: optionsArg.systemMessage,
       messages: [
-        ...optionsArg.messageHistory,
-        { role: 'user', content: optionsArg.userMessage },
+        ...messages,
+        { role: 'user' as const, content: optionsArg.userMessage }
       ],
       max_tokens: 4000,
     });
 
+    // Extract text content from the response
+    let message = '';
+    for (const block of result.content) {
+      if ('text' in block) {
+        message += block.text;
+      }
+    }
+
     return {
-      role: result.role as 'assistant',
-      message: result.content.join('\n'),
+      role: 'assistant' as const,
+      message,
     };
   }
 
-  private async audio(messageArg: string) {
+  public async audio(optionsArg: { message: string }): Promise<NodeJS.ReadableStream> {
     // Anthropic does not provide an audio API, so this method is not implemented.
     throw new Error('Audio generation is not yet supported by Anthropic.');
   }