oh-my-opencode 4.17.1 → 4.18.1

package/packages/lsp-core/src/lsp/fixtures/workspace-edit-contract-probe.ts

@@ -0,0 +1,196 @@
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+	renameTextEdit,
+	waitForEventCount,
+} from "../workspace-apply-edit-test-support.js";
+import { workspaceEditContractFailureEvidence } from "../workspace-edit-contract-evidence.js";
+
+class WorkspaceEditContractProbeError extends Error {
+	override readonly name = "WorkspaceEditContractProbeError";
+}
+
+function requireProbe(condition: boolean, message: string): asserts condition {
+	if (!condition) throw new WorkspaceEditContractProbeError(message);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function applyResponses(eventsPath: string): readonly unknown[] {
+	return readEvents(eventsPath)
+		.filter((event) => event.type === "clientResponse" && event.method === "workspace/applyEdit")
+		.map((event) => event.result);
+}
+
+function isRejectedApply(value: unknown): boolean {
+	return isRecord(value) && value["applied"] === false && typeof value["failureReason"] === "string";
+}
+
+function didChangeVersions(eventsPath: string): readonly number[] {
+	const versions: number[] = [];
+	for (const event of readEvents(eventsPath)) {
+		if (event.type !== "clientNotification" || event.method !== "textDocument/didChange") continue;
+		if (!isRecord(event.params)) continue;
+		const textDocument = event.params["textDocument"];
+		if (!isRecord(textDocument) || typeof textDocument["version"] !== "number") continue;
+		versions.push(textDocument["version"]);
+	}
+	return versions;
+}
+
+const outputPath = process.argv[2];
+if (!outputPath) throw new WorkspaceEditContractProbeError("output path is required");
+
+const harness = createWorkspaceEditTestHarness();
+try {
+	const success = await harness.makeClient({
+		renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }],
+		diagnostics: [diagnostic("todo3-fresh")],
+	});
+	let successWrites = 0;
+	success.client.setWorkspaceEditIo({
+		writeFile(path, content) {
+			successWrites += 1;
+			writeFileSync(path, content, "utf-8");
+		},
+	});
+	await success.client.openFile(success.source);
+	const successResult = await success.client.rename(success.source, 1, 6, "after");
+	const successResponses = applyResponses(success.events);
+	const successVersions = didChangeVersions(success.events);
+	const successUri = pathToFileURL(realpathSync(success.source)).href;
+	const successEvidence = {
+		serverAppliedRename:
+			successResponses.length === 1 && isRecord(successResponses[0]) && successResponses[0]["applied"] === true,
+		recordedResultReused: successResult.edit !== null && successResult.apply.success && successWrites === 1,
+		writeCount: successWrites,
+		secondWritePrevented: successWrites === 1 && successVersions.length === 1,
+		synchronizedDocumentVersion: success.client.getOpenDocumentVersion(success.source) ?? null,
+		didChangeVersions: successVersions,
+		immediateDiagnostics: success.client
+			.getStoredDiagnostics(successUri)
+			.some((entry) => entry.message === "todo3-fresh"),
+		finalContent: readFileSync(success.source, "utf-8"),
+	};
+	requireProbe(successEvidence.serverAppliedRename, "successful server apply was not reported truthfully");
+	requireProbe(successEvidence.recordedResultReused, "rename did not reuse the recorded server result");
+	requireProbe(successEvidence.secondWritePrevented, "server edit was written or synchronized more than once");
+	requireProbe(successEvidence.synchronizedDocumentVersion === 2, "open document version did not advance to 2");
+	requireProbe(successEvidence.immediateDiagnostics, "fresh diagnostics were not visible immediately after applyEdit");
+	requireProbe(successEvidence.finalContent === "const after = 1;\n", "successful rename produced unexpected bytes");
+
+	const unscoped = await harness.makeClient({
+		unscopedApplyEdit: renameTextEdit("before", "after", { version: 1 }),
+	});
+	const unscopedResponses = await waitForEventCount(
+		unscoped.events,
+		(event) => event.type === "clientResponse" && event.method === "workspace/applyEdit",
+		1,
+	);
+	const unscopedFailure = unscopedResponses[0]?.result;
+	requireProbe(isRejectedApply(unscopedFailure), "unscoped applyEdit was not rejected");
+	requireProbe(readFileSync(unscoped.source, "utf-8") === "const before = 1;\n", "unscoped failure mutated bytes");
+
+	const concurrent = await harness.makeClient({
+		renameSteps: [
+			{
+				applyEdit: renameTextEdit("before", "after", { version: 1 }),
+				applyConcurrently: true,
+				renameResult: "same",
+			},
+		],
+	});
+	let concurrentWrites = 0;
+	concurrent.client.setWorkspaceEditIo({
+		writeFile(path, content) {
+			concurrentWrites += 1;
+			writeFileSync(path, content, "utf-8");
+		},
+	});
+	await concurrent.client.openFile(concurrent.source);
+	const concurrentResult = await concurrent.client.rename(concurrent.source, 1, 6, "after");
+	const concurrentFailure = applyResponses(concurrent.events).find(isRejectedApply);
+	requireProbe(concurrentResult.apply.success, "the winning concurrent applyEdit did not complete");
+	requireProbe(concurrentWrites === 1, "concurrent applyEdit wrote more than once");
+	requireProbe(isRejectedApply(concurrentFailure), "concurrent applyEdit loser was not rejected");
+
+	const mismatched = await harness.makeClient({
+		renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 9 }), renameResult: "same" }],
+	});
+	await mismatched.client.openFile(mismatched.source);
+	const mismatchedResult = await mismatched.client.rename(mismatched.source, 1, 6, "after");
+	const mismatchedFailure = applyResponses(mismatched.events).find(isRejectedApply);
+	requireProbe(!mismatchedResult.apply.success, "mismatched document version unexpectedly succeeded");
+	requireProbe(isRejectedApply(mismatchedFailure), "mismatched version was not rejected over applyEdit");
+	requireProbe(readFileSync(mismatched.source, "utf-8") === "const before = 1;\n", "version failure mutated bytes");
+
+	const preGate = await harness.makeClient({
+		renameSteps: [
+			{
+				applyEdit: renameTextEdit("before", "after", { version: 1 }),
+				applyDelayMs: 100,
+				renameResult: "same",
+			},
+		],
+	});
+	const controller = new AbortController();
+	await preGate.client.openFile(preGate.source);
+	const pendingRename = preGate.client.rename(preGate.source, 1, 6, "after", controller.signal);
+	await waitForEventCount(
+		preGate.events,
+		(event) => event.type === "clientRequest" && event.method === "textDocument/rename",
+		1,
+		);
+		controller.abort();
+		const preGateError = await pendingRename.then(
+			() => null,
+			(error: unknown) => error,
+		);
+		const preGateMessage = preGateError instanceof Error ? preGateError.message : String(preGateError);
+		const preGateFailure = {
+			success: false,
+			filesModified: [],
+			totalEdits: 0,
+			errors: [preGateMessage],
+		};
+		requireProbe(preGateError !== null, "pre-gate cancellation unexpectedly succeeded");
+		requireProbe(
+			preGateFailure.errors.some((message) => /cancel|abort/i.test(message)),
+			"pre-gate cancellation returned the wrong failure",
+		);
+		requireProbe(readFileSync(preGate.source, "utf-8") === "const before = 1;\n", "pre-gate cancellation mutated bytes");
+
+	const failureCases = {
+			unscoped: workspaceEditContractFailureEvidence(unscopedFailure, unscoped.workspace),
+			concurrent: workspaceEditContractFailureEvidence(concurrentFailure, concurrent.workspace),
+			mismatched: workspaceEditContractFailureEvidence(mismatchedFailure, mismatched.workspace),
+			preGate: workspaceEditContractFailureEvidence(preGateFailure, preGate.workspace),
+		};
+	writeFileSync(
+		outputPath,
+		`${JSON.stringify(
+			{
+				schemaVersion: 1,
+				success: successEvidence,
+				failureCases,
+				failureHashes: {
+					unscoped: failureCases.unscoped.sha256,
+					concurrent: failureCases.concurrent.sha256,
+					mismatched: failureCases.mismatched.sha256,
+					preGate: failureCases.preGate.sha256,
+				},
+			},
+			null,
+			2,
+		)}\n`,
+		"utf-8",
+	);
+} finally {
+	await harness.cleanup();
+}

