@oh-my-pi/pi-coding-agent 16.0.7 → 16.0.8

package/src/markit/converters/pptx.ts

@@ -0,0 +1,325 @@
+// Adapted from markit-ai (MIT). See ../NOTICE.
+import * as path from "node:path";
+import { XMLParser } from "fast-xml-parser";
+import { unzip, unzipText } from "../../utils/zip";
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+
+const EXTENSIONS = [".pptx"];
+const MIMETYPES = ["application/vnd.openxmlformats-officedocument.presentationml.presentation"];
+
+/** A text value: bare string/number, or a `{ "#text" }` node when the element carries attributes. */
+type XmlText = string | number | { "#text"?: string };
+
+interface TextRun {
+	"a:t"?: XmlText;
+}
+interface Paragraph {
+	"a:r"?: TextRun | TextRun[];
+}
+interface TextBody {
+	"a:p"?: Paragraph | Paragraph[];
+}
+interface CNvPr {
+	"@_name": string;
+}
+interface Placeholder {
+	"@_type": string;
+}
+interface NvPr {
+	"p:ph"?: Placeholder;
+}
+interface NvSpPr {
+	"p:cNvPr"?: CNvPr;
+	"p:nvPr"?: NvPr;
+}
+interface NvPicPr {
+	"p:cNvPr"?: CNvPr;
+}
+interface Shape {
+	"p:txBody"?: TextBody;
+	"p:nvSpPr"?: NvSpPr;
+}
+interface Blip {
+	"@_r:embed": string;
+}
+interface BlipFill {
+	"a:blip"?: Blip;
+}
+interface Picture {
+	"p:blipFill"?: BlipFill;
+	"p:nvSpPr"?: NvSpPr;
+	"p:nvPicPr"?: NvPicPr;
+}
+interface TableCell {
+	"a:txBody"?: TextBody;
+}
+interface TableRow {
+	"a:tc"?: TableCell | TableCell[];
+}
+interface Table {
+	"a:tr"?: TableRow | TableRow[];
+}
+interface GraphicData {
+	"a:tbl"?: Table;
+}
+interface Graphic {
+	"a:graphicData"?: GraphicData;
+}
+interface GraphicFrame {
+	"a:graphic"?: Graphic;
+}
+interface SpTree {
+	"p:sp"?: Shape | Shape[];
+	"p:pic"?: Picture | Picture[];
+	"p:graphicFrame"?: GraphicFrame | GraphicFrame[];
+}
+interface CSld {
+	"p:spTree"?: SpTree;
+}
+interface SlideDoc {
+	"p:sld"?: { "p:cSld"?: CSld };
+}
+interface NotesDoc {
+	"p:notes"?: { "p:cSld"?: CSld };
+}
+interface SldId {
+	"@_r:id": string;
+}
+interface PresentationDoc {
+	"p:presentation"?: { "p:sldIdLst"?: { "p:sldId"?: SldId | SldId[] } };
+}
+interface Relationship {
+	"@_Id": string;
+	"@_Target": string;
+}
+interface RelationshipsDoc {
+	Relationships?: { Relationship?: Relationship | Relationship[] };
+}
+
+export class PptxConverter implements Converter {
+	name = "pptx";
+
+	accepts(streamInfo: StreamInfo): boolean {
+		if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension)) return true;
+		if (streamInfo.mimetype && MIMETYPES.some(m => streamInfo.mimetype?.startsWith(m))) return true;
+		return false;
+	}
+
+	async convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult> {
+		const entries = unzip(input);
+		const parser = new XMLParser({
+			ignoreAttributes: false,
+			attributeNamePrefix: "@_",
+			textNodeName: "#text",
+			processEntities: { maxTotalExpansions: 1_000_000 },
+		});
+		// Get slide order from presentation.xml
+		const presXml = unzipText(entries, "ppt/presentation.xml");
+		if (!presXml) throw new Error("Invalid PPTX: missing presentation.xml");
+		const pres = parser.parse(presXml) as PresentationDoc;
+		const sldIdList = pres["p:presentation"]?.["p:sldIdLst"]?.["p:sldId"];
+		const sldIds = Array.isArray(sldIdList) ? sldIdList : sldIdList ? [sldIdList] : [];
+		// Get relationship mappings
+		const relsXml = unzipText(entries, "ppt/_rels/presentation.xml.rels");
+		const rels = relsXml ? (parser.parse(relsXml) as RelationshipsDoc) : null;
+		const relList = rels?.Relationships?.Relationship;
+		const relArray = Array.isArray(relList) ? relList : relList ? [relList] : [];
+		const relMap = new Map<string, string>();
+		for (const r of relArray) {
+			relMap.set(r["@_Id"], r["@_Target"]);
+		}
+		// Map slide IDs to file paths in order
+		const slidePaths: string[] = [];
+		for (const sld of sldIds) {
+			const rId = sld["@_r:id"];
+			const target = relMap.get(rId);
+			if (target) slidePaths.push(`ppt/${target}`);
+		}
+		// If we couldn't resolve from rels, fall back to finding slide files
+		if (slidePaths.length === 0) {
+			const slideFiles = Object.keys(entries)
+				.filter(f => /^ppt\/slides\/slide\d+\.xml$/.test(f))
+				.sort((a, b) => {
+					const na = parseInt(a.match(/slide(\d+)/)?.[1] || "0", 10);
+					const nb = parseInt(b.match(/slide(\d+)/)?.[1] || "0", 10);
+					return na - nb;
+				});
+			slidePaths.push(...slideFiles);
+		}
+		const imageDir = streamInfo.imageDir;
+		const sections: string[] = [];
+		let imageCount = 0;
+		for (let i = 0; i < slidePaths.length; i++) {
+			const slideXml = unzipText(entries, slidePaths[i]);
+			if (!slideXml) continue;
+			const slide = parser.parse(slideXml) as SlideDoc;
+			const spTree = slide["p:sld"]?.["p:cSld"]?.["p:spTree"];
+			if (!spTree) continue;
+			// Parse slide-level rels for image references
+			const slideRelsPath = `${slidePaths[i].replace("slides/slide", "slides/_rels/slide")}.rels`;
+			const slideRelsXml = unzipText(entries, slideRelsPath);
+			const slideRelMap = new Map<string, string>();
+			if (slideRelsXml) {
+				const slideRels = parser.parse(slideRelsXml) as RelationshipsDoc;
+				const relItems = toList(slideRels?.Relationships?.Relationship);
+				for (const r of relItems) {
+					slideRelMap.set(r["@_Id"], r["@_Target"]);
+				}
+			}
+			const slideLines = [`<!-- Slide ${i + 1} -->`];
+			const shapes = spTree["p:sp"];
+			const shapeList = Array.isArray(shapes) ? shapes : shapes ? [shapes] : [];
+			let isTitle = true;
+			for (const shape of shapeList) {
+				const text = this.extractText(shape);
+				if (!text) continue;
+				if (isTitle) {
+					slideLines.push(`# ${text}`);
+					isTitle = false;
+				} else {
+					slideLines.push(text);
+				}
+			}
+			// Extract embedded images
+			const pics = toList(spTree["p:pic"]);
+			for (const pic of pics) {
+				const blipFill = pic["p:blipFill"];
+				const rEmbed = blipFill?.["a:blip"]?.["@_r:embed"];
+				if (!rEmbed) continue;
+				const target = slideRelMap.get(rEmbed);
+				if (!target) continue;
+				// Resolve relative target against slide directory
+				const imagePath = target.startsWith("/") ? target.slice(1) : `ppt/slides/${target}`;
+				// Normalize path (e.g. ppt/slides/../media/image1.png → ppt/media/image1.png)
+				const normalizedPath = imagePath
+					.split("/")
+					.reduce<string[]>((parts, seg) => {
+						if (seg === "..") parts.pop();
+						else parts.push(seg);
+						return parts;
+					}, [])
+					.join("/");
+				const buf = entries[normalizedPath];
+				if (!buf) continue;
+				imageCount++;
+				const name =
+					pic["p:nvSpPr"]?.["p:cNvPr"]?.["@_name"] ||
+					pic["p:nvPicPr"]?.["p:cNvPr"]?.["@_name"] ||
+					`image_${imageCount}`;
+				if (imageDir) {
+					try {
+						const ext = normalizedPath.split(".").pop() || "png";
+						const filename = `slide${i + 1}_${imageCount}.${ext}`;
+						const filepath = path.join(imageDir, filename);
+						await Bun.write(filepath, buf);
+						slideLines.push(`![${name}](${filepath})`);
+					} catch {
+						slideLines.push(`<!-- image: ${name} (slide ${i + 1}) -->`);
+					}
+				} else {
+					slideLines.push(`<!-- image: ${name} (slide ${i + 1}) -->`);
+				}
+			}
+			// Tables
+			const graphicFrames = spTree["p:graphicFrame"];
+			const gfList = Array.isArray(graphicFrames) ? graphicFrames : graphicFrames ? [graphicFrames] : [];
+			for (const gf of gfList) {
+				const table = this.extractTable(gf);
+				if (table) slideLines.push(table);
+			}
+			// Slide notes
+			const noteFile = slidePaths[i].replace("slides/slide", "notesSlides/notesSlide");
+			const noteXml = unzipText(entries, noteFile);
+			if (noteXml) {
+				const note = parser.parse(noteXml) as NotesDoc;
+				const noteSpTree = note["p:notes"]?.["p:cSld"]?.["p:spTree"];
+				if (noteSpTree) {
+					const noteShapes = noteSpTree["p:sp"];
+					const noteList = Array.isArray(noteShapes) ? noteShapes : noteShapes ? [noteShapes] : [];
+					const noteTexts: string[] = [];
+					for (const ns of noteList) {
+						// Skip slide image placeholder
+						const phType = ns["p:nvSpPr"]?.["p:nvPr"]?.["p:ph"]?.["@_type"];
+						if (phType === "sldImg") continue;
+						const t = this.extractText(ns);
+						if (t) noteTexts.push(t);
+					}
+					if (noteTexts.length > 0) {
+						slideLines.push("\n### Notes:");
+						slideLines.push(noteTexts.join("\n"));
+					}
+				}
+			}
+			sections.push(slideLines.join("\n"));
+		}
+		return { markdown: sections.join("\n\n").trim() };
+	}
+
+	extractText(shape: Shape): string {
+		const txBody = shape["p:txBody"];
+		if (!txBody) return "";
+		const paragraphs = txBody["a:p"];
+		const pList = Array.isArray(paragraphs) ? paragraphs : paragraphs ? [paragraphs] : [];
+		const lines: string[] = [];
+		for (const p of pList) {
+			const runs = p["a:r"];
+			const rList = Array.isArray(runs) ? runs : runs ? [runs] : [];
+			const parts: string[] = [];
+			for (const r of rList) {
+				const t = r["a:t"];
+				if (t != null) parts.push(typeof t === "object" ? t["#text"] || "" : String(t));
+			}
+			if (parts.length > 0) lines.push(parts.join(""));
+		}
+		return lines.join("\n").trim();
+	}
+
+	extractTable(gf: GraphicFrame): string | null {
+		const tbl = gf?.["a:graphic"]?.["a:graphicData"]?.["a:tbl"];
+		if (!tbl) return null;
+		const rows = tbl["a:tr"];
+		const rowList = Array.isArray(rows) ? rows : rows ? [rows] : [];
+		if (rowList.length === 0) return null;
+		const mdRows: string[][] = [];
+		for (const row of rowList) {
+			const cells = row["a:tc"];
+			const cellList = Array.isArray(cells) ? cells : cells ? [cells] : [];
+			const cellTexts: string[] = [];
+			for (const cell of cellList) {
+				const txBody = cell["a:txBody"];
+				if (!txBody) {
+					cellTexts.push("");
+					continue;
+				}
+				const paragraphs = txBody["a:p"];
+				const pList = Array.isArray(paragraphs) ? paragraphs : paragraphs ? [paragraphs] : [];
+				const parts: string[] = [];
+				for (const p of pList) {
+					const runs = p["a:r"];
+					const rList = Array.isArray(runs) ? runs : runs ? [runs] : [];
+					for (const r of rList) {
+						const t = r["a:t"];
+						if (t != null) parts.push(typeof t === "object" ? t["#text"] || "" : String(t));
+					}
+				}
+				cellTexts.push(parts.join(" "));
+			}
+			mdRows.push(cellTexts);
+		}
+		if (mdRows.length === 0) return null;
+		const [header, ...body] = mdRows;
+		const lines: string[] = [];
+		lines.push(`| ${header.join(" | ")} |`);
+		lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+		for (const row of body) {
+			while (row.length < header.length) row.push("");
+			lines.push(`| ${row.join(" | ")} |`);
+		}
+		return lines.join("\n");
+	}
+}
+
+function toList<T>(val: T | T[] | undefined): T[] {
+	if (!val) return [];
+	return Array.isArray(val) ? val : [val];
+}

