Files
rea/tests/boundary/mcp/oversizedErrorDeliveryMcp.test.ts
T
b6ad1f2c3d feat(mcp): compact input schema profile for size-capped providers (kimi-cli/Moonshot) (#1514)
* feat(mcp): add compact input schema profile for size-capped providers

Moonshot's function-calling API rejects a request while any single tool
parameters schema exceeds its literal serialized size cap, so clients
such as kimi-cli fail every request while the default catalog is
attached (#1484).

Add an opt-in REA_MCP_INPUT_SCHEMA_PROFILE=compact server presentation.
Each advertised input schema is rendered within a 13,312-byte budget,
measured to sit below the observed provider cap: annotation prose
(nested descriptions, examples, defaults, titles) is dropped, repeated
annotation-free subschemas are shared through schema-local $defs/$ref
references the provider validates without expansion, and the three
structurally oversized schemas are advertised in a documented reduced
form. The canonical catalog, tool set, output schemas, and server-side
canonical validation are unchanged; the default full profile is
byte-identical to today's advertisement.

Boundary tests pin every compact schema to the budget, keep them valid
JSON Schema that still accepts every canonical example, hold reduced
presentations at three or fewer, and verify canonical rejection still
guards a permissive advertisement. Verified against the real Moonshot
API through kimi-cli: prompts succeed with the compact catalog attached
where the default catalog fails every request with 400.

* fix(mcp): preserve compact schemas through Kimi conversion

---------

Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
2026-10-10 16:58:43 +08:00

192 lines
6.3 KiB
TypeScript

import { parseMcpToolError } from "../../fixtures/mcpToolError.js";
import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
import {
STDIO_DEFAULT_MAX_BUFFER_SIZE,
type CallToolResult,
} from "@modelcontextprotocol/server";
import { expect, it } from "vitest";
import { z } from "zod";
import { AnalysisInputError } from "../../../src/domain/analysisErrorCore.js";
import type { EvidenceWriter } from "../../../src/application/investigation/InvestigationRecordPort.js";
import { EvidenceIntegrityError } from "../../../src/domain/evidenceErrors.js";
import type { Evidence } from "../../../src/domain/evidence.js";
import { err, ok } from "../../../src/domain/result.js";
import { EvidenceMcpServer } from "../../../src/server/EvidenceMcpServer.js";
import { ToolResultDelivery } from "../../../src/server/toolResult.js";
const delivery = new ToolResultDelivery(STDIO_DEFAULT_MAX_BUFFER_SIZE);
const failureWithName = (nameBytes: number) =>
delivery.toErrorToolResult(
new AnalysisInputError("procedure_address", undefined, [
{
path: ["procedure"],
reason: "invalid_value",
message: `Unknown Ghidra procedure name or address: REA_MISSING_${"x".repeat(nameBytes)}`,
},
]),
);
// The delivered error carries its JSON once, as text, so only a diagnostic
// larger than the whole budget is oversized.
const oversizedFailure = () =>
failureWithName(STDIO_DEFAULT_MAX_BUFFER_SIZE + 64 * 1024);
const exerciseDeliveryFailure = async (
recordEvidence: EvidenceWriter["recordEvidence"] | undefined,
retention: "retained" | "unavailable" | "failed",
) => {
const server = new EvidenceMcpServer(
{ name: "oversized-error-test", version: "1" },
{ capabilities: {} },
recordEvidence,
delivery,
);
server.registerTool(
"large_failure",
{ inputSchema: z.object({}) },
async () => oversizedFailure(),
);
server.registerTool(
"healthy",
{ inputSchema: z.object({}) },
async (): Promise<CallToolResult> => ({
content: [{ type: "text", text: "still connected" }],
}),
);
const client = new Client({ name: "oversized-error-client", version: "1" });
const [clientTransport, serverTransport] =
InMemoryTransport.createLinkedPair();
try {
await server.connect(serverTransport);
await client.connect(clientTransport);
const failure = await client.callTool({
name: "large_failure",
arguments: {},
});
expect(failure.isError).toBe(true);
expect(failure.structuredContent).toBeUndefined();
expect(parseMcpToolError(failure)).toMatchObject({
error: {
code: "resource_constraint",
details: {
reported_limits: {
original_error_code: "invalid_request",
},
},
},
});
const reportedLimits = z
.object({
error: z.object({
code: z.literal("resource_constraint"),
details: z.object({
reported_limits: z.record(z.string(), z.unknown()),
}),
}),
})
.parse(parseMcpToolError(failure)).error.details.reported_limits;
expect(parseMcpToolError(failure)).toMatchObject({
error: {
details: {
reported_limits: {
boundary: "mcp-response",
},
},
},
});
if (retention === "retained") {
expect(reportedLimits.evidence_reference).toMatchObject({
kind: "retained-evidence",
evidence_id: expect.any(String),
});
expect(reportedLimits).not.toHaveProperty("retention");
} else {
expect(reportedLimits).not.toHaveProperty("evidence_reference");
expect(reportedLimits.retention).toBe(retention);
}
if (retention === "failed")
expect(reportedLimits.retention_error).toMatchObject({
code: "evidence_integrity_mismatch",
});
expect(Buffer.byteLength(JSON.stringify(failure))).toBeLessThan(
STDIO_DEFAULT_MAX_BUFFER_SIZE,
);
const healthy = await client.callTool({ name: "healthy", arguments: {} });
expect(healthy.content).toContainEqual({
type: "text",
text: "still connected",
});
} finally {
await Promise.all([client.close(), server.close()]);
}
};
it("keeps the SDK connection usable when oversized-error retention is unavailable or fails", async () => {
await exerciseDeliveryFailure(undefined, "unavailable");
await exerciseDeliveryFailure(
() =>
err(
new EvidenceIntegrityError(
"fixture ledger rejected the Evidence record",
),
),
"failed",
);
});
it("retains the complete oversized diagnostic before removing its private structured carrier", async () => {
const retained: Evidence[] = [];
await exerciseDeliveryFailure((evidence) => {
retained.push(evidence);
return ok("added");
}, "retained");
expect(retained).toHaveLength(1);
expect(retained[0]?.normalized_result).toEqual(
oversizedFailure().structuredContent,
);
expect(retained[0]?.raw_result).toEqual(oversizedFailure());
});
it("delivers an error whose text fits although structured and text copies would not", async () => {
const nameBytes = Math.ceil(STDIO_DEFAULT_MAX_BUFFER_SIZE / 2) + 64 * 1024;
const retained: Evidence[] = [];
const server = new EvidenceMcpServer(
{ name: "mid-sized-error-test", version: "1" },
{ capabilities: {} },
(evidence) => {
retained.push(evidence);
return ok("added");
},
delivery,
);
server.registerTool("mid_failure", { inputSchema: z.object({}) }, async () =>
failureWithName(nameBytes),
);
const client = new Client({ name: "mid-sized-error-client", version: "1" });
const [clientTransport, serverTransport] =
InMemoryTransport.createLinkedPair();
try {
await server.connect(serverTransport);
await client.connect(clientTransport);
const failure = await client.callTool({
name: "mid_failure",
arguments: {},
});
expect(failure.isError).toBe(true);
expect(failure.structuredContent).toBeUndefined();
expect(parseMcpToolError(failure)).toEqual(
failureWithName(nameBytes).structuredContent,
);
expect(retained).toHaveLength(0);
expect(Buffer.byteLength(JSON.stringify(failure))).toBeLessThan(
STDIO_DEFAULT_MAX_BUFFER_SIZE,
);
} finally {
await Promise.all([client.close(), server.close()]);
}
});