gsd-pi 2.67.0-dev.5399650 → 2.67.0-dev.fe39184

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/tool-execution.test.ts

@@ -0,0 +1,54 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+import { ToolExecutionComponent } from "../tool-execution.js";
+import { initTheme } from "../../theme/theme.js";
+
+initTheme("dark", false);
+
+function renderTool(
+	toolName: string,
+	args: Record<string, unknown>,
+	result?: {
+		content: Array<{ type: string; text?: string }>;
+		isError: boolean;
+		details?: Record<string, unknown>;
+	},
+): string {
+	const component = new ToolExecutionComponent(
+		toolName,
+		args,
+		{},
+		undefined,
+		{ requestRender() {} } as any,
+	);
+	component.setExpanded(true);
+	if (result) component.updateResult(result);
+	return stripAnsi(component.render(120).join("\n"));
+}
+
+describe("ToolExecutionComponent", () => {
+	test("renders capitalized Claude Code Bash tool names with bash output instead of generic args JSON", () => {
+		const rendered = renderTool(
+			"Bash",
+			{ command: "pwd" },
+			{ content: [{ type: "text", text: "/tmp/gsd-pr-fix" }], isError: false },
+		);
+
+		assert.match(rendered, /\$ pwd/);
+		assert.match(rendered, /\/tmp\/gsd-pr-fix/);
+		assert.doesNotMatch(rendered, /^\{\s*\}$/m);
+	});
+
+	test("renders capitalized Claude Code Read tool names with read output", () => {
+		const rendered = renderTool(
+			"Read",
+			{ path: "/tmp/demo.txt" },
+			{ content: [{ type: "text", text: "hello\nworld" }], isError: false },
+		);
+
+		assert.match(rendered, /read .*demo\.txt/);
+		assert.match(rendered, /hello/);
+		assert.match(rendered, /world/);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/components/tool-execution.ts

@@ -97,6 +97,10 @@ export class ToolExecutionComponent extends Container {
 	// When true, this component intentionally renders no lines
 	private hideComponent = false;
 
+	private get normalizedToolName(): string {
+		return typeof this.toolName === "string" ? this.toolName.toLowerCase() : "";
+	}
+
 	constructor(
 		toolName: string,
 		args: any,
@@ -121,7 +125,7 @@ export class ToolExecutionComponent extends Container {
 
 		// Use contentBox for bash (visual truncation) or custom tools with custom renderers
 		// Use contentText for built-in tools (including overrides without custom renderers)
-		if (toolName === "bash" || (toolDefinition && !this.shouldUseBuiltInRenderer())) {
+		if (this.normalizedToolName === "bash" || (toolDefinition && !this.shouldUseBuiltInRenderer())) {
 			this.addChild(this.contentBox);
 		} else {
 			this.addChild(this.contentText);
@@ -136,7 +140,8 @@ export class ToolExecutionComponent extends Container {
 	 * or the toolDefinition doesn't provide custom renderers.
 	 */
 	private shouldUseBuiltInRenderer(): boolean {
-		const isBuiltInName = this.toolName in allTools;
+		const normalizedToolName = this.normalizedToolName;
+		const isBuiltInName = normalizedToolName in allTools;
 		const hasCustomRenderers = this.toolDefinition?.renderCall || this.toolDefinition?.renderResult;
 		return isBuiltInName && !hasCustomRenderers;
 	}
@@ -152,7 +157,7 @@ export class ToolExecutionComponent extends Container {
 
 	updateArgs(args: any): void {
 		this.args = args;
-		if (this.toolName === "write" && this.isPartial) {
+		if (this.normalizedToolName === "write" && this.isPartial) {
 			this.updateWriteHighlightCacheIncremental();
 		}
 		this.updateDisplay();
@@ -308,7 +313,7 @@ export class ToolExecutionComponent extends Container {
 	): void {
 		this.result = result;
 		this.isPartial = isPartial;
-		if (this.toolName === "write" && !isPartial) {
+		if (this.normalizedToolName === "write" && !isPartial) {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const fileContent = str(this.args?.content);
 			if (rawPath !== null && fileContent !== null) {
@@ -387,7 +392,7 @@ export class ToolExecutionComponent extends Container {
 
 		// Use built-in rendering for built-in tools (or overrides without custom renderers)
 		if (useBuiltInRenderer) {
-			if (this.toolName === "bash") {
+			if (this.normalizedToolName === "bash") {
 				// Bash uses Box with visual line truncation
 				this.contentBox.setBgFn(bgFn);
 				this.contentBox.clear();
@@ -629,8 +634,9 @@ export class ToolExecutionComponent extends Container {
 	private formatToolExecution(): string {
 		let text = "";
 		const invalidArg = theme.fg("error", "[invalid arg]");
+		const normalizedToolName = this.normalizedToolName;
 
-		if (this.toolName === "read") {
+		if (normalizedToolName === "read") {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath) : null;
 			const offset = this.args?.offset;
@@ -692,7 +698,7 @@ export class ToolExecutionComponent extends Container {
 					}
 				}
 			}
-		} else if (this.toolName === "write") {
+		} else if (normalizedToolName === "write") {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const fileContent = str(this.args?.content);
 			const path = rawPath !== null ? shortenPath(rawPath) : null;
@@ -751,7 +757,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n\n${theme.fg("error", errorText)}`;
 				}
 			}
-		} else if (this.toolName === "edit") {
+		} else if (normalizedToolName === "edit") {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath) : null;
 
@@ -787,7 +793,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n\n${renderDiff(this.editDiffPreview.diff, { filePath: rawPath ?? undefined })}`;
 				}
 			}
-		} else if (this.toolName === "ls") {
+		} else if (normalizedToolName === "ls") {
 			const rawPath = str(this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
 			const limit = this.args?.limit;
@@ -824,7 +830,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
 				}
 			}
-		} else if (this.toolName === "find") {
+		} else if (normalizedToolName === "find") {
 			const pattern = str(this.args?.pattern);
 			const rawPath = str(this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
@@ -866,7 +872,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
 				}
 			}
-		} else if (this.toolName === "grep") {
+		} else if (normalizedToolName === "grep") {
 			const pattern = str(this.args?.pattern);
 			const rawPath = str(this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
@@ -916,7 +922,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
 				}
 			}
-		} else if (this.toolName === "web_search") {
+		} else if (normalizedToolName === "web_search") {
 			// Server-side Anthropic web search
 			text = theme.fg("toolTitle", theme.bold("web search"));
 

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

@@ -121,6 +121,27 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 			if (host.streamingComponent && event.message.role === "assistant") {
 				host.streamingMessage = event.message;
 				host.streamingComponent.updateContent(host.streamingMessage);
+
+				// When the stream adapter signals a completed tool call with an
+				// external result (from Claude Code SDK), update the pending
+				// ToolExecutionComponent immediately so output is visible in
+				// real-time instead of waiting for the session to end.
+				const innerEvent = event.assistantMessageEvent;
+				if (innerEvent.type === "toolcall_end" && innerEvent.toolCall) {
+					const tc = innerEvent.toolCall as any;
+					const externalResult = tc.externalResult;
+					if (externalResult) {
+						const component = host.pendingTools.get(tc.id);
+						if (component) {
+							component.updateResult({
+								content: externalResult.content ?? [{ type: "text", text: "" }],
+								details: externalResult.details ?? {},
+								isError: externalResult.isError ?? false,
+							});
+						}
+					}
+				}
+
 				const contentBlocks = host.streamingMessage.content;
 				for (let i = lastProcessedContentIndex; i < contentBlocks.length; i++) {
 					const content = contentBlocks[i];

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

@@ -82,7 +82,6 @@ import { LoginDialogComponent } from "./components/login-dialog.js";
 import { ModelSelectorComponent, providerDisplayName } from "./components/model-selector.js";
 import { OAuthSelectorComponent } from "./components/oauth-selector.js";
 import { ProviderManagerComponent } from "./components/provider-manager.js";
-import { getProviderSetupAction } from "./provider-auth-setup.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
@@ -3413,21 +3412,9 @@ export class InteractiveMode {
 					this.ui.requestRender();
 				},
 				async (provider: string) => {
+					// Enter key → auth setup for selected provider (#3579)
 					done();
-
-					const action = getProviderSetupAction({
-						provider,
-						authMode: this.session.modelRegistry.getProviderAuthMode(provider),
-						hasAuth: this.session.modelRegistry.authStorage.hasAuth(provider),
-					});
-
-					if (action.kind === "oauth-login") {
-						await this.showLoginDialog(provider);
-						return;
-					}
-
-					this.showStatus(action.message);
-					this.ui.requestRender();
+					await this.showLoginDialog(provider);
 				},
 			);
 			return { component, focus: component };

package/src/resources/extensions/claude-code-cli/stream-adapter.ts

@@ -14,6 +14,7 @@ import type {
 	Context,
 	Model,
 	SimpleStreamOptions,
+	ToolCall,
 } from "@gsd/pi-ai";
 import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
@@ -24,8 +25,26 @@ import type {
 	SDKMessage,
 	SDKPartialAssistantMessage,
 	SDKResultMessage,
+	SDKUserMessage,
 } from "./sdk-types.js";
 
+export interface ExternalToolResultContentBlock {
+	type: string;
+	text?: string;
+	data?: string;
+	mimeType?: string;
+}
+
+export interface ExternalToolResultPayload {
+	content: ExternalToolResultContentBlock[];
+	details?: Record<string, unknown>;
+	isError: boolean;
+}
+
+type ToolCallWithExternalResult = ToolCall & {
+	externalResult?: ExternalToolResultPayload;
+};
+
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -153,89 +172,6 @@ export function makeStreamExhaustedErrorMessage(model: string, lastTextContent:
 	return message;
 }
 
-/**
- * Claude Code executes its own internal tool loop inside the SDK call. The
- * streamed and final assistant messages should therefore contain only
- * user-facing content (text/thinking), not replayable tool blocks that GSD
- * would render again.
- */
-function isUserFacingClaudeCodeBlock(block: AssistantMessage["content"][number]): boolean {
-	return block.type === "text" || block.type === "thinking";
-}
-
-function filterUserFacingClaudeCodeContent(
-	blocks: AssistantMessage["content"],
-): AssistantMessage["content"] {
-	return blocks.filter(isUserFacingClaudeCodeBlock);
-}
-
-function remapClaudeCodeContentIndex(
-	blocks: AssistantMessage["content"],
-	contentIndex: number,
-): number {
-	let visibleCount = 0;
-	for (let i = 0; i <= contentIndex && i < blocks.length; i++) {
-		if (isUserFacingClaudeCodeBlock(blocks[i]!)) visibleCount++;
-	}
-	return Math.max(0, visibleCount - 1);
-}
-
-function sanitizeClaudeCodePartial(
-	partial: AssistantMessage,
-): AssistantMessage {
-	return {
-		...partial,
-		content: filterUserFacingClaudeCodeContent(partial.content),
-	};
-}
-
-export function sanitizeClaudeCodeStreamingEvent(
-	event: AssistantMessageEvent,
-): AssistantMessageEvent | null {
-	switch (event.type) {
-		case "toolcall_start":
-		case "toolcall_delta":
-		case "toolcall_end":
-		case "server_tool_use":
-		case "web_search_result":
-			return null;
-		case "text_start":
-		case "text_delta":
-		case "text_end":
-		case "thinking_start":
-		case "thinking_delta":
-		case "thinking_end":
-			return {
-				...event,
-				contentIndex: remapClaudeCodeContentIndex(event.partial.content, event.contentIndex),
-				partial: sanitizeClaudeCodePartial(event.partial),
-			};
-		default:
-			return event;
-	}
-}
-
-export function buildFinalClaudeCodeContent(
-	blocks: AssistantMessage["content"],
-	lastThinkingContent: string,
-	lastTextContent: string,
-	resultText?: string,
-): AssistantMessage["content"] {
-	const finalContent = filterUserFacingClaudeCodeContent(blocks);
-	if (finalContent.length > 0) return finalContent;
-
-	if (lastThinkingContent) {
-		finalContent.push({ type: "thinking", thinking: lastThinkingContent });
-	}
-	if (lastTextContent) {
-		finalContent.push({ type: "text", text: lastTextContent });
-	}
-	if (finalContent.length === 0 && resultText) {
-		finalContent.push({ type: "text", text: resultText });
-	}
-	return finalContent;
-}
-
 // ---------------------------------------------------------------------------
 // SDK options builder
 // ---------------------------------------------------------------------------
@@ -263,6 +199,110 @@ export function buildSdkOptions(modelId: string, prompt: string): Record<string,
 	};
 }
 
+function normalizeToolResultContent(content: unknown): ExternalToolResultContentBlock[] {
+	if (typeof content === "string") {
+		return [{ type: "text", text: content }];
+	}
+
+	if (!Array.isArray(content)) {
+		if (content == null) return [{ type: "text", text: "" }];
+		return [{ type: "text", text: JSON.stringify(content) }];
+	}
+
+	const blocks: ExternalToolResultContentBlock[] = [];
+
+	for (const item of content) {
+		if (typeof item === "string") {
+			blocks.push({ type: "text", text: item });
+			continue;
+		}
+		if (!item || typeof item !== "object") {
+			blocks.push({ type: "text", text: String(item) });
+			continue;
+		}
+
+		const block = item as Record<string, unknown>;
+		if (block.type === "text") {
+			blocks.push({ type: "text", text: typeof block.text === "string" ? block.text : "" });
+			continue;
+		}
+		if (
+			block.type === "image"
+			&& typeof block.data === "string"
+			&& typeof block.mimeType === "string"
+		) {
+			blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+			continue;
+		}
+
+		blocks.push({ type: "text", text: JSON.stringify(block) });
+	}
+
+	return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+
+export function extractToolResultsFromSdkUserMessage(message: SDKUserMessage): Array<{
+	toolUseId: string;
+	result: ExternalToolResultPayload;
+}> {
+	const extracted: Array<{ toolUseId: string; result: ExternalToolResultPayload }> = [];
+	const seen = new Set<string>();
+	const rawMessage = message.message as Record<string, unknown> | null | undefined;
+	const content = Array.isArray(rawMessage?.content) ? rawMessage.content : [];
+
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const block = item as Record<string, unknown>;
+		const type = typeof block.type === "string" ? block.type : "";
+		if (type !== "tool_result" && type !== "mcp_tool_result") continue;
+
+		const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
+		if (!toolUseId || seen.has(toolUseId)) continue;
+		seen.add(toolUseId);
+
+		extracted.push({
+			toolUseId,
+			result: {
+				content: normalizeToolResultContent(block.content),
+				details: {},
+				isError: block.is_error === true,
+			},
+		});
+	}
+
+	if (extracted.length === 0) {
+		const fallback = message.tool_use_result;
+		if (fallback && typeof fallback === "object") {
+			const toolResult = fallback as Record<string, unknown>;
+			const toolUseId = typeof toolResult.tool_use_id === "string" ? toolResult.tool_use_id : "";
+			if (toolUseId) {
+				extracted.push({
+					toolUseId,
+					result: {
+						content: normalizeToolResultContent(toolResult.content),
+						details: {},
+						isError: toolResult.is_error === true,
+					},
+				});
+			}
+		}
+	}
+
+	return extracted;
+}
+
+function attachExternalResultsToToolCalls(
+	toolCalls: AssistantMessage["content"],
+	toolResultsById: ReadonlyMap<string, ExternalToolResultPayload>,
+): void {
+	for (const block of toolCalls) {
+		if (block.type !== "toolCall") continue;
+		const externalResult = toolResultsById.get(block.id);
+		if (!externalResult) continue;
+		(block as ToolCallWithExternalResult).externalResult = externalResult;
+	}
+}
+
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
@@ -297,6 +337,10 @@ async function pumpSdkMessages(
 	/** Track the last text content seen across all assistant turns for the final message. */
 	let lastTextContent = "";
 	let lastThinkingContent = "";
+	/** Collect tool calls from intermediate SDK turns for tool_execution events. */
+	const intermediateToolCalls: AssistantMessage["content"] = [];
+	/** Preserve real external tool results from Claude Code's synthetic user messages. */
+	const toolResultsById = new Map<string, ExternalToolResultPayload>();
 
 	try {
 		// Dynamic import — the SDK is an optional dependency.
@@ -365,10 +409,9 @@ async function pumpSdkMessages(
 					if (!builder) break;
 
 					const assistantEvent = builder.handleEvent(event);
-					const sanitizedEvent = assistantEvent
-						? sanitizeClaudeCodeStreamingEvent(assistantEvent)
-						: null;
-					if (sanitizedEvent) stream.push(sanitizedEvent);
+					if (assistantEvent) {
+						stream.push(assistantEvent);
+					}
 					break;
 				}
 
@@ -396,9 +439,39 @@ async function pumpSdkMessages(
 								lastTextContent = block.text;
 							} else if (block.type === "thinking" && block.thinking) {
 								lastThinkingContent = block.thinking;
+							} else if (block.type === "toolCall") {
+								// Collect tool calls for externalToolExecution rendering
+								intermediateToolCalls.push(block);
 							}
 						}
 					}
+
+					// Extract tool results from the SDK's synthetic user message
+					// and attach to corresponding tool call blocks immediately.
+					for (const { toolUseId, result } of extractToolResultsFromSdkUserMessage(msg as SDKUserMessage)) {
+						toolResultsById.set(toolUseId, result);
+					}
+					attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
+
+					// Push a synthetic toolcall_end for each tool call from this turn
+					// so the TUI can render tool results in real-time during the SDK
+					// session instead of waiting until the entire session completes.
+					if (builder) {
+						for (const block of builder.message.content) {
+							if (block.type !== "toolCall") continue;
+							const extResult = (block as ToolCallWithExternalResult).externalResult;
+							if (!extResult) continue;
+							// Push a toolcall_end with result attached so the chat-controller
+							// can call updateResult on the pending ToolExecutionComponent.
+							stream.push({
+								type: "toolcall_end",
+								contentIndex: builder.message.content.indexOf(block),
+								toolCall: block,
+								partial: builder.message,
+							});
+						}
+					}
+
 					builder = null;
 					break;
 				}
@@ -406,12 +479,36 @@ async function pumpSdkMessages(
 				// -- Result (terminal) --
 				case "result": {
 					const result = msg as SDKResultMessage;
-					const finalContent = buildFinalClaudeCodeContent(
-						builder?.message.content ?? [],
-						lastThinkingContent,
-						lastTextContent,
-						result.subtype === "success" ? result.result : undefined,
-					);
+
+					// Build final message. Include intermediate tool calls so the
+					// agent loop's externalToolExecution path emits tool_execution
+					// events for proper TUI rendering, followed by the text response.
+					const finalContent: AssistantMessage["content"] = [];
+
+					// Add tool calls from intermediate turns first (renders above text)
+					attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
+					finalContent.push(...intermediateToolCalls);
+
+					// Add text/thinking from the last turn
+					if (builder && builder.message.content.length > 0) {
+						for (const block of builder.message.content) {
+							if (block.type === "text" || block.type === "thinking") {
+								finalContent.push(block);
+							}
+						}
+					} else {
+						if (lastThinkingContent) {
+							finalContent.push({ type: "thinking", thinking: lastThinkingContent });
+						}
+						if (lastTextContent) {
+							finalContent.push({ type: "text", text: lastTextContent });
+						}
+					}
+
+					// Fallback: use the SDK's result text if we have no content
+					if (finalContent.length === 0 && result.subtype === "success" && result.result) {
+						finalContent.push({ type: "text", text: result.result });
+					}
 
 					const finalMessage: AssistantMessage = {
 						role: "assistant",