@lobehub/chat 1.45.16 → 1.46.0

package/src/libs/agent-runtime/minimax/index.test.ts

@@ -1,275 +0,0 @@
-// @vitest-environment edge-runtime
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { ChatStreamPayload, ModelProvider } from '@/libs/agent-runtime';
-import * as debugStreamModule from '@/libs/agent-runtime/utils/debugStream';
-
-import { LobeMinimaxAI } from './index';
-
-const provider = ModelProvider.Minimax;
-const bizErrorType = 'ProviderBizError';
-const invalidErrorType = 'InvalidProviderAPIKey';
-
-const encoder = new TextEncoder();
-
-// Mock the console.error to avoid polluting test output
-vi.spyOn(console, 'error').mockImplementation(() => {});
-
-let instance: LobeMinimaxAI;
-
-beforeEach(() => {
-  instance = new LobeMinimaxAI({ apiKey: 'test' });
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('LobeMinimaxAI', () => {
-  describe('init', () => {
-    it('should correctly initialize with an API key', async () => {
-      const instance = new LobeMinimaxAI({ apiKey: 'test_api_key' });
-      expect(instance).toBeInstanceOf(LobeMinimaxAI);
-    });
-
-    it('should throw AgentRuntimeError with InvalidMinimaxAPIKey if no apiKey is provided', async () => {
-      try {
-        new LobeMinimaxAI({});
-      } catch (e) {
-        expect(e).toEqual({ errorType: invalidErrorType });
-      }
-    });
-  });
-
-  describe('chat', () => {
-    it('should return a StreamingTextResponse on successful API call', async () => {
-      const mockResponseData = {
-        choices: [{ delta: { content: 'Hello, world!' } }],
-      };
-      const mockResponse = new Response(
-        new ReadableStream({
-          start(controller) {
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(mockResponseData)}`));
-            controller.close();
-          },
-        }),
-      );
-      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(mockResponse);
-
-      const result = await instance.chat({
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'text-davinci-003',
-        temperature: 0,
-      });
-
-      expect(result).toBeInstanceOf(Response);
-    });
-
-    it('should handle text messages correctly', async () => {
-      const mockResponseData = {
-        choices: [{ delta: { content: 'Hello, world!' } }],
-      };
-      const mockResponse = new Response(
-        new ReadableStream({
-          start(controller) {
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(mockResponseData)}`));
-            controller.close();
-          },
-        }),
-      );
-      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(mockResponse);
-
-      const result = await instance.chat({
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'text-davinci-003',
-        temperature: 0,
-      });
-
-      expect(result).toBeInstanceOf(Response);
-    });
-
-    it('should call debugStream in DEBUG mode', async () => {
-      process.env.DEBUG_MINIMAX_CHAT_COMPLETION = '1';
-
-      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-        new Response(
-          new ReadableStream({
-            start(controller) {
-              controller.enqueue(encoder.encode(JSON.stringify('Hello, world!')));
-              controller.close();
-            },
-          }),
-        ),
-      );
-
-      vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
-
-      await instance.chat({
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'text-davinci-003',
-        temperature: 0,
-      });
-
-      // Assert
-      expect(debugStreamModule.debugStream).toHaveBeenCalled();
-
-      delete process.env.DEBUG_MINIMAX_CHAT_COMPLETION;
-    });
-
-    describe('Error', () => {
-      it('should throw InvalidMinimaxAPIKey error on API_KEY_INVALID error', async () => {
-        const mockErrorResponse = {
-          base_resp: {
-            status_code: 1004,
-            status_msg: 'API key not valid',
-          },
-        };
-        vi.spyOn(globalThis, 'fetch').mockResolvedValue(
-          new Response(
-            new ReadableStream({
-              start(controller) {
-                controller.enqueue(encoder.encode(JSON.stringify(mockErrorResponse)));
-                controller.close();
-              },
-            }),
-          ),
-        );
-
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'text-davinci-003',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            errorType: invalidErrorType,
-            error: {
-              code: 1004,
-              message: 'API key not valid',
-            },
-            provider,
-          });
-        }
-      });
-
-      it('should throw MinimaxBizError error on other error status codes', async () => {
-        const mockErrorResponse = {
-          base_resp: {
-            status_code: 1001,
-            status_msg: 'Some error occurred',
-          },
-        };
-        vi.spyOn(globalThis, 'fetch').mockResolvedValue(
-          new Response(
-            new ReadableStream({
-              start(controller) {
-                controller.enqueue(encoder.encode(JSON.stringify(mockErrorResponse)));
-                controller.close();
-              },
-            }),
-          ),
-        );
-
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'text-davinci-003',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            errorType: bizErrorType,
-            error: {
-              code: 1001,
-              message: 'Some error occurred',
-            },
-            provider,
-          });
-        }
-      });
-
-      it('should throw MinimaxBizError error on generic errors', async () => {
-        const mockError = new Error('Something went wrong');
-        vi.spyOn(globalThis, 'fetch').mockRejectedValueOnce(mockError);
-
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'text-davinci-003',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            errorType: bizErrorType,
-            error: {
-              cause: undefined,
-              message: 'Something went wrong',
-              name: 'Error',
-              stack: mockError.stack,
-            },
-            provider,
-          });
-        }
-      });
-    });
-  });
-
-  describe('private methods', () => {
-    describe('buildCompletionsParams', () => {
-      it('should build the correct parameters', () => {
-        const payload: ChatStreamPayload = {
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'text-davinci-003',
-          temperature: 0.5,
-          top_p: 0.8,
-        };
-
-        const result = instance['buildCompletionsParams'](payload);
-
-        expect(result).toEqual({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'text-davinci-003',
-          stream: true,
-          temperature: 0.25,
-          top_p: 0.8,
-        });
-      });
-
-      it('should exclude temperature and top_p when they are 0', () => {
-        const payload: ChatStreamPayload = {
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'text-davinci-003',
-          temperature: 0,
-          top_p: 0,
-        };
-
-        const result = instance['buildCompletionsParams'](payload);
-
-        expect(result).toEqual({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'text-davinci-003',
-          stream: true,
-        });
-      });
-
-      it('should include max tokens when model is abab6.5t-chat', () => {
-        const payload: ChatStreamPayload = {
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'abab6.5t-chat',
-          temperature: 0,
-          top_p: 0,
-        };
-
-        const result = instance['buildCompletionsParams'](payload);
-
-        expect(result).toEqual({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'abab6.5t-chat',
-          stream: true,
-          max_tokens: 4096,
-        });
-      });
-    });
-  });
-});

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

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { processDoubleData } from './minimax';
-
-// 假设文件名为 minimax.ts
-
-describe('processDoubleData', () => {
-  it('should remove the second "data: {"id": and everything after it when matchCount is 2', () => {
-    const chunkValue = `data: {"id":"first"} some other text 
-    
-    data: {"id":"second"} more text`;
-    const result = processDoubleData(chunkValue);
-    expect(result).toBe('data: {"id":"first"} some other text');
-  });
-
-  it('should not modify chunkValue when matchCount is not 2', () => {
-    const chunkValue = `data: {"id":"first"} some other text`;
-    const result = processDoubleData(chunkValue);
-    expect(result).toBe(chunkValue);
-  });
-
-  it('should not modify chunkValue when matchCount is more than 2', () => {
-    const chunkValue = `data: {"id":"first"} some other text data: {"id":"second"} more text data: {"id":"third"} even more text`;
-    const result = processDoubleData(chunkValue);
-    expect(result).toBe(chunkValue);
-  });
-});

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