package/packages/lsp-core/src/lsp/fixtures/workspace-edit-server.mjs

@@ -0,0 +1,215 @@
+import { appendFileSync, readFileSync } from "node:fs";
+
+const [, , scenarioPath, eventsPath] = process.argv;
+const scenario = JSON.parse(readFileSync(scenarioPath, "utf-8"));
+
+let buffer = Buffer.alloc(0);
+let nextServerRequestId = 10_000;
+let renameIndex = 0;
+let diagnosticIndex = 0;
+const pendingServerRequests = new Map();
+
+function record(event) {
+	appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, "utf-8");
+}
+
+function send(message) {
+	const body = Buffer.from(JSON.stringify(message), "utf-8");
+	process.stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
+	process.stdout.write(body);
+}
+
+function sendResponse(id, result) {
+	send({ jsonrpc: "2.0", id, result });
+}
+
+function sendError(id, code, message) {
+	send({ jsonrpc: "2.0", id, error: { code, message } });
+}
+
+function sendApplyEdit(edit, context) {
+	const id = nextServerRequestId;
+	nextServerRequestId += 1;
+	pendingServerRequests.set(String(id), context);
+	record({ type: "serverRequest", method: "workspace/applyEdit", id, edit });
+	send({ jsonrpc: "2.0", id, method: "workspace/applyEdit", params: { edit } });
+}
+
+function renameResult(step) {
+	if (step.renameResult === "same") return step.applyEdit ?? null;
+	if (step.renameResult === "different") return step.differentEdit ?? null;
+	if (step.renameResult === "edit") return step.renameEdit ?? null;
+	return null;
+}
+
+function finishRename(context) {
+	const result = renameResult(context.step);
+	const delay = Number(context.step.responseDelayMs ?? 0);
+	setTimeout(() => {
+		record({ type: "serverResponse", method: "textDocument/rename", result });
+		sendResponse(context.renameRequestId, result);
+	}, delay);
+}
+
+function schedulePublish(step, fallbackUri, fallbackVersion) {
+	const delay = Number(step.delayMs ?? 0);
+	setTimeout(() => {
+		const params = {
+			uri: step.uri ?? fallbackUri,
+			...(step.version === undefined ? {} : { version: step.version }),
+			diagnostics: Array.isArray(step.diagnostics) ? step.diagnostics : [],
+		};
+		record({ type: "serverNotification", method: "textDocument/publishDiagnostics", params });
+		send({ jsonrpc: "2.0", method: "textDocument/publishDiagnostics", params });
+	}, delay);
+}
+
+function publishSteps(trigger) {
+	if (!Array.isArray(scenario.publishDiagnostics)) return [];
+	return scenario.publishDiagnostics.filter((step) => step?.trigger === trigger);
+}
+
+function applyPublishSteps(trigger, fallbackUri, fallbackVersion) {
+	for (const step of publishSteps(trigger)) schedulePublish(step, fallbackUri, fallbackVersion);
+}
+
+function handleClientResponse(message) {
+	const context = pendingServerRequests.get(String(message.id));
+	if (!context) return;
+	pendingServerRequests.delete(String(message.id));
+	record({
+		type: "clientResponse",
+		method: "workspace/applyEdit",
+		result: message.result ?? null,
+		error: message.error ?? null,
+	});
+	if (context.kind === "unscoped") return;
+	if (typeof context.pendingApplyResponses === "number") {
+		context.pendingApplyResponses -= 1;
+		if (context.pendingApplyResponses > 0) return;
+		finishRename(context);
+		return;
+	}
+	if (context.step.applyTwice === true && context.applyCount === 1) {
+		sendApplyEdit(context.step.applyEdit, { ...context, applyCount: 2 });
+		return;
+	}
+	finishRename(context);
+}
+
+function handleRequest(message) {
+	if (message.method === "initialize") {
+		record({ type: "clientRequest", method: message.method, id: message.id, params: message.params });
+		sendResponse(message.id, { capabilities: scenario.capabilities ?? {} });
+		return;
+	}
+	if (message.method === "textDocument/rename") {
+		const step = scenario.renameSteps?.[renameIndex] ?? {};
+		renameIndex += 1;
+		record({ type: "clientRequest", method: message.method, id: message.id, params: message.params, renameIndex });
+		if (step.applyEdit) {
+			const context = { kind: "rename", renameRequestId: message.id, step, applyCount: 1 };
+			if (step.applyConcurrently === true) {
+				context.pendingApplyResponses = 2;
+				sendApplyEdit(step.applyEdit, context);
+				sendApplyEdit(step.applyEdit, context);
+				return;
+			}
+			const delay = Number(step.applyDelayMs ?? 0);
+			if (delay > 0) {
+				setTimeout(() => sendApplyEdit(step.applyEdit, context), delay);
+				return;
+			}
+			sendApplyEdit(step.applyEdit, context);
+			return;
+		}
+		finishRename({ renameRequestId: message.id, step });
+		return;
+	}
+	if (message.method === "textDocument/diagnostic") {
+		record({ type: "clientRequest", method: message.method, id: message.id, params: message.params, diagnosticIndex: diagnosticIndex + 1 });
+		applyPublishSteps("diagnosticRequest", message.params?.textDocument?.uri, undefined);
+		const step = Array.isArray(scenario.diagnosticResponses) ? scenario.diagnosticResponses[diagnosticIndex] : undefined;
+		diagnosticIndex += 1;
+		if (step?.action === "hang") return;
+		if (step?.action === "close") {
+			const delay = Number(step.delayMs ?? 0);
+			setTimeout(() => process.exit(0), delay);
+			return;
+		}
+		const delay = Number(step?.delayMs ?? 0);
+		setTimeout(() => {
+			if (step?.error) {
+				record({ type: "serverError", method: "textDocument/diagnostic", error: step.error });
+				sendError(message.id, step.error.code, step.error.message);
+				return;
+			}
+			const result = step?.report ?? { items: scenario.diagnostics ?? [] };
+			record({ type: "serverResponse", method: "textDocument/diagnostic", result });
+			sendResponse(message.id, result);
+		}, delay);
+		return;
+	}
+	if (message.method === "shutdown") {
+		sendResponse(message.id, null);
+		return;
+	}
+	sendResponse(message.id, null);
+}
+
+function handleNotification(message) {
+	record({ type: "clientNotification", method: message.method, params: message.params ?? null });
+	if (message.method === "initialized" && scenario.unscopedApplyEdit) {
+		sendApplyEdit(scenario.unscopedApplyEdit, { kind: "unscoped" });
+	}
+	if (message.method === "initialized") {
+		applyPublishSteps("initialized", undefined, undefined);
+	}
+	if (message.method === "textDocument/didOpen") {
+		applyPublishSteps("didOpen", message.params.textDocument.uri, message.params.textDocument.version);
+	}
+	if (message.method === "textDocument/didChange" && Array.isArray(scenario.diagnostics)) {
+		send({
+			jsonrpc: "2.0",
+			method: "textDocument/publishDiagnostics",
+			params: {
+				uri: message.params.textDocument.uri,
+				version: message.params.textDocument.version,
+				diagnostics: scenario.diagnostics,
+			},
+		});
+	}
+	if (message.method === "textDocument/didChange") {
+		applyPublishSteps("didChange", message.params.textDocument.uri, message.params.textDocument.version);
+	}
+	if (message.method === "exit") process.exit(0);
+}
+
+function handleMessage(message) {
+	if (Object.hasOwn(message, "id") && (Object.hasOwn(message, "result") || Object.hasOwn(message, "error"))) {
+		handleClientResponse(message);
+		return;
+	}
+	if (Object.hasOwn(message, "id")) {
+		handleRequest(message);
+		return;
+	}
+	handleNotification(message);
+}
+
+process.stdin.on("data", (chunk) => {
+	buffer = Buffer.concat([buffer, chunk]);
+	for (;;) {
+		const headerEnd = buffer.indexOf("\r\n\r\n");
+		if (headerEnd === -1) return;
+		const header = buffer.subarray(0, headerEnd).toString("ascii");
+		const match = /content-length:\s*(\d+)/i.exec(header);
+		if (!match) process.exit(2);
+		const length = Number(match[1]);
+		const bodyStart = headerEnd + 4;
+		if (buffer.length < bodyStart + length) return;
+		const body = buffer.subarray(bodyStart, bodyStart + length).toString("utf-8");
+		buffer = buffer.subarray(bodyStart + length);
+		handleMessage(JSON.parse(body));
+	}
+});

