@lobehub/chat 0.156.2 → 0.157.0

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

@@ -2,7 +2,6 @@ import {
   BedrockRuntimeClient,
   InvokeModelWithResponseStreamCommand,
 } from '@aws-sdk/client-bedrock-runtime';
-import { AWSBedrockLlama2Stream, AWSBedrockStream, StreamingTextResponse } from 'ai';
 import { experimental_buildLlama2Prompt } from 'ai/prompts';
 
 import { LobeRuntimeAI } from '../BaseAI';
@@ -11,6 +10,12 @@ import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../typ
 import { buildAnthropicMessages } from '../utils/anthropicHelpers';
 import { AgentRuntimeError } from '../utils/createError';
 import { debugStream } from '../utils/debugStream';
+import { StreamingResponse } from '../utils/response';
+import {
+  AWSBedrockClaudeStream,
+  AWSBedrockLlamaStream,
+  createBedrockStream,
+} from '../utils/streams';
 
 export interface LobeBedrockAIParams {
   accessKeyId?: string;
@@ -39,7 +44,7 @@ export class LobeBedrockAI implements LobeRuntimeAI {
   }
 
   async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
-    if (payload.model.startsWith('meta')) return this.invokeLlamaModel(payload);
+    if (payload.model.startsWith('meta')) return this.invokeLlamaModel(payload, options);
 
     return this.invokeClaudeModel(payload, options);
   }
