@lobehub/chat 1.138.2 → 1.138.4

package/packages/prompts/src/contexts/supervisor/makeDecision.ts

@@ -0,0 +1,68 @@
+import { ChatCompletionTool, ChatMessage, ChatStreamPayload } from '@lobechat/types';
+
+import { groupChatPrompts, groupSupervisorPrompts } from '../../prompts';
+import { SupervisorToolName, SupervisorTools } from './tools';
+
+interface SupervisorTodoItem {
+  // optional assigned owner (agent id or name)
+  assignee?: string;
+  content: string;
+  finished: boolean;
+}
+
+interface AgentItem {
+  id: string;
+  title?: string | null;
+}
+export interface SupervisorContext {
+  allowDM?: boolean;
+  availableAgents: AgentItem[];
+  messages: ChatMessage[];
+  // Group scene controls which tools are exposed (e.g., todos only in 'productive')
+  scene?: 'casual' | 'productive';
+  systemPrompt?: string;
+  todoList?: SupervisorTodoItem[];
+  userName?: string;
+}
+
+export const contextSupervisorMakeDecision = ({
+  allowDM,
+  scene,
+  systemPrompt,
+  availableAgents,
+  todoList,
+  userName,
+  messages,
+}: SupervisorContext) => {
+  const conversationHistory = groupSupervisorPrompts(messages);
+  const prompt = groupChatPrompts.buildSupervisorPrompt({
+    allowDM,
+    availableAgents: availableAgents.filter((agent) => agent.id),
+    conversationHistory,
+    scene,
+    systemPrompt,
+    todoList,
+    userName,
+  });
+
+  const tools = SupervisorTools.filter((tool) => {
+    if (tool.name === SupervisorToolName.trigger_agent_dm) {
+      return allowDM;
+    }
+
+    if ([SupervisorToolName.finish_todo, SupervisorToolName.create_todo].includes(tool.name)) {
+      return scene === 'productive';
+    }
+
+    return true;
+  }).map<ChatCompletionTool>((tool) => ({
+    function: tool,
+    type: 'function',
+  }));
+
+  return {
+    messages: [{ content: prompt, role: 'user' }],
+    temperature: 0.3,
+    tools,
+  } satisfies Partial<ChatStreamPayload>;
+};

package/packages/prompts/src/contexts/supervisor/tools.ts

@@ -0,0 +1,102 @@
+import { LobeUniformTool } from '@lobechat/types';
+
+export const SupervisorToolName = {
+  create_todo: 'create_todo',
+  finish_todo: 'finish_todo',
+  trigger_agent: 'trigger_agent',
+  trigger_agent_dm: 'trigger_agent_dm',
+  wait_for_user_input: 'wait_for_user_input',
+};
+
+export const SupervisorTools: LobeUniformTool[] = [
+  {
+    description: 'Trigger an agent to speak (group message).',
+    name: SupervisorToolName.trigger_agent,
+    parameters: {
+      properties: {
+        id: {
+          description: 'The agent id to trigger.',
+          type: 'string',
+        },
+        instruction: {
+          description:
+            'The instruction or message for the agent. No longer than 10 words. Always use English.',
+          type: 'string',
+        },
+      },
+      required: ['id', 'instruction'],
+      type: 'object',
+    },
+  },
+  {
+    description:
+      'Wait for user input. Use this when the conversation history looks likes fine for now, or agents are waiting for user input.',
+    name: SupervisorToolName.wait_for_user_input,
+    parameters: {
+      properties: {
+        reason: {
+          description: 'Optional reason for pausing the conversation.',
+          type: 'string',
+        },
+      },
+      required: [],
+      type: 'object',
+    },
+  },
+
+  {
+    description: 'Trigger an agent to DM another agent or user.',
+    name: SupervisorToolName.trigger_agent_dm,
+    parameters: {
+      additionalProperties: false,
+      properties: {
+        id: {
+          description: 'The agent id to trigger.',
+          type: 'string',
+        },
+        instruction: {
+          type: 'string',
+        },
+        target: {
+          description: 'The target agent id. Only used when need DM.',
+          type: 'string',
+        },
+      },
+      required: ['instruction', 'id', 'target'],
+      type: 'object',
+    },
+  },
+  {
+    description: 'Create a new todo item',
+    name: SupervisorToolName.create_todo,
+    parameters: {
+      additionalProperties: false,
+      properties: {
+        assignee: {
+          description: 'Who will do the todo. Can be agent id or empty.',
+          type: 'string',
+        },
+        content: {
+          description: 'The todo content or description.',
+          type: 'string',
+        },
+      },
+      required: ['content', 'assignee'],
+      type: 'object',
+    },
+  },
+  {
+    description: 'Finish a todo by index or all todos',
+    name: SupervisorToolName.finish_todo,
+    parameters: {
+      additionalProperties: false,
+      properties: {
+        index: {
+          type: 'number',
+        },
+      },
+      required: ['index'],
+      type: 'object',
+    },
+  },
+];

