@namzu/sdk 48.3.1 → 50.0.0

package/src/runtime/query/index.ts

@@ -59,6 +59,7 @@ import {
 import type { CheckpointId, MessageId, SessionId, TenantId } from '../../types/ids/index.js'
 import type { InvocationState } from '../../types/invocation/index.js'
 import type { MemoryStore } from '../../types/memory/index.js'
+import type { DurableInboundSource } from '../../types/message/inbound-delivery.js'
 import {
 	type AssistantMessage,
 	type Message,
@@ -264,6 +265,12 @@ export interface QueryParams {
 	 * finishes.
 	 */
 	backgroundJobOwner?: string
+	/**
+	 * Called with job ids only when their exit notices enter model context:
+	 * a tool result or a recorded job-exit message. An exit event alone does not
+	 * mean the model saw it. A host can carry unacknowledged exits to its next turn.
+	 */
+	onJobNoticeDelivered?: (jobIds: readonly string[]) => void
 
 	/**
 	 * What else goes in this turn's prompt.
@@ -727,6 +734,9 @@ export interface QueryParams {
 	 */
 	waitForInbound?: (signal: AbortSignal) => Promise<void>
 
+	/** Durable host input: normal append, flush and exact acknowledgement before inference. Requires sessionLog. */
+	durableInbound?: DurableInboundSource
+
 	/**
 	 * Live project policy for this turn. Unlike `inboundMessages`, snapshot
 	 * replacement is durable state and never implies another model turn.
@@ -950,6 +960,9 @@ function withOwnedResumeOutcomes(
 }
 
 export async function* query(params: QueryParams): AsyncGenerator<SessionEvent, Turn> {
+	if (params.durableInbound && !params.sessionLog) {
+		throw new Error('durableInbound requires an explicit sessionLog and its active writer.')
+	}
 	const prepared = await prepareTurn(params)
 	const {
 		turnConfig,
@@ -1138,9 +1151,11 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 		// invalidate the whole prompt cache for the rest of the turn — the same
 		// reason the forced-final turn keeps its tools array and uses
 		// `toolChoice: 'none'` instead of dropping it.
-		if (params.structuredOutput && params.structuredOutput.mode !== 'native') {
-			addRuntimeTool(createStructuredOutputTool(params.structuredOutput.schema), 'active')
-		}
+		const structuredOutputTool =
+			params.structuredOutput && params.structuredOutput.mode !== 'native'
+				? createStructuredOutputTool(params.structuredOutput.schema)
+				: undefined
+		if (structuredOutputTool) addRuntimeTool(structuredOutputTool, 'active')
 
 		for (const tool of advisoryToolDefs) addRuntimeTool(tool, 'active')
 
@@ -1319,6 +1334,20 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 		// subscription that fills it below, because the wait-intent recorder needs
 		// to ask whether its text has been read yet.
 		const jobNotices = params.backgroundJobs ? new SteeringBinding() : undefined
+		const pendingJobNoticeIds = new Set<string>()
+		const acknowledgeJobNotices = () => {
+			if (pendingJobNoticeIds.size === 0) return
+			const ids = [...pendingJobNoticeIds]
+			pendingJobNoticeIds.clear()
+			try {
+				params.onJobNoticeDelivered?.(ids)
+			} catch (error) {
+				// A host observer cannot retract model-visible context or fail the turn.
+				ctx.log.warn('A background job notice observer failed', {
+					'exception.message': error instanceof Error ? error.message : String(error),
+				})
+			}
+		}
 		// Jobs the model told `wait_for_job` it is waiting on, which is the only
 		// thing that can hold this turn open for a job. Built only where there is a
 		// registry, so a host with no background mode carries no recorder and the
@@ -1336,6 +1365,9 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			{
 				skillGrants,
 				tools: toolManager,
+				...(params.structuredOutput?.toolResultRetention === 'durable' && structuredOutputTool
+					? { durableStructuredOutputTool: structuredOutputTool }
+					: {}),
 				sessionId: ctx.sessionId,
 				turnId: ctx.turnId,
 				workingDirectory: ctx.cwd,
@@ -1425,6 +1457,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			jobNotices?.steer(
 				`Background job ${job.id} (${job.command}) ${outcome}. Read its output with the job tool if you need it.`,
 			)
+			pendingJobNoticeIds.add(job.id)
 			void eventTranslator
 				.emitEvent({
 					type: 'background_job_exited',
@@ -1463,6 +1496,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			basePrompt: params.basePrompt,
 			tools: toolManager,
 			allowedTools: effectiveAllowedTools,
+			sandboxed: params.sandboxProvider !== undefined,
 			runtimeContext: params.runtimeContext,
 			contributions: promptContributions,
 		})
@@ -1567,12 +1601,14 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 				: {}),
 			tools: toolManager,
 			allowedTools: effectiveAllowedTools,
+			showDeferredToolContext: params.contextLevel !== 'minimal',
 			recorder: ctx.recorder,
 			toolExecutor,
 			guard,
 			activityStore: ctx.activityStore,
 			emitEvent: eventTranslator.emitEvent,
 			drainPending: () => eventTranslator.drainPending(),
+			onPendingEvents: (listener) => eventTranslator.onPendingEvents(listener),
 			abortController: ctx.abortController,
 			log: ctx.log,
 			// Read through the box on every call, so a swap lands on the next
@@ -1582,6 +1618,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			promptContributions,
 			...(params.steering ? { steering: params.steering } : {}),
 			...(jobNotices ? { jobNotices } : {}),
+			...(jobNotices ? { onJobNoticeDelivered: acknowledgeJobNotices } : {}),
 			...(awaitedJobs ? { awaitedJobs } : {}),
 			checkpointMgr,
 			planManager: ctx.planManager,
@@ -1599,6 +1636,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			...(params.repeatCallAdvisory === false ? {} : { repeatCalls: new RepeatCallTracker() }),
 			compactionConfig,
 			...(params.inboundMessages ? { inboundMessages: params.inboundMessages } : {}),
+			...(params.durableInbound ? { durableInbound: params.durableInbound } : {}),
 			...(params.resumeFromCheckpoint ? { resumedInput: queuedForThisRun } : {}),
 			...(params.waitForInbound ? { waitForInbound: params.waitForInbound } : {}),
 			...(params.projectInstructionContext
@@ -1807,7 +1845,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 					if (annotations.length > 0) {
 						promptContributions.replace({
 							id: 'hooks:user_prompt_submit',
-							placement: 'dynamic',
+							placement: 'context',
 							render: () => `Context from the operator's hooks:\n\n${annotations.join('\n\n')}`,
 						})
 					}
@@ -1822,6 +1860,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 					basePrompt: contextLevel === 'full' ? params.basePrompt : undefined,
 					tools: toolManager,
 					allowedTools: effectiveAllowedTools,
+					sandboxed: params.sandboxProvider !== undefined,
 					runtimeContext: params.runtimeContext,
 					contributions: promptContributions,
 				}
@@ -2125,6 +2164,9 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 				// boundaries are not all cooperative and must not regain withdrawn
 				// authority merely because the turn record still had to be created.
 				ctx.abortController.signal.throwIfAborted()
+				// A restored assistant/tool pair cannot be split by a user-role arrival.
+				// Its pending results are applied below, before the loop drains input.
+				if (!pendingResume) await iterationOrchestrator.deliverInitialDurable()
 
 				// Handed over here, and the position is load-bearing in three
 				// directions. It has to follow `wirePlanManager`, or a host that
@@ -2387,13 +2429,14 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 						}
 					}
 
-					await applyPendingResume(
+					const resumedBatch = await applyPendingResume(
 						pendingResume,
 						ctx.recorder,
 						toolExecutor,
 						recoveredResults,
 						pendingResumeAssistantId,
 					)
+					iterationOrchestrator.setResumedToolResults(resumedBatch.results)
 					yield* eventTranslator.drainPending()
 				}