@namzu/sdk 38.2.1 → 39.0.0

package/src/runtime/query/file-evidence-context.ts

@@ -0,0 +1,65 @@
+import { resolve } from 'node:path'
+import { isClearedToolResult } from '../../compaction/tool-result-editing.js'
+import { fingerprintContent } from '../../tools/builtins/content-fingerprint.js'
+import { WriteFileTool } from '../../tools/builtins/write-file.js'
+import type { Message, ToolCall } from '../../types/message/index.js'
+import type { FileReadTracker } from '../../types/tool/index.js'
+
+/** Join visible call bodies, successful receipts and this executor's observation ledger. */
+export function describeVisibleFileEvidence(
+	messages: readonly Message[],
+	tracker: FileReadTracker,
+	workingDirectory: string,
+	sandboxed: boolean,
+): string | undefined {
+	// Execution-owned witnesses survive transparent wrappers; a name alone proves nothing.
+	if (!tracker.writeCallId || !tracker.fingerprint) return
+	const calls = new Map<string, ToolCall | null>()
+	const results = new Map<string, Message | null>()
+	for (const message of messages) {
+		if (message.role === 'assistant') {
+			for (const call of message.toolCalls ?? []) {
+				calls.set(call.id, calls.has(call.id) ? null : call)
+			}
+		} else if (message.role === 'tool') {
+			results.set(message.toolCallId, results.has(message.toolCallId) ? null : message)
+		}
+	}
+	const files = new Map<string, { path: string; bodyInCall: string; observedFingerprint: string }>()
+	for (const [id, call] of calls) {
+		const receipt = results.get(id)
+		if (
+			!call ||
+			call.function.name !== 'write' ||
+			call.metadata?.inputTruncated ||
+			call.function.arguments.length > 32_000 ||
+			id.length > 256 ||
+			!receipt ||
+			receipt.role !== 'tool' ||
+			receipt.isError ||
+			typeof receipt.content !== 'string' ||
+			isClearedToolResult(receipt.content)
+		)
+			continue
+		try {
+			const input = WriteFileTool.inputSchema.safeParse(JSON.parse(call.function.arguments))
+			if (!input.success || input.data.path.length > 512) continue
+			const body = input.data.content ?? input.data.newStr
+			if (typeof body !== 'string') continue
+			const key = sandboxed ? input.data.path : resolve(workingDirectory, input.data.path)
+			const fingerprint = fingerprintContent(body)
+			if (tracker.writeCallId(key) !== id || tracker.fingerprint(key) !== fingerprint) continue
+			files.delete(key)
+			files.set(key, {
+				path: input.data.path,
+				bodyInCall: id,
+				observedFingerprint: fingerprint,
+			})
+			if (files.size > 6) files.delete(files.keys().next().value as string)
+		} catch {
+			// Malformed retained inputs or a custom tracker cannot establish evidence.
+		}
+	}
+	if (files.size === 0) return
+	return `Visible file evidence (this request only): each complete body remains in the named successful write call and matches the latest conversation observation. Reuse that body for a targeted edit; a read solely to recall it is unnecessary. This is NOT a fresh disk check. Built-in edit/write still compare the disk body at mutation admission and refuse observed drift; on refusal inspect the current file and replan. Missing entries establish nothing.\n${JSON.stringify([...files.values()])}`
+}

package/src/runtime/query/guard.ts

