Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(mcp): bound SDK validation errors before transport delivery
morluto7fb0a0cc577f
diff --git a/src/server/EvidenceMcpServer.test.ts b/src/server/EvidenceMcpServer.test.tsindex dedbfe5ce..ce3e7a274 100644--- a/src/server/EvidenceMcpServer.test.ts+++ b/src/server/EvidenceMcpServer.test.ts@@ -1,6 +1,25 @@import { describe, expect, it } from "vitest";+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";+import { z } from "zod";-import { forgetPendingMcpRequest } from "./EvidenceMcpServer.js";+import { InvestigationRecords } from "../application/investigation/InvestigationRecords.js";+import {+ EvidenceMcpServer,+ forgetPendingMcpRequest,+} from "./EvidenceMcpServer.js";+import { ToolResultDelivery } from "./toolResult.js";++const firstText = (result: {+ readonly content: readonly {+ readonly type: string;+ readonly text?: string;+ }[];+}): string | undefined => {+ for (const item of result.content) {+ if (item.type === "text") return item.text;+ }+ return undefined;+};describe("MCP request bookkeeping", () => {it("releases list, tool, and completion state when cancellation arrives", () => {@@ -22,3 +41,106 @@ describe("MCP request bookkeeping", () => {expect(pendingCompletions.has(7)).toBe(false);});});++describe("SDK validation error delivery", () => {+ it("bounds oversized errors, retains their source, and preserves fitting and valid calls", async () => {+ const delivery = new ToolResultDelivery(4096);+ const records = new InvestigationRecords();+ const server = new EvidenceMcpServer(+ { name: "sdk-validation-budget-test", version: "1" },+ { capabilities: {} },+ (evidence) => records.recordEvidence(evidence),+ delivery,+ );+ server.registerTool(+ "procedure_pseudo_code",+ { inputSchema: z.strictObject({ required: z.string() }) },+ async () => ({ content: [{ type: "text", text: "valid call" }] }),+ );+ const client = new Client({+ name: "sdk-validation-budget-client",+ version: "1",+ });+ const [clientTransport, serverTransport] =+ InMemoryTransport.createLinkedPair();+ const oversizedKey = `unexpected_${"x".repeat(6000)}`;+ try {+ await server.connect(serverTransport);+ await client.connect(clientTransport);++ const oversized = await client.callTool({+ name: "procedure_pseudo_code",+ arguments: { required: "present", [oversizedKey]: true },+ });+ expect(oversized.isError).toBe(true);+ expect(oversized.structuredContent).toBeUndefined();+ expect(oversized._meta).toEqual({+ provenance: { untrusted_content: true, source: "analysis_target" },+ });+ expect(Buffer.byteLength(JSON.stringify(oversized))).toBeLessThan(4096);+ const oversizedError = z+ .object({+ error: z.object({+ code: z.string(),+ details: z.object({+ reported_limits: z.record(z.string(), z.unknown()),+ }),+ }),+ })+ .parse(JSON.parse(firstText(oversized) ?? "null"));+ expect(oversizedError.error.code).toBe("resource_constraint");+ const reportedLimits = oversizedError.error.details.reported_limits;+ expect(reportedLimits).toMatchObject({+ evidence_reference: {+ kind: "retained-evidence",+ evidence_id: expect.any(String),+ },+ diagnostic_truncated: true,+ });+ expect(reportedLimits).not.toHaveProperty("retention");+ const bundle = records.exportEvidenceBundle();+ expect(bundle.records).toHaveLength(1);+ expect(bundle.records[0]?.operation).toBe("mcp_tool_error");+ expect(bundle.records[0]?.raw_result).toMatchObject({+ isError: true,+ content: [+ { type: "text", text: expect.stringContaining(oversizedKey) },+ ],+ });+ const evidenceReference = z+ .object({ evidence_id: z.string() })+ .parse(reportedLimits.evidence_reference);+ expect(bundle.records[0]?.evidence_id).toBe(+ evidenceReference.evidence_id,+ );++ const fitting = await client.callTool({+ name: "procedure_pseudo_code",+ arguments: { unexpected: true },+ });+ expect(fitting.isError).toBe(true);+ expect(firstText(fitting)).toContain("Input validation error");++ const quotedKey = '"\\'.repeat(350);+ const quoted = await client.callTool({+ name: "procedure_pseudo_code",+ arguments: { required: "present", [quotedKey]: true },+ });+ expect(quoted.isError).toBe(true);+ expect(firstText(quoted)).toContain("Input validation error");+ expect(Buffer.byteLength(JSON.stringify(quoted))).toBeLessThan(4096);+ expect(records.exportEvidenceBundle().records).toHaveLength(1);++ const valid = await client.callTool({+ name: "procedure_pseudo_code",+ arguments: { required: "present" },+ });+ expect(valid.content).toContainEqual({+ type: "text",+ text: "valid call",+ });+ } finally {+ await Promise.all([client.close(), server.close()]);+ }+ });+});diff --git a/src/server/EvidenceMcpServer.ts b/src/server/EvidenceMcpServer.tsindex 96c7b58b7..3d2cd0da2 100644--- a/src/server/EvidenceMcpServer.ts+++ b/src/server/EvidenceMcpServer.ts@@ -37,6 +37,7 @@ import { toolReturnsTargetContent } from "../contracts/toolEffects.js";import {carriesTargetContentMarker,encodeToolResult,+ measureMcpResultWithinBudget,TARGET_CONTENT_RESULT_META,} from "./toolResultEncoding.js";@@ -346,38 +347,65 @@ class ErrorEvidenceTransport implements Transport {if (!isJSONRPCResultResponse(message) ||!isCallToolResult(message.result) ||- message.result.isError !== true ||- message.result.structuredContent === undefined+ message.result.isError !== true)return message;- const structured = jsonObjectSchema.parse(message.result.structuredContent);const budget = this.delivery.resultBudgetBytes;// Count the provenance marker exactly as the projected error did, and keep// it on the replacement: the retained original may hold target content.- const targetContent = carriesTargetContentMarker(message.result);- // The delivered error omits structuredContent, so its text and error flag count.- const encoded = encodeToolResult(- structured,- budget,- "error-text",- targetContent,- );+ const targetContent =+ carriesTargetContentMarker(message.result) ||+ (tool !== undefined && toolReturnsTargetContent(tool));+ // SDK validation failures have no structured carrier. Size their existing+ // text-only result without serializing the complete JSON-RPC message.+ const isStructured = message.result.structuredContent !== undefined;+ const structured = isStructured+ ? jsonObjectSchema.parse(message.result.structuredContent)+ : undefined;+ const sdkResultWithMarker =+ !isStructured &&+ targetContent &&+ !carriesTargetContentMarker(message.result)+ ? {+ ...message.result,+ _meta: {+ ...message.result._meta,+ ...TARGET_CONTENT_RESULT_META,+ },+ }+ : message.result;+ const encoded =+ structured !== undefined+ ? encodeToolResult(structured, budget, "error-text", targetContent)+ : measureMcpResultWithinBudget(sdkResultWithMarker, budget);if (encoded.ok) return message;const operation = tool ?? "mcp_tool_error";- const originalError = analysisErrorProjectionSchema.safeParse(- structured["error"],- );- // Retain the already projected diagnostic. Transport authentication and raw- // request arguments are deliberately excluded: the application owns their- // explicit sensitivity policy, and its error projection is authoritative.+ const originalResult = jsonObjectSchema.parse(message.result);+ const sdkDiagnostic = !isStructured+ ? message.result.content.find((item) => item.type === "text")?.text+ : undefined;+ const retainedResult = structured ?? originalResult;+ const originalError = isStructured+ ? analysisErrorProjectionSchema.safeParse(structured?.["error"])+ : undefined;+ // Retain the complete original response, including SDK validation text.+ // The SDK error contains its rendered issue, not a separate argument bag;+ // transport authentication and caller arguments are never added here.const evidence = createEvidence(undefined,{ id: "rea-mcp", name: "REA MCP delivery", version: "1" },{operation: "mcp_tool_error",parameters: { tool_name: operation },- result: structured,- rawResult: jsonObjectSchema.parse(message.result),+ result:+ sdkDiagnostic === undefined+ ? retainedResult+ : {+ boundary: "sdk-input-validation",+ diagnostic_preview: sdkDiagnostic.slice(0, 256),+ diagnostic_truncated: sdkDiagnostic.length > 256,+ },+ rawResult: originalResult,},);const recorded = this.recordEvidence?.(evidence);@@ -388,12 +416,18 @@ class ErrorEvidenceTransport implements Transport {"The tool failed, but its complete error response exceeds the MCP response budget.",{boundary: "mcp-response",- ...(originalError.success+ ...(originalError?.success? { original_error_code: originalError.data.code }: {}),result_budget_bytes: budget,response_bytes_at_least: encoded.bytesAtLeast,constraint: encoded.constraint,+ ...(sdkDiagnostic === undefined+ ? {}+ : {+ diagnostic_preview: sdkDiagnostic.slice(0, 256),+ diagnostic_truncated: sdkDiagnostic.length > 256,+ }),...(retained? {evidence_reference: {diff --git a/src/server/toolResultEncoding.ts b/src/server/toolResultEncoding.tsindex 73ec2c717..dc563e105 100644--- a/src/server/toolResultEncoding.ts+++ b/src/server/toolResultEncoding.ts@@ -63,6 +63,26 @@ export type ToolResultEncoding =readonly constraint: "receive-buffer" | "string-length";};+/** Measure an already-formed MCP result object without allocating its JSON text. */+export const measureMcpResultWithinBudget = (+ value: unknown,+ budgetBytes: number,+):+ | { readonly ok: true; readonly bytes: number }+ | {+ readonly ok: false;+ readonly bytesAtLeast: number;+ readonly constraint: "receive-buffer";+ } => {+ let bytes = 0;+ for (const part of bufferedJsonParts(jsonParts(value))) {+ bytes += Buffer.byteLength(part);+ if (bytes > budgetBytes)+ return { ok: false, bytesAtLeast: bytes, constraint: "receive-buffer" };+ }+ return { ok: true, bytes };+};+/** Account for the delivered JSON representations before allocating the complete text. */export const encodeToolResult = (value: JsonValue,diff --git a/tests/boundary/mcp/oversizedErrorDeliveryMcp.test.ts b/tests/boundary/mcp/oversizedErrorDeliveryMcp.test.tsindex 10d081d84..6d4df6da9 100644--- a/tests/boundary/mcp/oversizedErrorDeliveryMcp.test.ts+++ b/tests/boundary/mcp/oversizedErrorDeliveryMcp.test.ts@@ -20,8 +20,12 @@ const UNTRUSTED_TARGET_CONTENT = {provenance: { untrusted_content: true, source: "analysis_target" },};-const failureWithName = (nameBytes: number, targetContent = false) =>- delivery.toErrorToolResult(+const failureWithName = (+ nameBytes: number,+ targetContent = false,+ selectedDelivery = delivery,+) =>+ selectedDelivery.toErrorToolResult(new AnalysisInputError("procedure_address", undefined, [{path: ["procedure"],@@ -260,10 +264,15 @@ it("keeps the untrusted target-content marker on an oversized error's replacemen// The delivered error wire omits only the private structured carrier; its// `isError` flag and any provenance marker count against the result budget.-const deliveredErrorBytes = (nameBytes: number, targetContent: boolean) => {+const deliveredErrorBytes = (+ nameBytes: number,+ targetContent: boolean,+ selectedDelivery = delivery,+) => {const { structuredContent: _carrier, ...wire } = failureWithName(nameBytes,targetContent,+ selectedDelivery,);return Buffer.byteLength(JSON.stringify(wire));};@@ -271,26 +280,28 @@ const deliveredErrorBytes = (nameBytes: number, targetContent: boolean) => {it.each([false, true])("applies the result budget to the complete delivered error (target content: %s)",async (targetContent) => {+ const boundaryDelivery = new ToolResultDelivery(4096);const fittingName =- delivery.resultBudgetBytes - deliveredErrorBytes(0, targetContent);- expect(deliveredErrorBytes(fittingName, targetContent)).toBe(- delivery.resultBudgetBytes,- );+ boundaryDelivery.resultBudgetBytes -+ deliveredErrorBytes(0, targetContent, boundaryDelivery);+ expect(+ deliveredErrorBytes(fittingName, targetContent, boundaryDelivery),+ ).toBe(boundaryDelivery.resultBudgetBytes);+ const toolName = targetContent ? "procedure_pseudo_code" : "record_unknown";const server = new EvidenceMcpServer({ name: "error-budget-test", version: "1" },{ capabilities: {} },undefined,- delivery,+ boundaryDelivery,);- server.registerTool(- "fitting_failure",- { inputSchema: z.object({}) },- async () => failureWithName(fittingName, targetContent),+ server.registerTool(toolName, { inputSchema: z.object({}) }, async () =>+ failureWithName(fittingName, targetContent, boundaryDelivery),);server.registerTool(- "one_byte_over_failure",+ targetContent ? "inspect_artifact" : "export_evidence_bundle",{ inputSchema: z.object({}) },- async () => failureWithName(fittingName + 1, targetContent),+ async () =>+ failureWithName(fittingName + 1, targetContent, boundaryDelivery),);const client = new Client({ name: "error-budget-client", version: "1" });const [clientTransport, serverTransport] =@@ -299,15 +310,19 @@ it.each([false, true])(await server.connect(serverTransport);await client.connect(clientTransport);const fitting = await client.callTool({- name: "fitting_failure",+ name: toolName,arguments: {},});expect(fitting.isError).toBe(true);+ expect(fitting._meta).toEqual(+ targetContent ? UNTRUSTED_TARGET_CONTENT : undefined,+ );expect(parseMcpToolError(fitting)).toEqual(- failureWithName(fittingName, targetContent).structuredContent,+ failureWithName(fittingName, targetContent, boundaryDelivery)+ .structuredContent,);const over = await client.callTool({- name: "one_byte_over_failure",+ name: targetContent ? "inspect_artifact" : "export_evidence_bundle",arguments: {},});expect(over.isError).toBe(true);