@lobehub/lobehub 2.0.9 → 2.0.11

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

@@ -34,6 +34,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  vi.unstubAllGlobals();
   vi.clearAllMocks();
 });
 
@@ -333,6 +334,107 @@ describe('LobeOpenRouterAI - custom features', () => {
         expect.anything(),
       );
     });
+
+    it('should map thinkingLevel to reasoning effort', async () => {
+      await instance.chat({
+        messages: [{ content: 'Think level', role: 'user' }],
+        model: 'openai/gpt-4',
+        thinkingLevel: 'medium',
+      } as any);
+
+      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+        expect.objectContaining({ reasoning: { effort: 'medium' } }),
+        expect.anything(),
+      );
+    });
+  });
+
+  describe('models mapping', () => {
+    it('should map extendParams for gpt-5.x reasoning and verbosity', async () => {
+      const mockModels = [
+        {
+          architecture: { input_modalities: ['text'] },
+          created: 1_700_000_000,
+          description: 'Test model',
+          id: 'openai/gpt-5.2-mini',
+          name: 'openai/gpt-5.2-mini',
+          pricing: { completion: '0.00001', prompt: '0.00001' },
+          supported_parameters: ['reasoning'],
+          top_provider: { context_length: 8192, max_completion_tokens: 1024 },
+        },
+        {
+          architecture: { input_modalities: ['text'] },
+          created: 1_700_000_000,
+          description: 'Test model',
+          id: 'openai/gpt-5.1-mini',
+          name: 'openai/gpt-5.1-mini',
+          pricing: { completion: '0.00001', prompt: '0.00001' },
+          supported_parameters: ['reasoning'],
+          top_provider: { context_length: 8192, max_completion_tokens: 1024 },
+        },
+      ];
+
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: async () => ({ data: mockModels }),
+        } as any),
+      );
+
+      const models = await params.models();
+      const gpt52 = models.find((m) => m.id === 'openai/gpt-5.2-mini');
+      const gpt51 = models.find((m) => m.id === 'openai/gpt-5.1-mini');
+
+      expect(gpt52?.settings?.extendParams).toEqual(
+        expect.arrayContaining(['gpt5_2ReasoningEffort', 'textVerbosity']),
+      );
+      expect(gpt51?.settings?.extendParams).toEqual(
+        expect.arrayContaining(['gpt5_1ReasoningEffort', 'textVerbosity']),
+      );
+    });
+
+    it('should map thinkingLevel for gemini-3 flash/pro reasoning', async () => {
+      const mockModels = [
+        {
+          architecture: { input_modalities: ['text'] },
+          created: 1_700_000_000,
+          description: 'Test model',
+          id: 'google/gemini-3-pro',
+          name: 'google/gemini-3-pro',
+          pricing: { completion: '0.00001', prompt: '0.00001' },
+          supported_parameters: ['reasoning'],
+          top_provider: { context_length: 8192, max_completion_tokens: 1024 },
+        },
+        {
+          architecture: { input_modalities: ['text'] },
+          created: 1_700_000_000,
+          description: 'Test model',
+          id: 'google/gemini-3-flash',
+          name: 'google/gemini-3-flash',
+          pricing: { completion: '0.00001', prompt: '0.00001' },
+          supported_parameters: ['reasoning'],
+          top_provider: { context_length: 8192, max_completion_tokens: 1024 },
+        },
+      ];
+
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: async () => ({ data: mockModels }),
+        } as any),
+      );
+
+      const models = await params.models();
+      const geminiPro = models.find((m) => m.id === 'google/gemini-3-pro');
+      const geminiFlash = models.find((m) => m.id === 'google/gemini-3-flash');
+
+      expect(geminiPro?.settings?.extendParams).toEqual(expect.arrayContaining(['thinkingLevel2']));
+      expect(geminiFlash?.settings?.extendParams).toEqual(
+        expect.arrayContaining(['thinkingLevel']),
+      );
+    });
   });
 
   describe('models', () => {

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

@@ -17,11 +17,11 @@ export const params = {
   chatCompletion: {
     handlePayload: (payload) => {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { reasoning_effort, thinking, reasoning: _reasoning, ...rest } = payload;
+      const { reasoning_effort, thinking, reasoning: _reasoning, thinkingLevel, ...rest } = payload;
 
       let reasoning: OpenRouterReasoning | undefined;
 
-      if (thinking?.type || thinking?.budget_tokens !== undefined || reasoning_effort) {
+      if (thinking?.type || thinking?.budget_tokens !== undefined || reasoning_effort || thinkingLevel) {
         if (thinking?.type === 'disabled') {
           reasoning = { enabled: false };
         } else if (thinking?.budget_tokens !== undefined) {
@@ -31,6 +31,9 @@ export const params = {
         } else if (reasoning_effort) {
           reasoning = { effort: reasoning_effort };
         }
+        else if (thinkingLevel) {
+          reasoning = { effort: thinkingLevel };
+        }
       }
 
       return {
@@ -126,11 +129,14 @@ export const params = {
           if (model.description && model.description.includes('`reasoning` `enabled`')) {
             extendParams.push('enableReasoning');
           }
-          if (hasReasoning && model.id.includes('gpt-5')) {
-            extendParams.push('gpt5ReasoningEffort');
-          }
-          if (hasReasoning && model.id.includes('openai') && !model.id.includes('gpt-5')) {
-            extendParams.push('reasoningEffort');
+          if (hasReasoning && model.id.includes('gpt-5.2')) {
+            extendParams.push('gpt5_2ReasoningEffort', 'textVerbosity');
+          } else if (hasReasoning && model.id.includes('gpt-5.1')) {
+            extendParams.push('gpt5_1ReasoningEffort', 'textVerbosity');
+          } else if (hasReasoning && model.id.includes('gpt-5')) {
+            extendParams.push('gpt5ReasoningEffort', 'textVerbosity');
+          } else if (hasReasoning && model.id.includes('openai')) {
+            extendParams.push('reasoningEffort', 'textVerbosity');
           }
           if (hasReasoning && model.id.includes('claude')) {
             extendParams.push('enableReasoning', 'reasoningBudgetToken');
@@ -141,6 +147,12 @@ export const params = {
           if (hasReasoning && model.id.includes('gemini-2.5')) {
             extendParams.push('reasoningBudgetToken');
           }
+          if (hasReasoning && model.id.includes('gemini-3-pro')) {
+            extendParams.push('thinkingLevel2');
+          }
+          if (hasReasoning && model.id.includes('gemini-3-flash')) {
+            extendParams.push('thinkingLevel');
+          }
           return extendParams.length > 0 ? { settings: { extendParams } } : {};
         })(),
       };

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

@@ -245,6 +245,53 @@ describe('LobeVercelAIGatewayAI - custom features', () => {
       expect(Array.isArray(model?.pricing?.units)).toBe(true);
     });
 
+    it('should map extendParams for gpt-5.x reasoning models', async () => {
+      const mockModelData: VercelAIGatewayModelCard[] = [
+        {
+          id: 'openai/gpt-5.2-mini',
+          name: 'GPT-5.2 Mini',
+          pricing: { input: 0.000_003, output: 0.000_015 },
+          tags: ['reasoning'],
+          type: 'chat',
+        },
+        {
+          id: 'openai/gpt-5.1-mini',
+          name: 'GPT-5.1 Mini',
+          pricing: { input: 0.000_003, output: 0.000_015 },
+          tags: ['reasoning'],
+          type: 'chat',
+        },
+        {
+          id: 'openai/gpt-5-mini',
+          name: 'GPT-5 Mini',
+          pricing: { input: 0.000_003, output: 0.000_015 },
+          tags: ['reasoning'],
+          type: 'chat',
+        },
+      ];
+
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({ data: mockModelData }),
+        },
+      };
+
+      const models = await params.models({ client: mockClient as any });
+      const gpt52 = models.find((m) => m.id === 'openai/gpt-5.2-mini');
+      const gpt51 = models.find((m) => m.id === 'openai/gpt-5.1-mini');
+      const gpt5 = models.find((m) => m.id === 'openai/gpt-5-mini');
+
+      expect(gpt52?.settings?.extendParams).toEqual(
+        expect.arrayContaining(['gpt5_2ReasoningEffort', 'textVerbosity']),
+      );
+      expect(gpt51?.settings?.extendParams).toEqual(
+        expect.arrayContaining(['gpt5_1ReasoningEffort', 'textVerbosity']),
+      );
+      expect(gpt5?.settings?.extendParams).toEqual(
+        expect.arrayContaining(['gpt5ReasoningEffort', 'textVerbosity']),
+      );
+    });
+
     it('should handle models with missing pricing', async () => {
       const mockModelData: VercelAIGatewayModelCard[] = [
         {

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

@@ -125,9 +125,15 @@ export const params = {
         // Merge all applicable extendParams for settings
         ...(() => {
           const extendParams: string[] = [];
-          if (tags.includes('reasoning') && m.id.includes('gpt-5')) {
+          if (tags.includes('reasoning') && m.id.includes('gpt-5') && !m.id.includes('gpt-5.1') && !m.id.includes('gpt-5.2')) {
             extendParams.push('gpt5ReasoningEffort', 'textVerbosity');
           }
+          if (tags.includes('reasoning') && m.id.includes('gpt-5.1') && !m.id.includes('gpt-5.2')) {
+            extendParams.push('gpt5_1ReasoningEffort', 'textVerbosity');
+          }
+          if (tags.includes('reasoning') && m.id.includes('gpt-5.2')) {
+            extendParams.push('gpt5_2ReasoningEffort', 'textVerbosity');
+          }
           if (tags.includes('reasoning') && m.id.includes('openai') && !m.id.includes('gpt-5')) {
             extendParams.push('reasoningEffort', 'textVerbosity');
           }

package/packages/types/src/message/ui/chat.ts

@@ -25,6 +25,7 @@ export type UIMessageRoleType =
   | 'tool'
   | 'task'
   | 'tasks'
+  | 'groupTasks'
   | 'supervisor'
   | 'assistantGroup'
   | 'agentCouncil'
@@ -185,6 +186,7 @@ export interface UIChatMessage {
   /**
    * Task messages for role='tasks' virtual message
    * Contains aggregated task messages with same parentId
+   * Also used to store task execution messages (intermediate steps) from polling
    */
   tasks?: UIChatMessage[];
   threadId?: string | null;

package/packages/types/src/tool/builtin.ts

@@ -433,6 +433,10 @@ export interface TriggerExecuteTaskParams extends GroupOrchestrationBaseParams {
    * The agent ID to execute the task
    */
   agentId: string;
+  /**
+   * The instruction/task description for the agent
+   */
+  instruction: string;
   /**
    * Whether to run on the desktop client (for local file/shell access).
    * MUST be true when task requires local-system tools. Default is false (server execution).
@@ -443,10 +447,6 @@ export interface TriggerExecuteTaskParams extends GroupOrchestrationBaseParams {
    * without calling the supervisor again.
    */
   skipCallSupervisor?: boolean;
-  /**
-   * The task description for the agent
-   */
-  task: string;
   /**
    * Optional timeout in milliseconds
    */
@@ -466,7 +466,7 @@ export interface TriggerExecuteTaskItem {
    */
   agentId: string;
   /**
-   * Detailed instruction/prompt for the task execution
+   * Detailed instruction for the agent to execute
    */
   instruction: string;
   /**

package/src/features/Conversation/ChatItem/components/Title.tsx

@@ -24,7 +24,7 @@ const Title = memo<TitleProps>(({ showTitle, time, avatar, titleAddon }) => {
         </Text>
       )}
       {showTitle ? titleAddon : undefined}
-      {time && (
+      {!time ? null : (
         <Text
           aria-label="published-date"
           as={'time'}

package/src/features/Conversation/ChatList/index.tsx

@@ -91,7 +91,6 @@ const ChatList = memo<ChatListProps>(({ disableActionsBar, welcome, itemContent
     <MessageActionProvider withSingletonActionsBar={!disableActionsBar}>
       <VirtualizedList
         dataSource={displayMessageIds}
-        // isGenerating={isGenerating}
         itemContent={itemContent ?? defaultItemContent}
       />
     </MessageActionProvider>

package/src/features/Conversation/Messages/GroupTasks/TaskItem/ClientTaskItem.tsx

@@ -0,0 +1,183 @@
+'use client';
+
+import { AccordionItem, Block, Text } from '@lobehub/ui';
+import { memo, useMemo, useState } from 'react';
+
+import { useAgentGroupStore } from '@/store/agentGroup';
+import { agentGroupSelectors } from '@/store/agentGroup/selectors';
+import { useChatStore } from '@/store/chat';
+import { displayMessageSelectors } from '@/store/chat/selectors';
+import { messageMapKey } from '@/store/chat/utils/messageMapKey';
+import { ThreadStatus } from '@/types/index';
+import type { UIChatMessage } from '@/types/index';
+
+import {
+  ErrorState,
+  InitializingState,
+  TaskMessages,
+  isProcessingStatus,
+} from '../../Tasks/shared';
+import TaskTitle, { type TaskMetrics } from './TaskTitle';
+
+interface ClientTaskItemProps {
+  item: UIChatMessage;
+}
+
+const ClientTaskItem = memo<ClientTaskItemProps>(({ item }) => {
+  const { id, agentId: itemAgentId, groupId: itemGroupId, metadata, taskDetail } = item;
+  const [expanded, setExpanded] = useState(false);
+
+  const title = taskDetail?.title || metadata?.taskTitle;
+  const instruction = metadata?.instruction;
+  const status = taskDetail?.status;
+  const threadId = taskDetail?.threadId;
+
+  const isProcessing = isProcessingStatus(status);
+  const isCompleted = status === ThreadStatus.Completed;
+  const isError = status === ThreadStatus.Failed || status === ThreadStatus.Cancel;
+  const isInitializing = !taskDetail || !status;
+
+  // Fetch thread messages for client mode
+  // Use item's agentId (from task message) to query with the correct SubAgent ID that created the thread
+  // Fall back to activeAgentId if task message doesn't have agentId (shouldn't happen normally)
+  const [activeAgentId, activeTopicId, useFetchMessages] = useChatStore((s) => [
+    s.activeAgentId,
+    s.activeTopicId,
+    s.useFetchMessages,
+  ]);
+
+  // Use task message's agentId (skip 'supervisor' as it's not a valid agent ID for queries)
+  // Fall back to activeAgentId if not available
+  const agentId = itemAgentId && itemAgentId !== 'supervisor' ? itemAgentId : activeAgentId;
+
+  // Get agent info from store for displaying
+  const activeGroupId = useAgentGroupStore(agentGroupSelectors.activeGroupId);
+  const agent = useAgentGroupStore((s) =>
+    activeGroupId && itemAgentId
+      ? agentGroupSelectors.getAgentByIdFromGroup(activeGroupId, itemAgentId)(s)
+      : null,
+  );
+
+  const threadContext = useMemo(
+    () => ({
+      agentId,
+      groupId: itemGroupId,
+      scope: 'thread' as const,
+      threadId,
+      topicId: activeTopicId,
+    }),
+    [agentId, itemGroupId, activeTopicId, threadId],
+  );
+
+  const threadMessageKey = useMemo(
+    () => (threadId ? messageMapKey(threadContext) : null),
+    [threadId, threadContext],
+  );
+
+  // Fetch thread messages (skip when executing - messages come from real-time updates)
+  useFetchMessages(threadContext, isProcessing);
+
+  // Get thread messages from store using selector
+  const threadMessages = useChatStore((s) =>
+    threadMessageKey
+      ? displayMessageSelectors.getDisplayMessagesByKey(threadMessageKey)(s)
+      : undefined,
+  );
+
+  // Find the assistantGroup message which contains the children blocks
+  const assistantGroupMessage = threadMessages?.find((item) => item.role === 'assistantGroup');
+  const blocks = assistantGroupMessage?.children;
+  const childrenCount = blocks?.length ?? 0;
+
+  // Get model/provider from assistantGroup message
+  const model = assistantGroupMessage?.model;
+  const provider = assistantGroupMessage?.provider;
+
+  // Build metrics for TaskTitle based on blocks data
+  const metrics: TaskMetrics | undefined = useMemo(() => {
+    if (isProcessing && blocks) {
+      const toolCalls = blocks.reduce((sum, block) => sum + (block.tools?.length || 0), 0);
+      return {
+        isLoading: false,
+        startTime: assistantGroupMessage?.createdAt,
+        steps: blocks.length,
+        toolCalls,
+      };
+    }
+    if (isCompleted || isError) {
+      return {
+        duration: taskDetail?.duration,
+        steps: taskDetail?.totalSteps,
+        toolCalls: taskDetail?.totalToolCalls,
+      };
+    }
+    return undefined;
+  }, [
+    isProcessing,
+    isCompleted,
+    isError,
+    blocks,
+    assistantGroupMessage?.createdAt,
+    taskDetail?.duration,
+    taskDetail?.totalSteps,
+    taskDetail?.totalToolCalls,
+  ]);
+
+  // Check if we have blocks to show (for Processing and Completed states)
+  const hasBlocks = blocks && childrenCount > 0;
+
+  return (
+    <AccordionItem
+      expand={expanded}
+      itemKey={id}
+      onExpandChange={setExpanded}
+      paddingBlock={4}
+      paddingInline={4}
+      title={
+        <TaskTitle
+          agent={
+            agent
+              ? { avatar: agent.avatar || undefined, backgroundColor: agent.backgroundColor }
+              : undefined
+          }
+          metrics={metrics}
+          status={status}
+          title={title}
+        />
+      }
+    >
+      <Block gap={16} padding={12} style={{ marginBlock: 8 }} variant={'outlined'}>
+        {instruction && (
+          <Block padding={12}>
+            <Text fontSize={13} type={'secondary'}>
+              {instruction}
+            </Text>
+          </Block>
+        )}
+
+        {/* Initializing State - no taskDetail yet or no blocks */}
+        {(isInitializing || (isProcessing && !hasBlocks)) && <InitializingState />}
+
+        {/* Processing or Completed State - show blocks via TaskMessages */}
+        {!isInitializing && (isProcessing || isCompleted) && hasBlocks && threadMessages && (
+          <TaskMessages
+            duration={taskDetail?.duration}
+            isProcessing={isProcessing}
+            messages={threadMessages}
+            model={model ?? undefined}
+            provider={provider ?? undefined}
+            startTime={assistantGroupMessage?.createdAt}
+            totalCost={taskDetail?.totalCost}
+          />
+        )}
+
+        {/* Error State */}
+        {!isInitializing && isError && taskDetail && <ErrorState taskDetail={taskDetail} />}
+      </Block>
+    </AccordionItem>
+  );
+}, Object.is);
+
+ClientTaskItem.displayName = 'ClientTaskItem';
+
+export default ClientTaskItem;

package/src/features/Conversation/Messages/GroupTasks/TaskItem/ServerTaskItem.tsx

@@ -0,0 +1,94 @@
+'use client';
+
+import { ThreadStatus } from '@lobechat/types';
+import type { UIChatMessage } from '@lobechat/types';
+import { AccordionItem, Block } from '@lobehub/ui';
+import isEqual from 'fast-deep-equal';
+import { memo, useMemo, useState } from 'react';
+
+import { useAgentGroupStore } from '@/store/agentGroup';
+import { agentGroupSelectors } from '@/store/agentGroup/selectors';
+
+import { TaskContent } from '../../Tasks/shared';
+import TaskTitle, { type TaskMetrics } from './TaskTitle';
+
+interface ServerTaskItemProps {
+  item: UIChatMessage;
+}
+
+const ServerTaskItem = memo<ServerTaskItemProps>(({ item }) => {
+  const { id, agentId, metadata, taskDetail, tasks } = item;
+  const [expanded, setExpanded] = useState(false);
+
+  const title = taskDetail?.title || metadata?.taskTitle;
+  const status = taskDetail?.status;
+  const threadId = taskDetail?.threadId;
+
+  const isCompleted = status === ThreadStatus.Completed;
+  const isError = status === ThreadStatus.Failed || status === ThreadStatus.Cancel;
+
+  // Get agent info from store
+  const activeGroupId = useAgentGroupStore(agentGroupSelectors.activeGroupId);
+  const agent = useAgentGroupStore((s) =>
+    activeGroupId && agentId
+      ? agentGroupSelectors.getAgentByIdFromGroup(activeGroupId, agentId)(s)
+      : null,
+  );
+
+  // Build metrics for TaskTitle (only for completed/error states)
+  const metrics: TaskMetrics | undefined = useMemo(() => {
+    if (isCompleted || isError) {
+      return {
+        duration: taskDetail?.duration,
+        steps: taskDetail?.totalSteps,
+        toolCalls: taskDetail?.totalToolCalls,
+      };
+    }
+    return undefined;
+  }, [
+    isCompleted,
+    isError,
+    taskDetail?.duration,
+    taskDetail?.totalSteps,
+    taskDetail?.totalToolCalls,
+  ]);
+
+  return (
+    <AccordionItem
+      expand={expanded}
+      itemKey={id}
+      onExpandChange={setExpanded}
+      paddingBlock={4}
+      paddingInline={4}
+      title={
+        <TaskTitle
+          agent={
+            agent
+              ? { avatar: agent.avatar || undefined, backgroundColor: agent.backgroundColor }
+              : undefined
+          }
+          metrics={metrics}
+          status={status}
+          title={title}
+        />
+      }
+    >
+      <Block gap={16} padding={12} style={{ marginBlock: 8 }} variant={'outlined'}>
+        {expanded && (
+          <TaskContent
+            id={id}
+            isError={isError}
+            messages={tasks}
+            status={status}
+            taskDetail={taskDetail}
+            threadId={threadId}
+          />
+        )}
+      </Block>
+    </AccordionItem>
+  );
+}, isEqual);
+
+ServerTaskItem.displayName = 'ServerTaskItem';
+
+export default ServerTaskItem;