package/src/markit/converters/xlsx.ts

@@ -0,0 +1,173 @@
+// Adapted from markit-ai (MIT). See ../NOTICE.
+import { XMLParser } from "fast-xml-parser";
+import { unzip, unzipText } from "../../utils/zip";
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+
+const EXTENSIONS = [".xlsx"];
+const MIMETYPES = ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"];
+
+/** A text value: bare string/number, or a `{ "#text" }` node when the element carries attributes. */
+type XmlText = string | number | { "#text"?: string };
+
+interface RichTextRun {
+	t?: XmlText;
+}
+interface StringItem {
+	t?: XmlText;
+	r?: RichTextRun | RichTextRun[];
+}
+interface Cell {
+	"@_t"?: string;
+	v?: string | number;
+	is?: StringItem;
+}
+interface Row {
+	c?: Cell | Cell[];
+}
+interface WorksheetDoc {
+	worksheet?: { sheetData?: { row?: Row | Row[] } };
+}
+interface Sheet {
+	"@_name": string;
+	"@_r:id": string;
+}
+interface WorkbookDoc {
+	workbook?: { sheets?: { sheet?: Sheet | Sheet[] } };
+}
+interface SharedStringsDoc {
+	sst?: { si?: StringItem | StringItem[] };
+}
+interface Relationship {
+	"@_Id": string;
+	"@_Target": string;
+}
+interface RelationshipsDoc {
+	Relationships?: { Relationship?: Relationship | Relationship[] };
+}
+
+export class XlsxConverter implements Converter {
+	name = "xlsx";
+
+	accepts(streamInfo: StreamInfo): boolean {
+		if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension)) return true;
+		if (streamInfo.mimetype && MIMETYPES.some(m => streamInfo.mimetype?.startsWith(m))) return true;
+		return false;
+	}
+
+	async convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult> {
+		const entries = unzip(input);
+		const parser = new XMLParser({
+			ignoreAttributes: false,
+			attributeNamePrefix: "@_",
+			textNodeName: "#text",
+			processEntities: { maxTotalExpansions: 1_000_000 },
+		});
+		// Parse shared strings
+		const ssXml = unzipText(entries, "xl/sharedStrings.xml");
+		const ss = ssXml ? (parser.parse(ssXml) as SharedStringsDoc) : null;
+		const siList = ss?.sst?.si;
+		const shared = toArray(siList);
+		// Parse workbook for sheet names
+		const wbXml = unzipText(entries, "xl/workbook.xml");
+		if (!wbXml) throw new Error("Invalid XLSX: missing workbook.xml");
+		const wb = parser.parse(wbXml) as WorkbookDoc;
+		const sheets = toArray(wb.workbook?.sheets?.sheet);
+		// Parse workbook rels to map rIds to sheet files
+		const relsXml = unzipText(entries, "xl/_rels/workbook.xml.rels");
+		const rels = relsXml ? (parser.parse(relsXml) as RelationshipsDoc) : null;
+		const relList = toArray(rels?.Relationships?.Relationship);
+		const relMap = new Map<string, string>();
+		for (const r of relList) {
+			relMap.set(r["@_Id"], r["@_Target"]);
+		}
+		const sections: string[] = [];
+		for (const sheet of sheets) {
+			const sheetName = sheet["@_name"];
+			const rId = sheet["@_r:id"];
+			const target = relMap.get(rId);
+			if (!target) continue;
+			const sheetPath = target.startsWith("/") ? target.slice(1) : `xl/${target}`;
+			const sheetXml = unzipText(entries, sheetPath);
+			if (!sheetXml) continue;
+			const parsed = parser.parse(sheetXml) as WorksheetDoc;
+			const rows = toArray(parsed.worksheet?.sheetData?.row);
+			if (rows.length === 0) continue;
+			// Extract all rows as string arrays
+			const tableRows: string[][] = [];
+			for (const row of rows) {
+				const cells = toArray(row.c);
+				const values: string[] = [];
+				for (const cell of cells) {
+					values.push(this.getCellValue(cell, shared));
+				}
+				tableRows.push(values);
+			}
+			if (tableRows.length === 0) continue;
+			// Normalize column count
+			const maxCols = Math.max(...tableRows.map(r => r.length));
+			for (const row of tableRows) {
+				while (row.length < maxCols) row.push("");
+			}
+			sections.push(`## ${sheetName}`);
+			const [header, ...body] = tableRows;
+			const lines: string[] = [];
+			lines.push(`| ${header.join(" | ")} |`);
+			lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+			for (const row of body) {
+				lines.push(`| ${row.join(" | ")} |`);
+			}
+			sections.push(lines.join("\n"));
+		}
+		return { markdown: sections.join("\n\n") };
+	}
+
+	getCellValue(cell: Cell, shared: StringItem[]): string {
+		// Shared string
+		if (cell["@_t"] === "s") {
+			return this.getSharedString(shared, Number(cell.v));
+		}
+		// Inline string
+		if (cell["@_t"] === "inlineStr") {
+			const is = cell.is;
+			if (!is) return "";
+			if (is.t != null) return textValue(is.t);
+			if (is.r)
+				return toArray(is.r)
+					.map(r => textValue(r.t))
+					.join("");
+			return "";
+		}
+		// Boolean
+		if (cell["@_t"] === "b") {
+			return cell.v === 1 || cell.v === "1" ? "TRUE" : "FALSE";
+		}
+		// Number or formula result
+		if (cell.v != null) return String(cell.v);
+		return "";
+	}
+
+	getSharedString(shared: StringItem[], idx: number): string {
+		const si = shared[idx];
+		if (!si) return "";
+		// Simple text
+		if (si.t != null) return textValue(si.t);
+		// Rich text runs
+		if (si.r) {
+			return toArray(si.r)
+				.map(r => textValue(r.t))
+				.join("");
+		}
+		return "";
+	}
+}
+
+function textValue(t: XmlText | undefined): string {
+	if (t == null) return "";
+	if (typeof t === "object") return t["#text"] || "";
+	return String(t);
+}
+
+function toArray<T>(val: T | T[] | undefined): T[] {
+	if (!val) return [];
+	return Array.isArray(val) ? val : [val];
+}

