@lobehub/chat 0.156.2 → 0.157.1

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

@@ -40,24 +40,6 @@ describe('LobeMoonshotAI', () => {
   });
 
   describe('chat', () => {
-    it('should return a StreamingTextResponse on successful API call', async () => {
-      // Arrange
-      const mockStream = new ReadableStream();
-      const mockResponse = Promise.resolve(mockStream);
-
-      (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await instance.chat({
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'text-davinci-003',
-        temperature: 0,
-      });
-
-      // Assert
-      expect(result).toBeInstanceOf(Response);
-    });
-
     describe('Error', () => {
       it('should return OpenAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
         // Arrange
@@ -223,59 +205,6 @@ describe('LobeMoonshotAI', () => {
       });
     });
 
-    describe('LobeMoonshotAI 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: 'gpt-3.5-turbo-0125',
-                  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: 'text-davinci-003',
-            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_MOONSHOT_CHAT_COMPLETION is 1', async () => {
         // Arrange
@@ -306,6 +235,7 @@ describe('LobeMoonshotAI', () => {
         await instance.chat({
           messages: [{ content: 'Hello', role: 'user' }],
           model: 'text-davinci-003',
+          stream: true,
           temperature: 0,
         });
 

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

@@ -0,0 +1,197 @@
+import { Ollama } from 'ollama/browser';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { AgentRuntimeErrorType } from '../error';
+import { ModelProvider } from '../types';
+import { AgentRuntimeError } from '../utils/createError';
+import { LobeOllamaAI } from './index';
+
+vi.mock('ollama/browser');
+
+describe('LobeOllamaAI', () => {
+  let ollamaAI: LobeOllamaAI;
+
+  beforeEach(() => {
+    ollamaAI = new LobeOllamaAI({ baseURL: 'https://example.com' });
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize Ollama client and baseURL with valid baseURL', () => {
+      expect(ollamaAI['client']).toBeInstanceOf(Ollama);
+      expect(ollamaAI.baseURL).toBe('https://example.com');
+    });
+
+    it('should throw AgentRuntimeError with invalid baseURL', () => {
+      try {
+        new LobeOllamaAI({ baseURL: 'invalid-url' });
+      } catch (e) {
+        expect(e).toEqual(AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidOllamaArgs));
+      }
+    });
+  });
+
+  describe('chat', () => {
+    it('should call Ollama client chat method and return StreamingResponse', async () => {
+      const chatMock = vi.fn().mockResolvedValue({});
+      vi.mocked(Ollama.prototype.chat).mockImplementation(chatMock);
+
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'model-id',
+      };
+      const options = { signal: new AbortController().signal };
+
+      const response = await ollamaAI.chat(payload as any, options);
+
+      expect(chatMock).toHaveBeenCalledWith({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'model-id',
+        options: {
+          frequency_penalty: undefined,
+          presence_penalty: undefined,
+          temperature: undefined,
+          top_p: undefined,
+        },
+        stream: true,
+      });
+      expect(response).toBeInstanceOf(Response);
+    });
+
+    it('should throw AgentRuntimeError when Ollama client chat method throws an error', async () => {
+      const errorMock = {
+        message: 'Chat error',
+        name: 'ChatError',
+        status_code: 500,
+      };
+      vi.mocked(Ollama.prototype.chat).mockRejectedValue(errorMock);
+
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'model-id',
+      };
+
+      try {
+        await ollamaAI.chat(payload as any);
+      } catch (e) {
+        expect(e).toEqual(
+          AgentRuntimeError.chat({
+            error: errorMock,
+            errorType: AgentRuntimeErrorType.OllamaBizError,
+            provider: ModelProvider.Ollama,
+          }),
+        );
+      }
+    });
+
+    it('should abort the request when signal aborts', async () => {
+      const abortMock = vi.fn();
+      vi.mocked(Ollama.prototype.abort).mockImplementation(abortMock);
+
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'model-id',
+      };
+      const options = { signal: new AbortController().signal };
+
+      ollamaAI.chat(payload as any, options);
+
+      options.signal.dispatchEvent(new Event('abort'));
+
+      expect(abortMock).toHaveBeenCalled();
+    });
+  });
+
+  describe('models', () => {
+    it('should call Ollama client list method and return ChatModelCard array', async () => {
+      const listMock = vi.fn().mockResolvedValue({
+        models: [{ name: 'model-1' }, { name: 'model-2' }],
+      });
+      vi.mocked(Ollama.prototype.list).mockImplementation(listMock);
+
+      const models = await ollamaAI.models();
+
+      expect(listMock).toHaveBeenCalled();
+      expect(models).toEqual([{ id: 'model-1' }, { id: 'model-2' }]);
+    });
+  });
+
+  describe('buildOllamaMessages', () => {
+    it('should convert OpenAIChatMessage array to OllamaMessage array', () => {
+      const messages = [
+        { content: 'Hello', role: 'user' },
+        { content: 'Hi there!', role: 'assistant' },
+      ];
+
+      const ollamaMessages = ollamaAI['buildOllamaMessages'](messages as any);
+
+      expect(ollamaMessages).toEqual([
+        { content: 'Hello', role: 'user' },
+        { content: 'Hi there!', role: 'assistant' },
+      ]);
+    });
+  });
+
+  describe('convertContentToOllamaMessage', () => {
+    it('should convert string content to OllamaMessage', () => {
+      const message = { content: 'Hello', role: 'user' };
+
+      const ollamaMessage = ollamaAI['convertContentToOllamaMessage'](message as any);
+
+      expect(ollamaMessage).toEqual({ content: 'Hello', role: 'user' });
+    });
+
+    it('should convert text content to OllamaMessage', () => {
+      const message = {
+        content: [{ type: 'text', text: 'Hello' }],
+        role: 'user',
+      };
+
+      const ollamaMessage = ollamaAI['convertContentToOllamaMessage'](message as any);
+
+      expect(ollamaMessage).toEqual({ content: 'Hello', role: 'user' });
+    });
+
+    it('should convert image_url content to OllamaMessage with images', () => {
+      const message = {
+        content: [
+          {
+            type: 'image_url',
+            image_url: { url: 'data:image/png;base64,abc123' },
+          },
+        ],
+        role: 'user',
+      };
+
+      const ollamaMessage = ollamaAI['convertContentToOllamaMessage'](message as any);
+
+      expect(ollamaMessage).toEqual({
+        content: '',
+        role: 'user',
+        images: ['abc123'],
+      });
+    });
+
+    it('should ignore invalid image_url content', () => {
+      const message = {
+        content: [
+          {
+            type: 'image_url',
+            image_url: { url: 'invalid-url' },
+          },
+        ],
+        role: 'user',
+      };
+
+      const ollamaMessage = ollamaAI['convertContentToOllamaMessage'](message as any);
+
+      expect(ollamaMessage).toEqual({
+        content: '',
+        role: 'user',
+      });
+    });
+  });
+});

package/src/libs/agent-runtime/ollama/index.ts

@@ -1,15 +1,15 @@
-import { StreamingTextResponse } from 'ai';
 import { Ollama } from 'ollama/browser';
 import { ClientOptions } from 'openai';
 
 import { OpenAIChatMessage } from '@/libs/agent-runtime';
-import { OllamaStream } from '@/libs/agent-runtime/ollama/stream';
 import { ChatModelCard } from '@/types/llm';
 
 import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType } from '../error';
 import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
 import { AgentRuntimeError } from '../utils/createError';
