gsd-pi 2.82.0-dev.3709f22a5 → 2.82.0-dev.57fd453e4

package/packages/pi-coding-agent/src/core/chat-controller-ordering.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for streamed interactive chat ordering.
 import assert from "node:assert/strict";
 import { test } from "node:test";
 
@@ -97,9 +99,7 @@ function createHost() {
 	return host;
 }
 
-test("chat-controller renders content blocks in content[] index order (tool-first stream)", async () => {
-	// ToolExecutionComponent uses the global theme singleton.
-	// Install a minimal no-op theme implementation for this unit test.
+function installTheme() {
 	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
 		fg: (_key: string, text: string) => text,
 		bg: (_key: string, text: string) => text,
@@ -107,6 +107,12 @@ test("chat-controller renders content blocks in content[] index order (tool-firs
 		italic: (text: string) => text,
 		truncate: (text: string) => text,
 	};
+}
+
+test("chat-controller renders content blocks in content[] index order (tool-first stream)", async () => {
+	// ToolExecutionComponent uses the global theme singleton.
+	// Install a minimal no-op theme implementation for this unit test.
+	installTheme();
 
 	const host = createHost();
 	const toolId = "mcp-tool-1";
@@ -168,6 +174,50 @@ test("chat-controller renders content blocks in content[] index order (tool-firs
 	assert.equal(host.chatContainer.children[1]?.constructor?.name, "AssistantMessageComponent");
 });
 
+test("chat-controller skips empty GPT reasoning blocks before tool-only turns", async () => {
+	installTheme();
+
+	const host = createHost();
+	host.getMarkdownThemeWithSettings = () => ({});
+	const toolId = "gpt-tool-1";
+	const toolCall = {
+		type: "toolCall",
+		id: toolId,
+		name: "read",
+		arguments: { filePath: "todo.js" },
+	};
+	const content = [
+		{ type: "thinking", thinking: "", thinkingSignature: "encrypted" },
+		toolCall,
+	];
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	await handleAgentEvent(
+		host,
+		{
+			type: "message_update",
+			message: makeAssistant(content),
+			assistantMessageEvent: {
+				type: "toolcall_end",
+				contentIndex: 1,
+				toolCall: {
+					...toolCall,
+					externalResult: {
+						content: [{ type: "text", text: "todo contents" }],
+						details: {},
+						isError: false,
+					},
+				},
+				partial: makeAssistant(content),
+			},
+		} as any,
+	);
+
+	assert.equal(host.chatContainer.children.length, 1, "empty reasoning should not create a blank assistant block");
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolExecutionComponent");
+});
+
 test("chat-controller renders serverToolUse before trailing text matching content[] index order", async () => {
 	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
 		fg: (_key: string, text: string) => text,

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -573,7 +573,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					const removed = modelRegistry.authStorage.removeLegacyOAuthCredential(resolvedProvider);
 					if (removed) {
 						console.warn(
-							`[auth] Removed unsupported Anthropic OAuth credential from auth.json (#3952).`,
+							`[auth] Removed unsupported Anthropic OAuth credential from auth.json.`,
 						);
 					}
 					if (isClaudeCodeBinaryInPath()) {

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

@@ -1,4 +1,5 @@
-// GSD-2 Interactive Chat Controller
+// Project/App: GSD-2
+// File Purpose: Interactive TUI chat stream controller.
 import { Loader, Markdown, Spacer, Text } from "@gsd/pi-tui";
 
 import type { InteractiveModeEvent, InteractiveModeStateHost } from "../interactive-mode-state.js";
@@ -31,18 +32,77 @@ type RenderedSegment =
 	| { kind: "tool"; contentIndex: number; component: ToolExecutionComponent }
 	| { kind: "tool-summary"; component: ToolPhaseSummaryComponent; phases: ToolExecutionPhase[] };
 
+type DesiredSegment =
+	| { kind: "text-run"; startIndex: number; endIndex: number; contentType: "text" | "thinking" }
+	| { kind: "tool"; contentIndex: number; toolId: string };
+
 let renderedSegments: RenderedSegment[] = [];
 // When providers reuse one assistant lifecycle across internal sub-turns,
 // a content[] shrink resets renderedSegments. Keep the displaced segments so
 // claude-code MCP pruning can remove stale provisional text later.
 let orphanedSegments: RenderedSegment[] = [];
 
+function getVisibleTextLikeBlockType(block: any): "text" | "thinking" | undefined {
+	if (block?.type === "text" && typeof block.text === "string" && block.text.trim().length > 0) return "text";
+	if (block?.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim().length > 0) return "thinking";
+	return undefined;
+}
+
+function buildDesiredSegments(
+	blocks: Array<any>,
+	options: { shouldSkipTextBlock?: (block: any, index: number) => boolean } = {},
+): DesiredSegment[] {
+	const desired: DesiredSegment[] = [];
+	let runStart = -1;
+	let runEnd = -1;
+	let runType: "text" | "thinking" | undefined;
+	const closeRun = () => {
+		if (runStart !== -1 && runType) {
+			desired.push({ kind: "text-run", startIndex: runStart, endIndex: runEnd, contentType: runType });
+			runStart = -1;
+			runEnd = -1;
+			runType = undefined;
+		}
+	};
+
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		const blockType = getVisibleTextLikeBlockType(block);
+		const isInvisibleTextLike = blockType === undefined && (block?.type === "text" || block?.type === "thinking");
+		const isTool = block?.type === "toolCall" || block?.type === "serverToolUse";
+
+		if (blockType) {
+			if (options.shouldSkipTextBlock?.(block, i)) {
+				closeRun();
+				continue;
+			}
+			if (runStart === -1) {
+				runStart = i;
+				runEnd = i;
+				runType = blockType;
+			} else if (runType !== blockType) {
+				closeRun();
+				runStart = i;
+				runEnd = i;
+				runType = blockType;
+			} else {
+				runEnd = i;
+			}
+		} else {
+			if (isInvisibleTextLike) continue;
+			closeRun();
+			if (isTool) {
+				desired.push({ kind: "tool", contentIndex: i, toolId: block.id });
+			}
+		}
+	}
+	closeRun();
+
+	return desired;
+}
+
 function hasVisibleAssistantContent(message: { content: Array<any> }): boolean {
-	return message.content.some(
-		(c) =>
-			(c.type === "text" && typeof c.text === "string" && c.text.trim().length > 0)
-			|| (c.type === "thinking" && typeof c.thinking === "string" && c.thinking.trim().length > 0),
-	);
+	return message.content.some((c) => getVisibleTextLikeBlockType(c) !== undefined);
 }
 
 function hasAssistantToolBlocks(message: { content: Array<any> }): boolean {
@@ -470,59 +530,14 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					// Only prune provisional pre-tool prose after post-tool prose exists,
 					// so MCP tool-only windows do not blank the assistant content.
 					const shouldDropPreToolProse = isClaudeCodeProvider && hasMcpToolBlock && hasPostToolText;
-					type DesiredSegment =
-						| { kind: "text-run"; startIndex: number; endIndex: number; contentType: "text" | "thinking" }
-						| { kind: "tool"; contentIndex: number; toolId: string };
-				const desired: DesiredSegment[] = [];
-				let runStart = -1;
-				let runEnd = -1;
-				let runType: "text" | "thinking" | undefined;
-				const closeRun = () => {
-					if (runStart !== -1 && runType) {
-						desired.push({ kind: "text-run", startIndex: runStart, endIndex: runEnd, contentType: runType });
-						runStart = -1;
-						runEnd = -1;
-						runType = undefined;
-						}
-					};
-				for (let i = 0; i < blocks.length; i++) {
-					const b = blocks[i];
-					const blockType = b.type === "text" || b.type === "thinking" ? b.type : undefined;
-					const isTextLike = blockType === "text" || blockType === "thinking";
-					const isTool = b.type === "toolCall" || b.type === "serverToolUse";
-					// For Claude Code MCP turns, prune only pre-tool prose, never thinking.
-					const textValue = blockType === "text" && typeof b?.text === "string" ? b.text : "";
-					const isLikelyQuestion = blockType === "text" && typeof textValue === "string" && /\?\s*$/.test(textValue.trim());
-					const shouldSkipProse = shouldDropPreToolProse
-						&& firstToolIdx >= 0
-						&& i < firstToolIdx
-						&& blockType === "text"
-						&& !isLikelyQuestion;
-					if (shouldSkipProse) {
-						closeRun();
-						continue;
-					}
-						if (isTextLike) {
-							if (runStart === -1) {
-								runStart = i;
-								runEnd = i;
-								runType = blockType;
-							} else if (runType !== blockType) {
-								closeRun();
-								runStart = i;
-								runEnd = i;
-								runType = blockType;
-							} else {
-								runEnd = i;
-							}
-						} else {
-							closeRun();
-							if (isTool) {
-								desired.push({ kind: "tool", contentIndex: i, toolId: b.id });
-							}
-						}
-					}
-					closeRun();
+					const desired = buildDesiredSegments(blocks, {
+						shouldSkipTextBlock: (block: any, index: number) => {
+							if (!shouldDropPreToolProse || firstToolIdx < 0 || index >= firstToolIdx) return false;
+							if (getVisibleTextLikeBlockType(block) !== "text") return false;
+							const textValue = typeof block?.text === "string" ? block.text : "";
+							return !/\?\s*$/.test(textValue.trim());
+						},
+					});
 
 					// Claude Code MCP can emit provisional pre-tool prose that gets
 					// superseded by post-tool output. Prune stale text-run segments so
@@ -742,49 +757,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					// ranges/components don't keep stale partial indices.
 					if (renderedSegments.length > 0) {
 						const finalBlocks = host.streamingMessage.content;
-						type DesiredSegment =
-							| { kind: "text-run"; startIndex: number; endIndex: number; contentType: "text" | "thinking" }
-							| { kind: "tool"; contentIndex: number; toolId: string };
-						const desired: DesiredSegment[] = [];
-						let runStart = -1;
-						let runEnd = -1;
-						let runType: "text" | "thinking" | undefined;
-						const closeRun = () => {
-							if (runStart !== -1 && runType) {
-								desired.push({ kind: "text-run", startIndex: runStart, endIndex: runEnd, contentType: runType });
-								runStart = -1;
-								runEnd = -1;
-								runType = undefined;
-							}
-						};
-
-						for (let i = 0; i < finalBlocks.length; i++) {
-							const block = finalBlocks[i] as any;
-							const blockType = block?.type === "text" || block?.type === "thinking" ? block.type : undefined;
-							const isTextLike = blockType === "text" || blockType === "thinking";
-							const isTool = block?.type === "toolCall" || block?.type === "serverToolUse";
-
-							if (isTextLike) {
-								if (runStart === -1) {
-									runStart = i;
-									runEnd = i;
-									runType = blockType;
-								} else if (runType !== blockType) {
-									closeRun();
-									runStart = i;
-									runEnd = i;
-									runType = blockType;
-								} else {
-									runEnd = i;
-								}
-							} else {
-								closeRun();
-								if (isTool) {
-									desired.push({ kind: "tool", contentIndex: i, toolId: block.id });
-								}
-							}
-						}
-						closeRun();
+						const desired = buildDesiredSegments(finalBlocks);
 
 						const toolComponentsById = new Map<string, ToolExecutionComponent>();
 						for (const [toolId, component] of host.pendingTools.entries()) {

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode-ordering.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for interactive assistant replay ordering.
 import assert from "node:assert/strict";
 import { test } from "node:test";
 
@@ -42,3 +44,15 @@ test("buildAssistantReplaySegments ignores non-rendered non-tool blocks", () =>
 		{ kind: "assistant", startIndex: 2, endIndex: 2 },
 	]);
 });
+
+test("buildAssistantReplaySegments skips empty GPT reasoning blocks before tools", () => {
+	const segments = buildAssistantReplaySegments([
+		{ type: "thinking", thinking: "", thinkingSignature: "encrypted" },
+		{ type: "text", text: "   " },
+		{ type: "toolCall", id: "t1", name: "read", arguments: { filePath: "todo.js" } },
+	]);
+
+	assert.deepEqual(segments, [
+		{ kind: "tool", contentIndex: 2 },
+	]);
+});

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -134,6 +134,13 @@ export type AssistantReplaySegment =
 	| { kind: "assistant"; startIndex: number; endIndex: number }
 	| { kind: "tool"; contentIndex: number };
 
+function isVisibleAssistantReplayText(block: any): boolean {
+	return (
+		(block?.type === "text" && typeof block.text === "string" && block.text.trim().length > 0)
+		|| (block?.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim().length > 0)
+	);
+}
+
 /**
  * Build replay segments for historical assistant messages so rebuild paths
  * preserve the original content[] ordering between assistant prose and tools.
@@ -141,30 +148,38 @@ export type AssistantReplaySegment =
 export function buildAssistantReplaySegments(contentBlocks: Array<any>): AssistantReplaySegment[] {
 	const segments: AssistantReplaySegment[] = [];
 	let runStart = -1;
+	let runEnd = -1;
+
+	const closeRun = () => {
+		if (runStart !== -1) {
+			segments.push({ kind: "assistant", startIndex: runStart, endIndex: runEnd });
+			runStart = -1;
+			runEnd = -1;
+		}
+	};
 
 	for (let i = 0; i < contentBlocks.length; i++) {
 		const block = contentBlocks[i];
-		const isAssistantText = block?.type === "text" || block?.type === "thinking";
+		const isAssistantText = isVisibleAssistantReplayText(block);
+		const isInvisibleAssistantText = block?.type === "text" || block?.type === "thinking";
 		const isTool = block?.type === "toolCall" || block?.type === "serverToolUse";
 
 		if (isAssistantText) {
 			if (runStart === -1) runStart = i;
+			runEnd = i;
 			continue;
 		}
 
-		if (runStart !== -1) {
-			segments.push({ kind: "assistant", startIndex: runStart, endIndex: i - 1 });
-			runStart = -1;
-		}
+		if (isInvisibleAssistantText) continue;
+
+		closeRun();
 
 		if (isTool) {
 			segments.push({ kind: "tool", contentIndex: i });
 		}
 	}
 
-	if (runStart !== -1) {
-		segments.push({ kind: "assistant", startIndex: runStart, endIndex: contentBlocks.length - 1 });
-	}
+	closeRun();
 
 	return segments;
 }