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

package/src/features/Conversation/Messages/Group/Tool/Render/Intervention/Fallback.tsx

@@ -0,0 +1,98 @@
+import { safeParseJSON } from '@lobechat/utils';
+import { ActionIcon } from '@lobehub/ui';
+import { Edit3Icon } from 'lucide-react';
+import { Suspense, memo, useCallback, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Flexbox } from 'react-layout-kit';
+
+import { useChatStore } from '@/store/chat';
+import { useUserStore } from '@/store/user';
+import { toolInterventionSelectors } from '@/store/user/selectors';
+
+import Arguments from '../Arguments';
+import ApprovalActions from './ApprovalActions';
+import KeyValueEditor from './KeyValueEditor';
+import ModeSelector from './ModeSelector';
+
+interface FallbackInterventionProps {
+  apiName: string;
+  id: string;
+  identifier: string;
+  requestArgs: string;
+  toolCallId: string;
+}
+
+const FallbackIntervention = memo<FallbackInterventionProps>(
+  ({ requestArgs, id, identifier, apiName, toolCallId }) => {
+    const { t } = useTranslation('chat');
+    const approvalMode = useUserStore(toolInterventionSelectors.approvalMode);
+    const [isEditing, setIsEditing] = useState(false);
+    const [optimisticUpdatePluginArguments] = useChatStore((s) => [
+      s.optimisticUpdatePluginArguments,
+    ]);
+
+    const handleCancel = useCallback(() => {
+      setIsEditing(false);
+    }, []);
+
+    const handleFinish = useCallback(
+      async (editedObject: Record<string, any>) => {
+        if (!id) return;
+
+        try {
+          const newArgsString = JSON.stringify(editedObject, null, 2);
+
+          if (newArgsString !== requestArgs) {
+            await optimisticUpdatePluginArguments(id, editedObject, true);
+          }
+          setIsEditing(false);
+        } catch (error) {
+          console.error('Error stringifying arguments:', error);
+        }
+      },
+      [requestArgs, id],
+    );
+
+    if (isEditing)
+      return (
+        <Suspense fallback={<Arguments arguments={requestArgs} />}>
+          <KeyValueEditor
+            initialValue={safeParseJSON(requestArgs || '')}
+            onCancel={handleCancel}
+            onFinish={handleFinish}
+          />
+        </Suspense>
+      );
+
+    return (
+      <Flexbox gap={12}>
+        <Arguments
+          actions={
+            <ActionIcon
+              icon={Edit3Icon}
+              onClick={() => {
+                setIsEditing(true);
+              }}
+              size={'small'}
+              title={t('edit', { ns: 'common' })}
+            />
+          }
+          arguments={requestArgs}
+        />
+
+        <Flexbox horizontal justify={'space-between'}>
+          <ModeSelector />
+          <ApprovalActions
+            apiName={apiName}
+            approvalMode={approvalMode}
+            identifier={identifier}
+            messageId={id}
+            toolCallId={toolCallId}
+          />
+        </Flexbox>
+      </Flexbox>
+    );
+  },
+);
+
+export default FallbackIntervention;

package/src/features/Conversation/Messages/Group/Tool/Render/Intervention/ModeSelector.tsx

@@ -6,6 +6,7 @@ import { useTranslation } from 'react-i18next';
 import { Center } from 'react-layout-kit';
 
 import { useUserStore } from '@/store/user';
+import { toolInterventionSelectors } from '@/store/user/selectors';
 
 import { ApprovalMode } from './index';
 
