@namzu/sdk 1.3.0 → 2.0.0

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

@@ -6,6 +6,7 @@ import { GENAI, NAMZU, agentIterationSpanName } from '../../../telemetry/attribu
 import { getTracer } from '../../../telemetry/runtime-accessors.js'
 import { createAssistantMessage, createUserMessage } from '../../../types/message/index.js'
 import type { RunEvent, StopReason } from '../../../types/run/index.js'
+import type { LLMToolSchema, ToolRegistryContract } from '../../../types/tool/index.js'
 import { toErrorMessage } from '../../../utils/error.js'
 import { generateMessageId } from '../../../utils/id.js'
 import { applyLifecycleHookResults } from '../plugin-hooks.js'
@@ -118,6 +119,7 @@ export class IterationOrchestrator {
 				// risks a 400 because the history still carries
 				// tool_use/tool_result blocks.
 				const openAITools = this.ctx.tools.toLLMTools(this.ctx.allowedTools)
+				const enforceToolInputSchema = enforcedModelInputToolNames(this.ctx.tools, openAITools)
 
 				const messages = forceFinalize
 					? [
@@ -152,6 +154,7 @@ export class IterationOrchestrator {
 						model,
 						messages,
 						tools: openAITools.length > 0 ? openAITools : undefined,
+						enforceToolInputSchema,
 						toolChoice: forceFinalize && openAITools.length > 0 ? 'none' : undefined,
 						temperature: runConfig.temperature,
 						maxTokens: runConfig.maxResponseTokens,
@@ -428,11 +431,13 @@ export class IterationOrchestrator {
 			// 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 enforceToolInputSchema = enforcedModelInputToolNames(this.ctx.tools, finalTools)
 			const response = await collect(
 				this.ctx.provider.chatStream({
 					model,
 					messages: finalMessages,
 					tools: finalTools.length > 0 ? finalTools : undefined,
+					enforceToolInputSchema,
 					toolChoice: finalTools.length > 0 ? 'none' : undefined,
 					temperature: this.ctx.runConfig.temperature,
 					maxTokens: this.ctx.runConfig.maxResponseTokens,
@@ -471,3 +476,13 @@ export class IterationOrchestrator {
 		}
 	}
 }
+
+function enforcedModelInputToolNames(
+	registry: ToolRegistryContract,
+	tools: readonly LLMToolSchema[],
+): readonly string[] | undefined {
+	const names = tools
+		.map((tool) => tool.function.name)
+		.filter((name) => registry.get(name)?.enforceModelInput === true)
+	return names.length > 0 ? names : undefined
+}

package/src/runtime/query/iteration/phases/compaction-safe-cut.test.ts

@@ -0,0 +1,186 @@
+/**
+ * The UNBOUNDED CUT.
+ *
+ * `runCompactionCheck` snaps the naive recent-window boundary
+ * (`messages.length - keepRecentMessages`) FORWARD via `findSafeTrimIndex` so a
+ * tool pair is never split. But `findSafeTrimIndex` only ever walks forward, and
+ * its leading-`tool`-message skip has no stop short of `messages.length` — so
+ * whenever the whole suffix from the naive index to the end is `tool` messages,
+ * the cut lands ON `messages.length`, `recentMessages` comes back EMPTY, and
+ * `[...preservedSystem, compactionMessage]` replaces the ENTIRE recent window.
+ * What is left is a transcript with no non-system message at all.
+ *
+ * The shape that produces it: ONE assistant turn that fans out
+ * `>= keepRecentMessages` parallel tool calls, measured at the START of the next
+ * iteration — which is exactly where `runCompactionCheck` runs (iteration/index.ts,
+ * after `refreshWorkingMemory`, before the model call), i.e. immediately after
+ * those results were appended.
+ *
+ * The `olderMessages.length < 1` guard at :117 cannot fire: `olderMessages` is
+ * the whole transcript in exactly this situation.
+ *
+ * Symmetrically, when the naive index lands BELOW `systemMessages.length` the
+ * cut sits inside the system prefix and the leading prompts are duplicated into
+ * `recentMessages`.
+ *
+ * The invariant these tests pin is the one a cut taken AT OR BELOW naive gives
+ * for free: a pass never removes more than the naive cut would, so at least
+ * `keepRecentMessages` original messages survive verbatim — or, when no safe cut
+ * exists at all, the pass is skipped and the transcript is untouched.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import { WorkingStateManager } from '../../../../compaction/manager.js'
+import { CompactionConfigSchema } from '../../../../config/runtime.js'
+import type { RunId } from '../../../../types/ids/index.js'
+import {
+	type Message,
+	createAssistantMessage,
+	createSystemMessage,
+	createToolMessage,
+	createUserMessage,
+} from '../../../../types/message/index.js'
+import type { Logger } from '../../../../utils/logger.js'
+import { runCompactionCheck } from './compaction.js'
+import type { IterationContext } from './context.js'
+
+function makeLogger(): Logger {
+	const self = {
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		debug: vi.fn(),
+		child: vi.fn(),
+	} as unknown as Logger
+	;(self as { child: (ctx: unknown) => Logger }).child = vi.fn(() => self)
+	return self
+}
+
+/** Long enough that a handful of messages overflow a tiny budget. */
+const FILLER = 'x'.repeat(200)
+
+const KEEP_RECENT = 4
+
+function makeCtx(opts: {
+	messages: Message[]
+	contextWindowTokens?: number
+	tokenBudget?: number
+}): IterationContext {
+	const config = CompactionConfigSchema.parse({
+		strategy: 'structured',
+		llmVerification: false,
+		keepRecentMessages: KEEP_RECENT,
+		...(opts.contextWindowTokens !== undefined
+			? { contextWindowTokens: opts.contextWindowTokens }
+			: {}),
+	})
+	const manager = new WorkingStateManager(config)
+	manager.addDecision('built the report as .docx')
+
+	return {
+		runConfig: { tokenBudget: opts.tokenBudget ?? 0 },
+		compactionConfig: config,
+		workingStateManager: manager,
+		log: makeLogger(),
+		runMgr: {
+			id: 'run_1' as RunId,
+			currentIteration: 3,
+			messages: opts.messages,
+		},
+	} as unknown as IterationContext
+}
+
+function toolCall(id: string) {
+	return { id, type: 'function' as const, function: { name: 'read', arguments: '{}' } }
+}
+
+/** How many of the ORIGINAL messages survived the pass, by identity. */
+function survivorCount(before: readonly Message[], after: readonly Message[]): number {
+	const kept = new Set<Message>(after)
+	return before.filter((m) => kept.has(m)).length
+}
+
+/**
+ * The exact shape the iteration loop holds when `runCompactionCheck` runs: the
+ * user's turn, one assistant that fanned out four parallel tool calls, and the
+ * four results that just landed. The next thing that happens is the model call —
+ * with whatever this function leaves behind.
+ */
+function buildParallelFanOutTail(): Message[] {
+	return [
+		createSystemMessage(`STATIC SYSTEM PROMPT ${FILLER}`, 'cache'),
+		createUserMessage(`please rename the heading to Q3 ${FILLER}`),
+		createAssistantMessage(`reading the sources ${FILLER}`, [
+			toolCall('a'),
+			toolCall('b'),
+			toolCall('c'),
+			toolCall('d'),
+		]),
+		createToolMessage(`result a ${FILLER}`, 'a'),
+		createToolMessage(`result b ${FILLER}`, 'b'),
+		createToolMessage(`result c ${FILLER}`, 'c'),
+		createToolMessage(`result d ${FILLER}`, 'd'),
+	]
+}
+
+describe('compaction — the unbounded cut', () => {
+	it('keeps at least keepRecentMessages messages verbatim when the tail is a parallel tool fan-out', async () => {
+		const messages = buildParallelFanOutTail()
+		const before = [...messages]
+		const ctx = makeCtx({ messages, contextWindowTokens: 100 })
+
+		await runCompactionCheck(ctx)
+
+		expect(survivorCount(before, messages)).toBeGreaterThanOrEqual(KEEP_RECENT)
+	})
+
+	it('never leaves a system-only transcript (nothing for the next turn to answer)', async () => {
+		const messages = buildParallelFanOutTail()
+		const ctx = makeCtx({ messages, contextWindowTokens: 100 })
+
+		await runCompactionCheck(ctx)
+
+		const nonSystem = messages.filter((m) => m.role !== 'system')
+		expect(nonSystem.length).toBeGreaterThan(0)
+	})
+
+	it('skips the pass, leaving the transcript intact, when no safe cut exists at or below naive', async () => {
+		// System prefix, then a single assistant fanning out six parallel calls.
+		// Every candidate boundary at or below naive splits that one pair-set, so
+		// there is nothing safe to cut to — skipping beats deleting the turn.
+		const ids = ['a', 'b', 'c', 'd', 'e', 'f']
+		const messages: Message[] = [
+			createSystemMessage(`STATIC SYSTEM PROMPT ${FILLER}`, 'cache'),
+			createAssistantMessage(`fanning out ${FILLER}`, ids.map(toolCall)),
+			...ids.map((id) => createToolMessage(`result ${id} ${FILLER}`, id)),
+		]
+		const before = [...messages]
+		const ctx = makeCtx({ messages, contextWindowTokens: 100 })
+
+		await runCompactionCheck(ctx)
+
+		expect(messages).toEqual(before)
+	})
+
+	it('does not duplicate the leading system prompts when the naive cut lands inside them', async () => {
+		// Legacy (tokenBudget) path: five leading system messages and only three
+		// conversational ones, so naive = 8 - 4 = 4 < systemMessages.length = 5.
+		const messages: Message[] = [
+			createSystemMessage(`SYS-1 ${FILLER}`, 'cache'),
+			createSystemMessage(`SYS-2 ${FILLER}`),
+			createSystemMessage(`SYS-3 ${FILLER}`),
+			createSystemMessage(`SYS-4 ${FILLER}`),
+			createSystemMessage(`SYS-5 UNIQUE-MARKER ${FILLER}`),
+			createUserMessage(`user 0 ${FILLER}`),
+			createAssistantMessage(`assistant 0 ${FILLER}`),
+			createUserMessage(`user 1 ${FILLER}`),
+		]
+		const ctx = makeCtx({ messages, tokenBudget: 100 })
+
+		await runCompactionCheck(ctx)
+
+		const marker = messages.filter((m) => m.content?.includes('UNIQUE-MARKER'))
+		expect(marker).toHaveLength(1)
+	})
+})

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

@@ -94,18 +94,60 @@ export async function runCompactionCheck(ctx: IterationContext): Promise<void> {
 	}
 	if (systemMessages.length === 0) return
 
-	// Tool-pair atomicity guard. A naive cut at `length - keepRecentMessages`
-	// can land BETWEEN an assistant-with-toolCalls (which would be dropped into
-	// `olderMessages`) and its `tool` results (kept in `recentMessages`),
-	// leaving orphaned `tool_result` blocks at the head of the recent window.
-	// The Anthropic provider then emits a `tool_result` with no matching
-	// `tool_use` and the API rejects the next turn with a 400 — so compaction,
-	// whose whole job is to keep a long run alive, instead kills it. Snap the
-	// boundary FORWARD to a safe point (existing `findSafeTrimIndex`, previously
-	// only wired to the unused ConversationManager strategy classes) so no pair
-	// is split. Any message this moves out of the recent window is already
-	// represented in the extracted WorkingState the summary is built from.
-	const keepStart = findSafeTrimIndex(messages, messages.length - config.keepRecentMessages)
+	// Tool-pair atomicity guard, taken DOWNWARD.
+	//
+	// A naive cut at `length - keepRecentMessages` can land BETWEEN an
+	// assistant-with-toolCalls (dropped into `olderMessages`) and its `tool`
+	// results (kept in `recentMessages`), leaving orphaned `tool_result` blocks at
+	// the head of the recent window. The Anthropic provider then emits a
+	// `tool_result` with no matching `tool_use` and the API rejects the next turn
+	// with a 400 — so compaction, whose whole job is to keep a long run alive,
+	// instead kills it.
+	//
+	// Snapping FORWARD via `findSafeTrimIndex` fixes the orphan and introduces a
+	// worse failure. That walk skips leading `tool` messages with no stop short of
+	// `messages.length`, so whenever the entire suffix from the naive index is
+	// `tool` messages, the boundary lands ON `messages.length`: `recentMessages`
+	// comes back EMPTY and `[...preservedSystem, compactionMessage]` replaces the
+	// whole recent window. The model is then asked to answer a conversation whose
+	// last turn — including the user's own message — was deleted, and it answers a
+	// question nobody asked. The shape is routine, not exotic: one assistant turn
+	// fanning out `>= keepRecentMessages` parallel tool calls, measured at the
+	// start of the very next iteration, which is exactly where this runs. The
+	// `olderMessages` floor guard below cannot catch it either — in that shape
+	// `olderMessages` is the whole transcript.
+	//
+	// So take the LARGEST safe boundary AT OR BELOW naive instead. A cut that low
+	// removes no more than the naive cut would, so at least `keepRecentMessages`
+	// original messages always survive verbatim, and the transcript can never be
+	// reduced to system messages alone. `findSafeTrimIndex(m, k) === k` is the
+	// safety predicate — reused rather than reimplemented, so the function itself
+	// (public API, other callers) is untouched.
+	const naiveKeepStart = messages.length - config.keepRecentMessages
+	let keepStart = -1
+	for (let candidate = naiveKeepStart; candidate > systemMessages.length; candidate--) {
+		if (findSafeTrimIndex(messages, candidate) === candidate) {
+			keepStart = candidate
+			break
+		}
+	}
+
+	// No safe boundary at or below naive. Either every candidate splits a pair-set
+	// (one assistant fanning out more calls than the recent window holds), or naive
+	// itself sits inside the leading system prefix — which would otherwise
+	// duplicate those prompts into `recentMessages`. Skipping costs one iteration's
+	// worth of context headroom; cutting anyway costs the live turn. The condition
+	// is self-clearing: the next assistant message moves naive past the tool block.
+	if (keepStart < 0) {
+		ctx.log.debug('Skipping compaction — no safe cut at or below the naive boundary', {
+			runId: ctx.runMgr.id,
+			naiveKeepStart,
+			systemMessages: systemMessages.length,
+			messageCount: messages.length,
+		})
+		return
+	}
+
 	const recentMessages = messages.slice(keepStart)
 	const olderMessages = messages.slice(systemMessages.length, keepStart)
 

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

@@ -1,3 +1,4 @@
+import { isProviderRequestError } from '../../../provider/errors.js'
 import { mergeTokenUsage } from '../../../types/common/index.js'
 import type { ToolUseId } from '../../../types/ids/index.js'
 import type {
@@ -111,9 +112,12 @@ export async function* streamProviderTurn(
 			inputTruncated: boolean
 		}
 	>()
-	let streamError: string | undefined
+	let streamError: Error | undefined
 
-	const stream = provider.chatStream({ ...params, stream: true }) as AsyncIterable<StreamChunk>
+	const stream = provider.chatStream({
+		...params,
+		stream: true,
+	}) as AsyncIterable<StreamChunk>
 
 	// Drive the stream manually so each `.next()` can be RACED against the run
 	// abort: a Stop tears the in-flight model request down (the provider got
@@ -145,7 +149,7 @@ export async function* streamProviderTurn(
 			if (res.done) break
 			const chunk = res.value
 			if (chunk.error) {
-				streamError = chunk.error
+				streamError = new Error(`Provider stream error: ${chunk.error}`)
 				break
 			}
 			if (!id && chunk.id) id = chunk.id
@@ -252,7 +256,7 @@ export async function* streamProviderTurn(
 		// run as cancelled rather than recording a normal (errored) turn. Any
 		// other stream error is captured into the synthesized response as before.
 		if (signal?.aborted) throw err
-		streamError = err instanceof Error ? err.message : String(err)
+		streamError = err instanceof Error ? err : new Error(String(err))
 	} finally {
 		if (onAbort) signal?.removeEventListener('abort', onAbort)
 		// Release the underlying connection on every exit (natural end, error,
@@ -355,7 +359,7 @@ export async function* streamProviderTurn(
 		log.warn('provider stream failed after tool input; surfacing tool call to executor', {
 			runId,
 			iteration,
-			error: streamError,
+			error: streamError?.message ?? 'provider stream failed',
 			toolCallCount: toolCalls.length,
 		})
 	}
@@ -378,7 +382,8 @@ export async function* streamProviderTurn(
 	yield* drainPending()
 
 	if (streamError && !recoveredToolInputFromStreamError) {
-		throw new Error(`Provider stream error: ${streamError}`)
+		if (isProviderRequestError(streamError)) throw streamError
+		throw new Error(`Provider stream error: ${streamError.message}`)
 	}
 
 	const response: ChatCompletionResponse = {

package/src/runtime/query/result.ts

@@ -1,6 +1,7 @@
 import { type Span, SpanStatusCode } from '@opentelemetry/api'
 import type { PlanManager } from '../../manager/plan/lifecycle.js'
 import type { RunPersistence } from '../../manager/run/persistence.js'
+import { isProviderRequestError } from '../../provider/errors.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
 import { GENAI, NAMZU } from '../../telemetry/attributes.js'
 import type { Run, RunEvent } from '../../types/run/index.js'
@@ -61,7 +62,15 @@ export class ResultAssembler {
 	async *handleError(err: unknown, rootSpan: Span): AsyncGenerator<RunEvent> {
 		const { runMgr, planManager, log, emitEvent, drainPending } = this.config
 		const errorMessage = toErrorMessage(err)
-		runMgr.markFailed(errorMessage)
+		const providerError = isProviderRequestError(err)
+			? {
+					kind: err.kind,
+					providerId: err.providerId,
+					...(err.status !== undefined ? { status: err.status } : {}),
+					...(err.retryAfterMs !== undefined ? { retryAfterMs: err.retryAfterMs } : {}),
+				}
+			: undefined
+		runMgr.markFailed(errorMessage, providerError)
 
 		if (planManager.isActive) {
 			planManager.failPlan(errorMessage)
@@ -71,6 +80,7 @@ export class ResultAssembler {
 			type: 'run_failed',
 			runId: runMgr.id,
 			error: errorMessage,
+			...(providerError ? { providerError } : {}),
 		})
 		yield* drainPending()