@lobehub/lobehub 2.0.0-next.307 → 2.0.0-next.309

package/src/server/services/toolExecution/builtin.ts

@@ -4,6 +4,7 @@ import { type ChatToolPayload } from '@lobechat/types';
 import { safeParseJSON } from '@lobechat/utils';
 import debug from 'debug';
 
+import { LobehubSkillService } from '@/server/services/lobehubSkill';
 import { SearchService } from '@/server/services/search';
 
 import { type IToolExecutor, type ToolExecutionContext, type ToolExecutionResult } from './types';
@@ -19,11 +20,36 @@ export class BuiltinToolsExecutor implements IToolExecutor {
     payload: ChatToolPayload,
     context: ToolExecutionContext,
   ): Promise<ToolExecutionResult> {
-    const { identifier, apiName, arguments: argsStr } = payload;
+    const { identifier, apiName, arguments: argsStr, source } = payload;
     const args = safeParseJSON(argsStr) || {};
 
-    log('Executing builtin tool: %s:%s with args: %O', identifier, apiName, args, context);
+    log(
+      'Executing builtin tool: %s:%s (source: %s) with args: %O',
+      identifier,
+      apiName,
+      source,
+      args,
+    );
 
+    // Route LobeHub Skills to dedicated service
+    if (source === 'lobehubSkill') {
+      if (!context.serverDB || !context.userId) {
+        return {
+          content: 'Server context not available for LobeHub Skills execution.',
+          error: { code: 'CONTEXT_NOT_AVAILABLE' },
+          success: false,
+        };
+      }
+
+      const skillService = new LobehubSkillService(context.serverDB, context.userId);
+      return skillService.execute({
+        args,
+        provider: identifier,
+        toolName: apiName,
+      });
+    }
+
+    // Default: original builtin runtime logic
     const ServerRuntime = BuiltinToolServerRuntimes[identifier];
 
     if (!ServerRuntime) {

package/src/server/services/toolExecution/types.ts

@@ -1,7 +1,10 @@
 import { type LobeToolManifest } from '@lobechat/context-engine';
+import { type LobeChatDatabase } from '@lobechat/database';
 import { type ChatToolPayload } from '@lobechat/types';
 
 export interface ToolExecutionContext {
+  /** Server database for LobeHub Skills execution */
+  serverDB?: LobeChatDatabase;
   toolManifestMap: Record<string, LobeToolManifest>;
   userId?: string;
 }

package/src/store/chat/agents/GroupOrchestration/__tests__/call-supervisor.test.ts

@@ -0,0 +1,305 @@
+import type { AgentState } from '@lobechat/agent-runtime';
+import type { UIChatMessage } from '@lobechat/types';
+import { nanoid } from '@lobechat/utils';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ChatStore } from '@/store/chat/store';
+
+import { createGroupOrchestrationExecutors } from '../createGroupOrchestrationExecutors';
+
+const TEST_IDS = {
+  GROUP_ID: 'test-group-id',
+  OPERATION_ID: 'test-operation-id',
+  ORCHESTRATION_OPERATION_ID: 'test-orchestration-operation-id',
+  SUPERVISOR_AGENT_ID: 'test-supervisor-agent-id',
+  TOPIC_ID: 'test-topic-id',
+  USER_MESSAGE_ID: 'test-user-message-id',
+};
+
+/**
+ * Create a minimal mock store for group orchestration executor tests
+ */
+const createMockStore = (overrides: Partial<ChatStore> = {}): ChatStore => {
+  const operations: Record<string, any> = {};
+
+  return {
+    dbMessagesMap: {},
+    internal_execAgentRuntime: vi.fn().mockResolvedValue(undefined),
+    messagesMap: {},
+    operations,
+    startOperation: vi.fn().mockImplementation((config) => {
+      const operationId = `op_${nanoid()}`;
+      const abortController = new AbortController();
+      operations[operationId] = {
+        abortController,
+        context: config.context || {},
+        id: operationId,
+        status: 'running',
+        type: config.type,
+      };
+      return { abortController, operationId };
+    }),
+    ...overrides,
+  } as unknown as ChatStore;
+};
+
+/**
+ * Create initial agent state for testing
+ */
+const createInitialState = (overrides: Partial<AgentState> = {}): AgentState => {
+  return {
+    cost: {
+      calculatedAt: new Date().toISOString(),
+      currency: 'USD',
+      llm: { byModel: [], currency: 'USD', total: 0 },
+      tools: { byTool: [], currency: 'USD', total: 0 },
+      total: 0,
+    },
+    createdAt: new Date().toISOString(),
+    lastModified: new Date().toISOString(),
+    maxSteps: 10,
+    messages: [],
+    operationId: TEST_IDS.OPERATION_ID,
+    status: 'running',
+    stepCount: 0,
+    toolManifestMap: {},
+    usage: {
+      humanInteraction: {
+        approvalRequests: 0,
+        promptRequests: 0,
+        selectRequests: 0,
+        totalWaitingTimeMs: 0,
+      },
+      llm: { apiCalls: 0, processingTimeMs: 0, tokens: { input: 0, output: 0, total: 0 } },
+      tools: { byTool: [], totalCalls: 0, totalTimeMs: 0 },
+    },
+    userInterventionConfig: { allowList: [], approvalMode: 'auto' },
+    ...overrides,
+  } as AgentState;
+};
+
+describe('createGroupOrchestrationExecutors', () => {
+  describe('call_supervisor executor', () => {
+    it('should NOT pass operationId to internal_execAgentRuntime (creates new child operation)', async () => {
+      const mockStore = createMockStore({
+        dbMessagesMap: {
+          [`group_${TEST_IDS.GROUP_ID}_${TEST_IDS.TOPIC_ID}`]: [
+            {
+              content: 'Hello',
+              createdAt: Date.now(),
+              id: TEST_IDS.USER_MESSAGE_ID,
+              role: 'user',
+              updatedAt: Date.now(),
+            } as UIChatMessage,
+          ],
+        },
+      });
+
+      const executors = createGroupOrchestrationExecutors({
+        get: () => mockStore,
+        messageContext: {
+          agentId: TEST_IDS.GROUP_ID,
+          scope: 'group',
+          topicId: TEST_IDS.TOPIC_ID,
+        },
+        orchestrationOperationId: TEST_IDS.ORCHESTRATION_OPERATION_ID,
+        supervisorAgentId: TEST_IDS.SUPERVISOR_AGENT_ID,
+      });
+
+      const callSupervisorExecutor = executors.call_supervisor!;
+
+      await callSupervisorExecutor(
+        {
+          payload: { round: 1, supervisorAgentId: TEST_IDS.SUPERVISOR_AGENT_ID },
+          type: 'call_supervisor',
+        },
+        createInitialState(),
+      );
+
+      // Verify internal_execAgentRuntime was called
+      expect(mockStore.internal_execAgentRuntime).toHaveBeenCalledTimes(1);
+
+      // Verify operationId is NOT passed (should be undefined)
+      // This ensures a new child operation is created
+      const callArgs = (mockStore.internal_execAgentRuntime as any).mock.calls[0][0];
+      expect(callArgs.operationId).toBeUndefined();
+
+      // Verify parentOperationId is passed correctly
+      expect(callArgs.parentOperationId).toBe(TEST_IDS.ORCHESTRATION_OPERATION_ID);
+
+      // Verify isSupervisor is passed in context
+      expect(callArgs.context.isSupervisor).toBe(true);
+
+      // Verify agentId is the supervisor agent id
+      expect(callArgs.context.agentId).toBe(TEST_IDS.SUPERVISOR_AGENT_ID);
+    });
+
+    it('should pass isSupervisor: true in context for supervisor messages metadata', async () => {
+      const mockStore = createMockStore({
+        dbMessagesMap: {
+          [`group_${TEST_IDS.GROUP_ID}_${TEST_IDS.TOPIC_ID}`]: [
+            {
+              content: 'Hello',
+              createdAt: Date.now(),
+              id: TEST_IDS.USER_MESSAGE_ID,
+              role: 'user',
+              updatedAt: Date.now(),
+            } as UIChatMessage,
+          ],
+        },
+      });
+
+      const executors = createGroupOrchestrationExecutors({
+        get: () => mockStore,
+        messageContext: {
+          agentId: TEST_IDS.GROUP_ID,
+          scope: 'group',
+          topicId: TEST_IDS.TOPIC_ID,
+        },
+        orchestrationOperationId: TEST_IDS.ORCHESTRATION_OPERATION_ID,
+        supervisorAgentId: TEST_IDS.SUPERVISOR_AGENT_ID,
+      });
+
+      const callSupervisorExecutor = executors.call_supervisor!;
+
+      await callSupervisorExecutor(
+        {
+          payload: { round: 1, supervisorAgentId: TEST_IDS.SUPERVISOR_AGENT_ID },
+          type: 'call_supervisor',
+        },
+        createInitialState(),
+      );
+
+      const callArgs = (mockStore.internal_execAgentRuntime as any).mock.calls[0][0];
+
+      // The key assertion: isSupervisor must be true
+      // This is used by createAgentExecutors to set metadata.isSupervisor on assistant messages
+      expect(callArgs.context).toMatchObject({
+        agentId: TEST_IDS.SUPERVISOR_AGENT_ID,
+        isSupervisor: true,
+        scope: 'group',
+        topicId: TEST_IDS.TOPIC_ID,
+      });
+    });
+  });
+
+  describe('call_agent executor', () => {
+    it('should NOT pass operationId to internal_execAgentRuntime (creates new child operation)', async () => {
+      const mockStore = createMockStore({
+        dbMessagesMap: {
+          [`group_${TEST_IDS.GROUP_ID}_${TEST_IDS.TOPIC_ID}`]: [
+            {
+              content: 'Hello',
+              createdAt: Date.now(),
+              id: TEST_IDS.USER_MESSAGE_ID,
+              role: 'user',
+              updatedAt: Date.now(),
+            } as UIChatMessage,
+          ],
+        },
+      });
+
+      const executors = createGroupOrchestrationExecutors({
+        get: () => mockStore,
+        messageContext: {
+          agentId: TEST_IDS.GROUP_ID,
+          scope: 'group',
+          topicId: TEST_IDS.TOPIC_ID,
+        },
+        orchestrationOperationId: TEST_IDS.ORCHESTRATION_OPERATION_ID,
+        supervisorAgentId: TEST_IDS.SUPERVISOR_AGENT_ID,
+      });
+
+      const callAgentExecutor = executors.call_agent!;
+      const targetAgentId = 'target-agent-id';
+
+      await callAgentExecutor(
+        {
+          payload: { agentId: targetAgentId, instruction: 'Please respond' },
+          type: 'call_agent',
+        },
+        createInitialState(),
+      );
+
+      // Verify internal_execAgentRuntime was called
+      expect(mockStore.internal_execAgentRuntime).toHaveBeenCalledTimes(1);
+
+      // Verify operationId is NOT passed (should be undefined)
+      const callArgs = (mockStore.internal_execAgentRuntime as any).mock.calls[0][0];
+      expect(callArgs.operationId).toBeUndefined();
+
+      // Verify parentOperationId is passed correctly
+      expect(callArgs.parentOperationId).toBe(TEST_IDS.ORCHESTRATION_OPERATION_ID);
+
+      // Verify subAgentId is passed (NOT isSupervisor)
+      expect(callArgs.context.subAgentId).toBe(targetAgentId);
+      expect(callArgs.context.isSupervisor).toBeUndefined();
+    });
+  });
+
+  describe('operation structure comparison', () => {
+    it('call_supervisor and call_agent should both create independent child operations', async () => {
+      const mockStore = createMockStore({
+        dbMessagesMap: {
+          [`group_${TEST_IDS.GROUP_ID}_${TEST_IDS.TOPIC_ID}`]: [
+            {
+              content: 'Hello',
+              createdAt: Date.now(),
+              id: TEST_IDS.USER_MESSAGE_ID,
+              role: 'user',
+              updatedAt: Date.now(),
+            } as UIChatMessage,
+          ],
+        },
+      });
+
+      const executors = createGroupOrchestrationExecutors({
+        get: () => mockStore,
+        messageContext: {
+          agentId: TEST_IDS.GROUP_ID,
+          scope: 'group',
+          topicId: TEST_IDS.TOPIC_ID,
+        },
+        orchestrationOperationId: TEST_IDS.ORCHESTRATION_OPERATION_ID,
+        supervisorAgentId: TEST_IDS.SUPERVISOR_AGENT_ID,
+      });
+
+      // Execute call_supervisor
+      await executors.call_supervisor!(
+        {
+          payload: { round: 1, supervisorAgentId: TEST_IDS.SUPERVISOR_AGENT_ID },
+          type: 'call_supervisor',
+        },
+        createInitialState(),
+      );
+
+      // Execute call_agent
+      await executors.call_agent!(
+        {
+          payload: { agentId: 'agent-1', instruction: 'test' },
+          type: 'call_agent',
+        },
+        createInitialState(),
+      );
+
+      // Verify both were called
+      expect(mockStore.internal_execAgentRuntime).toHaveBeenCalledTimes(2);
+
+      // Get both call arguments
+      const supervisorCallArgs = (mockStore.internal_execAgentRuntime as any).mock.calls[0][0];
+      const agentCallArgs = (mockStore.internal_execAgentRuntime as any).mock.calls[1][0];
+
+      // Both should NOT have operationId (create new child operations)
+      expect(supervisorCallArgs.operationId).toBeUndefined();
+      expect(agentCallArgs.operationId).toBeUndefined();
+
+      // Both should have same parentOperationId (orchestration operation)
+      expect(supervisorCallArgs.parentOperationId).toBe(TEST_IDS.ORCHESTRATION_OPERATION_ID);
+      expect(agentCallArgs.parentOperationId).toBe(TEST_IDS.ORCHESTRATION_OPERATION_ID);
+
+      // Supervisor should have isSupervisor: true
+      expect(supervisorCallArgs.context.isSupervisor).toBe(true);
+      expect(agentCallArgs.context.isSupervisor).toBeUndefined();
+    });
+  });
+});

package/src/store/chat/agents/GroupOrchestration/createGroupOrchestrationExecutors.ts

@@ -126,10 +126,11 @@ export const createGroupOrchestrationExecutors = (
 
       // Execute Supervisor agent with the supervisor's agentId in context
       // Mark isSupervisor=true so assistant messages get metadata.isSupervisor for UI rendering
+      // Note: Don't pass operationId - let it create a new child operation (same as call_agent)
+      // This ensures each call has its own immutable context with isSupervisor properly set
       await get().internal_execAgentRuntime({
         context: { ...messageContext, agentId: supervisorAgentId, isSupervisor: true },
         messages,
-        operationId: state.operationId,
         parentMessageId: lastMessage.id,
         parentMessageType: lastMessage.role as 'user' | 'assistant' | 'tool',
         parentOperationId: orchestrationOperationId,

package/src/store/chat/agents/createAgentExecutors.ts

@@ -1087,12 +1087,14 @@ export const createAgentExecutors = (context: {
           }
 
           if (status.status === 'failed') {
-            log('[%s] Task failed: %s', taskLogId, status.error);
+            // Extract error message (error is always a string in TaskStatusResult)
+            const errorMessage = status.error || 'Unknown error';
+            log('[%s] Task failed: %s', taskLogId, errorMessage);
             await context
               .get()
               .optimisticUpdateMessageContent(
                 taskMessageId,
-                `Task failed: ${status.error}`,
+                `Task failed: ${errorMessage}`,
                 undefined,
                 { operationId: state.operationId },
               );

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

@@ -0,0 +1,92 @@
+import { type MCPToolCallResult } from '@/libs/mcp';
+import { useToolStore } from '@/store/tool';
+import { type ChatToolPayload } from '@/types/message';
+import { safeParseJSON } from '@/utils/safeParseJSON';
+
+/**
+ * Executor function type for remote tool invocation
+ * @param payload - Tool call payload
+ * @returns Promise with MCPToolCallResult data
+ */
+export type RemoteToolExecutor = (payload: ChatToolPayload) => Promise<MCPToolCallResult>;
+
+/**
+ * Create a failed MCPToolCallResult
+ */
+const createFailedResult = (
+  errorMessage: string,
+): { content: string; error: any; state: any; success: false } => ({
+  content: errorMessage,
+  error: { message: errorMessage },
+  state: {},
+  success: false,
+});
+
+export const klavisExecutor: RemoteToolExecutor = async (p) => {
+  // payload.identifier 现在是存储用的 identifier（如 'google-calendar'）
+  const identifier = p.identifier;
+  const klavisServers = useToolStore.getState().servers || [];
+  const server = klavisServers.find((s) => s.identifier === identifier);
+
+  if (!server) {
+    return createFailedResult(`Klavis server not found: ${identifier}`);
+  }
+
+  // Parse arguments
+  const args = safeParseJSON(p.arguments) || {};
+
+  // Call Klavis tool via store action
+  const result = await useToolStore.getState().callKlavisTool({
+    serverUrl: server.serverUrl,
+    toolArgs: args,
+    toolName: p.apiName,
+  });
+
+  if (!result.success) {
+    return createFailedResult(result.error || 'Klavis tool execution failed');
+  }
+
+  // result.data is MCPToolCallProcessedResult from server
+  // Convert to MCPToolCallResult format
+  const toolResult = result.data;
+  if (toolResult) {
+    return {
+      content: toolResult.content,
+      error: toolResult.state?.isError ? toolResult.state : undefined,
+      state: toolResult.state,
+      success: toolResult.success,
+    };
+  }
+
+  return createFailedResult('Klavis tool returned empty result');
+};
+
+export const lobehubSkillExecutor: RemoteToolExecutor = async (p) => {
+  // payload.identifier is the provider id (e.g., 'linear', 'microsoft')
+  const provider = p.identifier;
+
+  // Parse arguments
+  const args = safeParseJSON(p.arguments) || {};
+
+  // Call LobeHub Skill tool via store action
+  const result = await useToolStore.getState().callLobehubSkillTool({
+    args,
+    provider,
+    toolName: p.apiName,
+  });
+
+  if (!result.success) {
+    return createFailedResult(
+      result.error || `LobeHub Skill tool ${provider} ${p.apiName} execution failed`,
+    );
+  }
+
+  // Convert to MCPToolCallResult format
+  const content = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
+  return {
+    content,
+    error: undefined,
+    state: { content: [{ text: content, type: 'text' }] },
+    success: true,
+  };
+};