@@ -47,7 +52,7 @@ export class LobeBedrockAI implements LobeRuntimeAI {
   private invokeClaudeModel = async (
     payload: ChatStreamPayload,
     options?: ChatCompetitionOptions,
-  ): Promise<StreamingTextResponse> => {
+  ): Promise<Response> => {
     const { max_tokens, messages, model, temperature, top_p } = payload;
     const system_message = messages.find((m) => m.role === 'system');
     const user_messages = messages.filter((m) => m.role !== 'system');
@@ -68,23 +73,20 @@ export class LobeBedrockAI implements LobeRuntimeAI {
 
     try {
       // Ask Claude for a streaming chat completion given the prompt
-      const bedrockResponse = await this.client.send(command, { abortSignal: options?.signal });
+      const res = await this.client.send(command, { abortSignal: options?.signal });
 
-      // Convert the response into a friendly text-stream
-      const stream = AWSBedrockStream(
-        bedrockResponse,
-        options?.callback,
-        (chunk) => chunk.delta?.text,
-      );
+      const claudeStream = createBedrockStream(res);
 
-      const [debug, output] = stream.tee();
+      const [prod, debug] = claudeStream.tee();
 
       if (process.env.DEBUG_BEDROCK_CHAT_COMPLETION === '1') {
         debugStream(debug).catch(console.error);
       }
 
       // Respond with the stream
-      return new StreamingTextResponse(output);
+      return StreamingResponse(AWSBedrockClaudeStream(prod, options?.callback), {
+        headers: options?.headers,
+      });
     } catch (e) {
       const err = e as Error & { $metadata: any };
 
@@ -101,7 +103,10 @@ export class LobeBedrockAI implements LobeRuntimeAI {
     }
   };
 
-  private invokeLlamaModel = async (payload: ChatStreamPayload): Promise<StreamingTextResponse> => {
+  private invokeLlamaModel = async (
+    payload: ChatStreamPayload,
+    options?: ChatCompetitionOptions,
+  ): Promise<Response> => {
     const { max_tokens, messages, model } = payload;
     const command = new InvokeModelWithResponseStreamCommand({
       accept: 'application/json',
@@ -115,18 +120,19 @@ export class LobeBedrockAI implements LobeRuntimeAI {
 
     try {
       // Ask Claude for a streaming chat completion given the prompt
-      const bedrockResponse = await this.client.send(command);
+      const res = await this.client.send(command);
 
-      // Convert the response into a friendly text-stream
-      const stream = AWSBedrockLlama2Stream(bedrockResponse);
+      const stream = createBedrockStream(res);
 
-      const [debug, output] = stream.tee();
+      const [prod, debug] = stream.tee();
 
       if (process.env.DEBUG_BEDROCK_CHAT_COMPLETION === '1') {
         debugStream(debug).catch(console.error);
       }
       // Respond with the stream
-      return new StreamingTextResponse(output);
+      return StreamingResponse(AWSBedrockLlamaStream(prod, options?.callback), {
+        headers: options?.headers,
+      });
     } catch (e) {
       const err = e as Error & { $metadata: any };
 

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

@@ -1,4 +1,6 @@
 // @vitest-environment edge-runtime
+import { FunctionDeclarationSchemaType } from '@google/generative-ai';
+import { JSONSchema7 } from 'json-schema';
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -426,5 +428,157 @@ describe('LobeGoogleAI', () => {
         expect(model).toEqual('gemini-pro-vision');
       });
     });
+
+    describe('buildGoogleTools', () => {
+      it('should return undefined when tools is undefined or empty', () => {
+        expect(instance['buildGoogleTools'](undefined)).toBeUndefined();
+        expect(instance['buildGoogleTools']([])).toBeUndefined();
+      });
+
+      it('should correctly convert ChatCompletionTool to GoogleFunctionCallTool', () => {
+        const tools: OpenAI.ChatCompletionTool[] = [
+          {
+            function: {
+              name: 'testTool',
+              description: 'A test tool',
+              parameters: {
+                type: 'object',
+                properties: {
+                  param1: { type: 'string' },
+                  param2: { type: 'number' },
+                },
+                required: ['param1'],
+              },
+            },
+            type: 'function',
+          },
+        ];
+
+        const googleTools = instance['buildGoogleTools'](tools);
+
+        expect(googleTools).toHaveLength(1);
+        expect(googleTools![0].functionDeclarations![0]).toEqual({
+          name: 'testTool',
+          description: 'A test tool',
+          parameters: {
+            type: FunctionDeclarationSchemaType.OBJECT,
+            properties: {
+              param1: { type: FunctionDeclarationSchemaType.STRING },
+              param2: { type: FunctionDeclarationSchemaType.NUMBER },
+            },
+            required: ['param1'],
+          },
+        });
+      });
+    });
+
+    describe('convertSchemaObject', () => {
+      it('should correctly convert object schema', () => {
+        const schema: JSONSchema7 = {
+          type: 'object',
+          properties: {
+            prop1: { type: 'string' },
+            prop2: { type: 'number' },
+          },
+        };
+
+        const converted = instance['convertSchemaObject'](schema);
+
+        expect(converted).toEqual({
+          type: FunctionDeclarationSchemaType.OBJECT,
+          properties: {
+            prop1: { type: FunctionDeclarationSchemaType.STRING },
+            prop2: { type: FunctionDeclarationSchemaType.NUMBER },
+          },
+        });
+      });
+
+      // 类似地添加 array/string/number/boolean 类型schema的测试用例
+      // ...
+
+      it('should correctly convert nested schema', () => {
+        const schema: JSONSchema7 = {
+          type: 'object',
+          properties: {
+            nested: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  prop: { type: 'string' },
+                },
+              },
+            },
+          },
+        };
+
+        const converted = instance['convertSchemaObject'](schema);
+
+        expect(converted).toEqual({
+          type: FunctionDeclarationSchemaType.OBJECT,
+          properties: {
+            nested: {
+              type: FunctionDeclarationSchemaType.ARRAY,
+              items: {
+                type: FunctionDeclarationSchemaType.OBJECT,
+                properties: {
+                  prop: { type: FunctionDeclarationSchemaType.STRING },
+                },
+              },
+            },
+          },
+        });
+      });
+    });
+
+    describe('convertOAIMessagesToGoogleMessage', () => {
+      it('should correctly convert assistant message', () => {
+        const message: OpenAIChatMessage = {
+          role: 'assistant',
+          content: 'Hello',
+        };
+
+        const converted = instance['convertOAIMessagesToGoogleMessage'](message);
+
+        expect(converted).toEqual({
+          role: 'model',
+          parts: [{ text: 'Hello' }],
+        });
+      });
+
+      it('should correctly convert user message', () => {
+        const message: OpenAIChatMessage = {
+          role: 'user',
+          content: 'Hi',
+        };
+
+        const converted = instance['convertOAIMessagesToGoogleMessage'](message);
+
+        expect(converted).toEqual({
+          role: 'user',
+          parts: [{ text: 'Hi' }],
+        });
+      });
+
+      it('should correctly convert message with content parts', () => {
+        const message: OpenAIChatMessage = {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'Check this image:' },
+            { type: 'image_url', image_url: { url: 'data:image/png;base64,...' } },
+          ],
+        };
+
+        const converted = instance['convertOAIMessagesToGoogleMessage'](message);
+
+        expect(converted).toEqual({
+          role: 'user',
+          parts: [
+            { text: 'Check this image:' },
+            { inlineData: { data: '...', mimeType: 'image/png' } },
+          ],
+        });
+      });
+    });
   });
 });

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

