@roj-ai/sdk 0.1.28 → 0.1.30

package/src/core/llm/message-sanitization.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, test } from 'bun:test'
+import type { LLMMessage } from '~/core/agents/state.js'
+import { ToolCallId } from '~/core/tools/schema.js'
+import type { LogContext, Logger } from '~/lib/logger/logger.js'
+import { AnthropicProvider } from './anthropic.js'
+import { sanitizeProviderMessages } from './message-sanitization.js'
+import { OpenRouterProvider } from './openrouter.js'
+import type { RawInferenceRequest } from './provider.js'
+import { ModelId } from './schema.js'
+
+type CapturedWarning = {
+	message: string
+	context?: LogContext
+}
+
+const createCapturingLogger = (): { logger: Logger; warnings: CapturedWarning[] } => {
+	const warnings: CapturedWarning[] = []
+	const logger: Logger = {
+		debug: () => {},
+		info: () => {},
+		warn: (message, context) => warnings.push({ message, context }),
+		error: () => {},
+		child: () => logger,
+		level: 'debug',
+	}
+	return { logger, warnings }
+}
+
+const createOpenRouterProvider = (logger?: Logger) =>
+	new OpenRouterProvider({
+		apiKey: 'test-key',
+		imageProcessor: { resolveContent: async (content) => content },
+		logger,
+	})
+
+const createAnthropicProvider = (logger?: Logger) =>
+	new AnthropicProvider({
+		apiKey: 'test-key',
+		imageProcessor: { resolveContent: async (content) => content },
+		logger,
+	})
+
+const buildRequest = (messages: LLMMessage[]): RawInferenceRequest => ({
+	model: ModelId('test-model'),
+	systemPrompt: 'You are helpful.',
+	messages,
+})
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+	typeof value === 'object' && value !== null
+
+const getBodyMessages = (body: unknown): Record<string, unknown>[] => {
+	if (!isRecord(body) || !Array.isArray(body.messages)) {
+		throw new Error('Expected a request body with messages')
+	}
+	return body.messages.map((message) => {
+		if (!isRecord(message)) {
+			throw new Error('Expected each request message to be an object')
+		}
+		return message
+	})
+}
+
+const getContentBlocks = (message: Record<string, unknown>): Record<string, unknown>[] => {
+	if (!Array.isArray(message.content)) {
+		throw new Error('Expected message content blocks')
+	}
+	return message.content.map((block) => {
+		if (!isRecord(block)) {
+			throw new Error('Expected each content block to be an object')
+		}
+		return block
+	})
+}
+
+const wellFormedToolHistory = (): LLMMessage[] => [
+	{ role: 'user', content: 'Check the weather' },
+	{
+		role: 'assistant',
+		content: '',
+		toolCalls: [{ id: ToolCallId('call_1'), name: 'get_weather', input: { city: 'Prague' } }],
+	},
+	{
+		role: 'tool',
+		toolCallId: ToolCallId('call_1'),
+		toolName: 'get_weather',
+		content: 'Sunny',
+	},
+]
+
+const orphanedToolHistory = (): LLMMessage[] => [
+	{ role: 'user', content: 'Check the weather' },
+	{ role: 'assistant', content: 'I will check.' },
+	{
+		role: 'tool',
+		toolCallId: ToolCallId('orphan_1'),
+		toolName: 'get_weather',
+		content: 'Sunny',
+		cacheControl: { type: 'ephemeral' },
+	},
+]
+
+describe('sanitizeProviderMessages', () => {
+	test('returns a well-formed history unchanged', () => {
+		const messages = wellFormedToolHistory()
+		const result = sanitizeProviderMessages(messages, 'test')
+
+		expect(result).toBe(messages)
+		expect(result).toEqual(messages)
+	})
+
+	test('preserves an orphaned tool result as a marked user message and warns', () => {
+		const { logger, warnings } = createCapturingLogger()
+		const result = sanitizeProviderMessages(orphanedToolHistory(), 'test', logger)
+
+		expect(result[result.length - 1]).toEqual({
+			role: 'user',
+			content: '[Orphaned tool result from "get_weather"; tool call ID: orphan_1]\nSunny',
+			cacheControl: { type: 'ephemeral' },
+		})
+		expect(warnings).toEqual([{
+			message: 'Orphaned tool result converted to user message',
+			context: {
+				provider: 'test',
+				messageIndex: 2,
+				toolCallId: 'orphan_1',
+				toolName: 'get_weather',
+			},
+		}])
+	})
+
+	test('rejects a history ending in an assistant message', () => {
+		expect(() => sanitizeProviderMessages([
+			{ role: 'user', content: 'Hello' },
+			{ role: 'assistant', content: 'Hello back' },
+		], 'test')).toThrow('test request history ends with an assistant message after sanitation')
+	})
+})
+
+describe('OpenRouterProvider message sanitation', () => {
+	test('converts a trailing orphan to user without moving its cache breakpoint', async () => {
+		const { logger, warnings } = createCapturingLogger()
+		const request = await createOpenRouterProvider(logger).buildHttpRequest(buildRequest(orphanedToolHistory()))
+		const messages = getBodyMessages(request.body)
+		const last = messages[messages.length - 1]
+		const blocks = getContentBlocks(last)
+
+		expect(last.role).toBe('user')
+		expect(blocks).toEqual([{
+			type: 'text',
+			text: '[Orphaned tool result from "get_weather"; tool call ID: orphan_1]\nSunny',
+			cache_control: { type: 'ephemeral' },
+		}])
+		expect(warnings).toHaveLength(1)
+	})
+
+	test('keeps a matched tool result as a tool message', async () => {
+		const request = await createOpenRouterProvider().buildHttpRequest(buildRequest(wellFormedToolHistory()))
+		const messages = getBodyMessages(request.body)
+		const last = messages[messages.length - 1]
+
+		expect(last).toEqual({
+			role: 'tool',
+			content: 'Sunny',
+			tool_call_id: 'call_1',
+		})
+	})
+
+	test('rejects an assistant tail before issuing a request', async () => {
+		const promise = createOpenRouterProvider().buildHttpRequest(buildRequest([
+			{ role: 'user', content: 'Hello' },
+			{ role: 'assistant', content: 'Hello back' },
+		]))
+
+		await expect(promise).rejects.toThrow('openrouter request history ends with an assistant message after sanitation')
+	})
+})
+
+describe('AnthropicProvider message sanitation', () => {
+	test('converts a trailing orphan to user without moving its cache breakpoint', async () => {
+		const { logger, warnings } = createCapturingLogger()
+		const request = await createAnthropicProvider(logger).buildHttpRequest(buildRequest(orphanedToolHistory()))
+		const messages = getBodyMessages(request.body)
+		const last = messages[messages.length - 1]
+		const blocks = getContentBlocks(last)
+
+		expect(last.role).toBe('user')
+		expect(blocks).toEqual([{
+			type: 'text',
+			text: '[Orphaned tool result from "get_weather"; tool call ID: orphan_1]\nSunny',
+			cache_control: { type: 'ephemeral' },
+		}])
+		expect(warnings).toHaveLength(1)
+	})
+
+	test('keeps a matched tool result as a tool_result block', async () => {
+		const request = await createAnthropicProvider().buildHttpRequest(buildRequest(wellFormedToolHistory()))
+		const messages = getBodyMessages(request.body)
+		const last = messages[messages.length - 1]
+
+		expect(last.role).toBe('user')
+		expect(getContentBlocks(last)).toEqual([{
+			type: 'tool_result',
+			tool_use_id: 'call_1',
+			content: 'Sunny',
+		}])
+	})
+
+	test('rejects an assistant tail before issuing a request', async () => {
+		const promise = createAnthropicProvider().buildHttpRequest(buildRequest([
+			{ role: 'user', content: 'Hello' },
+			{ role: 'assistant', content: 'Hello back' },
+		]))
+
+		await expect(promise).rejects.toThrow('anthropic request history ends with an assistant message after sanitation')
+	})
+})