package/packages/lsp-core/src/lsp/formatters.ts

@@ -127,6 +127,9 @@ export function formatApplyResult(result: ApplyResult): string {
 		for (const file of result.filesModified) {
 			lines.push(`  - ${file}`);
 		}
+		if (result.lateAbort) {
+			lines.push("Cancellation arrived after the filesystem commit began; the committed edit completed.");
+		}
 	} else {
 		lines.push("Failed to apply some changes:");
 		for (const err of result.errors) {

package/packages/lsp-core/src/lsp/json-rpc-connection-cancellation.test.ts

@@ -0,0 +1,97 @@
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it } from "bun:test";
+
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+
+type JsonMessage = Record<string, unknown>;
+
+function messageId(message: JsonMessage): string | number | null | undefined {
+	const id = message["id"];
+	return typeof id === "string" || typeof id === "number" || id === null ? id : undefined;
+}
+
+function cancelTarget(message: JsonMessage): string | number | undefined {
+	const params = message["params"];
+	if (!params || typeof params !== "object" || Array.isArray(params)) return undefined;
+	const id = Reflect.get(params, "id");
+	return typeof id === "string" || typeof id === "number" ? id : undefined;
+}
+
+function encodeMessage(message: JsonMessage): string {
+	const body = JSON.stringify(message);
+	return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function recordJsonRpcMessages(stream: PassThrough) {
+	const messages: JsonMessage[] = [];
+	const waiters: Array<() => void> = [];
+	let buffer = Buffer.alloc(0);
+	stream.on("data", (chunk: Buffer) => {
+		buffer = Buffer.concat([buffer, chunk]);
+		for (;;) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) return;
+			const header = buffer.subarray(0, headerEnd).toString("ascii");
+			const match = /content-length:\s*(\d+)/i.exec(header);
+			if (!match?.[1]) throw new Error("missing content-length");
+			const bodyStart = headerEnd + 4;
+			const bodyEnd = bodyStart + Number.parseInt(match[1], 10);
+			if (buffer.length < bodyEnd) return;
+			const parsed: unknown = JSON.parse(buffer.subarray(bodyStart, bodyEnd).toString("utf8"));
+			buffer = buffer.subarray(bodyEnd);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				messages.push(Object.fromEntries(Object.entries(parsed)));
+			}
+			for (const wake of waiters.splice(0)) wake();
+		}
+	});
+	return {
+		messages,
+		waitForCount(count: number): Promise<void> {
+			if (messages.length >= count) return Promise.resolve();
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					reject(new Error(`waited for ${count} JSON-RPC messages, observed ${messages.length}`));
+				}, 1_000);
+				const wake = (): void => {
+					if (messages.length < count) {
+						waiters.push(wake);
+						return;
+					}
+					clearTimeout(timer);
+					resolve();
+				};
+				waiters.push(wake);
+			});
+		},
+	};
+}
+
+describe("JsonRpcConnection cancellation", () => {
+	it("#given an active request #when its signal aborts #then cancel uses the same id and late responses are ignored", async () => {
+		const serverToClient = new PassThrough();
+		const clientToServer = new PassThrough();
+		const recorder = recordJsonRpcMessages(clientToServer);
+		const connection = new JsonRpcConnection(serverToClient, clientToServer);
+		connection.listen();
+		const controller = new AbortController();
+
+		const request = connection.sendRequest("textDocument/diagnostic", { textDocument: { uri: "file:///a.ts" } }, {
+			signal: controller.signal,
+		});
+		await recorder.waitForCount(1);
+		const requestId = messageId(recorder.messages[0] ?? {});
+		expect(typeof requestId === "string" || typeof requestId === "number").toBe(true);
+
+		controller.abort(new Error("caller cancelled"));
+		await recorder.waitForCount(2);
+		await expect(request).rejects.toThrow("caller cancelled");
+		expect(connection.pendingRequestCount()).toBe(0);
+		expect(recorder.messages[1]?.["method"]).toBe("$/cancelRequest");
+		expect(cancelTarget(recorder.messages[1] ?? {})).toBe(typeof requestId === "number" || typeof requestId === "string" ? requestId : undefined);
+
+		serverToClient.write(encodeMessage({ jsonrpc: "2.0", id: requestId ?? null, result: { items: [] } }));
+		expect(connection.pendingRequestCount()).toBe(0);
+	});
+});

