@lobehub/chat 1.136.13 → 1.137.1

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

@@ -1,313 +1,985 @@
 // @vitest-environment node
-import { ChatStreamCallbacks, LobeOpenAICompatibleRuntime } from '@lobechat/model-runtime';
-import { OpenAI } from 'openai';
-import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { LobeOpenAICompatibleRuntime } from '@lobechat/model-runtime';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { testProvider } from '../../providerTestUtils';
+import { LobeZhipuAI, params } from './index';
+
+testProvider({
+  provider: 'zhipu',
+  defaultBaseURL: 'https://open.bigmodel.cn/api/paas/v4',
+  chatModel: 'glm-4',
+  Runtime: LobeZhipuAI,
+  chatDebugEnv: 'DEBUG_ZHIPU_CHAT_COMPLETION',
+  test: {
+    skipAPICall: true, // Skip because Zhipu has custom handlePayload that normalizes temperature
+  },
+});
+
+// Mock the console.error to avoid polluting test output
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+let instance: LobeOpenAICompatibleRuntime;
+
+beforeEach(() => {
+  instance = new LobeZhipuAI({ apiKey: 'test' });
+
+  // Mock chat.completions.create
+  vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+    new ReadableStream() as any,
+  );
+});
 
-import * as debugStreamModule from '../../utils/debugStream';
-import { LobeZhipuAI } from './index';
+afterEach(() => {
+  vi.clearAllMocks();
+});
 
