@lobehub/chat 1.84.16 → 1.84.18

package/src/libs/agent-runtime/utils/openaiCompatibleFactory/index.ts

@@ -68,7 +68,7 @@ interface OpenAICompatibleFactoryOptions<T extends Record<string, any> = any> {
     ) => OpenAI.ChatCompletionCreateParamsStreaming;
     handleStream?: (
       stream: Stream<OpenAI.ChatCompletionChunk> | ReadableStream,
-      callbacks?: ChatStreamCallbacks,
+      { callbacks, inputStartAt }: { callbacks?: ChatStreamCallbacks; inputStartAt?: number },
     ) => ReadableStream;
     handleStreamBizErrorType?: (error: {
       message: string;
@@ -256,7 +256,10 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
 
           return StreamingResponse(
             chatCompletion?.handleStream
-              ? chatCompletion.handleStream(prod, streamOptions.callbacks)
+              ? chatCompletion.handleStream(prod, {
+                  callbacks: streamOptions.callbacks,
+                  inputStartAt,
+                })
               : OpenAIStream(prod, { ...streamOptions, inputStartAt }),
             {
               headers: options?.headers,
@@ -276,7 +279,10 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
 
         return StreamingResponse(
           chatCompletion?.handleStream
-            ? chatCompletion.handleStream(stream, streamOptions.callbacks)
+            ? chatCompletion.handleStream(stream, {
+                callbacks: streamOptions.callbacks,
+                inputStartAt,
+              })
             : OpenAIStream(stream, { ...streamOptions, inputStartAt }),
           {
             headers: options?.headers,

package/src/libs/agent-runtime/utils/streams/qwen.test.ts

@@ -46,9 +46,11 @@ describe('QwenAIStream', () => {
     const onCompletionMock = vi.fn();
 
     const protocolStream = QwenAIStream(mockOpenAIStream, {
-      onStart: onStartMock,
-      onText: onTextMock,
-      onCompletion: onCompletionMock,
+      callbacks: {
+        onStart: onStartMock,
+        onText: onTextMock,
+        onCompletion: onCompletionMock,
+      },
     });
 
     const decoder = new TextDecoder();
@@ -111,7 +113,9 @@ describe('QwenAIStream', () => {
     const onToolCallMock = vi.fn();
 
     const protocolStream = QwenAIStream(mockOpenAIStream, {
-      onToolsCalling: onToolCallMock,
+      callbacks: {
+        onToolsCalling: onToolCallMock,
+      },
     });
 
     const decoder = new TextDecoder();

package/src/libs/agent-runtime/utils/streams/qwen.ts

@@ -92,7 +92,9 @@ export const transformQwenStream = (chunk: OpenAI.ChatCompletionChunk): StreamPr
 
 export const QwenAIStream = (
   stream: Stream<OpenAI.ChatCompletionChunk> | ReadableStream,
-  callbacks?: ChatStreamCallbacks,
+  // TODO: preserve for RFC 097
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-vars
+  { callbacks, inputStartAt }: { callbacks?: ChatStreamCallbacks; inputStartAt?: number } = {},
 ) => {
   const readableStream =
     stream instanceof ReadableStream ? stream : convertIterableToStream(stream);

package/src/libs/agent-runtime/utils/streams/spark.test.ts

@@ -96,7 +96,9 @@ describe('SparkAIStream', () => {
     const onToolCallMock = vi.fn();
 
     const protocolStream = SparkAIStream(mockStream, {
-      onToolsCalling: onToolCallMock,
+      callbacks: {
+        onToolsCalling: onToolCallMock,
+      },
     });
 
     const decoder = new TextDecoder();
@@ -156,7 +158,9 @@ describe('SparkAIStream', () => {
     const onTextMock = vi.fn();
 
     const protocolStream = SparkAIStream(mockStream, {
-      onText: onTextMock,
+      callbacks: {
+        onText: onTextMock,
+      },
     });
 
     const decoder = new TextDecoder();

package/src/libs/agent-runtime/utils/streams/spark.ts

@@ -123,7 +123,9 @@ export const transformSparkStream = (chunk: OpenAI.ChatCompletionChunk): StreamP
 
 export const SparkAIStream = (
   stream: Stream<OpenAI.ChatCompletionChunk> | ReadableStream,
-  callbacks?: ChatStreamCallbacks,
+  // TODO: preserve for RFC 097
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-vars
+  { callbacks, inputStartAt }: { callbacks?: ChatStreamCallbacks; inputStartAt?: number } = {},
 ) => {
   const readableStream =
     stream instanceof ReadableStream ? stream : convertIterableToStream(stream);

package/src/services/electron/localFileService.ts

@@ -10,6 +10,7 @@ import {
   OpenLocalFileParams,
   OpenLocalFolderParams,
   RenameLocalFileParams,
+  WriteLocalFileParams,
   dispatch,
 } from '@lobechat/electron-client-ipc';
 
@@ -46,6 +47,10 @@ class LocalFileService {
     return dispatch('renameLocalFile', params);
   }
 
+  async writeFile(params: WriteLocalFileParams) {
+    return dispatch('writeLocalFile', params);
+  }
+
   async openLocalFileOrFolder(path: string, isDirectory: boolean) {
     if (isDirectory) {
       return this.openLocalFolder({ isDirectory, path });

package/src/store/chat/slices/builtinTool/actions/__tests__/localFile.test.ts

@@ -0,0 +1,211 @@
+import { LocalFileItem, LocalMoveFilesResultItem } from '@lobechat/electron-client-ipc';
+import { describe, expect, it, vi } from 'vitest';
+
+import { localFileService } from '@/services/electron/localFileService';
+import { ChatStore } from '@/store/chat/store';
+
+import { localFileSlice } from '../localFile';
+
+vi.mock('@/services/electron/localFileService', () => ({
+  localFileService: {
+    listLocalFiles: vi.fn(),
+    moveLocalFiles: vi.fn(),
+    readLocalFile: vi.fn(),
+    readLocalFiles: vi.fn(),
+    renameLocalFile: vi.fn(),
+    searchLocalFiles: vi.fn(),
+    writeFile: vi.fn(),
+  },
+}));
+
+const mockSet = vi.fn();
+
+const mockStore = {
+  internal_triggerLocalFileToolCalling: vi.fn(),
+  internal_updateMessageContent: vi.fn(),
+  internal_updateMessagePluginError: vi.fn(),
+  set: mockSet,
+  toggleLocalFileLoading: vi.fn(),
+  updatePluginArguments: vi.fn(),
+  updatePluginState: vi.fn(),
+} as unknown as ChatStore;
+
+const createStore = () => {
+  return localFileSlice(
+    (set) => ({
+      ...mockStore,
+      set,
+    }),
+    () => mockStore,
+    {} as any,
+  );
+};
+
+describe('localFileSlice', () => {
+  const store = createStore();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('internal_triggerLocalFileToolCalling', () => {
+    it('should handle successful calling', async () => {
+      const mockContent = { foo: 'bar' };
+      const mockState = { state: 'test' };
+      const mockService = vi.fn().mockResolvedValue({ content: mockContent, state: mockState });
+
+      await store.internal_triggerLocalFileToolCalling('test-id', mockService);
+
+      expect(mockStore.toggleLocalFileLoading).toBeCalledWith('test-id', true);
+      expect(mockStore.updatePluginState).toBeCalledWith('test-id', mockState);
+      expect(mockStore.internal_updateMessageContent).toBeCalledWith(
+        'test-id',
+        JSON.stringify(mockContent),
+      );
+      expect(mockStore.toggleLocalFileLoading).toBeCalledWith('test-id', false);
+    });
+
+    it('should handle error', async () => {
+      const mockError = new Error('test error');
+      const mockService = vi.fn().mockRejectedValue(mockError);
+
+      await store.internal_triggerLocalFileToolCalling('test-id', mockService);
+
+      expect(mockStore.internal_updateMessagePluginError).toBeCalledWith('test-id', {
+        body: mockError,
+        message: 'test error',
+        type: 'PluginServerError',
+      });
+    });
+  });
+
+  describe('listLocalFiles', () => {
+    it('should call listLocalFiles service and update state', async () => {
+      const mockResult: LocalFileItem[] = [
+        {
+          name: 'test.txt',
+          path: '/test.txt',
+          isDirectory: false,
+          createdTime: new Date(),
+          lastAccessTime: new Date(),
+          modifiedTime: new Date(),
+          size: 100,
+          type: 'file',
+        },
+      ];
+      vi.mocked(localFileService.listLocalFiles).mockResolvedValue(mockResult);
+
+      await store.listLocalFiles('test-id', { path: '/test' });
+
+      expect(mockStore.internal_triggerLocalFileToolCalling).toBeCalled();
+    });
+  });
+
+  describe('moveLocalFiles', () => {
+    it('should handle successful move', async () => {
+      const mockResults = [
+        {
+          sourcePath: '/test.txt',
+          destinationPath: '/target/test.txt',
+          success: true,
+        },
+      ] as unknown as LocalMoveFilesResultItem[];
+
+      vi.mocked(localFileService.moveLocalFiles).mockResolvedValue(mockResults);
+
+      await store.moveLocalFiles('test-id', {
+        sourcePaths: ['/test.txt'],
+        destinationDir: '/target',
+      } as any);
+
+      expect(mockStore.internal_triggerLocalFileToolCalling).toBeCalled();
+    });
+  });
+
+  describe('writeLocalFile', () => {
+    it('should handle successful write', async () => {
+      vi.mocked(localFileService.writeFile).mockResolvedValue({
+        success: true,
+        newPath: '/test.txt',
+      });
+
+      await store.writeLocalFile('test-id', { path: '/test.txt', content: 'test' });
+
+      expect(mockStore.internal_triggerLocalFileToolCalling).toBeCalled();
+    });
+
+    it('should handle write error', async () => {
+      vi.mocked(localFileService.writeFile).mockResolvedValue({
+        success: false,
+        error: 'Write failed',
+        newPath: '/test.txt',
+      });
+
+      await store.writeLocalFile('test-id', { path: '/test.txt', content: 'test' });
+
+      expect(mockStore.internal_triggerLocalFileToolCalling).toBeCalled();
+    });
+  });
+
+  describe('renameLocalFile', () => {
+    it('should handle successful rename', async () => {
+      vi.mocked(localFileService.renameLocalFile).mockResolvedValue({
+        success: true,
+        newPath: '/new.txt',
+      });
+
+      await store.renameLocalFile('test-id', { path: '/test.txt', newName: 'new.txt' });
+
+      expect(mockStore.internal_triggerLocalFileToolCalling).toBeCalled();
+    });
+
+    it('should handle rename error', async () => {
+      vi.mocked(localFileService.renameLocalFile).mockResolvedValue({
+        success: false,
+        error: 'Rename failed',
+        newPath: '/test.txt',
+      });
+
+      await store.renameLocalFile('test-id', { path: '/test.txt', newName: 'new.txt' });
+
+      expect(mockStore.internal_triggerLocalFileToolCalling).toBeCalled();
+    });
+
+    it('should validate new filename', async () => {
+      vi.mocked(localFileService.renameLocalFile).mockRejectedValue(
+        new Error('Invalid new name provided'),
+      );
+
+      await store.renameLocalFile('test-id', {
+        path: '/test.txt',
+        newName: '../invalid.txt',
+      });
+
+      expect(mockStore.internal_triggerLocalFileToolCalling).toBeCalledWith(
+        'test-id',
+        expect.any(Function),
+      );
+    });
+  });
+
+  describe('toggleLocalFileLoading', () => {
+    it('should toggle loading state', () => {
+      const mockSetFn = vi.fn();
+      const testStore = localFileSlice(mockSetFn, () => mockStore, {} as any);
+
+      testStore.toggleLocalFileLoading('test-id', true);
+      expect(mockSetFn).toHaveBeenCalledWith(
+        expect.any(Function),
+        false,
+        'toggleLocalFileLoading/start',
+      );
+
+      testStore.toggleLocalFileLoading('test-id', false);
+      expect(mockSetFn).toHaveBeenCalledWith(
+        expect.any(Function),
+        false,
+        'toggleLocalFileLoading/end',
+      );
+    });
+  });
+});

package/src/store/chat/slices/builtinTool/actions/localFile.ts

@@ -6,6 +6,7 @@ import {
   LocalSearchFilesParams,
   MoveLocalFilesParams,
   RenameLocalFileParams,
+  WriteLocalFileParams,
 } from '@lobechat/electron-client-ipc';
 import { StateCreator } from 'zustand/vanilla';
 
@@ -23,7 +24,7 @@ import {
 export interface LocalFileAction {
   internal_triggerLocalFileToolCalling: <T = any>(
     id: string,
-    callingService: () => Promise<{ content: any; state: T }>,
+    callingService: () => Promise<{ content: any; state?: T }>,
   ) => Promise<boolean>;
 
   listLocalFiles: (id: string, params: ListLocalFileParams) => Promise<boolean>;
@@ -34,8 +35,9 @@ export interface LocalFileAction {
   renameLocalFile: (id: string, params: RenameLocalFileParams) => Promise<boolean>;
   // Added rename action
   searchLocalFiles: (id: string, params: LocalSearchFilesParams) => Promise<boolean>;
-
   toggleLocalFileLoading: (id: string, loading: boolean) => void;
+
+  writeLocalFile: (id: string, params: WriteLocalFileParams) => Promise<boolean>;
 }
 
 export const localFileSlice: StateCreator<
@@ -48,7 +50,9 @@ export const localFileSlice: StateCreator<
     get().toggleLocalFileLoading(id, true);
     try {
       const { state, content } = await callingService();
-      await get().updatePluginState(id, state as any);
+      if (state) {
+        await get().updatePluginState(id, state as any);
+      }
       await get().internal_updateMessageContent(id, JSON.stringify(content));
     } catch (error) {
       await get().internal_updateMessagePluginError(id, {
@@ -183,4 +187,24 @@ export const localFileSlice: StateCreator<
       `toggleLocalFileLoading/${loading ? 'start' : 'end'}`,
     );
   },
+
+  writeLocalFile: async (id, params) => {
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      const result = await localFileService.writeFile(params);
+
+      let content: { message: string; success: boolean };
+
+      if (result.success) {
+        content = {
+          message: `成功写入文件 ${params.path}`,
+          success: true,
+        };
+      } else {
+        const errorMessage = result.error;
+
+        content = { message: errorMessage || '写入文件失败', success: false };
+      }
+      return { content };
+    });
+  },
 });

package/src/store/electron/selectors/desktopState.ts

@@ -0,0 +1,7 @@
+import { ElectronState } from '@/store/electron/initialState';
+
+const usePath = (s: ElectronState) => s.appState.userPath;
+
+export const desktopStateSelectors = {
+  usePath,
+};

package/src/store/electron/selectors/index.ts

@@ -1 +1,2 @@
+export * from './desktopState';
 export * from './sync';

package/src/tools/local-files/Render/ListFiles/index.tsx

@@ -1,42 +1,12 @@
 import { ListLocalFileParams } from '@lobechat/electron-client-ipc';
-import { Typography } from 'antd';
-import { createStyles } from 'antd-style';
 import React, { memo } from 'react';
-import { Flexbox } from 'react-layout-kit';
 
-import FileIcon from '@/components/FileIcon';
-import { localFileService } from '@/services/electron/localFileService';
+import { LocalFolder } from '@/features/LocalFile';
 import { LocalFileListState } from '@/tools/local-files/type';
 import { ChatMessagePluginError } from '@/types/message';
 
 import SearchResult from './Result';
 
-const useStyles = createStyles(({ css, token, cx }) => ({
-  actions: cx(css`
-    cursor: pointer;
-    color: ${token.colorTextTertiary};
-    opacity: 1;
-    transition: opacity 0.2s ${token.motionEaseInOut};
-  `),
-  container: css`
-    cursor: pointer;
-
-    padding-block: 2px;
-    padding-inline: 4px;
-    border-radius: 4px;
-
-    color: ${token.colorTextSecondary};
-
-    :hover {
-      color: ${token.colorText};
-      background: ${token.colorFillTertiary};
-    }
-  `,
-  path: css`
-    color: ${token.colorTextSecondary};
-  `,
-}));
-
 interface ListFilesProps {
   args: ListLocalFileParams;
   messageId: string;
@@ -45,22 +15,9 @@ interface ListFilesProps {
 }
 
 const ListFiles = memo<ListFilesProps>(({ messageId, pluginError, args, pluginState }) => {
-  const { styles } = useStyles();
   return (
     <>
-      <Flexbox
-        className={styles.container}
-        gap={8}
-        horizontal
-        onClick={() => {
-          localFileService.openLocalFolder({ isDirectory: true, path: args.path });
-        }}
-      >
-        <FileIcon fileName={args.path} isDirectory size={22} variant={'raw'} />
-        <Typography.Text className={styles.path} ellipsis>
-          {args.path}
-        </Typography.Text>
-      </Flexbox>
+      <LocalFolder path={args.path} />
       <SearchResult
         listResults={pluginState?.listResults}
         messageId={messageId}

package/src/tools/local-files/Render/RenameLocalFile/index.tsx

@@ -2,10 +2,11 @@ import { RenameLocalFileParams } from '@lobechat/electron-client-ipc';
 import { Icon } from '@lobehub/ui';
 import { createStyles } from 'antd-style';
 import { ArrowRightIcon } from 'lucide-react';
+import path from 'path-browserify-esm';
 import React, { memo } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
-import FileIcon from '@/components/FileIcon';
+import { LocalFile } from '@/features/LocalFile';
 import { LocalReadFileState } from '@/tools/local-files/type';
 import { ChatMessagePluginError } from '@/types/message';
 
@@ -28,17 +29,15 @@ interface RenameLocalFileProps {
 const RenameLocalFile = memo<RenameLocalFileProps>(({ args }) => {
   const { styles } = useStyles();
 
-  const oldFileName = args.path.split('/').at(-1);
+  const { base: oldFileName, dir } = path.parse(args.path);
+
   return (
     <Flexbox align={'center'} className={styles.container} gap={8} horizontal paddingInline={12}>
       <Flexbox>{oldFileName}</Flexbox>
       <Flexbox>
         <Icon icon={ArrowRightIcon} />
       </Flexbox>
-      <Flexbox className={styles.new} gap={4} horizontal>
-        <FileIcon fileName={args.newName} size={20} variant={'raw'} />
-        {args.newName}
-      </Flexbox>
+      <LocalFile name={args.newName} path={path.join(dir, args.newName)} />
     </Flexbox>
   );
 });

package/src/tools/local-files/Render/RunCommand/index.tsx

@@ -0,0 +1,35 @@
+import { RunCommandParams } from '@lobechat/electron-client-ipc';
+import { Terminal } from '@xterm/xterm';
+import '@xterm/xterm/css/xterm.css';
+import { memo, useEffect, useRef } from 'react';
+
+import { LocalReadFileState } from '@/tools/local-files/type';
+import { ChatMessagePluginError } from '@/types/message';
+
+interface RunCommandProps {
+  args: RunCommandParams;
+  messageId: string;
+  pluginError: ChatMessagePluginError;
+  pluginState: LocalReadFileState;
+}
+
+const RunCommand = memo<RunCommandProps>(({ args }) => {
+  const terminalRef = useRef(null);
+
+  useEffect(() => {
+    if (!terminalRef.current) return;
+
+    const term = new Terminal({ cols: 80, cursorBlink: true, rows: 30 });
+
+    term.open(terminalRef.current);
+    term.write(args.command);
+
+    return () => {
+      term.dispose();
+    };
+  }, []);
+
+  return <div ref={terminalRef} />;
+});
+
+export default RunCommand;

package/src/tools/local-files/Render/WriteFile/index.tsx

@@ -0,0 +1,32 @@
+import { WriteLocalFileParams } from '@lobechat/electron-client-ipc';
+import { Icon } from '@lobehub/ui';
+import { Skeleton } from 'antd';
+import { ChevronRight } from 'lucide-react';
+import path from 'path-browserify-esm';
+import { memo } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+import { LocalFile, LocalFolder } from '@/features/LocalFile';
+import { ChatMessagePluginError } from '@/types/message';
+
+interface WriteFileProps {
+  args: WriteLocalFileParams;
+  messageId: string;
+  pluginError: ChatMessagePluginError;
+}
+
+const WriteFile = memo<WriteFileProps>(({ args }) => {
+  if (!args) return <Skeleton active />;
+
+  const { base, dir } = path.parse(args.path);
+
+  return (
+    <Flexbox horizontal>
+      <LocalFolder path={dir} />
+      <Icon icon={ChevronRight} />
+      <LocalFile name={base} path={args.path} />
+    </Flexbox>
+  );
+});
+
+export default WriteFile;

package/src/tools/local-files/Render/index.tsx

@@ -8,12 +8,14 @@ import ListFiles from './ListFiles';
 import ReadLocalFile from './ReadLocalFile';
 import RenameLocalFile from './RenameLocalFile';
 import SearchFiles from './SearchFiles';
+import WriteFile from './WriteFile';
 
 const RenderMap = {
   [LocalFilesApiName.searchLocalFiles]: SearchFiles,
   [LocalFilesApiName.listLocalFiles]: ListFiles,
   [LocalFilesApiName.readLocalFile]: ReadLocalFile,
   [LocalFilesApiName.renameLocalFile]: RenameLocalFile,
+  [LocalFilesApiName.writeLocalFile]: WriteFile,
 };
 
 const LocalFilesRender = memo<BuiltinRenderProps<LocalFileItem[]>>(

package/src/tools/local-files/index.ts

@@ -8,7 +8,7 @@ export const LocalFilesApiName = {
   readLocalFile: 'readLocalFile',
   renameLocalFile: 'renameLocalFile',
   searchLocalFiles: 'searchLocalFiles',
-  writeFile: 'writeFile',
+  writeLocalFile: 'writeLocalFile',
 };
 
 export const LocalFilesManifest: BuiltinToolManifest = {
@@ -176,26 +176,25 @@ export const LocalFilesManifest: BuiltinToolManifest = {
         type: 'object',
       },
     },
-    // TODO: Add writeFile API definition later
-    // {
-    //   description:
-    //     'Write content to a specific file. Input should be the file path and content. Overwrites existing file or creates a new one.',
-    //   name: LocalFilesApiName.writeFile,
-    //   parameters: {
-    //     properties: {
-    //       path: {
-    //         description: 'The file path to write to',
-    //         type: 'string',
-    //       },
-    //       content: {
-    //         description: 'The content to write',
-    //         type: 'string',
-    //       },
-    //     },
-    //     required: ['path', 'content'],
-    //     type: 'object',
-    //   },
-    // },
+    {
+      description:
+        'Write content to a specific file. Input should be the file path and content. Overwrites existing file or creates a new one.',
+      name: LocalFilesApiName.writeLocalFile,
+      parameters: {
+        properties: {
+          content: {
+            description: 'The content to write',
+            type: 'string',
+          },
+          path: {
+            description: 'The file path to write to',
+            type: 'string',
+          },
+        },
+        required: ['path', 'content'],
+        type: 'object',
+      },
+    },
   ],
   identifier: 'lobe-local-files',
   meta: {