@lobehub/lobehub 2.0.0-next.75 → 2.0.0-next.77

package/packages/model-runtime/src/core/streams/openai/openai.test.ts

@@ -2317,6 +2317,155 @@ describe('OpenAIStream', () => {
       );
     });
 
+    it('should handle reasoning_details array format from MiniMax M2', async () => {
+      const data = [
+        {
+          id: '055ccc4cbe1ca0dc18037256237d0823',
+          object: 'chat.completion.chunk',
+          created: 1762498892,
+          model: 'MiniMax-M2',
+          choices: [
+            {
+              index: 0,
+              delta: {
+                content: '',
+                role: 'assistant',
+                name: 'MiniMax AI',
+                audio_content: '',
+                reasoning_details: [
+                  {
+                    type: 'reasoning.text',
+                    id: 'reasoning-text-1',
+                    format: 'MiniMax-response-v1',
+                    index: 0,
+                    text: '中文打招呼说"你好"，',
+                  },
+                ],
+              },
+              finish_reason: null,
+            },
+          ],
+          usage: null,
+        },
+        {
+          id: '055ccc4cbe1ca0dc18037256237d0823',
+          object: 'chat.completion.chunk',
+          created: 1762498892,
+          model: 'MiniMax-M2',
+          choices: [
+            {
+              index: 0,
+              delta: {
+                reasoning_details: [
+                  {
+                    type: 'reasoning.text',
+                    id: 'reasoning-text-2',
+                    format: 'MiniMax-response-v1',
+                    index: 0,
+                    text: '我需要用中文回复。',
+                  },
+                ],
+              },
+              finish_reason: null,
+            },
+          ],
+          usage: null,
+        },
+        {
+          id: '055ccc4cbe1ca0dc18037256237d0823',
+          object: 'chat.completion.chunk',
+          created: 1762498892,
+          model: 'MiniMax-M2',
+          choices: [
+            {
+              index: 0,
+              delta: {
+                content: '你好',
+              },
+              finish_reason: null,
+            },
+          ],
+          usage: null,
+        },
+        {
+          id: '055ccc4cbe1ca0dc18037256237d0823',
+          object: 'chat.completion.chunk',
+          created: 1762498892,
+          model: 'MiniMax-M2',
+          choices: [
+            {
+              index: 0,
+              delta: {
+                content: '！',
+              },
+              finish_reason: null,
+            },
+          ],
+          usage: null,
+        },
+        {
+          id: '055ccc4cbe1ca0dc18037256237d0823',
+          object: 'chat.completion.chunk',
+          created: 1762498892,
+          model: 'MiniMax-M2',
+          choices: [
+            {
+              index: 0,
+              delta: {
+                content: '',
+              },
+              finish_reason: 'stop',
+            },
+          ],
+          usage: {
+            prompt_tokens: 10,
+            completion_tokens: 20,
+            total_tokens: 30,
+          },
+        },
+      ];
+
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          data.forEach((chunk) => {
+            controller.enqueue(chunk);
+          });
+
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks).toEqual(
+        [
+          'id: 055ccc4cbe1ca0dc18037256237d0823',
+          'event: reasoning',
+          `data: "中文打招呼说\\"你好\\"，"\n`,
+          'id: 055ccc4cbe1ca0dc18037256237d0823',
+          'event: reasoning',
+          `data: "我需要用中文回复。"\n`,
+          'id: 055ccc4cbe1ca0dc18037256237d0823',
+          'event: text',
+          `data: "你好"\n`,
+          'id: 055ccc4cbe1ca0dc18037256237d0823',
+          'event: text',
+          `data: "！"\n`,
+          'id: 055ccc4cbe1ca0dc18037256237d0823',
+          'event: usage',
+          `data: {"inputTextTokens":10,"outputTextTokens":20,"totalInputTokens":10,"totalOutputTokens":20,"totalTokens":30}\n`,
+        ].map((i) => `${i}\n`),
+      );
+    });
+
     it('should handle claude reasoning in litellm openai mode', async () => {
       const data = [
         {
@@ -3346,5 +3495,166 @@ describe('OpenAIStream', () => {
         'chat response streaming chunk parse error, please contact your API Provider to fix it.',
       );
     });
+
+    it('should handle MiniMax base_resp error with insufficient quota (1008)', async () => {
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            id: 'minimax-error-1008',
+            choices: null,
+            base_resp: {
+              status_code: 1008,
+              status_msg: 'insufficient balance',
+            },
+          });
+
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks[0]).toBe('id: minimax-error-1008\n');
+      expect(chunks[1]).toBe('event: error\n');
+      expect(chunks[2]).toContain('InsufficientQuota');
+      expect(chunks[2]).toContain('insufficient balance');
+      expect(chunks[2]).toContain('minimax');
+    });
+
+    it('should handle MiniMax base_resp error with invalid API key (2049)', async () => {
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            id: 'minimax-error-2049',
+            choices: null,
+            base_resp: {
+              status_code: 2049,
+              status_msg: 'invalid API Key',
+            },
+          });
+
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks[0]).toBe('id: minimax-error-2049\n');
+      expect(chunks[1]).toBe('event: error\n');
+      expect(chunks[2]).toContain('InvalidProviderAPIKey');
+      expect(chunks[2]).toContain('invalid API Key');
+    });
+
+    it('should handle MiniMax base_resp error with rate limit (1002)', async () => {
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            id: 'minimax-error-1002',
+            choices: null,
+            base_resp: {
+              status_code: 1002,
+              status_msg: 'request frequency exceeds limit',
+            },
+          });
+
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks[0]).toBe('id: minimax-error-1002\n');
+      expect(chunks[1]).toBe('event: error\n');
+      expect(chunks[2]).toContain('QuotaLimitReached');
+      expect(chunks[2]).toContain('request frequency exceeds limit');
+    });
+
+    it('should handle MiniMax base_resp error with context window exceeded (1039)', async () => {
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            id: 'minimax-error-1039',
+            choices: null,
+            base_resp: {
+              status_code: 1039,
+              status_msg: 'token limit exceeded',
+            },
+          });
+
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks[0]).toBe('id: minimax-error-1039\n');
+      expect(chunks[1]).toBe('event: error\n');
+      expect(chunks[2]).toContain('ExceededContextWindow');
+      expect(chunks[2]).toContain('token limit exceeded');
+    });
+
+    it('should handle MiniMax base_resp error with fallback to ProviderBizError', async () => {
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            id: 'minimax-error-unknown',
+            choices: null,
+            base_resp: {
+              status_code: 9999,
+              status_msg: 'unknown error',
+            },
+          });
+
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks[0]).toBe('id: minimax-error-unknown\n');
+      expect(chunks[1]).toBe('event: error\n');
+      expect(chunks[2]).toContain('ProviderBizError');
+      expect(chunks[2]).toContain('unknown error');
+    });
   });
 });