-const bizErrorType = 'ProviderBizError';
-const invalidErrorType = 'InvalidProviderAPIKey';
+describe('LobeZhipuAI - custom features', () => {
+  describe('Debug Configuration', () => {
+    it('should disable debug by default', () => {
+      delete process.env.DEBUG_ZHIPU_CHAT_COMPLETION;
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(false);
+    });
 
-describe('LobeZhipuAI', () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
+    it('should enable debug when env is set', () => {
+      process.env.DEBUG_ZHIPU_CHAT_COMPLETION = '1';
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(true);
+      delete process.env.DEBUG_ZHIPU_CHAT_COMPLETION;
+    });
   });
 
-  describe('chat', () => {
-    let instance: LobeOpenAICompatibleRuntime;
+  describe('handlePayload', () => {
+    describe('Web Search Feature', () => {
+      it('should add web_search tool when enabledSearch is true', async () => {
+        await instance.chat({
+          enabledSearch: true,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0,
+        });
 
-    beforeEach(async () => {
-      instance = new LobeZhipuAI({
-        apiKey: 'test_api_key',
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            tools: expect.arrayContaining([
+              expect.objectContaining({
+                type: 'web_search',
+                web_search: expect.objectContaining({
+                  enable: true,
+                  result_sequence: 'before',
+                  search_engine: 'search_std',
+                  search_result: true,
+                }),
+              }),
+            ]),
+          }),
+          expect.anything(),
+        );
       });
 
-      // Mock chat.completions.create
-      vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
-        new ReadableStream() as any,
-      );
-    });
+      it('should use custom search engine from env', async () => {
+        process.env.ZHIPU_SEARCH_ENGINE = 'search_pro';
 
-    it('should return a StreamingTextResponse on successful API call', async () => {
-      const result = await instance.chat({
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'glm-4',
-        temperature: 0,
+        const payload = params.chatCompletion.handlePayload({
+          enabledSearch: true,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+        });
+
+        expect(payload.tools).toContainEqual(
+          expect.objectContaining({
+            type: 'web_search',
+            web_search: expect.objectContaining({
+              search_engine: 'search_pro',
+            }),
+          }),
+        );
+
+        delete process.env.ZHIPU_SEARCH_ENGINE;
+      });
+
+      it('should merge web_search with existing tools', async () => {
+        const existingTool = {
+          type: 'function' as const,
+          function: { name: 'test_tool', parameters: {} },
+        };
+
+        await instance.chat({
+          enabledSearch: true,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0,
+          tools: [existingTool],
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            tools: expect.arrayContaining([
+              existingTool,
+              expect.objectContaining({ type: 'web_search' }),
+            ]),
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should not add web_search tool when enabledSearch is false', async () => {
+        await instance.chat({
+          enabledSearch: false,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0,
+        });
+
+        const callArgs = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+        expect(callArgs.tools).toBeUndefined();
+      });
+
+      it('should use existing tools without web_search when enabledSearch is not set', async () => {
+        const existingTool = {
+          type: 'function' as const,
+          function: { name: 'test_tool', parameters: {} },
+        };
+
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0,
+          tools: [existingTool],
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            tools: [existingTool],
+          }),
+          expect.anything(),
+        );
       });
-      expect(result).toBeInstanceOf(Response);
     });
 
-    it('should handle callback and headers correctly', async () => {
-      // 模拟 chat.completions.create 方法返回一个可读流
-      const mockCreateMethod = vi
-        .spyOn(instance['client'].chat.completions, 'create')
-        .mockResolvedValue(
-          new ReadableStream({
-            start(controller) {
-              controller.enqueue({
-                id: 'chatcmpl-8xDx5AETP8mESQN7UB30GxTN2H1SO',
-                object: 'chat.completion.chunk',
-                created: 1709125675,
-                model: 'gpt-3.5-turbo-0125',
-                system_fingerprint: 'fp_86156a94a0',
-                choices: [
-                  { index: 0, delta: { content: 'hello' }, logprobs: null, finish_reason: null },
-                ],
-              });
-              controller.close();
-            },
-          }) as any,
+    describe('Model-specific max_tokens constraints', () => {
+      it('should limit max_tokens to 1024 for glm-4v models', async () => {
+        await instance.chat({
+          max_tokens: 2000,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4v',
+          temperature: 0.5,
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            max_tokens: 1024,
+          }),
+          expect.anything(),
         );
+      });
 
-      // 准备 callback 和 headers
-      const mockCallback: ChatStreamCallbacks = {
-        onStart: vi.fn(),
-        onText: vi.fn(),
-      };
-      const mockHeaders = { 'Custom-Header': 'TestValue' };
+      it('should limit max_tokens to 15300 for glm-zero-preview model', async () => {
+        await instance.chat({
+          max_tokens: 20000,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-zero-preview',
+          temperature: 0.5,
+        });
 
-      // 执行测试
-      const result = await instance.chat(
-        {
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            max_tokens: 15_300,
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should allow max_tokens lower than constraint for glm-4v', async () => {
+        await instance.chat({
+          max_tokens: 512,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4v',
+          temperature: 0.5,
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            max_tokens: 512,
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should not limit max_tokens for other models', async () => {
+        await instance.chat({
+          max_tokens: 4000,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0.5,
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            max_tokens: 4000,
+          }),
+          expect.anything(),
+        );
+      });
+    });
+
+    describe('glm-4-alltools temperature and top_p constraints', () => {
+      it('should clamp temperature to [0.01, 0.99] for glm-4-alltools', async () => {
+        await instance.chat({
           messages: [{ content: 'Hello', role: 'user' }],
-          model: 'text-davinci-003',
+          model: 'glm-4-alltools',
           temperature: 0,
-        },
-        { callback: mockCallback, headers: mockHeaders },
-      );
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            temperature: 0.01,
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should clamp high temperature to 0.99 for glm-4-alltools', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4-alltools',
+          temperature: 2.0, // Will be normalized to 1.0, then clamped to 0.99
+        });
 
-      // 验证 callback 被调用
-      await result.text(); // 确保流被消费
-      expect(mockCallback.onStart).toHaveBeenCalled();
-      expect(mockCallback.onText).toHaveBeenCalledWith('hello');
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            temperature: 0.99,
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should clamp top_p to [0.01, 0.99] for glm-4-alltools', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4-alltools',
+          temperature: 0.5,
+          top_p: 0,
+        });
 
-      // 验证 headers 被正确传递
-      expect(result.headers.get('Custom-Header')).toEqual('TestValue');
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            top_p: 0.01,
+          }),
+          expect.anything(),
+        );
+      });
 
-      // 清理
-      mockCreateMethod.mockRestore();
+      it('should clamp high top_p to 0.99 for glm-4-alltools', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4-alltools',
+          temperature: 0.5,
+          top_p: 1,
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            top_p: 0.99,
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should normalize and preserve temperature in range for glm-4-alltools', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4-alltools',
+          temperature: 1.0, // Will be normalized to 0.5
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            temperature: 0.5,
+          }),
+          expect.anything(),
+        );
+      });
     });
 
-    it('should transform messages correctly', async () => {
-      const spyOn = vi.spyOn(instance['client'].chat.completions, 'create');
+    describe('Temperature normalization', () => {
+      it('should normalize temperature by dividing by 2', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 1.0,
+        });
 
-      await instance.chat({
-        messages: [
-          { content: 'Hello', role: 'user' },
-          { content: [{ type: 'text', text: 'Hello again' }], role: 'user' },
-        ],
-        model: 'glm-4',
-        temperature: 1.6,
-        top_p: 1,
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            temperature: 0.5,
+          }),
+          expect.anything(),
+        );
       });
 
-      const calledWithParams = spyOn.mock.calls[0][0];
+      it('should normalize high temperature', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 1.6,
+        });
 
-      expect(calledWithParams.messages[1].content).toEqual([{ type: 'text', text: 'Hello again' }]);
-      expect(calledWithParams.temperature).toBe(0.8); // temperature should be divided by two
-      expect(calledWithParams.top_p).toEqual(1);
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            temperature: 0.8,
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should handle temperature 0 correctly', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0,
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            temperature: 0,
+          }),
+          expect.anything(),
+        );
+      });
     });
 
