@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

package/src/resources/extensions/cursor-cli/stream-adapter.ts

@@ -0,0 +1,440 @@
+import { spawn } from "node:child_process";
+import type {
+	Api,
+	AssistantMessage,
+	AssistantMessageEventStream,
+	Context,
+	Message,
+	Model,
+	SimpleStreamOptions,
+	TextContent,
+	ToolCall,
+} from "@gsd/pi-ai";
+import { createAssistantMessageEventStream } from "@gsd/pi-ai";
+import { buildCursorAgentSpawnInvocation } from "./readiness.js";
+
+interface CursorAgentRunResult {
+	stdout: string;
+	stderr: string;
+	code: number | null;
+	signal: NodeJS.Signals | null;
+}
+
+export type CursorAgentLineHandler = (line: string) => void;
+
+export interface CursorAgentRunPlan {
+	command: string;
+	args: string[];
+}
+
+export interface CursorAgentStreamOptions extends SimpleStreamOptions {
+	_cursorAgentRunnerForTest?: (
+		plan: CursorAgentRunPlan,
+		options: SimpleStreamOptions | undefined,
+		onLine: CursorAgentLineHandler,
+	) => Promise<CursorAgentRunResult>;
+}
+
+type ExternalToolResult = NonNullable<ToolCall["externalResult"]>;
+
+type ParsedCursorAgentLine =
+	| { type: "text"; text: string }
+	| { type: "tool_call"; toolCall: ToolCall }
+	| { type: "tool_result"; toolCallId: string; result: ExternalToolResult }
+	| { type: "usage"; usage: Partial<AssistantMessage["usage"]> }
+	| { type: "error"; message: string }
+	| { type: "ignore" };
+
+const ZERO_USAGE: AssistantMessage["usage"] = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+function textBlocks(content: (TextContent | { type: string })[]): string {
+	return content
+		.map((block) => block.type === "text" ? (block as TextContent).text : `[${block.type} omitted]`)
+		.join("\n");
+}
+
+function messageToText(message: Message): string {
+	if (message.role === "user") {
+		const content = typeof message.content === "string" ? message.content : textBlocks(message.content);
+		return `User:\n${content}`;
+	}
+
+	if (message.role === "assistant") {
+		const text = message.content
+			.map((block) => {
+				if (block.type === "text") return block.text;
+				if (block.type === "thinking") return "[thinking omitted]";
+				if (block.type === "toolCall") return `[tool call: ${block.name}]`;
+				if (block.type === "serverToolUse") return `[server tool: ${block.name}]`;
+				if (block.type === "webSearchResult") return "[web search result omitted]";
+				return `[${(block as { type: string }).type} omitted]`;
+			})
+			.join("\n");
+		return `Assistant:\n${text}`;
+	}
+
+	return `Tool result (${message.toolName}):\n${textBlocks(message.content)}`;
+}
+
+export function buildCursorPrompt(context: Context): string {
+	const parts: string[] = [];
+	if (context.systemPrompt?.trim()) parts.push(`System instructions:\n${context.systemPrompt.trim()}`);
+	if (context.messages.length > 0) parts.push(context.messages.map(messageToText).join("\n\n"));
+	if (context.tools?.length) {
+		parts.push(
+			`The external Cursor agent may execute its own tools. ` +
+			`GSD will not redispatch Cursor-owned internal tool events locally. ` +
+			`Requested GSD tools: ${context.tools.map((tool) => tool.name).join(", ")}`,
+		);
+	}
+	return parts.join("\n\n").trim();
+}
+
+export function buildCursorSpawnInvocation(
+	command: string,
+	args: string[],
+	platform: NodeJS.Platform = process.platform,
+): CursorAgentRunPlan {
+	return buildCursorAgentSpawnInvocation(command, args, platform);
+}
+
+export function buildCursorAgentRunPlan(
+	modelId: string,
+	prompt: string,
+	cwd: string,
+	platform: NodeJS.Platform = process.platform,
+): CursorAgentRunPlan {
+	return buildCursorSpawnInvocation(
+		process.env.CURSOR_AGENT_BIN?.trim() || "cursor-agent",
+		["-p", prompt, "--output-format", "stream-json", "--model", modelId, "--workspace", cwd, "--trust"],
+		platform,
+	);
+}
+
+function emitCompleteLines(chunk: string, pending: { value: string }, onLine: CursorAgentLineHandler): void {
+	pending.value += chunk;
+	const lines = pending.value.split(/\r?\n/);
+	pending.value = lines.pop() ?? "";
+	for (const line of lines) onLine(line);
+}
+
+function flushPendingLine(pending: { value: string }, onLine: CursorAgentLineHandler): void {
+	if (!pending.value) return;
+	onLine(pending.value);
+	pending.value = "";
+}
+
+function runCursorAgent(
+	plan: CursorAgentRunPlan,
+	options: SimpleStreamOptions | undefined,
+	onLine: CursorAgentLineHandler,
+): Promise<CursorAgentRunResult> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(plan.command, plan.args, {
+			cwd: options?.cwd || process.cwd(),
+			env: process.env,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+		const pendingStdout = { value: "" };
+
+		const settle = (fn: () => void) => {
+			if (settled) return;
+			settled = true;
+			options?.signal?.removeEventListener("abort", onAbort);
+			fn();
+		};
+		const onAbort = () => {
+			child.kill("SIGTERM");
+			settle(() => reject(new Error("Request was aborted")));
+		};
+
+		if (options?.signal?.aborted) {
+			onAbort();
+			return;
+		}
+		options?.signal?.addEventListener("abort", onAbort);
+
+		child.stdout?.setEncoding("utf8");
+		child.stderr?.setEncoding("utf8");
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk;
+			try {
+				emitCompleteLines(chunk, pendingStdout, onLine);
+			} catch (error) {
+				child.kill("SIGTERM");
+				settle(() => reject(error));
+			}
+		});
+		child.stderr?.on("data", (chunk) => { stderr += chunk; });
+		child.on("error", (error) => settle(() => reject(error)));
+		child.on("close", (code, signal) => settle(() => {
+			try {
+				flushPendingLine(pendingStdout, onLine);
+			} catch (error) {
+				reject(error);
+				return;
+			}
+			resolve({ stdout, stderr, code, signal });
+		}));
+	});
+}
+
+function stringValue(...values: unknown[]): string | undefined {
+	for (const value of values) {
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function objectValue(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function extractText(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		return value
+			.map((item) => stringValue(objectValue(item)?.text, objectValue(item)?.content, item))
+			.filter((item): item is string => Boolean(item))
+			.join("\n");
+	}
+	const obj = objectValue(value);
+	if (!obj) return "";
+	return stringValue(obj.text, obj.content, obj.message, obj.result) ?? "";
+}
+
+function mapUsage(raw: Record<string, unknown>): Partial<AssistantMessage["usage"]> {
+	const input = Number(raw.input_tokens ?? raw.input ?? raw.prompt_tokens ?? 0);
+	const output = Number(raw.output_tokens ?? raw.output ?? raw.completion_tokens ?? 0);
+	const cacheRead = Number(raw.cache_read_input_tokens ?? raw.cacheRead ?? 0);
+	const cacheWrite = Number(raw.cache_creation_input_tokens ?? raw.cacheWrite ?? 0);
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+	};
+}
+
+function normalizeToolArguments(input: unknown): Record<string, unknown> {
+	return objectValue(input) ?? { input };
+}
+
+function normalizeToolResult(raw: Record<string, unknown>): ExternalToolResult {
+	const text = extractText(raw.content ?? raw.result ?? raw.output);
+	return {
+		content: text ? [{ type: "text", text }] : [],
+		isError: Boolean(raw.is_error ?? raw.isError ?? raw.error),
+	};
+}
+
+export function parseCursorAgentLine(line: string): ParsedCursorAgentLine {
+	const trimmed = line.trim();
+	if (!trimmed) return { type: "ignore" };
+
+	let event: Record<string, unknown>;
+	try {
+		event = JSON.parse(trimmed) as Record<string, unknown>;
+	} catch {
+		return { type: "text", text: trimmed };
+	}
+
+	const type = stringValue(event.type, event.event) ?? "";
+	if (type === "error") {
+		return { type: "error", message: stringValue(event.message, event.error) ?? "cursor_agent_error" };
+	}
+
+	if (type === "tool_call") {
+		if (event.call_id || event.subtype || event.tool_call) return { type: "ignore" };
+
+		const id = stringValue(event.id, event.tool_call_id) ?? `cursor_tool_${Date.now()}`;
+		const name = stringValue(event.name, event.tool_name) ?? "cursor_tool";
+		return {
+			type: "tool_call",
+			toolCall: { type: "toolCall", id, name, arguments: normalizeToolArguments(event.input ?? event.arguments) },
+		};
+	}
+
+	if (type === "tool_result") {
+		return {
+			type: "tool_result",
+			toolCallId: stringValue(event.tool_call_id, event.id) ?? "",
+			result: normalizeToolResult(event),
+		};
+	}
+
+	if (type === "result") {
+		const usage = objectValue(event.usage);
+		return usage ? { type: "usage", usage: mapUsage(usage) } : { type: "ignore" };
+	}
+
+	const text = extractText(event.delta ?? event.text ?? event.content ?? objectValue(event.message)?.content ?? event.message);
+	if (text) return { type: "text", text };
+
+	const usage = objectValue(event.usage);
+	if (usage) return { type: "usage", usage: mapUsage(usage) };
+
+	return { type: "ignore" };
+}
+
+function createUsage(partial?: Partial<AssistantMessage["usage"]>): AssistantMessage["usage"] {
+	const input = partial?.input ?? 0;
+	const output = partial?.output ?? 0;
+	const cacheRead = partial?.cacheRead ?? 0;
+	const cacheWrite = partial?.cacheWrite ?? 0;
+	return {
+		...ZERO_USAGE,
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: input + output + cacheWrite,
+		cost: { ...ZERO_USAGE.cost },
+	};
+}
+
+function buildAssistantMessage(
+	model: Model<Api>,
+	content: AssistantMessage["content"],
+	usage?: Partial<AssistantMessage["usage"]>,
+	stopReason: AssistantMessage["stopReason"] = "stop",
+	errorMessage?: string,
+): AssistantMessage {
+	return {
+		role: "assistant",
+		content,
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: createUsage(usage),
+		stopReason,
+		...(errorMessage ? { errorMessage } : {}),
+		timestamp: Date.now(),
+	};
+}
+
+function emitDone(stream: AssistantMessageEventStream, message: AssistantMessage, text: string): void {
+	stream.push({ type: "start", partial: { ...message, content: [] } });
+	if (text) {
+		stream.push({ type: "text_start", contentIndex: 0, partial: message });
+		stream.push({ type: "text_delta", contentIndex: 0, delta: text, partial: message });
+		stream.push({ type: "text_end", contentIndex: 0, content: text, partial: message });
+	}
+	message.content.forEach((block, index) => {
+		if (block.type !== "toolCall") return;
+		stream.push({ type: "toolcall_start", contentIndex: index, partial: message });
+		stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: message });
+	});
+	stream.push({ type: "done", reason: "stop", message });
+	stream.end(message);
+}
+
+function emitError(stream: AssistantMessageEventStream, model: Model<Api>, error: unknown): void {
+	const message = error instanceof Error ? error.message : String(error);
+	const output = buildAssistantMessage(model, [], undefined, "error", message);
+	stream.push({ type: "error", reason: "error", error: output });
+	stream.end(output);
+}
+
+export function streamViaCursorAgent(
+	model: Model<Api>,
+	context: Context,
+	options?: CursorAgentStreamOptions,
+): AssistantMessageEventStream {
+	const stream = createAssistantMessageEventStream();
+
+	queueMicrotask(async () => {
+		try {
+			const cwd = options?.cwd || process.cwd();
+			const prompt = buildCursorPrompt(context);
+			const plan = buildCursorAgentRunPlan(model.id, prompt, cwd);
+			const runForTest = options?._cursorAgentRunnerForTest;
+			let text = "";
+			let usage: Partial<AssistantMessage["usage"]> | undefined;
+			let streamStarted = false;
+			let textStarted = false;
+			const toolCalls = new Map<string, ToolCall>();
+			const content: AssistantMessage["content"] = [];
+
+			const partialMessage = (): AssistantMessage => {
+				const partialContent: AssistantMessage["content"] = text ? [{ type: "text", text }, ...content] : [...content];
+				return buildAssistantMessage(model, partialContent, usage);
+			};
+			const ensureStart = () => {
+				if (streamStarted) return;
+				streamStarted = true;
+				stream.push({ type: "start", partial: buildAssistantMessage(model, []) });
+			};
+			const handleLine = (line: string): void => {
+				const parsed = parseCursorAgentLine(line);
+				if (parsed.type === "ignore") return;
+				if (parsed.type === "error") throw new Error(parsed.message);
+				if (parsed.type === "text") {
+					ensureStart();
+					if (!textStarted) {
+						textStarted = true;
+						stream.push({ type: "text_start", contentIndex: 0, partial: partialMessage() });
+					}
+					text += parsed.text;
+					stream.push({ type: "text_delta", contentIndex: 0, delta: parsed.text, partial: partialMessage() });
+					return;
+				}
+				if (parsed.type === "usage") {
+					usage = { ...(usage ?? {}), ...parsed.usage };
+					return;
+				}
+				if (parsed.type === "tool_call") {
+					ensureStart();
+					toolCalls.set(parsed.toolCall.id, parsed.toolCall);
+					content.push(parsed.toolCall);
+					const index = text ? content.length : content.length - 1;
+					const partial = partialMessage();
+					stream.push({ type: "toolcall_start", contentIndex: index, partial });
+					stream.push({ type: "toolcall_end", contentIndex: index, toolCall: parsed.toolCall, partial });
+					return;
+				}
+				if (parsed.type === "tool_result") {
+					const toolCall = toolCalls.get(parsed.toolCallId);
+					if (toolCall) toolCall.externalResult = parsed.result;
+				}
+			};
+
+			const result = runForTest
+				? await runForTest(plan, options, handleLine)
+				: await runCursorAgent(plan, options, handleLine);
+
+			if (runForTest) {
+				for (const line of result.stdout.split(/\r?\n/)) handleLine(line);
+			}
+
+			if (result.code !== 0) {
+				throw new Error((result.stderr || result.stdout || `cursor-agent exited with code ${result.code}`).trim());
+			}
+
+			const finalContent: AssistantMessage["content"] = text ? [{ type: "text", text }, ...content] : content;
+			const finalMessage = buildAssistantMessage(model, finalContent, usage);
+			if (!streamStarted) {
+				emitDone(stream, finalMessage, text);
+				return;
+			}
+			if (textStarted) stream.push({ type: "text_end", contentIndex: 0, content: text, partial: finalMessage });
+			stream.push({ type: "done", reason: "stop", message: finalMessage });
+			stream.end(finalMessage);
+		} catch (error) {
+			emitError(stream, model, error);
+		}
+	});
+
+	return stream;
+}

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