package/packages/model-runtime/src/core/streams/openai/openai.ts

@@ -71,6 +71,55 @@ const transformOpenAIStream = (
     return { data: errorData, id: 'first_chunk_error', type: 'error' };
   }
 
+  // MiniMax 会在 base_resp 中返回业务错误（如余额不足），但不走 FIRST_CHUNK_ERROR_KEY
+  // 典型返回：{ id: '...', choices: null, base_resp: { status_code: 1008, status_msg: 'insufficient balance' }, usage: {...} }
+  if ((chunk as any).base_resp && typeof (chunk as any).base_resp.status_code === 'number') {
+    const baseResp = (chunk as any).base_resp as {
+      message?: string;
+      status_code: number;
+      status_msg?: string;
+    };
+
+    if (baseResp.status_code !== 0) {
+      // 根据 MiniMax 错误码映射到对应的错误类型
+      let errorType: ILobeAgentRuntimeErrorType = AgentRuntimeErrorType.ProviderBizError;
+
+      switch (baseResp.status_code) {
+        // 1004 - 未授权 / Token 不匹配 / 2049 - 无效的 API Key
+        case 1004:
+        case 2049: {
+          errorType = AgentRuntimeErrorType.InvalidProviderAPIKey;
+          break;
+        }
+        // 1008 - 余额不足
+        case 1008: {
+          errorType = AgentRuntimeErrorType.InsufficientQuota;
+          break;
+        }
+        // 1002 - 请求频率超限 / 1041 - 连接数限制 / 2045 - 请求频率增长超限
+        case 1002:
+        case 1041:
+        case 2045: {
+          errorType = AgentRuntimeErrorType.QuotaLimitReached;
+          break;
+        }
+        // 1039 - Token 限制
+        case 1039: {
+          errorType = AgentRuntimeErrorType.ExceededContextWindow;
+          break;
+        }
+      }
+
+      const errorData: ChatMessageError = {
+        body: { ...baseResp, provider: 'minimax' },
+        message: baseResp.status_msg || baseResp.message || 'MiniMax provider error',
+        type: errorType,
+      };
+
+      return { data: errorData, id: chunk.id, type: 'error' };
+    }
+  }
+
   try {
     // maybe need another structure to add support for multiple choices
     if (!Array.isArray(chunk.choices) || chunk.choices.length === 0) {
@@ -265,6 +314,24 @@ const transformOpenAIStream = (
       let reasoning_content = (() => {
         if ('reasoning_content' in item.delta) return item.delta.reasoning_content;
         if ('reasoning' in item.delta) return item.delta.reasoning;
+        // Handle MiniMax M2 reasoning_details format (array of objects with text field)
+        if ('reasoning_details' in item.delta) {
+          const details = item.delta.reasoning_details;
+          if (Array.isArray(details)) {
+            return details
+              .filter((detail: any) => detail.text)
+              .map((detail: any) => detail.text)
+              .join('');
+          }
+          if (typeof details === 'string') {
+            return details;
+          }
+          if (typeof details === 'object' && details !== null && 'text' in details) {
+            return details.text;
+          }
+          // Fallback for unexpected types
+          return '';
+        }
         // Handle content array format with thinking blocks (e.g. mistral AI Magistral model)
         if ('content' in item.delta && Array.isArray(item.delta.content)) {
           return item.delta.content

package/packages/model-runtime/src/providers/minimax/index.ts

@@ -13,17 +13,45 @@ export const LobeMinimaxAI = createOpenAICompatibleRuntime({
   baseURL: 'https://api.minimaxi.com/v1',
   chatCompletion: {
     handlePayload: (payload) => {
-      const { enabledSearch, max_tokens, temperature, tools, top_p, ...params } = payload;
+      const { enabledSearch, max_tokens, messages, temperature, tools, top_p, ...params } = payload;
 
       const minimaxTools = enabledSearch
         ? [
-          ...(tools || []),
-          {
-            type: 'web_search',
-          },
-        ]
+            ...(tools || []),
+            {
+              type: 'web_search',
+            },
+          ]
         : tools;
 
+      // Interleaved thinking
+      const processedMessages = messages.map((message: any) => {
+        if (message.role === 'assistant' && message.reasoning) {
+          // 只处理没有 signature 的历史推理内容
+          if (!message.reasoning.signature && message.reasoning.content) {
+            const { reasoning, ...messageWithoutReasoning } = message;
+            return {
+              ...messageWithoutReasoning,
+              reasoning_details: [
+                {
+                  format: 'MiniMax-response-v1',
+                  id: 'reasoning-text-0',
+                  index: 0,
+                  text: reasoning.content,
+                  type: 'reasoning.text',
+                },
+              ],
+            };
+          }
+
+          // 有 signature 或没有 content 的情况，移除 reasoning 字段
+          // eslint-disable-next-line unused-imports/no-unused-vars, @typescript-eslint/no-unused-vars
+          const { reasoning, ...messageWithoutReasoning } = message;
+          return messageWithoutReasoning;
+        }
+        return message;
+      });
+
       // Resolve parameters with constraints
       const resolvedParams = resolveParameters(
         {
@@ -46,6 +74,8 @@ export const LobeMinimaxAI = createOpenAICompatibleRuntime({
       return {
         ...params,
         max_tokens: resolvedParams.max_tokens,
+        messages: processedMessages,
+        reasoning_split: true,
         temperature: finalTemperature,
         tools: minimaxTools,
         top_p: resolvedParams.top_p,