@lobehub/lobehub 2.0.0-next.50 → 2.0.0-next.52

package/src/store/chat/agents/__tests__/GeneralChatAgent.test.ts

@@ -601,5 +601,178 @@ describe('GeneralChatAgent', () => {
         },
       ]);
     });
+
+    it('should execute all tools when user approvalMode is auto-run', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        sessionId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const toolCall: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'dangerous-tool',
+        apiName: 'delete',
+        arguments: '{}',
+        type: 'default',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          'dangerous-tool': {
+            identifier: 'dangerous-tool',
+            humanIntervention: 'required', // Tool requires approval
+          },
+        },
+        userInterventionConfig: {
+          approvalMode: 'auto-run', // But user config overrides
+          allowList: [],
+        },
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [toolCall],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should execute directly despite tool requiring approval
+      expect(result).toEqual([
+        {
+          type: 'call_tool',
+          payload: {
+            parentMessageId: 'msg-1',
+            toolCalling: toolCall,
+          },
+        },
+      ]);
+    });
+
+    it('should respect allowList when approvalMode is allow-list', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        sessionId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const allowedTool: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'bash',
+        apiName: 'bash',
+        arguments: '{"command":"ls"}',
+        type: 'builtin',
+      };
+
+      const blockedTool: ChatToolPayload = {
+        id: 'call-2',
+        identifier: 'bash',
+        apiName: 'dangerous-command',
+        arguments: '{"command":"rm -rf"}',
+        type: 'builtin',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          bash: {
+            identifier: 'bash',
+            humanIntervention: 'never', // Tool doesn't require approval by default
+          },
+        },
+        userInterventionConfig: {
+          approvalMode: 'allow-list',
+          allowList: ['bash/bash'], // Only bash/bash is allowed
+        },
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [allowedTool, blockedTool],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should execute allowed tool first, then request approval for blocked tool
+      expect(result).toEqual([
+        {
+          type: 'call_tool',
+          payload: {
+            parentMessageId: 'msg-1',
+            toolCalling: allowedTool,
+          },
+        },
+        {
+          type: 'request_human_approve',
+          pendingToolsCalling: [blockedTool],
+          reason: 'human_intervention_required',
+        },
+      ]);
+    });
+
+    it('should use tool config when approvalMode is manual', async () => {
+      const agent = new GeneralChatAgent({
+        agentConfig: { maxSteps: 100 },
+        sessionId: 'test-session',
+        modelRuntimeConfig: mockModelRuntimeConfig,
+      });
+
+      const safeTool: ChatToolPayload = {
+        id: 'call-1',
+        identifier: 'web-search',
+        apiName: 'search',
+        arguments: '{}',
+        type: 'default',
+      };
+
+      const dangerousTool: ChatToolPayload = {
+        id: 'call-2',
+        identifier: 'bash',
+        apiName: 'bash',
+        arguments: '{}',
+        type: 'builtin',
+      };
+
+      const state = createMockState({
+        toolManifestMap: {
+          'web-search': {
+            identifier: 'web-search',
+            humanIntervention: 'never', // Safe tool
+          },
+          'bash': {
+            identifier: 'bash',
+            humanIntervention: 'required', // Dangerous tool
+          },
+        },
+        userInterventionConfig: {
+          approvalMode: 'manual', // Use tool's own config
+        },
+      });
+
+      const context = createMockContext('llm_result', {
+        hasToolsCalling: true,
+        toolsCalling: [safeTool, dangerousTool],
+        parentMessageId: 'msg-1',
+      });
+
+      const result = await agent.runner(context, state);
+
+      // Should execute safe tool, request approval for dangerous tool
+      expect(result).toEqual([
+        {
+          type: 'call_tool',
+          payload: {
+            parentMessageId: 'msg-1',
+            toolCalling: safeTool,
+          },
+        },
+        {
+          type: 'request_human_approve',
+          pendingToolsCalling: [dangerousTool],
+          reason: 'human_intervention_required',
+        },
+      ]);
+    });
   });
 });

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

@@ -1,13 +1,10 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 // Disable the auto sort key eslint rule to make the code more logic and readable
-import { AgentRuntime, type AgentRuntimeContext } from '@lobechat/agent-runtime';
+import { type AgentRuntimeContext } from '@lobechat/agent-runtime';
 import { MESSAGE_CANCEL_FLAT } from '@lobechat/const';
 import { produce } from 'immer';
 import { StateCreator } from 'zustand/vanilla';
 
