@roj-ai/sdk 0.1.14 → 0.1.16

package/src/core/llm/anthropic.ts

@@ -85,10 +85,15 @@ interface AnthropicErrorResponse {
 // Request body types
 // ============================================================================
 
+interface AnthropicCacheControl {
+	type: 'ephemeral'
+	ttl?: '5m' | '1h'
+}
+
 interface AnthropicTextBlockParam {
 	type: 'text'
 	text: string
-	cache_control?: { type: 'ephemeral' }
+	cache_control?: AnthropicCacheControl
 }
 
 interface AnthropicImageBlockParam {
@@ -96,7 +101,7 @@ interface AnthropicImageBlockParam {
 	source:
 		| { type: 'base64'; media_type: string; data: string }
 		| { type: 'url'; url: string }
-	cache_control?: { type: 'ephemeral' }
+	cache_control?: AnthropicCacheControl
 }
 
 interface AnthropicToolUseBlockParam {
@@ -104,7 +109,7 @@ interface AnthropicToolUseBlockParam {
 	id: string
 	name: string
 	input: unknown
-	cache_control?: { type: 'ephemeral' }
+	cache_control?: AnthropicCacheControl
 }
 
 interface AnthropicToolResultBlockParam {
@@ -112,7 +117,7 @@ interface AnthropicToolResultBlockParam {
 	tool_use_id: string
 	content: string | Array<AnthropicTextBlockParam | AnthropicImageBlockParam>
 	is_error?: boolean
-	cache_control?: { type: 'ephemeral' }
+	cache_control?: AnthropicCacheControl
 }
 
 type AnthropicContentBlockParam =
@@ -127,19 +132,19 @@ interface AnthropicMessageParam {
 }
 
 /**
- * Add `cache_control: { type: 'ephemeral' }` to the LAST content block of an
- * AnthropicMessageParam, regardless of block type. Converts string content to
- * a single text block first so the mark has a place to live. Mutates in place
- * so the cache breakpoint survives subsequent `mergeConsecutiveMessages`.
+ * Add `cache_control` to the LAST content block of an AnthropicMessageParam,
+ * regardless of block type. Converts string content to a single text block
+ * first so the mark has a place to live. Mutates in place so the cache
+ * breakpoint survives subsequent `mergeConsecutiveMessages`.
  */
-function applyCacheControlToLastBlock(msg: AnthropicMessageParam): void {
+function applyCacheControlToLastBlock(msg: AnthropicMessageParam, cacheControl: AnthropicCacheControl): void {
 	if (typeof msg.content === 'string') {
-		msg.content = [{ type: 'text', text: msg.content, cache_control: { type: 'ephemeral' } }]
+		msg.content = [{ type: 'text', text: msg.content, cache_control: cacheControl }]
 		return
 	}
 	if (msg.content.length === 0) return
 	const lastIdx = msg.content.length - 1
-	msg.content[lastIdx] = { ...msg.content[lastIdx], cache_control: { type: 'ephemeral' } }
+	msg.content[lastIdx] = { ...msg.content[lastIdx], cache_control: cacheControl }
 }
 
 interface AnthropicToolParam {
@@ -366,7 +371,9 @@ export class AnthropicProvider implements RoutableLLMProvider {
 	private async mapMessage(msg: LLMMessage, context?: InferenceContext): Promise<AnthropicMessageParam> {
 		const mapped = await this.mapMessageContent(msg, context)
 		if (msg.cacheControl) {
-			applyCacheControlToLastBlock(mapped)
+			const cc: AnthropicCacheControl = { type: 'ephemeral' }
+			if (msg.cacheControl.ttl) cc.ttl = msg.cacheControl.ttl
+			applyCacheControlToLastBlock(mapped, cc)
 		}
 		return mapped
 	}

package/src/core/llm/cache-breakpoints.ts

@@ -1,4 +1,4 @@
-import type { LLMMessage } from '~/core/agents/state.js'
+import type { LLMMessage, LLMMessageCacheControl } from '~/core/agents/state.js'
 
 /**
  * Mark the prompt cache breakpoint on a message list.
@@ -13,25 +13,34 @@ import type { LLMMessage } from '~/core/agents/state.js'
  * Target index is `messages.length - 1 - uncachedSuffixCount`. The suffix is
  * the tail of messages that must remain fresh (e.g. ephemeral session context
  * rebuilt each inference).
+ *
+ * `ttl` opts into Anthropic's 1-hour cache tier (write cost 2× input, read
+ * still 0.1×). Useful for long-lived agents where the default 5-minute TTL
+ * would expire between user turns. Omit for the default 5-minute tier.
  */
-export function applyCacheBreakpoint(messages: LLMMessage[], uncachedSuffixCount: number): LLMMessage[] {
+export function applyCacheBreakpoint(
+	messages: LLMMessage[],
+	uncachedSuffixCount: number,
+	ttl?: '5m' | '1h',
+): LLMMessage[] {
 	const idx = messages.length - 1 - uncachedSuffixCount
 	if (idx < 0) return messages
 
+	const cacheControl: LLMMessageCacheControl = ttl ? { type: 'ephemeral', ttl } : { type: 'ephemeral' }
 	const target = messages[idx]
 	const result = [...messages]
 	switch (target.role) {
 		case 'user':
-			result[idx] = { ...target, cacheControl: { type: 'ephemeral' } }
+			result[idx] = { ...target, cacheControl }
 			break
 		case 'assistant':
-			result[idx] = { ...target, cacheControl: { type: 'ephemeral' } }
+			result[idx] = { ...target, cacheControl }
 			break
 		case 'system':
-			result[idx] = { ...target, cacheControl: { type: 'ephemeral' } }
+			result[idx] = { ...target, cacheControl }
 			break
 		case 'tool':
-			result[idx] = { ...target, cacheControl: { type: 'ephemeral' } }
+			result[idx] = { ...target, cacheControl }
 			break
 	}
 	return result

package/src/core/sessions/session.test.ts

@@ -712,6 +712,8 @@ describe('applyEvent', () => {
 			expect(session.agents.get(agentId)!.pendingMessages).toHaveLength(2)
 			expect(session.agents.get(agentId)!.status).toBe('inferring')
 
+			const historyLenBeforeFailure = session.agents.get(agentId)!.conversationHistory.length
+
 			// 6. Inference fails
 			session = applyEvent(
 				session,
@@ -735,6 +737,10 @@ describe('applyEvent', () => {
 			expect(getAgentMailbox(selectMailboxState(session), agentId)[0].consumed).toBe(false)
 			// status is errored
 			expect(agent.status).toBe('errored')
+			// conversationHistory NOT extended — pendingMessages are dropped, not promoted.
+			// Otherwise tool results would appear both in history and in pendingToolResults,
+			// duplicating them on the next inference (Bedrock-style provider rejects 400).
+			expect(agent.conversationHistory).toHaveLength(historyLenBeforeFailure)
 		})
 	})
 

package/src/core/sessions/session.ts

@@ -494,6 +494,7 @@ export class Session {
 		}
 
 		const result = await methodDef.handler(ctx, parsed.data)
+
 		return result
 	}
 
@@ -795,6 +796,7 @@ export class Session {
 				checkIntervalMs: orch.checkIntervalMs,
 				input: orch.input,
 				plugins: withServicePluginConfig(orch),
+				cacheTtl: orch.cacheTtl,
 			}
 		}
 
@@ -810,6 +812,7 @@ export class Session {
 				checkIntervalMs: comm.checkIntervalMs,
 				input: comm.input,
 				plugins: withServicePluginConfig(comm),
+				cacheTtl: comm.cacheTtl,
 			}
 		}
 
@@ -828,6 +831,7 @@ export class Session {
 			checkIntervalMs: agentDef.checkIntervalMs,
 			input: agentDef.input,
 			plugins: withServicePluginConfig(agentDef),
+			cacheTtl: agentDef.cacheTtl,
 		}
 	}
 }

package/src/core/sessions/state.ts

@@ -207,15 +207,19 @@ export const coreReducer = createTypedReducer(
 						pendingToolCalls: toolCalls,
 						pendingMessages: [],
 						pendingToolResults: [],
+						lastInferenceMetrics: event.metrics,
 					}
 				})
 			}
 
 			case 'inference_failed':
+				// Failure is a clean rollback: pendingMessages are dropped (not promoted to history)
+				// and pendingToolResults / mailbox tokens stay intact so the next inference
+				// rebuilds the same turn. Runtime must skip markConsumed on failure to preserve
+				// mailbox tokens — see runInference().
 				return updateAgent(state, event.agentId, (agent) => ({
 					...agent,
 					status: 'errored',
-					conversationHistory: [...agent.conversationHistory, ...agent.pendingMessages],
 					pendingMessages: [],
 				}))
 

package/src/core/tools/executor.test.ts

@@ -51,6 +51,7 @@ const createTestContext = (): ToolContext => {
 		agentConfig: { systemPrompt: 'test', model: ModelId('test'), spawnableAgents: [] },
 		input: undefined,
 		parentId: null,
+		runAuxiliaryInference: async () => Err({ type: 'invalid_request', message: 'not implemented in test' }),
 	}
 }
 

package/src/plugins/agent-status/plugin.ts

@@ -38,40 +38,33 @@ export const agentStatusPlugin = definePlugin('agent-status')
 				sessionId: ctx.sessionId,
 				agentId: ctx.agentId,
 				status: 'thinking',
+				definitionName: ctx.agentState.definitionName,
 				timestamp: Date.now(),
 			})
 		}
 		return null
 	})
 	.hook('onComplete', async (ctx) => {
-		if (ctx.parentId !== null) {
-			ctx.notify('agentStatus', {
-				sessionId: ctx.sessionId,
-				agentId: ctx.agentId,
-				status: 'idle',
-				definitionName: ctx.agentState.definitionName,
-				timestamp: Date.now(),
-			})
-		} else {
-			ctx.notify('agentStatus', {
-				sessionId: ctx.sessionId,
-				agentId: ctx.agentId,
-				status: 'idle',
-				timestamp: Date.now(),
-			})
-		}
+		ctx.notify('agentStatus', {
+			sessionId: ctx.sessionId,
+			agentId: ctx.agentId,
+			status: 'idle',
+			definitionName: ctx.agentState.definitionName,
+			timestamp: Date.now(),
+		})
 		return null
 	})
 	.hook('onError', async (ctx) => {
-		if (ctx.parentId !== null) {
-			ctx.notify('agentStatus', {
-				sessionId: ctx.sessionId,
-				agentId: ctx.agentId,
-				status: 'idle',
-				definitionName: ctx.agentState.definitionName,
-				timestamp: Date.now(),
-			})
-		}
+		// Emit idle for both entry and sub-agents — without this the client's
+		// `activeAgents` map keeps the agent flagged thinking until reconnect,
+		// since the session-store no longer clears it on chat_message/ask_user.
+		ctx.notify('agentStatus', {
+			sessionId: ctx.sessionId,
+			agentId: ctx.agentId,
+			status: 'idle',
+			definitionName: ctx.agentState.definitionName,
+			timestamp: Date.now(),
+		})
 		return null
 	})
 	.build()

