@lobehub/lobehub 2.0.0-next.187 → 2.0.0-next.189

package/packages/builtin-tool-local-system/src/executor/index.ts

@@ -0,0 +1,435 @@
+import type {
+  EditLocalFileParams,
+  EditLocalFileResult,
+  GetCommandOutputParams,
+  GetCommandOutputResult,
+  GlobFilesParams,
+  GlobFilesResult,
+  GrepContentParams,
+  GrepContentResult,
+  KillCommandParams,
+  KillCommandResult,
+  ListLocalFileParams,
+  LocalFileItem,
+  LocalMoveFilesResultItem,
+  LocalReadFileParams,
+  LocalReadFileResult,
+  LocalReadFilesParams,
+  LocalSearchFilesParams,
+  MoveLocalFilesParams,
+  RenameLocalFileParams,
+  RenameLocalFileResult,
+  RunCommandParams,
+  RunCommandResult,
+  WriteLocalFileParams,
+} from '@lobechat/electron-client-ipc';
+import { BaseExecutor, type BuiltinToolResult } from '@lobechat/types';
+
+import { localFileService } from '@/services/electron/localFileService';
+
+import {
+  type EditLocalFileState,
+  type GetCommandOutputState,
+  type GlobFilesState,
+  type GrepContentState,
+  type KillCommandState,
+  type LocalFileListState,
+  type LocalFileSearchState,
+  type LocalMoveFilesState,
+  type LocalReadFileState,
+  type LocalReadFilesState,
+  type LocalRenameFileState,
+  LocalSystemIdentifier,
+  type RunCommandState,
+} from '../types';
+
+const LocalSystemApiEnum = {
+  editLocalFile: 'editLocalFile' as const,
+  getCommandOutput: 'getCommandOutput' as const,
+  globLocalFiles: 'globLocalFiles' as const,
+  grepContent: 'grepContent' as const,
+  killCommand: 'killCommand' as const,
+  listLocalFiles: 'listLocalFiles' as const,
+  moveLocalFiles: 'moveLocalFiles' as const,
+  readLocalFile: 'readLocalFile' as const,
+  readLocalFiles: 'readLocalFiles' as const,
+  renameLocalFile: 'renameLocalFile' as const,
+  runCommand: 'runCommand' as const,
+  searchLocalFiles: 'searchLocalFiles' as const,
+  writeLocalFile: 'writeLocalFile' as const,
+};
+
+/**
+ * Local System Tool Executor
+ *
+ * Handles all local file system operations including file CRUD, shell commands, and search.
+ */
+class LocalSystemExecutor extends BaseExecutor<typeof LocalSystemApiEnum> {
+  readonly identifier = LocalSystemIdentifier;
+  protected readonly apiEnum = LocalSystemApiEnum;
+
+  // ==================== File Operations ====================
+
+  listLocalFiles = async (params: ListLocalFileParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: LocalFileItem[] = await localFileService.listLocalFiles(params);
+
+      const state: LocalFileListState = { listResults: result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  readLocalFile = async (params: LocalReadFileParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: LocalReadFileResult = await localFileService.readLocalFile(params);
+
+      const state: LocalReadFileState = { fileContent: result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  readLocalFiles = async (params: LocalReadFilesParams): Promise<BuiltinToolResult> => {
+    try {
+      const results: LocalReadFileResult[] = await localFileService.readLocalFiles(params);
+
+      const state: LocalReadFilesState = { filesContent: results };
+
+      return {
+        content: JSON.stringify(results),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  searchLocalFiles = async (params: LocalSearchFilesParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: LocalFileItem[] = await localFileService.searchLocalFiles(params);
+
+      const state: LocalFileSearchState = { searchResults: result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  moveLocalFiles = async (params: MoveLocalFilesParams): Promise<BuiltinToolResult> => {
+    try {
+      const results: LocalMoveFilesResultItem[] = await localFileService.moveLocalFiles(params);
+
+      const allSucceeded = results.every((r) => r.success);
+      const someFailed = results.some((r) => !r.success);
+      const successCount = results.filter((r) => r.success).length;
+      const failedCount = results.length - successCount;
+
+      let message = '';
+
+      if (allSucceeded) {
+        message = `Successfully moved ${results.length} item(s).`;
+      } else if (someFailed) {
+        message = `Moved ${successCount} item(s) successfully. Failed to move ${failedCount} item(s).`;
+      } else {
+        message = `Failed to move all ${results.length} item(s).`;
+      }
+
+      const state: LocalMoveFilesState = {
+        results,
+        successCount,
+        totalCount: results.length,
+      };
+
+      return {
+        content: JSON.stringify({ message, results }),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  renameLocalFile = async (params: RenameLocalFileParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: RenameLocalFileResult = await localFileService.renameLocalFile(params);
+
+      if (!result.success) {
+        const state: LocalRenameFileState = {
+          error: result.error,
+          newPath: '',
+          oldPath: params.path,
+          success: false,
+        };
+
+        return {
+          content: JSON.stringify({ message: result.error, success: false }),
+          state,
+          success: false,
+        };
+      }
+
+      const state: LocalRenameFileState = {
+        newPath: result.newPath!,
+        oldPath: params.path,
+        success: true,
+      };
+
+      return {
+        content: JSON.stringify({
+          message: `Successfully renamed file ${params.path} to ${params.newName}.`,
+          success: true,
+        }),
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  writeLocalFile = async (params: WriteLocalFileParams): Promise<BuiltinToolResult> => {
+    try {
+      const result = await localFileService.writeFile(params);
+
+      if (!result.success) {
+        return {
+          content: JSON.stringify({
+            message: result.error || 'Failed to write file',
+            success: false,
+          }),
+          error: { message: result.error || 'Failed to write file', type: 'PluginServerError' },
+          success: false,
+        };
+      }
+
+      return {
+        content: JSON.stringify({
+          message: `Successfully wrote file ${params.path}`,
+          success: true,
+        }),
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  editLocalFile = async (params: EditLocalFileParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: EditLocalFileResult = await localFileService.editLocalFile(params);
+
+      if (!result.success) {
+        return {
+          content: `Edit failed: ${result.error}`,
+          success: false,
+        };
+      }
+
+      const statsText =
+        result.linesAdded || result.linesDeleted
+          ? ` (+${result.linesAdded || 0} -${result.linesDeleted || 0})`
+          : '';
+      const message = `Successfully replaced ${result.replacements} occurrence(s) in ${params.file_path}${statsText}`;
+
+      const state: EditLocalFileState = {
+        diffText: result.diffText,
+        linesAdded: result.linesAdded,
+        linesDeleted: result.linesDeleted,
+        replacements: result.replacements,
+      };
+
+      return {
+        content: message,
+        state,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  // ==================== Shell Commands ====================
+
+  runCommand = async (params: RunCommandParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: RunCommandResult = await localFileService.runCommand(params);
+
+      let message: string;
+
+      if (result.success) {
+        if (result.shell_id) {
+          message = `Command started in background with shell_id: ${result.shell_id}`;
+        } else {
+          message = `Command completed successfully.`;
+        }
+      } else {
+        message = `Command failed: ${result.error}`;
+      }
+
+      const state: RunCommandState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  getCommandOutput = async (params: GetCommandOutputParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: GetCommandOutputResult = await localFileService.getCommandOutput(params);
+
+      const message = result.success
+        ? `Output retrieved. Running: ${result.running}`
+        : `Failed: ${result.error}`;
+
+      const state: GetCommandOutputState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  killCommand = async (params: KillCommandParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: KillCommandResult = await localFileService.killCommand(params);
+
+      const message = result.success
+        ? `Successfully killed shell: ${params.shell_id}`
+        : `Failed to kill shell: ${result.error}`;
+
+      const state: KillCommandState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  // ==================== Search & Find ====================
+
+  grepContent = async (params: GrepContentParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: GrepContentResult = await localFileService.grepContent(params);
+
+      const message = result.success
+        ? `Found ${result.total_matches} matches in ${result.matches.length} locations`
+        : 'Search failed';
+
+      const state: GrepContentState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+
+  globLocalFiles = async (params: GlobFilesParams): Promise<BuiltinToolResult> => {
+    try {
+      const result: GlobFilesResult = await localFileService.globFiles(params);
+
+      const message = result.success ? `Found ${result.total_files} files` : 'Glob search failed';
+
+      const state: GlobFilesState = { message, result };
+
+      return {
+        content: JSON.stringify(result),
+        state,
+        success: result.success,
+      };
+    } catch (error) {
+      return {
+        content: (error as Error).message,
+        error: { body: error, message: (error as Error).message, type: 'PluginServerError' },
+        success: false,
+      };
+    }
+  };
+}
+
+// Export the executor instance for registration
+export const localSystemExecutor = new LocalSystemExecutor();

package/packages/builtin-tool-web-browsing/src/client/Inspector/Search/index.tsx

@@ -1,7 +1,12 @@
 'use client';
 
-import { type BuiltinInspectorProps, type SearchQuery } from '@lobechat/types';
-import { createStaticStyles, cx } from 'antd-style';
+import {
+  type BuiltinInspectorProps,
+  type SearchQuery,
+  type UniformSearchResponse,
+} from '@lobechat/types';
+import { Text } from '@lobehub/ui';
+import { createStaticStyles, cssVar, cx } from 'antd-style';
 import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
@@ -18,11 +23,13 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
   `,
 }));
 
-export const SearchInspector = memo<BuiltinInspectorProps<SearchQuery>>(
-  ({ args, partialArgs, isArgumentsStreaming }) => {
+export const SearchInspector = memo<BuiltinInspectorProps<SearchQuery, UniformSearchResponse>>(
+  ({ args, partialArgs, isArgumentsStreaming, isLoading, pluginState }) => {
     const { t } = useTranslation('plugin');
 
     const query = args?.query || partialArgs?.query || '';
+    const resultCount = pluginState?.results?.length ?? 0;
+    const hasResults = resultCount > 0;
 
     if (isArgumentsStreaming && !query) {
       return (
@@ -33,9 +40,29 @@ export const SearchInspector = memo<BuiltinInspectorProps<SearchQuery>>(
     }
 
     return (
-      <div className={cx(styles.root, isArgumentsStreaming && shinyTextStyles.shinyText)}>
+      <div
+        className={cx(
+          styles.root,
+          (isArgumentsStreaming || isLoading) && shinyTextStyles.shinyText,
+        )}
+      >
         <span>{t('builtins.lobe-web-browsing.apiName.search')}: </span>
         {query && <span className={highlightTextStyles.gold}>{query}</span>}
+        {!isLoading &&
+          !isArgumentsStreaming &&
+          pluginState?.results &&
+          (hasResults ? (
+            <span style={{ marginInlineStart: 4 }}>({resultCount})</span>
+          ) : (
+            <Text
+              as={'span'}
+              color={cssVar.colorTextDescription}
+              fontSize={12}
+              style={{ marginInlineStart: 4 }}
+            >
+              ({t('builtins.lobe-web-browsing.inspector.noResults')})
+            </Text>
+          ))}
       </div>
     );
   },

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/src/app/[variants]/(main)/chat/_layout/Sidebar/Topic/List/Item/Actions.tsx

@@ -1,25 +1,16 @@
-import { ActionIcon, Dropdown, type MenuProps } from '@lobehub/ui';
+import { ActionIcon, type DropdownItem, DropdownMenu } from '@lobehub/ui';
 import { MoreHorizontalIcon } from 'lucide-react';
 import { memo } from 'react';
 
 interface ActionProps {
-  dropdownMenu: MenuProps['items'];
+  dropdownMenu: DropdownItem[] | (() => DropdownItem[]);
 }
 
 const Actions = memo<ActionProps>(({ dropdownMenu }) => {
   return (
-    <Dropdown
-      arrow={false}
-      menu={{
-        items: dropdownMenu,
-        onClick: ({ domEvent }) => {
-          domEvent.stopPropagation();
-        },
-      }}
-      trigger={['click']}
-    >
+    <DropdownMenu items={dropdownMenu}>
       <ActionIcon icon={MoreHorizontalIcon} size={'small'} />
-    </Dropdown>
+    </DropdownMenu>
   );
 });