@oh-my-pi/pi-coding-agent 14.9.3 → 14.9.7

package/src/eval/js/tool-bridge.ts

@@ -1,11 +1,9 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
+import type { JsStatusEvent } from "./shared/types";
 
-export interface JsStatusEvent {
-	op: string;
-	[key: string]: unknown;
-}
+export type { JsStatusEvent } from "./shared/types";
 
 interface ToolBridgeOptions {
 	session: ToolSession;

package/src/eval/js/worker-core.ts

@@ -0,0 +1,146 @@
+import { ToolError } from "../../tools/tool-errors";
+import { JsRuntime, type RuntimeHooks } from "./shared/runtime";
+import type { RunErrorPayload, SessionSnapshot, ToolReply, Transport, WorkerInbound } from "./worker-protocol";
+
+interface PendingTool {
+	resolve(value: unknown): void;
+	reject(error: Error): void;
+}
+
+interface ActiveRun {
+	runId: string;
+	pendingTools: Map<string, PendingTool>;
+}
+
+function errorPayload(error: unknown): RunErrorPayload {
+	if (error instanceof Error) {
+		return {
+			name: error.name,
+			message: error.message,
+			stack: error.stack,
+			isAbort: error.name === "AbortError" || error.name === "ToolAbortError",
+			isToolError: error.name === "ToolError" || error instanceof ToolError,
+		};
+	}
+	return { message: String(error) };
+}
+
+function errorFromPayload(payload: RunErrorPayload): Error {
+	const ctor = payload.isToolError ? ToolError : Error;
+	const error = new ctor(payload.message);
+	if (payload.name) error.name = payload.name;
+	if (payload.stack) error.stack = payload.stack;
+	return error;
+}
+
+export class WorkerCore {
+	#transport: Transport;
+	#runtime: JsRuntime | null = null;
+	#queue: Promise<void> = Promise.resolve();
+	#active: ActiveRun | null = null;
+	#unsubscribe: () => void;
+
+	constructor(transport: Transport) {
+		this.#transport = transport;
+		this.#unsubscribe = transport.onMessage(msg => this.#handle(msg));
+		transport.send({ type: "ready" });
+	}
+
+	#handle(msg: WorkerInbound): void {
+		switch (msg.type) {
+			case "init":
+				this.#ensureRuntime(msg.snapshot);
+				return;
+			case "run":
+				this.#enqueueRun(msg.runId, msg.code, msg.filename, msg.snapshot);
+				return;
+			case "tool-reply":
+				this.#deliverToolReply(msg.id, msg.reply);
+				return;
+			case "close":
+				this.#close();
+				return;
+		}
+	}
+
+	#ensureRuntime(snapshot: SessionSnapshot): JsRuntime {
+		if (this.#runtime) {
+			this.#runtime.setCwd(snapshot.cwd);
+			return this.#runtime;
+		}
+		this.#runtime = new JsRuntime({
+			initialCwd: snapshot.cwd,
+			sessionId: snapshot.sessionId,
+			getHooks: () => this.#hooksForCurrentRun(),
+		});
+		return this.#runtime;
+	}
+
+	#hooksForCurrentRun(): RuntimeHooks | null {
+		const active = this.#active;
+		if (!active) return null;
+		const runId = active.runId;
+		return {
+			onText: chunk => this.#transport.send({ type: "text", runId, chunk }),
+			onDisplay: output => this.#transport.send({ type: "display", runId, output }),
+			callTool: (name, args) => this.#callTool(active, name, args),
+		};
+	}
+
+	#enqueueRun(runId: string, code: string, filename: string, snapshot: SessionSnapshot): void {
+		const previous = this.#queue;
+		const next = (async () => {
+			await previous.catch(() => undefined);
+			await this.#runOne(runId, code, filename, snapshot);
+		})();
+		this.#queue = next.catch(() => undefined);
+	}
+
+	async #runOne(runId: string, code: string, filename: string, snapshot: SessionSnapshot): Promise<void> {
+		const runtime = this.#ensureRuntime(snapshot);
+		runtime.setCwd(snapshot.cwd);
+		this.#active = { runId, pendingTools: new Map() };
+		try {
+			const value = await runtime.run(code, filename);
+			runtime.displayValue(value);
+			this.#transport.send({ type: "result", runId, ok: true });
+		} catch (error) {
+			this.#transport.send({ type: "result", runId, ok: false, error: errorPayload(error) });
+		} finally {
+			this.#active = null;
+		}
+	}
+
+	async #callTool(active: ActiveRun, name: string, args: unknown): Promise<unknown> {
+		const id = `tc-${active.runId}-${crypto.randomUUID()}`;
+		const { promise, resolve, reject } = Promise.withResolvers<unknown>();
+		active.pendingTools.set(id, { resolve, reject });
+		this.#transport.send({ type: "tool-call", id, runId: active.runId, name, args });
+		return await promise;
+	}
+
+	#deliverToolReply(id: string, reply: ToolReply): void {
+		const active = this.#active;
+		if (!active) return;
+		const pending = active.pendingTools.get(id);
+		if (!pending) return;
+		active.pendingTools.delete(id);
+		if (reply.ok) pending.resolve(reply.value);
+		else pending.reject(errorFromPayload(reply.error));
+	}
+
+	#close(): void {
+		const active = this.#active;
+		if (active) {
+			for (const pending of active.pendingTools.values()) {
+				pending.reject(new ToolError("JS worker closed"));
+			}
+			active.pendingTools.clear();
+		}
+		this.#active = null;
+		this.#runtime = null;
+		this.#transport.send({ type: "closed" });
+		this.#unsubscribe();
+		this.#transport.close();
+	}
+}

