gsd-pi 2.73.0 → 2.73.1-dev.088d28f

package/packages/pi-coding-agent/src/core/model-resolver.ts

@@ -3,45 +3,13 @@
  */
 
 import type { ThinkingLevel } from "@gsd/pi-agent-core";
-import { type Api, type KnownProvider, type Model, modelsAreEqual } from "@gsd/pi-ai";
+import { type Api, type Model, modelsAreEqual } from "@gsd/pi-ai";
 import chalk from "chalk";
 import { minimatch } from "minimatch";
 import { isValidThinkingLevel } from "../cli/args.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import type { ModelRegistry } from "./model-registry.js";
 
-/** Default model IDs for each known provider */
-const defaultModelPerProvider: Record<KnownProvider, string> = {
-	"amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
-	anthropic: "claude-opus-4-6",
-	"anthropic-vertex": "claude-sonnet-4-6",
-	openai: "gpt-5.4",
-	"azure-openai-responses": "gpt-5.2",
-	"openai-codex": "gpt-5.4",
-	google: "gemini-2.5-pro",
-	"google-gemini-cli": "gemini-2.5-pro",
-	"google-antigravity": "gemini-3.1-pro-high",
-	"google-vertex": "gemini-3-pro-preview",
-	"github-copilot": "gpt-4o",
-	openrouter: "openai/gpt-5.1-codex",
-	"vercel-ai-gateway": "anthropic/claude-opus-4-6",
-	xai: "grok-4-fast-non-reasoning",
-	groq: "openai/gpt-oss-120b",
-	cerebras: "zai-glm-4.6",
-	zai: "glm-4.6",
-	mistral: "devstral-medium-latest",
-	minimax: "MiniMax-M2.1",
-	"minimax-cn": "MiniMax-M2.1",
-	huggingface: "moonshotai/Kimi-K2.5",
-	opencode: "claude-opus-4-6",
-	"opencode-go": "kimi-k2.5",
-	"kimi-coding": "kimi-k2-thinking",
-	"alibaba-coding-plan": "qwen3.5-plus",
-	"alibaba-dashscope": "qwen3.5-plus",
-	ollama: "llama3.1:8b",
-	"ollama-cloud": "qwen3:32b",
-};
-
 export interface ScopedModel {
 	model: Model<Api>;
 	/** Thinking level if explicitly specified in pattern (e.g., "model:high"), undefined otherwise */
@@ -123,10 +91,11 @@ function buildFallbackModel(provider: string, modelId: string, availableModels:
 	const providerModels = availableModels.filter((m) => m.provider === provider);
 	if (providerModels.length === 0) return undefined;
 
-	const defaultId = defaultModelPerProvider[provider as KnownProvider];
-	const baseModel = defaultId
-		? (providerModels.find((m) => m.id === defaultId) ?? providerModels[0])
-		: providerModels[0];
+	// Use the first available model from this provider as a template for
+	// capabilities (context window, reasoning support, etc.). The user is
+	// explicitly providing a custom model id, so we just need any shape of
+	// model from the same provider to inherit from.
+	const baseModel = providerModels[0];
 
 	return {
 		...baseModel,
@@ -503,33 +472,19 @@ export async function findInitialModel(options: {
 		};
 	}
 
-	// 3. Try saved default from settings
-	if (defaultProvider && defaultModelId) {
-		// Guard against stale settings defaults: only use the saved provider/model
-		// if the provider is actually request-ready (auth/OAuth/CLI ready).
-		if (modelRegistry.isProviderRequestReady(defaultProvider)) {
-			const found = modelRegistry.find(defaultProvider, defaultModelId);
-			if (found) {
-				// Check if the provider's recommended default is a higher-capability variant
-				// of the saved model (e.g. saved "claude-opus-4-6" vs recommended "claude-opus-4-6-extended").
-				// If so, prefer the recommended variant to avoid using a smaller context window (#1125).
-				const recommendedId = defaultModelPerProvider[defaultProvider as KnownProvider];
-				if (recommendedId && recommendedId !== defaultModelId && recommendedId.startsWith(defaultModelId)) {
-					const recommended = modelRegistry.find(defaultProvider, recommendedId);
-					if (recommended) {
-						model = recommended;
-						if (defaultThinkingLevel) {
-							thinkingLevel = defaultThinkingLevel;
-						}
-						return { model, thinkingLevel, fallbackMessage: undefined };
-					}
-				}
-				model = found;
-				if (defaultThinkingLevel) {
-					thinkingLevel = defaultThinkingLevel;
-				}
-				return { model, thinkingLevel, fallbackMessage: undefined };
+	// 3. Try saved default from settings — use it exactly as configured.
+	// Whatever the user chose is what gets used; no silent substitution.
+	// Skip the saved default if its provider is not request-ready (no auth
+	// available) so we fall through to an actually-usable model instead of
+	// returning a stale selection every selector surface would display.
+	if (defaultProvider && defaultModelId && modelRegistry.isProviderRequestReady(defaultProvider)) {
+		const found = modelRegistry.find(defaultProvider, defaultModelId);
+		if (found) {
+			model = found;
+			if (defaultThinkingLevel) {
+				thinkingLevel = defaultThinkingLevel;
 			}
+			return { model, thinkingLevel, fallbackMessage: undefined };
 		}
 	}
 
@@ -537,16 +492,17 @@ export async function findInitialModel(options: {
 	const availableModels = await modelRegistry.getAvailable();
 
 	if (availableModels.length > 0) {
-		// Try to find a default model from known providers
-		for (const provider of Object.keys(defaultModelPerProvider) as KnownProvider[]) {
-			const defaultId = defaultModelPerProvider[provider];
-			const match = availableModels.find((m) => m.provider === provider && m.id === defaultId);
-			if (match) {
-				return { model: match, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
+		// Prefer a model from the user's saved provider if any is still available —
+		// provider stickiness, not a hard-coded Anthropic/OpenAI preference.
+		if (defaultProvider) {
+			const sameProvider = availableModels.find((m) => m.provider === defaultProvider);
+			if (sameProvider) {
+				return { model: sameProvider, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
 			}
 		}
 
-		// If no default found, use first available
+		// Otherwise use the first available — registry order reflects models.json
+		// order, which the user controls.
 		return { model: availableModels[0], thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
 	}
 

package/packages/pi-coding-agent/src/modes/interactive/components/assistant-message.ts

@@ -3,8 +3,15 @@ import { Container, Markdown, type MarkdownTheme, Spacer, Text } from "@gsd/pi-t
 import { getMarkdownTheme, theme } from "../theme/theme.js";
 import { formatTimestamp, type TimestampFormat } from "./timestamp.js";
 
+export interface ContentRange {
+	startIndex: number;
+	endIndex: number;
+}
+
 /**
- * Component that renders a complete assistant message
+ * Component that renders a complete assistant message, or a sub-range of its content[].
+ * When `range` is provided, only content[startIndex..endIndex] (inclusive) is rendered.
+ * Non-text/thinking blocks within the range are silently skipped.
  */
 export class AssistantMessageComponent extends Container {
 	private contentContainer: Container;
@@ -12,18 +19,26 @@ export class AssistantMessageComponent extends Container {
 	private markdownTheme: MarkdownTheme;
 	private lastMessage?: AssistantMessage;
 	private timestampFormat: TimestampFormat;
+	private range?: ContentRange;
+	private showMetadata: boolean;
 
 	constructor(
 		message?: AssistantMessage,
 		hideThinkingBlock = false,
 		markdownTheme: MarkdownTheme = getMarkdownTheme(),
 		timestampFormat: TimestampFormat = "date-time-iso",
+		range?: ContentRange,
 	) {
 		super();
 
 		this.hideThinkingBlock = hideThinkingBlock;
 		this.markdownTheme = markdownTheme;
 		this.timestampFormat = timestampFormat;
+		this.range = range;
+		// No range = legacy full-message rendering; show metadata by default.
+		// Ranged (interleaved) instances start with metadata hidden; chat-controller
+		// calls setShowMetadata(true) on the last segment at message_end.
+		this.showMetadata = !range;
 
 		// Container for text/thinking content
 		this.contentContainer = new Container();
@@ -34,6 +49,20 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	setRange(range: ContentRange | undefined): void {
+		this.range = range;
+		if (this.lastMessage) {
+			this.updateContent(this.lastMessage);
+		}
+	}
+
+	setShowMetadata(show: boolean): void {
+		this.showMetadata = show;
+		if (this.lastMessage) {
+			this.updateContent(this.lastMessage);
+		}
+	}
+
 	override invalidate(): void {
 		super.invalidate();
 		if (this.lastMessage) {
@@ -51,7 +80,11 @@ export class AssistantMessageComponent extends Container {
 		// Clear content container
 		this.contentContainer.clear();
 
-		const hasVisibleContent = message.content.some(
+		const start = this.range?.startIndex ?? 0;
+		const end = this.range?.endIndex ?? message.content.length - 1;
+		const slice = message.content.slice(start, end + 1);
+
+		const hasVisibleContent = slice.some(
 			(c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()),
 		);
 
@@ -59,9 +92,9 @@ export class AssistantMessageComponent extends Container {
 			this.contentContainer.addChild(new Spacer(1));
 		}
 
-		// Render content in order
-		for (let i = 0; i < message.content.length; i++) {
-			const content = message.content[i];
+		// Render content in order; non-text/thinking blocks are silently skipped
+		for (let i = 0; i < slice.length; i++) {
+			const content = slice[i];
 			if (content.type === "text" && content.text.trim()) {
 				// Assistant text messages with no background - trim the text
 				// Set paddingY=0 to avoid extra spacing before tool executions
@@ -69,7 +102,7 @@ export class AssistantMessageComponent extends Container {
 			} else if (content.type === "thinking" && content.thinking.trim()) {
 				// Add spacing only when another visible assistant content block follows.
 				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
-				const hasVisibleContentAfter = message.content
+				const hasVisibleContentAfter = slice
 					.slice(i + 1)
 					.some((c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
 
@@ -94,30 +127,33 @@ export class AssistantMessageComponent extends Container {
 			}
 		}
 
-		// Check if aborted - show after partial content
-		// But only if there are no tool calls (tool execution components will show the error)
-		const hasToolCalls = message.content.some((c) => c.type === "toolCall");
-		if (!hasToolCalls) {
-			if (message.stopReason === "aborted") {
-				const abortMessage =
-					message.errorMessage && message.errorMessage !== "Request was aborted"
-						? message.errorMessage
-						: "Operation aborted";
-				if (hasVisibleContent) {
+		// Metadata (errors, timestamp): gated on showMetadata so ranged instances stay clean
+		// until chat-controller explicitly enables it on the last segment at message_end.
+		if (this.showMetadata) {
+			// Check if aborted - show after partial content
+			// But only if there are no tool calls (tool execution components will show the error)
+			const hasToolCalls = message.content.some((c) => c.type === "toolCall");
+			if (!hasToolCalls) {
+				if (message.stopReason === "aborted") {
+					const abortMessage =
+						message.errorMessage && message.errorMessage !== "Request was aborted"
+							? message.errorMessage
+							: "Operation aborted";
+					if (hasVisibleContent) {
+						this.contentContainer.addChild(new Spacer(1));
+					}
+					this.contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
+				} else if (message.stopReason === "error") {
+					const errorMsg = message.errorMessage || "Unknown error";
 					this.contentContainer.addChild(new Spacer(1));
+					this.contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
 				}
-				this.contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
-			} else if (message.stopReason === "error") {
-				const errorMsg = message.errorMessage || "Unknown error";
-				this.contentContainer.addChild(new Spacer(1));
-				this.contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
 			}
-		}
 
-		// Show timestamp when the message is complete (has a stop reason)
-		if (message.stopReason && message.timestamp) {
-			const timeStr = formatTimestamp(message.timestamp, this.timestampFormat);
-			this.contentContainer.addChild(new Text(theme.fg("dim", timeStr), 1, 0));
+			if (message.stopReason && message.timestamp) {
+				const timeStr = formatTimestamp(message.timestamp, this.timestampFormat);
+				this.contentContainer.addChild(new Text(theme.fg("dim", timeStr), 1, 0));
+			}
 		}
 	}
 }

package/packages/pi-coding-agent/src/modes/interactive/components/dynamic-border.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { describe, it, mock } from "node:test";
+
+import { DynamicBorder } from "./dynamic-border.js";
+
+function makeTUI() {
+	return {
+		renderCount: 0,
+		requestRender() {
+			this.renderCount++;
+		},
+	};
+}
+
+describe("DynamicBorder spinner", () => {
+	it("suppresses standalone render when an external render occurred recently", () => {
+		const border = new DynamicBorder((s) => s);
+		const tui = makeTUI();
+
+		border.startSpinner(tui as any, (s) => s);
+		// startSpinner calls requestRender once immediately
+		assert.equal(tui.renderCount, 1, "initial render on startSpinner");
+
+		// Simulate an externally-triggered render (e.g. from streaming)
+		border.render(80);
+
+		// Access the private interval callback by advancing the timer
+		// Instead, we directly test the render-batching logic:
+		// After render() sets lastExternalRender, a spinner tick within 200ms
+		// should NOT call requestRender.
+		const anyBorder = border as any;
+		assert.ok(
+			Date.now() - anyBorder.lastExternalRender < 200,
+			"lastExternalRender should be recent after render()",
+		);
+
+		border.stopSpinner();
+	});
+
+	it("triggers standalone render when no external render occurred recently", async () => {
+		const border = new DynamicBorder((s) => s);
+		const tui = makeTUI();
+
+		// Set lastExternalRender to a time well in the past
+		const anyBorder = border as any;
+		anyBorder.lastExternalRender = 0;
+
+		border.startSpinner(tui as any, (s) => s);
+		const initialCount = tui.renderCount;
+
+		// Wait for one spinner tick (200ms interval + buffer)
+		await new Promise((r) => setTimeout(r, 250));
+
+		assert.ok(
+			tui.renderCount > initialCount,
+			"spinner should trigger requestRender when no recent external render",
+		);
+
+		border.stopSpinner();
+	});
+
+	it("updates lastExternalRender on each render() call", () => {
+		const border = new DynamicBorder((s) => s);
+		const anyBorder = border as any;
+
+		const before = Date.now();
+		border.render(80);
+		const after = Date.now();
+
+		assert.ok(anyBorder.lastExternalRender >= before);
+		assert.ok(anyBorder.lastExternalRender <= after);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/components/dynamic-border.ts

@@ -17,6 +17,7 @@ export class DynamicBorder implements Component {
 	private spinnerIndex = 0;
 	private spinnerInterval: NodeJS.Timeout | null = null;
 	private spinnerColorFn?: (str: string) => string;
+	private lastExternalRender = 0;
 
 	constructor(color: (str: string) => string = (str) => {
 		try { return theme.fg("border", str); } catch { return str; }
@@ -31,7 +32,7 @@ export class DynamicBorder implements Component {
 
 	/**
 	 * Start an animated spinner that prepends to the label.
-	 * The spinner rotates every 80ms and triggers a re-render via the TUI.
+	 * The spinner rotates every 200ms and triggers a re-render via the TUI.
 	 */
 	startSpinner(ui: TUI, colorFn: (str: string) => string): void {
 		this.stopSpinner();
@@ -39,8 +40,12 @@ export class DynamicBorder implements Component {
 		this.spinnerIndex = 0;
 		this.spinnerInterval = setInterval(() => {
 			this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
-			ui.requestRender();
-		}, 80);
+			// Only trigger standalone render if no other source rendered recently.
+			// During active streaming, message_update already calls requestRender().
+			if (Date.now() - this.lastExternalRender > 200) {
+				ui.requestRender();
+			}
+		}, 200);
 		ui.requestRender();
 	}
 
@@ -64,6 +69,7 @@ export class DynamicBorder implements Component {
 	}
 
 	render(width: number): string[] {
+		this.lastExternalRender = Date.now();
 		const spinnerPrefix = this.spinnerInterval && this.spinnerColorFn
 			? this.spinnerColorFn(this.spinnerFrames[this.spinnerIndex]) + " "
 			: "";

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.test.ts

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { findLatestPinnableText } from "./chat-controller.js";
+
+test("findLatestPinnableText: empty content returns empty string", () => {
+	assert.equal(findLatestPinnableText([]), "");
+});
+
+test("findLatestPinnableText: no tool calls returns empty string", () => {
+	const blocks = [
+		{ type: "text", text: "hello" },
+		{ type: "text", text: "world" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "");
+});
+
+test("findLatestPinnableText: returns text preceding a tool call", () => {
+	const blocks = [
+		{ type: "text", text: "doing the thing" },
+		{ type: "toolCall", id: "1", name: "Read" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "doing the thing");
+});
+
+test("findLatestPinnableText: ignores trailing streaming text after the last tool call (regression: pinned mirror duplicated chat-container tokens)", () => {
+	const blocks = [
+		{ type: "text", text: "first prose" },
+		{ type: "toolCall", id: "1", name: "Read" },
+		{ type: "text", text: "second prose still streaming" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "first prose");
+});
+
+test("findLatestPinnableText: with multiple tools, picks text before the most recent tool call", () => {
+	const blocks = [
+		{ type: "text", text: "first" },
+		{ type: "toolCall", id: "1", name: "Read" },
+		{ type: "text", text: "second" },
+		{ type: "toolCall", id: "2", name: "Grep" },
+		{ type: "text", text: "third streaming" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "second");
+});
+
+test("findLatestPinnableText: treats serverToolUse the same as toolCall", () => {
+	const blocks = [
+		{ type: "text", text: "before web search" },
+		{ type: "serverToolUse", id: "ws1", name: "web_search" },
+		{ type: "text", text: "answer streaming" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "before web search");
+});
+
+test("findLatestPinnableText: skips empty/whitespace-only text blocks", () => {
+	const blocks = [
+		{ type: "text", text: "real prose" },
+		{ type: "text", text: "   " },
+		{ type: "text", text: "" },
+		{ type: "toolCall", id: "1", name: "Read" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "real prose");
+});
+
+test("findLatestPinnableText: thinking blocks are not pinnable", () => {
+	const blocks = [
+		{ type: "thinking", thinking: "internal" },
+		{ type: "toolCall", id: "1", name: "Read" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "");
+});