-    it('should pass arameters correctly', async () => {
-      const spyOn = vi.spyOn(instance['client'].chat.completions, 'create');
+    describe('Thinking mode for GLM-4.5 models', () => {
+      it('should include thinking type for glm-4.5 models', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4.5',
+          temperature: 0.5,
+          thinking: { type: 'enabled', budget_tokens: 1000 },
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            thinking: { type: 'enabled' },
+          }),
+          expect.anything(),
+        );
+      });
+
+      it('should include thinking for glm-4.5-turbo', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4.5-turbo',
+          temperature: 0.5,
+          thinking: { type: 'disabled', budget_tokens: 0 },
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            thinking: { type: 'disabled' },
+          }),
+          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 },
+        });
 
-      await instance.chat({
-        messages: [
-          { content: 'Hello', role: 'user' },
-          { content: [{ type: 'text', text: 'Hello again' }], role: 'user' },
-        ],
-        model: 'glm-4-alltools',
-        temperature: 0,
-        top_p: 1,
+        const callArgs = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+        expect(callArgs.thinking).toBeUndefined();
       });
 
-      const calledWithParams = spyOn.mock.calls[0][0];
+      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(calledWithParams.messages[1].content).toEqual([{ type: 'text', text: 'Hello again' }]);
-      expect(calledWithParams.temperature).toBe(0.01);
-      expect(calledWithParams.top_p).toEqual(0.99);
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            thinking: { type: undefined },
+          }),
+          expect.anything(),
+        );
+      });
     });
 
