@namzu/sdk 49.0.0 → 50.0.0

package/src/runtime/query/durable-inbound.ts

@@ -0,0 +1,101 @@
+import type { TurnRecorder } from '../../manager/session/turn-recorder.js'
+import {
+	type DurableInboundSource,
+	type InboundDeliveryReceipt,
+	isInboundDeliveryRef,
+} from '../../types/message/inbound-delivery.js'
+import { isRuntimeContextMessageSource } from '../../types/message/index.js'
+
+/** Only an active writer can claim or acknowledge input for this turn. */
+async function assertWriter(recorder: TurnRecorder, signal: AbortSignal): Promise<void> {
+	signal.throwIfAborted()
+	const own = recorder.lease
+	const current = await recorder.log.lease()
+	const active = await recorder.log.activeTurn()
+	signal.throwIfAborted()
+	if (
+		!own ||
+		!current ||
+		own.fence !== current.fence ||
+		own.holder !== current.holder ||
+		active?.turnId !== recorder.turnId ||
+		active.state !== 'running' ||
+		active.ownerGen !== own.fence
+	) {
+		throw new Error('Durable input requires the current active session writer.')
+	}
+}
+
+/** Append normally, flush the recorder, then await the host's exact acknowledgement. */
+export async function deliverDurableInbound(
+	recorder: TurnRecorder,
+	source: DurableInboundSource | undefined,
+	signal: AbortSignal,
+): Promise<number> {
+	if (!source) return 0
+	await assertWriter(recorder, signal)
+	const supplied = await source.claim({
+		sessionId: recorder.sessionId,
+		turnId: recorder.turnId,
+		signal,
+	})
+	signal.throwIfAborted()
+	// Snapshot before the next await: the host retains its own objects.
+	// Never let mutation during a writer check or queued append
+	// change the payload or reference we subsequently acknowledge.
+	const claims = structuredClone(supplied).map((claim) => ({
+		...claim,
+		message: { ...claim.message, id: undefined },
+	}))
+	const seen = new Set<string>()
+	for (const claim of claims) {
+		if (
+			typeof claim.claimId !== 'string' ||
+			claim.claimId.length === 0 ||
+			claim.claimId.length > 512 ||
+			seen.has(claim.claimId) ||
+			!isInboundDeliveryRef(claim.ref) ||
+			claim.message?.role !== 'user' ||
+			typeof claim.message.content !== 'string'
+		) {
+			throw new Error('Invalid durable inbound claim.')
+		}
+		seen.add(claim.claimId)
+		const provenance: unknown = claim.message.source
+		if (!isRuntimeContextMessageSource(provenance) || provenance.kind === 'steering')
+			throw new Error('Durable input requires validated runtime context provenance.')
+		const ref = provenance.deliveryRef
+		if (
+			!ref ||
+			ref.namespace !== claim.ref.namespace ||
+			ref.id !== claim.ref.id ||
+			ref.digest !== claim.ref.digest
+		) {
+			throw new Error('Durable input provenance does not match its claim.')
+		}
+		// Restored IDs are never evidence for a fresh delivery. The recorder
+		// assigns the actual message record ID on this new, stampable object.
+	}
+	await assertWriter(recorder, signal)
+	if (claims.length === 0) return 0
+	for (const claim of claims) recorder.pushMessage(claim.message)
+	const through = await recorder.head()
+	if (!through) throw new Error('Durable input has no recorded session-log head.')
+	await assertWriter(recorder, signal)
+	const receipts: InboundDeliveryReceipt[] = claims.map((claim) => {
+		const messageId = recorder.recordedIdOf(claim.message)
+		if (!messageId || claim.message.id !== messageId)
+			throw new Error('Durable input was not recorded.')
+		return {
+			claimId: claim.claimId,
+			ref: Object.freeze({ ...claim.ref }),
+			sessionId: recorder.sessionId,
+			turnId: recorder.turnId,
+			messageId,
+			through: structuredClone(through),
+		}
+	})
+	await source.recorded(receipts)
+	await assertWriter(recorder, signal)
+	return claims.length
+}

package/src/runtime/query/events.ts