@@ -0,0 +1,54 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import cursorCli from "../index.ts";
+
+type Handler = (event: unknown, ctx: unknown) => unknown;
+
+function makeMockPi() {
+	const providers: Array<{ name: string; config: Record<string, unknown> }> = [];
+	const pi = {
+		on(_event: string, _handler: Handler) {},
+		registerProvider(name: string, config: Record<string, unknown>) {
+			providers.push({ name, config });
+		},
+	};
+	return { pi, providers };
+}
+
+test("registers the cursor-agent provider with external CLI auth", () => {
+	const { pi, providers } = makeMockPi();
+	cursorCli(pi as never);
+
+	assert.equal(providers.length, 1);
+	assert.equal(providers[0].name, "cursor-agent");
+	assert.equal(providers[0].config.name, "Cursor Agent");
+	assert.equal(providers[0].config.authMode, "externalCli");
+	assert.equal(providers[0].config.api, "cursor-stream-json");
+	assert.equal(providers[0].config.baseUrl, "local://cursor-agent");
+	assert.equal(typeof providers[0].config.isReady, "function");
+	assert.equal(typeof providers[0].config.streamSimple, "function");
+});
+
+test("registers static Cursor subscription models", () => {
+	const { pi, providers } = makeMockPi();
+	cursorCli(pi as never);
+
+	const models = providers[0].config.models as Array<Record<string, unknown>>;
+	assert.ok(models.some((model) => model.id === "composer-2.5"));
+	assert.ok(models.some((model) => model.id === "claude-sonnet-4-6"));
+	assert.ok(models.some((model) => model.id === "gpt-5.5"));
+	assert.ok(models.every((model) => (model.cost as Record<string, number>).input === 0));
+});
+
+test("GSD_CURSOR_DISABLE keeps the provider dormant", () => {
+	const original = process.env.GSD_CURSOR_DISABLE;
+	process.env.GSD_CURSOR_DISABLE = "1";
+	try {
+		const { pi, providers } = makeMockPi();
+		cursorCli(pi as never);
+		assert.equal(providers.length, 0);
+	} finally {
+		if (original === undefined) delete process.env.GSD_CURSOR_DISABLE;
+		else process.env.GSD_CURSOR_DISABLE = original;
+	}
+});

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

