🐛 fix: filter out reasoning fields from messages in ChatCompletion API (#10203)

* fix max tokens issue

* 🐛 fix: filter out reasoning fields from messages in ChatCompletion API

Explicitly map only valid ChatCompletionMessageParam fields and exclude reasoning/reasoning_content to prevent JSON unmarshaling errors when conversation history contains reasoning objects.

Fixes #10193

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: arvinxx

packages/model-runtime/src/core/contextBuilders/openai.test.ts

@@ -150,6 +150,64 @@ describe('convertOpenAIMessages', () => {
 
     expect(Promise.all).toHaveBeenCalledTimes(2); // 一次用于消息数组，一次用于内容数组
   });
+
+  it('should filter out reasoning field from messages', async () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: 'Hello',
+        reasoning: { content: 'some reasoning', duration: 100 },
+      },
+      { role: 'user', content: 'Hi' },
+    ] as any;
+
+    const result = await convertOpenAIMessages(messages);
+
+    expect(result).toEqual([
+      { role: 'assistant', content: 'Hello' },
+      { role: 'user', content: 'Hi' },
+    ]);
+    // Ensure reasoning field is removed
+    expect((result[0] as any).reasoning).toBeUndefined();
+  });
+
+  it('should filter out reasoning_content field from messages', async () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: 'Hello',
+        reasoning_content: 'some reasoning content',
+      },
+      { role: 'user', content: 'Hi' },
+    ] as any;
+
+    const result = await convertOpenAIMessages(messages);
+
+    expect(result).toEqual([
+      { role: 'assistant', content: 'Hello' },
+      { role: 'user', content: 'Hi' },
+    ]);
+    // Ensure reasoning_content field is removed
+    expect((result[0] as any).reasoning_content).toBeUndefined();
+  });
+
+  it('should filter out both reasoning and reasoning_content fields from messages', async () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: 'Hello',
+        reasoning: { content: 'some reasoning', duration: 100 },
+        reasoning_content: 'some reasoning content',
+      },
+    ] as any;
+
+    const result = await convertOpenAIMessages(messages);
+
+    expect(result).toEqual([{ role: 'assistant', content: 'Hello' }]);
+    // Ensure both fields are removed
+    expect((result[0] as any).reasoning).toBeUndefined();
+    expect((result[0] as any).reasoning_content).toBeUndefined();
+  });
 });
 
 describe('convertOpenAIResponseInputs', () => {

packages/model-runtime/src/core/contextBuilders/openai.ts

@@ -26,17 +26,31 @@ export const convertMessageContent = async (
 
 export const convertOpenAIMessages = async (messages: OpenAI.ChatCompletionMessageParam[]) => {
   return (await Promise.all(
-    messages.map(async (message) => ({
-      ...message,
-      content:
-        typeof message.content === 'string'
-          ? message.content
-          : await Promise.all(
-              (message.content || []).map((c) =>
-                convertMessageContent(c as OpenAI.ChatCompletionContentPart),
+    messages.map(async (message) => {
+      const msg = message as any;
+
+      // Explicitly map only valid ChatCompletionMessageParam fields
+      // Exclude reasoning and reasoning_content fields as they should not be sent in requests
+      const result: any = {
+        content:
+          typeof message.content === 'string'
+            ? message.content
+            : await Promise.all(
+                (message.content || []).map((c) =>
+                  convertMessageContent(c as OpenAI.ChatCompletionContentPart),
+                ),
               ),
-            ),
-    })),
+        role: msg.role,
+      };
+
+      // Add optional fields if they exist
+      if (msg.name !== undefined) result.name = msg.name;
+      if (msg.tool_calls !== undefined) result.tool_calls = msg.tool_calls;
+      if (msg.tool_call_id !== undefined) result.tool_call_id = msg.tool_call_id;
+      if (msg.function_call !== undefined) result.function_call = msg.function_call;
+
+      return result;
+    }),
   )) as OpenAI.ChatCompletionMessageParam[];
 };
 

packages/model-runtime/src/core/openaiCompatibleFactory/index.ts

@@ -766,12 +766,12 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
 
       const inputStartAt = Date.now();
 
-      const { messages, reasoning_effort, tools, reasoning, responseMode, ...res } =
+      const { messages, reasoning_effort, tools, reasoning, responseMode, max_tokens, ...res } =
         responses?.handlePayload
           ? (responses?.handlePayload(payload, this._options) as ChatStreamPayload)
           : payload;
 
-      // remove penalty params
+      // remove penalty params and chat completion specific params
       delete res.apiMode;
       delete res.frequency_penalty;
       delete res.presence_penalty;
@@ -797,6 +797,7 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
             }
           : {}),
         input,
+        ...(max_tokens && { max_output_tokens: max_tokens }),
         store: false,
         stream: !isStreaming ? undefined : isStreaming,
         tools: tools?.map((tool) => this.convertChatCompletionToolToResponseTool(tool)),

packages/model-runtime/src/providers/openai/index.test.ts

@@ -409,6 +409,50 @@ describe('LobeOpenAI', () => {
       const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
       expect(createCall.reasoning).toEqual({ effort: 'high', summary: 'auto' });
     });
+
+    it('should convert max_tokens to max_output_tokens for responses API', async () => {
+      const payload = {
+        max_tokens: 2048,
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'o1-pro',
+        temperature: 0.7,
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.max_output_tokens).toBe(2048);
+      expect(createCall.max_tokens).toBeUndefined();
+    });
+
+    it('should not include max_output_tokens when max_tokens is undefined', async () => {
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'o1-pro',
+        temperature: 0.7,
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.max_output_tokens).toBeUndefined();
+    });
+
+    it('should convert max_tokens to max_output_tokens for search-enabled models', async () => {
+      const payload = {
+        enabledSearch: true,
+        max_tokens: 4096,
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'gpt-4o',
+        temperature: 0.7,
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.max_output_tokens).toBe(4096);
+      expect(createCall.max_tokens).toBeUndefined();
+    });
   });
 
   describe('supportsFlexTier', () => {