@@ -184,15 +184,17 @@ describe("AwsBedrockHandler", () => {
 				content: [
 					{ type: "thinking", thinking: "Signed by MiniMax.", signature: "minimax-signature" },
 					{ type: "text", text: "Done." },
+					{ type: "tool_use", id: "t1", name: "read_file", input: {} },
 				],
 			},
-			{ role: "user", content: "next" },
+			{ role: "user", content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }] },
 		] as Anthropic.Messages.MessageParam[]
 		await collectStream(provider.createMessage("system", history))
 		const [{ messages }] = mockConverseStreamCommand.mock.lastCall!
 		expect(messages?.[1].content).toStrictEqual([
 			...(kept ? [{ reasoningContent: { reasoningText: { text: "Signed by MiniMax." } } }] : []),
 			{ text: "Done." },
+			{ toolUse: { toolUseId: "t1", name: "read_file", input: {} } },
 		])
 	})
 
 
@@ -50,6 +50,21 @@ describe("convertToBedrockConverseMessages", () => {
 		])
 	})
 
+	it("replays reasoning into a tool_result continuation but drops it before a new user message", () => {
+		const reasoning = { type: "reasoning", text: "Plan.", summary: [] }
+		const messages = [
+			{ role: "assistant", content: [reasoning, { type: "tool_use", id: "t1", name: "read", input: {} }] },
+			{ role: "user", content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }] },
+			{ role: "assistant", content: [reasoning, { type: "text", text: "Done." }] },
+			{ role: "user", content: [{ type: "text", text: "next" }] },
+		] as unknown as Anthropic.Messages.MessageParam[]
+
+		const result = convertToBedrockConverseMessages(messages, { preserveReasoning: true })
+
+		expect(result[0].content?.[0]).toEqual({ reasoningContent: { reasoningText: { text: "Plan." } } })
+		expect(result[2].content).toEqual([{ text: "Done." }])
+	})
+
 	it("drops reasoning and thinking blocks for models that do not preserve reasoning", () => {
 		// Signed thinking bypasses Task's reasoning filter, so the converter must not send it to e.g. Claude.
 		const messages = [
 
@@ -27,14 +27,15 @@ interface BedrockMessageContent {
 /**
  * Convert Anthropic messages to Bedrock Converse format
  * @param anthropicMessages Messages in Anthropic format
- * @param options.preserveReasoning Replay reasoning/thinking blocks as `reasoningContent`.
+ * @param options.preserveReasoning Replay reasoning/thinking blocks as `reasoningContent` while a tool loop
+ *   continues; reasoning followed by a new user message is dropped.
  *   Otherwise they are dropped, matching Task's stripping for models without `preserveReasoning`.
  */
 export function convertToBedrockConverseMessages(
 	anthropicMessages: Anthropic.Messages.MessageParam[],
 	{ preserveReasoning = false }: { preserveReasoning?: boolean } = {},
 ): Message[] {
-	return anthropicMessages.map((anthropicMessage) => {
+	return anthropicMessages.map((anthropicMessage, index) => {
 		// Map Anthropic roles to Bedrock roles
 		const role: ConversationRole = anthropicMessage.role === "assistant" ? "assistant" : "user"
 
@@ -52,12 +53,19 @@ export function convertToBedrockConverseMessages(
 		// Signed thinking blocks (e.g. from MiniMax) bypass Task's reasoning filter, so they can reach
 		// any Bedrock model after a provider switch. Unsigned reasoning is only safe for models that
 		// opt in; Claude would receive thinking it cannot verify.
-		const blocks = preserveReasoning
-			? anthropicMessage.content
-			: anthropicMessage.content.filter((block) => {
-					const type = (block as { type: string }).type
-					return type !== "reasoning" && type !== "thinking"
-				})
+		// Reasoning continuity only spans a tool loop: a following new user message ends it.
+		const next = anthropicMessages[index + 1]
+		const endsAtNewUserMessage =
+			next?.role === "user" &&
+			(typeof next.content === "string" ||
+				!next.content.some((block) => (block as { type: string }).type === "tool_result"))
+		const blocks =
+			preserveReasoning && !endsAtNewUserMessage
+				? anthropicMessage.content
+				: anthropicMessage.content.filter((block) => {
+						const type = (block as { type: string }).type
+						return type !== "reasoning" && type !== "thinking"
+					})
 
 		// Process complex content types
 		const content = blocks.map((block) => {