@lobehub/chat 0.156.1 → 0.157.0

package/src/libs/agent-runtime/togetherai/index.test.ts

@@ -2,9 +2,10 @@
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { ChatStreamCallbacks, LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
+import { LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
 
 import * as debugStreamModule from '../utils/debugStream';
+import models from './fixtures/models.json';
 import { LobeTogetherAI } from './index';
 
 const provider = 'togetherai';
@@ -81,6 +82,7 @@ describe('LobeTogetherAI', () => {
           messages: [{ content: 'Hello', role: 'user' }],
           model: 'mistralai/mistral-7b-instruct:free',
           temperature: 0.7,
+          stream: true,
           top_p: 1,
         },
         { headers: { Accept: '*/*' } },
@@ -253,59 +255,6 @@ describe('LobeTogetherAI', () => {
       });
     });
 
-    describe('LobeTogetherAI chat with callback and headers', () => {
-      it('should handle callback and headers correctly', async () => {
-        // 模拟 chat.completions.create 方法返回一个可读流
-        const mockCreateMethod = vi
-          .spyOn(instance['client'].chat.completions, 'create')
-          .mockResolvedValue(
-            new ReadableStream({
-              start(controller) {
-                controller.enqueue({
-                  id: 'chatcmpl-8xDx5AETP8mESQN7UB30GxTN2H1SO',
-                  object: 'chat.completion.chunk',
-                  created: 1709125675,
-                  model: 'mistralai/mistral-7b-instruct:free',
-                  system_fingerprint: 'fp_86156a94a0',
-                  choices: [
-                    { index: 0, delta: { content: 'hello' }, logprobs: null, finish_reason: null },
-                  ],
-                });
-                controller.close();
-              },
-            }) as any,
-          );
-
-        // 准备 callback 和 headers
-        const mockCallback: ChatStreamCallbacks = {
-          onStart: vi.fn(),
-          onToken: vi.fn(),
-        };
-        const mockHeaders = { 'Custom-Header': 'TestValue' };
-
-        // 执行测试
-        const result = await instance.chat(
-          {
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'mistralai/mistral-7b-instruct:free',
-            temperature: 0,
-          },
-          { callback: mockCallback, headers: mockHeaders },
-        );
-
-        // 验证 callback 被调用
-        await result.text(); // 确保流被消费
-        expect(mockCallback.onStart).toHaveBeenCalled();
-        expect(mockCallback.onToken).toHaveBeenCalledWith('hello');
-
-        // 验证 headers 被正确传递
-        expect(result.headers.get('Custom-Header')).toEqual('TestValue');
-
-        // 清理
-        mockCreateMethod.mockRestore();
-      });
-    });
-
     describe('DEBUG', () => {
       it('should call debugStream and return StreamingTextResponse when DEBUG_TOGETHERAI_CHAT_COMPLETION is 1', async () => {
         // Arrange
@@ -347,4 +296,17 @@ describe('LobeTogetherAI', () => {
       });
     });
   });
+
+  describe('models', () => {
+    it('should get models', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+        json: async () => models,
+        ok: true,
+      } as Response);
+
+      const list = await instance.models();
+
+      expect(list).toMatchSnapshot();
+    });
+  });
 });

package/src/libs/agent-runtime/types/chat.ts

@@ -1,6 +1,6 @@
-import { OpenAIStreamCallbacks } from 'ai';
+import { MessageToolCall } from '@/types/message';
 
-export type LLMRoleType = 'user' | 'system' | 'assistant' | 'function';
+export type LLMRoleType = 'user' | 'system' | 'assistant' | 'function' | 'tool';
 
 interface UserMessageContentPartText {
   text: string;
@@ -30,6 +30,8 @@ export interface OpenAIChatMessage {
    * @description 消息发送者的角色
    */
   role: LLMRoleType;
+  tool_call_id?: string;
+  tool_calls?: MessageToolCall[];
 }
 
 /**
@@ -127,4 +129,18 @@ export interface ChatCompletionTool {
   type: 'function';
 }
 
-export type ChatStreamCallbacks = OpenAIStreamCallbacks;
+export interface ChatStreamCallbacks {
+  /**
+   * `onCompletion`: Called for each tokenized message.
+   **/
+  onCompletion?: (completion: string) => Promise<void> | void;
+  /** `onFinal`: Called once when the stream is closed with the final completion message. */
+  onFinal?: (completion: string) => Promise<void> | void;
+  /** `onStart`: Called once when the stream is initialized. */
+  onStart?: () => Promise<void> | void;
+  /** `onText`: Called for each text chunk. */
+  onText?: (text: string) => Promise<void> | void;
+  /** `onToken`: Called for each tokenized message. */
+  onToken?: (token: string) => Promise<void> | void;
+  onToolCall?: () => Promise<void> | void;
+}

package/src/libs/agent-runtime/utils/anthropicHelpers.test.ts