@@ -1,57 +0,0 @@
-import OpenAI from 'openai';
-
-import { ChatStreamCallbacks } from '../../types';
-import { transformOpenAIStream } from './openai';
-import { createCallbacksTransformer, createSSEProtocolTransformer } from './protocol';
-
-export const processDoubleData = (chunkValue: string): string => {
-  const dataPattern = /data: {"id":"/g;
-  const matchCount = (chunkValue.match(dataPattern) || []).length;
-  let modifiedChunkValue = chunkValue;
-  if (matchCount === 2) {
-    const secondDataIdIndex = chunkValue.indexOf(
-      'data: {"id":',
-      chunkValue.indexOf('data: {"id":') + 1,
-    );
-    if (secondDataIdIndex !== -1) {
-      modifiedChunkValue = chunkValue.slice(0, secondDataIdIndex).trim();
-    }
-  }
-  return modifiedChunkValue;
-};
-
-const unit8ArrayToJSONChunk = (unit8Array: Uint8Array): OpenAI.ChatCompletionChunk => {
-  const decoder = new TextDecoder();
-
-  let chunkValue = decoder.decode(unit8Array, { stream: true });
-
-  // chunkValue example:
-  // data: {"id":"028a65377137d57aaceeffddf48ae99f","choices":[{"finish_reason":"tool_calls","index":0,"delta":{"role":"assistant","tool_calls":[{"id":"call_function_7371372822","type":"function","function":{"name":"realtime-weather____fetchCurrentWeather","arguments":"{\"city\": [\"杭州\", \"北京\"]}"}}]}}],"created":155511,"model":"abab6.5s-chat","object":"chat.completion.chunk"}
-
-  chunkValue = processDoubleData(chunkValue);
-
-  // so we need to remove `data:` prefix and then parse it as JSON
-  if (chunkValue.startsWith('data:')) {
-    chunkValue = chunkValue.slice(5).trim();
-  }
-
-  try {
-    return JSON.parse(chunkValue);
-  } catch (e) {
-    console.error('minimax chunk parse error:', e);
-
-    return { raw: chunkValue } as any;
-  }
-};
-
-export const MinimaxStream = (stream: ReadableStream, callbacks?: ChatStreamCallbacks) => {
-  return stream
-    .pipeThrough(
-      createSSEProtocolTransformer((buffer) => {
-        const chunk = unit8ArrayToJSONChunk(buffer);
-
-        return transformOpenAIStream(chunk);
-      }),
-    )
-    .pipeThrough(createCallbacksTransformer(callbacks));
-};