@namzu/sdk 30.2.0 → 31.1.0

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

@@ -45,6 +45,10 @@ import { stableDigest } from '../../../utils/hash.js'
 import { generateMessageId } from '../../../utils/id.js'
 import type { ToolCallOutcome } from '../executor.js'
 import { applyLifecycleHookResults } from '../plugin-hooks.js'
+import {
+	DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+	projectRequestRichContent,
+} from '../request-rich-content.js'
 import { formatSteeringNote } from '../steering.js'
 import { runAdvisoryPhase } from './phases/advisory.js'
 import { runIterationCheckpoint } from './phases/checkpoint.js'
@@ -220,7 +224,9 @@ export class IterationOrchestrator {
 
 				if (guardResult.shouldStop) {
 					if (guardResult.isCancelled) {
-						this.ctx.log.info('Run cancelled by signal', { [NAMZU.RUN_ID]: runMgr.id })
+						this.ctx.log.info('Run cancelled by signal', {
+							[NAMZU.RUN_ID]: runMgr.id,
+						})
 						runMgr.setStopReason('cancelled')
 						runMgr.markCancelled()
 						break
@@ -336,7 +342,11 @@ export class IterationOrchestrator {
 					if (this.ctx.pluginManager) {
 						const hookResults = await this.ctx.pluginManager.executeHooks(
 							'iteration_start',
-							{ runId: runMgr.id, iteration: iterationNum },
+							{
+								runId: runMgr.id,
+								iteration: iterationNum,
+								signal: this.ctx.abortController.signal,
+							},
 							this.ctx.emitEvent,
 						)
 						applyLifecycleHookResults('iteration_start', hookResults)
@@ -348,6 +358,11 @@ export class IterationOrchestrator {
 					// compaction preserves). No-op when no provider is configured.
 					await refreshWorkingMemory(this.ctx)
 					await runCompactionCheck(this.ctx)
+					// A context edit is a host-visible state transition, not a prelude
+					// whose events may wait behind the next network call. In particular,
+					// a slow or failing provider must not leave the host displaying the
+					// pre-compaction context after Run.messages already shrank.
+					yield* this.ctx.drainPending()
 
 					// Cache discipline: keep the tools param byte-stable even on the
 					// forced-final iteration and forbid tool use via tool_choice
@@ -426,14 +441,20 @@ export class IterationOrchestrator {
 					// a standing instruction, and either way the state they
 					// exist to report goes stale silently.
 					const turnSections =
-						this.ctx.promptContributions?.render('turn', { iteration: iterationNum }) ?? []
+						this.ctx.promptContributions?.render('turn', {
+							iteration: iterationNum,
+						}) ?? []
 
 					const stepPreamble = [step.system, stepSkills, policyNotice, ...turnSections]
 						.filter(Boolean)
 						.join('\n\n')
-					const messages = stepPreamble
+					const requestHistory = stepPreamble
 						? [...baseMessages, createSystemMessage(stepPreamble)]
 						: [...baseMessages]
+					const messages = projectRequestRichContent(
+						requestHistory,
+						this.ctx.runConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+					)
 
 					// What the model is about to be ASKED, recorded when it
 					// changed. `run_started` carries one system prompt and tool
@@ -484,6 +505,7 @@ export class IterationOrchestrator {
 							{
 								runId: runMgr.id,
 								iteration: iterationNum,
+								signal: this.ctx.abortController.signal,
 								// Built inside the guard: a run with no plugins installed
 								// pays nothing for a projection nobody reads.
 								request: Object.freeze({
@@ -521,10 +543,20 @@ export class IterationOrchestrator {
 					// `message_completed` under this id, which is the trail a
 					// reader wants most on exactly that turn.
 					stepMessageId = generateMessageId()
+					const requestedMember = this.ctx.servingMember?.() ?? {
+						index: 0,
+						providerId: this.ctx.provider.id,
+					}
+					const requestedRoute: StepProvenance = {
+						providerId: requestedMember.providerId,
+						model: requestedMember.model ?? stepModel,
+						chainIndex: requestedMember.index,
+					}
 					const { response, messageId } = yield* streamProviderTurn(
 						this.ctx.provider,
 						{
 							model: stepModel,
+							providerRoute: requestedRoute,
 							messages,
 							tools: llmTools.length > 0 ? llmTools : undefined,
 							...(enforceToolInputSchema ? { enforceToolInputSchema } : {}),
@@ -618,6 +650,7 @@ export class IterationOrchestrator {
 							{
 								runId: runMgr.id,
 								iteration: iterationNum,
+								signal: this.ctx.abortController.signal,
 								response: Object.freeze({
 									content: response.message.content,
 									toolNames: Object.freeze(
@@ -681,10 +714,10 @@ export class IterationOrchestrator {
 						...contextFigures,
 					})
 
-					// Reasoning rides along with the turn it belongs to, so the
-					// replay contract holds automatically: trimming or compacting
-					// the assistant message takes its thinking blocks with it,
-					// and no separate atomicity rule is needed.
+					// Durable reasoning and its adapter-private replay envelope ride
+					// with the turn they belong to. Trimming therefore removes both;
+					// retaining them gives the target adapter enough evidence to
+					// validate native replay against the exact serving route.
 					const assistantMsg = createAssistantMessage(
 						response.message.content,
 						forceFinalize ? undefined : response.message.toolCalls,
@@ -693,6 +726,13 @@ export class IterationOrchestrator {
 						// trimming or compacting the turn takes its evidence with it
 						// rather than leaving citations pointing at prose that is gone.
 						response.message.citations,
+						{
+							type: 'model',
+							...servedBy,
+							...(response.message.replayState !== undefined
+								? { replayState: response.message.replayState }
+								: {}),
+						},
 					)
 					runMgr.pushMessage(assistantMsg)
 
@@ -1162,7 +1202,11 @@ export class IterationOrchestrator {
 					if (this.ctx.pluginManager) {
 						const hookResults = await this.ctx.pluginManager.executeHooks(
 							'iteration_end',
-							{ runId: runMgr.id, iteration: iterationNum },
+							{
+								runId: runMgr.id,
+								iteration: iterationNum,
+								signal: this.ctx.abortController.signal,
+							},
 							this.ctx.emitEvent,
 						)
 						applyLifecycleHookResults('iteration_end', hookResults)
@@ -1895,21 +1939,35 @@ export class IterationOrchestrator {
 		})
 
 		try {
-			const finalMessages = [
+			const finalHistory = [
 				...this.ctx.runMgr.messages,
 				createUserMessage(
 					`[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.`,
 				),
 			]
+			const finalMessages = projectRequestRichContent(
+				finalHistory,
+				this.ctx.runConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+			)
 
 			// Same cache discipline as the forced-final iteration: keep the
 			// tools param identical to prior iterations (cache prefix intact,
 			// no 400 on tool blocks in history) and forbid use via tool_choice.
 			const finalTools = this.ctx.tools.toLLMTools(this.ctx.allowedTools)
 			const finalEnforced = enforcedModelInputToolNames(this.ctx.tools, finalTools)
+			const requestedMember = this.ctx.servingMember?.() ?? {
+				index: 0,
+				providerId: this.ctx.provider.id,
+			}
+			const requestedRoute: StepProvenance = {
+				providerId: requestedMember.providerId,
+				model: requestedMember.model ?? model,
+				chainIndex: requestedMember.index,
+			}
 			const response = await collectChatCompletion(
 				this.ctx.provider.chatStream({
 					model,
+					providerRoute: requestedRoute,
 					messages: finalMessages,
 					tools: finalTools.length > 0 ? finalTools : undefined,
 					...(finalEnforced ? { enforceToolInputSchema: finalEnforced } : {}),
@@ -1928,12 +1986,30 @@ export class IterationOrchestrator {
 				}),
 			)
 
+			const servingMember = this.ctx.servingMember?.() ?? requestedMember
+			const servedBy: StepProvenance = {
+				providerId: servingMember.providerId,
+				model: servingMember.model ?? model,
+				chainIndex: servingMember.index,
+			}
 			this.ctx.runMgr.accumulateUsage(response.usage, {
-				providerId: this.ctx.runMgr.servingProviderId,
-				model,
+				providerId: servedBy.providerId,
+				model: servedBy.model,
 			})
 
-			const assistantMsg = createAssistantMessage(response.message.content)
+			const assistantMsg = createAssistantMessage(
+				response.message.content,
+				undefined,
+				response.message.reasoning,
+				response.message.citations,
+				{
+					type: 'model',
+					...servedBy,
+					...(response.message.replayState !== undefined
+						? { replayState: response.message.replayState }
+						: {}),
+				},
+			)
 			this.ctx.runMgr.pushMessage(assistantMsg)
 
 			const finalMessageId = generateMessageId()

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

@@ -1,12 +1,12 @@
 import { resolveContextWindow } from '../../../../compaction/context-window.js'
 import { findDanglingMessages } from '../../../../compaction/dangling.js'
-import { planCompaction } from '../../../../compaction/plan.js'
+import { type CompactionPlan, planCompaction } from '../../../../compaction/plan.js'
 import type { ContextReducer, ContextReduction } from '../../../../compaction/reducer.js'
 import { createSlidingWindowReducer } from '../../../../compaction/reducer.js'
 import { findRetainedIndices } from '../../../../compaction/retention.js'
 import { serializeState } from '../../../../compaction/serializer.js'
 import { buildCompactionMessage, isCompactionMessage } from '../../../../compaction/summary.js'
-import { buildVerifiedSummary } from '../../../../compaction/verifier.js'
+import { buildVerifiedSummaryWithBoundedProvider } from '../../../../compaction/verifier.js'
 import { CHARS_PER_TOKEN } from '../../../../constants/limits.js'
 import { NAMZU } from '../../../../constants/telemetry/index.js'
 import { invariants } from '../../../../invariants/index.js'
@@ -97,6 +97,78 @@ function estimateTokens(ctx: IterationContext): number {
 	return estimateMessageTokens(ctx.runMgr.messages) + estimateToolCatalogTokens(ctx)
 }
 
+type ToolResultClearPlan = Extract<CompactionPlan, { kind: 'cleared' }>
+
+/** Replace the contents while preserving the live array identity. */
+function installMessages(live: Message[], next: readonly Message[]): void {
+	live.length = 0
+	for (const message of next) live.push(message)
+}
+
+/**
+ * Publish a status snapshot for a context edit that has already committed.
+ *
+ * Cumulative usage and cost do not fall when history is shed. The context
+ * does, and until the next provider response there is no more authoritative
+ * number than the post-edit estimate. Emitting the existing state event at
+ * this boundary lets hosts update immediately without inventing a second
+ * accounting channel.
+ */
+async function emitContextUsageSnapshot(
+	ctx: IterationContext,
+	contextTokens: number,
+	contextWindowTokens: number,
+	windowSource: 'config' | 'provider' | 'model-table' | 'default',
+): Promise<void> {
+	await ctx.emitEvent?.({
+		type: 'token_usage_updated',
+		runId: ctx.runMgr.id,
+		usage: { ...ctx.runMgr.tokenUsage },
+		cost: { ...ctx.runMgr.costInfo },
+		contextTokens,
+		contextMeasuredBy: 'estimate',
+		contextWindowTokens,
+		windowSource,
+	})
+}
+
+async function emitToolResultClear(
+	ctx: IterationContext,
+	plan: ToolResultClearPlan,
+): Promise<void> {
+	ctx.log.info('Cleared stale tool results instead of compacting', {
+		[NAMZU.RUN_ID]: ctx.runMgr.id,
+		'namzu.runtime.cleared': plan.clearedCount,
+		'namzu.runtime.chars_reclaimed': plan.charsReclaimed,
+		'namzu.runtime.reclaimed_tokens': plan.reclaimedTokens,
+	})
+
+	await ctx.emitEvent?.({
+		type: 'compaction_tool_results_cleared',
+		runId: ctx.runMgr.id,
+		iteration: ctx.runMgr.currentIteration,
+		clearedCount: plan.clearedCount,
+		charsReclaimed: plan.charsReclaimed,
+		reclaimedTokens: plan.reclaimedTokens,
+		reliefWasEnough: plan.reliefWasEnough,
+	})
+}
+
+/** Install a clear-only pass and publish the state it established. */
+async function commitToolResultClear(
+	ctx: IterationContext,
+	plan: ToolResultClearPlan,
+	contextWindowTokens: number,
+	windowSource: 'config' | 'provider' | 'model-table' | 'default',
+): Promise<void> {
+	installMessages(ctx.runMgr.messages, plan.messages)
+	// The provider counted the pre-edit prompt. Leaving that measurement live
+	// makes the next trigger compare the old prompt against the new history.
+	ctx.runMgr.clearLastPromptTokens?.()
+	await emitToolResultClear(ctx, plan)
+	await emitContextUsageSnapshot(ctx, estimateTokens(ctx), contextWindowTokens, windowSource)
+}
+
 /**
  * How full the context is, in tokens.
  *
@@ -335,8 +407,7 @@ async function applyReducer(
 
 	await recordShed(ctx, [...messages], next, reduction.reason)
 
-	messages.length = 0
-	for (const message of next) messages.push(message)
+	installMessages(messages, next)
 
 	// The provider's count described the pre-reduction prompt. Same reasoning
 	// as the structured path: leaving it would have the next trigger check
@@ -360,6 +431,7 @@ async function applyReducer(
 	//
 	// Found by a test written for the decline paths asserting that success does
 	// NOT report a failure, which is the only reason anybody looked here.
+	const tokensAfter = estimateTokens(ctx)
 	await ctx.emitEvent?.({
 		type: 'compaction_completed',
 		runId: ctx.runMgr.id,
@@ -367,11 +439,17 @@ async function applyReducer(
 		messagesBefore: before,
 		messagesAfter: messages.length,
 		tokensBefore: reduction.estimatedTokens,
-		tokensAfter: estimateMessageTokens(messages),
+		tokensAfter,
 		measuredBy: measurement.measuredBy,
 		contextWindowTokens: reduction.contextWindowTokens,
 		windowSource: measurement.windowSource,
 	})
+	await emitContextUsageSnapshot(
+		ctx,
+		tokensAfter,
+		reduction.contextWindowTokens,
+		measurement.windowSource,
+	)
 }
 
 /**
@@ -502,46 +580,22 @@ export async function runCompactionCheck(
 	})
 
 	if (clearPlan.kind === 'cleared') {
-		// Element-wise, not a rebuild: the edit is length-preserving by
-		// construction (only `content` changes), so writing entries back
-		// keeps the live array identity the rest of the run holds.
-		const live = ctx.runMgr.messages
-		clearPlan.messages.forEach((msg, i) => {
-			live[i] = msg
-		})
-
-		ctx.log.info('Cleared stale tool results instead of compacting', {
-			[NAMZU.RUN_ID]: ctx.runMgr.id,
-			'namzu.runtime.cleared': clearPlan.clearedCount,
-			'namzu.runtime.chars_reclaimed': clearPlan.charsReclaimed,
-			'namzu.runtime.reclaimed_tokens': clearPlan.reclaimedTokens,
-		})
-
-		// Emitted BEFORE the return so the insufficient branch is not the
-		// silent one: a clear that fell through to summarization edited the
-		// history exactly as much as one that did not.
-		await ctx.emitEvent?.({
-			type: 'compaction_tool_results_cleared',
-			runId: ctx.runMgr.id,
-			iteration: ctx.runMgr.currentIteration,
-			clearedCount: clearPlan.clearedCount,
-			charsReclaimed: clearPlan.charsReclaimed,
-			reclaimedTokens: clearPlan.reclaimedTokens,
-			reliefWasEnough: clearPlan.reliefWasEnough,
-		})
-
 		// If that was enough, stop here and keep the history verbatim. The
 		// measurement is an estimate either way; the provider's own count for
 		// the NEXT turn will correct it, and an over-eager summarization is
 		// far more costly than one late pass.
-		if (clearPlan.reliefWasEnough) return
+		if (clearPlan.reliefWasEnough) {
+			await commitToolResultClear(ctx, clearPlan, budget, window.source)
+			return
+		}
 	}
 
-	// Second call, over the history the clear above may have just edited.
-	// `skipToolResultClear` because that step already ran and installed its
-	// result; asking again would clear nothing and say so as a `cleared`
-	// with a zero count, which is a shape this branch would have to ignore.
-	const messages = ctx.runMgr.messages
+	// Second call, over the cleared CANDIDATE when there is one. An
+	// insufficient clear stays off the live Run until summary verification
+	// succeeds. If that side call stalls, fails or is cancelled, the run keeps
+	// one coherent pre-edit history instead of publishing half a pass.
+	const stagedClear = clearPlan.kind === 'cleared' ? clearPlan : undefined
+	const messages = stagedClear?.messages ?? ctx.runMgr.messages
 	const plan = planCompaction({
 		messages,
 		config,
@@ -579,6 +633,12 @@ export async function runCompactionCheck(
 					break
 			}
 		}
+		// Clearing may have been useful even though no safe summary cut exists.
+		// There is no opaque provider wait on this path, so publish that single
+		// complete edit now rather than discarding it.
+		if (stagedClear) {
+			await commitToolResultClear(ctx, stagedClear, budget, window.source)
+		}
 		return
 	}
 
@@ -593,7 +653,7 @@ export async function runCompactionCheck(
 		// to a cheap model while the bill is written against the expensive one
 		// is a mistake with no symptom.
 		const compactionModel = resolveTaskModel('compaction', ctx.taskRouter, ctx.runConfig.model)
-		compactedContent = await buildVerifiedSummary(
+		compactedContent = await buildVerifiedSummaryWithBoundedProvider(
 			manager,
 			olderMessages as Message[],
 			ctx.provider,
@@ -610,6 +670,7 @@ export async function runCompactionCheck(
 			// been accepted, validated and threaded through four types since it
 			// was added, and nothing ever consulted it.
 			compactionModel,
+			ctx.abortController.signal,
 		)
 	} else {
 		compactedContent = serializeState(manager.getState())
@@ -617,13 +678,14 @@ export async function runCompactionCheck(
 
 	const compactionMessage = buildCompactionMessage(compactedContent)
 
-	// Drop any PRIOR `[COMPACTED CONTEXT]` summary from the leading floor —
-	// `serializeState` is cumulative, so the new summary supersedes it.
-	// Without this the never-trimmed floor accumulates one redundant summary
-	// per pass, unbounded. Unconditional now, for the reason given at the
-	// thrash guard above.
+	// Drop a replaceable PRIOR `[COMPACTED CONTEXT]` summary from this run's
+	// leading floor — `serializeState` is cumulative, so the new summary
+	// supersedes it. A retained summary came from outside this manager's state
+	// horizon (for example a host-triggered pass between runs) and remains
+	// opaque; deleting it would erase the only surviving record of that span.
 	const preservedSystem = systemMessages.filter(
-		(m) => !isCompactionMessage(typeof m.content === 'string' ? m.content : null),
+		(m) =>
+			!isCompactionMessage(typeof m.content === 'string' ? m.content : null) || m.retain === true,
 	)
 
 	// Pinned turns from the older window survive verbatim, in order, between
@@ -660,13 +722,11 @@ export async function runCompactionCheck(
 		}
 	}
 
-	const oldCount = messages.length
-	await recordShed(ctx, [...messages], newMessages, options?.force ? 'overflow' : 'threshold')
+	const live = ctx.runMgr.messages
+	const oldCount = live.length
+	await recordShed(ctx, [...live], newMessages, options?.force ? 'overflow' : 'threshold')
 
-	messages.length = 0
-	for (const msg of newMessages) {
-		messages.push(msg)
-	}
+	installMessages(live, newMessages)
 
 	const newEstimate = estimateTokens(ctx)
 
@@ -676,6 +736,10 @@ export async function runCompactionCheck(
 	// trigger check does not compare the old prompt size against the new
 	// context and compact again immediately.
 	ctx.runMgr.clearLastPromptTokens?.()
+	// The clear and the summary were one staged state transition. Publish the
+	// clear first for chronological audit semantics, but only now that both
+	// edits are installed and no verifier can still fail between them.
+	if (stagedClear) await emitToolResultClear(ctx, stagedClear)
 
 	// Hysteresis. A pass that only gets the context from 0.72 to 0.71 of the
 	// window leaves the trigger armed, so the next iteration compacts again
@@ -697,8 +761,8 @@ export async function runCompactionCheck(
 	ctx.log.info('Context compacted', {
 		[NAMZU.RUN_ID]: ctx.runMgr.id,
 		'namzu.runtime.old_message_count': oldCount,
-		'namzu.runtime.new_message_count': messages.length,
-		'namzu.runtime.removed_messages': oldCount - messages.length,
+		'namzu.runtime.new_message_count': live.length,
+		'namzu.runtime.removed_messages': oldCount - live.length,
 		'namzu.runtime.old_token_estimate': estimatedTokens,
 		'namzu.runtime.new_token_estimate': newEstimate,
 		'namzu.runtime.reduction_percent': Math.round((1 - newEstimate / estimatedTokens) * 100),
@@ -714,7 +778,7 @@ export async function runCompactionCheck(
 		runId: ctx.runMgr.id,
 		iteration: ctx.runMgr.currentIteration,
 		messagesBefore: oldCount,
-		messagesAfter: messages.length,
+		messagesAfter: live.length,
 		tokensBefore: estimatedTokens,
 		tokensAfter: newEstimate,
 		measuredBy: measured.source,
@@ -722,4 +786,5 @@ export async function runCompactionCheck(
 		windowSource: window.source,
 		reachedResetThreshold: reachedReset,
 	})
+	await emitContextUsageSnapshot(ctx, newEstimate, budget, window.source)
 }

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

@@ -37,6 +37,7 @@ import type { CheckpointManager } from '../../checkpoint.js'
 import type { EmitEvent } from '../../events.js'
 import type { ToolExecutor } from '../../executor.js'
 import type { GuardCoordinator } from '../../guard.js'
+import type { ProjectInstructionContext } from '../../project-instructions.js'
 import type { RepeatCallTracker } from '../../repeat-call.js'
 import type { SteeringChannel } from '../../steering.js'
 import type { ToolGrantSet } from '../../tool-grants.js'
@@ -181,6 +182,9 @@ export interface IterationContext {
 	 */
 	readonly inboundMessages?: () => readonly import('../../../../types/message/index.js').Message[]
 
+	/** Live project policy; separate from human inbound continuation. */
+	readonly projectInstructionContext?: ProjectInstructionContext
+
 	readonly workingStateManager?: WorkingStateManager
 
 	/**

package/src/runtime/query/iteration/phases/tool-review.ts

@@ -2,6 +2,10 @@ import type { AuthorizationGate } from '../../../../authorization/index.js'
 import type { ChatCompletionResponse } from '../../../../types/provider/index.js'
 import type { RunEvent } from '../../../../types/run/index.js'
 import type { ToolCallDenials } from '../../executor.js'
+import {
+	awaitProjectInstructionCallback,
+	replaceProjectInstructionSnapshot,
+} from '../../project-instructions.js'
 import { attachRepeatNotice } from '../../repeat-call.js'
 import { attachSteering } from '../../steering.js'
 import { type IterationContext, awaitDecisionDurably } from './context.js'
@@ -100,6 +104,30 @@ export async function* runToolReview(
 		for (const msg of attachRepeatNotice(attachSteering(batch.messages, ctx.steering), notices)) {
 			ctx.runMgr.pushMessage(msg)
 		}
+		// The complete tool-result batch is already in history before host policy
+		// may react, so a replacement cannot split provider-required adjacency.
+		// Commit each accepted observation before entering the next one. A single
+		// batch-end drain loses the accepted prefix when a later observer aborts.
+		// Nested registry dispatches are carried in this same ordered list.
+		if (ctx.projectInstructionContext) {
+			for (const observation of batch.observations) {
+				const signal = ctx.abortController.signal
+				const snapshot = await awaitProjectInstructionCallback(signal, () =>
+					ctx.projectInstructionContext?.observeToolResult(observation, {
+						messages: [...ctx.runMgr.messages],
+						signal,
+					}),
+				)
+				// Callback settlement and snapshot publication are distinct
+				// microtasks. Authority may be withdrawn between them.
+				signal.throwIfAborted()
+				if (snapshot !== undefined) {
+					ctx.runMgr.replaceMessages(
+						replaceProjectInstructionSnapshot(ctx.runMgr.messages, snapshot),
+					)
+				}
+			}
+		}
 	}
 
 	/** Every call denied for the same reason (human rejection, gate stop). */

package/src/runtime/query/iteration/stream-turn.ts

@@ -219,6 +219,7 @@ export async function* streamProviderTurn(
 	// them, and are collected verbatim: they are evidence, so reordering or
 	// de-duplicating them would edit the record the reader checks against.
 	const citations: Citation[] = []
+	let replayState: unknown
 
 	let streamError: string | undefined
 	let streamCause: unknown
@@ -310,6 +311,7 @@ export async function* streamProviderTurn(
 				break
 			}
 			if (!id && chunk.id) id = chunk.id
+			if (chunk.replayState !== undefined) replayState = chunk.replayState
 
 			// The first delta of the turn, of ANY kind — text, reasoning or a
 			// tool call. namzu streams, so perceived latency is dominated by
@@ -686,6 +688,7 @@ export async function* streamProviderTurn(
 			content: textBuf.length > 0 ? textBuf : null,
 			toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
 			...(reasoningBlocks.length > 0 ? { reasoning: reasoningBlocks } : {}),
+			...(replayState !== undefined ? { replayState } : {}),
 			...(citations.length > 0 ? { citations } : {}),
 		},
 		finishReason: effectiveFinishReason,