package/src/plugins/context-compact/compaction-live.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Live compaction tests against the real Anthropic API.
+ *
+ * Opt-in: run with `LIVE_TESTS=1 ANTHROPIC_API_KEY=…`. Skipped otherwise so the
+ * default `bun test` run stays hermetic.
+ *
+ * These cover the two real-API claims of the context-compact rewrite (5c27ab7):
+ *  1. The auxiliary-inference call (used by `ContextCompactor`) reuses the
+ *     agent's warm prompt cache — only the trailing instruction + output are
+ *     paid for, not the whole conversation a second time.
+ *  2. `DEFAULT_SUMMARY_INSTRUCTION` actually elicits a plain-text summary from
+ *     a real Sonnet/Haiku-class model (no tool calls, non-empty content), so
+ *     the end-to-end `ContextCompactor.compact()` path produces a usable
+ *     `[CONVERSATION SUMMARY]` block.
+ */
+
+import { describe, expect, test } from 'bun:test'
+import { generateTestAgentId } from '~/core/agents/schema.js'
+import type { ImageProcessor } from '~/core/image/types.js'
+import type { LLMMessage } from '~/core/agents/state.js'
+import { AnthropicProvider } from '~/core/llm/anthropic.js'
+import { applyCacheBreakpoint } from '~/core/llm/cache-breakpoints.js'
+import type { InferenceResponse, LLMError } from '~/core/llm/provider.js'
+import { ModelId } from '~/core/llm/schema.js'
+import { generateSessionId } from '~/core/sessions/schema.js'
+import { silentLogger } from '~/lib/logger/logger.js'
+import type { Result } from '~/lib/utils/result.js'
+import {
+	ContextCompactor,
+	DEFAULT_SUMMARY_INSTRUCTION,
+	type RunInferenceFn,
+} from './context-compactor.js'
+
+const liveEnabled = process.env.LIVE_TESTS === '1'
+const anthropicApiKey = liveEnabled ? process.env.ANTHROPIC_API_KEY : undefined
+
+const describeLive = (name: string, apiKey: string | undefined, fn: () => void) => {
+	if (!apiKey) {
+		describe.skip(`${name} (skipped — API key missing)`, fn)
+		return
+	}
+	describe(name, fn)
+}
+
+const noopImageProcessor: ImageProcessor = {
+	resolveContent: async (content) => content,
+}
+
+const MODEL = ModelId('claude-haiku-4-5-20251001')
+
+/**
+ * Padded system prompt so the cacheable prefix comfortably exceeds Anthropic's
+ * 1024-token minimum for Haiku. Deterministic content so identical calls reuse
+ * the exact same prefix.
+ */
+const LARGE_SYSTEM_PROMPT = [
+	'You are a meticulous assistant helping a developer review a long conversation.',
+	'Always respond concisely and accurately. Never speculate beyond the data.',
+	'Follow these rules strictly:',
+	...Array.from(
+		{ length: 120 },
+		(_, i) => `- Rule ${i + 1}: When asked about topic ${i + 1}, prefer factual sources and decline to speculate.`,
+	),
+	'End of instructions.',
+].join('\n')
+
+/**
+ * Deterministic multi-turn history padded well past 1024 tokens so cache writes
+ * and reads are unambiguous. Includes both user and assistant messages, which
+ * is the shape an inline-compaction call sees in practice.
+ */
+function buildLongHistory(): LLMMessage[] {
+	const history: LLMMessage[] = []
+	for (let i = 0; i < 8; i++) {
+		history.push({
+			role: 'user',
+			content:
+				`Turn ${i + 1} user: please analyze topic ${i + 1}. `
+				+ 'context detail '.repeat(30),
+		})
+		history.push({
+			role: 'assistant',
+			content:
+				`Turn ${i + 1} assistant: here is my analysis of topic ${i + 1}. `
+				+ 'analysis detail '.repeat(30),
+		})
+	}
+	return history
+}
+
+describeLive('context-compact live: auxiliary inference cache reuse', anthropicApiKey, () => {
+	test('priming inference then auxiliary summary call hits the prompt cache', async () => {
+		const provider = new AnthropicProvider({
+			apiKey: anthropicApiKey!,
+			imageProcessor: noopImageProcessor,
+			defaultModel: 'claude-haiku-4-5-20251001',
+		})
+
+		const history = buildLongHistory()
+
+		// Call 1: regular inference, breakpoint on the last history message.
+		// Mirrors what an Agent.advance() turn does just before requesting a
+		// compaction summary.
+		const primeMessages = applyCacheBreakpoint(history, 0, '1h')
+		const prime = await provider.inference({
+			model: MODEL,
+			systemPrompt: LARGE_SYSTEM_PROMPT,
+			messages: primeMessages,
+		})
+		if (!prime.ok) {
+			if (prime.error.message?.includes('credit balance')) {
+				console.warn('⚠️  Live compaction cache test skipped: credit balance too low')
+				return
+			}
+			throw new Error(`prime call failed: ${JSON.stringify(prime.error)}`)
+		}
+		expect(prime.value.metrics.promptTokens).toBeGreaterThan(1024)
+
+		// Call 2: simulate Agent.runAuxiliaryInference — append the summary
+		// instruction as a trailing user message and place the breakpoint at
+		// the same position as the prime call (last history message), so the
+		// whole prefix lands as a cache read.
+		const summaryInstruction: LLMMessage = { role: 'user', content: DEFAULT_SUMMARY_INSTRUCTION }
+		const auxMessages = applyCacheBreakpoint([...history, summaryInstruction], 1, '1h')
+		const aux = await provider.inference({
+			model: MODEL,
+			systemPrompt: LARGE_SYSTEM_PROMPT,
+			messages: auxMessages,
+		})
+		if (!aux.ok) throw new Error(`auxiliary call failed: ${JSON.stringify(aux.error)}`)
+
+		// Core claim: the auxiliary call served the prefix from cache (otherwise
+		// we'd re-upload the entire conversation just to get a summary).
+		expect(aux.value.metrics.cachedTokens ?? 0).toBeGreaterThan(1024)
+
+		// Sonnet/Haiku reliably emit plain text under DEFAULT_SUMMARY_INSTRUCTION.
+		// If this regresses, the prompt is no longer fit for purpose.
+		expect(aux.value.toolCalls).toHaveLength(0)
+		expect(aux.value.finishReason).toBe('stop')
+		expect(aux.value.content ?? '').not.toBe('')
+	}, 60_000)
+})
+
+describeLive('context-compact live: end-to-end compactor', anthropicApiKey, () => {
+	test('ContextCompactor.compact() produces a real summary from a real model', async () => {
+		const provider = new AnthropicProvider({
+			apiKey: anthropicApiKey!,
+			imageProcessor: noopImageProcessor,
+			defaultModel: 'claude-haiku-4-5-20251001',
+		})
+
+		const history = buildLongHistory()
+
+		// Wraps the provider exactly the way AgentContext.runAuxiliaryInference
+		// does: full prefix + extraMessages, breakpoint pinned to the last
+		// pre-extraMessages position so the agent's cache is reused.
+		const auxCalls: InferenceResponse[] = []
+		const runInference: RunInferenceFn = async (
+			extraMessages,
+		): Promise<Result<InferenceResponse, LLMError>> => {
+			const messages = applyCacheBreakpoint(
+				[...history, ...extraMessages],
+				extraMessages.length,
+				'1h',
+			)
+			const result = await provider.inference({
+				model: MODEL,
+				systemPrompt: LARGE_SYSTEM_PROMPT,
+				messages,
+			})
+			if (result.ok) auxCalls.push(result.value)
+			return result
+		}
+
+		// Prime the cache with one regular inference first, otherwise the
+		// auxiliary call would pay full write cost — same as a real session
+		// where compaction always runs after at least one normal turn.
+		const prime = await provider.inference({
+			model: MODEL,
+			systemPrompt: LARGE_SYSTEM_PROMPT,
+			messages: applyCacheBreakpoint(history, 0, '1h'),
+		})
+		if (!prime.ok) {
+			if (prime.error.message?.includes('credit balance')) {
+				console.warn('⚠️  Live compaction end-to-end test skipped: credit balance too low')
+				return
+			}
+			throw new Error(`prime call failed: ${JSON.stringify(prime.error)}`)
+		}
+
+		const compactor = new ContextCompactor(silentLogger, {
+			// Force compaction regardless of estimator vs actual tokens.
+			maxTokens: 10,
+			keepRecentMessages: 2,
+		})
+
+		const result = await compactor.compact(
+			generateSessionId(),
+			generateTestAgentId(),
+			history,
+			runInference,
+		)
+
+		expect(result.ok).toBe(true)
+		if (!result.ok) return
+
+		expect(result.value.messagesRemoved).toBeGreaterThan(0)
+		expect(result.value.summary.trim().length).toBeGreaterThan(0)
+		// keepRecentMessages=2 → summary message + 2 kept = 3 total
+		expect(result.value.compactedMessages).toHaveLength(3)
+		expect(result.value.compactedMessages[0].role).toBe('user')
+		expect(result.value.compactedMessages[0].content as string).toContain(
+			'[CONVERSATION SUMMARY]',
+		)
+
+		// The auxiliary inference under the compactor should have served the
+		// prefix from cache (priming call wrote it).
+		expect(auxCalls).toHaveLength(1)
+		expect(auxCalls[0].metrics.cachedTokens ?? 0).toBeGreaterThan(1024)
+	}, 60_000)
+})