package/src/markit/index.ts

@@ -0,0 +1,2 @@
+export * from "./registry";
+export * from "./types";

package/src/markit/registry.ts

@@ -0,0 +1,59 @@
+// Adapted from markit-ai (MIT). See ./NOTICE.
+import * as path from "node:path";
+import { DocxConverter } from "./converters/docx";
+import { EpubConverter } from "./converters/epub";
+import { PdfConverter } from "./converters/pdf";
+import { PptxConverter } from "./converters/pptx";
+import { XlsxConverter } from "./converters/xlsx";
+import type { ConversionResult, Converter, MarkitOptions, StreamInfo } from "./types";
+
+/**
+ * In-house document → markdown engine (replaces the `markit-ai` package).
+ *
+ * Only the document converters omp routes are registered (pdf, docx, pptx,
+ * xlsx, epub). The first converter whose `accepts()` returns true and whose
+ * `convert()` succeeds wins.
+ */
+export class Markit {
+	readonly #converters: readonly Converter[];
+	readonly #options: MarkitOptions;
+
+	constructor(options: MarkitOptions = {}) {
+		this.#options = options;
+		this.#converters = [
+			new PdfConverter(),
+			new DocxConverter(),
+			new PptxConverter(),
+			new XlsxConverter(),
+			new EpubConverter(),
+		];
+	}
+
+	async convertFile(filePath: string, extra?: { imageDir?: string }): Promise<ConversionResult> {
+		const buffer = Buffer.from(await Bun.file(filePath).arrayBuffer());
+		const streamInfo: StreamInfo = {
+			localPath: filePath,
+			extension: path.extname(filePath).toLowerCase(),
+			filename: path.basename(filePath),
+			...extra,
+		};
+		return this.convert(buffer, streamInfo);
+	}
+
+	async convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult> {
+		const errors: { converter: string; error: Error }[] = [];
+		for (const converter of this.#converters) {
+			if (!converter.accepts(streamInfo)) continue;
+			try {
+				return await converter.convert(input, streamInfo, this.#options);
+			} catch (err) {
+				errors.push({ converter: converter.name, error: err instanceof Error ? err : new Error(String(err)) });
+			}
+		}
+		if (errors.length > 0) {
+			const details = errors.map(e => `  ${e.converter}: ${e.error.message}`).join("\n");
+			throw new Error(`Conversion failed:\n${details}`);
+		}
+		throw new Error(`Unsupported format: ${streamInfo.extension || streamInfo.mimetype || "unknown"}`);
+	}
+}