@@ -0,0 +1,29 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildCursorAgentSpawnInvocation, getCursorAgentCommandCandidates, isCursorAgentApiKeyValue, parseCursorAgentStatus } from "../readiness.ts";
+
+test("getCursorAgentCommandCandidates includes Windows shims", () => {
+	assert.deepEqual(getCursorAgentCommandCandidates("win32"), ["cursor-agent.cmd", "cursor-agent.exe", "cursor-agent"]);
+	assert.deepEqual(getCursorAgentCommandCandidates("linux"), ["cursor-agent"]);
+});
+
+test("buildCursorAgentSpawnInvocation uses cmd /c on Windows", () => {
+	assert.deepEqual(buildCursorAgentSpawnInvocation("cursor-agent.cmd", ["--version"], "win32"), {
+		command: "cmd",
+		args: ["/c", "cursor-agent.cmd", "--version"],
+	});
+});
+
+test("parseCursorAgentStatus recognizes auth status output", () => {
+	assert.equal(parseCursorAgentStatus('{"authenticated":true}'), true);
+	assert.equal(parseCursorAgentStatus('{"loggedIn":false}'), false);
+	assert.equal(parseCursorAgentStatus("Authenticated as user@example.com"), true);
+	assert.equal(parseCursorAgentStatus("not authenticated"), false);
+	assert.equal(parseCursorAgentStatus(""), null);
+});
+
+test("isCursorAgentApiKeyValue rejects external CLI sentinel values", () => {
+	assert.equal(isCursorAgentApiKeyValue("cursor-token"), true);
+	assert.equal(isCursorAgentApiKeyValue("cli"), false);
+	assert.equal(isCursorAgentApiKeyValue("  "), false);
+});

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