@@ -83,6 +83,7 @@ export class GuardCoordinator {
 	 * on the RUN rather than on the process now hosting it.
 	 */
 	remainingBeforeFinalizeMs(): number {
+		if (this.limitConfig.timeoutMs === 0) return Number.POSITIVE_INFINITY
 		const finalizeAt = this.limitConfig.timeoutMs * this.limitConfig.budgetWarningThreshold
 		return Math.max(0, finalizeAt - (Date.now() - this.startTime))
 	}
@@ -96,6 +97,7 @@ export class GuardCoordinator {
 	 * deadline around such work instead of inventing a second clock.
 	 */
 	remainingUntilTimeoutMs(): number {
+		if (this.limitConfig.timeoutMs === 0) return Number.POSITIVE_INFINITY
 		return Math.max(0, this.limitConfig.timeoutMs - (Date.now() - this.startTime))
 	}
 

package/src/runtime/query/index.ts

@@ -139,10 +139,10 @@ import { ResultAssembler } from './result.js'
 import {
 	type PendingResumePlan,
 	applyPendingResume,
+	interruptedToolCalls,
 	planCrashResume,
 	planPendingResume,
 	recoverCompletedCalls,
-	unansweredToolCalls,
 } from './resume-pending.js'
 import {
 	acquireSandbox,
@@ -362,6 +362,14 @@ export interface QueryParams {
 	 * agent decides the rest is worth re-reading. Set `0` to disable.
 	 */
 	maxToolOutputChars?: number
+	/**
+	 * Smaller preview for text that exceeded maxToolOutputChars, after its full
+	 * host output and integrity manifest have been saved. Unset/0 keeps the old
+	 * preview size. Does not change the spill threshold, rich blocks or ordinary
+	 * results. A failed spill/manifest or a cap too small for its recovery path
+	 * retains the ordinary output budget. Re-supply on resume.
+	 */
+	retainedToolPreviewChars?: number
 
 	/**
 	 * Cap on the RICH channel of a single tool result, in base64 characters.
@@ -411,6 +419,7 @@ export interface QueryParams {
 	 *
 	 * Bounded by {@link maxAnswerReviews}. Never called on the forced-final
 	 * turn, which exists to extract a closing summary under pressure.
+	 * Exceptions or malformed verdicts fail the run; cancellation stops waiting.
 	 */
 	reviewAnswer?: ReviewAnswer
 
@@ -422,7 +431,7 @@ export interface QueryParams {
 	 */
 	promoteMemory?: PromoteMemory
 
-	/** Rejections allowed before the run stops. Default 3. */
+	/** Corrections allowed before the run stops. Nonnegative safe integer; default 3. Consumed rejections survive checkpoints. */
 	maxAnswerReviews?: number
 
 	/** Called with each completed step, as it completes. */
@@ -931,11 +940,10 @@ async function resolveProviderContextWindow(
 		onAbort = () => resolve(interrupted)
 		resolverSignal.addEventListener('abort', onAbort, { once: true })
 	})
-	// Wire and directory config validation already limit this field to one
-	// hour. The clamp also keeps a direct QueryParams caller from triggering
-	// Node's >2^31-1 one-millisecond timer coercion and turning a huge run
-	// budget into an immediate metadata fallback.
-	const deadlineMs = Math.min(Math.max(0, timeoutMs), 2_147_483_647)
+	// Direct QueryParams callers can supply a large run deadline. The clamp
+	// avoids Node's >2^31-1 one-millisecond timer coercion during metadata lookup.
+	// Metadata discovery remains optional and bounded even without a run deadline.
+	const deadlineMs = timeoutMs === 0 ? 5_000 : Math.min(Math.max(0, timeoutMs), 2_147_483_647)
 	const timer = setTimeout(() => {
 		deadline.abort(new Error(`Provider context-window lookup exceeded ${deadlineMs}ms`))
 	}, deadlineMs)
@@ -1707,10 +1715,24 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		? new AuthorizationGate(gateConfig, ctx.log)
 		: undefined
 
-	//  is null only when the run has no disk layout (tests,
-	// in-memory hosts); the budget then degrades to middle-elision.
-	const runDirForTools = ctx.runMgr.getRunDir()
-	const toolOutputDir = runDirForTools ? join(runDirForTools, TOOL_OUTPUT_DIR_NAME) : undefined
+	// The store is initialized when the async query starts, after tooling is
+	// composed. Resolve lazily at execution time: capturing getRunDir() here
+	// permanently disabled retention for fresh disk-backed invocations.
+	const toolOutputDir = () => {
+		const runDir = ctx.runMgr.getRunDir()
+		return runDir ? join(runDir, TOOL_OUTPUT_DIR_NAME) : undefined
+	}
+	// The same invocation-owned capability serves tools and optional preparation.
+	// Local cancellation cannot override the run's cancellation or settled state.
+	const captureRunEvidence = async (maxReadBytes?: number, signal?: AbortSignal) => {
+		const combined = signal
+			? AbortSignal.any([ctx.abortController.signal, signal])
+			: ctx.abortController.signal
+		combined.throwIfAborted()
+		const source = await eventTranslator.captureRunEvidence(maxReadBytes, combined)
+		combined.throwIfAborted()
+		return source
+	}
 
 	const toolExecutor = ToolingBootstrap.init(
 		{
@@ -1750,13 +1772,17 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 			...(params.maxToolOutputChars !== undefined
 				? { maxToolOutputChars: params.maxToolOutputChars }
 				: {}),
+			...(params.retainedToolPreviewChars !== undefined
+				? { retainedToolPreviewChars: params.retainedToolPreviewChars }
+				: {}),
 			...(params.maxToolContentBytes !== undefined
 				? { maxToolContentBytes: params.maxToolContentBytes }
 				: {}),
 			// Overflow lands beside the run's other artifacts, so it is
 			// cleaned up with the run and reachable by the model's own
 			// `read`/`grep` without a new affordance.
-			...(toolOutputDir ? { toolOutputDir } : {}),
+			toolOutputDir,
+			captureRunEvidence,
 			...(params.repairToolCall ? { repairToolCall: params.repairToolCall } : {}),
 			...(verificationGate ? { authorizationGate: verificationGate } : {}),
 			recordAudit: (input) => ctx.runMgr.recordAudit(input),
@@ -1930,6 +1956,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 					: undefined
 			return {
 				messages: ctx.runMgr.messages,
+				turn: iterationOrchestrator.getAdvisoryTurnContext(),
 				...(summary !== undefined ? { workingStateSummary: summary } : {}),
 				...(advisoryConfig.includeToolCatalog
 					? { toolCatalog: params.tools.toLLMTools(effectiveAllowedTools) }
@@ -1950,6 +1977,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 	}
 
 	const iterationOrchestrator = new IterationOrchestrator({
+		captureRunEvidence,
 		provider: resilientProvider,
 		providerCapabilities: capabilities,
 		strictCapabilities: params.strictCapabilities === true,
@@ -2294,23 +2322,19 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 						? planPendingResume(projectedCheckpoint, params.pendingDecision, ctx.log)
 						: null
 
-				// Results of tools that finished before the process died. The
-				// executor already emits one `tool_completed` per tool inline
-				// and the transcript already persists it, so the record was
-				// durable all along — it was simply never read back, and the
-				// resumed run re-ran calls that had already charged a card or
-				// sent an email.
-				const unanswered = unansweredToolCalls(projectedCheckpoint.messages)
+				// Recover completed observations and explicitly unknown outcomes.
+				// A recorded start is not proof that its external effect failed.
+				const unanswered = interruptedToolCalls(projectedCheckpoint.messages)
 				recoveredResults =
 					unanswered.length > 0
-						? await recoverCompletedCalls(ctx.runMgr, unanswered, ctx.log)
+						? await recoverCompletedCalls(ctx.runMgr, unanswered, ctx.log, {
+								answers: pendingResume?.answers,
+								signal: ctx.abortController.signal,
+							})
 						: new Map()
 
-				// A batch caught MID-execution is a resume, not a fresh
-				// decision: stripping the turn and letting the model re-decide
-				// would re-run everything that already ran. Only taken when
-				// the transcript proves execution had begun — a tool-review
-				// park has no completions and keeps the cheap repair below.
+				// Preserve both known and unknown outcomes before continuing calls
+				// whose absence of a start was established by a complete scan.
 				if (!pendingResume && recoveredResults.size > 0) {
 					pendingResume = planCrashResume(projectedCheckpoint, recoveredResults, ctx.log)
 				}