@@ -51,11 +51,26 @@ const PENDING_EVENT_SOFT_CAP = 1000
  */
 export class EventTranslator {
 	private pendingEvents: SessionEvent[] = []
+	private readonly pendingListeners = new Set<() => void>()
 	private readonly recorder: TurnRecorder
 	private probes: ProbeObservation
 	private droppedDeltaCount = 0
 	private readonly log: Logger
 
+	/** Wake an active tool-batch drain without polling or retaining event copies. */
+	onPendingEvents(listener: () => void): () => void {
+		this.pendingListeners.add(listener)
+		if (this.pendingEvents.length > 0) listener()
+		return () => {
+			this.pendingListeners.delete(listener)
+		}
+	}
+
+	private enqueue(event: SessionEvent): void {
+		this.pendingEvents.push(event)
+		for (const listener of this.pendingListeners) listener()
+	}
+
 	constructor(
 		recorder: TurnRecorder,
 		probeRegistry: ProbeObservation = defaultProbeRegistry,
@@ -178,7 +193,7 @@ export class EventTranslator {
 		// honest statement: nothing persists this, so a consumer must never
 		// advance a cursor to it.
 		if (isEphemeralEvent(event)) {
-			this.pendingEvents.push(event)
+			this.enqueue(event)
 			return
 		}
 
@@ -190,10 +205,10 @@ export class EventTranslator {
 			try {
 				entry = await this.recorder.appendEvent(event)
 			} catch (err) {
-				this.pendingEvents.push(event)
+				this.enqueue(event)
 				throw err
 			}
-			this.pendingEvents.push(
+			this.enqueue(
 				entry === undefined
 					? event
 					: ({ ...event, seq: entry.record.seq, generation: entry.record.gen } as SessionEvent),
@@ -208,7 +223,7 @@ export class EventTranslator {
 	async beginTurn(draft: TurnBeginDraft): Promise<void> {
 		await this.withLogLock(async () => {
 			const entry = await this.recorder.begin(draft)
-			this.pendingEvents.push(liveEventOf(entry))
+			this.enqueue(liveEventOf(entry))
 		})
 	}
 
@@ -216,7 +231,7 @@ export class EventTranslator {
 	async resumeTurn(fromCheckpointId: CheckpointId, resolvedDecisionId?: string): Promise<void> {
 		await this.withLogLock(async () => {
 			const entry = await this.recorder.resume(fromCheckpointId, resolvedDecisionId)
-			this.pendingEvents.push(liveEventOf(entry))
+			this.enqueue(liveEventOf(entry))
 		})
 	}
 
@@ -271,6 +286,7 @@ export class EventTranslator {
 						// "depends on nothing" from an emitter that predates these.
 						...(task.blockedBy.length > 0 ? { blockedBy: task.blockedBy } : {}),
 						...(task.owner !== undefined ? { owner: task.owner } : {}),
+						...(task.activeForm ? { activeForm: task.activeForm } : {}),
 					})
 					break
 				case 'task.updated':
@@ -282,6 +298,7 @@ export class EventTranslator {
 						subject: task.subject,
 						status: task.status,
 						owner: task.owner,
+						...(task.activeForm ? { activeForm: task.activeForm } : {}),
 						...(task.blockedBy.length > 0 ? { blockedBy: task.blockedBy } : {}),
 						...(event.type === 'task.deleted' ? { deleted: true as const } : {}),
 					})

package/src/runtime/query/executor/tool-call-admission.ts

@@ -5,6 +5,7 @@ import type { ToolCall, ToolInputError } from '../../../types/message/index.js'
 import type { PluginHookResult } from '../../../types/plugin/index.js'
 import type { ToolDefinition } from '../../../types/tool/index.js'
 import type { ToolCallRepair, ToolCallRepairReason } from '../../../types/tool/repair.js'
+import { awaitWithAbort } from '../../../utils/await-with-abort.js'
 import { toErrorMessage } from '../../../utils/error.js'
 import type { Logger } from '../../../utils/logger.js'
 import type {
@@ -71,30 +72,39 @@ export async function runPreToolHook(
 	input: unknown,
 	signal: AbortSignal = host.config.abortSignal,
 ): Promise<PreToolHookOutcome> {
+	signal.throwIfAborted()
 	if (!host.config.pluginManager) return { kind: 'continue', input, modified: false }
-	const results = await host.config.pluginManager.executeHooks(
-		'pre_tool_use',
-		{
-			sessionId: host.config.sessionId,
-			turnId: host.config.turnId,
-			toolName,
-			toolInput: input,
-			signal,
-		},
-		host.emitEvent,
+	const results = await awaitWithAbort(
+		host.config.pluginManager.executeHooks(
+			'pre_tool_use',
+			{
+				sessionId: host.config.sessionId,
+				turnId: host.config.turnId,
+				toolName,
+				toolInput: input,
+				signal,
+			},
+			host.emitEvent,
+		),
+		signal,
 	)
+	signal.throwIfAborted()
 	return interpretPreToolResults(toolName, input, results)
 }
 
 export async function prepareDirectCall(
 	host: ToolAdmissionHost,
 	toolCall: ToolCall,
+	providerInput = true,
 ): Promise<PreparedDirectCall> {
+	const signal = host.config.abortSignal
+	signal.throwIfAborted()
 	let toolName = toolCall.function.name
 	const truncationRepair =
 		toolCall.metadata?.inputTruncated === true
 			? await repairTruncatedCall(host, toolCall, toolName)
 			: null
+	signal.throwIfAborted()
 	if (toolCall.metadata?.inputTruncated === true && !truncationRepair) {
 		return {
 			kind: 'synthetic',
@@ -103,10 +113,11 @@ export async function prepareDirectCall(
 			input: {},
 			message: unreadableToolCallMessage(host, toolCall, toolName),
 			isError: true,
+			...(providerInput ? { inputFailure: unreadableCallFailure(toolCall) } : {}),
 		}
 	}
 
-	const prepare = host.config.tools.prepareExecution
+	const prepare = host.config.tools.prepareExecutionAsync ?? host.config.tools.prepareExecution
 	const executePrepared = host.config.tools.executePrepared
 	if (typeof prepare !== 'function' || typeof executePrepared !== 'function') {
 		const resolved = await resolveCall(
@@ -132,6 +143,9 @@ export async function prepareDirectCall(
 				input: {},
 				message: resolved.message,
 				isError: true,
+				...(providerInput && !truncationRepair && resolved.inputFailure
+					? { inputFailure: resolved.inputFailure }
+					: {}),
 			}
 		}
 		const preOutcome = await runPreToolHook(host, toolName, resolved.input)
@@ -143,6 +157,7 @@ export async function prepareDirectCall(
 				input: preOutcome.input,
 				message: preOutcome.output,
 				isError: preOutcome.kind === 'error',
+				...(preOutcome.kind === 'skip' ? { skipped: true as const } : {}),
 			}
 		}
 		if (!host.config.authorizationGate) {
@@ -151,6 +166,9 @@ export async function prepareDirectCall(
 				toolCall,
 				toolName,
 				input: preOutcome.input,
+				...(providerInput && !truncationRepair && !preOutcome.modified && resolved.inputFailure
+					? { inputFailure: resolved.inputFailure }
+					: {}),
 			}
 		}
 		return {
@@ -166,8 +184,9 @@ export async function prepareDirectCall(
 	let raw = truncationRepair?.arguments ?? toolCall.function.arguments
 	toolName = truncationRepair?.toolName ?? toolName
 	let repairUsed = truncationRepair !== null
-	let preparation: ReturnType<typeof prepare>
+	let preparation: Awaited<ReturnType<typeof prepare>>
 	for (;;) {
+		signal.throwIfAborted()
 		let parsed: unknown
 		try {
 			parsed = parseArguments(raw)
@@ -186,12 +205,22 @@ export async function prepareDirectCall(
 				raw = repair.arguments
 				continue
 			}
-			return { kind: 'synthetic', toolCall, toolName, input: {}, message, isError: true }
+			return {
+				kind: 'synthetic',
+				toolCall,
+				toolName,
+				input: {},
+				message,
+				isError: true,
+				...(providerInput && !repairUsed ? { inputFailure: 'invalid_json' as const } : {}),
+			}
 		}
 
 		try {
-			preparation = prepare.call(host.config.tools, toolName, parsed)
+			preparation = await prepare.call(host.config.tools, toolName, parsed, signal)
+			signal.throwIfAborted()
 		} catch (err) {
+			signal.throwIfAborted()
 			// A name the registry does not hold gets the step's list, not the
 			// registry's "Not found", which lists everything it holds.
 			const message = isUnregistered(host, toolName)
@@ -210,7 +239,23 @@ export async function prepareDirectCall(
 				raw = repair.arguments
 				continue
 			}
-			return { kind: 'synthetic', toolCall, toolName, input: parsed, message, isError: true }
+			return {
+				kind: 'synthetic',
+				toolCall,
+				toolName,
+				input: parsed,
+				message,
+				isError: true,
+				...(isUnregistered(host, toolName)
+					? {
+							facts: {
+								kind: 'failure' as const,
+								reason: 'unknown_tool' as const,
+								subject: toolName,
+							},
+						}
+					: {}),
+			}
 		}
 
 		if (preparation.success) break
@@ -235,6 +280,9 @@ export async function prepareDirectCall(
 			input: parsed,
 			message,
 			isError: true,
+			...(providerInput && !repairUsed && preparation.inputFailure
+				? { inputFailure: preparation.inputFailure }
+				: {}),
 		}
 	}
 
@@ -247,11 +295,13 @@ export async function prepareDirectCall(
 			input: preOutcome.input,
 			message: preOutcome.output,
 			isError: preOutcome.kind === 'error',
+			...(preOutcome.kind === 'skip' ? { skipped: true as const } : {}),
 		}
 	}
 
 	if (preOutcome.modified) {
-		const modified = prepare.call(host.config.tools, toolName, preOutcome.input)
+		const modified = await prepare.call(host.config.tools, toolName, preOutcome.input, signal)
+		signal.throwIfAborted()
 		if (!modified.success) {
 			return {
 				kind: 'synthetic',
@@ -342,7 +392,18 @@ export async function resolveCall(
 	host: ToolAdmissionHost,
 	toolCall: ToolCall,
 ): Promise<
-	{ ok: true; toolName: string; input: unknown } | { ok: false; toolName: string; message: string }
+	| {
+			ok: true
+			toolName: string
+			input: unknown
+			inputFailure?: 'schema_validation'
+	  }
+	| {
+			ok: false
+			toolName: string
+			message: string
+			inputFailure?: 'invalid_json'
+	  }
 > {
 	let toolName = toolCall.function.name
 	let raw = toolCall.function.arguments
@@ -361,9 +422,23 @@ export async function resolveCall(
 				failure.reason === 'invalid_json' ||
 				(failure.reason === 'unknown_tool' && isUnregistered(host, toolName))
 			) {
-				return { ok: false, toolName, message: failure.message }
+				return {
+					ok: false,
+					toolName,
+					message: failure.message,
+					...(attempt === 0 && failure.reason === 'invalid_json'
+						? { inputFailure: 'invalid_json' as const }
+						: {}),
+				}
+			}
+			return {
+				ok: true,
+				toolName,
+				input: parseArguments(raw),
+				...(attempt === 0 && failure.reason === 'schema_validation'
+					? { inputFailure: 'schema_validation' as const }
+					: {}),
 			}
-			return { ok: true, toolName, input: parseArguments(raw) }
 		}
 
 		host.log.info('Repaired a malformed tool call', {
@@ -379,11 +454,17 @@ export async function resolveCall(
 	}
 }
 
+/** The normalized unreadable flag covers both malformed and truncated arguments. */
+export function unreadableCallFailure(toolCall: ToolCall): 'invalid_json' | 'input_truncated' {
+	return toolCall.metadata?.inputError?.reason === 'malformed' ? 'invalid_json' : 'input_truncated'
+}
+
 export async function repairTruncatedCall(
 	host: ToolAdmissionHost,
 	toolCall: ToolCall,
 	toolName: string,
 ): Promise<ToolCallRepair | null> {
+	host.config.abortSignal.throwIfAborted()
 	if (!host.config.repairToolCall) return null
 
 	// Present the PARTIAL buffer, not the normalized `"{}"` — a repairer
@@ -393,7 +474,10 @@ export async function repairTruncatedCall(
 		host,
 		{ ...toolCall, function: { ...toolCall.function, arguments: partial } },
 		toolName,
-		{ reason: 'invalid_json', message: unreadableToolCallMessage(host, toolCall, toolName) },
+		{
+			reason: 'invalid_json',
+			message: unreadableToolCallMessage(host, toolCall, toolName),
+		},
 	)
 	if (repair) {
 		// Unreadable is not the same as cut off: the reason says which.
@@ -469,24 +553,33 @@ async function requestRepair(
 	toolName: string,
 	failure: { reason: ToolCallRepairReason; message: string },
 ): Promise<ToolCallRepair | null> {
+	host.config.abortSignal.throwIfAborted()
 	const repairToolCall = host.config.repairToolCall
 	if (!repairToolCall) return null
 
 	const tool = host.config.tools.get(toolName)
 	try {
-		return await repairToolCall({
-			toolCall,
-			reason: failure.reason,
-			message: failure.message,
-			...(tool
-				? {
-						tool,
-						jsonSchema: tool.modelInputSchema ?? renderToolSchema(tool.inputSchema),
-					}
-				: {}),
-			availableTools: host.config.tools.listNames(),
-		})
+		const repair = await awaitWithAbort(
+			Promise.resolve(
+				repairToolCall({
+					toolCall,
+					reason: failure.reason,
+					message: failure.message,
+					...(tool
+						? {
+								tool,
+								jsonSchema: tool.modelInputSchema ?? renderToolSchema(tool.inputSchema),
+							}
+						: {}),
+					availableTools: host.config.tools.listNames(),
+				}),
+			),
+			host.config.abortSignal,
+		)
+		host.config.abortSignal.throwIfAborted()
+		return repair
 	} catch (err) {
+		host.config.abortSignal.throwIfAborted()
 		// A broken repairer must not turn a recoverable tool error into a
 		// failed turn: the original error is still a perfectly good answer
 		// to give the model.