@@ -1149,6 +1149,35 @@ describe("convertToOpenAiMessages", () => {
 			expect(msg.tool_calls[0].id).toBe("call_abc")
 		})
 
+		it("should accumulate multiple reasoning blocks in order, separated by a tool call", () => {
+			// DeepSeek / Z.ai interleaved thinking can emit more than one reasoning block per
+			// turn. A regression that overwrites (instead of accumulates) would silently drop
+			// all but the last block.
+			const anthropicMessages = [
+				{
+					role: "assistant" as const,
+					content: [
+						{ type: "reasoning", text: "First, I should check the file.", summary: [] },
+						{
+							type: "tool_use",
+							id: "call_abc",
+							name: "read_file",
+							input: { path: "foo.txt" },
+						},
+						{ type: "reasoning", text: "Now I know what to do next.", summary: [] },
+					],
+				},
+			] as any as Anthropic.Messages.MessageParam[]
+
+			const result = convertToOpenAiMessages(anthropicMessages)
+
+			expect(result).toHaveLength(1)
+			const msg = result[0] as any
+			expect(msg.reasoning_content).toBe("First, I should check the file.Now I know what to do next.")
+			expect(msg.tool_calls).toHaveLength(1)
+			expect(msg.tool_calls[0].id).toBe("call_abc")
+		})
+
 		it("should prefer top-level reasoning_content over content block", () => {
 			const anthropicMessages = [
 				{
 
@@ -253,6 +253,52 @@ export function sanitizeGeminiMessages(
 	return sanitized
 }
 
+/**
+ * A reasoning content block (DeepSeek / Z.ai interleaved thinking) that may
+ * appear in an assistant message's content array. Not part of Anthropic's
+ * ContentBlockParam union, so it's declared separately here.
+ */
+interface ReasoningContentBlock {
+	type: "reasoning"
+	text?: string
+}
+
+/**
+ * Extracts the reasoning text if `part` is a {@link ReasoningContentBlock}, or `undefined`
+ * otherwise. Providers like DeepSeek / Z.ai emit a `"reasoning"` content block that isn't part of
+ * Anthropic's `ContentBlockParam` union, so `part` is treated as `unknown` and its shape is
+ * validated at runtime rather than assumed via a cast. A boolean type-guard isn't viable here:
+ * TypeScript can't narrow `part` to `ReasoningContentBlock` because their `type` literals don't
+ * overlap with any variant of `ContentBlockParam`, so the narrowed type collapses to `never`.
+ */
+function getReasoningBlockText(part: unknown): string | undefined {
+	if (!part || typeof part !== "object") {
+		return undefined
+	}
+	const block = part as { type?: unknown; text?: unknown }
+	return block.type === "reasoning" && typeof block.text === "string" ? block.text : undefined
+}
+
+/**
+ * Non-standard fields Zoo Code attaches to Anthropic message params to
+ * round-trip provider-specific reasoning state (e.g. DeepSeek's
+ * `reasoning_content`, which must be echoed back or the API returns a 400).
+ */
+type AssistantMessageWithReasoning = Anthropic.Messages.MessageParam & {
+	reasoning_details?: any[]
+	reasoning_content?: string
+}
+
+/**
+ * Extra fields layered onto an outgoing OpenAI chat message to round-trip
+ * provider-specific reasoning state. Shared by both branches of the
+ * conversion below (string-content and content-block assistant messages).
+ */
+type ReasoningPassthroughFields = {
+	reasoning_details?: any[]
+	reasoning_content?: string
+}
+
 /**
  * Options for converting Anthropic messages to OpenAI format.
  */
@@ -306,19 +352,16 @@ export function convertToOpenAiMessages(
 			// will convert a single text block into a string for compactness.
 			// If a message also contains reasoning_details (Gemini 3 / xAI / o-series, etc.),
 			// we must preserve it here as well.
-			const messageWithDetails = anthropicMessage as any
-			const baseMessage: OpenAI.Chat.ChatCompletionMessageParam & {
-				reasoning_details?: any[]
-				reasoning_content?: string
-			} = {
+			const messageWithDetails = anthropicMessage as AssistantMessageWithReasoning
+			const baseMessage: OpenAI.Chat.ChatCompletionMessageParam & ReasoningPassthroughFields = {
 				role: anthropicMessage.role,
 				content: anthropicMessage.content,
 			}
 
 			if (anthropicMessage.role === "assistant") {
 				const mapped = mapReasoningDetails(messageWithDetails.reasoning_details)
 				if (mapped) {
-					;(baseMessage as any).reasoning_details = mapped
+					baseMessage.reasoning_details = mapped
 				}
 				// Pass through reasoning_content for DeepSeek / Z.ai thinking mode.
 				if (typeof messageWithDetails.reasoning_content === "string" && messageWithDetails.reasoning_content) {
@@ -457,7 +500,7 @@ export function convertToOpenAiMessages(
 					}
 				}
 			} else if (anthropicMessage.role === "assistant") {
-				const messageWithDetails = anthropicMessage as any
+				const messageWithDetails = anthropicMessage as AssistantMessageWithReasoning
 
 				let extractedReasoning: string | undefined
 				const { nonToolMessages, toolMessages } = anthropicMessage.content.reduce<{
@@ -469,14 +512,17 @@ export function convertToOpenAiMessages(
 							acc.toolMessages.push(part)
 						} else if (part.type === "text" || part.type === "image") {
 							acc.nonToolMessages.push(part)
-						} else if ((part as any).type === "reasoning" && (part as any).text) {
-							// Extract reasoning stored as a content block (DeepSeek / Z.ai interleaved thinking).
-							// Must be passed back as top-level reasoning_content so providers like DeepSeek
-							// don't reject the request with "reasoning_content must be passed back to the API".
-							// Accumulate all blocks (a turn may have more than one) to preserve order.
-							extractedReasoning = extractedReasoning
-								? extractedReasoning + (part as any).text
-								: (part as any).text
+						} else {
+							const reasoningText = getReasoningBlockText(part)
+							if (reasoningText) {
+								// Extract reasoning stored as a content block (DeepSeek / Z.ai interleaved thinking).
+								// Must be passed back as top-level reasoning_content so providers like DeepSeek
+								// don't reject the request with "reasoning_content must be passed back to the API".
+								// Accumulate all blocks (a turn may have more than one) to preserve order.
+								extractedReasoning = extractedReasoning
+									? extractedReasoning + reasoningText
+									: reasoningText
+							}
 						} // assistant cannot send tool_result messages
 						return acc
 					},
@@ -510,10 +556,7 @@ export function convertToOpenAiMessages(
 				// Build message with reasoning_details BEFORE tool_calls to preserve
 				// the order expected by providers like Roo. Property order matters
 				// when sending messages back to some APIs.
-				const baseMessage: OpenAI.Chat.ChatCompletionAssistantMessageParam & {
-					reasoning_details?: any[]
-					reasoning_content?: string
-				} = {
+				const baseMessage: OpenAI.Chat.ChatCompletionAssistantMessageParam & ReasoningPassthroughFields = {
 					role: "assistant",
 					// Use empty string instead of undefined for providers like Gemini (via OpenRouter)
 					// that require every message to have content in the "parts" field