@lobehub/lobehub 2.0.0-next.197 → 2.0.0-next.199

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+## [Version 2.0.0-next.199](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.198...v2.0.0-next.199)
+
+<sup>Released on **2026-01-03**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Filter empty assistant messages for Anthropic API.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Filter empty assistant messages for Anthropic API, closes [#11129](https://github.com/lobehub/lobe-chat/issues/11129) ([7af750b](https://github.com/lobehub/lobe-chat/commit/7af750b))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 2.0.0-next.198](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.197...v2.0.0-next.198)
+
+<sup>Released on **2026-01-03**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Support thoughtSignature for openrouter.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Support thoughtSignature for openrouter, closes [#11117](https://github.com/lobehub/lobe-chat/issues/11117) ([bf5d41e](https://github.com/lobehub/lobe-chat/commit/bf5d41e))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.197](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.196...v2.0.0-next.197)
 
 <sup>Released on **2026-01-03**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Filter empty assistant messages for Anthropic API."
+      ]
+    },
+    "date": "2026-01-03",
+    "version": "2.0.0-next.199"
+  },
+  {
+    "children": {
+      "fixes": [
+        "Support thoughtSignature for openrouter."
+      ]
+    },
+    "date": "2026-01-03",
+    "version": "2.0.0-next.198"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.197",
+  "version": "2.0.0-next.199",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/model-runtime/src/core/contextBuilders/anthropic.test.ts

@@ -155,9 +155,9 @@ describe('anthropicHelpers', () => {
         role: 'user',
       };
       const result = await buildAnthropicMessage(message);
-      expect(result.role).toBe('user');
-      expect(result.content).toHaveLength(2);
-      expect((result.content[1] as any).type).toBe('image');
+      expect(result!.role).toBe('user');
+      expect(result!.content).toHaveLength(2);
+      expect((result!.content[1] as any).type).toBe('image');
     });
 
     it('should correctly convert tool message', async () => {
@@ -167,8 +167,8 @@ describe('anthropicHelpers', () => {
         tool_call_id: 'tool123',
       };
       const result = await buildAnthropicMessage(message);
-      expect(result.role).toBe('user');
-      expect(result.content).toEqual([
+      expect(result!.role).toBe('user');
+      expect(result!.content).toEqual([
         {
           content: 'Tool result content',
           tool_use_id: 'tool123',
@@ -193,8 +193,8 @@ describe('anthropicHelpers', () => {
         ],
       };
       const result = await buildAnthropicMessage(message);
-      expect(result.role).toBe('assistant');
-      expect(result.content).toEqual([
+      expect(result!.role).toBe('assistant');
+      expect(result!.content).toEqual([
         { text: 'Here is the result:', type: 'text' },
         {
           id: 'call1',
@@ -266,15 +266,35 @@ describe('anthropicHelpers', () => {
 
         const contents = await buildAnthropicMessages(messages);
 
+        // Empty assistant messages should be filtered out
         expect(contents).toEqual([
           {
             content: '## Tools\n\nYou can use these tools',
             role: 'user',
           },
+        ]);
+      });
+
+      it('should filter out assistant message with whitespace-only content', async () => {
+        const messages: OpenAIChatMessage[] = [
           {
-            content: '',
+            content: 'Hello',
+            role: 'user',
+          },
+          {
+            content: '   \n\t  ',
             role: 'assistant',
           },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        // Whitespace-only assistant messages should be filtered out
+        expect(contents).toEqual([
+          {
+            content: 'Hello',
+            role: 'user',
+          },
         ]);
       });
       it('should correctly convert OpenAI tool message to Anthropic format', async () => {

package/packages/model-runtime/src/core/contextBuilders/anthropic.ts

@@ -62,7 +62,7 @@ const buildArrayContent = async (content: UserMessageContentPart[]) => {
 
 export const buildAnthropicMessage = async (
   message: OpenAIChatMessage,
-): Promise<Anthropic.Messages.MessageParam> => {
+): Promise<Anthropic.Messages.MessageParam | undefined> => {
   const content = message.content as string | UserMessageContentPart[];
 
   switch (message.role) {
@@ -118,7 +118,10 @@ export const buildAnthropicMessage = async (
       }
 
       // or it's a plain assistant message
-      return { content: content as string, role: 'assistant' };
+      // Anthropic API requires non-empty content, filter out empty/whitespace-only content
+      const textContent = (content as string)?.trim();
+      if (!textContent) return undefined;
+      return { content: textContent, role: 'assistant' };
     }
 
     case 'function': {
@@ -176,7 +179,10 @@ export const buildAnthropicMessages = async (
       }
     } else {
       const anthropicMessage = await buildAnthropicMessage(message);
-      messages.push({ ...anthropicMessage, role: anthropicMessage.role });
+      // Filter out undefined messages (e.g., empty assistant messages)
+      if (anthropicMessage) {
+        messages.push(anthropicMessage);
+      }
     }
   }
 

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

@@ -1048,6 +1048,161 @@ describe('OpenAIStream', () => {
         ].map((i) => `${i}\n`),
       );
     });
+
+    it('should handle OpenRouter tool calls with thoughtSignature (for Gemini models)', async () => {
+      // OpenRouter returns thoughtSignature in tool_calls for Gemini models
+      // This is required for preserving reasoning blocks across turns
+      // Ref: https://openrouter.ai/docs/guides/best-practices/reasoning-tokens
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            choices: [
+              {
+                delta: {
+                  tool_calls: [
+                    {
+                      function: { name: 'github__get_me', arguments: '{}' },
+                      id: 'call_123',
+                      index: 0,
+                      type: 'function',
+                      // OpenRouter adds thoughtSignature for Gemini 3 models
+                      thoughtSignature: 'ErEDCq4DAdHtim...',
+                    },
+                  ],
+                },
+                index: 0,
+              },
+            ],
+            id: 'or-123',
+          });
+
+          controller.close();
+        },
+      });
+
+      const onToolCallMock = vi.fn();
+
+      const protocolStream = OpenAIStream(mockOpenAIStream, {
+        callbacks: {
+          onToolsCalling: onToolCallMock,
+        },
+      });
+
+      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: or-123\n',
+        'event: tool_calls\n',
+        // thoughtSignature should be preserved in the output
+        `data: [{"function":{"arguments":"{}","name":"github__get_me"},"id":"call_123","index":0,"type":"function","thoughtSignature":"ErEDCq4DAdHtim..."}]\n\n`,
+      ]);
+
+      // Verify the callback receives thoughtSignature
+      expect(onToolCallMock).toHaveBeenCalledWith({
+        chunk: [
+          {
+            function: { arguments: '{}', name: 'github__get_me' },
+            id: 'call_123',
+            index: 0,
+            thoughtSignature: 'ErEDCq4DAdHtim...',
+            type: 'function',
+          },
+        ],
+        toolsCalling: [
+          {
+            function: { arguments: '{}', name: 'github__get_me' },
+            id: 'call_123',
+            thoughtSignature: 'ErEDCq4DAdHtim...',
+            type: 'function',
+          },
+        ],
+      });
+    });
+
+    it('should NOT include thoughtSignature in output when not present in tool call', async () => {
+      // Standard tool calls without thoughtSignature should not include the field
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            choices: [
+              {
+                delta: {
+                  tool_calls: [
+                    {
+                      function: { name: 'search', arguments: '{"query":"test"}' },
+                      id: 'call_456',
+                      index: 0,
+                      type: 'function',
+                      // No thoughtSignature field
+                    },
+                  ],
+                },
+                index: 0,
+              },
+            ],
+            id: 'standard-123',
+          });
+
+          controller.close();
+        },
+      });
+
+      const onToolCallMock = vi.fn();
+
+      const protocolStream = OpenAIStream(mockOpenAIStream, {
+        callbacks: {
+          onToolsCalling: onToolCallMock,
+        },
+      });
+
+      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: standard-123\n',
+        'event: tool_calls\n',
+        // thoughtSignature should NOT be in the output
+        `data: [{"function":{"arguments":"{\\"query\\":\\"test\\"}","name":"search"},"id":"call_456","index":0,"type":"function"}]\n\n`,
+      ]);
+
+      // Verify the callback does NOT receive thoughtSignature
+      expect(onToolCallMock).toHaveBeenCalledWith({
+        chunk: [
+          {
+            function: { arguments: '{"query":"test"}', name: 'search' },
+            id: 'call_456',
+            index: 0,
+            // thoughtSignature should not be present
+            type: 'function',
+          },
+        ],
+        toolsCalling: [
+          {
+            function: { arguments: '{"query":"test"}', name: 'search' },
+            id: 'call_456',
+            // thoughtSignature should not be present
+            type: 'function',
+          },
+        ],
+      });
+
+      // Verify thoughtSignature is not in the chunk
+      expect(onToolCallMock.mock.calls[0][0].chunk[0]).not.toHaveProperty('thoughtSignature');
+      expect(onToolCallMock.mock.calls[0][0].toolsCalling[0]).not.toHaveProperty(
+        'thoughtSignature',
+      );
+    });
   });
 
   describe('Reasoning', () => {

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

@@ -20,6 +20,23 @@ import {
   generateToolCallId,
 } from '../protocol';
 
+/**
+ * Extended type for OpenAI tool calls that includes provider-specific extensions
+ * like OpenRouter's thoughtSignature for Gemini models
+ */
+type OpenAIExtendedToolCall = OpenAI.ChatCompletionChunk.Choice.Delta.ToolCall & {
+  thoughtSignature?: string;
+};
+
+/**
+ * Type guard to check if a tool call has thoughtSignature
+ */
+const hasThoughtSignature = (
+  toolCall: OpenAI.ChatCompletionChunk.Choice.Delta.ToolCall,
+): toolCall is OpenAIExtendedToolCall => {
+  return 'thoughtSignature' in toolCall && typeof toolCall.thoughtSignature === 'string';
+};
+
 // Process markdown base64 images: extract URLs and clean text in one pass
 const processMarkdownBase64Images = (text: string): { cleanedText: string; urls: string[] } => {
   if (!text) return { cleanedText: text, urls: [] };
@@ -150,7 +167,7 @@ const transformOpenAIStream = (
               };
             }
 
-            return {
+            const baseData: StreamToolCallChunkData = {
               function: {
                 arguments: value.function?.arguments ?? '',
                 name: value.function?.name ?? null,
@@ -170,6 +187,14 @@ const transformOpenAIStream = (
               index: typeof value.index !== 'undefined' ? value.index : index,
               type: value.type || 'function',
             };
+
+            // OpenRouter returns thoughtSignature in tool_calls for Gemini models (e.g. gemini-3-flash-preview)
+            // [{"id":"call_123","type":"function","function":{"name":"get_weather","arguments":"{}"},"thoughtSignature":"abc123"}]
+            if (hasThoughtSignature(value)) {
+              baseData.thoughtSignature = value.thoughtSignature;
+            }
+
+            return baseData;
           }),
           id: chunk.id,
           type: 'tool_calls',