@xynogen/pix-pretty 1.0.0 → 1.2.0

package/package.json

@@ -1,54 +1,55 @@
 {
-  "name": "@xynogen/pix-pretty",
-  "version": "1.0.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",
-  "scripts": {
-    "test": "bun test"
-  },
-  "files": [
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "pi": {
-    "extensions": [
-      "./src/index.ts",
-      "./src/paste-chips.ts",
-      "./src/thinking.ts"
-    ]
-  },
-  "keywords": [
-    "pi",
-    "pi-package",
-    "pi-extension",
-    "syntax-highlighting",
-    "fff",
-    "paste-chips",
-    "tool-rendering"
-  ],
-  "author": "xynogen",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/xynogen/pix-mono.git",
-    "directory": "packages/pix-pretty"
-  },
-  "homepage": "https://github.com/xynogen/pix-mono/tree/main/packages/pix-pretty#readme",
-  "bugs": {
-    "url": "https://github.com/xynogen/pix-mono/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "cli-highlight": "^2.1.11",
-    "@ff-labs/fff-node": "^0.5.2",
-    "diff": "^7.0.0"
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
-  }
+	"name": "@xynogen/pix-pretty",
+	"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",
+	"scripts": {
+		"test": "bun test"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./src/index.ts",
+			"./src/paste-chips.ts",
+			"./src/thinking.ts"
+		]
+	},
+	"keywords": [
+		"pi",
+		"pi-package",
+		"pi-extension",
+		"syntax-highlighting",
+		"fff",
+		"paste-chips",
+		"tool-rendering"
+	],
+	"author": "xynogen",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/xynogen/pix-mono.git",
+		"directory": "packages/pix-pretty"
+	},
+	"homepage": "https://github.com/xynogen/pix-mono/tree/main/packages/pix-pretty#readme",
+	"bugs": {
+		"url": "https://github.com/xynogen/pix-mono/issues"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"dependencies": {
+		"cli-highlight": "^2.1.11",
+		"@ff-labs/fff-node": "^0.5.2",
+		"diff": "^7.0.0"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	}
 }

package/src/index.test.ts

