Handle DeepSeek thinking mode re-enable after disabled tool calls

Author: avaritiachaos

src/api/providers/__tests__/deepseek.spec.ts

@@ -559,6 +559,49 @@ describe("DeepSeekHandler", () => {
 			expect(callArgs.reasoning_effort).toBeUndefined()
 		})
 
+		it("should add empty reasoning_content to old tool calls when thinking is re-enabled", async () => {
+			const v4Handler = new DeepSeekHandler({
+				...mockOptions,
+				apiModelId: "deepseek-v4-pro",
+				enableReasoningEffort: true,
+				reasoningEffort: "high",
+			})
+
+			const priorMessages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "call_without_reasoning",
+							name: "read_file",
+							input: { path: "memory.md" },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "call_without_reasoning",
+							content: "ok",
+						},
+					],
+				},
+			]
+
+			const stream = v4Handler.createMessage(systemPrompt, priorMessages)
+			for await (const _chunk of stream) {
+				// Consume the stream
+			}
+
+			const callArgs = mockCreate.mock.calls[0][0]
+			const assistantWithToolCall = callArgs.messages.find((message: any) => message.role === "assistant")
+			expect(callArgs.thinking).toEqual({ type: "enabled" })
+			expect(assistantWithToolCall.reasoning_content).toBe("")
+		})
+
 		it("should handle tool calls with reasoning_content", async () => {
 			const reasonerHandler = new DeepSeekHandler({
 				...mockOptions,

src/api/providers/__tests__/openai.spec.ts

@@ -463,6 +463,55 @@ describe("OpenAiHandler", () => {
 			expect(callArgs.reasoning_effort).toBeUndefined()
 		})
 
+		it("should add empty reasoning_content to old tool calls for OpenAI-compatible DeepSeek V4 when thinking is re-enabled", async () => {
+			const deepSeekV4Options: ApiHandlerOptions = {
+				...mockOptions,
+				openAiBaseUrl: "https://api.deepseek.com",
+				openAiModelId: "deepseek-v4-pro",
+				enableReasoningEffort: true,
+				reasoningEffort: "high",
+				openAiCustomModelInfo: {
+					contextWindow: 1_000_000,
+					supportsPromptCache: true,
+					supportsReasoningEffort: ["disable", "high", "xhigh"],
+					reasoningEffort: "high",
+				},
+			}
+			const priorMessages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "call_without_reasoning",
+							name: "read_file",
+							input: { path: "memory.md" },
+						},
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "call_without_reasoning",
+							content: "ok",
+						},
+					],
+				},
+			]
+
+			const deepSeekV4Handler = new OpenAiHandler(deepSeekV4Options)
+			const stream = deepSeekV4Handler.createMessage(systemPrompt, priorMessages)
+			for await (const _chunk of stream) {
+			}
+
+			const callArgs = mockCreate.mock.calls[0][0]
+			const assistantWithToolCall = callArgs.messages.find((message: any) => message.role === "assistant")
+			expect(callArgs.thinking).toEqual({ type: "enabled" })
+			expect(assistantWithToolCall.reasoning_content).toBe("")
+		})
+
 		it("should preserve empty DeepSeek V4 reasoning_content chunks for OpenAI-compatible endpoints", async () => {
 			mockCreate.mockImplementationOnce(async () => ({
 				[Symbol.asyncIterator]: async function* () {

src/api/providers/deepseek.ts

@@ -74,6 +74,7 @@ export class DeepSeekHandler extends OpenAiHandler {
 		// See: https://api-docs.deepseek.com/guides/thinking_mode
 		const convertedMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages], {
 			mergeToolResultText: isThinkingModel,
+			requireReasoningContentForToolCalls: isThinkingModel && thinkingType === "enabled",
 		})
 
 		const requestOptions: DeepSeekChatCompletionParams = {

src/api/providers/openai.ts

@@ -136,7 +136,11 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 			let convertedMessages
 
 			if (deepseekReasoner) {
-				convertedMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
+				convertedMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages], {
+					mergeToolResultText: usesDeepSeekThinkingParam && deepseekThinkingType === "enabled",
+					requireReasoningContentForToolCalls:
+						usesDeepSeekThinkingParam && deepseekThinkingType === "enabled",
+				})
 			} else {
 				if (modelInfo.supportsPromptCache) {
 					systemMessage = {
@@ -256,7 +260,11 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 			const requestOptions: OpenAiCompatibleChatCompletionParamsNonStreaming = {
 				model: modelId,
 				messages: deepseekReasoner
-					? convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
+					? convertToR1Format([{ role: "user", content: systemPrompt }, ...messages], {
+							mergeToolResultText: usesDeepSeekThinkingParam && deepseekThinkingType === "enabled",
+							requireReasoningContentForToolCalls:
+								usesDeepSeekThinkingParam && deepseekThinkingType === "enabled",
+						})
 					: [systemMessage, ...convertToOpenAiMessages(messages)],
 				...(usesDeepSeekThinkingParam && { thinking: { type: deepseekThinkingType } }),
 				...(providerReasoning && providerReasoning),

src/api/transform/__tests__/r1-format.spec.ts

@@ -614,6 +614,41 @@ describe("convertToR1Format", () => {
 				// Most importantly: NO user message after tool message
 				expect(result.filter((m) => m.role === "user")).toHaveLength(1)
 			})
+
+			it("should add empty reasoning_content to prior tool calls when required", () => {
+				const input = [
+					{ role: "user" as const, content: "Start" },
+					{
+						role: "assistant" as const,
+						content: [
+							{
+								type: "tool_use" as const,
+								id: "call_123",
+								name: "test_tool",
+								input: {},
+							},
+						],
+					},
+					{
+						role: "user" as const,
+						content: [
+							{
+								type: "tool_result" as const,
+								tool_use_id: "call_123",
+								content: "Result",
+							},
+						],
+					},
+				]
+
+				const result = convertToR1Format(input as Anthropic.Messages.MessageParam[], {
+					mergeToolResultText: true,
+					requireReasoningContentForToolCalls: true,
+				})
+
+				expect((result[1] as any).tool_calls).toBeDefined()
+				expect((result[1] as any).reasoning_content).toBe("")
+			})
 		})
 	})
 })

src/api/transform/r1-format.ts

@@ -38,14 +38,15 @@ export type DeepSeekAssistantMessage = AssistantMessage & {
  */
 export function convertToR1Format(
 	messages: AnthropicMessage[],
-	options?: { mergeToolResultText?: boolean },
+	options?: { mergeToolResultText?: boolean; requireReasoningContentForToolCalls?: boolean },
 ): Message[] {
 	const result: Message[] = []
 
 	for (const message of messages) {
 		// Check if the message has reasoning_content (for DeepSeek interleaved thinking)
 		const messageWithReasoning = message as AnthropicMessage & { reasoning_content?: string }
 		const reasoningContent = messageWithReasoning.reasoning_content
+		const hasReasoningContent = typeof reasoningContent === "string"
 
 		if (message.role === "user") {
 			// Handle user messages - may contain tool_result blocks
@@ -187,15 +188,21 @@ export function convertToR1Format(
 					}
 				}
 
-				// Use reasoning from content blocks if not provided at top level
-				const finalReasoning = reasoningContent || extractedReasoning
+				// Use reasoning from content blocks if not provided at top level.
+				// Empty reasoning_content is meaningful for DeepSeek thinking-mode tool call continuations.
+				const finalReasoning = hasReasoningContent ? reasoningContent : extractedReasoning
+				const needsEmptyToolCallReasoning =
+					options?.requireReasoningContentForToolCalls === true &&
+					toolCalls.length > 0 &&
+					typeof finalReasoning !== "string"
+				const shouldAttachReasoning = typeof finalReasoning === "string" || needsEmptyToolCallReasoning
 
 				const assistantMessage: DeepSeekAssistantMessage = {
 					role: "assistant",
 					content: textParts.length > 0 ? textParts.join("\n") : null,
 					...(toolCalls.length > 0 && { tool_calls: toolCalls }),
 					// Preserve reasoning_content for DeepSeek interleaved thinking
-					...(finalReasoning && { reasoning_content: finalReasoning }),
+					...(shouldAttachReasoning && { reasoning_content: finalReasoning ?? "" }),
 				}
 
 				// Check if we can merge with the last message (only if no tool calls)
@@ -209,8 +216,8 @@ export function convertToR1Format(
 						lastMessage.content = `${lastContent}\n${assistantMessage.content}`
 					}
 					// Preserve reasoning_content from the new message if present
-					if (finalReasoning) {
-						;(lastMessage as DeepSeekAssistantMessage).reasoning_content = finalReasoning
+					if (shouldAttachReasoning) {
+						;(lastMessage as DeepSeekAssistantMessage).reasoning_content = finalReasoning ?? ""
 					}
 				} else {
 					result.push(assistantMessage)
@@ -225,14 +232,14 @@ export function convertToR1Format(
 						lastMessage.content = message.content
 					}
 					// Preserve reasoning_content from the new message if present
-					if (reasoningContent) {
+					if (hasReasoningContent) {
 						;(lastMessage as DeepSeekAssistantMessage).reasoning_content = reasoningContent
 					}
 				} else {
 					const assistantMessage: DeepSeekAssistantMessage = {
 						role: "assistant",
 						content: message.content,
-						...(reasoningContent && { reasoning_content: reasoningContent }),
+						...(hasReasoningContent && { reasoning_content: reasoningContent }),
 					}
 					result.push(assistantMessage)
 				}