@@ -39,10 +40,8 @@ const useStyles = createStyles(({ css, token }) => ({
 const ModeSelector = memo(() => {
   const { t } = useTranslation('chat');
   const { styles } = useStyles();
-  const [approvalMode, setSettings] = useUserStore((s) => [
-    s.settings.tool?.approvalMode || 'manual',
-    s.setSettings,
-  ]);
+  const approvalMode = useUserStore(toolInterventionSelectors.approvalMode);
+  const updateHumanIntervention = useUserStore((s) => s.updateHumanIntervention);
 
   const modeLabels = useMemo(
     () => ({
@@ -55,9 +54,9 @@ const ModeSelector = memo(() => {
 
   const handleModeChange = useCallback(
     async (mode: ApprovalMode) => {
-      await setSettings({ tool: { approvalMode: mode } });
+      await updateHumanIntervention({ approvalMode: mode });
     },
-    [setSettings],
+    [updateHumanIntervention],
   );
 
   const menuItems = useMemo<MenuProps['items']>(

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

@@ -1,15 +1,15 @@
 import { safeParseJSON } from '@lobechat/utils';
-import { ActionIcon } from '@lobehub/ui';
-import { Edit3Icon } from 'lucide-react';
 import { Suspense, memo, useCallback, useState } from 'react';
-import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { useChatStore } from '@/store/chat';
 import { useUserStore } from '@/store/user';
+import { toolInterventionSelectors } from '@/store/user/selectors';
+import { getBuiltinIntervention } from '@/tools/interventions';
 
 import Arguments from '../Arguments';
 import ApprovalActions from './ApprovalActions';
+import Fallback from './Fallback';
 import KeyValueEditor from './KeyValueEditor';
 import ModeSelector from './ModeSelector';
 
@@ -25,8 +25,7 @@ interface InterventionProps {
 
 const Intervention = memo<InterventionProps>(
   ({ requestArgs, id, identifier, apiName, toolCallId }) => {
-    const { t } = useTranslation('chat');
-    const approvalMode = useUserStore((s) => s.settings.tool?.approvalMode || 'manual');
+    const approvalMode = useUserStore(toolInterventionSelectors.approvalMode);
     const [isEditing, setIsEditing] = useState(false);
     const [optimisticUpdatePluginArguments] = useChatStore((s) => [
       s.optimisticUpdatePluginArguments,
@@ -53,45 +52,50 @@ const Intervention = memo<InterventionProps>(
       },
       [requestArgs, id],
     );
+    const BuiltinToolInterventionRender = getBuiltinIntervention(identifier, apiName);
 
-    if (isEditing)
-      return (
-        <Suspense fallback={<Arguments arguments={requestArgs} />}>
-          <KeyValueEditor
-            initialValue={safeParseJSON(requestArgs || '')}
-            onCancel={handleCancel}
-            onFinish={handleFinish}
-          />
-        </Suspense>
-      );
-
-    return (
-      <Flexbox gap={12}>
-        <Arguments
-          actions={
-            <ActionIcon
-              icon={Edit3Icon}
-              onClick={() => {
-                setIsEditing(true);
-              }}
-              size={'small'}
-              title={t('edit', { ns: 'common' })}
+    if (BuiltinToolInterventionRender) {
+      if (isEditing)
+        return (
+          <Suspense fallback={<Arguments arguments={requestArgs} />}>
+            <KeyValueEditor
+              initialValue={safeParseJSON(requestArgs || '')}
+              onCancel={handleCancel}
+              onFinish={handleFinish}
             />
-          }
-          arguments={requestArgs}
-        />
+          </Suspense>
+        );
 
-        <Flexbox horizontal justify={'space-between'}>
-          <ModeSelector />
-          <ApprovalActions
+      return (
+        <Flexbox gap={12}>
+          <BuiltinToolInterventionRender
             apiName={apiName}
-            approvalMode={approvalMode}
+            args={safeParseJSON(requestArgs || '')}
             identifier={identifier}
             messageId={id}
-            toolCallId={toolCallId}
           />
+          <Flexbox horizontal justify={'space-between'}>
+            <ModeSelector />
+            <ApprovalActions
+              apiName={apiName}
+              approvalMode={approvalMode}
+              identifier={identifier}
+              messageId={id}
+              toolCallId={toolCallId}
+            />
+          </Flexbox>
         </Flexbox>
-      </Flexbox>
+      );
+    }
+
+    return (
+      <Fallback
+        apiName={apiName}
+        id={id}
+        identifier={identifier}
+        requestArgs={requestArgs}
+        toolCallId={toolCallId}
+      />
     );
   },
 );

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

@@ -1,7 +1,7 @@
 import { safeParseJSON } from '@lobechat/utils';
 import { memo } from 'react';
 
-import { BuiltinToolPlaceholders } from '@/tools/placeholders';
+import { getBuiltinPlaceholder } from '@/tools/placeholders';
 
 import Arguments from '../Arguments';
 
@@ -14,9 +14,9 @@ interface LoadingPlaceholderProps {
 
 const LoadingPlaceholder = memo<LoadingPlaceholderProps>(
   ({ identifier, requestArgs, apiName, loading }) => {
-    const Render = BuiltinToolPlaceholders[identifier || ''];
+    const Render = getBuiltinPlaceholder(identifier, apiName);
 
-    if (identifier && Render) {
+    if (Render) {
       return (
         <Render apiName={apiName} args={safeParseJSON(requestArgs) || {}} identifier={identifier} />
       );

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/features/PluginsUI/Render/BuiltinType/index.test.tsx

@@ -4,11 +4,17 @@ import { describe, expect, it, vi } from 'vitest';
 import BuiltinType from './index';
 
 // Mock renders module
+const mockWebBrowsingRender = vi.fn(({ content }) => <div>WebBrowsingRender: {content}</div>);
+const mockCodeInterpreterRender = vi.fn(({ content }) => (
+  <div>CodeInterpreterRender: {content}</div>
+));
+
 vi.mock('@/tools/renders', () => ({
-  BuiltinToolsRenders: {
-    'lobe-web-browsing': vi.fn(({ content }) => <div>WebBrowsingRender: {content}</div>),
-    'lobe-code-interpreter': vi.fn(({ content }) => <div>CodeInterpreterRender: {content}</div>),
-  },
+  getBuiltinRender: vi.fn((identifier, apiName) => {
+    if (identifier === 'lobe-web-browsing') return mockWebBrowsingRender;
+    if (identifier === 'lobe-code-interpreter') return mockCodeInterpreterRender;
+    return undefined;
+  }),
 }));
 
 // Mock useParseContent hook

package/src/features/PluginsUI/Render/BuiltinType/index.tsx

@@ -1,7 +1,7 @@
 import { safeParseJSON } from '@lobechat/utils';
 import { memo } from 'react';
 
-import { BuiltinToolsRenders } from '@/tools/renders';
+import { getBuiltinRender } from '@/tools/renders';
 
 import { useParseContent } from '../useParseContent';
 
@@ -28,7 +28,7 @@ const BuiltinType = memo<BuiltinTypeProps>(
   }) => {
     const { data } = useParseContent(content);
 
-    const Render = BuiltinToolsRenders[identifier || ''];
+    const Render = getBuiltinRender(identifier, apiName);
 
     if (!Render) return;
 

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,10 +256,11 @@ export default {
       moveLocalFiles: '移动文件',
       readLocalFile: '读取文件内容',
       renameLocalFile: '重命名',
+      runCommand: '执行代码',
       searchLocalFiles: '搜索文件',
       writeLocalFile: '写入文件',
     },
-    title: '本地文件',
+    title: '本地系统',
   },
   mcpInstall: {
     CHECKING_INSTALLATION: '检查安装环境...',

package/src/services/chat/chat.test.ts

@@ -1004,6 +1004,7 @@ describe('ChatService', () => {
         stream: true,
         ...DEFAULT_AGENT_CONFIG.params,
         ...params,
+        apiMode: 'responses',
       };
 
       await chatService.getChatCompletion(params, options);

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/aiInfra/slices/aiProvider/__tests__/selectors.test.ts

@@ -246,4 +246,66 @@ describe('aiProviderSelectors', () => {
       );
     });
   });
+
+  describe('isProviderEnableResponseApi', () => {
+    it('should return true when config explicitly sets enableResponseApi to true', () => {
+      const state = {
+        ...mockState,
+        aiProviderRuntimeConfig: {
+          test: {
+            config: { enableResponseApi: true },
+            keyVaults: {},
+            settings: {},
+          },
+        },
+      };
+      expect(aiProviderSelectors.isProviderEnableResponseApi('test')(state)).toBe(true);
+    });
+
+    it('should return false when config explicitly sets enableResponseApi to false', () => {
+      const state = {
+        ...mockState,
+        aiProviderRuntimeConfig: {
+          test: {
+            config: { enableResponseApi: false },
+            keyVaults: {},
+            settings: {},
+          },
+        },
+      };
+      expect(aiProviderSelectors.isProviderEnableResponseApi('test')(state)).toBe(false);
+    });
+
+    it('should return true by default for openai provider', () => {
+      const state = {
+        ...mockState,
+        aiProviderRuntimeConfig: {
+          openai: {
+            keyVaults: {},
+            settings: {},
+          },
+        },
+      };
+      expect(aiProviderSelectors.isProviderEnableResponseApi('openai')(state)).toBe(true);
+    });
+
+    it('should return false by default for non-openai provider', () => {
+      const state = {
+        ...mockState,
+        aiProviderRuntimeConfig: {
+          anthropic: {
+            keyVaults: {},
+            settings: {},
+          },
+        },
+      };
+      expect(aiProviderSelectors.isProviderEnableResponseApi('anthropic')(state)).toBe(false);
+    });
+
+    it('should return false for provider without config', () => {
+      expect(aiProviderSelectors.isProviderEnableResponseApi('non-existing')(mockState)).toBe(
+        false,
+      );
+    });
+  });
 });

package/src/store/aiInfra/slices/aiProvider/selectors.ts

@@ -108,7 +108,7 @@ const isProviderEnableResponseApi = (id: string) => (s: AIProviderStoreState) =>
 
   if (typeof enableResponseApi === 'boolean') return enableResponseApi;
 
-  return false;
+  return id === 'openai';
 };
 
 const isInitAiProviderRuntimeState = (s: AIProviderStoreState) => !!s.isInitAiProviderRuntimeState;

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);
       }
     }