@namzu/sdk 31.0.0 → 32.0.0

package/src/runtime/query/executor.ts

@@ -29,6 +29,7 @@ import type {
 	RequestToolPause,
 	SkillRegistryRef,
 	ToolContext,
+	ToolDispatchOptions,
 	ToolRegistryContract,
 	ToolResult,
 } from '../../types/tool/index.js'
@@ -71,6 +72,103 @@ export const DEFAULT_TOOL_TIMEOUT_MS = 120_000
  */
 export const DEFAULT_TOOL_CONCURRENCY = 8
 
+/** Maximum UTF-8 size of one ephemeral tool-progress update. */
+const MAX_TOOL_PROGRESS_BYTES = 8 * 1024
+
+/** A visible marker: this event is a display projection, not durable output. */
+const TOOL_PROGRESS_OMISSION = '… '
+
+function boundedToolProgress(message: string): string {
+	if (Buffer.byteLength(message, 'utf8') <= MAX_TOOL_PROGRESS_BYTES) return message
+
+	const tailBudget = MAX_TOOL_PROGRESS_BYTES - Buffer.byteLength(TOOL_PROGRESS_OMISSION, 'utf8')
+	let low = 0
+	let high = message.length
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2)
+		if (Buffer.byteLength(message.slice(middle), 'utf8') > tailBudget) low = middle + 1
+		else high = middle
+	}
+	// Do not turn the low half of a retained surrogate pair into U+FFFD.
+	if (
+		low > 0 &&
+		low < message.length &&
+		message.charCodeAt(low) >= 0xdc00 &&
+		message.charCodeAt(low) <= 0xdfff &&
+		message.charCodeAt(low - 1) >= 0xd800 &&
+		message.charCodeAt(low - 1) <= 0xdbff
+	) {
+		low += 1
+	}
+	return `${TOOL_PROGRESS_OMISSION}${message.slice(low)}`
+}
+
+/**
+ * Latest-state publisher for one tool call.
+ *
+ * `ToolContext.report()` is synchronous by contract, while host event
+ * listeners may be arbitrarily slow. Starting one promise per report makes a
+ * chatty tool an unbounded allocation source. Progress is state rather than a
+ * transcript, so one in-flight update plus the latest pending update is the
+ * complete useful working set; intermediate states may be replaced.
+ */
+class ToolProgressPublisher {
+	private pending: { readonly message: string; readonly fraction?: number } | undefined
+	private draining: Promise<void> | null = null
+	private accepting = true
+
+	constructor(
+		private readonly emitEvent: EmitEvent,
+		private readonly base: Omit<
+			Extract<RunEvent, { type: 'tool_progress' }>,
+			'message' | 'fraction'
+		>,
+	) {}
+
+	report(message: string, fraction?: number): void {
+		if (!this.accepting) return
+		this.pending = {
+			message,
+			...(fraction !== undefined ? { fraction: Math.min(1, Math.max(0, fraction)) } : {}),
+		}
+		this.startDrain()
+	}
+
+	async close(): Promise<void> {
+		this.accepting = false
+		this.startDrain()
+		while (this.draining) await this.draining
+	}
+
+	private startDrain(): void {
+		if (this.draining || !this.pending) return
+		const current = this.drain()
+		this.draining = current
+		void current.finally(() => {
+			if (this.draining !== current) return
+			this.draining = null
+			// A report can land after the final loop check but before this
+			// settlement callback. It is still an accepted update and must be
+			// drained even when close() has since stopped new reports.
+			this.startDrain()
+		})
+	}
+
+	private async drain(): Promise<void> {
+		while (this.pending) {
+			const update = this.pending
+			this.pending = undefined
+			// A progress observer is diagnostic. Its failure cannot become a tool
+			// failure, and report() never hands a rejection back to the tool.
+			await this.emitEvent({
+				...this.base,
+				message: boundedToolProgress(update.message),
+				...(update.fraction !== undefined ? { fraction: update.fraction } : {}),
+			}).catch(() => {})
+		}
+	}
+}
+
 /**
  * Re-runs granted to a `post_tool_use` hook that returns `{action:'retry'}`
  * on a tool which did not opt into {@link ToolDefinition.maxRetries}.
@@ -548,33 +646,35 @@ export class ToolExecutor {
 			// Per-call, because the event has to name which call it is about:
 			// a batch can run several tools at once and a host rendering them
 			// side by side needs to know whose progress this is.
+			const progress = new ToolProgressPublisher(this.emitEvent, {
+				type: 'tool_progress',
+				runId: this.config.runId,
+				toolUseId: toolCall.id as ToolUseId,
+				toolName: toolCall.function.name,
+			})
 			const ctx: ToolContext = {
 				...baseContext,
 				toolUseId: toolCall.id,
+				source: { kind: 'direct' },
 				// Overridden per call, so a nested dispatch can name the call
 				// that made it. The base context has no `toolUseId`, and a
 				// closure built there would report every nested call as
 				// parentless.
-				dispatchTool: (name, input) => this.dispatchNested(name, input, ctx, recordObservation),
+				dispatchTool: (name, input, options) =>
+					this.dispatchNested(name, input, ctx, recordObservation, toolCall.function.name, options),
 				// Per-call for the same reason: a pause has to be routed back
 				// to the call that raised it, and a batch can raise several.
 				...(this.config.toolPause ? { requestPause: this.config.toolPause(toolCall.id) } : {}),
-				report: (message: string, fraction?: number) => {
-					// Fire-and-forget: a tool reporting progress must never be
-					// able to fail because the host's listener threw, and must
-					// never have to await the emit mid-work.
-					void this.emitEvent({
-						type: 'tool_progress',
-						runId: this.config.runId,
-						toolUseId: toolCall.id as ToolUseId,
-						toolName: toolCall.function.name,
-						message,
-						...(fraction !== undefined ? { fraction: Math.min(1, Math.max(0, fraction)) } : {}),
-					}).catch(() => {})
-				},
+				report: (message: string, fraction?: number) => progress.report(message, fraction),
 			}
 			const run = async () => {
-				results[i] = await this.executeSingle(toolCall, ctx, recordObservation)
+				try {
+					results[i] = await this.executeSingle(toolCall, ctx, recordObservation, () =>
+						progress.close(),
+					)
+				} finally {
+					await progress.close()
+				}
 			}
 			const gated = async () => {
 				await gate.acquire()
@@ -651,15 +751,64 @@ export class ToolExecutor {
 		input: unknown,
 		context: ToolContext,
 		recordObservation: (observation: ToolResultObservation) => void,
+		parentToolName?: string,
+		options?: ToolDispatchOptions,
 	): Promise<ToolResult> {
 		const parent = context.toolUseId
-		const via = parent ? { tool: name, toolUseId: parent as ToolUseId } : undefined
+		const via =
+			parent && parentToolName
+				? {
+						tool: parentToolName,
+						toolUseId: parent as ToolUseId,
+						...(options?.runtimeToolCallId ? { runtimeToolCallId: options.runtimeToolCallId } : {}),
+					}
+				: undefined
 		// Its own id, minted here. Reusing the parent's would make two
 		// different calls indistinguishable in any log keyed by it, which is
 		// exactly how a nested write gets attributed to the program that ran
 		// it rather than to itself.
 		const nestedId = generateToolCallId() as unknown as ToolUseId
 		const startedAt = Date.now()
+		const signal = options?.signal
+			? AbortSignal.any([context.abortSignal, options.signal])
+			: context.abortSignal
+		const source = parent
+			? options?.runtimeToolCallId
+				? {
+						kind: 'code' as const,
+						parentToolUseId: parent,
+						runtimeToolCallId: options.runtimeToolCallId,
+					}
+				: { kind: 'nested' as const, parentToolUseId: parent }
+			: { kind: 'direct' as const }
+		const progress = new ToolProgressPublisher(this.emitEvent, {
+			type: 'tool_progress',
+			runId: this.config.runId,
+			toolUseId: nestedId,
+			toolName: name,
+		})
+		const childContext: ToolContext = {
+			...context,
+			abortSignal: signal,
+			toolUseId: nestedId,
+			source,
+			dispatchTool: (childName, childInput, childOptions) =>
+				this.dispatchNested(
+					childName,
+					childInput,
+					childContext,
+					recordObservation,
+					name,
+					childOptions,
+				),
+			// A nested execution has its own event/progress identity, but its
+			// durable pause belongs to the nearest model-issued ancestor. The
+			// checkpoint transcript contains that ancestor call and not this
+			// ephemeral child id; minting a pause route for `nestedId` makes the
+			// answer impossible to match after process restart. `...context`
+			// intentionally preserves the ancestor route here.
+			report: (message: string, fraction?: number) => progress.report(message, fraction),
+		}
 
 		await this.emitEvent({
 			type: 'tool_executing',
@@ -670,16 +819,54 @@ export class ToolExecutor {
 			...(via ? { via } : {}),
 		})
 
-		const result = await this.config.tools.execute(name, input, context)
+		let result: ToolResult
+		try {
+			// Use the same deadline layer as a model-issued call. Calling the
+			// registry directly made nested tools the only tools whose own
+			// `timeoutMs` declaration was ignored.
+			result = await this.runOnce(name, input, childContext)
+		} finally {
+			await progress.close()
+		}
+
+		const rawOutput = result.success
+			? result.output
+			: formatFailedToolOutput(result.output, result.error)
+		const budgeted = applyToolOutputBudget({
+			toolName: name,
+			toolUseId: nestedId,
+			output: rawOutput,
+			maxChars: this.config.maxToolOutputChars ?? DEFAULT_MAX_TOOL_OUTPUT_CHARS,
+			spillDir: this.config.toolOutputDir,
+			onError: (message) =>
+				this.log.warn('Failed to spill oversized nested tool output', {
+					[NAMZU.RUN_ID]: this.config.runId,
+					[GENAI.TOOL_NAME]: name,
+					'exception.message': message,
+				}),
+		})
+		const visibleResult: ToolResult = result.success
+			? { ...result, output: budgeted.output }
+			: {
+					...result,
+					output: '',
+					// `run_code` sends `error`, not `output`, across the worker
+					// bridge on a failed host call. Leaving the raw error here would
+					// make the success path bounded and the failure path unbounded.
+					error: budgeted.output,
+				}
 
 		await this.emitEvent({
 			type: 'tool_completed',
 			runId: this.config.runId,
 			toolUseId: nestedId,
 			toolName: name,
-			result: result.success ? result.output : (result.error ?? 'failed'),
+			result: budgeted.output,
 			isError: !result.success,
 			durationMs: Date.now() - startedAt,
+			outputLength: budgeted.originalLength,
+			...(budgeted.truncated ? { outputTruncated: true } : {}),
+			...(budgeted.spillPath ? { outputSpillPath: budgeted.spillPath } : {}),
 			...(via ? { via } : {}),
 		})
 		recordObservation({
@@ -691,7 +878,7 @@ export class ToolExecutor {
 			...(parent ? { parentToolUseId: parent } : {}),
 		})
 
-		return result
+		return visibleResult
 	}
 
 	private buildToolContext(
@@ -729,7 +916,8 @@ export class ToolExecutor {
 			// dispatching outside a batch has no parent call to name. The
 			// per-call context below overrides it with one that does; see
 			// `dispatchNested`.
-			dispatchTool: (name, input) => this.dispatchNested(name, input, context, recordObservation),
+			dispatchTool: (name, input, options) =>
+				this.dispatchNested(name, input, context, recordObservation, undefined, options),
 			sandbox: this.config.sandbox,
 			fileReadTracker: this.fileReadTracker,
 			// Bound to this run, once. Binding here rather than passing the
@@ -759,6 +947,7 @@ export class ToolExecutor {
 		toolCall: ToolCall,
 		toolContext: ToolContext,
 		recordObservation: (observation: ToolResultObservation) => void,
+		settleProgress: () => Promise<void>,
 	): Promise<ToolCallOutcome> {
 		let toolName = toolCall.function.name
 
@@ -1095,6 +1284,11 @@ export class ToolExecutor {
 			}
 		}
 
+		// The terminal event closes the live row. Every accepted progress update
+		// must settle before it, otherwise a slow host can receive an update for a
+		// call it has already removed. Detached work reporting after a timeout is
+		// ignored because close() also revokes the publisher.
+		await settleProgress()
 		await this.emitEvent({
 			type: 'tool_completed',
 			runId: this.config.runId,
@@ -1180,10 +1374,10 @@ export class ToolExecutor {
 		}
 
 		const controller = new AbortController()
-		const runSignal = this.config.abortSignal
-		const onRunAbort = () => controller.abort(runSignal.reason)
-		if (runSignal.aborted) controller.abort(runSignal.reason)
-		else runSignal.addEventListener('abort', onRunAbort, { once: true })
+		const parentSignal = toolContext.abortSignal
+		const onParentAbort = () => controller.abort(parentSignal.reason)
+		if (parentSignal.aborted) controller.abort(parentSignal.reason)
+		else parentSignal.addEventListener('abort', onParentAbort, { once: true })
 
 		let timer: ReturnType<typeof setTimeout> | undefined
 		let timedOut = false
@@ -1211,9 +1405,21 @@ export class ToolExecutor {
 				)
 			})
 
+			const inheritedDispatch = toolContext.dispatchTool
 			const execution = this.config.tools.execute(toolName, input, {
 				...toolContext,
 				abortSignal: controller.signal,
+				...(inheritedDispatch
+					? {
+							dispatchTool: (name: string, nestedInput: unknown, options?: ToolDispatchOptions) =>
+								inheritedDispatch(name, nestedInput, {
+									...options,
+									signal: options?.signal
+										? AbortSignal.any([controller.signal, options.signal])
+										: controller.signal,
+								}),
+						}
+					: {}),
 			})
 			// The loser of the race may still reject later; neutralize it so
 			// it is never an unhandled rejection.
@@ -1254,7 +1460,7 @@ export class ToolExecutor {
 			return outcome
 		} finally {
 			if (timer !== undefined) clearTimeout(timer)
-			runSignal.removeEventListener('abort', onRunAbort)
+			parentSignal.removeEventListener('abort', onParentAbort)
 		}
 	}
 
@@ -1457,7 +1663,10 @@ export class ToolExecutor {
 				reason: failure.reason,
 				message: failure.message,
 				...(tool
-					? { tool, jsonSchema: tool.modelInputSchema ?? renderToolSchema(tool.inputSchema) }
+					? {
+							tool,
+							jsonSchema: tool.modelInputSchema ?? renderToolSchema(tool.inputSchema),
+						}
 					: {}),
 				availableTools: this.config.tools.listNames(),
 			})

package/src/runtime/query/index.ts

@@ -302,6 +302,11 @@ export interface QueryParams {
 	 * store REFUSES rather than dropping the attachment.
 	 */
 	attachmentStore?: import('../../store/attachment/index.js').AttachmentStore
