@lobehub/chat 1.106.2 → 1.106.4

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

@@ -7,7 +7,7 @@ export interface ModelProcessorConfig {
   visionKeywords?: readonly string[];
 }
 
-// 模型标签关键词配置
+// 模型能力标签关键词配置
 export const MODEL_LIST_CONFIGS = {
   anthropic: {
     functionCallKeywords: ['claude'],
@@ -64,7 +64,7 @@ export const MODEL_LIST_CONFIGS = {
   },
   zhipu: {
     functionCallKeywords: ['glm-4', 'glm-z1'],
-    reasoningKeywords: ['glm-zero', 'glm-z1'],
+    reasoningKeywords: ['glm-zero', 'glm-z1', 'glm-4.5'],
     visionKeywords: ['glm-4v'],
   },
 } as const;

package/src/libs/model-runtime/zhipu/index.ts

@@ -1,6 +1,8 @@
 import { ModelProvider } from '../types';
 import { MODEL_LIST_CONFIGS, processModelList } from '../utils/modelParse';
 import { createOpenAICompatibleRuntime } from '../utils/openaiCompatibleFactory';
+import { OpenAIStream } from '../utils/streams/openai';
+import { convertIterableToStream } from '../utils/streams/protocol';
 
 export interface ZhipuModelCard {
   description: string;
@@ -12,7 +14,8 @@ export const LobeZhipuAI = createOpenAICompatibleRuntime({
   baseURL: 'https://open.bigmodel.cn/api/paas/v4',
   chatCompletion: {
     handlePayload: (payload) => {
-      const { enabledSearch, max_tokens, model, temperature, tools, top_p, ...rest } = payload;
+      const { enabledSearch, max_tokens, model, temperature, thinking, tools, top_p, ...rest } =
+        payload;
 
       const zhipuTools = enabledSearch
         ? [
@@ -39,6 +42,7 @@ export const LobeZhipuAI = createOpenAICompatibleRuntime({
               max_tokens,
         model,
         stream: true,
+        thinking: model.includes('-4.5') ? { type: thinking?.type } : undefined,
         tools: zhipuTools,
         ...(model === 'glm-4-alltools'
           ? {
@@ -54,6 +58,58 @@ export const LobeZhipuAI = createOpenAICompatibleRuntime({
             }),
       } as any;
     },
+    handleStream: (stream, { callbacks, inputStartAt }) => {
+      const readableStream =
+        stream instanceof ReadableStream ? stream : convertIterableToStream(stream);
+
+      // GLM-4.5 系列模型在 tool_calls 中返回的 index 为 -1，需要在进入 OpenAIStream 之前修正
+      // 因为 OpenAIStream 内部会过滤掉 index < 0 的 tool_calls (openai.ts:58-60)
+      const preprocessedStream = readableStream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            // 处理原始的 OpenAI ChatCompletionChunk 格式
+            if (chunk.choices && chunk.choices[0]) {
+              const choice = chunk.choices[0];
+              if (choice.delta?.tool_calls && Array.isArray(choice.delta.tool_calls)) {
+                // 修正负数 index，将 -1 转换为基于数组位置的正数 index
+                const fixedToolCalls = choice.delta.tool_calls.map(
+                  (toolCall: any, globalIndex: number) => ({
+                    ...toolCall,
+                    index: toolCall.index < 0 ? globalIndex : toolCall.index,
+                  }),
+                );
+
+                // 创建修正后的 chunk
+                const fixedChunk = {
+                  ...chunk,
+                  choices: [
+                    {
+                      ...choice,
+                      delta: {
+                        ...choice.delta,
+                        tool_calls: fixedToolCalls,
+                      },
+                    },
+                  ],
+                };
+
+                controller.enqueue(fixedChunk);
+              } else {
+                controller.enqueue(chunk);
+              }
+            } else {
+              controller.enqueue(chunk);
+            }
+          },
+        }),
+      );
+
+      return OpenAIStream(preprocessedStream, {
+        callbacks,
+        inputStartAt,
+        provider: 'zhipu',
+      });
+    },
   },
   debug: {
     chatCompletion: () => process.env.DEBUG_ZHIPU_CHAT_COMPLETION === '1',

package/src/server/services/mcp/index.test.ts

@@ -0,0 +1,161 @@
+import { TRPCError } from '@trpc/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Mock 依赖
+vi.mock('@/libs/mcp');
+
+describe('MCPService', () => {
+  let mcpService: any;
+  let mockClient: any;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+
+    // 动态导入服务实例
+    const { mcpService: importedService } = await import('./index');
+    mcpService = importedService;
+
+    // 创建 mock 客户端
+    mockClient = {
+      callTool: vi.fn(),
+    };
+
+    // Mock getClient 方法返回 mock 客户端
+    vi.spyOn(mcpService as any, 'getClient').mockResolvedValue(mockClient);
+  });
+
+  describe('callTool', () => {
+    const mockParams = {
+      name: 'test-mcp',
+      type: 'stdio' as const,
+      command: 'test-command',
+      args: ['--test'],
+    };
+
+    it('should return original data when content array is empty', async () => {
+      mockClient.callTool.mockResolvedValue({
+        content: [],
+        isError: false,
+      });
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return original data when content is null or undefined', async () => {
+      mockClient.callTool.mockResolvedValue({
+        content: null,
+        isError: false,
+      });
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return parsed JSON when single element contains valid JSON', async () => {
+      const jsonData = { message: 'Hello World', status: 'success' };
+      mockClient.callTool.mockResolvedValue({
+        content: [{ type: 'text', text: JSON.stringify(jsonData) }],
+        isError: false,
+      });
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      expect(result).toEqual(jsonData);
+    });
+
+    it('should return plain text when single element contains non-JSON text', async () => {
+      const textData = 'Hello World';
+      mockClient.callTool.mockResolvedValue({
+        content: [{ type: 'text', text: textData }],
+        isError: false,
+      });
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      expect(result).toBe(textData);
+    });
+
+    it('should return original data when single element has no text', async () => {
+      const contentData = [{ type: 'text', text: '' }];
+      mockClient.callTool.mockResolvedValue({
+        content: contentData,
+        isError: false,
+      });
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      expect(result).toEqual(contentData);
+    });
+
+    it('should return complete array when content has multiple elements', async () => {
+      const multipleContent = [
+        { type: 'text', text: 'First message' },
+        { type: 'text', text: 'Second message' },
+        { type: 'text', text: '{"json": "data"}' },
+      ];
+
+      mockClient.callTool.mockResolvedValue({
+        content: multipleContent,
+        isError: false,
+      });
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      // 应该直接返回完整的数组，不进行任何处理
+      expect(result).toEqual(multipleContent);
+    });
+
+    it('should return complete array when content has two elements', async () => {
+      const twoContent = [
+        { type: 'text', text: 'First message' },
+        { type: 'text', text: 'Second message' },
+      ];
+
+      mockClient.callTool.mockResolvedValue({
+        content: twoContent,
+        isError: false,
+      });
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      expect(result).toEqual(twoContent);
+    });
+
+    it('should return error result when isError is true', async () => {
+      const errorResult = {
+        content: [{ type: 'text', text: 'Error occurred' }],
+        isError: true,
+      };
+
+      mockClient.callTool.mockResolvedValue(errorResult);
+
+      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+
+      expect(result).toEqual(errorResult);
+    });
+
+    it('should throw TRPCError when client throws error', async () => {
+      const error = new Error('MCP client error');
+      mockClient.callTool.mockRejectedValue(error);
+
+      await expect(mcpService.callTool(mockParams, 'testTool', '{}')).rejects.toThrow(TRPCError);
+    });
+
+    it('should parse args string correctly', async () => {
+      const argsObject = { param1: 'value1', param2: 'value2' };
+      const argsString = JSON.stringify(argsObject);
+
+      mockClient.callTool.mockResolvedValue({
+        content: [{ type: 'text', text: 'result' }],
+        isError: false,
+      });
+
+      await mcpService.callTool(mockParams, 'testTool', argsString);
+
+      expect(mockClient.callTool).toHaveBeenCalledWith('testTool', argsObject);
+    });
+  });
+});

package/src/server/services/mcp/index.ts

@@ -166,8 +166,11 @@ class MCPService {
 
       const data = content as { text: string; type: 'text' }[];
 
-      const text = data?.[0]?.text;
+      if (!data || data.length === 0) return data;
 
+      if (data.length > 1) return data;
+
+      const text = data[0]?.text;
       if (!text) return data;
 
       // try to get json object, which will be stringify in the client