Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(mcp): bound SDK validation errors before transport delivery

morluto7fb0a0cc577f
diff --git a/src/server/EvidenceMcpServer.test.ts b/src/server/EvidenceMcpServer.test.ts
index 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.ts
index 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.ts
index 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.ts
index 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);