@roj-ai/sdk 0.1.29 → 0.1.30

package/src/core/llm/middleware.ts

@@ -109,11 +109,11 @@ export function useProvider(name: string): LLMMiddleware {
  *
  * @example
  * ```ts
- * // Exclude Google providers:
- * llmMiddleware: [withOpenRouter({ providers: { deny: ['Google'] } })]
+ * // Exclude Amazon Bedrock while retaining provider fallbacks:
+ * llmMiddleware: [withOpenRouter({ providers: { ignore: ['amazon-bedrock'], allow_fallbacks: true } })]
  *
  * // Prefer specific providers:
- * llmMiddleware: [withOpenRouter({ providers: { order: ['Anthropic', 'AWS Bedrock'] } })]
+ * llmMiddleware: [withOpenRouter({ providers: { order: ['anthropic', 'google-vertex'] } })]
  * ```
  */
 export function withOpenRouter(opts: OpenRouterRequestOptions): LLMMiddleware {

package/src/core/llm/openrouter-mapping.test.ts

@@ -47,7 +47,26 @@ const asBlocks = (content: string | AnyBlock[]): AnyBlock[] => {
 	return content
 }
 
-describe('OpenRouterProvider buildHttpRequest cache placement', () => {
+describe('OpenRouterProvider buildHttpRequest', () => {
+	test('includes inline provider routing preferences', async () => {
+		const request = buildRequest([{ role: 'user', content: 'Hello' }])
+		request.openrouter = {
+			providers: {
+				ignore: ['amazon-bedrock'],
+				allow_fallbacks: true,
+			},
+		}
+
+		const http = await createProvider().buildHttpRequest(request)
+
+		expect(http.body).toEqual(expect.objectContaining({
+			provider: {
+				ignore: ['amazon-bedrock'],
+				allow_fallbacks: true,
+			},
+		}))
+	})
+
 	test('pure tool_result target: cache_control lands on the tool role message content', async () => {
 		const messages = applyCacheBreakpoint([
 			{ role: 'user', content: 'What is the weather?' },
@@ -87,12 +106,14 @@ describe('OpenRouterProvider buildHttpRequest cache placement', () => {
 					{ id: ToolCallId('call_2'), name: 'search', input: { query: 'weather' } },
 				],
 			},
-		], 0)
+			{ role: 'tool', toolCallId: ToolCallId('call_1'), content: 'Sunny' },
+			{ role: 'tool', toolCallId: ToolCallId('call_2'), content: 'Found results' },
+		], 2)
 
 		const http = await createProvider().buildHttpRequest(buildRequest(messages))
 		const msgs = getBodyMessages(http.body)
 
-		const assistant = msgs[msgs.length - 1]
+		const assistant = msgs[msgs.length - 3]
 		expect(assistant.role).toBe('assistant')
 		expect(assistant.tool_calls).toBeDefined()
 		// String content got wrapped so cache_control has a place to live

package/src/core/llm/openrouter.ts

@@ -13,9 +13,11 @@ import type {
 	LLMMessage,
 	LLMMetrics,
 	LLMProvider,
+	OpenRouterProviderRouting,
 	ProviderHttpRequest,
 	RawInferenceRequest,
 } from './provider.js'
+import { ProviderMessageValidationError, sanitizeProviderMessages } from './message-sanitization.js'
 
 // ============================================================================
 // Configuration
@@ -125,13 +127,6 @@ interface OpenRouterToolDefinition {
 	}
 }
 
-interface OpenRouterProviderRouting {
-	order?: string[]
-	allow?: string[]
-	deny?: string[]
-	quantizations?: string[]
-}
-
 interface OpenRouterRequestBody {
 	model: string
 	messages: OpenRouterMessage[]
@@ -263,7 +258,8 @@ export class OpenRouterProvider implements LLMProvider {
 	}
 
 	async buildHttpRequest(request: RawInferenceRequest, context?: InferenceContext): Promise<ProviderHttpRequest> {
-		const mappedMessages = await Promise.all(request.messages.map((m) => this.mapMessage(m, context)))
+		const sanitizedMessages = sanitizeProviderMessages(request.messages, this.name, this.logger)
+		const mappedMessages = await Promise.all(sanitizedMessages.map((m) => this.mapMessage(m, context)))
 
 		const messages: OpenRouterMessage[] = [
 			{ role: 'system', content: [{ type: 'text', text: request.systemPrompt, cache_control: { type: 'ephemeral' } }] },
@@ -447,6 +443,9 @@ export class OpenRouterProvider implements LLMProvider {
 	}
 
 	private mapError(err: unknown): LLMError {
+		if (err instanceof ProviderMessageValidationError) {
+			return { type: 'invalid_request', message: err.message }
+		}
 		if (err instanceof Error && err.name === 'AbortError') {
 			return { type: 'aborted', message: 'Request was aborted' }
 		}

package/src/core/llm/provider.ts

@@ -28,18 +28,22 @@ export interface RawToolSpec {
  *
  * @see https://openrouter.ai/docs/api-reference/overview
  */
+export interface OpenRouterProviderRouting {
+	/** Preferred provider ordering */
+	order?: string[]
+	/** Only allow these providers */
+	only?: string[]
+	/** Exclude these providers */
+	ignore?: string[]
+	/** Whether to allow backup providers */
+	allow_fallbacks?: boolean
+	/** Allowed quantizations (e.g. "bf16", "int8") */
+	quantizations?: string[]
+}
+
 export interface OpenRouterRequestOptions {
 	/** Provider routing preferences */
-	providers?: {
-		/** Preferred provider ordering */
-		order?: string[]
-		/** Only allow these providers */
-		allow?: string[]
-		/** Exclude these providers */
-		deny?: string[]
-		/** Allowed quantizations (e.g. "bf16", "int8") */
-		quantizations?: string[]
-	}
+	providers?: OpenRouterProviderRouting
 	/** Routing strategy */
 	route?: 'fallback'
 	/** Model transforms */

package/src/core/llm/state.ts

@@ -97,6 +97,15 @@ export const llmEvents = createEventsFactory({
 			error: z4.string(),
 			llmCallId: llmCallIdSchema.optional(),
 		}),
+		/**
+		 * A plugin's afterInference hook requested a retry of the turn. Rolls back
+		 * the staged turn (pendingMessages from inference_started) so the retried
+		 * inference can restage the same messages without double-appending; dequeue
+		 * tokens stay unconsumed until the turn actually commits.
+		 */
+		inference_retried: z4.object({
+			agentId: agentIdSchema,
+		}),
 	},
 })
 
@@ -104,3 +113,4 @@ export type InferenceStartedEvent = (typeof llmEvents)['Events']['inference_star
 export type InferenceCompletedEvent = (typeof llmEvents)['Events']['inference_completed']
 export type AuxiliaryInferenceCompletedEvent = (typeof llmEvents)['Events']['auxiliary_inference_completed']
 export type InferenceFailedEvent = (typeof llmEvents)['Events']['inference_failed']
+export type InferenceRetriedEvent = (typeof llmEvents)['Events']['inference_retried']

package/src/core/plugins/plugin-builder.ts

@@ -228,7 +228,9 @@ type PluginSelf<TMethods extends Record<string, MethodEntry>> = {
 type HookMap<TCtx> = {
 	onStart: (ctx: TCtx) => Promise<OnStartResult>
 	beforeInference: (ctx: TCtx & { pendingMessages: MailboxMessage[]; turnNumber: number }) => Promise<BeforeInferenceResult>
-	afterInference: (ctx: TCtx & { response: LLMResponse; turnNumber: number }) => Promise<AfterInferenceResult>
+	afterInference: (
+		ctx: TCtx & { response: LLMResponse; turnNumber: number; dequeuedSourcePlugins: readonly string[] },
+	) => Promise<AfterInferenceResult>
 	beforeToolCall: (ctx: TCtx & { toolCall: ToolCall }) => Promise<BeforeToolCallResult>
 	afterToolCall: (ctx: TCtx & { toolCall: ToolCall; result: { isError: boolean; content: ToolResultContent } }) => Promise<AfterToolCallResult>
 	onComplete: (ctx: TCtx) => Promise<OnCompleteResult>
@@ -298,7 +300,9 @@ export type BaseMethodHandlerContext = SessionContext & {
 type ErasedAgentHookMap = {
 	onStart: (ctx: BasePluginHookContext) => Promise<OnStartResult>
 	beforeInference: (ctx: BasePluginHookContext & { pendingMessages: MailboxMessage[]; turnNumber: number }) => Promise<BeforeInferenceResult>
-	afterInference: (ctx: BasePluginHookContext & { response: LLMResponse; turnNumber: number }) => Promise<AfterInferenceResult>
+	afterInference: (
+		ctx: BasePluginHookContext & { response: LLMResponse; turnNumber: number; dequeuedSourcePlugins: readonly string[] },
+	) => Promise<AfterInferenceResult>
 	beforeToolCall: (ctx: BasePluginHookContext & { toolCall: ToolCall }) => Promise<BeforeToolCallResult>
 	afterToolCall: (
 		ctx: BasePluginHookContext & { toolCall: ToolCall; result: { isError: boolean; content: ToolResultContent } },

package/src/core/sessions/session.ts

@@ -234,6 +234,9 @@ export class Session {
 	 * Schedule agent processing (with debounce).
 	 */
 	scheduleAgent(agentId: AgentId): void {
+		const agentState = this.store.getAgentState(agentId)
+		if (!agentState || agentState.status === 'paused') return
+
 		const agent = this.agents.get(agentId)
 		if (agent) {
 			agent.scheduleProcessing()
@@ -826,6 +829,7 @@ export class Session {
 				input: orch.input,
 				plugins: withServicePluginConfig(orch),
 				cacheTtl: orch.cacheTtl,
+				errorResumeBackoff: orch.errorResumeBackoff,
 			}
 		}
 
@@ -842,6 +846,7 @@ export class Session {
 				input: comm.input,
 				plugins: withServicePluginConfig(comm),
 				cacheTtl: comm.cacheTtl,
+				errorResumeBackoff: comm.errorResumeBackoff,
 			}
 		}
 
@@ -861,6 +866,7 @@ export class Session {
 			input: agentDef.input,
 			plugins: withServicePluginConfig(agentDef),
 			cacheTtl: agentDef.cacheTtl,
+			errorResumeBackoff: agentDef.errorResumeBackoff,
 		}
 	}
 }

package/src/core/sessions/state.ts

@@ -202,12 +202,16 @@ export const coreReducer = createTypedReducer(
 
 					return {
 						...agent,
-						status: hasToolCalls ? 'tool_exec' : 'pending',
+						// Preserve a pause that landed during the in-flight inference — the pause
+						// defers (tool calls stay pending until resume) instead of being clobbered.
+						status: agent.status === 'paused' ? 'paused' : hasToolCalls ? 'tool_exec' : 'pending',
 						conversationHistory: [...agent.conversationHistory, ...agent.pendingMessages, assistantMessage],
 						pendingToolCalls: toolCalls,
 						pendingMessages: [],
 						pendingToolResults: [],
 						lastInferenceMetrics: event.metrics,
+						consecutiveInferenceFailures: 0,
+						lastInferenceFailureAt: undefined,
 					}
 				})
 			}
@@ -221,6 +225,19 @@ export const coreReducer = createTypedReducer(
 					...agent,
 					status: 'errored',
 					pendingMessages: [],
+					consecutiveInferenceFailures: (agent.consecutiveInferenceFailures ?? 0) + 1,
+					lastInferenceFailureAt: event.timestamp,
+				}))
+
+			case 'inference_retried':
+				// Plugin-requested retry: roll back the staged turn (like inference_failed)
+				// so the retried inference_started doesn't double-append pendingMessages.
+				// Dequeue tokens are still unconsumed (consumption happens at commit), so
+				// the retry re-collects the same messages.
+				return updateAgent(state, event.agentId, (agent) => ({
+					...agent,
+					status: agent.status === 'paused' ? 'paused' : 'pending',
+					pendingMessages: [],
 				}))
 
 			case 'tool_completed': {
@@ -242,7 +259,9 @@ export const coreReducer = createTypedReducer(
 						...agent,
 						pendingToolCalls: remaining,
 						pendingToolResults: [...agent.pendingToolResults, pendingToolResult],
-						status: remaining.length === 0 ? 'pending' : 'tool_exec',
+						// Preserve a pause raised by a tool hook — recomputing the status here
+						// would silently un-pause the agent mid-turn.
+						status: agent.status === 'paused' ? 'paused' : remaining.length === 0 ? 'pending' : 'tool_exec',
 						executingToolCall: undefined,
 					}
 				})
@@ -267,7 +286,7 @@ export const coreReducer = createTypedReducer(
 						...agent,
 						pendingToolCalls: remaining,
 						pendingToolResults: [...agent.pendingToolResults, pendingToolResult],
-						status: remaining.length === 0 ? 'pending' : 'tool_exec',
+						status: agent.status === 'paused' ? 'paused' : remaining.length === 0 ? 'pending' : 'tool_exec',
 						executingToolCall: undefined,
 					}
 				})
@@ -276,23 +295,37 @@ export const coreReducer = createTypedReducer(
 			case 'context_compacted':
 				return updateAgent(state, event.agentId, (agent) => ({
 					...agent,
-					conversationHistory: event.newConversationHistory.map((m) => {
+					conversationHistory: event.newConversationHistory.map((m): LLMMessage => {
 						switch (m.role) {
 							case 'user':
 								return {
-									role: 'user' as const,
+									role: 'user',
 									content: m.content,
-									sourceMessageIds: [],
+									sourceMessageIds: m.sourceMessageIds ?? [],
+									cacheControl: m.cacheControl,
 								}
 							case 'assistant':
 								return {
-									role: 'assistant' as const,
+									role: 'assistant',
+									content: m.content,
+									toolCalls: m.toolCalls,
+									cacheControl: m.cacheControl,
+								}
+							case 'tool':
+								return {
+									role: 'tool',
 									content: m.content,
+									toolCallId: m.toolCallId,
+									toolName: m.toolName,
+									isError: m.isError,
+									timestamp: m.timestamp,
+									cacheControl: m.cacheControl,
 								}
 							case 'system':
 								return {
-									role: 'system' as const,
+									role: 'system',
 									content: m.content,
+									cacheControl: m.cacheControl,
 								}
 						}
 					}),
@@ -320,6 +353,10 @@ export const coreReducer = createTypedReducer(
 							...updated,
 							status: 'pending' as const,
 							pendingMessages: [],
+							// Restart is an explicit external trigger — start a fresh error episode
+							// so the outer error-resume backoff doesn't delay the first attempt.
+							consecutiveInferenceFailures: 0,
+							lastInferenceFailureAt: undefined,
 						}
 						changed = true
 					}
@@ -403,7 +440,9 @@ export const coreReducer = createTypedReducer(
 			case 'agent_resumed':
 				return updateAgent(state, event.agentId, (agent) => ({
 					...agent,
-					status: 'pending',
+					// Resume into tool_exec when the pause interrupted a tool turn — going to
+					// 'pending' would run inference with unresolved tool calls (unpaired tool_use).
+					status: agent.pendingToolCalls.length > 0 ? 'tool_exec' : 'pending',
 					pauseReason: undefined,
 					pauseMessage: undefined,
 				}))

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

@@ -3,7 +3,7 @@ import z from 'zod/v4'
 import { contextEvents } from '~/core/context/state.js'
 import { llmEvents } from '~/core/llm/state.js'
 import { MockLLMProvider } from '~/core/llm/mock.js'
-import type { InferenceRequest } from '~/core/llm/provider.js'
+import type { InferenceRequest, LLMMessage } 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'
@@ -48,6 +48,33 @@ function createCompactHarness(options: Omit<ConstructorParameters<typeof TestHar
 	return new TestHarness({ ...options, systemPlugins: [contextCompactPlugin] })
 }
 
+function expectToolPairing(messages: LLMMessage[]): void {
+	const declaredToolCallIds = new Set<string>()
+
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i]
+		if (message.role === 'assistant' && message.toolCalls?.length) {
+			const expected = new Set(message.toolCalls.map((toolCall) => toolCall.id))
+			const seen = new Set<string>()
+			for (const toolCall of message.toolCalls) {
+				declaredToolCallIds.add(toolCall.id)
+			}
+			for (let j = i + 1; j < messages.length; j++) {
+				const next = messages[j]
+				if (next.role !== 'tool') break
+				seen.add(next.toolCallId)
+			}
+			for (const id of expected) {
+				expect(seen.has(id)).toBe(true)
+			}
+		}
+
+		if (message.role === 'tool') {
+			expect(declaredToolCallIds.has(message.toolCallId)).toBe(true)
+		}
+	}
+}
+
 // ============================================================================
 // Tests
 // ============================================================================
@@ -222,6 +249,7 @@ describe('context-compact plugin', () => {
 			}
 
 			let capturedAuxRequest: InferenceRequest | undefined
+			let capturedToolResultRequest: InferenceRequest | undefined
 
 			const harness = new TestHarness({
 				systemPlugins: [contextCompactPlugin],
@@ -246,6 +274,7 @@ describe('context-compact plugin', () => {
 							metrics: MockLLMProvider.defaultMetrics(),
 						}
 					}
+					capturedToolResultRequest = request
 					return {
 						content: 'Done.',
 						toolCalls: [],
@@ -259,26 +288,14 @@ describe('context-compact plugin', () => {
 			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)
-				}
-			}
+			if (!capturedAuxRequest) return
+			expectToolPairing(capturedAuxRequest.messages)
+
+			// The event reducer runs before pending tool results are appended to the
+			// regular inference request. Pairing must survive that reconstruction.
+			expect(capturedToolResultRequest).toBeDefined()
+			if (!capturedToolResultRequest) return
+			expectToolPairing(capturedToolResultRequest.messages)
 
 			// Compaction must have actually succeeded — pre-fix it would Err-out
 			// in production (mock accepts it but the assertion above already

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

@@ -1,10 +1,15 @@
 import { beforeEach, describe, expect, it } from 'bun:test'
+import { agentEvents } from '~/core/agents/state.js'
 import type { AgentId } from '~/core/agents/schema.js'
 import { generateTestAgentId } from '~/core/agents/schema.js'
+import { contextCompactedEventSchema, contextEvents } from '~/core/context/state.js'
+import { withSessionId } from '~/core/events/test-helpers.js'
 import type { InferenceResponse, LLMMessage } from '~/core/llm/provider.js'
 import { ModelId } from '~/core/llm/schema.js'
+import { estimateMessagesTokens } from '~/core/llm/tokens.js'
 import type { SessionId } from '~/core/sessions/schema.js'
 import { generateSessionId } from '~/core/sessions/schema.js'
+import { coreReducer, createSessionState } from '~/core/sessions/state.js'
 import { generateToolCallId } from '~/core/tools/schema.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import { silentLogger } from '../../lib/logger/logger.js'
@@ -315,12 +320,26 @@ describe('createContextCompactedEvent', () => {
 		expect(event.timestamp).toBeDefined()
 	})
 
-	it('converts tool role to system in history', () => {
+	it('preserves assistant tool calls and tool results in history', () => {
 		const sessionId = generateSessionId()
 		const agentId = generateTestAgentId()
 		const toolCallId = generateToolCallId()
 		const result: CompactionResult = {
-			compactedMessages: [{ role: 'tool', content: 'tool result', toolCallId }],
+			compactedMessages: [
+				{
+					role: 'assistant',
+					content: 'Checking.',
+					toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
+				},
+				{
+					role: 'tool',
+					content: 'tool result',
+					toolCallId,
+					toolName: 'read',
+					isError: false,
+					timestamp: 123,
+				},
+			],
 			originalMessages: [],
 			summary: '',
 			originalTokens: 100,
@@ -330,8 +349,44 @@ describe('createContextCompactedEvent', () => {
 
 		const event = createContextCompactedEvent(sessionId, agentId, result)
 
-		// tool role should be converted to system
-		expect(event.newConversationHistory[0].role).toBe('system')
+		expect(event.newConversationHistory).toEqual(result.compactedMessages)
+	})
+
+	it('parses and reduces old-shape events exactly as before', () => {
+		const sessionId = generateSessionId()
+		const agentId = generateTestAgentId()
+		const oldPayload = contextCompactedEventSchema.parse({
+			agentId,
+			compactedContent: 'Old summary',
+			newConversationHistory: [
+				{ role: 'user', content: 'summary' },
+				{ role: 'assistant', content: 'recent response' },
+				{ role: 'system', content: 'legacy context' },
+			],
+			originalTokens: 1000,
+			compactedTokens: 100,
+			messagesRemoved: 12,
+		})
+
+		let state = createSessionState(sessionId, 'test', 0)
+		state = coreReducer(state, withSessionId(
+			sessionId,
+			agentEvents.create('agent_spawned', {
+				agentId,
+				definitionName: 'test-agent',
+				parentId: null,
+			}),
+		))
+		state = coreReducer(state, withSessionId(
+			sessionId,
+			contextEvents.create('context_compacted', oldPayload),
+		))
+
+		expect(state.agents.get(agentId)?.conversationHistory).toEqual([
+			{ role: 'user', content: 'summary', sourceMessageIds: [], cacheControl: undefined },
+			{ role: 'assistant', content: 'recent response', toolCalls: undefined, cacheControl: undefined },
+			{ role: 'system', content: 'legacy context', cacheControl: undefined },
+		])
 	})
 })
 
@@ -614,6 +669,97 @@ describe('ContextCompactor with tool calls', () => {
 		// All 5 original messages should be compacted (none kept except summary)
 		expect(result.value.messagesRemoved).toBe(5)
 	})
+
+	it('round-trips a kept tool turn and accounts for its token structure', async () => {
+		inference.setResponses([
+			{
+				content: 'Short summary',
+				toolCalls: [],
+				finishReason: 'stop',
+				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
+			},
+		])
+
+		const toolCallId = generateToolCallId()
+		const toolTurn: LLMMessage[] = [
+			{
+				role: 'assistant',
+				content: 'I will inspect the file.',
+				toolCalls: [{
+					id: toolCallId,
+					name: 'read',
+					input: { path: '/src/index.ts', reason: 'x'.repeat(400) },
+				}],
+			},
+			{
+				role: 'tool',
+				content: 'export const value = 1',
+				toolCallId,
+				toolName: 'read',
+				isError: false,
+				timestamp: 123,
+			},
+		]
+		const messages: LLMMessage[] = [
+			{ role: 'user', content: 'old context '.repeat(1000) },
+			{ role: 'assistant', content: 'old response '.repeat(1000) },
+			...toolTurn,
+		]
+		const preservingCompactor = new ContextCompactor(silentLogger, {
+			maxTokens: 100,
+			keepRecentMessages: 2,
+		})
+
+		const result = await preservingCompactor.compact(sessionId, agentId, messages, inference.run)
+		expect(result.ok).toBe(true)
+		if (!result.ok) return
+
+		expect(result.value.compactedMessages.slice(1)).toEqual(toolTurn)
+		expect(result.value.compactedTokens).toBeLessThan(result.value.originalTokens)
+		expect(result.value.compactedTokens).toBeGreaterThan(
+			estimateMessagesTokens(result.value.compactedMessages),
+		)
+
+		const event = createContextCompactedEvent(sessionId, agentId, result.value)
+		expect(event.newConversationHistory.slice(1)).toEqual(toolTurn)
+	})
+
+	it('keeps an open tool declaration even when keep limits are zero', async () => {
+		inference.setResponses([
+			{
+				content: 'Summary',
+				toolCalls: [],
+				finishReason: 'stop',
+				metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
+			},
+		])
+
+		const toolCallId = generateToolCallId()
+		const openToolCall: LLMMessage = {
+			role: 'assistant',
+			content: '',
+			toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
+		}
+		const zeroKeepCompactor = new ContextCompactor(silentLogger, {
+			maxTokens: 100,
+			keepRecentMessages: 0,
+			keepRecentTokens: 0,
+		})
+
+		const result = await zeroKeepCompactor.compact(
+			sessionId,
+			agentId,
+			[
+				{ role: 'user', content: 'old context' },
+				openToolCall,
+			],
+			inference.run,
+		)
+		expect(result.ok).toBe(true)
+		if (!result.ok) return
+
+		expect(result.value.compactedMessages.at(-1)).toEqual(openToolCall)
+	})
 })
 
 // ============================================================================