Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

perf(server): stop shipping full MCP tool results in thread payloads (#5482)

Theo Browne3da315e7b5c4
diff --git a/apps/server/src/orchestration/ActivityPayloadProjection.test.ts b/apps/server/src/orchestration/ActivityPayloadProjection.test.ts
index 7ea1e3ea0..fc9ea4b62 100644
--- a/apps/server/src/orchestration/ActivityPayloadProjection.test.ts
+++ b/apps/server/src/orchestration/ActivityPayloadProjection.test.ts
@@ -44,6 +44,60 @@ describe("projectActivityPayload agent-field survival", () => {
expect(data.somethingClientNeverReads).toBeUndefined();
});
+ it("slims Codex-shaped mcp_tool_call items to rendered fields plus a result summary", () => {
+ const projected = projectActivityPayload(
+ activity({
+ itemType: "mcp_tool_call",
+ data: {
+ item: {
+ type: "mcpToolCall",
+ id: "item-1",
+ tool: "fetch_pr",
+ server: "github",
+ status: "completed",
+ arguments: { pr: 42 },
+ durationMs: 1200,
+ result: {
+ content: [{ type: "text", text: `PR body line one\n${"x".repeat(5000)}` }],
+ structuredContent: { huge: "y".repeat(5000) },
+ },
+ _meta: { internal: true },
+ },
+ },
+ }),
+ );
+ const data = (projected.payload as Record<string, unknown>).data as Record<string, unknown>;
+ const item = data.item as Record<string, unknown>;
+ expect(item.tool).toBe("fetch_pr");
+ expect(item.server).toBe("github");
+ expect(item.arguments).toEqual({ pr: 42 });
+ expect(item._meta).toBeUndefined();
+ expect(item.result).toEqual({ content: "PR body line one" });
+ expect(JSON.stringify(projected.payload).length).toBeLessThan(500);
+ });
+
+ it("slims Claude-shaped mcp_tool_call data (toolName/input/result block)", () => {
+ const projected = projectActivityPayload(
+ activity({
+ itemType: "mcp_tool_call",
+ data: {
+ toolName: "mcp__github__fetch_pr",
+ input: { pr: 42 },
+ result: {
+ type: "tool_result",
+ tool_use_id: "toolu_1",
+ content: [{ type: "text", text: `first line of output\n${"z".repeat(5000)}` }],
+ },
+ },
+ }),
+ );
+ const data = (projected.payload as Record<string, unknown>).data as Record<string, unknown>;
+ expect(data.toolName).toBe("mcp__github__fetch_pr");
+ expect(data.input).toEqual({ pr: 42 });
+ expect(data.result).toEqual({ content: "first line of output" });
+ expect(JSON.stringify(projected.payload).length).toBeLessThan(500);
+ });
+
it("passes task lifecycle payloads (no data field) through untouched", () => {
const source = activity({
taskId: "task-9",
diff --git a/apps/server/src/orchestration/ActivityPayloadProjection.ts b/apps/server/src/orchestration/ActivityPayloadProjection.ts
index 67896961b..854e45dbf 100644
--- a/apps/server/src/orchestration/ActivityPayloadProjection.ts
+++ b/apps/server/src/orchestration/ActivityPayloadProjection.ts
@@ -123,6 +123,114 @@ function summarizeToolTextOutput(value: string): string | null {
return null;
}
+/**
+ * Fields of an MCP tool-call item both clients render in the expanded
+ * work-log row. Everything else — notably `result`, which carries the full
+ * tool output and dominates wire size on MCP-heavy threads — is summarized
+ * or dropped. Full payloads remain in persistence.
+ */
+const MCP_ITEM_KEPT_FIELDS = [
+ "type",
+ "id",
+ "tool",
+ "server",
+ "status",
+ "arguments",
+ "appContext",
+ "error",
+ "durationMs",
+] as const;
+
+/**
+ * Pulls renderable text out of an MCP tool result: either a Codex-style
+ * `{content: [{type: "text", text}, ...]}` record or a raw Claude
+ * `tool_result` block whose `content` is a string or block array.
+ */
+function extractMcpResultText(result: unknown): string | null {
+ const record = asRecord(result);
+ if (!record) {
+ return typeof result === "string" ? result : null;
+ }
+ if (typeof record.content === "string") {
+ return record.content;
+ }
+ if (Array.isArray(record.content)) {
+ const texts: string[] = [];
+ for (const entry of record.content) {
+ const text = asRecord(entry)?.text;
+ if (typeof text === "string" && text.trim().length > 0) {
+ texts.push(text);
+ }
+ }
+ if (texts.length > 0) {
+ return texts.join("\n");
+ }
+ }
+ return null;
+}
+
+function summarizeMcpResult(result: unknown): Record<string, unknown> | undefined {
+ if (result === undefined || result === null) {
+ return undefined;
+ }
+ const text = extractMcpResultText(result);
+ const summary = text ? summarizeToolTextOutput(text) : null;
+ return summary ? { content: summary } : undefined;
+}
+
+/**
+ * MCP tool calls carry full tool results (`data.item.result` on Codex,
+ * `data.result` on Claude/OpenCode) that used to bypass slimming entirely to
+ * keep the expanded-row UI working. Keep the fields the UI actually renders
+ * and summarize the result like regular tool output.
+ */
+function projectMcpToolCallData(data: Record<string, unknown>): Record<string, unknown> {
+ const projectedData: Record<string, unknown> = {};
+
+ const item = asRecord(data.item);
+ if (item) {
+ const projectedItem: Record<string, unknown> = {};
+ for (const key of MCP_ITEM_KEPT_FIELDS) {
+ if (key in item) {
+ projectedItem[key] = item[key];
+ }
+ }
+ const result = summarizeMcpResult(item.result);
+ if (result) {
+ projectedItem.result = result;
+ }
+ projectedData.item = projectedItem;
+ }
+
+ if ("toolName" in data) {
+ projectedData.toolName = data.toolName;
+ }
+ if ("input" in data) {
+ projectedData.input = data.input;
+ }
+ if (!item) {
+ const result = summarizeMcpResult(data.result);
+ if (result) {
+ projectedData.result = result;
+ }
+ }
+
+ if ("toolCallId" in data) {
+ projectedData.toolCallId = data.toolCallId;
+ }
+ if ("kind" in data) {
+ projectedData.kind = data.kind;
+ }
+
+ const changedFiles: string[] = [];
+ collectChangedFiles(data, changedFiles, new Set<string>(), 0);
+ if (changedFiles.length > 0) {
+ projectedData.files = changedFiles.map((path) => ({ path }));
+ }
+
+ return projectedData;
+}
+
function projectRawOutput(value: unknown): Record<string, unknown> | undefined {
const rawOutput = asRecord(value);
if (!rawOutput) {
@@ -160,10 +268,20 @@ export function projectActivityPayload(
): OrchestrationThreadActivity {
const payload = asRecord(activity.payload);
const data = asRecord(payload?.data);
- if (!payload || !data || payload.itemType === "mcp_tool_call") {
+ if (!payload || !data) {
return activity;
}
+ if (payload.itemType === "mcp_tool_call") {
+ return {
+ ...activity,
+ payload: {
+ ...payload,
+ data: projectMcpToolCallData(data),
+ },
+ };
+ }
+
const projectedData: Record<string, unknown> = {};
const item = projectCommandData(data);
if (item) {
diff --git a/apps/server/test/ActivityPayloadProjection.test.ts b/apps/server/test/ActivityPayloadProjection.test.ts
index d6098937e..2d1180139 100644
--- a/apps/server/test/ActivityPayloadProjection.test.ts
+++ b/apps/server/test/ActivityPayloadProjection.test.ts
@@ -117,9 +117,9 @@ const fixtures = [
server: "repository",
tool: "search",
arguments: { query: "activity projection" },
- aggregatedOutput: "mcp payload remains available",
+ aggregatedOutput: "mcp bulk is dropped",
},
- ignored: "MCP data is rendered verbatim",
+ ignored: "top-level bulk",
}),
makeActivity("search", "web_search", {
rawOutput: {
@@ -184,13 +184,37 @@ describe("projectActivityPayload", () => {
});
});
- it("passes MCP tool data through unchanged", () => {
- expect(projectActivityPayload(fixtures[4]!)).toBe(fixtures[4]);
+ it("slims MCP tool data to the fields the expanded row renders", () => {
+ expect(projectActivityPayload(fixtures[4]!).payload).toEqual({
+ itemType: "mcp_tool_call",
+ title: "mcp_tool_call",
+ detail: "mcp_tool_call detail",
+ status: "completed",
+ requestKind: "command",
+ data: {
+ item: {
+ server: "repository",
+ tool: "search",
+ arguments: { query: "activity projection" },
+ },
+ },
+ });
});
it("keeps current web and mobile derived output identical for every tool item type", () => {
for (const activity of fixtures) {
const projected = projectActivityPayload(activity);
+ if (activity === fixtures[4]) {
+ // MCP is the one deliberate difference: the expanded row's toolData
+ // loses result bulk but keeps the rendered identity fields.
+ const [entry] = deriveWorkLogEntries([projected]);
+ expect(entry?.toolData).toEqual({
+ server: "repository",
+ tool: "search",
+ arguments: { query: "activity projection" },
+ });
+ continue;
+ }
expect(deriveWorkLogEntries([projected])).toEqual(deriveWorkLogEntries([activity]));
expect(comparableThreadFeed([projected])).toEqual(comparableThreadFeed([activity]));
}
@@ -328,12 +352,12 @@ describe("context-window snapshot dedup", () => {
);
});
- it("leaves snapshots without context-window activities untouched", () => {
+ it("applies only payload slimming when there are no context-window activities", () => {
const projected = projectThreadDetailSnapshot({
snapshotSequence: 7,
thread: makeThread([fixtures[4]!]),
});
- expect(projected.thread.activities).toEqual([fixtures[4]]);
+ expect(projected.thread.activities).toEqual([projectActivityPayload(fixtures[4]!)]);
});
it("does not filter live activity-appended events", () => {