package/src/plugins/context-compact/context-compact.integration.test.ts

@@ -1,10 +1,27 @@
 import { describe, expect, it } from 'bun:test'
+import z from 'zod/v4'
 import { contextEvents } from '~/core/context/state.js'
 import { MockLLMProvider } from '~/core/llm/mock.js'
+import type { InferenceRequest } from '~/core/llm/provider.js'
 import { ModelId } from '~/core/llm/schema.js'
+import type { Preset } from '~/core/preset/index.js'
+import { createTool } from '~/core/tools/definition.js'
+import { ToolCallId } from '~/core/tools/schema.js'
 import { createTestPreset, TestHarness } from '~/testing/index.js'
 import { contextCompactPlugin } from './index.js'
 
+/**
+ * Inline compaction sends the agent's regular systemPrompt and full conversation
+ * to the LLM, with a trailing user message containing the summarization
+ * instruction. We detect compaction calls by looking at that trailing message.
+ */
+function isSummarizationRequest(request: InferenceRequest): boolean {
+	const last = request.messages[request.messages.length - 1]
+	if (!last || last.role !== 'user') return false
+	const content = typeof last.content === 'string' ? last.content : JSON.stringify(last.content)
+	return content.includes('[CONTEXT COMPACTION REQUEST]')
+}
+
 // ============================================================================
 // Helpers
 // ============================================================================
