diff --git a/tests/boundary/mcp/debuggerExternalMutationLifecycleMcp.test.ts b/tests/boundary/mcp/debuggerExternalMutationLifecycleMcp.test.ts index a42f2f7cd0..700ca3b70f 100644 --- a/tests/boundary/mcp/debuggerExternalMutationLifecycleMcp.test.ts +++ b/tests/boundary/mcp/debuggerExternalMutationLifecycleMcp.test.ts @@ -21,10 +21,13 @@ import { import { phaseGate } from "../../support/lifecycleHarness.js"; import { waitFor } from "../../support/testWait.js"; import { createMcpSchemaValidation } from "../../fixtures/mcpSchemaValidation.js"; +import type { BinarySession } from "../../../src/application/binary/BinarySession.js"; +import { ToolResultDelivery } from "../../../src/server/ToolResultDelivery.js"; +import { parseMcpToolError } from "../../fixtures/mcpToolError.js"; const SESSION_ID = "00000000-0000-4000-8000-000000000001"; -type RecordEvidence = (evidence: Evidence) => Result<"added", AnalysisError>; +type RecordEvidence = BinarySession["recordEvidence"]; /** * The debugger operations each lifecycle regression drives, independent of @@ -274,11 +277,9 @@ describe.each([RIZIN, GDB, CUTTER])( retryCleanup: async () => ok(null), ...overrides, }; - const recorded: Evidence[] = []; - const server = debuggerTools.serve(operations, session, (evidence) => { - recorded.push(evidence); - return ok("added" as const); - }); + const server = debuggerTools.serve(operations, session, (evidence) => + session.recordEvidence(evidence), + ); const client = new Client( { name: "debugger-lifecycle", version: "1" }, { jsonSchemaValidator: createMcpSchemaValidation() }, @@ -292,15 +293,16 @@ describe.each([RIZIN, GDB, CUTTER])( InMemoryTransport.createLinkedPair(); await server.connect(serverTransport); await client.connect(clientTransport); - return { client, recorded }; + return { client, session }; }; it("retries a failed debugger cleanup before the next mutation and keeps it owned while it fails", async () => { const detach = ownedDetachFailure(debuggerTools.command.name); + const completed = debuggerTools.evidence(); const execute = vi .fn() .mockResolvedValueOnce(err(detach.error)) - .mockImplementation(async () => ok(debuggerTools.evidence())); + .mockResolvedValue(ok(completed)); const start = vi.fn(async () => ok(null)); const retryCleanup = vi .fn() @@ -310,7 +312,7 @@ describe.each([RIZIN, GDB, CUTTER])( return ok(null); }); const operations = { execute, start, retryCleanup }; - const { client } = await connect(operations); + const { client, session } = await connect(operations); const next = operations[debuggerTools.next.runs as "execute" | "start"]; const failed = await client.callTool(debuggerTools.command); @@ -327,6 +329,12 @@ describe.each([RIZIN, GDB, CUTTER])( expect(admitted.isError ?? false, JSON.stringify(admitted)).toBe(false); expect(retryCleanup).toHaveBeenCalledTimes(2); expect(next).toHaveBeenCalledTimes(nextCalls + 1); + if (debuggerTools.next.runs === "execute") { + expect(admitted.structuredContent).toMatchObject({ + evidence_id: completed.evidence_id, + }); + expect(session.evidenceById(completed.evidence_id)).toEqual(completed); + } }); it("keeps a completed command's Evidence when cancellation arrives during final cleanup", async () => { @@ -348,23 +356,44 @@ describe.each([RIZIN, GDB, CUTTER])( expect((await session.open(target)).ok).toBe(true); const completed = debuggerTools.evidence(); const execute = vi.fn(async () => ok(completed)); - const { client, recorded } = await connect({ execute }, session); + const { client } = await connect({ execute }, session); + const partial = vi.spyOn( + ToolResultDelivery.prototype, + "toPartialErrorToolResult", + ); + onTestFinished(() => { + partial.mockRestore(); + }); const controller = new AbortController(); const command = client .callTool(debuggerTools.command, { signal: controller.signal }) - .catch(() => undefined); + .catch((cause: unknown) => cause); await retiring.reached(command, "analysis retirement close"); expect(execute).toHaveBeenCalledOnce(); + expect(session.hasEvidence(completed.evidence_id)).toBe(false); controller.abort(); + await client.ping(); retiring.release(); - await command; - // Retirement still completes, and the completed command's Evidence is - // retained through the session writer as the cancellation's partial. + expect(await command).toBeInstanceOf(Error); + + // The SDK suppresses replies to cancelled calls. Observe the canonical + // server result so client rejection alone cannot satisfy the test. await waitFor(() => - expect(recorded.map(({ evidence_id }) => evidence_id)).toContain( - completed.evidence_id, - ), + expect(session.hasEvidence(completed.evidence_id)).toBe(true), ); + expect(partial).toHaveBeenCalledOnce(); + const delivery = partial.mock.results[0]; + if (delivery?.type !== "return") + throw new Error("Missing server cancellation result"); + expect(parseMcpToolError(delivery.value)).toMatchObject({ + error: { + code: "cancelled", + details: { + partial_observation: { evidence_id: completed.evidence_id }, + }, + }, + }); + expect(session.evidenceById(completed.evidence_id)).toEqual(completed); expect(session.activeTarget()).toBeUndefined(); }); diff --git a/tests/boundary/mcp/gdbRetirementCancellation.test.ts b/tests/boundary/mcp/gdbRetirementCancellation.test.ts index ff7d3a3eb6..9edab7c787 100644 --- a/tests/boundary/mcp/gdbRetirementCancellation.test.ts +++ b/tests/boundary/mcp/gdbRetirementCancellation.test.ts @@ -1,14 +1,6 @@ import { unknownTarget } from "../../../src/domain/targetIdentity.js"; -import type { CallToolResult } from "@modelcontextprotocol/server"; import { expect, it, vi } from "vitest"; import { phaseGate } from "../../support/lifecycleHarness.js"; -import type { EvidenceMcpServer } from "../../../src/server/EvidenceMcpServer.js"; -import { - registerServiceTools, - type GdbToolOptions, -} from "../../../src/server/serviceToolBindings.js"; -import { createToolResultDelivery } from "../../../src/server/toolResult.js"; -import { silentLogger } from "../../../src/logger.js"; import { createEvidence } from "../../../src/domain/evidence.js"; import { ok, err } from "../../../src/domain/result.js"; import { AnalysisInputError } from "../../../src/domain/analysisErrorCore.js"; @@ -27,101 +19,51 @@ import { } from "../../fixtures/binarySession.js"; import { releaseOwnedCleanup } from "../../support/cleanupRelease.js"; -it("compares cancellation before dispatch, during retirement, and an uncancelled control", async () => { - for (const mode of ["pre-aborted", "during-retirement", "control"] as const) { - const [target] = await createBinarySessionTargets(); - const sessionRetirement = phaseGate(); - let closes = 0; - const session = createTestBinarySession( - () => - ({ - execute: async () => ok({ operation: "health", value: null }), - close: async () => { - closes++; - await sessionRetirement.hold(); - return ok(null); - }, - }) as never, - ); - expect((await session.open(target)).ok).toBe(true); - const id = "00000000-0000-4000-8000-000000000001"; - const evidence = createEvidence( - unknownTarget("not-observed"), - { id: "gdb", name: "GDB", version: null }, - { - predicateType: "rea.debugger.command-observation", - operation: "gdb_console", - parameters: { session_id: id, command: "info files" }, - result: { command: "info files", completion_status: "complete" }, - rawResult: { command: "info files" }, - }, - ); - let handler!: (input: unknown, context: unknown) => Promise; - const server = { - delivery: createToolResultDelivery(undefined), - registerTool(name: string, _options: unknown, fn: typeof handler) { - if (name === "gdb_console") handler = fn; - }, - } as unknown as EvidenceMcpServer; - const execute = vi.fn(async () => ok({ evidence })); - const manager = { +it("refuses a pre-cancelled debugger command before dispatch and retires the target for a later command", async () => { + const [target] = await createBinarySessionTargets(); + const provider = { id: "fixture", name: "Fixture", version: null }; + const close = vi.fn(async () => ok(null)); + const session = createTestBinarySession(() => ({ + execute: async (operation) => + ok(createAnalysisExecution(operation, provider)), + close, + })); + const evidence = createEvidence(unknownTarget("not-observed"), provider, { + operation: "gdb_console", + parameters: { command: "info files" }, + result: { completion_status: "complete" }, + }); + const execute = vi.fn(async () => ok(evidence)); + const reason = { phase: "before-dispatch" }; + const call = (signal?: AbortSignal) => + runWithExternalMutationAdmission( + session, + "gdb_console", + signal, execute, - retryCleanupFailures: async () => ok(null), - } as unknown as GdbToolOptions["manager"]; - const record = vi.fn((value: typeof evidence) => - session.recordEvidence(value), + (value) => value, ); - registerServiceTools( - server, - { gdb: { manager, session } }, - { logger: silentLogger, recordEvidence: record }, - ); - const controller = new AbortController(); - const reason = { phase: mode }; - if (mode === "pre-aborted") controller.abort(reason); - try { - const pending = handler( - { session_id: id, command: "info files", detail: "complete" }, - { mcpReq: { signal: controller.signal } }, - ); - if (mode !== "pre-aborted") { - await sessionRetirement.reached(pending, "session retirement"); - expect(execute).toHaveBeenCalledTimes(1); - expect(record).not.toHaveBeenCalled(); - if (mode === "during-retirement") controller.abort(reason); - } - sessionRetirement.release(); - const result = await pending; - const body = result.structuredContent as any; - const observation = { - mode, - aborted: controller.signal.aborted, - executions: execute.mock.calls.length, - retirementCloses: closes, - recordings: record.mock.calls.length, - isError: result.isError === true, - code: body.error?.code ?? null, - hasEvidence: typeof body.evidence_id === "string", - stored: session.hasEvidence(evidence.evidence_id), - }; - expect(observation).toEqual({ - mode, - aborted: mode !== "control", - executions: mode === "pre-aborted" ? 0 : 1, - retirementCloses: mode === "pre-aborted" ? 0 : 1, - recordings: mode === "pre-aborted" ? 0 : 1, - isError: mode !== "control", - code: mode === "control" ? null : "cancelled", - hasEvidence: mode === "control", - stored: mode !== "pre-aborted", - }); - if (mode === "during-retirement") - expect(record.mock.calls[0]?.[0]).toEqual(evidence); - } finally { - sessionRetirement.release(); - await session.close(); - } + expect((await session.open(target)).ok).toBe(true); + try { + expect(await call(AbortSignal.abort(reason))).toMatchObject({ + ok: false, + error: { + _tag: "AnalysisCancelledError", + cause: reason, + operation: "gdb_console", + }, + }); + expect(execute).not.toHaveBeenCalled(); + expect(close).not.toHaveBeenCalled(); + expect(session.activeTarget()?.path).toBe(target); + + expect(await call()).toEqual(ok(evidence)); + expect(execute).toHaveBeenCalledOnce(); + expect(close).toHaveBeenCalledOnce(); + expect(session.activeTarget()).toBeUndefined(); + } finally { + await session.close(); } });