+	/**
+	 * Maximum wall-clock time for resolving the run's stored attachments.
+	 * Defaults to one minute; `0` retains the prior unbounded wait.
+	 */
+	attachmentResolveTimeoutMs?: number
 
 	/**
 	 * How this run reaches the web.
@@ -1192,6 +1197,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		resolvedInitialMessages = [
 			...(await resolveAttachments(seeded, params.attachmentStore, {
 				signal: params.signal,
+				timeoutMs: params.attachmentResolveTimeoutMs,
 			})),
 		]
 		params.signal?.throwIfAborted()

package/src/runtime/query/iteration/index.ts

@@ -22,8 +22,8 @@ import type { CostInfo, TokenUsage } from '../../../types/common/index.js'
 import type { MessageId } from '../../../types/ids/index.js'
 import {
 	createAssistantMessage,
+	createRuntimeContextMessage,
 	createSystemMessage,
-	createUserMessage,
 } from '../../../types/message/index.js'
 import type { ToolChoice } from '../../../types/provider/chat.js'
 import { classifyProviderError } from '../../../types/provider/errors.js'
@@ -47,6 +47,8 @@ import type { ToolCallOutcome } from '../executor.js'
 import { applyLifecycleHookResults } from '../plugin-hooks.js'
 import {
 	DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+	type RequestImageIdentity,
+	markProviderRejectedImage,
 	projectRequestRichContent,
 } from '../request-rich-content.js'
 import { formatSteeringNote } from '../steering.js'
@@ -57,6 +59,7 @@ import type { IterationContext } from './phases/index.js'
 import { runPlanGate } from './phases/plan.js'
 import { runToolReview } from './phases/tool-review.js'
 import { refreshWorkingMemory } from './phases/working-memory.js'
+import { streamWithProviderRejectedImageRecovery } from './provider-rejected-image.js'
 import { streamProviderTurn } from './stream-turn.js'
 
 export type { IterationContext } from './phases/index.js'
@@ -394,8 +397,9 @@ export class IterationOrchestrator {
 					const baseMessages = forceFinalize
 						? [
 								...runMgr.messages,
-								createUserMessage(
+								createRuntimeContextMessage(
 									'[SYSTEM] You are approaching your resource limits. Provide your final, comprehensive response now based on everything you have gathered so far. Do not request any more tool calls.',
+									'limit-finalization',
 								),
 							]
 						: runMgr.messages
@@ -589,6 +593,9 @@ export class IterationOrchestrator {
 						this.ctx.log,
 						iterSpan,
 						stepMessageId,
+						{
+							onAccepted: (identity) => this.acceptProviderRejectedImage(identity),
+						},
 					)
 					stepResponse = response
 
@@ -880,7 +887,9 @@ export class IterationOrchestrator {
 								[NAMZU.ITERATION]: iterationNum,
 								[GENAI.USAGE_OUTPUT_TOKENS]: response.usage.completionTokens,
 							})
-							runMgr.pushMessage(createUserMessage(AUTO_CONTINUATION_USER_MESSAGE))
+							runMgr.pushMessage(
+								createRuntimeContextMessage(AUTO_CONTINUATION_USER_MESSAGE, 'auto-continuation'),
+							)
 							await this.ctx.emitEvent({
 								type: 'iteration_completed',
 								runId: runMgr.id,
@@ -912,7 +921,9 @@ export class IterationOrchestrator {
 								'namzu.retry.attempt': attempt,
 								'namzu.runtime.limit': limit,
 							})
-							runMgr.pushMessage(createUserMessage(STRUCTURED_OUTPUT_REPROMPT))
+							runMgr.pushMessage(
+								createRuntimeContextMessage(STRUCTURED_OUTPUT_REPROMPT, 'structured-output'),
+							)
 							await this.ctx.emitEvent({
 								type: 'iteration_completed',
 								runId: runMgr.id,
@@ -955,7 +966,7 @@ export class IterationOrchestrator {
 									'namzu.retry.attempt': attempt,
 									'namzu.runtime.limit': limit,
 								})
-								runMgr.pushMessage(createUserMessage(review.feedback))
+								runMgr.pushMessage(createRuntimeContextMessage(review.feedback, 'answer-review'))
 								await this.ctx.emitEvent({
 									type: 'iteration_completed',
 									runId: runMgr.id,
@@ -1188,7 +1199,9 @@ export class IterationOrchestrator {
 							[NAMZU.ITERATION]: iterationNum,
 							'namzu.runtime.tasks': unheard.map((h) => h.taskId),
 						})
-						runMgr.pushMessage(createUserMessage(formatCompletionNotification(unheard)))
+						runMgr.pushMessage(
+							createRuntimeContextMessage(formatCompletionNotification(unheard), 'task-completion'),
+						)
 					}
 
 					// The same seam, for the two channels that could accept text
@@ -1388,7 +1401,9 @@ export class IterationOrchestrator {
 		const arrived = this.ctx.completionInbox.drain()
 		if (arrived.length === 0) return false
 
-		this.ctx.runMgr.pushMessage(createUserMessage(formatCompletionNotification(arrived)))
+		this.ctx.runMgr.pushMessage(
+			createRuntimeContextMessage(formatCompletionNotification(arrived), 'task-completion'),
+		)
 		await this.ctx.emitEvent({
 			type: 'iteration_completed',
 			runId: this.ctx.runMgr.id,
@@ -1467,7 +1482,9 @@ export class IterationOrchestrator {
 			[NAMZU.RUN_ID]: this.ctx.runMgr.id,
 			'namzu.runtime.tasks': unheard.map((h) => h.taskId),
 		})
-		this.ctx.runMgr.pushMessage(createUserMessage(formatCompletionNotification(unheard)))
+		this.ctx.runMgr.pushMessage(
+			createRuntimeContextMessage(formatCompletionNotification(unheard), 'task-completion'),
+		)
 	}
 
 	/**
@@ -1633,7 +1650,9 @@ export class IterationOrchestrator {
 		// guidance from a turn that had no result to attach it to.
 		const stranded = this.ctx.steering?.drain()
 		if (stranded) {
-			this.ctx.runMgr.pushMessage(createUserMessage(formatSteeringNote(stranded)))
+			this.ctx.runMgr.pushMessage(
+				createRuntimeContextMessage(formatSteeringNote(stranded), 'steering'),
+			)
 		}
 
 		return queued.length + (stranded ? 1 : 0)
@@ -1922,6 +1941,23 @@ export class IterationOrchestrator {
 			.some((t) => t.state !== 'completed' && t.state !== 'failed' && t.state !== 'canceled')
 	}
 
+	private async acceptProviderRejectedImage(identity: RequestImageIdentity): Promise<void> {
+		const repaired = markProviderRejectedImage(this.ctx.runMgr.messages, identity)
+		if (repaired.count === 0) {
+			throw new Error('Provider-rejected image recovery could not find its durable source image')
+		}
+		this.ctx.runMgr.replaceMessages(repaired.messages)
+		await this.ctx.emitEvent?.({
+			type: 'message_history_repaired',
+			runId: this.ctx.runMgr.id,
+			source: 'provider-rejected-image',
+			duplicateToolResultsRemoved: 0,
+			orphanedToolResultsRemoved: 0,
+			syntheticToolResultsInserted: 0,
+			providerRejectedImagesSuppressed: repaired.count,
+		})
+	}
+
 	private async requestFinalResponse(model: string, reason: StopReason): Promise<void> {
 		const lastAssistant = [...this.ctx.runMgr.messages]
 			.reverse()
@@ -1941,8 +1977,9 @@ export class IterationOrchestrator {
 		try {
 			const finalHistory = [
 				...this.ctx.runMgr.messages,
-				createUserMessage(
+				createRuntimeContextMessage(
 					`[SYSTEM] Run is ending due to ${reason}. You MUST provide a final response now summarizing all your findings and work so far. Do not use any tools.`,
+					'limit-finalization',
 				),
 			]
 			const finalMessages = projectRequestRichContent(
@@ -1964,26 +2001,29 @@ export class IterationOrchestrator {
 				model: requestedMember.model ?? model,
 				chainIndex: requestedMember.index,
 			}
+			const finalParams = {
+				model,
+				providerRoute: requestedRoute,
+				messages: finalMessages,
+				tools: finalTools.length > 0 ? finalTools : undefined,
+				...(finalEnforced ? { enforceToolInputSchema: finalEnforced } : {}),
+				toolChoice: finalTools.length > 0 ? 'none' : undefined,
+				temperature: this.ctx.runConfig.temperature,
+				maxTokens: this.ctx.runConfig.maxResponseTokens,
+				cacheControl: { type: 'auto' },
+				...(this.ctx.runConfig.thinking ? { thinking: this.ctx.runConfig.thinking } : {}),
+				// This turn is a hand-maintained duplicate of the one above, which
+				// is exactly the shape a field goes missing from — so it is tested
+				// separately rather than assumed to have been kept in step.
+				...(this.ctx.runConfig.effort ? { effort: this.ctx.runConfig.effort } : {}),
+				// Cancellable too: a Stop during the closing summary must not
+				// stream to completion.
+				signal: this.ctx.abortController.signal,
+			} satisfies import('../../../types/provider/index.js').ChatCompletionParams
 			const response = await collectChatCompletion(
-				this.ctx.provider.chatStream({
-					model,
-					providerRoute: requestedRoute,
-					messages: finalMessages,
-					tools: finalTools.length > 0 ? finalTools : undefined,
-					...(finalEnforced ? { enforceToolInputSchema: finalEnforced } : {}),
-					toolChoice: finalTools.length > 0 ? 'none' : undefined,
-					temperature: this.ctx.runConfig.temperature,
-					maxTokens: this.ctx.runConfig.maxResponseTokens,
-					cacheControl: { type: 'auto' },
-					...(this.ctx.runConfig.thinking ? { thinking: this.ctx.runConfig.thinking } : {}),
-					// This turn is a hand-maintained duplicate of the one above, which
-					// is exactly the shape a field goes missing from — so it is tested
-					// separately rather than assumed to have been kept in step.
-					...(this.ctx.runConfig.effort ? { effort: this.ctx.runConfig.effort } : {}),
-					// Cancellable too: a Stop during the closing summary must not
-					// stream to completion.
-					signal: this.ctx.abortController.signal,
-				}),
+				streamWithProviderRejectedImageRecovery(this.ctx.provider, finalParams, (identity) =>
+					this.acceptProviderRejectedImage(identity),
+				),
 			)
 
 			const servingMember = this.ctx.servingMember?.() ?? requestedMember

package/src/runtime/query/iteration/phases/advisory.ts

@@ -2,7 +2,7 @@ import { serializeState } from '../../../../compaction/serializer.js'
 import { NAMZU } from '../../../../constants/telemetry/index.js'
 import type { AdvisoryRequest, TriggerEvaluationState } from '../../../../types/advisory/index.js'
 import { toolResultToText } from '../../../../types/message/content.js'
-import { createUserMessage } from '../../../../types/message/index.js'
+import { createRuntimeContextMessage } from '../../../../types/message/index.js'
 import type { ChatCompletionResponse } from '../../../../types/provider/index.js'
 import { toErrorMessage } from '../../../../utils/error.js'
 import type { IterationContext } from './context.js'
@@ -169,7 +169,7 @@ export async function runAdvisoryPhase(
 
 		sections.push('</advisory-result>')
 
-		ctx.runMgr.pushMessage(createUserMessage(sections.join('\n')))
+		ctx.runMgr.pushMessage(createRuntimeContextMessage(sections.join('\n'), 'advisory'))
 
 		ctx.log.info('Advisory phase completed', {
 			[NAMZU.RUN_ID]: ctx.runMgr.id,