@lobehub/chat 1.81.5 → 1.81.6

package/src/features/ChatInput/ActionBar/Clear.tsx

@@ -7,19 +7,28 @@ import { useTranslation } from 'react-i18next';
 import { useIsMobile } from '@/hooks/useIsMobile';
 import { useChatStore } from '@/store/chat';
 import { useFileStore } from '@/store/file';
+import { useUserStore } from '@/store/user';
+import { settingsSelectors } from '@/store/user/selectors';
+import { HotkeyEnum } from '@/types/hotkey';
+
+export const useClearCurrentMessages = () => {
+  const clearMessage = useChatStore((s) => s.clearMessage);
+  const clearImageList = useFileStore((s) => s.clearChatUploadFileList);
+
+  return useCallback(async () => {
+    await clearMessage();
+    clearImageList();
+  }, [clearImageList, clearMessage]);
+};
 
 const Clear = memo(() => {
   const { t } = useTranslation('setting');
-  const [clearMessage] = useChatStore((s) => [s.clearMessage]);
-  const [clearImageList] = useFileStore((s) => [s.clearChatUploadFileList]);
+  const hotkey = useUserStore(settingsSelectors.getHotkeyById(HotkeyEnum.ClearCurrentMessages));
+
+  const clearCurrentMessages = useClearCurrentMessages();
   const [confirmOpened, updateConfirmOpened] = useState(false);
   const mobile = useIsMobile();
 
-  const resetConversation = useCallback(async () => {
-    await clearMessage();
-    clearImageList();
-  }, []);
-
   const actionTitle: any = confirmOpened ? void 0 : t('clearCurrentMessages', { ns: 'chat' });
 
   const popconfirmPlacement = mobile ? 'top' : 'topRight';
@@ -28,7 +37,7 @@ const Clear = memo(() => {
     <Popconfirm
       arrow={false}
       okButtonProps={{ danger: true, type: 'primary' }}
-      onConfirm={resetConversation}
+      onConfirm={clearCurrentMessages}
       onOpenChange={updateConfirmOpened}
       open={confirmOpened}
       placement={popconfirmPlacement}
@@ -45,6 +54,7 @@ const Clear = memo(() => {
           root: { maxWidth: 'none' },
         }}
         title={actionTitle}
+        tooltipHotkey={hotkey}
       />
     </Popconfirm>
   );

package/src/hooks/useHotkeys/chatScope.ts

@@ -3,6 +3,7 @@ import { parseAsBoolean, useQueryState } from 'nuqs';
 import { useEffect } from 'react';
 import { useHotkeysContext } from 'react-hotkeys-hook';
 
+import { useClearCurrentMessages } from '@/features/ChatInput/ActionBar/Clear';
 import { useSendMessage } from '@/features/ChatInput/useSend';
 import { useOpenChatSettings } from '@/hooks/useInterceptingRoutes';
 import { useActionSWR } from '@/libs/swr';
@@ -78,6 +79,11 @@ export const useAddUserMessageHotkey = () => {
   return useHotkeyById(HotkeyEnum.AddUserMessage, () => send({ onlyAddUserMessage: true }));
 };
 
+export const useClearCurrentMessagesHotkey = () => {
+  const clearCurrentMessages = useClearCurrentMessages();
+  return useHotkeyById(HotkeyEnum.ClearCurrentMessages, () => clearCurrentMessages());
+};
+
 // 注册聚合
 
 export const useRegisterChatHotkeys = () => {
@@ -95,6 +101,7 @@ export const useRegisterChatHotkeys = () => {
   useRegenerateMessageHotkey();
   useSaveTopicHotkey();
   useAddUserMessageHotkey();
+  useClearCurrentMessagesHotkey();
 
   useEffect(() => {
     enableScope(HotkeyScopeEnum.Chat);

package/src/libs/agent-runtime/google/index.ts

@@ -368,7 +368,7 @@ export class LobeGoogleAI implements LobeRuntimeAI {
     payload?: ChatStreamPayload,
   ): GoogleFunctionCallTool[] | undefined {
     // 目前 Tools (例如 googleSearch) 无法与其他 FunctionCall 同时使用
-    if (payload?.messages?.some(m => m.tool_calls?.length)) {
+    if (payload?.messages?.some((m) => m.tool_calls?.length)) {
       return; // 若历史消息中已有 function calling，则不再注入任何 Tools
     }
     if (payload?.enabledSearch) {

package/src/libs/agent-runtime/sensenova/index.ts

@@ -1,10 +1,9 @@
+import type { ChatModelCard } from '@/types/llm';
+
 import { ModelProvider } from '../types';
 import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
-
 import { convertSenseNovaMessage } from '../utils/sensenovaHelpers';
 
-import type { ChatModelCard } from '@/types/llm';
-
 export interface SenseNovaModelCard {
   id: string;
 }
@@ -21,10 +20,10 @@ export const LobeSenseNovaAI = LobeOpenAICompatibleFactory({
           frequency_penalty !== undefined && frequency_penalty > 0 && frequency_penalty <= 2
             ? frequency_penalty
             : undefined,
-        messages: messages.map((message) => 
+        messages: messages.map((message) =>
           message.role !== 'user' || !/^Sense(Nova-V6|Chat-Vision)/.test(model)
             ? message
-            : { ...message, content: convertSenseNovaMessage(message.content) }
+            : { ...message, content: convertSenseNovaMessage(message.content) },
         ) as any[],
         model,
         stream: true,
@@ -42,46 +41,40 @@ export const LobeSenseNovaAI = LobeOpenAICompatibleFactory({
   models: async ({ client }) => {
     const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
 
-    const functionCallKeywords = [
-      'sensechat-5',
-    ];
+    const functionCallKeywords = ['sensechat-5'];
 
-    const visionKeywords = [
-      'vision',
-      'sensenova-v6',
-    ];
+    const visionKeywords = ['vision', 'sensenova-v6'];
 
-    const reasoningKeywords = [
-      'deepseek-r1',
-      'sensenova-v6',
-    ];
+    const reasoningKeywords = ['deepseek-r1', 'sensenova-v6'];
 
     client.baseURL = 'https://api.sensenova.cn/v1/llm';
 
-    const modelsPage = await client.models.list() as any;
+    const modelsPage = (await client.models.list()) as any;
     const modelList: SenseNovaModelCard[] = modelsPage.data;
 
     return modelList
       .map((model) => {
-        const knownModel = LOBE_DEFAULT_MODEL_LIST.find((m) => model.id.toLowerCase() === m.id.toLowerCase());
+        const knownModel = LOBE_DEFAULT_MODEL_LIST.find(
+          (m) => model.id.toLowerCase() === m.id.toLowerCase(),
+        );
 
         return {
           contextWindowTokens: knownModel?.contextWindowTokens ?? undefined,
           displayName: knownModel?.displayName ?? undefined,
           enabled: knownModel?.enabled || false,
           functionCall:
-            functionCallKeywords.some(keyword => model.id.toLowerCase().includes(keyword))
-            || knownModel?.abilities?.functionCall
-            || false,
+            functionCallKeywords.some((keyword) => model.id.toLowerCase().includes(keyword)) ||
+            knownModel?.abilities?.functionCall ||
+            false,
           id: model.id,
           reasoning:
-            reasoningKeywords.some(keyword => model.id.toLowerCase().includes(keyword))
-            || knownModel?.abilities?.reasoning
-            || false,
+            reasoningKeywords.some((keyword) => model.id.toLowerCase().includes(keyword)) ||
+            knownModel?.abilities?.reasoning ||
+            false,
           vision:
-            visionKeywords.some(keyword => model.id.toLowerCase().includes(keyword))
-            || knownModel?.abilities?.vision
-            || false,
+            visionKeywords.some((keyword) => model.id.toLowerCase().includes(keyword)) ||
+            knownModel?.abilities?.vision ||
+            false,
         };
       })
       .filter(Boolean) as ChatModelCard[];

package/src/libs/agent-runtime/utils/sensenovaHelpers.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+
 import { convertSenseNovaMessage } from './sensenovaHelpers';
 
 describe('convertSenseNovaMessage', () => {
@@ -10,9 +11,7 @@ describe('convertSenseNovaMessage', () => {
   });
 
   it('should handle array content with text type', () => {
-    const content = [
-      { type: 'text', text: 'Hello world' }
-    ];
+    const content = [{ type: 'text', text: 'Hello world' }];
     const result = convertSenseNovaMessage(content);
 
     expect(result).toEqual([{ type: 'text', text: 'Hello world' }]);
@@ -20,38 +19,32 @@ describe('convertSenseNovaMessage', () => {
 
   it('should convert image_url with base64 format to image_base64', () => {
     const content = [
-      { type: 'image_url', image_url: { url: 'data:image/jpeg;base64,ABCDEF123456' } }
+      { type: 'image_url', image_url: { url: 'data:image/jpeg;base64,ABCDEF123456' } },
     ];
     const result = convertSenseNovaMessage(content);
 
-    expect(result).toEqual([
-      { type: 'image_base64', image_base64: 'ABCDEF123456' }
-    ]);
+    expect(result).toEqual([{ type: 'image_base64', image_base64: 'ABCDEF123456' }]);
   });
 
   it('should keep image_url format for non-base64 urls', () => {
-    const content = [
-      { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } }
-    ];
+    const content = [{ type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } }];
     const result = convertSenseNovaMessage(content);
 
-    expect(result).toEqual([
-      { type: 'image_url', image_url: 'https://example.com/image.jpg' }
-    ]);
+    expect(result).toEqual([{ type: 'image_url', image_url: 'https://example.com/image.jpg' }]);
   });
 
   it('should handle mixed content types', () => {
     const content = [
       { type: 'text', text: 'Hello world' },
       { type: 'image_url', image_url: { url: 'data:image/jpeg;base64,ABCDEF123456' } },
-      { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } }
+      { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } },
     ];
     const result = convertSenseNovaMessage(content);
 
     expect(result).toEqual([
       { type: 'text', text: 'Hello world' },
       { type: 'image_base64', image_base64: 'ABCDEF123456' },
-      { type: 'image_url', image_url: 'https://example.com/image.jpg' }
+      { type: 'image_url', image_url: 'https://example.com/image.jpg' },
     ]);
   });
 
@@ -59,13 +52,11 @@ describe('convertSenseNovaMessage', () => {
     const content = [
       { type: 'text', text: 'Hello world' },
       { type: 'unknown', value: 'should be filtered' },
-      { type: 'image_url', image_url: { notUrl: 'missing url field' } }
+      { type: 'image_url', image_url: { notUrl: 'missing url field' } },
     ];
     const result = convertSenseNovaMessage(content);
 
-    expect(result).toEqual([
-      { type: 'text', text: 'Hello world' }
-    ]);
+    expect(result).toEqual([{ type: 'text', text: 'Hello world' }]);
   });
 
   it('should handle the example input format correctly', () => {
@@ -73,36 +64,36 @@ describe('convertSenseNovaMessage', () => {
       {
         content: [
           {
-            content: "Hi",
-            role: "user"
+            content: 'Hi',
+            role: 'user',
           },
           {
             image_url: {
-              detail: "auto",
-              url: "data:image/jpeg;base64,ABCDEF123456"
+              detail: 'auto',
+              url: 'data:image/jpeg;base64,ABCDEF123456',
             },
-            type: "image_url"
-          }
+            type: 'image_url',
+          },
         ],
-        role: "user"
-      }
+        role: 'user',
+      },
     ];
 
     // This is simulating how you might use convertSenseNovaMessage with the example input
     // Note: The actual function only converts the content part, not the entire messages array
     const content = messages[0].content;
-    
+
     // This is how the function would be expected to handle a mixed array like this
-    // However, the actual test would need to be adjusted based on how your function 
+    // However, the actual test would need to be adjusted based on how your function
     // is intended to handle this specific format with nested content objects
     const result = convertSenseNovaMessage([
-      { type: 'text', text: "Hi" },
-      { type: 'image_url', image_url: { url: "data:image/jpeg;base64,ABCDEF123456" } }
+      { type: 'text', text: 'Hi' },
+      { type: 'image_url', image_url: { url: 'data:image/jpeg;base64,ABCDEF123456' } },
     ]);
 
     expect(result).toEqual([
-      { type: 'text', text: "Hi" },
-      { type: 'image_base64', image_base64: "ABCDEF123456" }
+      { type: 'text', text: 'Hi' },
+      { type: 'image_base64', image_base64: 'ABCDEF123456' },
     ]);
   });
 });

package/src/libs/agent-runtime/utils/sensenovaHelpers.ts

@@ -1,5 +1,4 @@
 export const convertSenseNovaMessage = (content: any) => {
-
   // 如果为单条 string 类 content，则格式转换为 text 类
   if (typeof content === 'string') {
     return [{ text: content, type: 'text' }];
@@ -16,8 +15,8 @@ export const convertSenseNovaMessage = (content: any) => {
         const url = item.image_url.url;
 
         // 如果 image_url 为 base64 格式，则返回 image_base64 类，否则返回 image_url 类
-        return url.startsWith('data:image/jpeg;base64') 
-          ? { 
+        return url.startsWith('data:image/jpeg;base64')
+          ? {
               image_base64: url.split(',')[1],
               type: 'image_base64',
             }

package/src/locales/default/hotkey.ts

@@ -5,6 +5,10 @@ const hotkey: HotkeyI18nTranslations = {
     desc: '将当前输入内容添加为用户消息，但不触发生成',
     title: '添加一条用户消息',
   },
+  clearCurrentMessages: {
+    desc: '清空当前会话的消息和上传的文件',
+    title: '清空会话消息',
+  },
   editMessage: {
     desc: '通过按住 Alt 并双击消息进入编辑模式',
     title: '编辑消息',

package/src/server/modules/MCPClient/__tests__/__snapshots__/index.test.ts.snap

@@ -0,0 +1,113 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`MCPClient > Stdio Transport (using SDK Mock Server) > should list tools via stdio 1`] = `
+[
+  {
+    "description": "Echoes back a message with 'Hello' prefix",
+    "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
+      "properties": {
+        "message": {
+          "description": "The message to echo",
+          "type": "string",
+        },
+      },
+      "required": [
+        "message",
+      ],
+      "type": "object",
+    },
+    "name": "echo",
+  },
+  {
+    "description": "Lists all available tools and methods",
+    "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
+      "properties": {},
+      "type": "object",
+    },
+    "name": "debug",
+  },
+  {
+    "description": "Adds two numbers",
+    "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
+      "properties": {
+        "a": {
+          "description": "The first number",
+          "type": "number",
+        },
+        "b": {
+          "description": "The second number",
+          "type": "number",
+        },
+      },
+      "required": [
+        "a",
+        "b",
+      ],
+      "type": "object",
+    },
+    "name": "add",
+  },
+]
+`;
+
+exports[`MCPClient > Stdio Transport > should list tools via stdio 1`] = `
+[
+  {
+    "description": "Echoes back a message with 'Hello' prefix",
+    "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
+      "properties": {
+        "message": {
+          "description": "The message to echo",
+          "type": "string",
+        },
+      },
+      "required": [
+        "message",
+      ],
+      "type": "object",
+    },
+    "name": "echo",
+  },
+  {
+    "description": "Lists all available tools and methods",
+    "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
+      "properties": {},
+      "type": "object",
+    },
+    "name": "debug",
+  },
+  {
+    "description": "Adds two numbers",
+    "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
+      "properties": {
+        "a": {
+          "description": "The first number",
+          "type": "number",
+        },
+        "b": {
+          "description": "The second number",
+          "type": "number",
+        },
+      },
+      "required": [
+        "a",
+        "b",
+      ],
+      "type": "object",
+    },
+    "name": "add",
+  },
+]
+`;

package/src/server/modules/MCPClient/__tests__/index.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { MCPClient } from '../index';
+
+describe('MCPClient', () => {
+  // --- Updated Stdio Transport tests ---
+  describe('Stdio Transport', () => {
+    let mcpClient: MCPClient;
+    const stdioConnection = {
+      id: 'mcp-hello-world',
+      name: 'Stdio SDK Test Connection',
+      type: 'stdio' as const,
+      command: 'npx', // Use node to run the compiled mock server
+      args: ['mcp-hello-world@1.1.2'], // Use the path to the compiled JS file
+    };
+
+    beforeEach(async () => {
+      // args are now set directly in the connection object
+      mcpClient = new MCPClient(stdioConnection);
+      // Initialize the client - this starts the stdio process
+      await mcpClient.initialize();
+      // Add a small delay to allow the server process to fully start (optional, but can help)
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    });
+
+    afterEach(async () => {
+      // Assume SDK client/transport handles process termination gracefully
+      // If processes leak, more explicit cleanup might be needed here
+    });
+
+    it('should create and initialize an instance with stdio transport', () => {
+      expect(mcpClient).toBeInstanceOf(MCPClient);
+    });
+
+    it('should list tools via stdio', async () => {
+      const result = await mcpClient.listTools();
+
+      // Check exact length if no other tools are expected
+      expect(result.tools).toHaveLength(3);
+
+      // Expect the tools defined in mock-sdk-server.ts
+      expect(result.tools).toMatchSnapshot();
+    });
+
+    it('should call the "echo" tool via stdio', async () => {
+      const toolName = 'echo';
+      const toolArgs = { message: 'hello stdio' };
+      // Expect the result format defined in mock-sdk-server.ts
+      const expectedResult = {
+        content: [{ type: 'text', text: 'You said: hello stdio' }],
+      };
+
+      const result = await mcpClient.callTool(toolName, toolArgs);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should call the "add" tool via stdio', async () => {
+      const toolName = 'add';
+      const toolArgs = { a: 5, b: 7 };
+
+      const result = await mcpClient.callTool(toolName, toolArgs);
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'The sum is: 12' }],
+      });
+    });
+  });
+
+  // Error Handling tests remain the same...
+  describe('Error Handling', () => {
+    it('should throw error for unsupported connection type', () => {
+      const connection = {
+        id: 'invalid-test',
+        name: 'Invalid Test Connection',
+        type: 'invalid' as any,
+      };
+      expect(() => new MCPClient(connection as any)).toThrow(
+        'Unsupported MCP connection type: invalid',
+      );
+    });
+  });
+});

package/src/server/modules/MCPClient/index.ts

@@ -0,0 +1,80 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.d.ts';
+import debug from 'debug';
+
+const log = debug('lobe-mcp:client');
+
+interface MCPConnectionBase {
+  id: string;
+  name: string;
+  type: 'http' | 'stdio';
+}
+
+interface HttpMCPConnection extends MCPConnectionBase {
+  type: 'http';
+  url: string;
+}
+
+interface StdioMCPConnection extends MCPConnectionBase {
+  args: string[];
+  command: string;
+  type: 'stdio';
+}
+type MCPConnection = HttpMCPConnection | StdioMCPConnection;
+
+export class MCPClient {
+  private mcp: Client;
+  private transport: Transport;
+
+  constructor(connection: MCPConnection) {
+    log('Creating MCPClient with connection: %O', connection);
+    this.mcp = new Client({ name: 'lobehub-mcp-client', version: '1.0.0' });
+
+    switch (connection.type) {
+      case 'http': {
+        log('Using HTTP transport with url: %s', connection.url);
+        this.transport = new StreamableHTTPClientTransport(new URL(connection.url));
+        break;
+      }
+      case 'stdio': {
+        log(
+          'Using Stdio transport with command: %s and args: %O',
+          connection.command,
+          connection.args,
+        );
+        this.transport = new StdioClientTransport({
+          args: connection.args,
+          command: connection.command,
+        });
+        break;
+      }
+      default: {
+        const err = new Error(`Unsupported MCP connection type: ${(connection as any).type}`);
+        log('Error creating client: %O', err);
+        throw err;
+      }
+    }
+  }
+
+  async initialize() {
+    log('Initializing MCP connection...');
+    await this.mcp.connect(this.transport);
+    log('MCP connection initialized.');
+  }
+
+  async listTools() {
+    log('Listing tools...');
+    const tools = await this.mcp.listTools();
+    log('Listed tools: %O', tools);
+    return tools;
+  }
+
+  async callTool(toolName: string, args: any) {
+    log('Calling tool: %s with args: %O', toolName, args);
+    const result = await this.mcp.callTool({ arguments: args, name: toolName });
+    log('Tool call result: %O', result);
+    return result;
+  }
+}

package/src/types/hotkey.ts

@@ -58,6 +58,7 @@ export const KeyEnum = {
 
 export const HotkeyEnum = {
   AddUserMessage: 'addUserMessage',
+  ClearCurrentMessages: 'clearCurrentMessages',
   EditMessage: 'editMessage',
   OpenChatSettings: 'openChatSettings',
   OpenHotkeyHelper: 'openHotkeyHelper',