@@ -50,7 +67,7 @@ describe('context-compact plugin', () => {
 				presets: [createCompactPreset(10)],
 				mockHandler: (request) => {
 					// Compaction requests use CONTEXT_SUMMARY_PROMPT which contains "summarizer".
-					if (request.systemPrompt.includes('summary') || request.systemPrompt.includes('Summarize')) {
+					if (isSummarizationRequest(request)) {
 						return {
 							content: 'Summary of conversation so far.',
 							toolCalls: [],
@@ -119,7 +136,7 @@ describe('context-compact plugin', () => {
 					inferenceCallCount++
 
 					// Summarization requests (from context-compact plugin)
-					if (request.systemPrompt.includes('summary') || request.systemPrompt.includes('Summarize')) {
+					if (isSummarizationRequest(request)) {
 						return {
 							content: 'Conversation summary.',
 							toolCalls: [],
@@ -157,6 +174,121 @@ describe('context-compact plugin', () => {
 		})
 	})
 
+	// =========================================================================
+	// Pending tool results regression
+	// =========================================================================
+
+	describe('pending tool results', () => {
+		it('aux inference after a tool turn includes the tool_result before the summary instruction', async () => {
+			// Regression for the bug where context-compact's auxiliary inference call
+			// runs at a moment where `conversationHistory` ends with an assistant
+			// `tool_use` block but the corresponding tool_result is still in
+			// `pendingToolResults` (not yet committed to history). Sending
+			// `[..., assistant(tool_use), user(summary)]` to Anthropic 400s with
+			// "tool_use blocks must be followed by tool_result blocks".
+
+			const myTool = createTool({
+				name: 'my_tool',
+				description: 'returns a fixed value',
+				input: z.object({}),
+				execute: async () => ({ ok: true, value: 'tool result content' }),
+			})
+
+			const preset: Preset = {
+				id: 'test',
+				name: 'Tool Compaction Test',
+				orchestrator: {
+					system: 'You are a test agent.',
+					model: ModelId('mock'),
+					tools: [myTool],
+					agents: [],
+					debounceMs: 0,
+				},
+				agents: [],
+				plugins: [
+					contextCompactPlugin.configure({
+						compaction: {
+							model: ModelId('mock'),
+							maxTokens: 10,
+							// 1 so that after the tool turn, [user, assistant(tool_use)]
+							// splits into toCompact=[user], toKeep=[assistant(tool_use)] —
+							// the aux call actually runs and gets the buggy prefix.
+							keepRecentMessages: 1,
+						},
+					}),
+				],
+			}
+
+			let capturedAuxRequest: InferenceRequest | undefined
+
+			const harness = new TestHarness({
+				systemPlugins: [contextCompactPlugin],
+				presets: [preset],
+				mockHandler: (request) => {
+					if (isSummarizationRequest(request)) {
+						capturedAuxRequest = request
+						return {
+							content: 'Summary of conversation.',
+							toolCalls: [],
+							finishReason: 'stop',
+							metrics: MockLLMProvider.defaultMetrics(),
+						}
+					}
+					// First inference (no tool messages in history yet) → emit a tool call.
+					const hasToolMessages = request.messages.some((m) => m.role === 'tool')
+					if (!hasToolMessages) {
+						return {
+							content: '',
+							toolCalls: [{ id: ToolCallId('tc1'), name: 'my_tool', input: {} }],
+							finishReason: 'tool_calls',
+							metrics: MockLLMProvider.defaultMetrics(),
+						}
+					}
+					return {
+						content: 'Done.',
+						toolCalls: [],
+						finishReason: 'stop',
+						metrics: MockLLMProvider.defaultMetrics(),
+					}
+				},
+			})
+
+			const session = await harness.createSession('test')
+			await session.sendAndWaitForIdle('Please call my_tool')
+
+			expect(capturedAuxRequest).toBeDefined()
+
+			// Every assistant message with toolCalls must be followed by a contiguous
+			// run of tool messages covering each tool_use id before any further
+			// user/assistant message. This mirrors Anthropic's API contract.
+			const msgs = capturedAuxRequest!.messages
+			for (let i = 0; i < msgs.length; i++) {
+				const m = msgs[i]
+				if (m.role !== 'assistant' || !m.toolCalls?.length) continue
+
+				const expected = new Set(m.toolCalls.map((tc) => tc.id))
+				const seen = new Set<string>()
+				for (let j = i + 1; j < msgs.length; j++) {
+					const next = msgs[j]
+					if (next.role !== 'tool') break
+					seen.add(next.toolCallId)
+				}
+				for (const id of expected) {
+					expect(seen.has(id)).toBe(true)
+				}
+			}
+
+			// Compaction must have actually succeeded — pre-fix it would Err-out
+			// in production (mock accepts it but the assertion above already
+			// catches the malformed-prefix case).
+			const compactedEvents = await session.getEventsByType(contextEvents, 'context_compacted')
+			const actualCompactions = compactedEvents.filter((e) => e.messagesRemoved > 0)
+			expect(actualCompactions.length).toBeGreaterThanOrEqual(1)
+
+			await harness.shutdown()
+		})
+	})
+
 	// =========================================================================
 	// Compaction failure
 	// =========================================================================
@@ -170,7 +302,7 @@ describe('context-compact plugin', () => {
 				mockHandler: (request) => {
 					// Summarization requests — throw to simulate LLM failure.
 					// MockLLMProvider only returns Err() when the handler throws.
-					if (request.systemPrompt.includes('summary') || request.systemPrompt.includes('Summarize')) {
+					if (isSummarizationRequest(request)) {
 						throw { type: 'server_error', message: 'LLM summarization failed' }
 					}