-    describe('Error', () => {
-      it('should return ZhipuAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
-        // Arrange
-        const apiError = new OpenAI.APIError(
-          400,
-          {
-            status: 400,
-            error: {
-              message: 'Bad Request',
-            },
-          },
-          'Error message',
-          {},
+    describe('Stream parameter', () => {
+      it('should always set stream to true', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0.5,
+        });
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            stream: true,
+          }),
+          expect.anything(),
         );
+      });
+
+      it('should override stream parameter to true', async () => {
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          stream: false,
+          temperature: 0.5,
+        });
 
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            stream: true,
+          }),
+          expect.anything(),
+        );
+      });
+    });
+
+    describe('Preserve other payload properties', () => {
+      it('should preserve all other properties', async () => {
+        await instance.chat({
+          frequency_penalty: 0.5,
+          max_tokens: 100,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          presence_penalty: 0.3,
+          temperature: 0.5,
+          top_p: 0.9,
+        });
 
-        // Act
-        try {
-          await instance.chat({
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            frequency_penalty: 0.5,
+            max_tokens: 100,
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'text-davinci-003',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: 'https://open.bigmodel.cn/api/paas/v4',
-            error: {
-              error: { message: 'Bad Request' },
-              status: 400,
-            },
-            errorType: bizErrorType,
-            provider: 'zhipu',
-          });
-        }
+            model: 'glm-4',
+            presence_penalty: 0.3,
+            temperature: 0.25, // Normalized from 0.5
+            top_p: 0.9,
+          }),
+          expect.anything(),
+        );
       });
+    });
+  });
 
-      it('should throw AgentRuntimeError with NoOpenAIAPIKey if no apiKey is provided', async () => {
-        try {
-          new LobeZhipuAI({ apiKey: '' });
-        } catch (e) {
-          expect(e).toEqual({ errorType: invalidErrorType });
+  describe('handleStream', () => {
+    describe('Tool calls index fixing for GLM-4.5', () => {
+      it('should fix negative tool_calls index to positive', async () => {
+        const mockStream = new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              choices: [
+                {
+                  delta: {
+                    tool_calls: [
+                      { index: -1, id: 'call_1', function: { name: 'tool1', arguments: '{}' } },
+                      { index: -1, id: 'call_2', function: { name: 'tool2', arguments: '{}' } },
+                    ],
+                  },
+                  finish_reason: null,
+                  index: 0,
+                },
+              ],
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4.5',
+              object: 'chat.completion.chunk',
+            });
+            controller.close();
+          },
+        });
+
+        (instance['client'].chat.completions.create as any).mockResolvedValue(mockStream);
+
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4.5',
+          temperature: 0.5,
+        });
+
+        // Read the stream to trigger the transform
+        const reader = result.body?.getReader();
+        const chunks = [];
+        if (reader) {
+          let done = false;
+          while (!done) {
+            const { value, done: isDone } = await reader.read();
+            done = isDone;
+            if (value) {
+              chunks.push(new TextDecoder().decode(value));
+            }
+          }
         }
+
+        // The transform should have fixed the negative indices
+        expect(chunks).toBeDefined();
       });
 
-      it('should return OpenAIBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: {
-            message: 'api is undefined',
+      it('should preserve positive tool_calls index', async () => {
+        const mockStream = new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              choices: [
+                {
+                  delta: {
+                    tool_calls: [
+                      { index: 0, id: 'call_1', function: { name: 'tool1', arguments: '{}' } },
+                      { index: 1, id: 'call_2', function: { name: 'tool2', arguments: '{}' } },
+                    ],
+                  },
+                  finish_reason: null,
+                  index: 0,
+                },
+              ],
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4',
+              object: 'chat.completion.chunk',
+            });
+            controller.close();
           },
-        };
-        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+        });
 
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+        (instance['client'].chat.completions.create as any).mockResolvedValue(mockStream);
 
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'text-davinci-003',
-            temperature: 0.2,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: 'https://open.bigmodel.cn/api/paas/v4',
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider: 'zhipu',
-          });
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0.5,
+        });
+
+        // Read the stream
+        const reader = result.body?.getReader();
+        if (reader) {
+          let done = false;
+          while (!done) {
+            const { value, done: isDone } = await reader.read();
+            done = isDone;
+          }
         }
+
+        expect(result).toBeDefined();
       });
 
-      it('should return OpenAIBizError with an cause response with desensitize Url', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: { message: 'api is undefined' },
-        };
-        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+      it('should handle chunks without tool_calls', async () => {
+        const mockStream = new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              choices: [
+                {
+                  delta: {
+                    content: 'Hello',
+                  },
+                  finish_reason: null,
+                  index: 0,
+                },
+              ],
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4',
+              object: 'chat.completion.chunk',
+            });
+            controller.close();
+          },
+        });
 