package/src/eval/js/worker-entry.ts

@@ -0,0 +1,24 @@
+import { parentPort } from "node:worker_threads";
+import { WorkerCore } from "./worker-core";
+import type { Transport, WorkerInbound, WorkerOutbound } from "./worker-protocol";
+
+if (!parentPort) throw new Error("js worker-entry: missing parentPort");
+
+const port = parentPort;
+const transport: Transport = {
+	send: (msg: WorkerOutbound) => port.postMessage(msg),
+	onMessage: handler => {
+		const wrap = (data: unknown): void => handler(data as WorkerInbound);
+		port.on("message", wrap);
+		return () => port.off("message", wrap);
+	},
+	close: () => {
+		try {
+			port.close();
+		} catch {
+			// Already closed.
+		}
+	},
+};
+
+new WorkerCore(transport);

package/src/eval/js/worker-protocol.ts

@@ -0,0 +1,41 @@
+import type { JsDisplayOutput } from "./shared/types";
+
+export type { JsDisplayOutput } from "./shared/types";
+
+export interface SessionSnapshot {
+	cwd: string;
+	sessionId: string;
+}
+
+export interface RunErrorPayload {
+	name?: string;
+	message: string;
+	stack?: string;
+	isAbort?: boolean;
+	isToolError?: boolean;
+}
+
+export type ToolReply = { ok: true; value: unknown } | { ok: false; error: RunErrorPayload };
+
+export type WorkerInbound =
+	| { type: "init"; snapshot: SessionSnapshot }
+	| { type: "run"; runId: string; code: string; filename: string; snapshot: SessionSnapshot }
+	| { type: "tool-reply"; id: string; reply: ToolReply }
+	| { type: "close" };
+
+export type WorkerOutbound =
+	| { type: "ready" }
+	| { type: "init-failed"; error: RunErrorPayload }
+	| { type: "text"; runId: string; chunk: string }
+	| { type: "display"; runId: string; output: JsDisplayOutput }
+	| { type: "tool-call"; id: string; runId: string; name: string; args: unknown }
+	| { type: "result"; runId: string; ok: true }
+	| { type: "result"; runId: string; ok: false; error: RunErrorPayload }
+	| { type: "log"; level: "debug" | "warn" | "error"; msg: string; meta?: Record<string, unknown> }
+	| { type: "closed" };
+
+export interface Transport {
+	send(msg: WorkerOutbound): void;
+	onMessage(handler: (msg: WorkerInbound) => void): () => void;
+	close(): void;
+}

package/src/eval/parse.ts

@@ -43,16 +43,19 @@ const LANGUAGE_MAP: Record<string, EvalLanguage> = {
 	TYPESCRIPT: "js",
 };
 
-// Markers are case-insensitive, accept ≥2 leading stars (so `**Begin` and
-// `*** Begin` both work), and tolerate any whitespace (including tabs)
+// Markers are case-insensitive, accept ≥2 leading stars (so `**Cell` and
+// `*** Cell` both work), and tolerate any whitespace (including tabs)
 // between tokens. Models that can't constrain-sample frequently emit minor