@@ -1,3 +1,4 @@
+import { OpenAI } from 'openai';
 import { describe, expect, it } from 'vitest';
 
 import { OpenAIChatMessage, UserMessageContentPart } from '../types/chat';
@@ -5,6 +6,7 @@ import {
   buildAnthropicBlock,
   buildAnthropicMessage,
   buildAnthropicMessages,
+  buildAnthropicTools,
 } from './anthropicHelpers';
 import { parseDataUri } from './uriParser';
 
@@ -49,7 +51,87 @@ describe('anthropicHelpers', () => {
         role: 'system',
       };
       const result = buildAnthropicMessage(message);
-      expect(result).toEqual({ content: [{ type: 'text', text: 'Hello!' }], role: 'assistant' });
+      expect(result).toEqual({ content: [{ type: 'text', text: 'Hello!' }], role: 'user' });
+    });
+
+    it('should correctly convert user message with string content', () => {
+      const message: OpenAIChatMessage = {
+        content: 'Hello!',
+        role: 'user',
+      };
+      const result = buildAnthropicMessage(message);
+      expect(result).toEqual({ content: 'Hello!', role: 'user' });
+    });
+
+    it('should correctly convert user message with content parts', () => {
+      const message: OpenAIChatMessage = {
+        content: [
+          { type: 'text', text: 'Check out this image:' },
+          { type: 'image_url', image_url: { url: 'data:image/png;base64,abc123' } },
+        ],
+        role: 'user',
+      };
+      const result = buildAnthropicMessage(message);
+      expect(result.role).toBe('user');
+      expect(result.content).toHaveLength(2);
+      expect((result.content[1] as any).type).toBe('image');
+    });
+
+    it('should correctly convert tool message', () => {
+      const message: OpenAIChatMessage = {
+        content: 'Tool result content',
+        role: 'tool',
+        tool_call_id: 'tool123',
+      };
+      const result = buildAnthropicMessage(message);
+      expect(result.role).toBe('user');
+      expect(result.content).toEqual([
+        {
+          content: 'Tool result content',
+          tool_use_id: 'tool123',
+          type: 'tool_result',
+        },
+      ]);
+    });
+
+    it('should correctly convert assistant message with tool calls', () => {
+      const message: OpenAIChatMessage = {
+        content: 'Here is the result:',
+        role: 'assistant',
+        tool_calls: [
+          {
+            id: 'call1',
+            type: 'function',
+            function: {
+              name: 'search',
+              arguments: '{"query":"anthropic"}',
+            },
+          },
+        ],
+      };
+      const result = buildAnthropicMessage(message);
+      expect(result.role).toBe('assistant');
+      expect(result.content).toEqual([
+        { text: 'Here is the result:', type: 'text' },
+        {
+          id: 'call1',
+          input: { query: 'anthropic' },
+          name: 'search',
+          type: 'tool_use',
+        },
+      ]);
+    });
+
+    it('should correctly convert function message', () => {
+      const message: OpenAIChatMessage = {
+        content: 'def hello(name):\n  return f"Hello {name}"',
+        role: 'function',
+      };
+      const result = buildAnthropicMessage(message);
+      expect(result).toEqual({
+        content: 'def hello(name):\n  return f"Hello {name}"',
+        role: 'assistant',
+      });
     });
   });
 
@@ -111,4 +193,41 @@ describe('anthropicHelpers', () => {
       ]);
     });
   });
+
+  describe('buildAnthropicTools', () => {
+    it('should correctly convert OpenAI tools to Anthropic format', () => {
+      const tools: OpenAI.ChatCompletionTool[] = [
+        {
+          type: 'function',
+          function: {
+            name: 'search',
+            description: 'Searches the web',
+            parameters: {
+              type: 'object',
+              properties: {
+                query: { type: 'string' },
+              },
+              required: ['query'],
+            },
+          },
+        },
+      ];
+
+      const result = buildAnthropicTools(tools);
+
+      expect(result).toEqual([
+        {
+          name: 'search',
+          description: 'Searches the web',
+          input_schema: {
+            type: 'object',
+            properties: {
+              query: { type: 'string' },
+            },
+            required: ['query'],
+          },
+        },
+      ]);
+    });
+  });
 });

package/src/libs/agent-runtime/utils/anthropicHelpers.ts

@@ -1,4 +1,5 @@
 import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
 
 import { OpenAIChatMessage, UserMessageContentPart } from '../types';
 import { parseDataUri } from './uriParser';