-import { getAgentStoreState } from '@/store/agent';
-import { agentSelectors } from '@/store/agent/slices/chat';
-import { createAgentToolsEngine } from '@/store/chat/agents/createToolEngine';
 import { ChatStore } from '@/store/chat/store';
 import { setNamespace } from '@/utils/storeDebug';
 
@@ -146,7 +143,7 @@ export const conversationControl: StateCreator<
     }
   },
   approveToolCalling: async (toolMessageId) => {
-    const { activeId, activeTopicId, activeThreadId, internal_execAgentRuntime } = get();
+    const { activeThreadId, internal_execAgentRuntime } = get();
 
     // 1. Get tool message and verify it exists
     const toolMessage = dbMessageSelectors.getDbMessageById(toolMessageId)(get());
@@ -158,51 +155,22 @@ export const conversationControl: StateCreator<
     // 3. Get current messages for state construction
     const currentMessages = displayMessageSelectors.mainAIChats(get());
 
-    // 4. Get agent configuration and tools information
-    const agentStoreState = getAgentStoreState();
-    const agentConfigData = agentSelectors.currentAgentConfig(agentStoreState);
-
-    const toolsEngine = createAgentToolsEngine({
-      model: agentConfigData.model,
-      provider: agentConfigData.provider!,
-    });
-    const { enabledToolIds } = toolsEngine.generateToolsDetailed({
-      model: agentConfigData.model,
-      provider: agentConfigData.provider!,
-      toolIds: agentConfigData.plugins,
-    });
-    const toolManifestMap = Object.fromEntries(
-      toolsEngine.getEnabledPluginManifests(enabledToolIds).entries(),
-    );
-
-    // 5. Construct AgentState
-    const state = AgentRuntime.createInitialState({
-      sessionId: activeId,
+    // 4. Create agent state and context with user intervention config
+    const { state, context: initialContext } = get().internal_createAgentState({
       messages: currentMessages,
-      maxSteps: 400,
-      metadata: {
-        sessionId: activeId,
-        topicId: activeTopicId,
-        threadId: activeThreadId,
-      },
-      toolManifestMap,
+      parentMessageId: toolMessageId,
+      threadId: activeThreadId,
     });
 
-    console.log('toolMessage:', toolMessage);
-    // 6. Construct AgentRuntimeContext with 'human_approved_tool' phase
+    // 5. Override context with 'human_approved_tool' phase
     const context: AgentRuntimeContext = {
+      ...initialContext,
       phase: 'human_approved_tool',
       payload: {
         approvedToolCall: toolMessage.plugin,
         parentMessageId: toolMessageId,
         skipCreateToolMessage: true,
       },
-      session: {
-        sessionId: activeId,
-        messageCount: currentMessages.length,
-        status: 'running',
-        stepCount: 0,
-      },
     };
 
     // 7. Execute agent runtime from tool message position

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

@@ -26,6 +26,8 @@ import { createAgentExecutors } from '@/store/chat/agents/createAgentExecutors';
 import { createAgentToolsEngine } from '@/store/chat/agents/createToolEngine';
 import { ChatStore } from '@/store/chat/store';
 import { getFileStoreState } from '@/store/file/store';
+import { toolInterventionSelectors } from '@/store/user/selectors';
+import { getUserStoreState } from '@/store/user/store';
 import { setNamespace } from '@/utils/storeDebug';
 
 import { topicSelectors } from '../../../selectors';
@@ -54,6 +56,19 @@ interface ProcessMessageParams {
  * Core streaming execution actions for AI chat
  */
 export interface StreamingExecutorAction {
+  /**
+   * Creates initial agent state and context with user intervention config
+   */
+  internal_createAgentState: (params: {
+    messages: UIChatMessage[];
+    parentMessageId: string;
+    threadId?: string;
+    initialState?: AgentState;
+    initialContext?: AgentRuntimeContext;
+  }) => {
+    state: AgentState;
+    context: AgentRuntimeContext;
+  };
   /**
    * Retrieves an AI-generated chat message from the backend service with streaming
    */
@@ -106,6 +121,73 @@ export const streamingExecutor: StateCreator<
   [],
   StreamingExecutorAction
 > = (set, get) => ({
+  internal_createAgentState: ({
+    messages,
+    parentMessageId,
+    threadId,
+    initialState,
+    initialContext,
+  }) => {
+    const { activeId, activeTopicId } = get();
+    const agentStoreState = getAgentStoreState();
+    const agentConfigData = agentSelectors.currentAgentConfig(agentStoreState);
+
+    // Get tools manifest map
+    const toolsEngine = createAgentToolsEngine({
+      model: agentConfigData.model,
+      provider: agentConfigData.provider!,
+    });
+    const { enabledToolIds } = toolsEngine.generateToolsDetailed({
+      model: agentConfigData.model,
+      provider: agentConfigData.provider!,
+      toolIds: agentConfigData.plugins,
+    });
+    const toolManifestMap = Object.fromEntries(
+      toolsEngine.getEnabledPluginManifests(enabledToolIds).entries(),
+    );
+
+    // Get user intervention config
+    const userStore = getUserStoreState();
+    const userInterventionConfig = {
+      approvalMode: toolInterventionSelectors.approvalMode(userStore),
+      allowList: toolInterventionSelectors.allowList(userStore),
+    };
+
+    // Create initial state or use provided state
+    const state =
+      initialState ||
+      AgentRuntime.createInitialState({
+        sessionId: activeId,
+        messages,
+        maxSteps: 400,
+        metadata: {
+          sessionId: activeId,
+          topicId: activeTopicId,
+          threadId,
+        },
+        toolManifestMap,
+        userInterventionConfig,
+      });
+
+    // Create initial context or use provided context
+    const context: AgentRuntimeContext = initialContext || {
+      phase: 'init',
+      payload: {
+        model: agentConfigData.model,
+        provider: agentConfigData.provider,
+        parentMessageId,
+      },
+      session: {
+        sessionId: activeId,
+        messageCount: messages.length,
+        status: state.status,
+        stepCount: 0,
+      },
+    };
+
+    return { state, context };
+  },
+
   internal_fetchAIChatMessage: async ({ messages, messageId, params, provider, model }) => {
     const {
       internal_toggleChatLoading,
@@ -469,16 +551,6 @@ export const streamingExecutor: StateCreator<
       },
     });
 
-    const toolsEngine = createAgentToolsEngine({ model: model, provider: provider! });
-    const { enabledToolIds } = toolsEngine.generateToolsDetailed({
-      model: model,
-      provider: provider!,
-      toolIds: agentConfigData.plugins,
-    });
-    const toolManifestMap = Object.fromEntries(
-      toolsEngine.getEnabledPluginManifests(enabledToolIds).entries(),
-    );
-
     const runtime = new AgentRuntime(agent, {
       executors: createAgentExecutors({
         get,
@@ -489,33 +561,18 @@ export const streamingExecutor: StateCreator<
       }),
     });
 
-    // Create initial state or use provided state
-    let state =
-      params.initialState ||
-      AgentRuntime.createInitialState({
-        sessionId: activeId,
+    // Create agent state and context with user intervention config
+    const { state: initialAgentState, context: initialAgentContext } =
+      get().internal_createAgentState({
         messages,
-        // Prevent infinite loops
-        maxSteps: 400,
-        metadata: {
-          sessionId: activeId,
-          topicId: activeTopicId,
-          threadId: params.threadId,
-        },
-        toolManifestMap,
+        parentMessageId: params.parentMessageId,
+        threadId: params.threadId,
+        initialState: params.initialState,
+        initialContext: params.initialContext,
       });
 
-    // Initial context - use provided context or create default 'init' phase
-    let nextContext: AgentRuntimeContext = params.initialContext || {
-      phase: 'init',
-      payload: { model, provider, parentMessageId: params.parentMessageId },
-      session: {
-        sessionId: activeId,
-        messageCount: messages.length,
-        status: state.status,
-        stepCount: 0,
-      },
-    };
+    let state = initialAgentState;
+    let nextContext = initialAgentContext;
 
     log(
       '[internal_execAgentRuntime] Agent runtime loop start, initial phase: %s',

package/src/store/user/selectors.ts

@@ -4,5 +4,6 @@ export {
   keyVaultsConfigSelectors,
   settingsSelectors,
   systemAgentSelectors,
+  toolInterventionSelectors,
   userGeneralSettingsSelectors,
 } from './slices/settings/selectors';

package/src/store/user/slices/settings/action.ts

@@ -26,6 +26,10 @@ export interface UserSettingsAction {
   setSettings: (settings: PartialDeep<UserSettings>) => Promise<void>;
   updateDefaultAgent: (agent: PartialDeep<LobeAgentSettings>) => Promise<void>;
   updateGeneralConfig: (settings: Partial<UserGeneralConfig>) => Promise<void>;
+  updateHumanIntervention: (config: {
+    allowList?: string[];
+    approvalMode?: 'auto-run' | 'allow-list' | 'manual';
+  }) => Promise<void>;
   updateKeyVaults: (settings: Partial<UserKeyVaults>) => Promise<void>;
 
   updateSystemAgent: (
@@ -111,6 +115,14 @@ export const createSettingsSlice: StateCreator<
   updateGeneralConfig: async (general) => {
     await get().setSettings({ general });
   },
+  updateHumanIntervention: async (config) => {
+    const current = get().settings.tool?.humanIntervention || {};
+    await get().setSettings({
+      tool: {
+        humanIntervention: { ...current, ...config },
+      },
+    });
+  },
   updateKeyVaults: async (keyVaults) => {
     await get().setSettings({ keyVaults });
   },

package/src/store/user/slices/settings/selectors/__snapshots__/settings.test.ts.snap

@@ -95,13 +95,6 @@ exports[`settingsSelectors > currentTTS > should merge DEFAULT_TTS_CONFIG and s.
 }
 `;
 
-exports[`settingsSelectors > dalleConfig > should return the dalle configuration 1`] = `
-{
-  "apiKey": "dalle-api-key",
-  "autoGenerate": true,
-}
-`;
-
 exports[`settingsSelectors > defaultAgent > should merge DEFAULT_AGENT and s.settings.defaultAgent correctly 1`] = `
 {
   "config": {

package/src/store/user/slices/settings/selectors/index.ts

@@ -2,3 +2,4 @@ export { userGeneralSettingsSelectors } from './general';
 export { keyVaultsConfigSelectors } from './keyVaults';
 export { settingsSelectors } from './settings';
 export { systemAgentSelectors } from './systemAgent';
+export { toolInterventionSelectors } from './toolIntervention';

package/src/store/user/slices/settings/selectors/settings.test.ts

@@ -120,43 +120,6 @@ describe('settingsSelectors', () => {
     });
   });
 
-  describe('dalleConfig', () => {
-    it('should return the dalle configuration', () => {
-      const s = {
-        settings: {
-          tool: {
-            dalle: {
-              apiKey: 'dalle-api-key',
-              autoGenerate: true,
-            },
-          },
-        },
-      } as unknown as UserStore;
-
-      const result = settingsSelectors.dalleConfig(s);
-
-      expect(result).toMatchSnapshot();
-    });
-  });
-
-  describe('isDalleAutoGenerating', () => {
-    it('should return the autoGenerate flag from dalle configuration', () => {
-      const s = {
-        settings: {
-          tool: {
-            dalle: {
-              autoGenerate: true,
-            },
-          },
-        },
-      } as unknown as UserStore;
-
-      const result = settingsSelectors.isDalleAutoGenerating(s);
-
-      expect(result).toBe(true);
-    });
-  });
-
   describe('getProviderConfigById', () => {
     it('should return the provider config for a given provider id', () => {
       const providerConfig = {

package/src/store/user/slices/settings/selectors/settings.ts

@@ -36,9 +36,6 @@ const defaultAgentMeta = (s: UserStore) => merge(DEFAULT_AGENT_META, defaultAgen
 
 const exportSettings = currentSettings;
 
-const dalleConfig = (s: UserStore) => currentSettings(s).tool?.dalle || {};
-const isDalleAutoGenerating = (s: UserStore) => currentSettings(s).tool?.dalle?.autoGenerate;
-
 const currentSystemAgent = (s: UserStore) =>
   merge(DEFAULT_SYSTEM_AGENT_CONFIG, currentSettings(s).systemAgent);
 
@@ -50,12 +47,10 @@ export const settingsSelectors = {
   currentSettings,
   currentSystemAgent,
   currentTTS,
-  dalleConfig,
   defaultAgent,
   defaultAgentConfig,
   defaultAgentMeta,
   exportSettings,
   getHotkeyById,
-  isDalleAutoGenerating,
   providerConfig: getProviderConfigById,
 };

package/src/store/user/slices/settings/selectors/toolIntervention.ts

@@ -0,0 +1,17 @@
+import type { UserStore } from '@/store/user';
+
+import { currentSettings } from './settings';
+
+const humanInterventionConfig = (s: UserStore) => currentSettings(s).tool?.humanIntervention || {};
+
+const interventionApprovalMode = (s: UserStore) =>
+  currentSettings(s).tool?.humanIntervention?.approvalMode || 'manual';
+
+const interventionAllowList = (s: UserStore) =>
+  currentSettings(s).tool?.humanIntervention?.allowList || [];
+
+export const toolInterventionSelectors = {
+  allowList: interventionAllowList,
+  approvalMode: interventionApprovalMode,
+  config: humanInterventionConfig,
+};

package/src/tools/code-interpreter/Render/index.tsx

@@ -17,7 +17,7 @@ import { chatToolSelectors } from '@/store/chat/slices/builtinTool/selectors';
 import ResultFileGallery from './components/ResultFileGallery';
 
 const CodeInterpreter = memo<
-  BuiltinRenderProps<CodeInterpreterResponse, CodeInterpreterParams, CodeInterpreterState>
+  BuiltinRenderProps<CodeInterpreterParams, CodeInterpreterState, CodeInterpreterResponse>
 >(({ content, args, pluginState, messageId, apiName }) => {
   const { t } = useTranslation('tool');
   const theme = useTheme();

package/src/tools/interventions.ts

@@ -0,0 +1,32 @@
+import { BuiltinIntervention } from '@lobechat/types';
+
+import { LocalSystemApiName, LocalSystemManifest } from './local-system';
+import RunCommand from './local-system/Intervention/RunCommand';
+
+/**
+ * Builtin tools interventions registry
+ * Organized by toolset (identifier) -> API name
+ * Only register APIs that have custom intervention UI
+ */
+export const BuiltinToolInterventions: Record<string, Record<string, any>> = {
+  [LocalSystemManifest.identifier]: {
+    [LocalSystemApiName.runCommand]: RunCommand,
+  },
+};
+
+/**
+ * Get builtin intervention component for a specific API
+ * @param identifier - Tool identifier (e.g., 'lobe-local-system')
+ * @param apiName - API name (e.g., 'runCommand')
+ */
+export const getBuiltinIntervention = (
+  identifier?: string,
+  apiName?: string,
+): BuiltinIntervention | undefined => {
+  if (!identifier || !apiName) return undefined;
+
+  const toolset = BuiltinToolInterventions[identifier];
+  if (!toolset) return undefined;
+
+  return toolset[apiName];
+};

package/src/tools/local-system/Intervention/RunCommand/index.tsx

@@ -0,0 +1,56 @@
+import { RunCommandParams } from '@lobechat/electron-client-ipc';
+import { Highlighter, Text } from '@lobehub/ui';
+import { memo } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+const formatTimeout = (ms?: number) => {
+  if (!ms) return null;
+
+  const seconds = ms / 1000;
+
+  // >= 60s 显示分钟
+  if (seconds >= 60) {
+    const minutes = seconds / 60;
+    return `${minutes.toFixed(1)}min`;
+  }
+
+  // >= 1s 显示秒
+  if (seconds >= 1) {
+    return `${seconds.toFixed(1)}s`;
+  }
+
+  // < 1s 显示毫秒
+  return `${ms}ms`;
+};
+
+interface RunCommandProps extends RunCommandParams {
+  messageId: string;
+}
+
+const RunCommand = memo<RunCommandProps>(({ description, command, timeout }) => {
+  return (
+    <Flexbox gap={8}>
+      <Flexbox horizontal justify={'space-between'}>
+        {description && <Text>{description}</Text>}
+        {timeout && (
+          <Text style={{ fontSize: 12 }} type={'secondary'}>
+            timeout: {formatTimeout(timeout)}
+          </Text>
+        )}
+      </Flexbox>
+      {command && (
+        <Highlighter
+          language={'sh'}
+          showLanguage={false}
+          style={{ padding: '4px 8px' }}
+          variant={'outlined'}
+          wrap
+        >
+          {command}
+        </Highlighter>
+      )}
+    </Flexbox>
+  );
+});
+
+export default RunCommand;

package/src/tools/local-system/Placeholder/ListFiles.tsx

@@ -1,17 +1,15 @@
 import { ListLocalFileParams } from '@lobechat/electron-client-ipc';
+import { BuiltinPlaceholderProps } from '@lobechat/types';
 import { Skeleton } from 'antd';
 import React, { memo } from 'react';
 import { Center, Flexbox } from 'react-layout-kit';
 
 import { LocalFolder } from '@/features/LocalFile';
 
-interface ListFilesProps {
-  args: ListLocalFileParams;
-}
-export const ListFiles = memo<ListFilesProps>(({ args }) => {
+export const ListFiles = memo<BuiltinPlaceholderProps<ListLocalFileParams>>(({ args }) => {
   return (
     <Flexbox gap={12}>
-      <LocalFolder path={args.path} />
+      {args?.path && <LocalFolder path={args.path} />}
       <Center height={140}>
         <Flexbox gap={4} width={'90%'}>
           <Skeleton.Button active block style={{ height: 16 }} />