fix(mcp): cancel evidence imports before session mutation

Propagate request cancellation through immutable JSON bundle reading and
check it before committing session state. Preserve failed-close ownership.

Fixes #1746

Assisted-by: Suika (gensokyo-skills:suika-scatter-gather-planning)
This commit is contained in:
Ysopwnable
2026-10-11 15:59:21 +08:00
committed by GitHub
parent 953a0ce5bd
commit e5699d23b1
5 changed files with 235 additions and 12 deletions
+28 -6
View File
@@ -20,11 +20,13 @@ import {
canonicalJsonParts,
} from "../domain/jsonSerialization.js";
import { readJsonFile, writeTextParts } from "./JsonFiles.js";
import { RegularFileCleanupFailure } from "./RegularFileRead.js";
type EvidenceReadFailure =
| EvidenceFileError
| EvidenceIntegrityError
| AnalysisResourceConstraintError;
| AnalysisResourceConstraintError
| AnalysisCancelledError;
type EvidenceWriteFailure =
| EvidenceFileError
| EvidenceIntegrityError
@@ -39,18 +41,38 @@ export const readEvidenceBundle = (
/** Read an authenticated immutable snapshot for a subsequent session import. */
export const readImmutableEvidenceBundle = (
path: string,
signal?: AbortSignal,
): Promise<Result<EvidenceBundle, EvidenceReadFailure>> =>
readBundle(path, (input) => {
const bundle = parseEvidenceBundle(input);
return createImmutableEvidenceBundle(bundle.records, bundle.unknowns);
});
readBundle(
path,
(input) => {
const bundle = parseEvidenceBundle(input);
return createImmutableEvidenceBundle(bundle.records, bundle.unknowns);
},
signal,
);
const readBundle = async (
path: string,
parseBundle: (input: unknown) => EvidenceBundle,
signal?: AbortSignal,
): Promise<Result<EvidenceBundle, EvidenceReadFailure>> => {
const loaded = await readJsonFile(path);
if (signal?.aborted)
return err(new AnalysisCancelledError("import_evidence_bundle"));
const loaded = await readJsonFile(path, signal).catch((cause: unknown) => {
// A failed close transfers a live handle owner; preserve that failure.
if (
signal?.aborted === true &&
!(cause instanceof RegularFileCleanupFailure)
)
return err(
new AnalysisCancelledError("import_evidence_bundle", { cause }),
);
throw cause;
});
if (!loaded.ok) return loaded;
if (signal?.aborted)
return err(new AnalysisCancelledError("import_evidence_bundle"));
let bundle: EvidenceBundle;
try {
bundle = parseBundle(loaded.value);
+5 -2
View File
@@ -35,11 +35,14 @@ type TextWriteResult<Failure = EvidenceFileError | AnalysisCancelledError> =
/** Read JSON data from a regular file at the caller-supplied path. */
export const readJsonFile = async (
path: string,
signal?: AbortSignal,
): Promise<
Result<unknown, EvidenceFileError | AnalysisResourceConstraintError>
> =>
readJsonFileInput(path, (selected) =>
readJsonInputFile(selected, "read_evidence_file"),
readJsonFileInput(
path,
(selected) => readJsonInputFile(selected, "read_evidence_file", signal),
signal,
);
/** Read selected JSON members through the same regular-file error boundary. */
+10 -3
View File
@@ -7,7 +7,8 @@ import {
} from "../application/EvidenceBundleFiles.js";
import { toolContract } from "../contracts/toolContracts.js";
import type { EvidenceBundle } from "../domain/evidenceBundle.js";
import { ok } from "../domain/result.js";
import { err, ok } from "../domain/result.js";
import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
import { inspectEvidenceBundle } from "../application/investigation/InspectEvidenceBundle.js";
import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
@@ -89,9 +90,10 @@ const registerImportEvidenceTool = ({
server.registerTool(
importContract.name,
toolRegistrationOptions(importContract),
async (input) => {
async (input, context) => {
const path = input.path;
const loaded = await readImmutableEvidenceBundle(path);
const signal = context.mcpReq.signal;
const loaded = await readImmutableEvidenceBundle(path, signal);
if (!loaded.ok)
return server.delivery.toCallToolResult(loaded, importContract);
const retainedUnknownRevisions = new Set(
@@ -99,6 +101,11 @@ const registerImportEvidenceTool = ({
unknownRevisionKey(unknown),
),
);
if (signal.aborted)
return server.delivery.toCallToolResult(
err(new AnalysisCancelledError("import_evidence_bundle")),
importContract,
);
const imported = session.importEvidenceBundle(loaded.value);
return imported.ok
? server.delivery.toCallToolResult(
@@ -8,7 +8,7 @@ import {
} from "node:fs/promises";
import { join } from "node:path";
import { describe, expect, it } from "vitest";
import { describe, expect, it, vi } from "vitest";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
@@ -19,6 +19,8 @@ import {
} from "../../../src/application/EvidenceBundleFiles.js";
import { compareEvidenceBundlesCommand } from "../../../src/application/EvidenceBundleCommands.js";
import { EvidenceLedger } from "../../../src/application/investigation/EvidenceLedger.js";
import { RegularFileCleanupFailure } from "../../../src/application/RegularFileRead.js";
import { OwnedFileHandle } from "../../../src/filesystem/OwnedFileHandle.js";
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
import { createEvidence } from "../../../src/domain/evidence.js";
import { writeTextParts } from "../../../src/application/JsonFiles.js";
@@ -36,6 +38,56 @@ const bundle = (result = true) =>
),
]);
it("returns import cancellation before inspecting a selected path", async () => {
const root = await createTestTempDirectory("rea-import-pre-cancel-");
const controller = new AbortController();
controller.abort(new Error("cancel before import"));
expect(
await readImmutableEvidenceBundle(
join(root, "missing.json"),
controller.signal,
),
).toMatchObject({
ok: false,
error: {
_tag: "AnalysisCancelledError",
operation: "import_evidence_bundle",
},
});
expect(await readdir(root)).toEqual([]);
});
it("preserves the failed-close owner when import is also cancelled", async () => {
const root = await createTestTempDirectory("rea-import-cancel-cleanup-");
const path = join(root, "bundle.json");
await writeFile(path, JSON.stringify(bundle()));
const controller = new AbortController();
const cleanupCause = new Error("fixture close failure");
const close = vi
.spyOn(OwnedFileHandle.prototype, "close")
.mockImplementationOnce(async () => {
controller.abort(new Error("cancel during cleanup"));
throw cleanupCause;
});
let failure: unknown;
try {
try {
await readImmutableEvidenceBundle(path, controller.signal);
} catch (cause: unknown) {
failure = cause;
}
expect(failure).toBeInstanceOf(RegularFileCleanupFailure);
if (!(failure instanceof RegularFileCleanupFailure))
throw new Error("Expected the retained file handle owner");
expect(failure.cleanupCause).toBe(cleanupCause);
} finally {
close.mockRestore();
if (failure instanceof RegularFileCleanupFailure)
await failure.owner.close();
}
expect(await readEvidenceBundle(path)).toMatchObject({ ok: true });
});
describe("evidence bundle export cancellation", () => {
it("does not inspect the path or advance a source cancelled before writing", async () => {
const root = await createTestTempDirectory("rea-export-pre-cancel-");
@@ -0,0 +1,139 @@
import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
import { writeFile } from "node:fs/promises";
import { join } from "node:path";
import { expect, it, onTestFinished, vi } from "vitest";
import { AnalysisCancelledError } from "../../../src/domain/analysisErrorCore.js";
import { createEvidence } from "../../../src/domain/evidence.js";
import { createEvidenceBundle } from "../../../src/domain/evidenceBundle.js";
import { createServer } from "../../../src/server/createServer.js";
import { ToolResultDelivery } from "../../../src/server/toolResult.js";
import { createTestBinarySession } from "../../fixtures/binarySession.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
it("keeps the complete session unchanged after SDK import cancellation and permits a retry", async () => {
const root = await createTestTempDirectory("rea-mcp-import-cancel-");
const path = join(root, "bundle.json");
const session = createTestBinarySession(() => {
throw new Error("Evidence import must not start a binary provider");
});
const provider = { id: "fixture", name: "Fixture", version: "1" };
const existing = createEvidence(undefined, provider, {
operation: "existing_observation",
parameters: {},
result: { retained: true },
});
const recorded = session.recordEvidence(existing);
if (!recorded.ok) throw recorded.error;
const imported = createEvidence(undefined, provider, {
operation: "imported_observation",
parameters: {},
result: { retained: "雪😀" },
});
const bundle = createEvidenceBundle([imported]);
// Valid whitespace crosses the streaming threshold without a large JSON tree.
await writeFile(path, " ".repeat(9 * 1024 * 1024) + JSON.stringify(bundle));
const server = createServer({ kind: "session", session });
const client = new Client({
name: "evidence-import-cancellation",
version: "1",
});
const controller = new AbortController();
onTestFinished(async () => {
controller.abort();
vi.restoreAllMocks();
await client.close();
await server.close();
await session.close();
});
const [clientTransport, serverTransport] =
InMemoryTransport.createLinkedPair();
await server.connect(serverTransport);
await client.connect(clientTransport);
const unknown = await client.callTool({
name: "record_unknown",
arguments: {
question: "Which boundary remains unknown?",
domain: "fixture",
severity: "medium",
required_authority: null,
required_confidence: "derived",
required_environment: null,
recommended_probes: [],
relationships: [],
},
});
expect(unknown.isError, JSON.stringify(unknown)).not.toBe(true);
const before = session.exportEvidenceBundle();
let resolveDispatched: (() => void) | undefined;
const dispatched = new Promise<void>((resolve) => {
resolveDispatched = resolve;
});
const send = clientTransport.send.bind(clientTransport);
vi.spyOn(clientTransport, "send").mockImplementation(
async (message, ...args) => {
await send(message, ...args);
if ("method" in message && message.method === "tools/call")
resolveDispatched?.();
},
);
let resolveCompleted: (() => void) | undefined;
const completed = new Promise<void>((resolve) => {
resolveCompleted = resolve;
});
let settledResult: unknown;
const deliver = ToolResultDelivery.prototype.toCallToolResult;
vi.spyOn(ToolResultDelivery.prototype, "toCallToolResult").mockImplementation(
function (this: ToolResultDelivery, result, contract) {
const reply = deliver.call(this, result, contract);
if (contract.name === "import_evidence_bundle") {
settledResult = result;
resolveCompleted?.();
}
return reply;
},
);
const cancellation = client
.callTool(
{ name: "import_evidence_bundle", arguments: { path } },
{ signal: controller.signal },
)
.then(
() => "completed",
(error: unknown) => error,
);
await dispatched;
// The real SDK ping completes while the dispatched file reader awaits I/O.
await client.ping();
controller.abort(new Error("SDK import cancellation verification"));
expect(await cancellation).toMatchObject({
message: expect.stringContaining("SDK import cancellation verification"),
});
// Observe handler settlement, not just the client's local rejection.
await completed;
expect(session.exportEvidenceBundle()).toEqual(before);
expect(settledResult).toMatchObject({
ok: false,
error: expect.any(AnalysisCancelledError),
});
await client.ping();
const retry = await client.callTool({
name: "import_evidence_bundle",
arguments: { path },
});
expect(retry.isError, JSON.stringify(retry)).not.toBe(true);
expect(retry.structuredContent).toMatchObject({
result: {
imported: 1,
unknowns_added: 0,
total: before.records.length + 1,
},
});
const after = session.exportEvidenceBundle();
expect(after.unknowns).toEqual(before.unknowns);
expect(after.records).toHaveLength(before.records.length + 1);
expect(after.records).toEqual(
expect.arrayContaining([...before.records, imported]),
);
await client.ping();
});