@@ -30,10 +31,63 @@ export const buildAnthropicMessage = (
   message: OpenAIChatMessage,
 ): Anthropic.Messages.MessageParam => {
   const content = message.content as string | UserMessageContentPart[];
-  return {
-    content: typeof content === 'string' ? content : content.map((c) => buildAnthropicBlock(c)),
-    role: message.role === 'function' || message.role === 'system' ? 'assistant' : message.role,
-  };
+
+  switch (message.role) {
+    case 'system': {
+      return { content: content as string, role: 'user' };
+    }
+
+    case 'user': {
+      return {
+        content: typeof content === 'string' ? content : content.map((c) => buildAnthropicBlock(c)),
+        role: 'user',
+      };
+    }
+
+    case 'tool': {
+      // refs: https://docs.anthropic.com/claude/docs/tool-use#tool-use-and-tool-result-content-blocks
+      return {
+        content: [
+          {
+            content: message.content,
+            tool_use_id: message.tool_call_id,
+            type: 'tool_result',
+          } as any,
+        ],
+        role: 'user',
+      };
+    }
+
+    case 'assistant': {
+      // if there is tool_calls , we need to covert the tool_calls to tool_use content block
+      // refs: https://docs.anthropic.com/claude/docs/tool-use#tool-use-and-tool-result-content-blocks
+      if (message.tool_calls) {
+        return {
+          content: [
+            // avoid empty text content block
+            !!message.content && {
+              text: message.content as string,
+              type: 'text',
+            },
+            ...(message.tool_calls.map((tool) => ({
+              id: tool.id,
+              input: JSON.parse(tool.function.arguments),
+              name: tool.function.name,
+              type: 'tool_use',
+            })) as any),
+          ].filter(Boolean),
+          role: 'assistant',
+        };
+      }
+
+      // or it's a plain assistant message
+      return { content: content as string, role: 'assistant' };
+    }
+
+    case 'function': {
+      return { content: content as string, role: 'assistant' };
+    }
+  }
 };
 
 export const buildAnthropicMessages = (
@@ -55,3 +109,12 @@ export const buildAnthropicMessages = (
 
   return messages;
 };
+
+export const buildAnthropicTools = (tools?: OpenAI.ChatCompletionTool[]) =>
+  tools?.map(
+    (tool): Anthropic.Beta.Tools.Tool => ({
+      description: tool.function.description,
+      input_schema: tool.function.parameters as Anthropic.Beta.Tools.Tool.InputSchema,
+      name: tool.function.name,
+    }),
+  );

package/src/libs/agent-runtime/utils/debugStream.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { debugStream } from './debugStream';
+
+describe('debugStream', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should log stream start and end messages', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue('test chunk');
+        controller.close();
+      },
+    });
+
+    await debugStream(stream);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[stream start\]/));
+  });
+
+  it('should handle and log stream errors', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue('test chunk');
+      },
+    });
+
+    await debugStream(stream);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith('[debugStream error]', expect.any(Error));
+    expect(consoleErrorSpy).toHaveBeenCalledWith('[error chunk value:]', 'test chunk');
+  });
+
+  it('should decode ArrayBuffer chunk values', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode('test chunk'));
+        controller.close();
+      },
+    });
+
+    await debugStream(stream);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith('test chunk');
+  });
+
+  it('should stringify non-string chunk values', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue({ test: 'chunk' });
+        controller.close();
+      },
+    });
+
+    await debugStream(stream);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith('{"test":"chunk"}');
+  });
+});

package/src/libs/agent-runtime/utils/debugStream.ts

@@ -1,18 +1,48 @@
+// no need to introduce a package to get the current time as this module is just a debug utility
+const getTime = () => {
+  const date = new Date();
+  return `${date.getFullYear()}-${date.getDate()}-${date.getDay()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}.${date.getMilliseconds()}`;
+};
+
 export const debugStream = async (stream: ReadableStream) => {
-  let done = false;
+  let finished = false;
   let chunk = 0;
+  let chunkValue: any;
   const decoder = new TextDecoder();
 
   const reader = stream.getReader();
-  while (!done) {
-    const { value, done: _done } = await reader.read();
-    const chunkValue = decoder.decode(value, { stream: true });
-    if (!_done) {
-      console.log(`[chunk ${chunk}]`);
+
+  console.log(`[stream start] ${getTime()}`);
+
+  while (!finished) {
+    try {
+      const { value, done } = await reader.read();
+
+      if (done) {
+        console.log(`[stream finished] total chunks: ${chunk}\n`);
+        finished = true;
+        break;
+      }
+
+      chunkValue = value;
+
+      // if the value is ArrayBuffer, we need to decode it
+      if ('byteLength' in value) {
+        chunkValue = decoder.decode(value, { stream: true });
+      } else if (typeof value !== 'string') {
+        chunkValue = JSON.stringify(value);
+      }
+
+      console.log(`[chunk ${chunk}] ${getTime()}`);
       console.log(chunkValue);
-    }
+      console.log(`\n`);
 
-    done = _done;
-    chunk++;
+      finished = done;
+      chunk++;
+    } catch (e) {
+      finished = true;
+      console.error('[debugStream error]', e);
+      console.error('[error chunk value:]', chunkValue);
+    }
   }
 };