@xynogen/pix-pretty 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, FFF search, and paste chip formatting",
 	"type": "module",
 	"main": "src/index.ts",

package/src/thinking.test.ts

@@ -1,190 +1,181 @@
 /**
- * Tests for thinking tag rendering
+ * Tests for leaked-reasoning splitting into native content blocks.
+ *
+ * splitThinking() turns leaked `<think>`/`<thinking>` spans into real
+ * `thinking` content blocks (rendered dim + italic by pi's native
+ * `thinkingText` styling) while keeping surrounding answer text as `text`
+ * blocks.
  */
 
 import { describe, expect, it } from "bun:test";
-import { renderThinking, stripPartialTailTag } from "./thinking";
+import { splitThinking, stripPartialTailTag } from "./thinking";
 
-describe("thinking tag rendering", () => {
+type Block = { type: string; text?: string; thinking?: string };
+
+function texts(blocks: Block[]): string[] {
+	return blocks.filter((b) => b.type === "text").map((b) => b.text ?? "");
+}
+function thinkings(blocks: Block[]): string[] {
+	return blocks
+		.filter((b) => b.type === "thinking")
+		.map((b) => b.thinking ?? "");
+}
+
+describe("splitThinking", () => {
 	describe("closed thinking blocks", () => {
-		it("renders basic <thinking> block as blockquote", () => {
-			const input = "<thinking>This is reasoning</thinking>";
-			const output = renderThinking(input);
-			expect(output).toBe(`> This is reasoning\n\n`);
+		it("turns a <thinking> span into a thinking block", () => {
+			const out = splitThinking("<thinking>This is reasoning</thinking>");
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "This is reasoning" },
+			]);
 		});
 
-		it("renders basic <think> block as blockquote", () => {
-			const input = "<think>This is reasoning</think>";
-			const output = renderThinking(input);
-			expect(output).toBe(`> This is reasoning\n\n`);
+		it("turns a <think> span into a thinking block", () => {
+			const out = splitThinking("<think>This is reasoning</think>");
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "This is reasoning" },
+			]);
 		});
 
-		it("renders multi-line thinking block as blockquote", () => {
-			const input = "<thinking>Line 1\nLine 2\nLine 3</thinking>";
-			const output = renderThinking(input);
-			expect(output).toBe(`> Line 1\n> Line 2\n> Line 3\n\n`);
+		it("preserves multi-line reasoning inside one thinking block", () => {
+			const out = splitThinking("<thinking>Line 1\nLine 2\nLine 3</thinking>");
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "Line 1\nLine 2\nLine 3" },
+			]);
 		});
 
-		it("renders multiple thinking blocks", () => {
-			const input =
-				"<thinking>First block</thinking> Some text <thinking>Second block</thinking>";
-			const output = renderThinking(input);
-			expect(output).toContain("First block");
-			expect(output).toContain("Second block");
-			expect(output).toContain("Some text");
-			expect(output).toContain(">");
+		it("emits one thinking block per closed span in order", () => {
+			const out = splitThinking(
+				"<thinking>First block</thinking> Some text <thinking>Second block</thinking>",
+			);
+			expect(thinkings(out)).toEqual(["First block", "Second block"]);
+			expect(texts(out)).toEqual(["Some text"]);
 		});
 
-		it("removes empty thinking blocks", () => {
-			const input = "Before <thinking></thinking> After";
-			const output = renderThinking(input);
-			expect(output).not.toContain("thinking");
-			expect(output).toContain("Before");
-			expect(output).toContain("After");
+		it("drops empty thinking spans", () => {
+			const out = splitThinking("Before <thinking></thinking> After");
+			expect(thinkings(out)).toEqual([]);
+			expect(texts(out).join(" ")).toContain("Before");
+			expect(texts(out).join(" ")).toContain("After");
 		});
 
-		it("removes thinking blocks with only whitespace", () => {
-			const input = "Before <thinking>   \n  </thinking> After";
-			const output = renderThinking(input);
-			expect(output).not.toContain(">");
-			expect(output).toContain("Before");
-			expect(output).toContain("After");
+		it("drops whitespace-only thinking spans", () => {
+			const out = splitThinking("Before <thinking>   \n  </thinking> After");
+			expect(thinkings(out)).toEqual([]);
 		});
 
 		it("trims whitespace from thinking content", () => {
-			const input = "<thinking>\n  This is reasoning  \n</thinking>";
-			const output = renderThinking(input);
-			expect(output).toBe(`> This is reasoning\n\n`);
+			const out = splitThinking(
+				"<thinking>\n  This is reasoning  \n</thinking>",
+			);
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "This is reasoning" },
+			]);
 		});
 
 		it("handles mixed case tag names", () => {
-			const input =
-				"<THINKING>uppercase</THINKING> <ThInKiNg>mixedcase</ThInKiNg>";
-			const output = renderThinking(input);
-			expect(output).toContain("uppercase");
-			expect(output).toContain("mixedcase");
-			expect(output).toContain(">");
+			const out = splitThinking(
+				"<THINKING>uppercase</THINKING> <ThInKiNg>mixedcase</ThInKiNg>",
+			);
+			expect(thinkings(out)).toEqual(["uppercase", "mixedcase"]);
 		});
 	});
 
 	describe("dangling/unclosed blocks", () => {
-		it("renders dangling <thinking> block at end of text", () => {
-			const input = "Some text <thinking>Reasoning without close tag";
-			const output = renderThinking(input);
-			expect(output).toContain("Reasoning without close tag");
-			expect(output).toContain("Some text");
-			expect(output).toContain(">");
+		it("treats a trailing <thinking> as a thinking block", () => {
+			const out = splitThinking("Some text <thinking>Reasoning without close");
+			expect(texts(out)).toEqual(["Some text"]);
+			expect(thinkings(out)).toEqual(["Reasoning without close"]);
 		});
 
-		it("renders dangling <think> block at end of text", () => {
-			const input = "Some text <think>Reasoning without close tag";
-			const output = renderThinking(input);
-			expect(output).toContain("Reasoning without close tag");
-			expect(output).toContain("Some text");
-			expect(output).toContain(">");
+		it("treats a trailing <think> as a thinking block", () => {
+			const out = splitThinking("Some text <think>Reasoning without close");
+			expect(texts(out)).toEqual(["Some text"]);
+			expect(thinkings(out)).toEqual(["Reasoning without close"]);
 		});
 
-		it("does not treat mid-text unclosed tag as dangling", () => {
-			// Only dangling blocks at the END of text are processed by OPEN_TAIL_RE
-			const input = "<thinking>Unclosed\nMore text after";
-			const output = renderThinking(input);
-			expect(output).toContain(">");
+		it("captures the remainder of a leading unclosed tag as reasoning", () => {
+			const out = splitThinking("<thinking>Unclosed\nMore text after");
+			expect(thinkings(out)).toEqual(["Unclosed\nMore text after"]);
+			expect(texts(out)).toEqual([]);
 		});
 	});
 
 	describe("orphan tags", () => {
-		it("removes orphan closing tags", () => {
-			const input = "Some text </thinking> more text";
-			const output = renderThinking(input);
-			expect(output).not.toContain("</thinking>");
-			expect(output).not.toContain("<thinking>");
-			expect(output).toContain("Some text");
-			expect(output).toContain("more text");
+		it("removes orphan closing tags from text", () => {
+			const out = splitThinking("Some text </thinking> more text");
+			const joined = texts(out).join(" ");
+			expect(joined).not.toContain("</thinking>");
+			expect(joined).not.toContain("<thinking>");
+			expect(joined).toContain("Some text");
+			expect(joined).toContain("more text");
 		});
 
-		it("removes orphan opening tags after processing blocks", () => {
-			const input = "Text <think> orphan tag";
-			const output = renderThinking(input);
-			expect(output).not.toContain("<think>");
-			expect(output).toContain("Text");
+		it("treats a trailing open tag as a (possibly empty) reasoning span", () => {
+			const out = splitThinking("Text <think> orphan tag");
+			expect(texts(out)).toEqual(["Text"]);
+			expect(thinkings(out)).toEqual(["orphan tag"]);
 		});
 
-		it("removes multiple orphan tags", () => {
-			const input = "</thinking> text </think> more <thinking> stuff </think>";
-			const output = renderThinking(input);
-			// Note: <thinking> at the end is treated as dangling block, creating a blockquote
-			expect(output).not.toContain("<thinking>");
-			expect(output).not.toContain("</thinking>");
-			expect(output).not.toContain("</think>");
-			expect(output).toContain("text");
-			expect(output).toContain("stuff");
+		it("handles multiple orphan tags", () => {
+			const out = splitThinking(
+				"</thinking> text </think> more <thinking> stuff </think>",
+			);
+			const joined = texts(out).join(" ");
+			expect(joined).not.toContain("<thinking>");
+			expect(joined).not.toContain("</thinking>");
+			expect(joined).not.toContain("</think>");
+			expect(joined).toContain("text");
+			expect(thinkings(out).join(" ")).toContain("stuff");
 		});
 	});
 
 	describe("text without thinking tags", () => {
-		it("returns text unchanged when no thinking tags present", () => {
+		it("returns the original text block unchanged", () => {
 			const input = "This is regular text without any tags";
-			const output = renderThinking(input);
-			expect(output).toBe(input);
+			expect(splitThinking(input)).toEqual([{ type: "text", text: input }]);
 		});
 
-		it("preserves markdown formatting", () => {
+		it("preserves markdown formatting verbatim", () => {
 			const input = "# Header\n\n**bold** and *italic*";
-			const output = renderThinking(input);
-			expect(output).toBe(input);
-		});
-	});
-
-	describe("mixed content", () => {
-		it("preserves text before thinking block", () => {
-			const input = "Response text here\n\n<thinking>reasoning</thinking>";
-			const output = renderThinking(input);
-			expect(output).toContain("Response text here");
-			expect(output).toContain("reasoning");
-			expect(output).toContain(">");
-		});
-
-		it("preserves text after thinking block", () => {
-			const input = "<thinking>reasoning</thinking>\n\nMore response text";
-			const output = renderThinking(input);
-			expect(output).toContain("reasoning");
-			expect(output).toContain("More response text");
-			expect(output).toContain(">");
-		});
-
-		it("preserves text between multiple thinking blocks", () => {
-			const input =
-				"<thinking>first</thinking>\n\nMiddle text\n\n<thinking>second</thinking>";
-			const output = renderThinking(input);
-			expect(output).toContain("first");
-			expect(output).toContain("Middle text");
-			expect(output).toContain("second");
-			expect(output).toContain(">");
+			expect(splitThinking(input)).toEqual([{ type: "text", text: input }]);
 		});
 	});
 
-	describe("newline cleanup", () => {
-		it("reduces excessive newlines to maximum of 3", () => {
-			const input = "Text\n\n\n\n\n\nMore text";
-			const output = renderThinking(input);
-			expect(output).not.toContain("\n\n\n\n");
-			expect(output).toBe("Text\n\n\nMore text");
+	describe("mixed content order", () => {
+		it("keeps text before a thinking block", () => {
+			const out = splitThinking(
+				"Response text here\n\n<thinking>reasoning</thinking>",
+			);
+			expect(out).toEqual([
+				{ type: "text", text: "Response text here" },
+				{ type: "thinking", thinking: "reasoning" },
+			]);
 		});
 
-		it("removes leading whitespace", () => {
-			const input = "   \n  \n  Text";
-			const output = renderThinking(input);
-			expect(output).toBe("Text");
+		it("keeps text after a thinking block", () => {
+			const out = splitThinking(
+				"<thinking>reasoning</thinking>\n\nMore response text",
+			);
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "reasoning" },
+				{ type: "text", text: "More response text" },
+			]);
 		});
 
-		it("preserves necessary newlines", () => {
-			const input = "Line 1\n\nLine 2";
-			const output = renderThinking(input);
-			expect(output).toBe(input);
+		it("keeps text between multiple thinking blocks in order", () => {
+			const out = splitThinking(
+				"<thinking>first</thinking>\n\nMiddle text\n\n<thinking>second</thinking>",
+			);
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "first" },
+				{ type: "text", text: "Middle text" },
+				{ type: "thinking", thinking: "second" },
+			]);
 		});
 	});
 
-	describe("streaming (partial tail tags + live rendering)", () => {
+	describe("streaming (partial tail tags)", () => {
 		it("strips a half-streamed opening tag", () => {
 			expect(stripPartialTailTag("Hello <thin")).toBe("Hello ");
 			expect(stripPartialTailTag("Hello <")).toBe("Hello ");
@@ -205,63 +196,56 @@ describe("thinking tag rendering", () => {
 			expect(stripPartialTailTag("<thinking>body")).toBe("<thinking>body");
 		});
 
-		it("renders an open block as blockquote before close tag arrives", () => {
-			// Simulates mid-stream state: open tag + partial body, no close tag.
+		it("emits a thinking block for an open span before the close arrives", () => {
 			const midStream = "<thinking>I am reasoning about";
-			const output = renderThinking(stripPartialTailTag(midStream));
-			expect(output).toBe("> I am reasoning about\n\n");
+			const out = splitThinking(stripPartialTailTag(midStream));
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "I am reasoning about" },
+			]);
 		});
 
-		it("renders progressively without flashing partial close tag", () => {
-			const step1 = renderThinking(stripPartialTailTag("<think>step one"));
-			const step2 = renderThinking(
+		it("renders progressively without flashing a partial close tag", () => {
+			const step1 = splitThinking(stripPartialTailTag("<think>step one"));
+			const step2 = splitThinking(
 				stripPartialTailTag("<think>step one and two</thi"),
 			);
-			const step3 = renderThinking(
+			const step3 = splitThinking(
 				stripPartialTailTag("<think>step one and two</think>\n\nAnswer"),
 			);
-			expect(step1).toBe("> step one\n\n");
-			expect(step2).toBe("> step one and two\n\n");
-			expect(step3).toContain("> step one and two");
-			expect(step3).toContain("Answer");
-			expect(step3).not.toContain("<think>");
+			expect(step1).toEqual([{ type: "thinking", thinking: "step one" }]);
+			expect(step2).toEqual([
+				{ type: "thinking", thinking: "step one and two" },
+			]);
+			expect(step3).toEqual([
+				{ type: "thinking", thinking: "step one and two" },
+				{ type: "text", text: "Answer" },
+			]);
 		});
 	});
 
 	describe("edge cases", () => {
-		it("handles empty string", () => {
-			const input = "";
-			const output = renderThinking(input);
-			expect(output).toBe("");
-		});
-
-		it("handles string with only whitespace", () => {
-			const input = "   \n  \n  ";
-			const output = renderThinking(input);
-			expect(output).toBe("");
+		it("returns a single text block for an empty string", () => {
+			expect(splitThinking("")).toEqual([{ type: "text", text: "" }]);
 		});
 
-		it("handles nested-looking tags (not actually nested in HTML sense)", () => {
-			const input =
-				"<thinking>outer <thinking>inner</thinking> outer</thinking>";
-			const output = renderThinking(input);
-			// Regex will match first <thinking>...</thinking> pair
-			expect(output).toContain(">");
+		it("collapses an all-empty reasoning message to one empty text block", () => {
+			expect(splitThinking("<thinking></thinking>")).toEqual([
+				{ type: "text", text: "" },
+			]);
 		});
 
 		it("handles thinking content with special characters", () => {
-			const input = "<thinking>Special chars: $@#%^&*()</thinking>";
-			const output = renderThinking(input);
-			expect(output).toContain("Special chars: $@#%^&*()");
-			expect(output).toContain(">");
+			const out = splitThinking(
+				"<thinking>Special chars: $@#%^&*()</thinking>",
+			);
+			expect(thinkings(out)).toEqual(["Special chars: $@#%^&*()"]);
 		});
 
 		it("handles thinking content with code-like syntax", () => {
-			const input = "<thinking>const x = 5;\nreturn x + 1;</thinking>";
-			const output = renderThinking(input);
-			expect(output).toContain("const x = 5;");
-			expect(output).toContain("return x + 1;");
-			expect(output).toContain(">");
+			const out = splitThinking(
+				"<thinking>const x = 5;\nreturn x + 1;</thinking>",
+			);
+			expect(thinkings(out)).toEqual(["const x = 5;\nreturn x + 1;"]);
 		});
 	});
 });

package/src/thinking.ts

@@ -1,37 +1,38 @@
 /**
- * Render leaked reasoning tags as styled, visually distinct blocks.
+ * Convert leaked reasoning tags into native `thinking` content blocks.
  *
  * Some openai-compatible providers leak raw <think>/<thinking> tags into the
  * visible assistant `content[].text` (the real reasoning travels the proper
- * `reasoning_content` channel). Instead of stripping them, we render them
- * with clear visual styling so they're useful for debugging but don't
- * interfere with the actual response.
+ * `reasoning_content` channel). Instead of stripping or restyling them, we
+ * split each affected text block into ordered `text` + `thinking` content
+ * blocks. Pi renders `thinking` blocks dim + italic via the `thinkingText`
+ * theme token natively (see assistant-message.ts) — no ANSI injection, no
+ * markdown blockquote shim.
  *
  * Approach:
- *   - During streaming (`message_update`), re-render the event's message so
- *     reasoning blocks appear as styled blockquotes the moment the open tag
- *     streams in — no waiting for the close tag. The dangling-open-block
- *     handling in renderThinking() covers the not-yet-closed case, and a
- *     trailing half-streamed tag (e.g. "<thin") is stripped so it never
+ *   - During streaming (`message_update`), rebuild the event's message so a
+ *     reasoning block appears the moment the open tag streams in — no waiting
+ *     for the close tag. splitThinking() captures the dangling-open case, and
+ *     a trailing half-streamed tag (e.g. "<thin") is stripped so it never
  *     flashes as literal text.
  *
  *     Safety: `event.message` is a per-event shallow copy, but its content
  *     blocks are the provider's LIVE accumulating objects (providers do
  *     `block.text += delta`). We therefore never mutate text blocks in
  *     place — we replace `message.content` with fresh block objects. The
- *     TUI receives the same event object after extensions run, so the
- *     restyled content is what gets rendered live.
+ *     TUI receives the same event object after extensions run, so the rebuilt
+ *     content is what gets rendered live.
  *
- *   - On `message_end`, extract and reformat every reasoning block with
- *     visual markers, then return the styled message via the supported
- *     replacement channel. (The finalized message comes from
- *     `response.result()` — a fresh object that never saw the streaming
- *     restyling — so this step is still required for persistence.)
+ *   - On `message_end`, split every affected text block and return the
+ *     replacement via the supported channel. (The finalized message comes
+ *     from `response.result()` — a fresh object that never saw the streaming
+ *     rebuild — so this step is still required for persistence.)
  *
- * `content[].text` is MARKDOWN rendered by pi's TUI Markdown component.
- * The TUI does NOT parse HTML — <details>/<summary> would render as literal
- * junk text. We use a Markdown BLOCKQUOTE instead, which the TUI renders
- * natively via the `mdQuote`/`mdQuoteBorder` theme tokens.
+ * Persistence trade-off: the replacement is persisted and round-trips to the
+ * provider next turn. The synthesized `thinking` blocks carry no
+ * thinkingSignature (none was received — the reasoning leaked into the text
+ * channel), so signature-validating APIs (e.g. Anthropic) may reject or drop
+ * them on multi-turn. Accepted in exchange for native dim+italic rendering.
  *
  * To add a new tag variant, append to TAG_NAMES below.
  */
@@ -53,7 +54,11 @@ interface TextBlock {
 	type: "text";
 	text: string;
 }
-type Block = TextBlock | { type: string; [k: string]: unknown };
+interface ThinkingBlock {
+	type: "thinking";
+	thinking: string;
+}
+type Block = TextBlock | ThinkingBlock | { type: string; [k: string]: unknown };
 interface Msg {
 	role?: string;
 	content?: Block[];
@@ -73,41 +78,80 @@ function stripPartialTailTag(text: string): string {
 	return text;
 }
 
-// Render a reasoning body as a markdown blockquote.
-function asQuote(body: string, _label: string): string {
-	const lines = body.split("\n");
-	const quoted = lines.map((line) => `> ${line}`).join("\n");
-	return `\n\n${quoted}\n\n`;
+// Push a text block only when it has visible content. Surrounding whitespace
+// between reasoning and answer text is dropped so the native renderer doesn't
+// emit stray blank paragraphs.
+// True when the text contains any reasoning tag (open, close, or orphan).
+function hasReasoningTag(text: string): boolean {
+	ORPHAN_TAG_RE.lastIndex = 0;
+	return ORPHAN_TAG_RE.test(text);
 }
 
-function renderThinking(text: string): string {
-	// Replace closed blocks with a clearly-marked blockquote
-	text = text.replace(CLOSED_BLOCK_RE, (_match, _tag, content) => {
-		const trimmed = content.trim();
-		if (!trimmed) return "";
-		return asQuote(trimmed, "⚙ Reasoning");
-	});
+function pushText(blocks: Block[], text: string): void {
+	const trimmed = text.trim();
+	if (trimmed) blocks.push({ type: "text", text: trimmed });
+}
 
-	// Replace dangling open blocks (stream cut off before close tag)
-	text = text.replace(OPEN_TAIL_RE, (_match, _tag, content) => {
-		const trimmed = content.trim();
-		if (!trimmed) return "";
-		return asQuote(trimmed, "⚙ Reasoning (incomplete)");
-	});
+function pushThinking(blocks: Block[], thinking: string): void {
+	const trimmed = thinking.trim();
+	if (trimmed) blocks.push({ type: "thinking", thinking: trimmed });
+}
+
+/**
+ * Split leaked reasoning text into ordered native content blocks.
+ *
+ * Reasoning spans (`<think>…</think>`, plus a trailing unclosed `<think>…`)
+ * become real `thinking` blocks, which pi renders dim + italic via the
+ * `thinkingText` theme token — no ANSI injection, no markdown blockquote.
+ * Everything else stays a `text` block. Returns the original single text
+ * block unchanged when no reasoning tags are present.
+ */
+function splitThinking(text: string): Block[] {
+	if (!hasReasoningTag(text)) {
+		return [{ type: "text", text }];
+	}
+
+	const blocks: Block[] = [];
+	let rest = text;
+
+	// Consume closed reasoning blocks left-to-right, preserving order with the
+	// surrounding answer text.
+	CLOSED_BLOCK_RE.lastIndex = 0;
+	let match = CLOSED_BLOCK_RE.exec(rest);
+	while (match) {
+		pushText(blocks, rest.slice(0, match.index));
+		pushThinking(blocks, match[2]);
+		rest = rest.slice(match.index + match[0].length);
+		CLOSED_BLOCK_RE.lastIndex = 0;
+		match = CLOSED_BLOCK_RE.exec(rest);
+	}
 
-	// Clean up any orphan tags
-	text = text.replace(ORPHAN_TAG_RE, "");
+	// A dangling open block (close tag not yet streamed / never emitted): the
+	// remainder after the open tag is reasoning.
+	const openMatch = OPEN_TAIL_RE.exec(rest);
+	if (openMatch) {
+		// Leading text may still carry orphan tags (e.g. a stray `</think>`).
+		pushText(
+			blocks,
+			openMatch.input.slice(0, openMatch.index).replace(ORPHAN_TAG_RE, ""),
+		);
+		pushThinking(blocks, openMatch[2].replace(ORPHAN_TAG_RE, ""));
+	} else {
+		// Strip any orphan tags from the trailing text.
+		pushText(blocks, rest.replace(ORPHAN_TAG_RE, ""));
+	}
 
-	// Clean up excessive newlines
-	return text.replace(/\n{4,}/g, "\n\n\n").replace(/^\s+/, "");
+	// All-empty (e.g. `<think></think>`) collapses to a single empty text block
+	// so the message never becomes contentless.
+	return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
 }
 
 // Export for testing
-export { renderThinking, stripPartialTailTag };
+export { splitThinking, stripPartialTailTag };
 
 export default function thinkingExtension(pi: ExtensionAPI) {
-	// Live styling during streaming: restyle the event's message so reasoning
-	// renders as soon as the open tag appears, token by token.
+	// Live conversion during streaming: rebuild the event's message so a native
+	// thinking block appears as soon as the open tag streams in, token by token.
 	pi.on("message_update", (event) => {
 		const ev = event as {
 			message?: Msg;
@@ -121,19 +165,16 @@ export default function thinkingExtension(pi: ExtensionAPI) {
 		const streamType = ev.assistantMessageEvent?.type;
 		if (streamType && !streamType.startsWith("text_")) return;
 
-		msg.content = msg.content.map((block) => {
-			if (block.type !== "text") return block;
+		msg.content = msg.content.flatMap((block): Block[] => {
+			if (block.type !== "text") return [block];
 			const tb = block as TextBlock;
-			if (typeof tb.text !== "string" || !tb.text.includes("<")) return block;
+			if (typeof tb.text !== "string" || !tb.text.includes("<")) return [block];
+			// Strip a half-streamed tag so it never flashes as literal text.
 			const stripped = stripPartialTailTag(tb.text);
-			const lower = stripped.toLowerCase();
-			const hasTag = TAG_NAMES.some((t) => lower.includes(`<${t}`));
 			// Nothing reasoning-related: leave unrelated "<" text alone entirely.
-			if (!hasTag && stripped === tb.text) return block;
-			const rendered = hasTag ? renderThinking(stripped) : stripped;
-			if (rendered === tb.text) return block;
-			// New object — never mutate the provider's accumulating block.
-			return { ...block, text: rendered };
+			if (!hasReasoningTag(stripped) && stripped === tb.text) return [block];
+			// New objects — never mutate the provider's accumulating block.
+			return splitThinking(stripped);
 		});
 	});
 
@@ -142,19 +183,25 @@ export default function thinkingExtension(pi: ExtensionAPI) {
 		if (msg?.role !== "assistant" || !Array.isArray(msg.content)) return;
 
 		let changed = false;
-		for (const block of msg.content) {
-			if (block.type !== "text") continue;
+		const content = msg.content.flatMap((block): Block[] => {
+			if (block.type !== "text") return [block];
 			const tb = block as TextBlock;
-			if (typeof tb.text !== "string") continue;
-			if (!TAG_NAMES.some((t) => tb.text.includes(`<${t}`))) continue;
-			const rendered = renderThinking(tb.text);
-			if (rendered !== tb.text) {
-				tb.text = rendered;
-				changed = true;
-			}
-		}
+			if (typeof tb.text !== "string") return [block];
+			if (!hasReasoningTag(tb.text)) return [block];
+			changed = true;
+			return splitThinking(tb.text);
+		});
 
-		// Return the replacement so the styled message is what gets persisted.
-		if (changed) return { message: msg as unknown as never };
+		// Return the replacement so the native thinking blocks are persisted.
+		// Persistence note: this rewrites leaked reasoning from `text` into real
+		// `thinking` content blocks, which round-trip to the provider next turn.
+		// The blocks carry no thinkingSignature (we never received one — the
+		// reasoning leaked into the text channel), so signature-validating APIs
+		// may reject or drop them on multi-turn. Accepted trade-off for native
+		// dim+italic rendering via the `thinkingText` theme token.
+		if (changed) {
+			msg.content = content;
+			return { message: msg as unknown as never };
+		}
 	});
 }