package/packages/prompts/src/index.ts

@@ -1,2 +1,3 @@
 export * from './chains';
+export * from './contexts';
 export * from './prompts';

package/packages/types/src/aiChat.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 
 import { ChatMessage } from './message';
+import { OpenAIChatMessage } from './openai/chat';
 import { LobeUniformTool, LobeUniformToolSchema } from './tool';
 import { ChatTopic } from './topic';
 
@@ -74,8 +75,9 @@ export const StructureOutputSchema = z.object({
   model: z.string(),
   provider: z.string(),
   schema: StructureSchema.optional(),
-  systemRole: z.string().optional(),
-  tools: z.array(LobeUniformToolSchema).optional(),
+  tools: z
+    .array(z.object({ function: LobeUniformToolSchema, type: z.literal('function') }))
+    .optional(),
 });
 
 interface IStructureSchema {
@@ -92,10 +94,13 @@ interface IStructureSchema {
 
 export interface StructureOutputParams {
   keyVaultsPayload: string;
-  messages: ChatMessage[];
+  messages: OpenAIChatMessage[];
   model: string;
   provider: string;
   schema?: IStructureSchema;
   systemRole?: string;
-  tools?: LobeUniformTool[];
+  tools?: {
+    function: LobeUniformTool;
+    type: 'function';
+  }[];
 }

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

@@ -60,7 +60,6 @@ export const aiChatRouter = router({
       messages: input.messages,
       model: input.model,
       schema: input.schema,
-      systemRole: input.systemRole,
       tools: input.tools,
     });
 

package/src/server/services/aiChat/index.test.ts

@@ -32,7 +32,7 @@ describe('AiChatService', () => {
       { includeTopic: true, sessionId: 's1' },
       expect.objectContaining({ postProcessUrl: expect.any(Function) }),
     );
-    expect(mockQueryTopics).toHaveBeenCalledWith({ sessionId: 's1' });
+    expect(mockQueryTopics).toHaveBeenCalledWith({ containerId: 's1' });
     expect(res.messages).toEqual([{ id: 'm1' }]);
     expect(res.topics).toEqual([{ id: 't1' }]);
   });

package/src/server/services/aiChat/index.ts

@@ -29,7 +29,7 @@ export class AiChatService {
       this.messageModel.query(params, {
         postProcessUrl: (path) => this.fileService.getFullFileUrl(path),
       }),
-      params.includeTopic ? this.topicModel.query({ sessionId: params.sessionId }) : undefined,
+      params.includeTopic ? this.topicModel.query({ containerId: params.sessionId }) : undefined,
     ]);
 
     return { messages, topics };

package/src/services/topic/client.ts