@@ -2,7 +2,7 @@
  * Basic smoke tests for pix-pretty extensions
  */
 
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 
 describe("pix-pretty", () => {
 	it("exports are valid TypeScript modules", () => {

package/src/index.ts

@@ -920,7 +920,7 @@ export default function piPrettyExtension(
 	// SDK grep fallback otherwise)
 	// ===================================================================
 
-	if ((fffState.module || createGrepTool)) {
+	if (fffState.module || createGrepTool) {
 		const multiGrepFallback = createGrepTool ? createGrepTool(cwd) : null;
 
 		pi.registerTool({
@@ -1269,9 +1269,12 @@ export default function piPrettyExtension(
 			) {
 				const fp = params.path ?? params.file_path ?? "";
 				const operations = getEditOperations(params);
+				// params is the live tool input (upstream EditToolInput shape); we
+				// type it loosely as EditParams for defensive legacy-field reads, so
+				// cast back to the upstream input when delegating to the real tool.
 				const result = (await origEdit.execute(
 					tid,
-					params,
+					params as unknown as Parameters<typeof origEdit.execute>[1],
 					sig,
 					upd,
 					ctx,
@@ -1409,7 +1412,7 @@ export default function piPrettyExtension(
 
 				const result = (await origWrite.execute(
 					tid,
-					params,
+					params as unknown as Parameters<typeof origWrite.execute>[1],
 					sig,
 					upd,
 					ctx,

package/src/paste-chips.test.ts

@@ -6,7 +6,7 @@
  * See: pi-crash.log — "Rendered line 38 exceeds terminal width (285 > 283)"
  */
 
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { restyleMarkers } from "./paste-chips";
 

package/src/paste-chips.ts

@@ -13,14 +13,22 @@
  * The display rewrite is purely visual (render layer); buffer is untouched.
  */
 
-import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import type {
-	EditorFactory,
 	ExtensionAPI,
 	KeybindingsManager,
 } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+// Upstream stopped re-exporting `EditorFactory` from the package entry point,
+// so we reconstruct its signature locally from the still-exported primitives.
+// This matches ctx.ui.setEditorComponent's expected factory shape.
+type EditorFactory = (
+	tui: TUI,
+	theme: EditorTheme,
+	keybindings: KeybindingsManager,
+) => CustomEditor;
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
@@ -121,10 +129,6 @@ export function restyleMarkers(line: string, imageIds: Set<number>): string {
 class ChipEditor extends CustomEditor {
 	private readonly imageIds = new Set<number>();
 
-	constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
-		super(tui, theme, keybindings);
-	}
-
 	override insertTextAtCursor(text: string): void {
 		const internals = this as unknown as EditorInternals;
 		super.insertTextAtCursor(replaceImagePaths(text, internals, this.imageIds));

package/src/thinking.test.ts

@@ -1,223 +1,251 @@
 /**
- * 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, it, expect } from "bun:test";
-import { renderThinking } from "./thinking";
+import { describe, expect, it } from "bun:test";
+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 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("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("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("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("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);
+			expect(splitThinking(input)).toEqual([{ type: "text", text: 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(">");
+	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("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("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" },
+			]);
 		});
+	});
 
-		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(">");
+	describe("streaming (partial tail tags)", () => {
+		it("strips a half-streamed opening tag", () => {
+			expect(stripPartialTailTag("Hello <thin")).toBe("Hello ");
+			expect(stripPartialTailTag("Hello <")).toBe("Hello ");
+			expect(stripPartialTailTag("Hello <thinking")).toBe("Hello ");
 		});
 
-		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(">");
+		it("strips a half-streamed closing tag", () => {
+			expect(stripPartialTailTag("reasoning </thinkin")).toBe("reasoning ");
+			expect(stripPartialTailTag("reasoning </")).toBe("reasoning ");
 		});
-	});
 
-	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");
+		it("keeps non-reasoning partial tags", () => {
+			expect(stripPartialTailTag("a generic <div")).toBe("a generic <div");
+			expect(stripPartialTailTag("math: 1 < 2")).toBe("math: 1 < 2");
 		});
 
-		it("removes leading whitespace", () => {
-			const input = "   \n  \n  Text";
-			const output = renderThinking(input);
-			expect(output).toBe("Text");
+		it("keeps complete tags (only the trailing fragment is stripped)", () => {
+			expect(stripPartialTailTag("<thinking>body")).toBe("<thinking>body");
 		});
 
-		it("preserves necessary newlines", () => {
-			const input = "Line 1\n\nLine 2";
-			const output = renderThinking(input);
-			expect(output).toBe(input);
+		it("emits a thinking block for an open span before the close arrives", () => {
+			const midStream = "<thinking>I am reasoning about";
+			const out = splitThinking(stripPartialTailTag(midStream));
+			expect(out).toEqual([
+				{ type: "thinking", thinking: "I am reasoning about" },
+			]);
 		});
-	});
 
-	describe("edge cases", () => {
-		it("handles empty string", () => {
-			const input = "";
-			const output = renderThinking(input);
-			expect(output).toBe("");
+		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 = splitThinking(
+				stripPartialTailTag("<think>step one and two</think>\n\nAnswer"),
+			);
+			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" },
+			]);
 		});
+	});
 
-		it("handles string with only whitespace", () => {
-			const input = "   \n  \n  ";
-			const output = renderThinking(input);
-			expect(output).toBe("");
+	describe("edge cases", () => {
+		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,22 +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:
- *   - Do nothing during streaming (no live mutation, no polling, no races).
- *   - On `message_end`, extract and reformat every reasoning block with
- *     visual markers, then return the styled message via the supported
- *     replacement channel.
+ *   - 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.
  *
- * `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.
+ *     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 rebuilt
+ *     content is what gets rendered live.
+ *
+ *   - 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.)
+ *
+ * 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.
  */
@@ -38,63 +54,154 @@ 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[];
 }
 
-// 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`;
+// Trailing half-streamed tag, e.g. "<", "</", "<thin", "</thinkin".
+// Only used during streaming so an incomplete tag never flashes as text.
+const PARTIAL_TAIL_RE = /<\/?([a-zA-Z]*)$/;
+
+function stripPartialTailTag(text: string): string {
+	const match = text.match(PARTIAL_TAIL_RE);
+	if (!match) return text;
+	const fragment = match[1].toLowerCase();
+	if (TAG_NAMES.some((tag) => tag.startsWith(fragment))) {
+		return text.slice(0, match.index);
+	}
+	return 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");
-	});
+// 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);
+}
 
-	// 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 pushText(blocks: Block[], text: string): void {
+	const trimmed = text.trim();
+	if (trimmed) blocks.push({ type: "text", text: trimmed });
+}
 
-	// Clean up any orphan tags
-	text = text.replace(ORPHAN_TAG_RE, "");
+function pushThinking(blocks: Block[], thinking: string): void {
+	const trimmed = thinking.trim();
+	if (trimmed) blocks.push({ type: "thinking", thinking: trimmed });
+}
 
-	// Clean up excessive newlines
-	return text.replace(/\n{4,}/g, "\n\n\n").replace(/^\s+/, "");
+/**
+ * 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);
+	}
+
+	// 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, ""));
+	}
+
+	// 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 };
+export { splitThinking, stripPartialTailTag };
 
 export default function thinkingExtension(pi: ExtensionAPI) {
+	// 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;
+			assistantMessageEvent?: { type?: string };
+		};
+		const msg = ev.message;
+		if (msg?.role !== "assistant" || !Array.isArray(msg.content)) return;
+
+		// Only text stream events can change text blocks; skip toolcall/thinking
+		// channel deltas to avoid pointless re-renders.
+		const streamType = ev.assistantMessageEvent?.type;
+		if (streamType && !streamType.startsWith("text_")) return;
+
+		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];
+			// Strip a half-streamed tag so it never flashes as literal text.
+			const stripped = stripPartialTailTag(tb.text);
+			// Nothing reasoning-related: leave unrelated "<" text alone entirely.
+			if (!hasReasoningTag(stripped) && stripped === tb.text) return [block];
+			// New objects — never mutate the provider's accumulating block.
+			return splitThinking(stripped);
+		});
+	});
+
 	pi.on("message_end", (event) => {
 		const msg = (event as { message?: Msg }).message;
-		if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content)) return;
+		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 };
+		}
 	});
 }

package/src/types.ts

@@ -161,9 +161,35 @@ export type ReadParams = ReadToolInput;
 
 export type BashParams = BashToolInput;
 
-export type EditParams = EditToolInput;
+// The defensive renderers below accept several legacy / alternate field names
+// (snake_case + singular shapes) that upstream's strict tool-input types no
+// longer declare. We model the full accepted superset here so the runtime
+// fallbacks stay type-safe. These are intentionally standalone (not an
+// intersection with EditToolInput/WriteToolInput) because the upstream `edits`
+// element type is narrower and would conflict with the legacy item shape.
+export type EditOperationInput = {
+	oldText?: string;
+	newText?: string;
+	old_text?: string;
+	new_text?: string;
+};
+
+export type EditParams = {
+	path?: string;
+	file_path?: string;
+	edits?: EditOperationInput[];
+} & EditOperationInput;
+
+export type WriteParams = {
+	path?: string;
+	file_path?: string;
+	content?: string;
+};
 
-export type WriteParams = WriteToolInput;
+// Keep a reference to the upstream input types so the import stays meaningful
+// and future drift is visible at this seam.
+export type UpstreamEditToolInput = EditToolInput;
+export type UpstreamWriteToolInput = WriteToolInput;
 
 // A single old→new replacement extracted from an edit tool call (supports both
 // the single oldText/newText shape and the batched `edits[]` shape).