-// variations like `**End`, `*** end py`, or `***\tTitle: foo`.
+// variations like `**End` or `*** cell py`.
 const STARS = String.raw`\*{2,}`;
-const BEGIN_RE = new RegExp(`^${STARS}\\s*Begin\\b\\s*(\\S+)?\\s*$`, "i");
+// Cell header: `*** Cell <attrs...>`. The remainder of the line is captured
+// and tokenized separately so we can handle quoted values.
+const CELL_RE = new RegExp(`^${STARS}\\s*Cell\\b\\s*(.*)$`, "i");
+// `*** End` is a tolerated cell/file terminator. Documented as required at
+// the file level in the lark grammar (the trailing `*** End` quirks GPT-
+// trained models naturally produce), but optional at the parser level.
 const END_RE = new RegExp(`^${STARS}\\s*End\\b.*$`, "i");
-const TITLE_RE = new RegExp(`^${STARS}\\s*Title\\s*:\\s*(.+?)\\s*$`, "i");
-const TIMEOUT_RE = new RegExp(`^${STARS}\\s*Timeout\\s*:\\s*(\\S+)\\s*$`, "i");
-const RESET_RE = new RegExp(`^${STARS}\\s*Reset\\s*$`, "i");
+// `*** Abort` is the harmony-leak recovery sentinel; see ABORT_WARNING.
 const ABORT_RE = new RegExp(`^${STARS}\\s*Abort\\s*$`, "i");
 
 /**
@@ -62,6 +65,7 @@ const ABORT_RE = new RegExp(`^${STARS}\\s*Abort\\s*$`, "i");
  */
 export const ABORT_WARNING =
 	"Tool stream truncated mid-call due to detected output corruption. Earlier cells (if any) executed normally; their state persists. Re-issue the aborted cell.";
