fix(condense): pair stranded tool_use blocks on the send path

Author: edelauna

src/core/condense/__tests__/index.spec.ts

@@ -124,7 +124,7 @@ describe("injectSyntheticToolResults", () => {
 		]
 
 		const result = injectSyntheticToolResults(messages)
-		expect(result).toEqual(messages)
+		expect(result).toBe(messages)
 	})
 
 	it("should inject synthetic tool_result for orphan tool_call", () => {
@@ -250,6 +250,75 @@ describe("injectSyntheticToolResults", () => {
 		// Both tool_uses have matching tool_results, no injection needed
 		expect(result).toEqual(messages)
 	})
+
+	it("should independently pair two consecutive assistant tool_use turns", () => {
+		// Regression guard: the per-assistant-message loop must pair EACH turn independently.
+		// A fix that only patches the first orphan and skips subsequent ones would pass the
+		// single-orphan cases above but fail here.
+		const messages: ApiMessage[] = [
+			{ role: "user", content: "Hello", ts: 1 },
+			{
+				role: "assistant",
+				content: [{ type: "tool_use", id: "tool-A", name: "read_file", input: { path: "a.ts" } }],
+				ts: 2,
+			},
+			{
+				role: "user",
+				content: [{ type: "tool_result", tool_use_id: "tool-A", content: "contents a" }],
+				ts: 3,
+			},
+			{
+				role: "assistant",
+				content: [{ type: "tool_use", id: "tool-B", name: "read_file", input: { path: "b.ts" } }],
+				ts: 4,
+			},
+			// No tool_result for tool-B
+		]
+
+		const result = injectSyntheticToolResults(messages)
+
+		// 4 input messages + 1 synthetic = 5
+		expect(result.length).toBe(5)
+		// First pair must be unchanged.
+		expect((result[2].content as any[])[0]).toMatchObject({ type: "tool_result", tool_use_id: "tool-A" })
+		// Synthetic for second orphan must be spliced immediately after the second assistant.
+		expect(result[4].role).toBe("user")
+		const synthContent = result[4].content as any[]
+		expect(synthContent).toHaveLength(1)
+		expect(synthContent[0]).toMatchObject({ type: "tool_result", tool_use_id: "tool-B" })
+	})
+
+	it("should merge synthetic for missing tool_use_id into first surviving user message when result set is partial", () => {
+		// Two tool_uses on one assistant turn; the first result survives, the second was filtered
+		// away. The synthetic for the missing id must be merged into the existing user message
+		// (which carries the first result) rather than appended as a new third message.
+		const messages: ApiMessage[] = [
+			{ role: "user", content: "Hello", ts: 1 },
+			{
+				role: "assistant",
+				content: [
+					{ type: "tool_use", id: "tool-present", name: "read_file", input: { path: "a.ts" } },
+					{ type: "tool_use", id: "tool-missing", name: "read_file", input: { path: "b.ts" } },
+				],
+				ts: 2,
+			},
+			{
+				role: "user",
+				content: [{ type: "tool_result", tool_use_id: "tool-present", content: "contents a" }],
+				ts: 3,
+			},
+			// tool-missing has no result
+		]
+
+		const result = injectSyntheticToolResults(messages)
+
+		// Synthetic merges into existing user message — length stays 3.
+		expect(result.length).toBe(3)
+		const merged = result[2].content as any[]
+		expect(merged).toHaveLength(2)
+		expect(merged[0]).toMatchObject({ type: "tool_result", tool_use_id: "tool-present" })
+		expect(merged[1]).toMatchObject({ type: "tool_result", tool_use_id: "tool-missing" })
+	})
 })
 
 describe("getMessagesSinceLastSummary", () => {

src/core/condense/index.ts

@@ -140,6 +140,10 @@ The goal is for work to continue seamlessly after condensation - as if it never
  * following user message, adding synthetic placeholders for any that are missing.
  * Existing tool_result blocks are left untouched. Emits MissingToolResultError telemetry
  * when it fires.
+ *
+ * @param reason - Content for injected synthetic blocks. Defaults to
+ *   `SYNTHETIC_TOOL_RESULT_REASONS.condense` (condensation caller); use
+ *   `SYNTHETIC_TOOL_RESULT_REASONS.historyShaping` at the send path.
  */
 export function injectSyntheticToolResults(
 	messages: ApiMessage[],
@@ -151,14 +155,15 @@ export function injectSyntheticToolResults(
 	// after the orphan-bearing assistant — what the provider sees as "the next user
 	// message" once `mergeConsecutiveApiMessages` fuses them. A truncation marker stops
 	// the span (merge refuses to cross one).
-	const out: ApiMessage[] = messages.map((msg) => msg)
+	let out: ApiMessage[] | undefined
 	const allOrphanIds: string[] = []
 	const allExistingResultIds = new Set<string>()
 	let toolUseCount = 0
 	let toolResultCount = 0
 
-	for (let i = 0; i < out.length; i++) {
-		const msg = out[i]
+	for (let i = 0; i < (out ?? messages).length; i++) {
+		const work = out ?? messages
+		const msg = work[i]
 		if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
 			continue
 		}
@@ -177,8 +182,8 @@ export function injectSyntheticToolResults(
 
 		let spanEnd = i + 1
 		const spanResultIds = new Set<string>()
-		while (spanEnd < out.length) {
-			const candidate = out[spanEnd]
+		while (spanEnd < work.length) {
+			const candidate = work[spanEnd]
 			if (candidate.role !== "user") break
 			if (Array.isArray(candidate.content)) {
 				for (const block of candidate.content) {
@@ -204,6 +209,11 @@ export function injectSyntheticToolResults(
 
 		allOrphanIds.push(...missing)
 
+		// Clone lazily — only on first mutation.
+		if (!out) {
+			out = [...messages]
+		}
+
 		const syntheticResults: Anthropic.Messages.ToolResultBlockParam[] = missing.map((id) => ({
 			type: "tool_result" as const,
 			tool_use_id: id,
@@ -241,25 +251,28 @@ export function injectSyntheticToolResults(
 	// Mirror the validateToolResultIds.ts telemetry shape so PostHog dashboards keyed off
 	// MissingToolResultError already aggregate this. The `reason` tag lets us split sources
 	// once data is in.
+	const existingResultIds = [...allExistingResultIds]
 	if (TelemetryService.hasInstance()) {
 		TelemetryService.instance.captureException(
 			new MissingToolResultError(
 				`injectSyntheticToolResults paired ${allOrphanIds.length} orphan tool_use block(s). reason=${reason}`,
 				allOrphanIds,
-				[...allExistingResultIds],
+				existingResultIds,
 			),
 			{
 				reason,
 				missingToolUseIds: allOrphanIds,
-				existingToolResultIds: [...allExistingResultIds],
+				existingToolResultIds: existingResultIds,
 				toolUseCount,
 				toolResultCount,
 				source: "injectSyntheticToolResults",
 			},
 		)
 	}
 
-	return out
+	// out is guaranteed non-undefined here: allOrphanIds.length > 0 means at least one
+	// mutation occurred, which always initialises out before pushing to allOrphanIds.
+	return out!
 }
 
 /**