@lobehub/lobehub 2.0.0-next.186 → 2.0.0-next.188

package/packages/model-runtime/src/core/contextBuilders/google.test.ts

@@ -1028,6 +1028,90 @@ describe('google contextBuilders', () => {
 
       expect(result.parameters?.description).toBe('Test parameters');
     });
+
+    it('should convert const to enum for Google compatibility', () => {
+      const tool: ChatCompletionTool = {
+        function: {
+          description: 'A tool with const values',
+          name: 'constTool',
+          parameters: {
+            properties: {
+              action: { const: 'insert', type: 'string' },
+              nested: {
+                properties: {
+                  operation: { const: 'create', type: 'string' },
+                },
+                type: 'object',
+              },
+            },
+            type: 'object',
+          },
+        },
+        type: 'function',
+      };
+
+      const result = buildGoogleTool(tool);
+
+      // const should be converted to enum with single value
+      expect(result.parameters?.properties).toEqual({
+        action: { enum: ['insert'], type: 'string' },
+        nested: {
+          properties: {
+            operation: { enum: ['create'], type: 'string' },
+          },
+          type: 'object',
+        },
+      });
+    });
+
+    it('should handle oneOf with const values (like page-agent modifyNodes)', () => {
+      const tool: ChatCompletionTool = {
+        function: {
+          description: 'Modify nodes operation',
+          name: 'modifyNodes',
+          parameters: {
+            properties: {
+              operations: {
+                items: {
+                  oneOf: [
+                    {
+                      properties: {
+                        action: { const: 'insert', type: 'string' },
+                        beforeId: { type: 'string' },
+                      },
+                      type: 'object',
+                    },
+                    {
+                      properties: {
+                        action: { const: 'modify', type: 'string' },
+                        content: { type: 'string' },
+                      },
+                      type: 'object',
+                    },
+                  ],
+                },
+                type: 'array',
+              },
+            },
+            type: 'object',
+          },
+        },
+        type: 'function',
+      };
+
+      const result = buildGoogleTool(tool);
+
+      // All const values in nested oneOf should be converted to enum
+      const operations = result.parameters?.properties?.operations as any;
+      expect(operations.items.oneOf[0].properties.action).toEqual({
+        enum: ['insert'],
+        type: 'string',
+      });
+      expect(operations.items.oneOf[1].properties.action).toEqual({
+        enum: ['modify'],
+        type: 'string',
+      });
+    });
   });
 
   describe('buildGoogleTools', () => {

package/packages/model-runtime/src/core/contextBuilders/google.ts

@@ -209,6 +209,39 @@ export const buildGoogleMessages = async (messages: OpenAIChatMessage[]): Promis
   return filteredContents;
 };
 
+/**
+ * Sanitize JSON Schema for Google GenAI compatibility
+ * Google's API doesn't support certain JSON Schema keywords like 'const'
+ * This function recursively processes the schema and converts unsupported keywords
+ */
+const sanitizeSchemaForGoogle = (schema: Record<string, any>): Record<string, any> => {
+  if (!schema || typeof schema !== 'object') return schema;
+
+  // Handle arrays
+  if (Array.isArray(schema)) {
+    return schema.map((item) => sanitizeSchemaForGoogle(item));
+  }
+
+  const result: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(schema)) {
+    // Convert 'const' to 'enum' with single value (Google doesn't support 'const')
+    if (key === 'const') {
+      result['enum'] = [value];
+      continue;
+    }
+
+    // Recursively process nested objects
+    if (value && typeof value === 'object') {
+      result[key] = sanitizeSchemaForGoogle(value);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};
+
 /**
  * Convert ChatCompletionTool to Google FunctionDeclaration
  */
@@ -216,11 +249,14 @@ export const buildGoogleTool = (tool: ChatCompletionTool): FunctionDeclaration =
   const functionDeclaration = tool.function;
   const parameters = functionDeclaration.parameters;
   // refs: https://github.com/lobehub/lobe-chat/pull/5002
-  const properties =
+  const rawProperties =
     parameters?.properties && Object.keys(parameters.properties).length > 0
       ? parameters.properties
       : { dummy: { type: 'string' } }; // dummy property to avoid empty object
 
+  // Sanitize properties to remove unsupported JSON Schema keywords for Google
+  const properties = sanitizeSchemaForGoogle(rawProperties);
+
   return {
     description: functionDeclaration.description,
     name: functionDeclaration.name,

package/packages/model-runtime/src/providers/volcengine/index.ts

@@ -7,12 +7,13 @@ export const LobeVolcengineAI = createOpenAICompatibleRuntime({
   baseURL: 'https://ark.cn-beijing.volces.com/api/v3',
   chatCompletion: {
     handlePayload: (payload) => {
-      const { model, thinking, ...rest } = payload;
+      const { model, thinking, reasoning_effort, ...rest } = payload;
 
       return {
         ...rest,
         model,
         ...(thinking?.type && { thinking: { type: thinking.type } }),
+        ...(reasoning_effort && { reasoning_effort }),
       } as any;
     },
   },

package/packages/model-runtime/src/providers/zhipu/index.test.ts

@@ -382,33 +382,6 @@ describe('LobeZhipuAI - custom features', () => {
           expect.anything(),
         );
       });
-
-      it('should not include thinking for non-4.5 models', async () => {
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'glm-4',
-          temperature: 0.5,
-          thinking: { type: 'enabled', budget_tokens: 1000 },
-        });
-
-        const callArgs = (instance['client'].chat.completions.create as any).mock.calls[0][0];
-        expect(callArgs.thinking).toBeUndefined();
-      });
-
-      it('should handle undefined thinking gracefully for 4.5 models', async () => {
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'glm-4.5',
-          temperature: 0.5,
-        });
-
-        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-          expect.objectContaining({
-            thinking: { type: undefined },
-          }),
-          expect.anything(),
-        );
-      });
     });
 
     describe('Stream parameter', () => {

package/packages/model-runtime/src/providers/zhipu/index.ts

@@ -61,7 +61,7 @@ export const params = {
         ...resolvedParams,
         model,
         stream: true,
-        thinking: model.includes('-4.5') ? { type: thinking?.type } : undefined,
+        thinking: thinking ? { type: thinking.type } : undefined,
         tools: zhipuTools,
       } as any;
     },

package/packages/model-runtime/src/utils/modelParse.ts

@@ -38,9 +38,9 @@ export const MODEL_LIST_CONFIGS = {
     excludeKeywords: ['tts'],
     functionCallKeywords: ['gemini', '!-image-'],
     imageOutputKeywords: ['-image-'],
-    reasoningKeywords: ['thinking', '-2.5-', '!-image-'],
+    reasoningKeywords: ['thinking', '-2.5-', '!-image-', '-3-'],
     searchKeywords: ['-search', '!-image-'],
-    videoKeywords: ['-2.5-', '!-image-'],
+    videoKeywords: ['-2.5-', '!-image-', '-3-'],
     visionKeywords: ['gemini', 'learnlm'],
   },
   inclusionai: {
@@ -126,8 +126,8 @@ export const MODEL_LIST_CONFIGS = {
   },
   zhipu: {
     functionCallKeywords: ['glm-4', 'glm-z1'],
-    reasoningKeywords: ['glm-zero', 'glm-z1', 'glm-4.5'],
-    visionKeywords: ['glm-4v', 'glm-4.1v', 'glm-4.5v'],
+    reasoningKeywords: ['glm-zero', 'glm-z1', 'glm-4.'],
+    visionKeywords: ['re:glm-4(\\.\\d)?v'],
   },
 } as const;
 
@@ -183,36 +183,41 @@ export const EMBEDDING_MODEL_KEYWORDS = ['embedding', 'embed', 'bge', 'm3e'] as
  * @param keywords 关键词列表，支持以下前缀：
  *   - ^ 开头：只在模型ID开头匹配
  *   - ! 开头：排除匹配，优先级最高
+ *   - re: 开头：正则表达式匹配（支持 !re: 正则排除）
  *   - 无前缀：包含匹配（默认行为）
  * @returns 是否匹配（排除逻辑优先）
  */
 const isKeywordListMatch = (modelId: string, keywords: readonly string[]): boolean => {
-  // 先检查排除规则（感叹号开头）
+  const matchKeyword = (keyword: string): boolean => {
+    const rawKeyword = keyword.startsWith('!') ? keyword.slice(1) : keyword;
+
+    if (rawKeyword.startsWith('re:')) {
+      try {
+        return new RegExp(rawKeyword.slice(3)).test(modelId);
+      } catch {
+        return false;
+      }
+    }
+
+    if (rawKeyword.startsWith('^')) {
+      return modelId.startsWith(rawKeyword.slice(1));
+    }
+
+    return modelId.includes(rawKeyword);
+  };
+
+  // 先检查排除规则（感叹号开头，包括 !re:）
   const excludeKeywords = keywords.filter((keyword) => keyword.startsWith('!'));
   const includeKeywords = keywords.filter((keyword) => !keyword.startsWith('!'));
 
-  // 如果匹配任何排除规则，直接返回 false
   for (const excludeKeyword of excludeKeywords) {
-    const keywordWithoutPrefix = excludeKeyword.slice(1);
-    const isMatch = keywordWithoutPrefix.startsWith('^')
-      ? modelId.startsWith(keywordWithoutPrefix.slice(1))
-      : modelId.includes(keywordWithoutPrefix);
-
-    if (isMatch) {
+    if (matchKeyword(excludeKeyword)) {
       return false;
     }
   }
 
   // 检查包含规则
-  return includeKeywords.some((keyword) => {
-    if (keyword.startsWith('^')) {
-      // ^ 开头则只在开头匹配
-      const keywordWithoutPrefix = keyword.slice(1);
-      return modelId.startsWith(keywordWithoutPrefix);
-    }
-    // 默认行为：包含匹配
-    return modelId.includes(keyword);
-  });
+  return includeKeywords.some((keyword) => matchKeyword(keyword));
 };
 
 /**

package/packages/types/src/agent/chatConfig.ts

@@ -31,12 +31,14 @@ export interface LobeAgentChatConfig {
   reasoningEffort?: 'low' | 'medium' | 'high';
   gpt5ReasoningEffort?: 'minimal' | 'low' | 'medium' | 'high';
   gpt5_1ReasoningEffort?: 'none' | 'low' | 'medium' | 'high';
+  gpt5_2ReasoningEffort?: 'none' | 'low' | 'medium' | 'high' | 'xhigh';
+  gpt5_2ProReasoningEffort?: 'medium' | 'high' | 'xhigh';
   /**
    * Output text verbosity control
    */
   textVerbosity?: 'low' | 'medium' | 'high';
   thinking?: 'disabled' | 'auto' | 'enabled';
-  thinkingLevel?: 'low' | 'high';
+  thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high';
   thinkingBudget?: number;
   /**
    * Image aspect ratio for image generation models
@@ -84,6 +86,8 @@ export const AgentChatConfigSchema = z.object({
   enableStreaming: z.boolean().optional(),
   gpt5ReasoningEffort: z.enum(['minimal', 'low', 'medium', 'high']).optional(),
   gpt5_1ReasoningEffort: z.enum(['none', 'low', 'medium', 'high']).optional(),
+  gpt5_2ProReasoningEffort: z.enum(['medium', 'high', 'xhigh']).optional(),
+  gpt5_2ReasoningEffort: z.enum(['none', 'low', 'medium', 'high', 'xhigh']).optional(),
   historyCount: z.number().optional(),
   imageAspectRatio: z.string().optional(),
   imageResolution: z.enum(['1K', '2K', '4K']).optional(),
@@ -99,7 +103,7 @@ export const AgentChatConfigSchema = z.object({
   textVerbosity: z.enum(['low', 'medium', 'high']).optional(),
   thinking: z.enum(['disabled', 'auto', 'enabled']).optional(),
   thinkingBudget: z.number().optional(),
-  thinkingLevel: z.enum(['low', 'high']).optional(),
+  thinkingLevel: z.enum(['minimal', 'low', 'medium', 'high']).optional(),
   urlContext: z.boolean().optional(),
   useModelBuiltinSearch: z.boolean().optional(),
 });

package/src/features/ChatInput/ActionBar/Model/ControlsForm.tsx

@@ -15,12 +15,15 @@ import { useUpdateAgentConfig } from '../../hooks/useUpdateAgentConfig';
 import ContextCachingSwitch from './ContextCachingSwitch';
 import GPT5ReasoningEffortSlider from './GPT5ReasoningEffortSlider';
 import GPT51ReasoningEffortSlider from './GPT51ReasoningEffortSlider';
+import GPT52ProReasoningEffortSlider from './GPT52ProReasoningEffortSlider';
+import GPT52ReasoningEffortSlider from './GPT52ReasoningEffortSlider';
 import ImageAspectRatioSelect from './ImageAspectRatioSelect';
 import ImageResolutionSlider from './ImageResolutionSlider';
 import ReasoningEffortSlider from './ReasoningEffortSlider';
 import ReasoningTokenSlider from './ReasoningTokenSlider';
 import TextVerbositySlider from './TextVerbositySlider';
 import ThinkingBudgetSlider from './ThinkingBudgetSlider';
+import ThinkingLevel2Slider from './ThinkingLevel2Slider';
 import ThinkingLevelSlider from './ThinkingLevelSlider';
 import ThinkingSlider from './ThinkingSlider';
 
@@ -140,6 +143,28 @@ const ControlsForm = memo(() => {
         paddingBottom: 0,
       },
     },
+    {
+      children: <GPT52ReasoningEffortSlider />,
+      desc: 'reasoning_effort',
+      label: t('extendParams.reasoningEffort.title'),
+      layout: 'horizontal',
+      minWidth: undefined,
+      name: 'gpt5_2ReasoningEffort',
+      style: {
+        paddingBottom: 0,
+      },
+    },
+    {
+      children: <GPT52ProReasoningEffortSlider />,
+      desc: 'reasoning_effort',
+      label: t('extendParams.reasoningEffort.title'),
+      layout: 'horizontal',
+      minWidth: undefined,
+      name: 'gpt5_2ProReasoningEffort',
+      style: {
+        paddingBottom: 0,
+      },
+    },
     {
       children: <TextVerbositySlider />,
       desc: 'text_verbosity',
@@ -173,7 +198,7 @@ const ControlsForm = memo(() => {
       layout: isNarrow ? 'vertical' : 'horizontal',
       minWidth: undefined,
       name: 'urlContext',
-      style: isNarrow ? undefined : { width: 445 },
+      style: isNarrow ? undefined : { minWidth: 360 },
       tag: 'urlContext',
     },
     {
@@ -193,8 +218,22 @@ const ControlsForm = memo(() => {
       minWidth: undefined,
       name: 'thinkingLevel',
       style: {
+        minWidth: 400,
+        paddingBottom: 0,
+      },
+      tag: 'thinkingLevel',
+    },
+    {
+      children: <ThinkingLevel2Slider />,
+      label: t('extendParams.thinkingLevel.title'),
+      layout: 'horizontal',
+      minWidth: undefined,
+      name: 'thinkingLevel2',
+      style: {
+        minWidth: 400,
         paddingBottom: 0,
       },
+      tag: 'thinkingLevel',
     },
     {
       children: <ImageAspectRatioSelect />,

package/src/features/ChatInput/ActionBar/Model/GPT52ProReasoningEffortSlider.tsx

@@ -0,0 +1,59 @@
+import { Flexbox } from '@lobehub/ui';
+import { Slider } from 'antd';
+import { memo, useCallback } from 'react';
+
+import { useAgentStore } from '@/store/agent';
+import { chatConfigByIdSelectors } from '@/store/agent/selectors';
+
+import { useAgentId } from '../../hooks/useAgentId';
+import { useUpdateAgentConfig } from '../../hooks/useUpdateAgentConfig';
+
+const GPT52ProReasoningEffortSlider = memo(() => {
+  const agentId = useAgentId();
+  const { updateAgentChatConfig } = useUpdateAgentConfig();
+  const config = useAgentStore((s) => chatConfigByIdSelectors.getChatConfigById(agentId)(s));
+
+  const gpt5_2ProReasoningEffort = config.gpt5_2ProReasoningEffort || 'medium';
+
+  const marks = {
+    0: 'medium',
+    1: 'high',
+    2: 'xhigh',
+  };
+
+  const effortValues = ['medium', 'high', 'xhigh'];
+  const indexValue = effortValues.indexOf(gpt5_2ProReasoningEffort);
+  const currentValue = indexValue === -1 ? 0 : indexValue;
+
+  const updateGPT52ProReasoningEffort = useCallback(
+    (value: number) => {
+      const effort = effortValues[value] as 'medium' | 'high' | 'xhigh';
+      updateAgentChatConfig({ gpt5_2ProReasoningEffort: effort });
+    },
+    [updateAgentChatConfig],
+  );
+
+  return (
+    <Flexbox
+      align={'center'}
+      gap={12}
+      horizontal
+      paddingInline={'0 20px'}
+      style={{ minWidth: 160, width: '100%' }}
+    >
+      <Flexbox flex={1}>
+        <Slider
+          marks={marks}
+          max={2}
+          min={0}
+          onChange={updateGPT52ProReasoningEffort}
+          step={1}
+          tooltip={{ open: false }}
+          value={currentValue}
+        />
+      </Flexbox>
+    </Flexbox>
+  );
+});
+
+export default GPT52ProReasoningEffortSlider;

package/src/features/ChatInput/ActionBar/Model/GPT52ReasoningEffortSlider.tsx

@@ -0,0 +1,61 @@
+import { Flexbox } from '@lobehub/ui';
+import { Slider } from 'antd';
+import { memo, useCallback } from 'react';
+
+import { useAgentStore } from '@/store/agent';
+import { chatConfigByIdSelectors } from '@/store/agent/selectors';
+
+import { useAgentId } from '../../hooks/useAgentId';
+import { useUpdateAgentConfig } from '../../hooks/useUpdateAgentConfig';
+
+const GPT52ReasoningEffortSlider = memo(() => {
+  const agentId = useAgentId();
+  const { updateAgentChatConfig } = useUpdateAgentConfig();
+  const config = useAgentStore((s) => chatConfigByIdSelectors.getChatConfigById(agentId)(s));
+
+  const gpt5_2ReasoningEffort = config.gpt5_2ReasoningEffort || 'none';
+
+  const marks = {
+    0: 'none',
+    1: 'low',
+    2: 'medium',
+    3: 'high',
+    4: 'xhigh',
+  };
+
+  const effortValues = ['none', 'low', 'medium', 'high', 'xhigh'];
+  const indexValue = effortValues.indexOf(gpt5_2ReasoningEffort);
+  const currentValue = indexValue === -1 ? 0 : indexValue;
+
+  const updateGPT52ReasoningEffort = useCallback(
+    (value: number) => {
+      const effort = effortValues[value] as 'none' | 'low' | 'medium' | 'high' | 'xhigh';
+      updateAgentChatConfig({ gpt5_2ReasoningEffort: effort });
+    },
+    [updateAgentChatConfig],
+  );
+
+  return (
+    <Flexbox
+      align={'center'}
+      gap={12}
+      horizontal
+      paddingInline={'0 20px'}
+      style={{ minWidth: 230, width: '100%' }}
+    >
+      <Flexbox flex={1}>
+        <Slider
+          marks={marks}
+          max={4}
+          min={0}
+          onChange={updateGPT52ReasoningEffort}
+          step={1}
+          tooltip={{ open: false }}
+          value={currentValue}
+        />
+      </Flexbox>
+    </Flexbox>
+  );
+});
+
+export default GPT52ReasoningEffortSlider;

package/src/features/ChatInput/ActionBar/Model/TextVerbositySlider.tsx

@@ -39,7 +39,7 @@ const TextVerbositySlider = memo(() => {
       gap={12}
       horizontal
       paddingInline={'0 20px'}
-      style={{ minWidth: 200, width: '100%' }}
+      style={{ minWidth: 160, width: '100%' }}
     >
       <Flexbox flex={1}>
         <Slider

package/src/features/ChatInput/ActionBar/Model/ThinkingLevel2Slider.tsx

@@ -0,0 +1,58 @@
+import { Flexbox } from '@lobehub/ui';
+import { Slider } from 'antd';
+import { memo, useCallback } from 'react';
+
+import { useAgentStore } from '@/store/agent';
+import { chatConfigByIdSelectors } from '@/store/agent/selectors';
+
+import { useAgentId } from '../../hooks/useAgentId';
+import { useUpdateAgentConfig } from '../../hooks/useUpdateAgentConfig';
+
+const ThinkingLevel2Slider = memo(() => {
+  const agentId = useAgentId();
+  const { updateAgentChatConfig } = useUpdateAgentConfig();
+  const config = useAgentStore((s) => chatConfigByIdSelectors.getChatConfigById(agentId)(s));
+
+  const thinkingLevel = config.thinkingLevel || 'high'; // Default to 'high' if not set
+
+  const marks = {
+    0: 'low',
+    1: 'high',
+  };
+
+  const levelValues = ['low', 'high'];
+  const indexValue = levelValues.indexOf(thinkingLevel as any);
+  const currentValue = indexValue === -1 ? 1 : indexValue;
+
+  const updateThinkingLevel = useCallback(
+    (value: number) => {
+      const level = levelValues[value] as 'low' | 'high';
+      updateAgentChatConfig({ thinkingLevel: level });
+    },
+    [updateAgentChatConfig],
+  );
+
+  return (
+    <Flexbox
+      align={'center'}
+      gap={12}
+      horizontal
+      paddingInline={'0 20px'}
+      style={{ minWidth: 110, width: '100%' }}
+    >
+      <Flexbox flex={1}>
+        <Slider
+          marks={marks}
+          max={1}
+          min={0}
+          onChange={updateThinkingLevel}
+          step={1}
+          tooltip={{ open: false }}
+          value={currentValue}
+        />
+      </Flexbox>
+    </Flexbox>
+  );
+});
+
+export default ThinkingLevel2Slider;

package/src/features/ChatInput/ActionBar/Model/ThinkingLevelSlider.tsx

@@ -16,17 +16,19 @@ const ThinkingLevelSlider = memo(() => {
   const thinkingLevel = config.thinkingLevel || 'high'; // Default to 'high' if not set
 
   const marks = {
-    0: 'low',
-    1: 'high',
+    0: 'minimal',
+    1: 'low',
+    2: 'medium',
+    3: 'high',
   };
 
-  const levelValues = ['low', 'high'];
-  const indexValue = levelValues.indexOf(thinkingLevel);
-  const currentValue = indexValue === -1 ? 1 : indexValue;
+  const levelValues = ['minimal', 'low', 'medium', 'high'];
+  const indexValue = levelValues.indexOf(thinkingLevel as any);
+  const currentValue = indexValue === -1 ? 3 : indexValue;
 
   const updateThinkingLevel = useCallback(
     (value: number) => {
-      const level = levelValues[value] as 'low' | 'high';
+      const level = levelValues[value] as 'minimal' | 'low' | 'medium' | 'high';
       updateAgentChatConfig({ thinkingLevel: level });
     },
     [updateAgentChatConfig],
@@ -38,12 +40,12 @@ const ThinkingLevelSlider = memo(() => {
       gap={12}
       horizontal
       paddingInline={'0 20px'}
-      style={{ minWidth: 130, width: '100%' }} // 三项时宽度需改回 200
+      style={{ minWidth: 200, width: '100%' }}
     >
       <Flexbox flex={1}>
         <Slider
           marks={marks}
-          max={1}
+          max={3}
           min={0}
           onChange={updateThinkingLevel}
           step={1}

package/src/helpers/toolEngineering/index.ts

@@ -1,6 +1,7 @@
 /**
  * Tools Engineering - Unified tools processing using ToolsEngine
  */
+import { KnowledgeBaseManifest } from '@lobechat/builtin-tool-knowledge-base';
 import { WebBrowsingManifest } from '@lobechat/builtin-tool-web-browsing';
 import { ToolsEngine } from '@lobechat/context-engine';
 import type { PluginEnableChecker } from '@lobechat/context-engine';
@@ -11,7 +12,6 @@ import { getAgentStoreState } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
 import { getToolStoreState } from '@/store/tool';
 import { klavisStoreSelectors, pluginSelectors } from '@/store/tool/selectors';
-import { KnowledgeBaseManifest } from '@/tools/knowledge-base';
 
 import { getSearchConfig } from '../getSearchConfig';
 import { isCanUseFC } from '../isCanUseFC';

package/src/locales/default/plugin.ts

@@ -73,6 +73,8 @@ export default {
   'builtins.lobe-gtd.title': 'Task Tools',
   'builtins.lobe-knowledge-base.apiName.readKnowledge': 'Read Library content',
   'builtins.lobe-knowledge-base.apiName.searchKnowledgeBase': 'Search Library',
+  'builtins.lobe-knowledge-base.inspector.andMoreFiles': 'and {{count}} more',
+  'builtins.lobe-knowledge-base.inspector.noResults': 'No results',
   'builtins.lobe-knowledge-base.title': 'Library',
   'builtins.lobe-local-system.apiName.editLocalFile': 'Edit file',
   'builtins.lobe-local-system.apiName.getCommandOutput': 'Get command output',
@@ -86,6 +88,9 @@ export default {
   'builtins.lobe-local-system.apiName.runCommand': 'Run command',
   'builtins.lobe-local-system.apiName.searchLocalFiles': 'Search files',
   'builtins.lobe-local-system.apiName.writeLocalFile': 'Write file',
+  'builtins.lobe-local-system.inspector.noResults': 'No results',
+  'builtins.lobe-local-system.inspector.rename.result':
+    '<old>{{oldName}}</old> → <new>{{newName}}</new>',
   'builtins.lobe-local-system.title': 'Local System',
   'builtins.lobe-page-agent.apiName.batchUpdate': 'Batch update nodes',
   'builtins.lobe-page-agent.apiName.compareSnapshots': 'Compare snapshots',
@@ -143,6 +148,7 @@ export default {
   'builtins.lobe-web-browsing.apiName.crawlMultiPages': 'Read multiple pages',
   'builtins.lobe-web-browsing.apiName.crawlSinglePage': 'Read page content',
   'builtins.lobe-web-browsing.apiName.search': 'Search pages',
+  'builtins.lobe-web-browsing.inspector.noResults': 'No results',
   'builtins.lobe-web-browsing.title': 'Web Search',
   'confirm': 'Confirm',
   'debug.arguments': 'Arguments',