-        instance = new LobeZhipuAI({
-          apiKey: 'test',
+        (instance['client'].chat.completions.create as any).mockResolvedValue(mockStream);
 
-          baseURL: 'https://abc.com/v2',
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0.5,
         });
 
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+        expect(result).toBeInstanceOf(Response);
+      });
 
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'gpt-3.5-turbo',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: 'https://***.com/v2',
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider: 'zhipu',
-          });
-        }
+      it('should handle chunks without choices', async () => {
+        const mockStream = new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4',
+              object: 'chat.completion.chunk',
+            });
+            controller.close();
+          },
+        });
+
+        (instance['client'].chat.completions.create as any).mockResolvedValue(mockStream);
+
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0.5,
+        });
+
+        expect(result).toBeInstanceOf(Response);
       });
 
-      it('should return AgentRuntimeError for non-OpenAI errors', async () => {
-        // Arrange
-        const genericError = new Error('Generic Error');
+      it('should handle empty tool_calls array', async () => {
+        const mockStream = new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              choices: [
+                {
+                  delta: {
+                    tool_calls: [],
+                  },
+                  finish_reason: null,
+                  index: 0,
+                },
+              ],
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4',
+              object: 'chat.completion.chunk',
+            });
+            controller.close();
+          },
+        });
 
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(genericError);
+        (instance['client'].chat.completions.create as any).mockResolvedValue(mockStream);
 
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'text-davinci-003',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: 'https://open.bigmodel.cn/api/paas/v4',
-            errorType: 'AgentRuntimeError',
-            provider: 'zhipu',
-            error: {
-              name: genericError.name,
-              cause: genericError.cause,
-              message: genericError.message,
-            },
-          });
-        }
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4',
+          temperature: 0.5,
+        });
+
+        expect(result).toBeInstanceOf(Response);
       });
-    });
 
