@lobehub/chat 1.138.3 → 1.138.5

package/packages/model-runtime/src/providers/google/index.ts

@@ -1,17 +1,14 @@
 import {
-  Content,
-  FunctionDeclaration,
   GenerateContentConfig,
   Tool as GoogleFunctionCallTool,
   GoogleGenAI,
   HttpOptions,
-  Part,
-  Type as SchemaType,
   ThinkingConfig,
 } from '@google/genai';
 import debug from 'debug';
 
 import { LobeRuntimeAI } from '../../core/BaseAI';
+import { buildGoogleMessages, buildGoogleTools } from '../../core/contextBuilders/google';
 import { GoogleGenerativeAIStream, VertexAIStream } from '../../core/streams';
 import { LOBE_ERROR_KEY } from '../../core/streams/google';
 import {
@@ -20,8 +17,6 @@ import {
   ChatStreamPayload,
   GenerateObjectOptions,
   GenerateObjectPayload,
-  OpenAIChatMessage,
-  UserMessageContentPart,
 } from '../../types';
 import { AgentRuntimeErrorType } from '../../types/error';
 import { CreateImagePayload, CreateImageResponse } from '../../types/image';
@@ -29,12 +24,9 @@ import { AgentRuntimeError } from '../../utils/createError';
 import { debugStream } from '../../utils/debugStream';
 import { getModelPricing } from '../../utils/getModelPricing';
 import { parseGoogleErrorMessage } from '../../utils/googleErrorParser';
-import { imageUrlToBase64 } from '../../utils/imageToBase64';
 import { StreamingResponse } from '../../utils/response';
-import { safeParseJSON } from '../../utils/safeParseJSON';
-import { parseDataUri } from '../../utils/uriParser';
 import { createGoogleImage } from './createImage';
-import { createGoogleGenerateObject } from './generateObject';
+import { createGoogleGenerateObject, createGoogleGenerateObjectWithTools } from './generateObject';
 
 const log = debug('model-runtime:google');
 
@@ -217,7 +209,7 @@ export class LobeGoogleAI implements LobeRuntimeAI {
         thinkingBudget: resolvedThinkingBudget,
       };
 
-      const contents = await this.buildGoogleMessages(payload.messages);
+      const contents = await buildGoogleMessages(payload.messages);
 
       const controller = new AbortController();
       const originalSignal = options?.signal;
@@ -264,7 +256,7 @@ export class LobeGoogleAI implements LobeRuntimeAI {
           modelsDisableInstuction.has(model) || model.toLowerCase().includes('learnlm')
             ? undefined
             : thinkingConfig,
-        tools: this.buildGoogleTools(payload.tools, payload),
+        tools: this.buildGoogleToolsWithSearch(payload.tools, payload),
         topP: payload.top_p,
       };
 
@@ -330,16 +322,31 @@ export class LobeGoogleAI implements LobeRuntimeAI {
   /**
    * Generate structured output using Google Gemini API
    * @see https://ai.google.dev/gemini-api/docs/structured-output
+   * @see https://ai.google.dev/gemini-api/docs/function-calling
    */
   async generateObject(payload: GenerateObjectPayload, options?: GenerateObjectOptions) {
     // Convert OpenAI messages to Google format
-    const contents = await this.buildGoogleMessages(payload.messages);
+    const contents = await buildGoogleMessages(payload.messages);
+
+    // Handle tools-based structured output
+    if (payload.tools && payload.tools.length > 0) {
+      return createGoogleGenerateObjectWithTools(
+        this.client,
+        { contents, model: payload.model, tools: payload.tools },
+        options,
+      );
+    }
+
+    // Handle schema-based structured output
+    if (payload.schema) {
+      return createGoogleGenerateObject(
+        this.client,
+        { contents, model: payload.model, schema: payload.schema },
+        options,
+      );
+    }
 
-    return createGoogleGenerateObject(
-      this.client,
-      { contents, model: payload.model, schema: payload.schema },
-      options,
-    );
+    return undefined;
   }
 
   private createEnhancedStream(originalStream: any, signal: AbortSignal): ReadableStream {
@@ -489,147 +496,7 @@ export class LobeGoogleAI implements LobeRuntimeAI {
     };
   }
 
-  private convertContentToGooglePart = async (
-    content: UserMessageContentPart,
-  ): Promise<Part | undefined> => {
-    switch (content.type) {
-      default: {
-        return undefined;
-      }
-
-      case 'text': {
-        return { text: content.text };
-      }
-
-      case 'image_url': {
-        const { mimeType, base64, type } = parseDataUri(content.image_url.url);
-
-        if (type === 'base64') {
-          if (!base64) {
-            throw new TypeError("Image URL doesn't contain base64 data");
-          }
-
-          return {
-            inlineData: { data: base64, mimeType: mimeType || 'image/png' },
-          };
-        }
-
-        if (type === 'url') {
-          const { base64, mimeType } = await imageUrlToBase64(content.image_url.url);
-
-          return {
-            inlineData: { data: base64, mimeType },
-          };
-        }
-
-        throw new TypeError(`currently we don't support image url: ${content.image_url.url}`);
-      }
-
-      case 'video_url': {
-        const { mimeType, base64, type } = parseDataUri(content.video_url.url);
-
-        if (type === 'base64') {
-          if (!base64) {
-            throw new TypeError("Video URL doesn't contain base64 data");
-          }
-
-          return {
-            inlineData: { data: base64, mimeType: mimeType || 'video/mp4' },
-          };
-        }
-
-        if (type === 'url') {
-          // For video URLs, we need to fetch and convert to base64
-          // Note: This might need size/duration limits for practical use
-          const response = await fetch(content.video_url.url);
-          const arrayBuffer = await response.arrayBuffer();
-          const base64 = Buffer.from(arrayBuffer).toString('base64');
-          const mimeType = response.headers.get('content-type') || 'video/mp4';
-
-          return {
-            inlineData: { data: base64, mimeType },
-          };
-        }
-
-        throw new TypeError(`currently we don't support video url: ${content.video_url.url}`);
-      }
-    }
-  };
-
-  private convertOAIMessagesToGoogleMessage = async (
-    message: OpenAIChatMessage,
-    toolCallNameMap?: Map<string, string>,
-  ): Promise<Content> => {
-    const content = message.content as string | UserMessageContentPart[];
-    if (!!message.tool_calls) {
-      return {
-        parts: message.tool_calls.map<Part>((tool) => ({
-          functionCall: {
-            args: safeParseJSON(tool.function.arguments)!,
-            name: tool.function.name,
-          },
-        })),
-        role: 'model',
-      };
-    }
-
-    // 将 tool_call result 转成 functionResponse part
-    if (message.role === 'tool' && toolCallNameMap && message.tool_call_id) {
-      const functionName = toolCallNameMap.get(message.tool_call_id);
-      if (functionName) {
-        return {
-          parts: [
-            {
-              functionResponse: {
-                name: functionName,
-                response: { result: message.content },
-              },
-            },
-          ],
-          role: 'user',
-        };
-      }
-    }
-
-    const getParts = async () => {
-      if (typeof content === 'string') return [{ text: content }];
-
-      const parts = await Promise.all(
-        content.map(async (c) => await this.convertContentToGooglePart(c)),
-      );
-      return parts.filter(Boolean) as Part[];
-    };
-
-    return {
-      parts: await getParts(),
-      role: message.role === 'assistant' ? 'model' : 'user',
-    };
-  };
-
-  // convert messages from the OpenAI format to Google GenAI SDK
-  private buildGoogleMessages = async (messages: OpenAIChatMessage[]): Promise<Content[]> => {
-    const toolCallNameMap = new Map<string, string>();
-    messages.forEach((message) => {
-      if (message.role === 'assistant' && message.tool_calls) {
-        message.tool_calls.forEach((toolCall) => {
-          if (toolCall.type === 'function') {
-            toolCallNameMap.set(toolCall.id, toolCall.function.name);
-          }
-        });
-      }
-    });
-
-    const pools = messages
-      .filter((message) => message.role !== 'function')
-      .map(async (msg) => await this.convertOAIMessagesToGoogleMessage(msg, toolCallNameMap));
-
-    const contents = await Promise.all(pools);
-
-    // 筛除空消息: contents.parts must not be empty.
-    return contents.filter((content: Content) => content.parts && content.parts.length > 0);
-  };
-
-  private buildGoogleTools(
+  private buildGoogleToolsWithSearch(
     tools: ChatCompletionTool[] | undefined,
     payload?: ChatStreamPayload,
   ): GoogleFunctionCallTool[] | undefined {
@@ -640,7 +507,7 @@ export class LobeGoogleAI implements LobeRuntimeAI {
 
     // 如果已经有 tool_calls，优先处理 function declarations
     if (hasToolCalls && hasFunctionTools) {
-      return this.buildFunctionDeclarations(tools);
+      return buildGoogleTools(tools);
     }
 
     // 构建并返回搜索相关工具（搜索工具不能与 FunctionCall 同时使用）
@@ -655,41 +522,8 @@ export class LobeGoogleAI implements LobeRuntimeAI {
     }
 
     // 最后考虑 function declarations
-    return this.buildFunctionDeclarations(tools);
+    return buildGoogleTools(tools);
   }
-
-  private buildFunctionDeclarations(
-    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;
-    // refs: https://github.com/lobehub/lobe-chat/pull/5002
-    const properties =
-      parameters?.properties && Object.keys(parameters.properties).length > 0
-        ? parameters.properties
-        : { dummy: { type: 'string' } }; // dummy property to avoid empty object
-
-    return {
-      description: functionDeclaration.description,
-      name: functionDeclaration.name,
-      parameters: {
-        description: parameters?.description,
-        properties: properties,
-        required: parameters?.required,
-        type: SchemaType.OBJECT,
-      },
-    };
-  };
 }
 
 export default LobeGoogleAI;

package/packages/model-runtime/src/providers/openai/index.test.ts

@@ -59,10 +59,10 @@ describe('LobeOpenAI', () => {
         const apiError = new OpenAI.APIError(
           400,
           {
-            status: 400,
             error: {
               message: 'Bad Request',
             },
+            status: 400,
           },
           'Error message',
           {},
@@ -178,13 +178,13 @@ describe('LobeOpenAI', () => {
         } catch (e) {
           expect(e).toEqual({
             endpoint: 'https://api.openai.com/v1',
-            errorType: 'AgentRuntimeError',
-            provider: 'openai',
             error: {
-              name: genericError.name,
               cause: genericError.cause,
               message: genericError.message,
+              name: genericError.name,
             },
+            errorType: 'AgentRuntimeError',
+            provider: 'openai',
           });
         }
       });
@@ -261,10 +261,10 @@ describe('LobeOpenAI', () => {
 
     it('should use responses API when enabledSearch is true', async () => {
       const payload = {
+        enabledSearch: true,
         messages: [{ content: 'Hello', role: 'user' as const }],
         model: 'gpt-4o',
         temperature: 0.7,
-        enabledSearch: true,
       };
 
       await instance.chat(payload);
@@ -275,12 +275,12 @@ describe('LobeOpenAI', () => {
 
     it('should handle -search- models with stripped parameters', async () => {
       const payload = {
+        frequency_penalty: 0.5,
         messages: [{ content: 'Hello', role: 'user' as const }],
         model: 'gpt-4o-search-2024',
+        presence_penalty: 0.3,
         temperature: 0.7,
         top_p: 0.9,
-        frequency_penalty: 0.5,
-        presence_penalty: 0.3,
       };
 
       await instance.chat(payload);
@@ -296,12 +296,12 @@ describe('LobeOpenAI', () => {
 
     it('should handle regular models with all parameters', async () => {
       const payload = {
+        frequency_penalty: 0.5,
         messages: [{ content: 'Hello', role: 'user' as const }],
         model: 'gpt-4o',
+        presence_penalty: 0.3,
         temperature: 0.7,
         top_p: 0.9,
-        frequency_penalty: 0.5,
-        presence_penalty: 0.3,
       };
 
       await instance.chat(payload);
@@ -319,18 +319,19 @@ describe('LobeOpenAI', () => {
   describe('responses.handlePayload', () => {
     it('should add web_search tool when enabledSearch is true', async () => {
       const payload = {
+        enabledSearch: true,
         messages: [{ content: 'Hello', role: 'user' as const }],
-        model: 'gpt-4o', // 使用常规模型，通过 enabledSearch 触发 responses API
+        model: 'gpt-4o',
+        // 使用常规模型，通过 enabledSearch 触发 responses API
         temperature: 0.7,
-        enabledSearch: true,
-        tools: [{ type: 'function' as const, function: { name: 'test', description: 'test' } }],
+        tools: [{ function: { description: 'test', name: 'test' }, type: 'function' as const }],
       };
 
       await instance.chat(payload);
 
       const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
       expect(createCall.tools).toEqual([
-        { type: 'function', name: 'test', description: 'test' },
+        { description: 'test', name: 'test', type: 'function' },
         { type: 'web_search' },
       ]);
     });
@@ -339,10 +340,10 @@ describe('LobeOpenAI', () => {
       // Note: oaiSearchContextSize is read at module load time, not runtime
       // This test verifies the tool structure is correct when the env var would be set
       const payload = {
+        enabledSearch: true,
         messages: [{ content: 'Hello', role: 'user' as const }],
         model: 'gpt-4o',
         temperature: 0.7,
-        enabledSearch: true,
       };
 
       await instance.chat(payload);
@@ -358,8 +359,8 @@ describe('LobeOpenAI', () => {
       const payload = {
         messages: [{ content: 'Hello', role: 'user' as const }],
         model: 'computer-use-preview',
-        temperature: 0.7,
         reasoning: { effort: 'medium' },
+        temperature: 0.7,
       };
 
       await instance.chat(payload);
@@ -393,7 +394,7 @@ describe('LobeOpenAI', () => {
       await instance.chat(payload);
 
       const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
-      expect(createCall.reasoning).toEqual({ summary: 'auto', effort: 'high' });
+      expect(createCall.reasoning).toEqual({ effort: 'high', summary: 'auto' });
     });
 
     it('should set reasoning.effort to high for gpt-5-pro-2025-10-06 models', async () => {
@@ -406,7 +407,7 @@ describe('LobeOpenAI', () => {
       await instance.chat(payload);
 
       const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
-      expect(createCall.reasoning).toEqual({ summary: 'auto', effort: 'high' });
+      expect(createCall.reasoning).toEqual({ effort: 'high', summary: 'auto' });
     });
   });
 

package/packages/model-runtime/src/types/structureOutput.ts

@@ -1,4 +1,4 @@
-import { ChatCompletionFunctions } from './chat';
+import { ChatCompletionTool } from './chat';
 
 interface GenerateObjectMessage {
   content: string;
@@ -6,7 +6,7 @@ interface GenerateObjectMessage {
   role: 'user' | 'system' | 'assistant';
 }
 
-interface GenerateObjectSchema {
+export interface GenerateObjectSchema {
   description?: string;
   name: string;
   schema: {
@@ -23,8 +23,7 @@ export interface GenerateObjectPayload {
   model: string;
   responseApi?: boolean;
   schema?: GenerateObjectSchema;
-  systemRole?: string;
-  tools?: ChatCompletionFunctions[];
+  tools?: ChatCompletionTool[];
 }
 
 export interface GenerateObjectOptions {

package/packages/types/src/aiChat.ts

@@ -75,7 +75,6 @@ export const StructureOutputSchema = z.object({
   model: z.string(),
   provider: z.string(),
   schema: StructureSchema.optional(),
-  systemRole: z.string().optional(),
   tools: z
     .array(z.object({ function: LobeUniformToolSchema, type: z.literal('function') }))
     .optional(),

package/src/app/(backend)/trpc/edge/[trpc]/route.ts

@@ -5,8 +5,6 @@ import { pino } from '@/libs/logger';
 import { createEdgeContext } from '@/libs/trpc/edge/context';
 import { edgeRouter } from '@/server/routers/edge';
 
-export const runtime = 'edge';
-
 const handler = (req: NextRequest) =>
   fetchRequestHandler({
     /**

package/src/server/routers/edge/index.ts

@@ -1,5 +1,6 @@
 /**
- * This file contains the edge router of Lobe Chat tRPC-backend
+ * @deprecated
+ * TODO: it will be remove in V2.0
  */
 import { publicProcedure, router } from '@/libs/trpc/edge';
 

package/src/server/routers/lambda/aiChat.ts

@@ -60,8 +60,7 @@ export const aiChatRouter = router({
       messages: input.messages,
       model: input.model,
       schema: input.schema,
-      systemRole: input.systemRole,
-      tools: input.tools?.map((item) => item.function),
+      tools: input.tools,
     });
 
     log('generateObject completed, result: %O', result);

package/src/server/routers/lambda/index.ts

@@ -28,6 +28,7 @@ import { sessionRouter } from './session';
 import { sessionGroupRouter } from './sessionGroup';
 import { threadRouter } from './thread';
 import { topicRouter } from './topic';
+import { uploadRouter } from './upload';
 import { userRouter } from './user';
 
 export const lambdaRouter = router({
@@ -57,6 +58,7 @@ export const lambdaRouter = router({
   sessionGroup: sessionGroupRouter,
   thread: threadRouter,
   topic: topicRouter,
+  upload: uploadRouter,
   user: userRouter,
 });
 

package/src/server/routers/lambda/upload.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { S3 } from '@/server/modules/S3';
+
+export const uploadRouter = router({
+  createS3PreSignedUrl: authedProcedure
+    .input(z.object({ pathname: z.string() }))
+    .mutation(async ({ input }) => {
+      const s3 = new S3();
+
+      return await s3.createPreSignedUrl(input.pathname);
+    }),
+});
+
+export type FileRouter = typeof uploadRouter;