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:
@@ -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);
|
||||
|
||||
@@ -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. */
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
Reference in New Issue
Block a user