-    describe('DEBUG', () => {
-      it('should call debugStream and return StreamingTextResponse when DEBUG_OPENAI_CHAT_COMPLETION is 1', async () => {
-        // Arrange
-        const mockProdStream = new ReadableStream() as any; // 模拟的 prod 流
-        const mockDebugStream = new ReadableStream({
+      it('should handle mixed tool_calls indices', async () => {
+        const mockStream = new ReadableStream({
           start(controller) {
-            controller.enqueue('Debug stream content');
+            controller.enqueue({
+              choices: [
+                {
+                  delta: {
+                    tool_calls: [
+                      { index: 0, id: 'call_1', function: { name: 'tool1', arguments: '{}' } },
+                      { index: -1, id: 'call_2', function: { name: 'tool2', arguments: '{}' } },
+                      { index: 2, id: 'call_3', function: { name: 'tool3', arguments: '{}' } },
+                    ],
+                  },
+                  finish_reason: null,
+                  index: 0,
+                },
+              ],
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4.5',
+              object: 'chat.completion.chunk',
+            });
             controller.close();
           },
-        }) as any;
-        mockDebugStream.toReadableStream = () => mockDebugStream; // 添加 toReadableStream 方法
+        });
 
-        // 模拟 chat.completions.create 返回值，包括模拟的 tee 方法
-        (instance['client'].chat.completions.create as Mock).mockResolvedValue({
-          tee: () => [mockProdStream, { toReadableStream: () => mockDebugStream }],
+        (instance['client'].chat.completions.create as any).mockResolvedValue(mockStream);
+
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'glm-4.5',
+          temperature: 0.5,
         });
 
-        // 保存原始环境变量值
-        const originalDebugValue = process.env.DEBUG_ZHIPU_CHAT_COMPLETION;
+        // Read the stream to trigger the transform
+        const reader = result.body?.getReader();
+        if (reader) {
+          let done = false;
+          while (!done) {
+            const { value, done: isDone } = await reader.read();
+            done = isDone;
+          }
+        }
 
-        // 模拟环境变量
-        process.env.DEBUG_ZHIPU_CHAT_COMPLETION = '1';
-        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
+        expect(result).toBeDefined();
+      });
 
-        // 执行测试
-        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
-        // 假设的测试函数调用，你可能需要根据实际情况调整
-        await instance.chat({
+      it('should handle multiple chunks with tool_calls', async () => {
+        const mockStream = new ReadableStream({
+          start(controller) {
+            // First chunk with tool_call
+            controller.enqueue({
+              choices: [
+                {
+                  delta: {
+                    tool_calls: [{ index: -1, id: 'call_1', function: { name: 'tool1' } }],
+                  },
+                  finish_reason: null,
+                  index: 0,
+                },
+              ],
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4.5',
+              object: 'chat.completion.chunk',
+            });
+            // Second chunk with arguments
+            controller.enqueue({
+              choices: [
+                {
+                  delta: {
+                    tool_calls: [{ index: -1, function: { arguments: '{"a":1}' } }],
+                  },
+                  finish_reason: null,
+                  index: 0,
+                },
+              ],
+              created: 1234567890,
+              id: 'chatcmpl-123',
+              model: 'glm-4.5',
+              object: 'chat.completion.chunk',
+            });
+            controller.close();
+          },
+        });
+
+        (instance['client'].chat.completions.create as any).mockResolvedValue(mockStream);
+
+        const result = await instance.chat({
           messages: [{ content: 'Hello', role: 'user' }],
-          model: 'text-davinci-003',
-          temperature: 0,
+          model: 'glm-4.5',
+          temperature: 0.5,
         });
 
-        // 验证 debugStream 被调用
-        expect(debugStreamModule.debugStream).toHaveBeenCalled();
+        // Read the stream
+        const reader = result.body?.getReader();
+        if (reader) {
+          let done = false;
+          while (!done) {
+            const { value, done: isDone } = await reader.read();
+            done = isDone;
+          }
+        }
+
+        expect(result).toBeDefined();
+      });
+    });
+  });
+
+  describe('exports', () => {
+    it('should export params object', () => {
+      expect(params).toBeDefined();
+      expect(params.provider).toBe('zhipu');
+      expect(params.baseURL).toBe('https://open.bigmodel.cn/api/paas/v4');
+      expect(params.chatCompletion).toBeDefined();
+      expect(params.debug).toBeDefined();
+      expect(params.models).toBeDefined();
+    });
+
+    it('should export chatCompletion configuration with handlePayload', () => {
+      expect(params.chatCompletion.handlePayload).toBeDefined();
+      expect(typeof params.chatCompletion.handlePayload).toBe('function');
+    });
+
+    it('should export chatCompletion configuration with handleStream', () => {
+      expect(params.chatCompletion.handleStream).toBeDefined();
+      expect(typeof params.chatCompletion.handleStream).toBe('function');
+    });
+
+    it('should export debug configuration', () => {
+      expect(params.debug.chatCompletion).toBeDefined();
+      expect(typeof params.debug.chatCompletion).toBe('function');
+    });
+
+    it('should export models function', () => {
+      expect(params.models).toBeDefined();
+      expect(typeof params.models).toBe('function');
+    });
+  });
+
+  describe('models', () => {
+    const mockFetch = vi.fn();
+    const originalFetch = global.fetch;
+
+    beforeEach(() => {
+      global.fetch = mockFetch;
+      vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+      global.fetch = originalFetch;
+    });
+
+    it('should fetch and process models with correct headers', async () => {
+      mockFetch.mockResolvedValue({
+        json: async () => ({
+          rows: [
+            {
+              description: 'GLM-4 model',
+              modelCode: 'glm-4',
+              modelName: 'GLM-4',
+            },
+            {
+              description: 'GLM-4V model',
+              modelCode: 'glm-4v',
+              modelName: 'GLM-4V',
+            },
+          ],
+        }),
+      });
+
+      const mockClient = { apiKey: 'test_api_key' };
+      await params.models({ client: mockClient as any });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://open.bigmodel.cn/api/fine-tuning/model_center/list?pageSize=100&pageNum=1',
+        {
+          headers: {
+            'Authorization': 'Bearer test_api_key',
+            'Bigmodel-Organization': 'lobehub',
+            'Bigmodel-Project': 'lobechat',
+          },
+          method: 'GET',
+        },
+      );
+    });
+
+    it('should process model list correctly', async () => {
+      mockFetch.mockResolvedValue({
+        json: async () => ({
+          rows: [
+            {
+              description: 'GLM-4 model',
+              modelCode: 'glm-4',
+              modelName: 'GLM-4',
+            },
+          ],
+        }),
+      });
+
+      const mockClient = { apiKey: 'test_api_key' };
+      const models = await params.models({ client: mockClient as any });
+
+      expect(models).toBeDefined();
+      expect(Array.isArray(models)).toBe(true);
+    });
+
+    it('should transform modelCode to id and modelName to displayName', async () => {
+      mockFetch.mockResolvedValue({
+        json: async () => ({
+          rows: [
+            {
+              description: 'Test model',
+              modelCode: 'test-model-code',
+              modelName: 'Test Model Name',
+            },
+          ],
+        }),
+      });
+
+      const mockClient = { apiKey: 'test_api_key' };
+      const models = await params.models({ client: mockClient as any });
+
+      // processModelList will merge with LOBE_DEFAULT_MODEL_LIST
+      // Check that fetch was called and data was processed
+      expect(mockFetch).toHaveBeenCalled();
+      expect(models).toBeDefined();
+    });
+
+    it('should handle empty model list', async () => {
+      mockFetch.mockResolvedValue({
+        json: async () => ({
+          rows: [],
+        }),
+      });
+
+      const mockClient = { apiKey: 'test_api_key' };
+      const models = await params.models({ client: mockClient as any });
+
+      expect(models).toEqual([]);
+    });
+
+    it('should handle multiple models', async () => {
+      mockFetch.mockResolvedValue({
+        json: async () => ({
+          rows: [
+            {
+              description: 'GLM-4 model',
+              modelCode: 'glm-4',
+              modelName: 'GLM-4',
+            },
+            {
+              description: 'GLM-4V model',
+              modelCode: 'glm-4v',
+              modelName: 'GLM-4V',
+            },
+            {
+              description: 'GLM-4-Air model',
+              modelCode: 'glm-4-air',
+              modelName: 'GLM-4-Air',
+            },
+          ],
+        }),
+      });
+
+      const mockClient = { apiKey: 'test_api_key' };
+      const models = await params.models({ client: mockClient as any });
+
+      expect(models).toBeDefined();
+      expect(Array.isArray(models)).toBe(true);
+    });
 
-        // 恢复原始环境变量值
-        process.env.DEBUG_ZHIPU_CHAT_COMPLETION = originalDebugValue;
+    it('should include description in model data', async () => {
+      mockFetch.mockResolvedValue({
+        json: async () => ({
+          rows: [
+            {
+              description: 'This is a test description',
+              modelCode: 'glm-4',
+              modelName: 'GLM-4',
+            },
+          ],
+        }),
       });
+
+      const mockClient = { apiKey: 'test_api_key' };
+      await params.models({ client: mockClient as any });
+
+      // Verify the API was called correctly
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test_api_key',
+          }),
+        }),
+      );
+    });
+
+    it('should handle API errors gracefully', async () => {
+      mockFetch.mockRejectedValue(new Error('API Error'));
+
+      const mockClient = { apiKey: 'test_api_key' };
+
+      await expect(params.models({ client: mockClient as any })).rejects.toThrow('API Error');
+    });
+
+    it('should use correct API endpoint', async () => {
+      mockFetch.mockResolvedValue({
+        json: async () => ({ rows: [] }),
+      });
+
+      const mockClient = { apiKey: 'test_api_key' };
+      await params.models({ client: mockClient as any });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://open.bigmodel.cn/api/fine-tuning/model_center/list?pageSize=100&pageNum=1',
+        expect.anything(),
+      );
     });
   });
 });