@lobehub/lobehub 2.0.0-next.87 → 2.0.0-next.89

package/packages/model-runtime/src/core/streams/google/index.ts

@@ -1,4 +1,4 @@
-import { GenerateContentResponse } from '@google/genai';
+import { GenerateContentResponse, Part } from '@google/genai';
 import { GroundingSearch } from '@lobechat/types';
 
 import { ChatStreamCallbacks } from '../../../types';
@@ -74,19 +74,27 @@ const transformGoogleGenerativeAIStream = (
     }
   }
 
-  const functionCalls = chunk.functionCalls;
+  // Parse function calls from candidate.content.parts
+  const functionCalls =
+    candidate?.content?.parts
+      ?.filter((part: any) => part.functionCall)
+      .map((part: Part) => ({
+        ...part.functionCall,
+        thoughtSignature: part.thoughtSignature,
+      })) || [];
 
-  if (functionCalls) {
+  if (functionCalls.length > 0) {
     return [
       {
         data: functionCalls.map(
-          (value, index): StreamToolCallChunkData => ({
+          (value, index: number): StreamToolCallChunkData => ({
             function: {
               arguments: JSON.stringify(value.args),
               name: value.name,
             },
             id: generateToolCallId(index, value.name),
             index: index,
+            thoughtSignature: value.thoughtSignature,
             type: 'function',
           }),
         ),
@@ -97,7 +105,13 @@ const transformGoogleGenerativeAIStream = (
     ];
   }
 
-  const text = chunk.text;
+  // Parse text from candidate.content.parts
+  // Filter out thought content (thought: true) and thoughtSignature
+  const text =
+    candidate?.content?.parts
+      ?.filter((part: any) => part.text && !part.thought && !part.thoughtSignature)
+      .map((part: any) => part.text)
+      .join('') || '';
 
   if (candidate) {
     // 首先检查是否为 reasoning 内容 (thought: true)

package/packages/model-runtime/src/core/streams/protocol.ts

@@ -98,6 +98,7 @@ export interface StreamToolCallChunkData {
   };
   id?: string;
   index: number;
+  thoughtSignature?: string;
   type: 'function' | string;
 }
 

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

@@ -1,5 +1,5 @@
 // @vitest-environment node
-import { GenerateContentResponse, Tool } from '@google/genai';
+import { GenerateContentResponse } from '@google/genai';
 import OpenAI from 'openai';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 

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

@@ -194,7 +194,7 @@ export class LobeGoogleAI implements LobeRuntimeAI {
   async chat(rawPayload: ChatStreamPayload, options?: ChatMethodOptions) {
     try {
       const payload = this.buildPayload(rawPayload);
-      const { model, thinkingBudget } = payload;
+      const { model, thinkingBudget, thinkingLevel } = payload;
 
       // https://ai.google.dev/gemini-api/docs/thinking#set-budget
       const resolvedThinkingBudget = resolveModelThinkingBudget(model, thinkingBudget);
@@ -209,6 +209,11 @@ export class LobeGoogleAI implements LobeRuntimeAI {
         thinkingBudget: resolvedThinkingBudget,
       };
 
+      // Add thinkingLevel for 3.0 models
+      if (model?.toLowerCase().includes('-3-') && thinkingLevel) {
+        (thinkingConfig as any).thinkingLevel = thinkingLevel;
+      }
+
       const contents = await buildGoogleMessages(payload.messages);
 
       const controller = new AbortController();
@@ -262,19 +267,21 @@ export class LobeGoogleAI implements LobeRuntimeAI {
 
       const inputStartAt = Date.now();
 
-      const geminiStreamResponse = await this.client.models.generateContentStream({
-        config,
-        contents,
-        model,
-      });
-
-      const googleStream = this.createEnhancedStream(geminiStreamResponse, controller.signal);
-      const [prod, useForDebug] = googleStream.tee();
-
+      const finalPayload = { config, contents, model };
       const key = this.isVertexAi
         ? 'DEBUG_VERTEX_AI_CHAT_COMPLETION'
         : 'DEBUG_GOOGLE_CHAT_COMPLETION';
 
+      if (process.env[key] === '1') {
+        console.log('[requestPayload]');
+        console.log(JSON.stringify(finalPayload), '\n');
+      }
+
+      const geminiStreamResponse = await this.client.models.generateContentStream(finalPayload);
+
+      const googleStream = this.createEnhancedStream(geminiStreamResponse, controller.signal);
+      const [prod, useForDebug] = googleStream.tee();
+
       if (process.env[key] === '1') {
         debugStream(useForDebug).catch();
       }

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

@@ -124,6 +124,10 @@ export interface ChatStreamPayload {
     type: 'enabled' | 'disabled';
   };
   thinkingBudget?: number;
+  /**
+   * Thinking level for Gemini models (e.g., gemini-3.0-pro)
+   */
+  thinkingLevel?: 'low' | 'high';
   tool_choice?: string;
   tools?: ChatCompletionTool[];
   /**

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

@@ -1,5 +1,5 @@
-import { z } from 'zod';
 import type { PartialDeep } from 'type-fest';
+import { z } from 'zod';
 
 /**
  * The function that the model called.
@@ -30,6 +30,7 @@ export interface MessageToolCall {
    */
   id: string;
 
+  thoughtSignature?: string;
   /**
    * The type of the tool. Currently, only `function` is supported.
    */
@@ -42,6 +43,7 @@ export const MessageToolCallSchema = z.object({
     name: z.string(),
   }),
   id: z.string(),
+  thoughtSignature: z.string().optional(),
   type: z.string(),
 });
 

package/packages/types/src/agent/chatConfig.ts

@@ -38,6 +38,7 @@ export interface LobeAgentChatConfig {
    */
   textVerbosity?: 'low' | 'medium' | 'high';
   thinking?: 'disabled' | 'auto' | 'enabled';
+  thinkingLevel?: 'low' | 'high';
   thinkingBudget?: number;
   /**
    * Disable context caching
@@ -91,6 +92,7 @@ export const AgentChatConfigSchema = z.object({
   textVerbosity: z.enum(['low', 'medium', 'high']).optional(),
   thinking: z.enum(['disabled', 'auto', 'enabled']).optional(),
   thinkingBudget: z.number().optional(),
+  thinkingLevel: z.enum(['low', 'high']).optional(),
   urlContext: z.boolean().optional(),
   useModelBuiltinSearch: z.boolean().optional(),
 });

package/packages/types/src/message/common/tools.ts

@@ -30,6 +30,7 @@ export interface ChatToolPayload {
   identifier: string;
   intervention?: ToolIntervention;
   result_msg_id?: string;
+  thoughtSignature?: string;
   type: LobeToolRenderType;
 }
 
@@ -84,6 +85,7 @@ export interface MessageToolCall {
    */
   id: string;
 
+  thoughtSignature?: string;
   /**
    * The type of the tool. Currently, only `function` is supported.
    */
@@ -108,6 +110,7 @@ export const ChatToolPayloadSchema = z.object({
   identifier: z.string(),
   intervention: ToolInterventionSchema.optional(),
   result_msg_id: z.string().optional(),
+  thoughtSignature: z.string().optional(),
   type: z.string(),
 });
 

package/src/features/ChatInput/ActionBar/Model/ControlsForm.tsx

@@ -17,6 +17,7 @@ import ReasoningEffortSlider from './ReasoningEffortSlider';
 import ReasoningTokenSlider from './ReasoningTokenSlider';
 import TextVerbositySlider from './TextVerbositySlider';
 import ThinkingBudgetSlider from './ThinkingBudgetSlider';
+import ThinkingLevelSlider from './ThinkingLevelSlider';
 import ThinkingSlider from './ThinkingSlider';
 
 const ControlsForm = memo(() => {
@@ -177,6 +178,16 @@ const ControlsForm = memo(() => {
         paddingBottom: 0,
       },
     },
+    {
+      children: <ThinkingLevelSlider />,
+      label: t('extendParams.thinkingLevel.title'),
+      layout: 'horizontal',
+      minWidth: undefined,
+      name: 'thinkingLevel',
+      style: {
+        paddingBottom: 0,
+      },
+    },
   ].filter(Boolean) as FormItemProps[];
 
   return (

package/src/features/ChatInput/ActionBar/Model/ThinkingLevelSlider.tsx

@@ -0,0 +1,56 @@
+import { Slider } from 'antd';
+import { memo, useCallback } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+import { useAgentStore } from '@/store/agent';
+import { agentChatConfigSelectors } from '@/store/agent/selectors';
+
+const ThinkingLevelSlider = memo(() => {
+  const [config, updateAgentChatConfig] = useAgentStore((s) => [
+    agentChatConfigSelectors.currentChatConfig(s),
+    s.updateAgentChatConfig,
+  ]);
+
+  const thinkingLevel = config.thinkingLevel || 'high'; // Default to 'high' if not set
+
+  const marks = {
+    0: 'low',
+    1: 'high',
+  };
+
+  const levelValues = ['low', 'high'];
+  const indexValue = levelValues.indexOf(thinkingLevel);
+  const currentValue = indexValue === -1 ? 1 : indexValue;
+
+  const updateThinkingLevel = useCallback(
+    (value: number) => {
+      const level = levelValues[value] as 'low' | 'high';
+      updateAgentChatConfig({ thinkingLevel: level });
+    },
+    [updateAgentChatConfig],
+  );
+
+  return (
+    <Flexbox
+      align={'center'}
+      gap={12}
+      horizontal
+      paddingInline={'0 20px'}
+      style={{ minWidth: 130, width: '100%' }} // 三项时宽度需改回 200
+    >
+      <Flexbox flex={1}>
+        <Slider
+          marks={marks}
+          max={1}
+          min={0}
+          onChange={updateThinkingLevel}
+          step={1}
+          tooltip={{ open: false }}
+          value={currentValue}
+        />
+      </Flexbox>
+    </Flexbox>
+  );
+});
+
+export default ThinkingLevelSlider;

package/src/features/Conversation/Messages/Group/Error/index.tsx

@@ -15,12 +15,13 @@ export interface ErrorContentProps {
 
 const ErrorContent = memo<ErrorContentProps>(({ error, id }) => {
   const { t } = useTranslation('common');
-  const errorProps = useErrorContent(error);
 
   const [deleteMessage] = useChatStore((s) => [s.deleteDBMessage]);
   const message = <ErrorMessageExtra block data={{ error, id }} />;
 
-  if (!error?.message) {
+  const errorProps = useErrorContent(error);
+
+  if (!errorProps?.message) {
     if (!message) return null;
     return <Flexbox>{message}</Flexbox>;
   }

package/src/features/Conversation/Messages/Group/GroupItem.tsx

@@ -30,10 +30,10 @@ const GroupItem = memo<GroupItemProps>(
           });
         }}
       >
-        <ContentBlock index={index} {...item} />
+        <ContentBlock index={index} {...item} error={error} />
       </Flexbox>
     ) : (
-      <ContentBlock index={index} {...item} />
+      <ContentBlock index={index} {...item} error={error} />
     );
   },
   isEqual,

package/src/locales/default/chat.ts

@@ -66,6 +66,9 @@ export default {
     thinking: {
       title: '深度思考开关',
     },
+    thinkingLevel: {
+      title: '思考水平',
+    },
     title: '模型扩展功能',
     urlContext: {
       desc: '开启后将自动解析网页链接，以获取实际网页上下文内容',

package/src/services/chat/index.ts

@@ -196,6 +196,10 @@ class ChatService {
         extendParams.thinkingBudget = chatConfig.thinkingBudget;
       }
 
+      if (modelExtendParams!.includes('thinkingLevel') && chatConfig.thinkingLevel) {
+        extendParams.thinkingLevel = chatConfig.thinkingLevel;
+      }
+
       if (modelExtendParams!.includes('urlContext') && chatConfig.urlContext) {
         extendParams.urlContext = chatConfig.urlContext;
       }

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -76,7 +76,7 @@ export interface StreamingExecutorAction {
     tool_calls?: MessageToolCall[];
     content: string;
     traceId?: string;
-    finishType?: 'done' | 'error' | 'abort';
+    finishType?: string;
     usage?: ModelUsage;
   }>;
   /**
@@ -283,13 +283,13 @@ export const streamingExecutor: StateCreator<
     let thinkingStartAt: number;
     let duration: number | undefined;
     let reasoningOperationId: string | undefined;
-    let finishType: 'done' | 'error' | 'abort' | undefined;
+    let finishType: string | undefined;
     // to upload image
     const uploadTasks: Map<string, Promise<{ id?: string; url?: string }>> = new Map();
 
     // Throttle tool_calls updates to prevent excessive re-renders (max once per 300ms)
     const throttledUpdateToolCalls = throttle(
-      (toolCalls: any[]) => {
+      (toolCalls: MessageToolCall[]) => {
         internal_dispatchMessage(
           {
             id: messageId,
@@ -366,7 +366,6 @@ export const streamingExecutor: StateCreator<
           throttledUpdateToolCalls.flush();
           internal_toggleToolCallingStreaming(messageId, undefined);
 
-          tools = get().internal_transformToolCalls(parsedToolCalls);
           tool_calls = toolCalls;
 
           parsedToolCalls = parsedToolCalls.map((item) => ({
@@ -377,6 +376,8 @@ export const streamingExecutor: StateCreator<
             },
           }));
 
+          tools = get().internal_transformToolCalls(parsedToolCalls);
+
           isFunctionCall = true;
         }
 
@@ -395,7 +396,7 @@ export const streamingExecutor: StateCreator<
           messageId,
           content,
           {
-            toolCalls: parsedToolCalls,
+            tools,
             reasoning: !!reasoning
               ? { ...reasoning, duration: duration && !isNaN(duration) ? duration : undefined }
               : undefined,

package/src/store/chat/slices/message/actions/optimisticUpdate.ts

@@ -3,11 +3,11 @@ import {
   ChatImageItem,
   ChatMessageError,
   ChatMessagePluginError,
+  ChatToolPayload,
   CreateMessageParams,
   GroundingSearch,
   MessageMetadata,
   MessagePluginItem,
-  MessageToolCall,
   ModelReasoning,
   UIChatMessage,
   UpdateMessageRAGParams,
@@ -69,7 +69,7 @@ export interface MessageOptimisticUpdateAction {
       provider?: string;
       reasoning?: ModelReasoning;
       search?: GroundingSearch;
-      toolCalls?: MessageToolCall[];
+      tools?: ChatToolPayload[];
     },
     context?: OptimisticUpdateContext,
   ) => Promise<void>;
@@ -204,22 +204,17 @@ export const messageOptimisticUpdate: StateCreator<
   },
 
   optimisticUpdateMessageContent: async (id, content, extra, context) => {
-    const {
-      internal_dispatchMessage,
-      refreshMessages,
-      internal_transformToolCalls,
-      replaceMessages,
-    } = get();
+    const { internal_dispatchMessage, refreshMessages, replaceMessages } = get();
 
     // Due to the async update method and refresh need about 100ms
     // we need to update the message content at the frontend to avoid the update flick
     // refs: https://medium.com/@kyledeguzmanx/what-are-optimistic-updates-483662c3e171
-    if (extra?.toolCalls) {
+    if (extra?.tools) {
       internal_dispatchMessage(
         {
           id,
           type: 'updateMessage',
-          value: { tools: internal_transformToolCalls(extra?.toolCalls) },
+          value: { tools: extra?.tools },
         },
         context,
       );
@@ -246,7 +241,7 @@ export const messageOptimisticUpdate: StateCreator<
         provider: extra?.provider,
         reasoning: extra?.reasoning,
         search: extra?.search,
-        tools: extra?.toolCalls ? internal_transformToolCalls(extra?.toolCalls) : undefined,
+        tools: extra?.tools,
       },
       { sessionId, topicId },
     );

package/src/store/chat/slices/plugin/actions/internals.ts

@@ -1,6 +1,6 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 import { ToolNameResolver } from '@lobechat/context-engine';
-import { MessageToolCall, ToolsCallingContext } from '@lobechat/types';
+import { ChatToolPayload, MessageToolCall, ToolsCallingContext } from '@lobechat/types';
 import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 import { StateCreator } from 'zustand/vanilla';
 
@@ -19,7 +19,7 @@ export interface PluginInternalsAction {
   /**
    * Transform tool calls from runtime format to storage format
    */
-  internal_transformToolCalls: (toolCalls: MessageToolCall[]) => any[];
+  internal_transformToolCalls: (toolCalls: MessageToolCall[]) => ChatToolPayload[];
 
   /**
    * Construct tools calling context for plugin invocation