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

package/src/features/Conversation/Messages/Group/Tool/Render/index.tsx

@@ -1,10 +1,12 @@
 import { LOADING_FLAT } from '@lobechat/const';
 import { ChatToolResult, ToolIntervention } from '@lobechat/types';
 import { Suspense, memo } from 'react';
+import { Flexbox } from 'react-layout-kit';
 
 import CustomRender from './CustomRender';
 import ErrorResponse from './ErrorResponse';
 import Intervention from './Intervention';
+import ModeSelector from './Intervention/ModeSelector';
 import LoadingPlaceholder from './LoadingPlaceholder';
 import RejectedResponse from './RejectedResponse';
 
@@ -99,24 +101,29 @@ const Render = memo<RenderProps>(
 
     return (
       <Suspense fallback={placeholder}>
-        <CustomRender
-          content={result.content || ''}
-          id={toolCallId}
-          plugin={
-            type
-              ? ({
-                  apiName,
-                  arguments: requestArgs || '',
-                  identifier,
-                  type,
-                } as any)
-              : undefined
-          }
-          pluginState={result.state}
-          requestArgs={requestArgs}
-          setShowPluginRender={setShowPluginRender}
-          showPluginRender={showPluginRender}
-        />
+        <Flexbox gap={8}>
+          <CustomRender
+            content={result.content || ''}
+            id={toolCallId}
+            plugin={
+              type
+                ? ({
+                    apiName,
+                    arguments: requestArgs || '',
+                    identifier,
+                    type,
+                  } as any)
+                : undefined
+            }
+            pluginState={result.state}
+            requestArgs={requestArgs}
+            setShowPluginRender={setShowPluginRender}
+            showPluginRender={showPluginRender}
+          />
+          <div>
+            <ModeSelector />
+          </div>
+        </Flexbox>
       </Suspense>
     );
   },

package/src/features/LocalFile/LocalFile.tsx

@@ -1,5 +1,9 @@
+import { Button } from '@lobehub/ui';
+import { Popover, Space } from 'antd';
 import { createStyles } from 'antd-style';
+import { ExternalLink, FolderOpen } from 'lucide-react';
 import React from 'react';
+import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import FileIcon from '@/components/FileIcon';
@@ -13,7 +17,7 @@ const useStyles = createStyles(({ css, token }) => ({
     padding-inline: 4px 8px;
     border-radius: 4px;
 
-    color: ${token.colorTextSecondary};
+    color: ${token.colorText};
 
     :hover {
       color: ${token.colorText};
@@ -39,19 +43,25 @@ interface LocalFileProps {
 
 export const LocalFile = ({ name, path, isDirectory = false }: LocalFileProps) => {
   const { styles } = useStyles();
-  const handleClick = () => {
-    if (!path) return;
+  const { t } = useTranslation('components');
 
+  const handleOpenFile = () => {
+    if (!path) return;
     localFileService.openLocalFileOrFolder(path, isDirectory);
   };
 
-  return (
+  const handleOpenFolder = () => {
+    if (!path) return;
+    localFileService.openFileFolder(path);
+  };
+
+  const fileContent = (
     <Flexbox
       align={'center'}
       className={styles.container}
       gap={4}
       horizontal
-      onClick={handleClick}
+      onClick={isDirectory ? handleOpenFile : undefined}
       style={{ display: 'inline-flex', verticalAlign: 'middle' }}
     >
       <FileIcon fileName={name} isDirectory={isDirectory} size={22} variant={'raw'} />
@@ -60,4 +70,44 @@ export const LocalFile = ({ name, path, isDirectory = false }: LocalFileProps) =
       </Flexbox>
     </Flexbox>
   );
+
+  // Directory: no popover, just click to open
+  if (isDirectory) {
+    return fileContent;
+  }
+
+  // File: show popover with two actions
+  const popoverContent = (
+    <Space.Compact>
+      <Button
+        icon={ExternalLink}
+        onClick={handleOpenFile}
+        size="small"
+        title={t('LocalFile.action.open')}
+      >
+        {t('LocalFile.action.open')}
+      </Button>
+      <Button
+        icon={FolderOpen}
+        onClick={handleOpenFolder}
+        size="small"
+        title={t('LocalFile.action.showInFolder')}
+      >
+        {t('LocalFile.action.showInFolder')}
+      </Button>
+    </Space.Compact>
+  );
+
+  return (
+    <Popover
+      arrow={false}
+      content={popoverContent}
+      styles={{
+        body: { padding: 0 },
+      }}
+      trigger={['hover']}
+    >
+      {fileContent}
+    </Popover>
+  );
 };

package/src/locales/default/components.ts

@@ -108,6 +108,12 @@ export default {
     keyPlaceholder: '键',
     valuePlaceholder: '值',
   },
+  LocalFile: {
+    action: {
+      open: '打开',
+      showInFolder: '在文件夹中显示',
+    },
+  },
   MaxTokenSlider: {
     unlimited: '无限制',
   },

package/src/locales/default/plugin.ts

@@ -256,6 +256,7 @@ export default {
       moveLocalFiles: '移动文件',
       readLocalFile: '读取文件内容',
       renameLocalFile: '重命名',
+      runCommand: '执行代码',
       searchLocalFiles: '搜索文件',
       writeLocalFile: '写入文件',
     },

package/src/services/electron/localFileService.ts

@@ -98,6 +98,10 @@ class LocalFileService {
       return this.openLocalFile({ path });
     }
   }
+
+  async openFileFolder(path: string) {
+    return this.openLocalFolder({ isDirectory: false, path });
+  }
 }
 
 export const localFileService = new LocalFileService();

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

@@ -54,6 +54,7 @@ export class GeneralChatAgent implements Agent {
 
   /**
    * Check if tool calls need human intervention
+   * Combines user's global config with tool's own config
    * Returns [toolsNeedingIntervention, toolsToExecute]
    */
   private checkInterventionNeeded(
@@ -63,7 +64,31 @@ export class GeneralChatAgent implements Agent {
     const toolsNeedingIntervention: ChatToolPayload[] = [];
     const toolsToExecute: ChatToolPayload[] = [];
 
+    // Get user config (default to 'manual' mode)
+    const userConfig = state.userInterventionConfig || { approvalMode: 'manual' };
+    const { approvalMode, allowList = [] } = userConfig;
+
     for (const toolCalling of toolsCalling) {
+      const { identifier, apiName } = toolCalling;
+      const toolKey = `${identifier}/${apiName}`;
+
+      // Priority 1: User config is 'auto-run', all tools execute directly
+      if (approvalMode === 'auto-run') {
+        toolsToExecute.push(toolCalling);
+        continue;
+      }
+
+      // Priority 2: User config is 'allow-list', check if tool is in whitelist
+      if (approvalMode === 'allow-list') {
+        if (allowList.includes(toolKey)) {
+          toolsToExecute.push(toolCalling);
+        } else {
+          toolsNeedingIntervention.push(toolCalling);
+        }
+        continue;
+      }
+
+      // Priority 3: User config is 'manual' (default), use tool's own config
       const config = this.getToolInterventionConfig(toolCalling, state);
 
       // Parse arguments for intervention checking
@@ -82,7 +107,7 @@ export class GeneralChatAgent implements Agent {
       if (policy === 'never') {
         toolsToExecute.push(toolCalling);
       } else {
-        // 'require' or 'first' (when not confirmed) requires intervention
+        // 'required' or undefined requires intervention
         toolsNeedingIntervention.push(toolCalling);
       }
     }

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';