@@ -0,0 +1,166 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import type { Context, Model } from "@gsd/pi-ai";
+import {
+	buildCursorAgentRunPlan,
+	buildCursorPrompt,
+	buildCursorSpawnInvocation,
+	parseCursorAgentLine,
+	streamViaCursorAgent,
+} from "../stream-adapter.ts";
+
+const model = {
+	id: "composer-2.5",
+	name: "Composer 2.5",
+	api: "cursor-stream-json",
+	provider: "cursor-agent",
+	baseUrl: "local://cursor-agent",
+	reasoning: true,
+	input: ["text"],
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	contextWindow: 1_000_000,
+	maxTokens: 64_000,
+} as Model<string>;
+
+const context = {
+	systemPrompt: "Be concise.",
+	messages: [{ role: "user", content: "Hello" }],
+	tools: [{ name: "gsd_plan_slice" }],
+} as Context;
+
+test("buildCursorAgentRunPlan invokes cursor-agent in stream-json prompt mode", () => {
+	const plan = buildCursorAgentRunPlan("composer-2.5", "Prompt", "/tmp/project", "linux");
+	assert.equal(plan.command, "cursor-agent");
+	assert.deepEqual(plan.args, ["-p", "Prompt", "--output-format", "stream-json", "--model", "composer-2.5", "--workspace", "/tmp/project", "--trust"]);
+});
+
+test("buildCursorSpawnInvocation uses cmd /c on Windows", () => {
+	assert.deepEqual(buildCursorSpawnInvocation("cursor-agent", ["--version"], "win32"), {
+		command: "cmd",
+		args: ["/c", "cursor-agent", "--version"],
+	});
+});
+
+test("buildCursorPrompt preserves system, message, and tool context", () => {
+	const prompt = buildCursorPrompt(context);
+	assert.match(prompt, /System instructions:\nBe concise\./);
+	assert.match(prompt, /User:\nHello/);
+	assert.match(prompt, /Requested GSD tools: gsd_plan_slice/);
+});
+
+test("parseCursorAgentLine maps text, legacy tool, result, usage, and errors", () => {
+	assert.deepEqual(parseCursorAgentLine('{"type":"assistant","message":{"content":[{"type":"text","text":"hi"}]}}'), {
+		type: "text",
+		text: "hi",
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"tool_call","id":"tool_1","name":"edit","input":{"path":"a"}}'), {
+		type: "tool_call",
+		toolCall: { type: "toolCall", id: "tool_1", name: "edit", arguments: { path: "a" } },
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"tool_result","tool_call_id":"tool_1","content":"ok","is_error":false}'), {
+		type: "tool_result",
+		toolCallId: "tool_1",
+		result: { content: [{ type: "text", text: "ok" }], isError: false },
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"result","usage":{"input_tokens":3,"output_tokens":4}}'), {
+		type: "usage",
+		usage: { input: 3, output: 4, cacheRead: 0, cacheWrite: 0 },
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"error","message":"boom"}'), { type: "error", message: "boom" });
+});
+
+test("parseCursorAgentLine ignores Cursor-owned nested tool events so GSD does not redispatch them", () => {
+	const started = parseCursorAgentLine(
+		'{"type":"tool_call","subtype":"started","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}}}',
+	);
+
+	assert.deepEqual(started, { type: "ignore" });
+
+	const completed = parseCursorAgentLine(
+		'{"type":"tool_call","subtype":"completed","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}},"result":{"content":"ok"}}',
+	);
+
+	assert.deepEqual(completed, { type: "ignore" });
+});
+
+test("streamViaCursorAgent does not surface Cursor-owned nested tool events as local tool calls", async () => {
+	const lines = [
+		'{"type":"assistant","message":{"content":[{"type":"text","text":"I will inspect the file."}]}}',
+		'{"type":"tool_call","subtype":"started","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}}}',
+		'{"type":"tool_call","subtype":"completed","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}},"result":{"content":"ok"}}',
+		'{"type":"assistant","message":{"content":[{"type":"text","text":"Done."}]}}',
+	];
+	const stream = streamViaCursorAgent(model, context, {
+		_cursorAgentRunnerForTest: async () => ({ stdout: `${lines.join("\n")}\n`, stderr: "", code: 0, signal: null }),
+	});
+
+	const events = [];
+	for await (const event of stream) events.push(event);
+
+	const done = events.find((event) => event.type === "done");
+	assert.ok(done && done.type === "done");
+	assert.ok(
+		!done.message.content.some((block) => block.type === "toolCall"),
+		"Cursor-owned internal tool events must not become local GSD tool calls",
+	);
+	assert.ok(!events.some((event) => event.type === "toolcall_start"));
+});
+
+test("streamViaCursorAgent emits complete stdout lines before cursor-agent exits", async () => {
+	let releaseRunner: (() => void) | undefined;
+	const stream = streamViaCursorAgent(model, context, {
+		_cursorAgentRunnerForTest: async (_plan, _options, onLine) => {
+			onLine('{"type":"assistant","message":{"content":[{"type":"text","text":"Live"}]}}');
+			await new Promise<void>((resolve) => { releaseRunner = resolve; });
+			return { stdout: "", stderr: "", code: 0, signal: null };
+		},
+	});
+
+	const iterator = stream[Symbol.asyncIterator]();
+	const firstDelta = (async () => {
+		for (;;) {
+			const next = await iterator.next();
+			if (next.done) return undefined;
+			if (next.value.type === "text_delta") return next.value;
+		}
+	})();
+
+	const event = await Promise.race([
+		firstDelta,
+		new Promise<undefined>((resolve) => setTimeout(resolve, 100)),
+	]);
+	assert.ok(event, "expected streamed text before runner completed");
+	assert.equal(event.type, "text_delta");
+	assert.equal(event.delta, "Live");
+
+	releaseRunner?.();
+	for (;;) {
+		const next = await iterator.next();
+		if (next.done) break;
+	}
+});
+
+test("streamViaCursorAgent turns NDJSON into assistant events with external tool results", async () => {
+	const lines = [
+		'{"type":"assistant","message":{"content":[{"type":"text","text":"Hi"}]}}',
+		'{"type":"tool_call","id":"tool_1","name":"edit","input":{"path":"a"}}',
+		'{"type":"tool_result","tool_call_id":"tool_1","content":"ok","is_error":false}',
+		'{"type":"result","usage":{"input_tokens":3,"output_tokens":4}}',
+	];
+	const stream = streamViaCursorAgent(model, context, {
+		_cursorAgentRunnerForTest: async () => ({ stdout: `${lines.join("\n")}\n`, stderr: "", code: 0, signal: null }),
+	});
+
+	const events = [];
+	for await (const event of stream) events.push(event);
+
+	const done = events.find((event) => event.type === "done");
+	assert.ok(done && done.type === "done");
+	assert.equal(done.message.content[0].type, "text");
+	assert.equal(done.message.content[0].text, "Hi");
+	const toolCall = done.message.content.find((block) => block.type === "toolCall");
+	assert.ok(toolCall && toolCall.type === "toolCall");
+	assert.deepEqual(toolCall.externalResult, { content: [{ type: "text", text: "ok" }], isError: false });
+	assert.equal(done.message.usage.input, 3);
+	assert.equal(done.message.usage.output, 4);
+});