package/src/core/llm/message-sanitization.ts

@@ -0,0 +1,70 @@
+import type { LLMMessage, ToolLLMMessage, UserLLMMessage } from '~/core/agents/state.js'
+import type { ChatMessageContentItem } from '~/core/llm/llm-log-types.js'
+import type { Logger } from '~/lib/logger/logger.js'
+
+export class ProviderMessageValidationError extends Error {
+	constructor(message: string) {
+		super(message)
+		this.name = 'ProviderMessageValidationError'
+	}
+}
+
+const convertOrphanedToolResult = (message: ToolLLMMessage): UserLLMMessage => {
+	const toolName = message.toolName ? ` from "${message.toolName}"` : ''
+	const errorMarker = message.isError ? ' (error)' : ''
+	const marker = `[Orphaned tool result${toolName}; tool call ID: ${message.toolCallId}${errorMarker}]`
+	const markerItem: ChatMessageContentItem = { type: 'text', text: marker }
+	const content = typeof message.content === 'string'
+		? `${marker}\n${message.content}`
+		: [markerItem, ...message.content]
+
+	return {
+		role: 'user',
+		content,
+		cacheControl: message.cacheControl,
+	}
+}
+
+/**
+ * Preserve orphaned tool results as user messages and reject assistant-prefill requests.
+ */
+export const sanitizeProviderMessages = (
+	messages: LLMMessage[],
+	provider: string,
+	logger?: Logger,
+): LLMMessage[] => {
+	const declaredToolCallIds = new Set<string>()
+	let sanitizedMessages: LLMMessage[] | undefined
+
+	for (const [messageIndex, message] of messages.entries()) {
+		if (message.role === 'assistant') {
+			for (const toolCall of message.toolCalls ?? []) {
+				declaredToolCallIds.add(toolCall.id)
+			}
+		}
+
+		if (message.role === 'tool' && !declaredToolCallIds.has(message.toolCallId)) {
+			sanitizedMessages ??= messages.slice(0, messageIndex)
+			sanitizedMessages.push(convertOrphanedToolResult(message))
+			logger?.warn('Orphaned tool result converted to user message', {
+				provider,
+				messageIndex,
+				toolCallId: message.toolCallId,
+				toolName: message.toolName,
+			})
+			continue
+		}
+
+		sanitizedMessages?.push(message)
+	}
+
+	const result = sanitizedMessages ?? messages
+	const lastMessage = result[result.length - 1]
+	if (lastMessage?.role === 'assistant') {
+		throw new ProviderMessageValidationError(
+			`${provider} request history ends with an assistant message after sanitation`,
+		)
+	}
+
+	return result
+}

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()
@@ -800,13 +803,17 @@ export class Session {
 	 */
 	private getAgentConfig(definitionName: string): AgentConfig {
 		const withServicePluginConfig = (
-			config: { services?: { type: string }[]; plugins?: AgentPluginConfig[] },
+			config: { services?: { type: string; agentVisible?: boolean }[]; plugins?: AgentPluginConfig[] },
 		): AgentPluginConfig[] | undefined => {
 			const base = config.plugins ?? []
-			if (!config.services || config.services.length === 0) return base.length > 0 ? base : undefined
+			// agentVisible: false services stay registered at the session level (SessionManager
+			// collects them from agent definitions) but are excluded from the agent's own
+			// visibility list — no service_* tools, no session-context status line.
+			const visible = (config.services ?? []).filter(s => s.agentVisible !== false)
+			if (visible.length === 0) return base.length > 0 ? base : undefined
 			// Merge services config into plugins array (if not already present)
 			if (base.some(c => c.pluginName === 'services')) return base
-			return [...base, { pluginName: 'services', config: { services: config.services.map(s => s.type) } }]
+			return [...base, { pluginName: 'services', config: { services: visible.map(s => s.type) } }]
 		}
 
 		if (definitionName === ORCHESTRATOR_ROLE) {
@@ -822,6 +829,7 @@ export class Session {
 				input: orch.input,
 				plugins: withServicePluginConfig(orch),
 				cacheTtl: orch.cacheTtl,
+				errorResumeBackoff: orch.errorResumeBackoff,
 			}
 		}
 
@@ -838,6 +846,7 @@ export class Session {
 				input: comm.input,
 				plugins: withServicePluginConfig(comm),
 				cacheTtl: comm.cacheTtl,
+				errorResumeBackoff: comm.errorResumeBackoff,
 			}
 		}
 
@@ -857,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,
 				}))