+
 const DURATION_RE = /^(\d+)(ms|s|m)?$/i;
 
 function resolveLang(token: string | undefined): EvalLanguage | undefined {
@@ -88,7 +92,7 @@ const FENCE_OPEN_RE = /^```\s*([A-Za-z]\w*)?\s*$/;
 const FENCE_CLOSE_RE = /^```\s*$/;
 
 /**
- * Last-resort fallback when the input has no recognizable `*** Begin` header.
+ * Last-resort fallback when the input has no recognizable `*** Cell` header.
  * Models that can't constrain-sample sometimes pass bare code or wrap it in
  * a markdown fence (```py / ```python / bare ```). Treat the whole input as
  * a single implicit cell, sniffing the language from the body.
@@ -122,6 +126,187 @@ function parseImplicitCell(lines: string[]): ParsedEvalCell {
 	};
 }
 
+/**
+ * Tokenize a `*** Cell` header's attribute list while preserving quoted
+ * segments (`id:"some title"`, `py:"hi"`, single quotes too) as single
+ * tokens. Outer whitespace separates tokens; the quote characters
+ * themselves are kept verbatim so attribute parsing can strip them later.
+ */
+function tokenizeCellAttrs(input: string): string[] {
+	const tokens: string[] = [];
+	let i = 0;
+	while (i < input.length) {
+		while (i < input.length && /\s/.test(input[i])) i++;
+		if (i >= input.length) break;
+		let token = "";
+		while (i < input.length && !/\s/.test(input[i])) {
+			const ch = input[i];
+			if (ch === '"' || ch === "'") {
+				token += ch;
+				i++;
+				while (i < input.length && input[i] !== ch) {
+					token += input[i];
+					i++;
+				}
+				if (i < input.length) {
+					token += input[i];
+					i++;
+				}
+			} else {
+				token += ch;
+				i++;
+			}
+		}
+		tokens.push(token);
+	}
+	return tokens;
+}
+
+interface CellHeader {
+	language: EvalLanguage | undefined;
+	languageOrigin: EvalLanguageOrigin;
+	title: string | undefined;
+	timeoutMs: number | undefined;
+	reset: boolean;
+}
+
+/**
+ * Map an attribute key (from `key:value` or bare `key`) to one of the three
+ * canonical roles. Canonical keys: `id`, `t`, `rst`. Fallback aliases —
+ * accepted but not advertised in the prompt — cover common synonyms LLMs
+ * reach for instead of the short canonical.
+ */
+const ID_KEYS = new Set(["id", "title", "name", "cell", "file", "label"]);
+const T_KEYS = new Set(["t", "timeout", "duration", "time"]);
+const RST_KEYS = new Set(["rst", "reset"]);
+
+function classifyAttrKey(key: string): "id" | "t" | "rst" | null {
+	if (ID_KEYS.has(key)) return "id";
+	if (T_KEYS.has(key)) return "t";
+	if (RST_KEYS.has(key)) return "rst";
+	return null;
+}
+
+// `key:value` form. `value` may be `"..."`, `'...'`, or a bare run.
+const ATTR_TOKEN_RE = /^([a-zA-Z][\w-]*)(?::(?:"([^"]*)"|'([^']*)'|(.*)))?$/;
+// Bare positional duration (lenient — `t:` is canonical).
+const DURATION_TOKEN_RE = /^\d+(?:ms|s|m)?$/;
+
+function parseBooleanFlag(value: string): boolean | undefined {
+	const v = value.trim().toLowerCase();
+	if (v === "true" || v === "1" || v === "yes" || v === "on") return true;
+	if (v === "false" || v === "0" || v === "no" || v === "off") return false;
+	return undefined;
+}
+
+/**
+ * Decode a `*** Cell` header's attribute list into language, title,
+ * timeout, and reset flag.
+ *
+ * Token forms (all optional, any order):
+ *   - `py` / `js` / `ts`                       bare language
+ *   - `py:"..."` / `js:"..."` / `ts:"..."`     language + title shorthand
+ *   - `id:"..."`                               cell title (canonical)
+ *   - `t:<duration>`                           per-cell timeout (canonical)
+ *   - `<duration>` (e.g. `30s`)                bare positional duration
+ *   - `rst`                                    reset flag (canonical)
+ *   - `rst:true|false|1|0|yes|no|on|off`       reset flag with explicit value
+ *
+ * Fallback aliases (accepted but not advertised in the prompt):
+ *   - id:  title, name, cell, file, label
+ *   - t:   timeout, duration, time
+ *   - rst: reset
+ *
+ * Quotes may be `"` or `'`. Truly unknown keys are silently dropped. First
+ * occurrence wins when a key is repeated (canonical or alias). Anything
+ * that doesn't classify accumulates as a positional title fragment joined
+ * by spaces.
+ */
+function parseCellHeader(rest: string, lineNumber: number): CellHeader {
+	const tokens = tokenizeCellAttrs(rest);
+	let language: EvalLanguage | undefined;
+	let titleAttr: string | undefined;
+	let positionalDurationMs: number | undefined;
+	let tAttr: string | undefined;
+	let rstAttr: string | undefined;
+	let bareReset = false;
+	const titleParts: string[] = [];
+
+	for (const token of tokens) {
+		// Bare reset flag (canonical or alias).
+		if (RST_KEYS.has(token.toLowerCase())) {
+			bareReset = true;
+			continue;
+		}
+
+		const attrMatch = ATTR_TOKEN_RE.exec(token);
+		if (attrMatch && token.includes(":")) {
+			const key = attrMatch[1].toLowerCase();
+			const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+
+			// Language-with-title shorthand: `py:"foo"`, `js:'bar'`, etc.
+			const langCandidate = resolveLang(key);
+			if (langCandidate) {
+				if (language === undefined) language = langCandidate;
+				if (titleAttr === undefined && value !== "") titleAttr = value;
+				continue;
+			}
+
+			const role = classifyAttrKey(key);
+			if (role === "id" && titleAttr === undefined) titleAttr = value;
+			else if (role === "t" && tAttr === undefined) tAttr = value;
+			else if (role === "rst" && rstAttr === undefined) rstAttr = value;
+			// unknown / repeated keys silently dropped
+			continue;
+		}
+
+		// Bare language token (no colon).
+		const lang = resolveLang(token);
+		if (lang && language === undefined) {
+			language = lang;
+			continue;
+		}
+
+		// Bare positional duration (lenient — `t:` is canonical).
+		if (positionalDurationMs === undefined && DURATION_TOKEN_RE.test(token)) {
+			positionalDurationMs = parseDurationMs(token, lineNumber);
+			continue;
+		}
+
+		titleParts.push(token);
+	}
+
+	const explicitTitle = (titleAttr ?? "").trim();
+	const positionalTitle = titleParts.join(" ").trim();
+	const title = explicitTitle.length > 0 ? explicitTitle : positionalTitle.length > 0 ? positionalTitle : undefined;
+
+	let timeoutMs: number | undefined;
+	if (tAttr !== undefined) {
+		timeoutMs = parseDurationMs(tAttr, lineNumber);
+	} else if (positionalDurationMs !== undefined) {
+		timeoutMs = positionalDurationMs;
+	}
+
+	let reset = false;
+	if (rstAttr !== undefined) {
+		const parsed = parseBooleanFlag(rstAttr);
+		if (parsed === undefined) {
+			throw new Error(`Eval line ${lineNumber}: invalid rst value \`${rstAttr}\`; use true or false.`);
+		}
+		reset = parsed;
+	} else if (bareReset) {
+		reset = true;
+	}
+
+	return {
+		language,
+		languageOrigin: language ? "header" : "default",
+		title,
+		timeoutMs,
+		reset,
+	};
+}
+
 export function parseEvalInput(input: string): ParsedEvalInput {
 	const normalized = input.replace(/\r\n?/g, "\n");
 	const lines = normalized.split("\n");
@@ -134,10 +319,10 @@ export function parseEvalInput(input: string): ParsedEvalInput {
 	// Skip leading blank lines.
 	while (i < lines.length && lines[i].trim() === "") i++;
 
-	// Lenient fallback: if the input has no recognizable begin marker, treat
+	// Lenient fallback: if the input has no recognizable cell header, treat
 	// the entire input as one implicit cell — unless that content contains
 	// `*** Abort`, in which case the body is incomplete/unsafe and we drop it.
-	if (i < lines.length && !BEGIN_RE.test(lines[i])) {
+	if (i < lines.length && !CELL_RE.test(lines[i])) {
 		const tail = lines.slice(i);
 		if (tail.some(line => ABORT_RE.test(line))) {
 			return { cells, aborted: true };
@@ -148,42 +333,26 @@ export function parseEvalInput(input: string): ParsedEvalInput {
 	}
 
 	while (i < lines.length) {
-		const beginMatch = BEGIN_RE.exec(lines[i])!;
-		const langToken = beginMatch[1];
-		const explicitLanguage = resolveLang(langToken);
-		i++;
-
-		let title: string | undefined;
-		let timeoutMs: number | undefined;
-		let reset = false;
-
-		while (i < lines.length) {
-			const line = lines[i];
-			const lineNumber = i + 1;
-			const titleMatch = TITLE_RE.exec(line);
-			if (titleMatch) {
-				if (title === undefined) title = titleMatch[1];
-				i++;
-				continue;
-			}
-			const timeoutMatch = TIMEOUT_RE.exec(line);
-			if (timeoutMatch) {
-				if (timeoutMs === undefined) timeoutMs = parseDurationMs(timeoutMatch[1], lineNumber);
-				i++;
-				continue;
-			}
-			if (RESET_RE.test(line)) {
-				reset = true;
-				i++;
-				continue;
+		const headerLine = lines[i];
+		const cellMatch = CELL_RE.exec(headerLine);
+		if (!cellMatch) {
+			// Stray content between/after cells (blank lines were already
+			// consumed). `*** Abort` here terminates parsing; `*** End` is
+			// the optional file-level terminator (silently consumed). Anything
+			// else — typically a harmony-leak fragment — is skipped.
+			if (ABORT_RE.test(headerLine)) {
+				aborted = true;
+				break;
 			}
-			break;
+			i++;
+			continue;
 		}
+		const header = parseCellHeader(cellMatch[1] ?? "", i + 1);
+		i++;
 
-		// Collect cell body. Close on `*** End` OR on the next `*** Begin`
-		// (implicit end — leniency for models that drop end markers between
-		// back-to-back cells). `*** Abort` (recovery sentinel) drops the
-		// in-progress cell entirely: its body is partial and unsafe to run.
+		// Collect cell body. Close on `*** End` (any form), the next
+		// `*** Cell` header, or `*** Abort` (which drops the in-progress
+		// cell as its body is partial and unsafe to run).
 		const codeLines: string[] = [];
 		let cellAborted = false;
 		while (i < lines.length) {
@@ -198,7 +367,7 @@ export function parseEvalInput(input: string): ParsedEvalInput {
 				i++;
 				break;
 			}
-			if (BEGIN_RE.test(line)) break;
+			if (CELL_RE.test(line)) break;
 			codeLines.push(line);
 			i++;
 		}
@@ -212,17 +381,17 @@ export function parseEvalInput(input: string): ParsedEvalInput {
 		}
 		const code = codeLines.join("\n");
 
-		const language = explicitLanguage ?? sniffEvalLanguage(code) ?? DEFAULT_LANGUAGE;
-		const languageOrigin: EvalLanguageOrigin = explicitLanguage ? "header" : "default";
+		const language = header.language ?? sniffEvalLanguage(code) ?? DEFAULT_LANGUAGE;
+		const languageOrigin: EvalLanguageOrigin = header.language ? "header" : "default";
 
 		cells.push({
 			index: cells.length,
-			title,
+			title: header.title,
 			code,
 			language,
 			languageOrigin,
-			timeoutMs: timeoutMs ?? DEFAULT_TIMEOUT_MS,
-			reset,
+			timeoutMs: header.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+			reset: header.reset,
 		});
 
 		// Skip blank separator lines between cells; an `*** Abort` here

package/src/eval/py/display.ts

@@ -0,0 +1,71 @@
+/**
+ * Display bundle rendering shared between the Python runner output and the
+ * legacy Jupyter MIME conventions. Pure function, no kernel coupling.
+ */
+import { htmlToBasicMarkdown } from "../../web/scrapers/types";
+
+/** Status event emitted by prelude helpers for TUI rendering. */
+export interface PythonStatusEvent {
+	/** Operation name (e.g., "find", "read", "write") */
+	op: string;
+	/** Additional data fields (count, path, pattern, etc.) */
+	[key: string]: unknown;
+}
+
+export type KernelDisplayOutput =
+	| { type: "json"; data: unknown }
+	| { type: "image"; data: string; mimeType: string }
+	| { type: "markdown" }
+	| { type: "status"; event: PythonStatusEvent };
+
+function normalizeDisplayText(text: string): string {
+	return text.endsWith("\n") ? text : `${text}\n`;
+}
+
+/** Render a MIME bundle into text + structured outputs. */
+export async function renderKernelDisplay(content: Record<string, unknown>): Promise<{
+	text: string;
+	outputs: KernelDisplayOutput[];
+}> {
+	// Accept both raw bundles ({"text/plain": ...}) and Jupyter-style
+	// content envelopes ({ data: {...} }) so callers don't need to unwrap.
+	const data =
+		(content.data as Record<string, unknown> | undefined) ?? (content as Record<string, unknown> | undefined);
+	if (!data) return { text: "", outputs: [] };
+
+	const outputs: KernelDisplayOutput[] = [];
+
+	// Status events bypass the text path entirely — they exist only for TUI hooks.
+	if (data["application/x-omp-status"] !== undefined) {
+		const statusData = data["application/x-omp-status"];
+		if (statusData && typeof statusData === "object" && "op" in statusData) {
+			outputs.push({ type: "status", event: statusData as PythonStatusEvent });
+		}
+		return { text: "", outputs };
+	}
+
+	if (typeof data["image/png"] === "string") {
+		outputs.push({ type: "image", data: data["image/png"] as string, mimeType: "image/png" });
+	}
+	if (typeof data["image/jpeg"] === "string") {
+		outputs.push({ type: "image", data: data["image/jpeg"] as string, mimeType: "image/jpeg" });
+	}
+	if (data["application/json"] !== undefined) {
+		outputs.push({ type: "json", data: data["application/json"] });
+	}
+
+	// text/markdown takes precedence over text/plain (Markdown objects expose both
+	// where text/plain is just the repr).
+	if (typeof data["text/markdown"] === "string") {
+		outputs.push({ type: "markdown" });
+		return { text: normalizeDisplayText(String(data["text/markdown"])), outputs };
+	}
+	if (typeof data["text/plain"] === "string") {
+		return { text: normalizeDisplayText(String(data["text/plain"])), outputs };
+	}
+	if (data["text/html"] !== undefined) {
+		const markdown = (await htmlToBasicMarkdown(String(data["text/html"]))) || "";
+		return { text: markdown ? normalizeDisplayText(markdown) : "", outputs };
+	}
+	return { text: "", outputs };
+}