@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

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

@@ -2199,6 +2199,8 @@ interface SdkAttemptMessageState {
 	builder: PartialMessageBuilder | null;
 	intermediateToolBlocks: AssistantMessage["content"];
 	toolResultsById: Map<string, ExternalToolResultPayload>;
+	toolCompletionTargetsById: Map<string, { partial: AssistantMessage; contentIndex: number }>;
+	emittedExternalToolResultIds: Set<string>;
 }
 
 function createSdkAttemptMessageState(): SdkAttemptMessageState {
@@ -2206,6 +2208,8 @@ function createSdkAttemptMessageState(): SdkAttemptMessageState {
 		builder: null,
 		intermediateToolBlocks: [],
 		toolResultsById: new Map<string, ExternalToolResultPayload>(),
+		toolCompletionTargetsById: new Map<string, { partial: AssistantMessage; contentIndex: number }>(),
+		emittedExternalToolResultIds: new Set<string>(),
 	};
 }
 
@@ -2341,7 +2345,13 @@ async function pumpSdkMessages(
 
 			sdkAttemptLoop:
 			for (let readinessAttempt = 0; ; readinessAttempt++) {
-				let { builder, intermediateToolBlocks, toolResultsById } = createSdkAttemptMessageState();
+				let {
+					builder,
+					intermediateToolBlocks,
+					toolResultsById,
+					toolCompletionTargetsById,
+					emittedExternalToolResultIds,
+				} = createSdkAttemptMessageState();
 				const controller = new AbortController();
 				const forwardAbort = (): void => controller.abort();
 				if (options?.signal) {
@@ -2475,7 +2485,7 @@ async function pumpSdkMessages(
 						case "user": {
 							// Capture content from the completed turn before resetting
 							if (builder) {
-								for (const block of builder.message.content) {
+								for (const [contentIndex, block] of builder.message.content.entries()) {
 									if (block.type === "text" && block.text) {
 										lastTextContent = block.text;
 									} else if (block.type === "thinking" && block.thinking) {
@@ -2483,6 +2493,10 @@ async function pumpSdkMessages(
 									} else if (block.type === "toolCall" || block.type === "serverToolUse") {
 										// Collect tool blocks for externalToolExecution rendering
 										intermediateToolBlocks.push(block);
+										toolCompletionTargetsById.set(block.id, {
+											partial: builder.message,
+											contentIndex,
+										});
 									}
 								}
 							}
@@ -2497,59 +2511,63 @@ async function pumpSdkMessages(
 							// 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) {
-									const extResult = (block as ToolCallWithExternalResult).externalResult;
-									if (!extResult) continue;
-									const contentIndex = builder.message.content.indexOf(block);
-									if (contentIndex < 0) continue;
-									const suppressDuplicateUnavailable = shouldSuppressDuplicateToolUnavailableBlock(
-										block,
-										builder.message.content,
-									);
-									// Push synthetic completion events with result attached so the
-									// chat-controller can update pending ToolExecutionComponents.
-									if (block.type === "toolCall") {
-										if (suppressDuplicateUnavailable) {
-											delete (block as ToolCallWithExternalResult).externalResult;
-											stream.push({
-												type: "toolcall_end",
-												contentIndex,
-												toolCall: block,
-												partial: builder.message,
-											});
-											(block as ToolCallWithExternalResult).externalResult = extResult;
-											continue;
-										}
-										try {
-											await onExternalToolResult?.({
-												toolCall: block,
-												result: extResult,
-											});
-										} catch (error) {
-											console.warn("[claude-code] onExternalToolResult callback failed:", error);
-										}
+							for (const block of intermediateToolBlocks) {
+								if (block.type !== "toolCall" && block.type !== "serverToolUse") continue;
+								if (emittedExternalToolResultIds.has(block.id)) continue;
+								const target = toolCompletionTargetsById.get(block.id);
+								if (!target) continue;
+
+								const extResult = (block as ToolCallWithExternalResult).externalResult;
+								if (!extResult) continue;
+								const suppressDuplicateUnavailable = shouldSuppressDuplicateToolUnavailableBlock(
+									block,
+									target.partial.content,
+								);
+								// Push synthetic completion events with result attached so the
+								// chat-controller can update pending ToolExecutionComponents.
+								if (block.type === "toolCall") {
+									if (suppressDuplicateUnavailable) {
+										delete (block as ToolCallWithExternalResult).externalResult;
 										stream.push({
 											type: "toolcall_end",
-											contentIndex,
+											contentIndex: target.contentIndex,
 											toolCall: block,
-											partial: builder.message,
+											partial: target.partial,
 										});
-									} else if (block.type === "serverToolUse") {
-										try {
-											await onExternalToolResult?.({
-												toolCall: serverToolUseToToolCallLike(block),
-												result: extResult,
-											});
-										} catch (error) {
-											console.warn("[claude-code] onExternalToolResult callback failed:", error);
-										}
-										stream.push({
-											type: "server_tool_use",
-											contentIndex,
-											partial: builder.message,
+										(block as ToolCallWithExternalResult).externalResult = extResult;
+										emittedExternalToolResultIds.add(block.id);
+										continue;
+									}
+									try {
+										await onExternalToolResult?.({
+											toolCall: block,
+											result: extResult,
 										});
+									} catch (error) {
+										console.warn("[claude-code] onExternalToolResult callback failed:", error);
 									}
+									stream.push({
+										type: "toolcall_end",
+										contentIndex: target.contentIndex,
+										toolCall: block,
+										partial: target.partial,
+									});
+									emittedExternalToolResultIds.add(block.id);
+								} else if (block.type === "serverToolUse") {
+									try {
+										await onExternalToolResult?.({
+											toolCall: serverToolUseToToolCallLike(block),
+											result: extResult,
+										});
+									} catch (error) {
+										console.warn("[claude-code] onExternalToolResult callback failed:", error);
+									}
+									stream.push({
+										type: "server_tool_use",
+										contentIndex: target.contentIndex,
+										partial: target.partial,
+									});
+									emittedExternalToolResultIds.add(block.id);
 								}
 							}
 

package/src/resources/extensions/claude-code-cli/tests/index.test.ts

@@ -30,6 +30,20 @@ test("registers the claude-code provider with a streamSimple delegate", () => {
 	assert.equal(typeof providers[0].config.streamSimple, "function");
 });
 
+test("registers Claude Sonnet 5 as a Claude Code CLI model", () => {
+	const { pi, providers } = makeMockPi();
+	claudeCodeCli(pi as never);
+
+	const models = providers[0].config.models as Array<Record<string, unknown>>;
+	const sonnet5 = models.find((model) => model.id === "claude-sonnet-5");
+
+	assert.ok(sonnet5, "claude-sonnet-5 must be selectable via the claude-code provider");
+	assert.equal(sonnet5.name, "Claude Sonnet 5 (via Claude Code)");
+	assert.equal(sonnet5.reasoning, true);
+	assert.equal(sonnet5.contextWindow, 1_000_000);
+	assert.equal(sonnet5.maxTokens, 128_000);
+});
+
 test("registers a before_provider_request hook to capture the UI context", () => {
 	const { pi, handlers } = makeMockPi();
 	claudeCodeCli(pi as never);

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

@@ -661,6 +661,165 @@ describe("stream-adapter — no transcript fabrication (#4102)", () => {
 });
 
 describe("stream-adapter — Claude Code external tool results", () => {
+	test("emits one synthetic completion per tool when SDK sends consecutive user result messages (#1153)", async () => {
+		// Capture synthetic completions through onExternalToolResult, which the
+		// adapter invokes exactly once per tool at emission time. Filtering the
+		// collected toolcall_end events afterwards is unreliable here: the streaming
+		// toolcall_end (content_block_stop) and the synthetic completion reference
+		// the SAME tool-call block, and attachExternalResultsToToolBlocks mutates
+		// that block later, so a post-hoc `event.toolCall.externalResult` check also
+		// matches the earlier streaming ends and double-counts each tool.
+		const syntheticCompletions: Array<{ id: string; text: string | undefined }> = [];
+		const stream = streamViaClaudeCode(
+			{ id: "claude-sonnet-4-6" } as any,
+			{ messages: [{ role: "user", content: "Read and grep." } as Message] },
+			{
+				_skipWorkflowMcpPreflightForTest: true,
+				onExternalToolResult(event: {
+					toolCall: { id: string };
+					result: { content?: Array<{ text?: string }> };
+				}) {
+					syntheticCompletions.push({
+						id: event.toolCall.id,
+						text: event.result.content?.[0]?.text,
+					});
+				},
+				async *_sdkQueryForTest() {
+					yield {
+						type: "stream_event",
+						event: { type: "message_start", message: { model: "claude-sonnet-4-6" } },
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_start",
+							index: 0,
+							content_block: { type: "tool_use", id: "tool-read-1", name: "Read", input: {} },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_delta",
+							index: 0,
+							delta: { type: "input_json_delta", partial_json: "{\"file_path\":\"a.txt\"}" },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: { type: "content_block_stop", index: 0 },
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_start",
+							index: 1,
+							content_block: { type: "tool_use", id: "tool-grep-1", name: "Grep", input: {} },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_delta",
+							index: 1,
+							delta: { type: "input_json_delta", partial_json: "{\"pattern\":\"needle\"}" },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: { type: "content_block_stop", index: 1 },
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "user",
+						uuid: "user-result-1",
+						session_id: "session-1",
+						parent_tool_use_id: "tool-read-1",
+						message: {
+							role: "user",
+							content: [{
+								type: "tool_result",
+								tool_use_id: "tool-read-1",
+								content: "read result",
+								is_error: false,
+							}],
+						},
+					};
+					yield {
+						type: "user",
+						uuid: "user-result-2",
+						session_id: "session-1",
+						parent_tool_use_id: "tool-grep-1",
+						message: {
+							role: "user",
+							content: [{
+								type: "tool_result",
+								tool_use_id: "tool-grep-1",
+								content: "grep result",
+								is_error: false,
+							}],
+						},
+					};
+					yield {
+						type: "result",
+						subtype: "success",
+						uuid: "result-1",
+						session_id: "session-1",
+						duration_ms: 1,
+						duration_api_ms: 1,
+						is_error: false,
+						num_turns: 1,
+						result: "done",
+						stop_reason: "end_turn",
+						total_cost_usd: 0,
+						usage: {
+							input_tokens: 0,
+							output_tokens: 0,
+							cache_read_input_tokens: 0,
+							cache_creation_input_tokens: 0,
+						},
+					};
+				},
+			} as any,
+		);
+
+		// Drain the stream so the adapter processes every SDK message and fires
+		// onExternalToolResult for each synthetic completion.
+		const events: any[] = [];
+		for await (const event of stream) {
+			events.push(event);
+		}
+
+		assert.deepEqual(
+			syntheticCompletions.map((completion) => completion.id),
+			["tool-read-1", "tool-grep-1"],
+		);
+		assert.deepEqual(
+			syntheticCompletions.map((completion) => completion.text),
+			["read result", "grep result"],
+		);
+	});
+
 	test("serverToolUseToToolCallLike preserves object input for extension tool_result routing", () => {
 		const toolCall = serverToolUseToToolCallLike({
 			id: "srv-1",

package/src/resources/extensions/cursor-cli/index.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { CURSOR_AGENT_MODELS } from "./models.js";
+import { isCursorAgentReady } from "./readiness.js";
+import { streamViaCursorAgent } from "./stream-adapter.js";
+
+export default function cursorCli(pi: ExtensionAPI): void {
+	if (process.env.GSD_CURSOR_DISABLE === "1") return;
+
+	pi.registerProvider("cursor-agent", {
+		name: "Cursor Agent",
+		authMode: "externalCli",
+		api: "cursor-stream-json",
+		baseUrl: "local://cursor-agent",
+		isReady: isCursorAgentReady,
+		streamSimple: streamViaCursorAgent,
+		models: CURSOR_AGENT_MODELS,
+	});
+}

package/src/resources/extensions/cursor-cli/models.ts

@@ -0,0 +1,65 @@
+const ZERO_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+};
+
+const CURSOR_INPUT: ("text" | "image")[] = ["text"];
+
+export const CURSOR_AGENT_MODELS = [
+	{
+		id: "composer-2.5",
+		name: "Composer 2.5 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 64_000,
+	},
+	{
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 64_000,
+	},
+	{
+		id: "claude-opus-4-7",
+		name: "Claude Opus 4.7 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 128_000,
+	},
+	{
+		id: "gpt-5.5",
+		name: "GPT-5.5 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 128_000,
+	},
+	{
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+	},
+	{
+		id: "grok-4",
+		name: "Grok 4 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 256_000,
+		maxTokens: 64_000,
+	},
+];

package/src/resources/extensions/cursor-cli/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@gsd/cursor-cli",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/src/resources/extensions/cursor-cli/readiness.ts

@@ -0,0 +1,143 @@
+import { execFileSync } from "node:child_process";
+
+const VERSION_TIMEOUT_MS = 5_000;
+const STATUS_TIMEOUT_MS = 10_000;
+const CHECK_INTERVAL_MS = 30_000;
+
+let cachedBinaryPresent: boolean | null = null;
+let cachedAuthed: boolean | null = null;
+let lastCheckMs = 0;
+
+export function getCursorAgentCommand(platform: NodeJS.Platform = process.platform): string {
+	return platform === "win32" ? "cursor-agent.cmd" : "cursor-agent";
+}
+
+export function getCursorAgentCommandCandidates(platform: NodeJS.Platform = process.platform): string[] {
+	const command = getCursorAgentCommand(platform);
+	return platform === "win32" ? [command, "cursor-agent.exe", "cursor-agent"] : [command];
+}
+
+export function buildCursorAgentSpawnInvocation(
+	command: string,
+	args: string[],
+	platform: NodeJS.Platform = process.platform,
+): { command: string; args: string[] } {
+	if (platform === "win32") {
+		return { command: "cmd", args: ["/c", command, ...args] };
+	}
+	return { command, args };
+}
+
+function debugLog(...parts: unknown[]): void {
+	if (process.env.GSD_CURSOR_DEBUG) {
+		process.stderr.write(`[cursor-readiness] ${parts.map((part) => String(part)).join(" ")}\n`);
+	}
+}
+
+function spawnCursorAgent(command: string, args: string[], timeout: number): Buffer {
+	const invocation = buildCursorAgentSpawnInvocation(command, args);
+	return execFileSync(invocation.command, invocation.args, { timeout, stdio: "pipe" });
+}
+
+function findWorkingCommand(): string | null {
+	for (const command of getCursorAgentCommandCandidates()) {
+		try {
+			spawnCursorAgent(command, ["--version"], VERSION_TIMEOUT_MS);
+			debugLog("version probe ok via", command);
+			return command;
+		} catch (error) {
+			debugLog("version probe failed for", command, (error as Error).message?.slice(0, 200));
+		}
+	}
+	return null;
+}
+
+export function parseCursorAgentStatus(output: string): boolean | null {
+	const trimmed = output.trim();
+	if (!trimmed) return null;
+
+	if (trimmed.startsWith("{")) {
+		try {
+			const parsed = JSON.parse(trimmed) as Record<string, unknown>;
+			for (const key of ["authenticated", "loggedIn", "logged_in", "isAuthenticated"]) {
+				if (typeof parsed[key] === "boolean") return parsed[key];
+			}
+		} catch {
+			// Fall through to text heuristics.
+		}
+	}
+
+	const lower = trimmed.toLowerCase();
+	if (/not authenticated|not logged in|no credentials|logged out|unauthenticated/.test(lower)) return false;
+	if (/authenticated|logged in|signed in|cursor account|subscription/.test(lower)) return true;
+	return null;
+}
+
+export function isCursorAgentApiKeyValue(value: string | undefined): boolean {
+	const trimmed = value?.trim();
+	return Boolean(trimmed && trimmed !== "cli");
+}
+
+function hasCursorApiKey(): boolean {
+	return isCursorAgentApiKeyValue(process.env.CURSOR_API_KEY);
+}
+
+function probeAuth(command: string): boolean | null {
+	if (hasCursorApiKey()) return true;
+
+	for (const args of [["agent", "status", "--json"], ["status", "--json"], ["agent", "status"], ["status"]]) {
+		try {
+			const out = spawnCursorAgent(command, args, STATUS_TIMEOUT_MS).toString();
+			debugLog("status output", args.join(" "), out.slice(0, 200));
+			const parsed = parseCursorAgentStatus(out);
+			if (parsed !== null) return parsed;
+		} catch (error) {
+			debugLog("status failed", args.join(" "), (error as Error).message?.slice(0, 200));
+		}
+	}
+
+	return null;
+}
+
+export function isCursorAgentReadyUncached(): boolean {
+	const command = findWorkingCommand();
+	if (!command) return false;
+	return probeAuth(command) === true;
+}
+
+function refreshCache(): void {
+	const now = Date.now();
+	if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS) return;
+	lastCheckMs = now;
+
+	const command = findWorkingCommand();
+	if (!command) {
+		cachedBinaryPresent = false;
+		cachedAuthed = false;
+		return;
+	}
+
+	cachedBinaryPresent = true;
+	const authed = probeAuth(command);
+	if (authed === null) {
+		if (cachedAuthed === null) cachedAuthed = false;
+		return;
+	}
+	cachedAuthed = authed;
+}
+
+export function isCursorAgentBinaryPresent(): boolean {
+	refreshCache();
+	return cachedBinaryPresent ?? false;
+}
+
+export function isCursorAgentReady(): boolean {
+	refreshCache();
+	return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+
+export function clearCursorAgentReadinessCache(): void {
+	cachedBinaryPresent = null;
+	cachedAuthed = null;
+	lastCheckMs = 0;
+}