+import { StreamingResponse } from '../utils/response';
+import { OllamaStream } from '../utils/streams';
 import { parseDataUri } from '../utils/uriParser';
 import { OllamaMessage } from './type';
 
@@ -51,7 +51,7 @@ export class LobeOllamaAI implements LobeRuntimeAI {
         stream: true,
       });
 
-      return new StreamingTextResponse(OllamaStream(response, options?.callback), {
+      return StreamingResponse(OllamaStream(response, options?.callback), {
         headers: options?.headers,
       });
     } catch (error) {

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

@@ -190,59 +190,6 @@ describe('LobeOpenAI', () => {
       });
     });
 
-    describe('LobeOpenAI 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: 'gpt-3.5-turbo-0125',
-                  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: 'text-davinci-003',
-            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_OPENAI_CHAT_COMPLETION is 1', async () => {
         // Arrange

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

@@ -81,6 +81,7 @@ describe('LobeOpenRouterAI', () => {
         {
           max_tokens: 1024,
           messages: [{ content: 'Hello', role: 'user' }],
+          stream: true,
           model: 'mistralai/mistral-7b-instruct:free',
           temperature: 0.7,
           top_p: 1,
@@ -255,59 +256,6 @@ describe('LobeOpenRouterAI', () => {
       });
     });
 
-    describe('LobeOpenRouterAI 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_OPENROUTER_CHAT_COMPLETION is 1', async () => {
         // Arrange

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

@@ -40,24 +40,6 @@ describe('LobePerplexityAI', () => {
   });
 
   describe('chat', () => {
-    it('should return a StreamingTextResponse on successful API call', async () => {
-      // Arrange
-      const mockStream = new ReadableStream();
-      const mockResponse = Promise.resolve(mockStream);
-
-      (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await instance.chat({
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'text-davinci-003',
-        temperature: 0,
-      });
-
-      // Assert
-      expect(result).toBeInstanceOf(Response);
-    });
-
     describe('Error', () => {
       it('should return OpenAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
         // Arrange
@@ -223,59 +205,6 @@ describe('LobePerplexityAI', () => {
       });
     });
 
-    describe('LobePerplexityAI 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: 'gpt-3.5-turbo-0125',
-                  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: 'text-davinci-003',
-            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_PERPLEXITY_CHAT_COMPLETION is 1', async () => {
         // Arrange

package/src/libs/agent-runtime/perplexity/index.ts

@@ -9,7 +9,7 @@ export const LobePerplexityAI = LobeOpenAICompatibleFactory({
   chatCompletion: {
     handlePayload: (payload: ChatStreamPayload) => {
       // Set a default frequency penalty value greater than 0
-      const { presence_penalty, frequency_penalty, ...res } = payload;
+      const { presence_penalty, frequency_penalty, stream = true, ...res } = payload;
 
       let param;
 
@@ -22,8 +22,7 @@ export const LobePerplexityAI = LobeOpenAICompatibleFactory({
         param = { frequency_penalty: frequency_penalty || defaultFrequencyPenalty };
       }
 
-      console.log(param);
-      return { ...res, ...param } as OpenAI.ChatCompletionCreateParamsStreaming;
+      return { ...res, ...param, stream } as OpenAI.ChatCompletionCreateParamsStreaming;
     },
   },
   debug: {