package/src/markit/types.ts

@@ -0,0 +1,35 @@
+// Adapted from markit-ai (MIT). See ./NOTICE.
+
+export interface StreamInfo {
+	mimetype?: string;
+	extension?: string;
+	charset?: string;
+	filename?: string;
+	localPath?: string;
+	url?: string;
+	/** Directory to write extracted images/diagrams. */
+	imageDir?: string;
+}
+
+export interface ConversionResult {
+	markdown: string;
+	title?: string;
+}
+
+export interface MarkitOptions {
+	/** Describe an image, return markdown. Receives raw bytes and mimetype. */
+	describe?: (image: Buffer, mimetype: string) => Promise<string>;
+	/** Transcribe audio, return text. Receives raw bytes and mimetype. */
+	transcribe?: (audio: Buffer, mimetype: string) => Promise<string>;
+	/** Extra instructions appended to the image description prompt. */
+	prompt?: string;
+}
+
+export interface Converter {
+	/** Human-readable name for error messages. */
+	name: string;
+	/** Quick check: can this converter handle the given stream? */
+	accepts(streamInfo: StreamInfo): boolean;
+	/** Convert the source to markdown. */
+	convert(input: Buffer, streamInfo: StreamInfo, options?: MarkitOptions): Promise<ConversionResult>;
+}

