gsd-pi 2.73.1-dev.d987996 → 2.74.0-dev.0306a2e

package/packages/pi-coding-agent/src/core/compaction/utils.ts

@@ -218,7 +218,7 @@ export function serializeConversation(messages: Message[]): string {
 							.filter((c): c is { type: "text"; text: string } => c.type === "text")
 							.map((c) => c.text)
 							.join("");
-			if (content) parts.push(`[User]: ${content}`);
+			if (content) parts.push(`**User said:** ${content}`);
 		} else if (msg.role === "assistant") {
 			const textParts: string[] = [];
 			const thinkingParts: string[] = [];
@@ -239,13 +239,13 @@ export function serializeConversation(messages: Message[]): string {
 			}
 
 			if (thinkingParts.length > 0) {
-				parts.push(`[Assistant thinking]: ${thinkingParts.join("\n")}`);
+				parts.push(`**Assistant thinking:** ${thinkingParts.join("\n")}`);
 			}
 			if (textParts.length > 0) {
-				parts.push(`[Assistant]: ${textParts.join("\n")}`);
+				parts.push(`**Assistant responded:** ${textParts.join("\n")}`);
 			}
 			if (toolCalls.length > 0) {
-				parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+				parts.push(`**Assistant tool calls:** ${toolCalls.join("; ")}`);
 			}
 		} else if (msg.role === "toolResult") {
 			const content = msg.content
@@ -253,7 +253,7 @@ export function serializeConversation(messages: Message[]): string {
 				.map((c) => c.text)
 				.join("");
 			if (content) {
-				parts.push(`[Tool result]: ${truncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);
+				parts.push(`**Tool result:** ${truncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);
 			}
 		}
 	}

package/packages/pi-coding-agent/src/core/compaction-utils.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { Message } from "@gsd/pi-ai";
+
+import { serializeConversation } from "./compaction/index.js";
+
+test("serializeConversation uses narrative role markers instead of chat-style delimiters (#4054)", () => {
+	const messages: Message[] = [
+		{ role: "user", content: "Please refactor the parser." } as Message,
+		{
+			role: "assistant",
+			content: [
+				{ type: "thinking", thinking: "I should inspect the parser entry points first." },
+				{ type: "text", text: "I'll start with the parser entry points." },
+				{ type: "toolCall", id: "tool-1", name: "Read", arguments: { path: "src/parser.ts" } },
+			],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "stop",
+			timestamp: Date.now(),
+		} as Message,
+		{
+			role: "toolResult",
+			content: [{ type: "text", text: "parser contents" }],
+			toolName: "Read",
+			toolCallId: "tool-1",
+		} as Message,
+	];
+
+	const serialized = serializeConversation(messages);
+
+	assert.match(serialized, /\*\*User said:\*\* Please refactor the parser\./);
+	assert.match(serialized, /\*\*Assistant thinking:\*\* I should inspect the parser entry points first\./);
+	assert.match(serialized, /\*\*Assistant responded:\*\* I'll start with the parser entry points\./);
+	assert.match(serialized, /\*\*Assistant tool calls:\*\* Read\(path="src\/parser\.ts"\)/);
+	assert.match(serialized, /\*\*Tool result:\*\* parser contents/);
+	assert.ok(!serialized.includes("[User]:"), "chat-style [User]: markers should not remain");
+	assert.ok(!serialized.includes("[Assistant]:"), "chat-style [Assistant]: markers should not remain");
+	assert.ok(!serialized.includes("[Tool result]:"), "chat-style [Tool result]: markers should not remain");
+});

package/packages/pi-coding-agent/src/core/model-registry-env-fallback.test.ts

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+
+function createRegistryWithCapturedResolver() {
+	let capturedResolver: ((provider: string) => string | undefined) | undefined;
+	const authStorage = {
+		setFallbackResolver: (resolver: (provider: string) => string | undefined) => {
+			capturedResolver = resolver;
+		},
+		onCredentialChange: () => {},
+		getOAuthProviders: () => [],
+		get: () => undefined,
+		hasAuth: () => false,
+		getApiKey: async () => undefined,
+	} as unknown as AuthStorage;
+
+	new ModelRegistry(authStorage, undefined);
+	assert.ok(capturedResolver, "ModelRegistry should register a fallback resolver");
+	return capturedResolver!;
+}
+
+describe("ModelRegistry env fallback resolver (#3782)", () => {
+	it("falls back to built-in provider env vars when models.json has no custom key", () => {
+		const prev = process.env.MINIMAX_API_KEY;
+		process.env.MINIMAX_API_KEY = "minimax-env-test-key";
+
+		try {
+			const resolver = createRegistryWithCapturedResolver();
+			assert.equal(
+				resolver("minimax"),
+				"minimax-env-test-key",
+				"fallback resolver should return built-in provider env keys",
+			);
+		} finally {
+			if (prev === undefined) {
+				delete process.env.MINIMAX_API_KEY;
+			} else {
+				process.env.MINIMAX_API_KEY = prev;
+			}
+		}
+	});
+
+	it("still returns undefined when no custom or built-in env key exists", () => {
+		const prev = process.env.MINIMAX_API_KEY;
+		delete process.env.MINIMAX_API_KEY;
+
+		try {
+			const resolver = createRegistryWithCapturedResolver();
+			assert.equal(resolver("minimax"), undefined);
+			assert.equal(resolver("totally-unknown-provider"), undefined);
+		} finally {
+			if (prev !== undefined) {
+				process.env.MINIMAX_API_KEY = prev;
+			}
+		}
+	});
+});

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

@@ -8,6 +8,7 @@ import {
 	type AssistantMessageEventStream,
 	type Context,
 	getApiProvider,
+	getEnvApiKey,
 	getModels,
 	getProviders,
 	type KnownProvider,
@@ -245,7 +246,7 @@ export class ModelRegistry {
 			if (keyConfig) {
 				return resolveConfigValue(keyConfig);
 			}
-			return undefined;
+			return getEnvApiKey(provider);
 		});
 
 		// Refresh models when credentials change (e.g., OAuth token refresh with new model limits)

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,17 +80,27 @@ 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()),
 		);