@@ -38,7 +38,7 @@ export class ClientService extends BaseClientService implements ITopicService {
   getTopics: ITopicService['getTopics'] = async (params) => {
     const data = await this.topicModel.query({
       ...params,
-      sessionId: this.toDbSessionId(params.containerId),
+      containerId: this.toDbSessionId(params.containerId),
     });
     return data as unknown as Promise<ChatTopic[]>;
   };

package/src/store/chat/slices/message/supervisor.test.ts

@@ -5,10 +5,17 @@ import { aiChatService } from '@/services/aiChat';
 import { GroupChatSupervisor, type SupervisorContext } from './supervisor';
 
 vi.mock('@lobechat/prompts', () => ({
-  groupChatPrompts: {
-    buildSupervisorPrompt: vi.fn(() => 'structured-supervisor-prompt'),
-  },
-  groupSupervisorPrompts: vi.fn(() => 'conversation-history'),
+  contextSupervisorMakeDecision: vi.fn(() => ({
+    messages: [{ content: 'structured-supervisor-prompt', role: 'user' }],
+    temperature: 0.3,
+    tools: [
+      { function: { name: 'trigger_agent' }, type: 'function' },
+      { function: { name: 'wait_for_user_input' }, type: 'function' },
+      { function: { name: 'trigger_agent_dm' }, type: 'function' },
+      { function: { name: 'create_todo' }, type: 'function' },
+      { function: { name: 'finish_todo' }, type: 'function' },
+    ],
+  })),
 }));
 
 vi.mock('@/services/aiChat', () => ({
@@ -76,7 +83,7 @@ describe('GroupChatSupervisor', () => {
       temperature: 0.3,
     });
 
-    const toolNames = (payload.tools ?? []).map((tool: any) => tool.name);
+    const toolNames = (payload.tools ?? []).map((tool: any) => tool.function.name);
     expect(toolNames).toEqual(
       expect.arrayContaining([
         'trigger_agent',

package/src/store/chat/slices/message/supervisor.ts

@@ -1,4 +1,4 @@
-import { groupChatPrompts, groupSupervisorPrompts } from '@lobechat/prompts';
+import { contextSupervisorMakeDecision } from '@lobechat/prompts';
 import { ChatMessage, GroupMemberWithAgent } from '@lobechat/types';
 
 import { aiChatService } from '@/services/aiChat';
@@ -61,7 +61,7 @@ export class GroupChatSupervisor {
    * Make decision on who should speak next
    */
   async makeDecision(context: SupervisorContext): Promise<SupervisorDecisionResult> {
-    const { messages, availableAgents, userName, systemPrompt, allowDM, todoList } = context;
+    const { availableAgents } = context;
 
     // If no agents available, stop conversation
     if (availableAgents.length === 0) {
@@ -69,22 +69,7 @@ export class GroupChatSupervisor {
     }
 
     try {
-      // Create supervisor prompt with conversation context
-      const conversationHistory = groupSupervisorPrompts(messages);
-
-      const supervisorPrompt = groupChatPrompts.buildSupervisorPrompt({
-        allowDM,
-        availableAgents: availableAgents
-          .filter((agent) => agent.id)
-          .map((agent) => ({ id: agent.id!, title: agent.title })),
-        conversationHistory,
-        scene: context.scene,
-        systemPrompt,
-        todoList,
-        userName,
-      });
-
-      const response = await this.callLLMForDecision(supervisorPrompt, context);
+      const response = await this.callLLMForDecision(context);
       const result = this.parseSupervisorResponse(response, availableAgents, context);
 
       console.log('Supervisor TODO list:', result.todos);
@@ -102,123 +87,25 @@ export class GroupChatSupervisor {
    * Call LLM service to get supervisor decision
    */
   private async callLLMForDecision(
-    prompt: string,
     context: SupervisorContext,
   ): Promise<SupervisorToolCall[] | string> {
-    const supervisorConfig = {
-      model: context.model,
-      provider: context.provider,
-      temperature: 0.3,
-    };
-
-    // Build tools array
-    const tools: any[] = [
-      {
-        description: 'Trigger an agent to speak (group message).',
-        name: 'trigger_agent',
-        parameters: {
-          properties: {
-            id: {
-              description: 'The agent id to trigger.',
-              type: 'string',
-            },
-            instruction: {
-              description:
-                'The instruction or message for the agent. No longer than 10 words. Always use English.',
-              type: 'string',
-            },
-          },
-          required: ['id', 'instruction'],
-          type: 'object',
-        },
-      },
-      {
-        description:
-          'Wait for user input. Use this when the conversation history looks likes fine for now, or agents are waiting for user input.',
-        name: 'wait_for_user_input',
-        parameters: {
-          properties: {
-            reason: {
-              description: 'Optional reason for pausing the conversation.',
-              type: 'string',
-            },
-          },
-          required: [],
-          type: 'object',
-        },
-      },
-    ];
-
-    // Add DM tool if allowed
-    if (context.allowDM) {
-      tools.push({
-        description: 'Trigger an agent to DM another agent or user.',
-        name: 'trigger_agent_dm',
-        parameters: {
-          properties: {
-            id: {
-              description: 'The agent id to trigger.',
-              type: 'string',
-            },
-            instruction: {
-              description: 'The instruction or message for the agent.',
-              type: 'string',
-            },
-            target: {
-              description: 'The target agent id. Only used when need DM.',
-              type: 'string',
-            },
-          },
-          required: ['id', 'instruction', 'target'],
-          type: 'object',
-        },
-      });
-    }
-
-    // Add todo tools if in productive scene
-    if (context.scene === 'productive') {
-      tools.push(
-        {
-          description: 'Create a new todo item',
-          name: 'create_todo',
-          parameters: {
-            properties: {
-              assignee: {
-                description: 'Who will do the todo. Can be agent id or empty.',
-                type: 'string',
-              },
-              content: {
-                description: 'The todo content or description.',
-                type: 'string',
-              },
-            },
-            required: ['content', 'assignee'],
-            type: 'object',
-          },
-        },
-        {
-          description: 'Finish a todo by index',
-          name: 'finish_todo',
-          parameters: {
-            properties: {
-              index: {
-                description: 'The index of the todo to finish.',
-                type: 'number',
-              },
-            },
-            required: ['index'],
-            type: 'object',
-          },
-        },
-      );
-    }
+    const contexts = contextSupervisorMakeDecision({
+      allowDM: context.allowDM,
+      availableAgents: context.availableAgents
+        .filter((agent) => agent.id)
+        .map((agent) => ({ id: agent.id, title: agent.title })),
+      messages: context.messages,
+      scene: context.scene,
+      todoList: context.todoList,
+      userName: context.userName,
+    });
 
     try {
       const response = await aiChatService.generateJSON(
         {
-          messages: [{ content: prompt, role: 'user' }] as any,
-          tools,
-          ...supervisorConfig,
+          ...(contexts as any),
+          model: context.model,
+          provider: context.provider,
         },
         context.abortController || new AbortController(),
       );