package/src/modes/components/snapcompact-shape-preview-doc.md

@@ -1,11 +1,18 @@
-[User]: Fix the settings overlay crash. Wheeling past the last row throws.
+# User ¶
+Fix the settings overlay crash. Wheeling past the last row throws.
 
-[Tool Call]: read(path="src/select-list.ts:140-180")
+# Tool call ¶
+//Reading the select-list hit test
+read(path="src/select-list.ts:140-180")
+<out>
+162: const index = Math.floor(line / rowHeight); index is never checked against bounds.
+</out>
 
-[Tool Result]: 162: const index = Math.floor(line / rowHeight); index is never checked against bounds.
+# Assistant ¶
+Found it. The hit test indexes past the filtered list; clamping to the last row fixes the crash.
 
-[Assistant]: Found it. The hit test indexes past the filtered list; clamping to the last row fixes the crash.
+# User ¶
+Does the fix survive filtering?
 
-[User]: Does the fix survive filtering?
-
-[Assistant]: Yes. The clamp applies after the filter pass, so a narrowed list keeps the hit map in sync. Added a regression test that wheels past the last row with a filter active and asserts no throw.
+# Assistant ¶
+Yes. The clamp applies after the filter pass, so a narrowed list keeps the hit map in sync. Added a regression test that wheels past the last row with a filter active and asserts no throw.

package/src/modes/components/snapcompact-shape-preview.ts

@@ -38,10 +38,10 @@ const ZOOM_SCALE = 4;
 const MAX_IMAGE_COLS = 28;
 const MAX_IMAGE_ROWS = 14;
 
-/** Sample transcript with `[Tool Result]:` bodies wrapped in dim-ink toggles. */
+/** Sample transcript with `<out>…</out>` bodies wrapped in dim-ink toggles. */
 const PREVIEW_TEXT = sampleDoc
 	.trim()
-	.replace(/\[Tool Result\]: ([^[]*)/g, (_match, body: string) => `[Tool Result]: ${DIM_ON}${body}${DIM_OFF}`);
+	.replace(/<out>\n([\s\S]*?)\n<\/out>/g, (_match, body: string) => `<out>\n${DIM_ON}${body}${DIM_OFF}\n</out>`);
 
 type PreviewEntry =
 	| { state: "rendering" }