+		const hasTextContent = message.content.some((c) => c.type === "text" && c.text.trim().length > 0);
+		const hasToolContent = message.content.some((c) => c.type === "toolCall" || c.type === "serverToolUse");
+		// Claude Code often emits long reasoning blocks ahead of user-visible text/tool
+		// output in the same lifecycle. Keep chat output visible without requiring a
+		// manual thinking toggle every turn.
+		const shouldCapThinking = hasTextContent || hasToolContent || message.provider === "claude-code";
 
 		if (hasVisibleContent) {
 			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 +108,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()));
 
@@ -81,12 +120,16 @@ export class AssistantMessageComponent extends Container {
 					}
 				} else {
 					// Thinking traces in thinkingText color, italic
-					this.contentContainer.addChild(
-						new Markdown(content.thinking.trim(), 1, 0, this.markdownTheme, {
-							color: (text: string) => theme.fg("thinkingText", text),
-							italic: true,
-						}),
-					);
+					const thinkingMarkdown = new Markdown(content.thinking.trim(), 1, 0, this.markdownTheme, {
+						color: (text: string) => theme.fg("thinkingText", text),
+						italic: true,
+					});
+					// Keep visible chat output readable when thinking traces are long.
+					// Tool-bearing turns can stream text in a later assistant message.
+					if (shouldCapThinking) {
+						thinkingMarkdown.maxLines = 8;
+					}
+					this.contentContainer.addChild(thinkingMarkdown);
 					if (hasVisibleContentAfter) {
 						this.contentContainer.addChild(new Spacer(1));
 					}
@@ -94,30 +137,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]) + " "
 			: "";