package/packages/lsp-core/src/lsp/json-rpc-connection.ts

@@ -3,11 +3,16 @@ type JsonRpcId = number | string | null;
 interface PendingRequest {
 	resolve(result: unknown): void;
 	reject(error: Error): void;
+	cleanup(): void;
 }
 
 type NotificationHandler = (params: unknown) => void;
 type RequestHandler = (params: unknown) => Promise<unknown> | unknown;
 
+export interface JsonRpcRequestOptions {
+	readonly signal?: AbortSignal;
+}
+
 const HEADER_SEPARATOR = "\r\n\r\n";
 const PARSE_ERROR = -32700;
 const INVALID_REQUEST = -32600;
@@ -56,32 +61,81 @@ export class JsonRpcConnection {
 		this.errorHandlers.push(handler);
 	}
 
-	async sendRequest<T>(method: string, params?: unknown): Promise<T> {
+	async sendRequest<T>(method: string, params?: unknown, options: JsonRpcRequestOptions = {}): Promise<T> {
 		if (this.disposed) throw new Error("JSON-RPC connection is disposed");
 
 		const id = this.nextRequestId;
 		this.nextRequestId += 1;
+		const key = String(id);
 		const message = params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
+		let requestWritten = false;
+		let cancelAfterWrite = false;
+		let settled = false;
+		const writeCancel = (): Promise<void> => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
 
 		const responsePromise = new Promise<T>((resolve, reject) => {
-			this.pendingRequests.set(String(id), {
+			const cleanup = (): void => {
+				options.signal?.removeEventListener("abort", onAbort);
+			};
+			const settleCancel = (): void => {
+				if (settled) return;
+				settled = true;
+				this.pendingRequests.delete(key);
+				cleanup();
+				const rejectCancelled = (): void => reject(abortError(options.signal));
+				if (!requestWritten) {
+					cancelAfterWrite = true;
+					rejectCancelled();
+					return;
+				}
+				void writeCancel().then(rejectCancelled, (error) => {
+					this.emitError(toError(error));
+					rejectCancelled();
+				});
+			};
+			const onAbort = (): void => settleCancel();
+			this.pendingRequests.set(key, {
 				resolve(result) {
+					settled = true;
+					cleanup();
 					resolve(result as T);
 				},
-				reject,
+				reject(error) {
+					settled = true;
+					cleanup();
+					reject(error);
+				},
+				cleanup,
 			});
+			if (options.signal?.aborted) {
+				settleCancel();
+				return;
+			}
+			options.signal?.addEventListener("abort", onAbort, { once: true });
 		});
 
+		if (settled) return responsePromise;
 		try {
 			await this.writeMessage(message);
+			requestWritten = true;
+			if (cancelAfterWrite) await writeCancel();
 		} catch (error) {
-			this.pendingRequests.delete(String(id));
+			if (settled) return responsePromise;
+			const pending = this.pendingRequests.get(key);
+			if (pending) {
+				pending.cleanup();
+				this.pendingRequests.delete(key);
+			}
 			throw error;
 		}
 
 		return responsePromise;
 	}
 
+	pendingRequestCount(): number {
+		return this.pendingRequests.size;
+	}
+
 	async sendNotification(method: string, params?: unknown): Promise<void> {
 		if (this.disposed) return;
 		const message = params === undefined ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params };
@@ -97,6 +151,7 @@ export class JsonRpcConnection {
 		this.reader.off("error", this.handleStreamError);
 		this.writer.off("error", this.handleStreamError);
 		for (const pending of this.pendingRequests.values()) {
+			pending.cleanup();
 			pending.reject(new Error("JSON-RPC connection disposed"));
 		}
 		this.pendingRequests.clear();
@@ -188,6 +243,7 @@ export class JsonRpcConnection {
 		const pending = this.pendingRequests.get(String(id));
 		if (!pending) return;
 		this.pendingRequests.delete(String(id));
+		pending.cleanup();
 
 		if ("error" in message) {
 			pending.reject(jsonRpcErrorToError(message["error"]));
@@ -203,7 +259,11 @@ export class JsonRpcConnection {
 		try {
 			handler(params);
 		} catch (error) {
-			this.emitError(toError(error));
+			if (error instanceof Error) {
+				this.emitError(error);
+				return;
+			}
+			this.emitError(new Error(String(error)));
 		}
 	}
 
@@ -259,6 +319,14 @@ export class JsonRpcConnection {
 	}
 }
 
+function abortError(signal: AbortSignal | undefined): Error {
+	const reason = signal?.reason;
+	if (reason instanceof Error) return reason;
+	const error = new Error(typeof reason === "string" ? reason : "LSP request cancelled");
+	error.name = "AbortError";
+	return error;
+}
+
 function parseContentLength(headers: string): number | null {
 	for (const line of headers.split("\r\n")) {
 		const separatorIndex = line.indexOf(":");

package/packages/lsp-core/src/lsp/server-install-state.ts

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { dirname } from "node:path";
 
-import { contextEnv } from "../request-context.js";
+import { lspRequestContext } from "../request-context.js";
 
 export type InstallDecision = "declined" | "allowed";
 
@@ -14,9 +13,7 @@ export interface InstallDecisionRecord {
 type InstallDecisions = Record<string, InstallDecisionRecord>;
 
 export function getInstallDecisionsPath(): string {
-	const override = contextEnv("LSP_TOOLS_MCP_INSTALL_DECISIONS");
-	if (!override) return join(homedir(), ".codex", "lsp-install-decisions.json");
-	return isAbsolute(override) ? override : join(homedir(), override);
+	return lspRequestContext().installDecisionsPath;
 }
 
 export function loadInstallDecisions(): InstallDecisions {