feat(error-interception): add INVALID_JSON_ARGUMENTS pattern for concatenated JSON objects

When AI models concatenate multiple JSON objects into a single tool call's
arguments string (e.g., {path:file1}{path:file2}), JSON.parse throws and
the tool call is silently discarded. The model receives no feedback and
repeats the mistake.

This commit adds:
- INVALID_JSON_ARGUMENTS error category in types.ts
- EI/INVALID_JSON_ARGUMENTS/001 pattern in errorPatterns.ts (priority 63)
- parseErrors static Map in NativeToolCallParser to store parse error messages
- consumeParseError()/hasParseError() methods for error retrieval
- presentAssistantMessage routes parse errors to INVALID_JSON_ARGUMENTS pattern
- 3 unit tests + 2 integration tests (144 total tests pass)

Closes #1000 (addresses edelauna's comment on concatenated JSON objects)

Author: k1yt

src/core/assistant-message/NativeToolCallParser.ts

@@ -73,6 +73,35 @@ export class NativeToolCallParser {
 		}
 	>()
 
+	/**
+	 * Stores JSON.parse error messages keyed by tool call ID.
+	 * When parseToolCall() catches a JSON.parse failure, it records the error
+	 * here so presentAssistantMessage can retrieve it and route the signal to
+	 * the INVALID_JSON_ARGUMENTS error-interception pattern instead of the
+	 * generic PARAM_MISSING path.
+	 */
+	private static parseErrors = new Map<string, string>()
+
+	/**
+	 * Retrieve and remove the parse error for a given tool call ID.
+	 * Returns undefined if no parse error was recorded.
+	 */
+	public static consumeParseError(toolCallId: string): string | undefined {
+		const error = NativeToolCallParser.parseErrors.get(toolCallId)
+		if (error !== undefined) {
+			NativeToolCallParser.parseErrors.delete(toolCallId)
+		}
+		return error
+	}
+
+	/**
+	 * Check whether a parse error was recorded for a given tool call ID
+	 * without consuming it.
+	 */
+	public static hasParseError(toolCallId: string): boolean {
+		return NativeToolCallParser.parseErrors.has(toolCallId)
+	}
+
 	private static coerceOptionalBoolean(value: unknown): boolean | undefined {
 		if (typeof value === "boolean") {
 			return value
@@ -1030,14 +1059,22 @@ export class NativeToolCallParser {
 
 			return result
 		} catch (error) {
-			console.error(
-				`Failed to parse tool call arguments: ${error instanceof Error ? error.message : String(error)}`,
-			)
-
-			console.error(`Tool call: ${JSON.stringify(toolCall, null, 2)}`)
-			return null
+				const errorMessage = error instanceof Error ? error.message : String(error)
+	
+				console.error(
+					`Failed to parse tool call arguments: ${errorMessage}`,
+				)
+	
+				console.error(`Tool call: ${JSON.stringify(toolCall, null, 2)}`)
+	
+				// Store the parse error so presentAssistantMessage can route it
+				// to the INVALID_JSON_ARGUMENTS error-interception pattern
+				// instead of the generic PARAM_MISSING path.
+				NativeToolCallParser.parseErrors.set(toolCall.id, errorMessage)
+	
+				return null
+			}
 		}
-	}
 
 	/**
 	 * Parse dynamic MCP tools (named mcp--serverName--toolName).

src/core/assistant-message/__tests__/presentAssistantMessage-error-interception.spec.ts

@@ -3,6 +3,7 @@
 import { describe, it, expect, beforeEach, vi } from "vitest"
 import { presentAssistantMessage } from "../presentAssistantMessage"
 import { getTaskErrorState } from "../../tools/error-interception"
+import { NativeToolCallParser } from "../NativeToolCallParser"
 
 // Mock heavy dependencies that are not relevant to error interception paths.
 vi.mock("../../task/Task")
@@ -38,6 +39,15 @@ vi.mock("../../i18n", () => ({
 	}),
 }))
 
+// Mock NativeToolCallParser so we can simulate JSON.parse failures
+// (concatenated JSON objects in tool call arguments).
+vi.mock("../NativeToolCallParser", () => ({
+	NativeToolCallParser: {
+		consumeParseError: vi.fn(() => undefined),
+		hasParseError: vi.fn(() => false),
+	},
+}))
+
 function createMockTask() {
 	const mockTask: any = {
 		taskId: "ei-task-id",
@@ -99,6 +109,8 @@ describe("presentAssistantMessage - Error Interception Integration", () => {
 		// Reset validateToolUse mock to prevent cross-test contamination from mockImplementationOnce
 		const { validateToolUse } = await import("../../tools/validateToolUse")
 		;(validateToolUse as any).mockReset()
+		// Reset NativeToolCallParser.consumeParseError mock to default (no parse error)
+		vi.mocked(NativeToolCallParser.consumeParseError).mockReturnValue(undefined)
 	})
 
 	describe("XML_NATIVE_DUAL_PROTOCOL detection", () => {
@@ -622,5 +634,76 @@ describe("presentAssistantMessage - Error Interception Integration", () => {
 			)
 			expect(mockTask.didAlreadyUseTool).toBe(false)
 		})
+	
+		describe("INVALID_JSON_ARGUMENTS - concatenated JSON tool call", () => {
+			it("produces guided tool_result with INVALID_JSON_ARGUMENTS when parse error is recorded", async () => {
+				const toolCallId = "call_concat_json_001"
+	
+				// Simulate NativeToolCallParser having recorded a JSON.parse
+				// failure for this tool call (e.g. concatenated JSON objects).
+				vi.mocked(NativeToolCallParser.consumeParseError).mockReturnValue(
+					"Unexpected non-whitespace character after JSON at position 42",
+				)
+	
+				mockTask.assistantMessageContent = [
+					{
+						type: "tool_use",
+						id: toolCallId,
+						name: "read_file",
+						params: {},
+						// nativeArgs is absent because JSON.parse failed
+						partial: false,
+					},
+				]
+	
+				await presentAssistantMessage(mockTask)
+	
+				const toolResult = mockTask.userMessageContent.find(
+					(item: any) => item.type === "tool_result" && item.tool_use_id === toolCallId,
+				)
+				expect(toolResult).toBeDefined()
+				expect(toolResult.is_error).toBe(true)
+				// The guided payload should reference the INVALID_JSON_ARGUMENTS category
+				expect(String(toolResult.content)).toContain("INVALID_JSON_ARGUMENTS")
+				// The guidance should mention concatenation
+				expect(String(toolResult.content)).toContain("concatenated")
+				// Should mention one tool call per file
+				expect(String(toolResult.content)).toContain("one tool call per file")
+				// Should NOT contain the generic PARAM_MISSING message
+				expect(String(toolResult.content)).not.toContain("PARAM_MISSING")
+				// consecutiveMistakeCount should increment
+				expect(mockTask.consecutiveMistakeCount).toBe(1)
+				// Should NOT have set didAlreadyUseTool
+				expect(mockTask.didAlreadyUseTool).toBe(false)
+			})
+	
+			it("falls back to PARAM_MISSING when no parse error is recorded", async () => {
+				const toolCallId = "call_missing_args_002"
+	
+				// No parse error recorded — simulate the original missing-args path
+				vi.mocked(NativeToolCallParser.consumeParseError).mockReturnValue(undefined)
+	
+				mockTask.assistantMessageContent = [
+					{
+						type: "tool_use",
+						id: toolCallId,
+						name: "read_file",
+						params: {},
+						partial: false,
+					},
+				]
+	
+				await presentAssistantMessage(mockTask)
+	
+				const toolResult = mockTask.userMessageContent.find(
+					(item: any) => item.type === "tool_result" && item.tool_use_id === toolCallId,
+				)
+				expect(toolResult).toBeDefined()
+				expect(toolResult.is_error).toBe(true)
+				// Should contain PARAM_MISSING, not INVALID_JSON_ARGUMENTS
+				expect(String(toolResult.content)).toContain("PARAM_MISSING")
+				expect(String(toolResult.content)).not.toContain("INVALID_JSON_ARGUMENTS")
+			})
+		})
 	})
 })

src/core/assistant-message/presentAssistantMessage.ts

@@ -20,6 +20,7 @@ import type { ToolParamName, ToolResponse, ToolUse, McpToolUse } from "../../sha
 
 import { AskIgnoredError } from "../task/AskIgnoredError"
 import { Task } from "../task/Task"
+import { NativeToolCallParser } from "./NativeToolCallParser"
 
 import { listFilesTool } from "../tools/ListFilesTool"
 import { readFileTool } from "../tools/ReadFileTool"
@@ -509,25 +510,39 @@ export async function presentAssistantMessage(cline: Task) {
 				const customTool = stateExperiments?.customTools ? customToolRegistry.get(block.name) : undefined
 				const isKnownTool = isValidToolName(String(block.name), stateExperiments)
 				if (isKnownTool && !block.nativeArgs && !customTool) {
-					const errorMessage =
-						`Invalid tool call for '${block.name}': missing nativeArgs. ` +
-						`This usually means the model streamed invalid or incomplete arguments and the call could not be finalized.`
-
+					// Check whether NativeToolCallParser recorded a JSON.parse
+					// failure for this tool call ID. If so, the arguments were
+					// present but malformed (e.g. concatenated JSON objects),
+					// which is a distinct failure pattern from missing args.
+					const parseErrorMessage = NativeToolCallParser.consumeParseError(toolCallId)
+					const isInvalidJson = parseErrorMessage !== undefined
+	
+					const errorMessage = isInvalidJson
+						? `Invalid tool call for '${block.name}': arguments could not be parsed as JSON. ` +
+							`This usually means multiple JSON objects were concatenated into a single arguments string.`
+						: `Invalid tool call for '${block.name}': missing nativeArgs. ` +
+							`This usually means the model streamed invalid or incomplete arguments and the call could not be finalized.`
+	
 					cline.consecutiveMistakeCount++
 					try {
 						cline.recordToolError(block.name as ToolName, errorMessage)
 					} catch {
 						// Best-effort only
 					}
-
+	
 					// Convert missing nativeArgs into a structured guided payload.
+					// When a JSON.parse error was recorded, route to the
+					// INVALID_JSON_ARGUMENTS pattern; otherwise fall back to
+					// the generic PARAM_MISSING pattern.
 					const guided = interceptor.transformError(cline, {
 						source: "parser",
 						stage: "parse",
 						taskId: cline.taskId,
 						toolCallId,
 						toolName: block.name,
-						metadata: { missingNativeArgs: true },
+						metadata: isInvalidJson
+							? { invalidJsonArguments: true }
+							: { missingNativeArgs: true },
 					})
 
 					// Push tool_result directly without setting didAlreadyUseTool so streaming can

src/core/tools/error-interception/__tests__/ErrorClassifier.spec.ts

@@ -194,6 +194,41 @@ describe("classifyError", () => {
 		})
 	})
 
+	it("classifies invalid JSON arguments from parser as INVALID_JSON_ARGUMENTS", () => {
+		const signal = baseSignal({
+			source: "parser",
+			stage: "parse",
+			metadata: { invalidJsonArguments: true },
+		})
+		const result = classifyError(signal)
+		expect(result.category).toBe("INVALID_JSON_ARGUMENTS")
+		expect(result.patternId).toBe("EI/INVALID_JSON_ARGUMENTS/001")
+		expect(result.confidence).toBe("exact")
+		expect(result.retryPolicy).toBe("correct-and-retry")
+	})
+
+	it("does not classify INVALID_JSON_ARGUMENTS without tool context", () => {
+		const signal = baseSignal({
+			source: "parser",
+			stage: "parse",
+			toolName: undefined,
+			metadata: { invalidJsonArguments: true },
+		})
+		const result = classifyError(signal)
+		expect(result.category).not.toBe("INVALID_JSON_ARGUMENTS")
+	})
+
+	it("does not classify INVALID_JSON_ARGUMENTS for missing native args", () => {
+		const signal = baseSignal({
+			source: "parser",
+			stage: "parse",
+			metadata: { missingNativeArgs: true },
+		})
+		const result = classifyError(signal)
+		expect(result.category).toBe("PARAM_MISSING")
+		expect(result.category).not.toBe("INVALID_JSON_ARGUMENTS")
+	})
+
 	describe("fallback heuristic matches", () => {
 		it("classifies shell integration message when name is missing", () => {
 			const signal = baseSignal({
@@ -369,6 +404,7 @@ describe("classifyError", () => {
 				"SHELL_INTEGRATION",
 				"MCP_TOOL_MISSING",
 				"INVALID_TOOL_PROTOCOL",
+				"INVALID_JSON_ARGUMENTS",
 				"CONTEXT_OVERFLOW",
 				"UNCLASSIFIED",
 			]

src/core/tools/error-interception/errorPatterns.ts

@@ -350,6 +350,29 @@ export const ERROR_PATTERNS: readonly ErrorPattern[] = [
 		},
 	},
 
+	// -------------------------------------------------------------------------
+	// 63 INVALID_JSON_ARGUMENTS
+	// -------------------------------------------------------------------------
+	{
+		id: "EI/INVALID_JSON_ARGUMENTS/001",
+		category: "INVALID_JSON_ARGUMENTS",
+		priority: 63,
+		severity: "error",
+		retryPolicy: "correct-and-retry",
+		requiresToolContext: true,
+		matches: (signal) =>
+			signal.source === "parser" &&
+			signal.stage === "parse" &&
+			metadataIs(signal, "invalidJsonArguments", true),
+		template: {
+			what: "Tool call arguments could not be parsed as JSON.",
+			why: "You concatenated multiple JSON objects into a single arguments string. Each tool call must contain exactly one valid JSON object.",
+			next: [
+				"Issue one tool call per file. Use parallel tool calls if you need multiple files simultaneously.",
+			],
+		},
+	},
+
 	// -------------------------------------------------------------------------
 	// 60 CONTEXT_OVERFLOW
 	// -------------------------------------------------------------------------

src/core/tools/error-interception/types.ts

@@ -14,6 +14,7 @@ export type ErrorCategory =
 	| "DIFF_MATCH_FAILED"
 	| "DUPLICATE_CALL"
 	| "FILE_NOT_FOUND"
+	| "INVALID_JSON_ARGUMENTS"
 	| "INVALID_TOOL_PROTOCOL"
 	| "MCP_TOOL_MISSING"
 	| "PARAM_MISSING"