@@ -1,10 +1,20 @@
-import { Content, GoogleGenerativeAI, Part } from '@google/generative-ai';
-import { GoogleGenerativeAIStream, StreamingTextResponse } from 'ai';
+import {
+  Content,
+  FunctionDeclaration,
+  FunctionDeclarationSchemaProperty,
+  FunctionDeclarationSchemaType,
+  Tool as GoogleFunctionCallTool,
+  GoogleGenerativeAI,
+  Part,
+} from '@google/generative-ai';
+import { JSONSchema7 } from 'json-schema';
+import { transform } from 'lodash-es';
 
 import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../error';
 import {
   ChatCompetitionOptions,
+  ChatCompletionTool,
   ChatStreamPayload,
   OpenAIChatMessage,
   UserMessageContentPart,
@@ -12,6 +22,8 @@ import {
 import { ModelProvider } from '../types/type';
 import { AgentRuntimeError } from '../utils/createError';
 import { debugStream } from '../utils/debugStream';
+import { StreamingResponse } from '../utils/response';
+import { GoogleGenerativeAIStream, googleGenAIResultToStream } from '../utils/streams';
 import { parseDataUri } from '../utils/uriParser';
 
 enum HarmCategory {
@@ -42,7 +54,7 @@ export class LobeGoogleAI implements LobeRuntimeAI {
 
       const contents = this.buildGoogleMessages(payload.messages, model);
 
-      const geminiStream = await this.client
+      const geminiStreamResult = await this.client
         .getGenerativeModel(
           {
             generationConfig: {
@@ -74,19 +86,20 @@ export class LobeGoogleAI implements LobeRuntimeAI {
           },
           { apiVersion: 'v1beta', baseUrl: this.baseURL },
         )
-        .generateContentStream({ contents });
-
-      // Convert the response into a friendly text-stream
-      const stream = GoogleGenerativeAIStream(geminiStream, options?.callback);
+        .generateContentStream({ contents, tools: this.buildGoogleTools(payload.tools) });
 
-      const [debug, output] = stream.tee();
+      const googleStream = googleGenAIResultToStream(geminiStreamResult);
+      const [prod, useForDebug] = googleStream.tee();
 
       if (process.env.DEBUG_GOOGLE_CHAT_COMPLETION === '1') {
-        debugStream(debug).catch(console.error);
+        debugStream(useForDebug).catch();
       }
 
+      // Convert the response into a friendly text-stream
+      const stream = GoogleGenerativeAIStream(prod, options?.callback);
+
       // Respond with the stream
-      return new StreamingTextResponse(output, { headers: options?.headers });
+      return StreamingResponse(stream, { headers: options?.headers });
     } catch (e) {
       const err = e as Error;
 
@@ -226,6 +239,74 @@ export class LobeGoogleAI implements LobeRuntimeAI {
       return defaultError;
     }
   }
+
+  private buildGoogleTools(
+    tools: ChatCompletionTool[] | undefined,
+  ): GoogleFunctionCallTool[] | undefined {
+    if (!tools || tools.length === 0) return;
+
+    return [
+      {
+        functionDeclarations: tools.map((tool) => this.convertToolToGoogleTool(tool)),
+      },
+    ];
+  }
+
+  private convertToolToGoogleTool = (tool: ChatCompletionTool): FunctionDeclaration => {
+    const functionDeclaration = tool.function;
+    const parameters = functionDeclaration.parameters;
+
+    return {
+      description: functionDeclaration.description,
+      name: functionDeclaration.name,
+      parameters: {
+        description: parameters?.description,
+        properties: transform(parameters?.properties, (result, value, key: string) => {
+          result[key] = this.convertSchemaObject(value as JSONSchema7);
+        }),
+        required: parameters?.required,
+        type: FunctionDeclarationSchemaType.OBJECT,
+      },
+    };
+  };
+
+  private convertSchemaObject(schema: JSONSchema7): FunctionDeclarationSchemaProperty {
+    switch (schema.type) {
+      default:
+      case 'object': {
+        return {
+          ...schema,
+          properties: Object.fromEntries(
+            Object.entries(schema.properties || {}).map(([key, value]) => [
+              key,
+              this.convertSchemaObject(value as JSONSchema7),
+            ]),
+          ),
+          type: FunctionDeclarationSchemaType.OBJECT,
+        } as any;
+      }
+
+      case 'array': {
+        return {
+          ...schema,
+          items: this.convertSchemaObject(schema.items as JSONSchema7),
+          type: FunctionDeclarationSchemaType.ARRAY,
+        } as any;
+      }
+
+      case 'string': {
+        return { ...schema, type: FunctionDeclarationSchemaType.STRING } as any;
+      }
+
+      case 'number': {
+        return { ...schema, type: FunctionDeclarationSchemaType.NUMBER } as any;
+      }
+
+      case 'boolean': {
+        return { ...schema, type: FunctionDeclarationSchemaType.BOOLEAN } as any;
+      }
+    }
+  }
 }
 
 export default LobeGoogleAI;

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

@@ -40,25 +40,7 @@ describe('LobeGroqAI', () => {
   });
 
   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: 'mistralai/mistral-7b-instruct:free',
-        temperature: 0,
-      });
-
-      // Assert
-      expect(result).toBeInstanceOf(Response);
-    });
-
-    it('should call OpenRouter API with corresponding options', async () => {
+    it('should call chat with corresponding options', async () => {
       // Arrange
       const mockStream = new ReadableStream();
       const mockResponse = Promise.resolve(mockStream);
@@ -78,6 +60,7 @@ describe('LobeGroqAI', () => {
       expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
         {
           max_tokens: 1024,
+          stream: true,
           messages: [{ content: 'Hello', role: 'user' }],
           model: 'mistralai/mistral-7b-instruct:free',
           temperature: 0.7,
@@ -88,6 +71,45 @@ describe('LobeGroqAI', () => {
       expect(result).toBeInstanceOf(Response);
     });
 
+    describe('handlePayload option', () => {
+      it('should set stream to false when payload contains tools', async () => {
+        const mockCreateMethod = vi
+          .spyOn(instance['client'].chat.completions, 'create')
+          .mockResolvedValue({
+            id: 'chatcmpl-8xDx5AETP8mESQN7UB30GxTN2H1SO',
+            object: 'chat.completion',
+            created: 1709125675,
+            model: 'mistralai/mistral-7b-instruct:free',
+            system_fingerprint: 'fp_86156a94a0',
+            choices: [
+              {
+                index: 0,
+                message: { role: 'assistant', content: 'hello' },
+                logprobs: null,
+                finish_reason: 'stop',
+              },
+            ],
+          });
+
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'mistralai/mistral-7b-instruct:free',
+          temperature: 0,
+          tools: [
+            {
+              type: 'function',
+              function: { name: 'tool1', description: '', parameters: {} },
+            },
+          ],
+        });
+
+        expect(mockCreateMethod).toHaveBeenCalledWith(
+          expect.objectContaining({ stream: false }),
+          expect.anything(),
+        );
+      });
+    });
+
     describe('Error', () => {
       it('should return OpenRouterBizError with an openai error response when OpenAI.APIError is thrown', async () => {
         // Arrange
@@ -253,59 +275,6 @@ describe('LobeGroqAI', () => {
       });
     });
 
-    describe('LobeGroqAI 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/groq/index.ts

@@ -10,6 +10,13 @@ export const LobeGroq = LobeOpenAICompatibleFactory({
       if (error.status === 403)
         return { error, errorType: AgentRuntimeErrorType.LocationNotSupportError };
     },
+    handlePayload: (payload) => {
+      return {
+        ...payload,
+        // disable stream for tools due to groq dont support
+        stream: !payload.tools,
+      } as any;
+    },
   },
   debug: {
     chatCompletion: () => process.env.DEBUG_GROQ_CHAT_COMPLETION === '1',

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

@@ -62,7 +62,7 @@ describe('LobeMinimaxAI', () => {
         temperature: 0,
       });
 
-      expect(result).toBeInstanceOf(StreamingTextResponse);
+      expect(result).toBeInstanceOf(Response);
     });
 
     it('should handle text messages correctly', async () => {
@@ -85,7 +85,7 @@ describe('LobeMinimaxAI', () => {
         temperature: 0,
       });
 
-      expect(result).toBeInstanceOf(StreamingTextResponse);
+      expect(result).toBeInstanceOf(Response);
     });
 
     it('should call debugStream in DEBUG mode', async () => {

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

@@ -1,9 +1,6 @@
-import { StreamingTextResponse } from 'ai';
 import { isEmpty } from 'lodash-es';
 import OpenAI from 'openai';
 
-import { debugStream } from '@/libs/agent-runtime/utils/debugStream';
-
 import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType } from '../error';
 import {
@@ -13,6 +10,9 @@ import {
   ModelProvider,
 } from '../types';
 import { AgentRuntimeError } from '../utils/createError';
+import { debugStream } from '../utils/debugStream';
+import { StreamingResponse } from '../utils/response';
+import { MinimaxStream } from '../utils/streams';
 
 interface MinimaxBaseResponse {
   base_resp?: {
@@ -69,18 +69,8 @@ export class LobeMinimaxAI implements LobeRuntimeAI {
     this.apiKey = apiKey;
   }
 
-  async chat(
-    payload: ChatStreamPayload,
-    options?: ChatCompetitionOptions,
-  ): Promise<StreamingTextResponse> {
+  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions): Promise<Response> {
     try {
-      let streamController: ReadableStreamDefaultController | undefined;
-      const readableStream = new ReadableStream({
-        start(controller) {
-          streamController = controller;
-        },
-      });
-
       const response = await fetch('https://api.minimax.chat/v1/text/chatcompletion_v2', {
         body: JSON.stringify(this.buildCompletionsParams(payload)),
         headers: {
@@ -107,12 +97,10 @@ export class LobeMinimaxAI implements LobeRuntimeAI {
         debugStream(debug).catch(console.error);
       }
 
-      this.parseResponse(prod.getReader(), streamController);
-
       // wait for the first response, and throw error if minix returns an error
       await this.parseFirstResponse(prod2.getReader());
 
-      return new StreamingTextResponse(readableStream, { headers: options?.headers });
+      return StreamingResponse(MinimaxStream(prod), { headers: options?.headers });
     } catch (error) {
       console.log('error', error);
       const err = error as Error | ChatCompletionErrorPayload;
@@ -154,30 +142,19 @@ export class LobeMinimaxAI implements LobeRuntimeAI {
       max_tokens: this.getMaxTokens(payload.model),
       stream: true,
       temperature: temperature === 0 ? undefined : temperature,
+
+      tools: params.tools?.map((tool) => ({
+        function: {
+          description: tool.function.description,
+          name: tool.function.name,
+          parameters: JSON.stringify(tool.function.parameters),
+        },
+        type: 'function',
+      })),
       top_p: top_p === 0 ? undefined : top_p,
     };
   }
 
-  private async parseResponse(
-    reader: ReadableStreamDefaultReader<Uint8Array>,
-    streamController: ReadableStreamDefaultController | undefined,
-  ) {
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    let done = false;
-
-    while (!done) {
-      const { value, done: doneReading } = await reader.read();
-      done = doneReading;
-      const chunkValue = decoder.decode(value, { stream: true });
-      const data = parseMinimaxResponse(chunkValue);
-      const text = data?.choices?.at(0)?.delta?.content || undefined;
-      streamController?.enqueue(encoder.encode(text));
-    }
-
-    streamController?.close();
-  }
-
   private async parseFirstResponse(reader: ReadableStreamDefaultReader<Uint8Array>) {
     const decoder = new TextDecoder();