@roj-ai/sdk 0.1.28 → 0.1.30

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)
+	})
 })
 
 // ============================================================================

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

@@ -194,7 +194,7 @@ export class ContextCompactor {
 			count = 0
 			let tokens = 0
 			for (let i = messages.length - 1; i >= 0 && count < maxCount; i--) {
-				const msgTokens = estimateMessagesTokens([messages[i]])
+				const msgTokens = estimateConversationTokens([messages[i]])
 				if (tokens + msgTokens > tokenBudget) break
 				tokens += msgTokens
 				count++
@@ -206,6 +206,13 @@ export class ContextCompactor {
 			count--
 		}
 
+		// An incomplete tool turn at the tail has pending results outside history.
+		// Keep its assistant declaration even if count/token limits would drop it.
+		const openToolTurnStart = findOpenToolTurnStart(messages)
+		if (openToolTurnStart !== undefined) {
+			count = Math.max(count, messages.length - openToolTurnStart)
+		}
+
 		return count
 	}
 
@@ -220,7 +227,7 @@ export class ContextCompactor {
 	 * relying on it alone causes the trigger to never fire in long sessions.
 	 */
 	needsCompaction(messages: LLMMessage[], lastActualPromptTokens?: number): boolean {
-		const tokens = lastActualPromptTokens ?? estimateMessagesTokens(messages)
+		const tokens = lastActualPromptTokens ?? estimateConversationTokens(messages)
 		return tokens > this.config.maxTokens
 	}
 
@@ -256,7 +263,7 @@ export class ContextCompactor {
 		runInference: RunInferenceFn,
 		lastActualPromptTokens?: number,
 	): Promise<Result<CompactionResult, Error>> {
-		const originalTokens = lastActualPromptTokens ?? estimateMessagesTokens(messages)
+		const originalTokens = lastActualPromptTokens ?? estimateConversationTokens(messages)
 
 		this.logger.info('Starting context compaction', {
 			sessionId,
@@ -338,7 +345,7 @@ export class ContextCompactor {
 		}
 
 		const compactedMessages = [summaryMessage, ...toKeep]
-		const compactedTokens = estimateMessagesTokens(compactedMessages)
+		const compactedTokens = estimateConversationTokens(compactedMessages)
 
 		this.logger.info('Context compaction complete', {
 			sessionId,
@@ -362,6 +369,54 @@ export class ContextCompactor {
 	}
 }
 
+function findOpenToolTurnStart(messages: LLMMessage[]): number | undefined {
+	let assistantIndex = messages.length - 1
+	while (assistantIndex >= 0 && messages[assistantIndex].role === 'tool') {
+		assistantIndex--
+	}
+
+	const assistant = messages[assistantIndex]
+	if (assistant?.role !== 'assistant' || !assistant.toolCalls?.length) {
+		return undefined
+	}
+
+	const completedToolCallIds = new Set<string>()
+	for (let i = assistantIndex + 1; i < messages.length; i++) {
+		const message = messages[i]
+		if (message.role === 'tool') {
+			completedToolCallIds.add(message.toolCallId)
+		}
+	}
+	return assistant.toolCalls.some((toolCall) => !completedToolCallIds.has(toolCall.id))
+		? assistantIndex
+		: undefined
+}
+
+function estimateConversationTokens(messages: LLMMessage[]): number {
+	return estimateMessagesTokens(messages.map((message) => ({
+		role: message.role,
+		content: tokenEstimationContent(message),
+	})))
+}
+
+function tokenEstimationContent(message: LLMMessage): unknown {
+	switch (message.role) {
+		case 'assistant':
+			return message.toolCalls?.length
+				? { content: message.content, toolCalls: message.toolCalls }
+				: message.content
+		case 'tool':
+			return {
+				content: message.content,
+				toolCallId: message.toolCallId,
+				isError: message.isError,
+			}
+		case 'user':
+		case 'system':
+			return message.content
+	}
+}
+
 // ============================================================================
 // Event creation helper
 // ============================================================================
@@ -371,11 +426,7 @@ export function createContextCompactedEvent(
 	agentId: AgentId,
 	result: CompactionResult,
 ): ContextCompactedEvent {
-	// Convert LLMMessage[] to CompactedConversationMessage[]
-	const newConversationHistory: CompactedConversationMessage[] = result.compactedMessages.map((msg) => ({
-		role: msg.role === 'tool' ? 'system' : msg.role,
-		content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-	}))
+	const newConversationHistory: CompactedConversationMessage[] = result.compactedMessages
 
 	return withSessionId(
 		sessionId,
@@ -397,7 +448,10 @@ export function createContextCompactedEvent(
  * tool-call and tool-result detail in the rendered content. Used for the
  * compaction "input" snapshot shown in the debug UI — not for reconstruction.
  */
-function toDisplayMessage(msg: LLMMessage): CompactedConversationMessage {
+function toDisplayMessage(msg: LLMMessage): {
+	role: 'user' | 'assistant' | 'system'
+	content: string
+} {
 	if (msg.role === 'assistant') {
 		const parts: string[] = []
 		if (msg.content) parts.push(msg.content)

package/src/plugins/limits-guard/config.ts

@@ -23,6 +23,8 @@ export interface AgentLimits {
 	maxRepeatedToolCalls?: number
 	/** Maximum consecutive identical text-only responses. Default: 3 */
 	maxRepeatedResponses?: number
+	/** Maximum consecutive outbound-only turns without newly consumed inbound work. Default: 3 */
+	maxConsecutiveNoProgressTurns?: number
 	/**
 	 * Maximum cumulative LLM cost (USD) this agent may spend before it is paused.
 	 * Spend is summed from `inference_completed` metrics and, unlike the counter

package/src/plugins/limits-guard/limit-guard.test.ts

@@ -14,6 +14,7 @@ describe('resolveAgentLimits', () => {
 		expect(limits.softLimitRatio).toBe(0.8)
 		expect(limits.maxRepeatedToolCalls).toBe(3)
 		expect(limits.maxRepeatedResponses).toBe(3)
+		expect(limits.maxConsecutiveNoProgressTurns).toBe(3)
 		// Budgets and compaction cap are opt-in (unlimited by default)
 		expect(limits.maxCost).toBe(Number.POSITIVE_INFINITY)
 		expect(limits.maxTokens).toBe(Number.POSITIVE_INFINITY)
@@ -112,6 +113,18 @@ describe('checkLimits', () => {
 		}
 	})
 
+	it('detects consecutive no-progress turns', () => {
+		const result = checkLimits(
+			makeCounters({ consecutiveNoProgressTurns: 3 }),
+			defaultLimits,
+		)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxConsecutiveNoProgressTurns')
+			expect(result.reason).toContain('used only outbound communication')
+		}
+	})
+
 	it('detects consecutive tool failures', () => {
 		const result = checkLimits(
 			makeCounters({ consecutiveToolFailures: { read_file: { count: 3, lastError: 'file not found' } } }),

package/src/plugins/limits-guard/limit-guard.ts

@@ -20,6 +20,7 @@ export interface ResolvedAgentLimits {
 	softLimitRatio: number
 	maxRepeatedToolCalls: number
 	maxRepeatedResponses: number
+	maxConsecutiveNoProgressTurns: number
 	maxCost: number
 	maxTokens: number
 	maxCompactions: number
@@ -34,6 +35,7 @@ const DEFAULTS: ResolvedAgentLimits = {
 	softLimitRatio: 0.8,
 	maxRepeatedToolCalls: 3,
 	maxRepeatedResponses: 3,
+	maxConsecutiveNoProgressTurns: 3,
 	// Budgets and the compaction cap are opt-in: unset means unlimited.
 	maxCost: Number.POSITIVE_INFINITY,
 	maxTokens: Number.POSITIVE_INFINITY,
@@ -51,6 +53,8 @@ export function resolveAgentLimits(config?: AgentLimits): ResolvedAgentLimits {
 		softLimitRatio: config.softLimitRatio ?? DEFAULTS.softLimitRatio,
 		maxRepeatedToolCalls: config.maxRepeatedToolCalls ?? DEFAULTS.maxRepeatedToolCalls,
 		maxRepeatedResponses: config.maxRepeatedResponses ?? DEFAULTS.maxRepeatedResponses,
+		maxConsecutiveNoProgressTurns:
+			config.maxConsecutiveNoProgressTurns ?? DEFAULTS.maxConsecutiveNoProgressTurns,
 		maxCost: config.maxCost ?? DEFAULTS.maxCost,
 		maxTokens: config.maxTokens ?? DEFAULTS.maxTokens,
 		maxCompactions: config.maxCompactions ?? DEFAULTS.maxCompactions,
@@ -165,16 +169,24 @@ export function checkLimits(counters: AgentCounters, limits: ResolvedAgentLimits
 		{ name: 'maxSpawnedAgents', current: counters.spawnedAgentCount, max: limits.maxSpawnedAgents },
 		{ name: 'maxMessagesSent', current: counters.messagesSentCount, max: limits.maxMessagesSent },
 		{ name: 'maxCompactions', current: counters.compactionCount, max: limits.maxCompactions },
+		{
+			name: 'maxConsecutiveNoProgressTurns',
+			current: counters.consecutiveNoProgressTurns,
+			max: limits.maxConsecutiveNoProgressTurns,
+		},
 	]
 
 	for (const check of hardChecks) {
 		if (check.current >= check.max) {
+			const reason = check.name === 'maxConsecutiveNoProgressTurns'
+				? `No progress detected: ${check.current} consecutive turns used only outbound communication without new input`
+				: `${check.name} reached: ${check.current}/${check.max}`
 			return {
 				status: 'hard_limit',
 				limitName: check.name,
 				currentValue: check.current,
 				hardLimit: check.max,
-				reason: `${check.name} reached: ${check.current}/${check.max}`,
+				reason,
 			}
 		}
 	}