@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/src/chat/served-model-marker.ts

@@ -0,0 +1,91 @@
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { classifyModel } from "@oh-my-pi/pi-catalog/identity";
+import { MessageDividerComponent } from "../chrome/message-divider";
+import { theme } from "../theme";
+
+/** A turn whose response provably came from a different model than was requested. */
+export interface ServedModelMismatch {
+	/** Model id the request asked for. */
+	requested: string;
+	/** Model id recovered from the response (signed thinking block or router report). */
+	served: string;
+	/** Configured provider the request went to. */
+	provider: string;
+	/** Upstream host the provider routed to, when it reported one (OpenRouter's `provider`). */
+	upstreamProvider?: string;
+}
+
+/**
+ * Decide whether `message` was served by a model other than the one requested.
+ *
+ * Compares the requested and served ids through `classifyModel` rather than
+ * textually: a snapshot suffix (`claude-haiku-4-5` → `claude-haiku-4-5-20251001`)
+ * or a gateway prefix (`anthropic/claude-opus-5`) is the same model, while a
+ * different family or revision (`claude-opus-5` → `claude-haiku-4-5`) is a
+ * substitution. Ids either side cannot classify — Anthropic's internal A/B
+ * codenames (`numbat-v6-…`) show up as served ids on first-party traffic —
+ * are unverifiable, not mismatches, so they yield `undefined`.
+ */
+export function detectServedModelMismatch(message: AssistantMessage): ServedModelMismatch | undefined {
+	const served = message.upstreamModel;
+	if (!served || served === message.model) return undefined;
+	const requested = classifyModel(message.provider, message.model, { lenient: true });
+	const actual = classifyModel(message.provider, served, { lenient: true });
+	if (requested.class === "unknown" || actual.class === "unknown") return undefined;
+	if (
+		requested.class === actual.class &&
+		requested.family === actual.family &&
+		(requested.revision === undefined || actual.revision === undefined || requested.revision === actual.revision)
+	) {
+		return undefined;
+	}
+	return {
+		requested: message.model,
+		served,
+		provider: message.provider,
+		...(message.upstreamProvider ? { upstreamProvider: message.upstreamProvider } : {}),
+	};
+}
+
+/**
+ * Per-transcript memory that surfaces each distinct (requested → served)
+ * substitution once. A gateway that swaps models does so for every turn, so
+ * repeating the marker would only add noise; a new pair after a model switch
+ * still gets its own marker. Replaced wholesale on rebuild so replaying history
+ * re-derives the same first occurrence.
+ */
+export class ServedModelTracker {
+	readonly #announced = new Set<string>();
+
+	/** The mismatch to render for `message`, or undefined when there is none or it was already shown. */
+	check(message: AssistantMessage): ServedModelMismatch | undefined {
+		const mismatch = detectServedModelMismatch(message);
+		if (!mismatch) return undefined;
+		const key = `${mismatch.provider}\0${mismatch.requested}\0${mismatch.served}`;
+		if (this.#announced.has(key)) return undefined;
+		this.#announced.add(key);
+		return mismatch;
+	}
+}
+
+/**
+ * Slim left-aligned divider rendered after the first assistant turn whose
+ * response came from a different model than requested. Same shape as the
+ * cache-miss divider, in the warning color:
+ *
+ *   ────────── ⚠ served claude-haiku-4-5-20251001 · requested claude-opus-5 · via openrouter/Amazon Bedrock
+ */
+export class ServedModelMarkerComponent extends MessageDividerComponent {
+	constructor(info: ServedModelMismatch) {
+		super({
+			label: () => {
+				const dot = theme.sep.dot.trim();
+				const via = info.upstreamProvider ? `${info.provider}/${info.upstreamProvider}` : info.provider;
+				return `${theme.status.warning} served ${info.served} ${dot} requested ${info.requested} ${dot} via ${via}`;
+			},
+			labelColor: "warning",
+			ruleColor: "dim",
+			ruleWidth: 10,
+		});
+	}
+}

package/src/chat/skill-message.ts

@@ -0,0 +1,220 @@
+import type { TextContent } from "@oh-my-pi/pi-ai";
+import { type Component } from "../tui";
+import { Box } from "../components/box";
+import { Disclosure } from "../components/disclosure";
+import { Container } from "../tui";
+import { Markdown } from "../components/markdown";
+import { Spacer } from "../components/spacer";
+import { Text } from "../components/text";
+import { getMarkdownTheme, theme } from "../theme";
+import type { CustomMessage, SkillPromptDetails } from "./messages";
+import { fileHyperlink } from "../render";
+import { collapseSkillTokens, skillChipLabel, skillChipStyle, skillToken } from "../prompt/composer-attachments";
+import { type UserBubbleOptions, UserMessageComponent, userBubbleColor } from "./user-message";
+
+/**
+ * Transcript row for a user-invoked skill. Two layouts, chosen by where the
+ * `/skill:<name>` token sat in the submitted draft:
+ *
+ * - **Callout** (token first): a user bubble with a skill-colored left rail,
+ *   the skill chip and prompt size as its header, then the rest of the draft
+ *   as full Markdown.
+ * - **Inline** (token mid-prompt): a plain user bubble with the token drawn
+ *   as the same soft-pill chip the composer showed.
+ *
+ * In both, the chip is an OSC 8 link to the SKILL.md. Expanding (tool-output
+ * toggle) appends the rendered skill prompt.
+ */
+export class SkillMessageComponent extends Container {
+	// Canonical and replayed skill cards finalize immediately so they retire to
+	// native scrollback like any settled block. An optimistically-painted
+	// `/skill:` row (issue #11217) is instead held live until its canonical
+	// `message_start` reconciles it, so it stays removable and never leaves a
+	// duplicate behind in scrollback if reconcile swaps it out.
+	#transcriptBlockFinalized = true;
+	// Controlled expansion delegate. In callout mode it is the prompt-only
+	// disclosure nested inside the single continuous SkillCallout rail; in
+	// inline mode it pairs the user bubble summary with a lazy SkillCallout
+	// body. Rebuilt (unmaterialized) on invalidate so header/body pick up the
+	// current theme without eagerly constructing the expanded prompt.
+	#disclosure: Disclosure | undefined;
+
+	readonly #message: CustomMessage<SkillPromptDetails>;
+	readonly #imageLinks?: readonly (string | undefined)[];
+
+	constructor(message: CustomMessage<SkillPromptDetails>, imageLinks?: readonly (string | undefined)[]) {
+		super();
+		this.#message = message;
+		this.#imageLinks = imageLinks;
+
+		this.#rebuild();
+	}
+
+	setExpanded(expanded: boolean): void {
+		this.#disclosure?.setExpanded(expanded);
+	}
+
+	/**
+	 * Transcript finalization contract (see `FinalizableBlock`): an optimistic
+	 * `/skill:` row reports `false` so the container keeps it live and removable
+	 * until reconcile; every other skill card is finalized on creation.
+	 */
+	isTranscriptBlockFinalized(): boolean {
+		return this.#transcriptBlockFinalized;
+	}
+
+	/** Hold this card live as an unreconciled optimistic `/skill:` row (#11217). */
+	markTranscriptBlockPending(): void {
+		this.#transcriptBlockFinalized = false;
+	}
+
+	/** Finalize an optimistic row adopted in place after it already retired to
+	 *  scrollback before its canonical `message_start` arrived (#11217). */
+	markTranscriptBlockFinalized(): void {
+		this.#transcriptBlockFinalized = true;
+	}
+
+	override invalidate(): void {
+		this.#rebuild();
+	}
+
+	override dispose(): void {
+		this.#disclosure?.dispose();
+		super.dispose();
+	}
+
+	#rebuild(): void {
+		const expanded = this.#disclosure?.expanded ?? false;
+		this.#disclosure?.dispose();
+		this.clear();
+		const details = this.#message.details;
+		const name = details?.name?.trim() || "unknown";
+		const token = skillToken(name);
+		const prompt = details?.prompt ?? (details?.args ? `${token} ${details.args}` : token);
+		// Display-only collapse: only the invoked skill becomes a chip; a second `/skill:` token the
+		// dispatcher ignored stays literal so the transcript never claims a skill that never loaded.
+		const display = collapseSkillTokens(
+			prompt,
+			candidate => candidate === name,
+			() => {},
+		);
+		const label = skillChipLabel(name);
+		const leading = display.startsWith(label) && /^\s*$/.test(display.charAt(label.length));
+		const bubble: UserBubbleOptions = {
+			imageLinks: this.#imageLinks,
+			skillPath: candidate => (candidate === name ? details?.path : undefined),
+		};
+
+		if (!leading) {
+			this.#disclosure = new Disclosure({
+				summary: new UserMessageComponent(display, bubble),
+				// Prompt extraction and Markdown layout stay lazy: the factory
+				// runs on the first expanded render, reading the current theme.
+				body: () =>
+					new SkillCallout([new Text(this.#header(label, details), 0, 0), ...this.#promptSection(bubble)]),
+				expanded,
+			});
+			this.addChild(this.#disclosure);
+			return;
+		}
+
+		const body = display.slice(label.length).trim();
+		const children: Component[] = [new Text(this.#header(label, details), 0, 0)];
+		if (body) children.push(new Spacer(1), this.#markdown(body, bubble));
+		// The prompt disclosure nests inside the one callout so the
+		// skill-colored rail stays continuous across summary and detail.
+		const promptDisclosure = new Disclosure({
+			body: () => this.#promptFragment(bubble),
+			expanded,
+		});
+		// The rail box and its Markdown always ignore tight viewports.
+		promptDisclosure.setIgnoreTight(true);
+		this.#disclosure = promptDisclosure;
+		children.push(promptDisclosure);
+		this.addChild(new SkillCallout(children));
+	}
+
+	/**
+	 * Expanded prompt section (leading mode detail slot): raw rows appended to
+	 * the outer callout, matching the pre-Disclosure layout of a single rail
+	 * with no duplicate header.
+	 */
+	#promptFragment(bubble: UserBubbleOptions): Component {
+		const fragment = new Container();
+		for (const child of this.#promptSection(bubble)) fragment.addChild(child);
+		return fragment;
+	}
+
+	#markdown(text: string, bubble: UserBubbleOptions): Markdown {
+		const md = new Markdown(text, 0, 0, getMarkdownTheme(), {
+			bgColor: value => theme.bg("userMessageBg", value),
+			color: userBubbleColor(bubble),
+		});
+		md.setIgnoreTight(true);
+		return md;
+	}
+
+	/** Chip linked to its SKILL.md, then the muted prompt size. */
+	#header(label: string, details: SkillPromptDetails | undefined): string {
+		const chip = skillChipStyle(label, bubbleReset());
+		const parts = [details?.path ? fileHyperlink(details.path, chip, { line: 1 }) : chip];
+		if (typeof details?.lineCount === "number") {
+			parts.push(theme.fg("muted", `${details.lineCount} ${details.lineCount === 1 ? "line" : "lines"}`));
+		}
+		return parts.join("  ");
+	}
+
+	/** The rendered SKILL.md prompt under a calm subheader (expanded view only). */
+	#promptSection(bubble: UserBubbleOptions): Component[] {
+		const text = this.#extractText();
+		if (!text) return [];
+		return [new Spacer(1), new Text(theme.fg("muted", "prompt"), 0, 0), new Spacer(1), this.#markdown(text, bubble)];
+	}
+
+	#extractText(): string {
+		if (typeof this.#message.content === "string") {
+			return this.#message.content;
+		}
+		return this.#message.content
+			.filter((c): c is TextContent => c.type === "text")
+			.map(c => c.text)
+			.join("\n");
+	}
+}
+
+/** Bubble foreground + background to re-arm after an inline chip. */
+function bubbleReset(): string {
+	return `${theme.getFgOnBgAnsi("userMessageText", "userMessageBg")}${theme.getBgAnsi("userMessageBg")}`;
+}
+
+/**
+ * A user-bubble box with a skill-colored rail down its left edge. Memoized on the
+ * inner box's render so the transcript's incremental assembly sees stable rows.
+ */
+class SkillCallout implements Component {
+	readonly #box: Box;
+	#source: readonly string[] | undefined;
+	#lines: string[] | undefined;
+
+	constructor(children: readonly Component[]) {
+		this.#box = new Box(1, 1, value => theme.bgFill("userMessageBg", value));
+		this.#box.setIgnoreTight(true);
+		for (const child of children) this.#box.addChild(child);
+	}
+
+	invalidate(): void {
+		this.#box.invalidate();
+		this.#source = undefined;
+		this.#lines = undefined;
+	}
+
+	render(width: number): readonly string[] {
+		const inner = this.#box.render(Math.max(1, width - 1));
+		if (this.#source === inner && this.#lines !== undefined) return this.#lines;
+		const rail = theme.bg("userMessageBg", theme.fg("customMessageLabel", theme.symbol("skill.rail")));
+		const lines = inner.map(line => rail + line);
+		this.#source = inner;
+		this.#lines = lines;
+		return lines;
+	}
+}

package/src/chat/skill-title-input.ts

@@ -0,0 +1,41 @@
+/** Compact title-model input for a user-invoked `/skill:<name>` prompt — also the draft a rewind restores. */
+export function skillPromptTitleInput(input: {
+	name?: string;
+	args?: string;
+	prompt?: string;
+	queueChipText?: string;
+}): string {
+	const chip = input.queueChipText?.trim();
+	if (chip) return chip;
+	const prompt = input.prompt?.trim();
+	if (prompt) return prompt;
+	const name = input.name?.trim();
+	const args = input.args?.trim();
+	if (name && args) return `/skill:${name} ${args}`;
+	if (name) return `/skill:${name}`;
+	return args ?? "";
+}
+
+/** Title text for a persisted skill-prompt custom message. Never the expanded SKILL.md body. */
+export function titleTextFromSkillPrompt(message: {
+	role: string;
+	customType?: string;
+	attribution?: string;
+	details?: unknown;
+}): string | undefined {
+	if (message.role !== "custom" || message.customType !== "skill-prompt" || message.attribution !== "user") {
+		return undefined;
+	}
+	let name: string | undefined;
+	let args: string | undefined;
+	let prompt: string | undefined;
+	let queueChipText: string | undefined;
+	if (message.details && typeof message.details === "object") {
+		const details = message.details as Record<string, unknown>;
+		if (typeof details.name === "string") name = details.name;
+		if (typeof details.args === "string") args = details.args;
+		if (typeof details.prompt === "string") prompt = details.prompt;
+		if (typeof details.__queueChipText === "string") queueChipText = details.__queueChipText;
+	}
+	return skillPromptTitleInput({ name, args, prompt, queueChipText }) || undefined;
+}

package/src/chat/stripped-tool-calls-placeholder.ts

@@ -0,0 +1,35 @@
+import { Text } from "../components/text";
+import { theme } from "../theme";
+
+/**
+ * Dim transcript marker for tool calls stripped from the resolved branch
+ * (failed/retried turns, results on sibling branches). It is tool activity,
+ * so it hides and reappears with the `display.hideToolActivity` toggle.
+ */
+export class StrippedToolCallsPlaceholder extends Text {
+	#toolActivityVisible: boolean;
+
+	constructor(strippedToolCalls: number, toolActivityVisible: boolean) {
+		super(
+			theme.fg(
+				"dim",
+				theme.italic(
+					`${strippedToolCalls} tool call${strippedToolCalls === 1 ? "" : "s"} elided — no result on this branch`,
+				),
+			),
+			1,
+			0,
+		);
+		this.#toolActivityVisible = toolActivityVisible;
+	}
+
+	setToolActivityVisible(visible: boolean): void {
+		this.#toolActivityVisible = visible;
+		this.invalidate();
+	}
+
+	override render(width: number): readonly string[] {
+		if (!this.#toolActivityVisible) return [];
+		return super.render(width);
+	}
+}