@namzu/sdk 62.4.0 → 62.5.0

package/src/agents/runAgent.ts

@@ -13,7 +13,12 @@ import type { AuthorizationGateConfig } from '../types/authorization/index.js'
 import type { InputGuardrailSpec, OutputGuardrailSpec } from '../types/guardrail/index.js'
 import type { ProjectId, SessionId, TenantId, TopicId } from '../types/ids/index.js'
 import type { Message } from '../types/message/index.js'
-import type { LLMProvider, ReasoningEffort, ThinkingConfig } from '../types/provider/index.js'
+import type {
+	InferenceSpeed,
+	LLMProvider,
+	ReasoningEffort,
+	ThinkingConfig,
+} from '../types/provider/index.js'
 import type { SandboxProvider } from '../types/sandbox/index.js'
 import type { TurnConfig } from '../types/session/config.js'
 import type { SessionEventListener } from '../types/session/events.js'
@@ -202,6 +207,8 @@ export interface RunAgentOptions extends AgentIdentity {
 	 */
 	thinking?: ThinkingConfig
 	effort?: ReasoningEffort
+	/** Inference speed for every model call; see `TurnConfig.speed`. */
+	speed?: InferenceSpeed
 
 	/** Names the agent in traces and events. Defaults to `Agent`. */
 	name?: string
@@ -295,6 +302,7 @@ const RUN_AGENT_OPTION_ROUTES = {
 	structuredOutput: 'query',
 	thinking: 'special',
 	effort: 'special',
+	speed: 'turn',
 	name: 'special',
 	signal: 'query',
 	listener: 'special',

package/src/bridge/a2a/mapper.ts

@@ -152,9 +152,11 @@ const MAPPING: {
 					text:
 						e.outcome === 'fallback' && e.fallbackModel
 							? `${e.model} declined to answer; continuing on ${e.fallbackModel}`
-							: e.outcome === 'retry'
-								? `${e.model} stopped its reply; continuing once with that noted`
-								: `${e.model} declined to answer`,
+							: e.outcome === 'withheld'
+								? `${e.model} declined to answer; continuing once without the recorded context it carried`
+								: e.outcome === 'retry'
+									? `${e.model} stopped its reply; continuing once with that noted`
+									: `${e.model} declined to answer`,
 				},
 			],
 		}),

package/src/pricing/catalogue.generated.ts

@@ -49,6 +49,7 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					inputCostPer1M: 8,
 					outputCostPer1M: 40,
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.2, writeCostPer1M: 10 },
+					fastMultiplier: 2,
 				},
 			],
 			[
@@ -81,6 +82,7 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					inputCostPer1M: 8,
 					outputCostPer1M: 40,
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.2, writeCostPer1M: 10 },
+					fastMultiplier: 2,
 				},
 			],
 			[
@@ -121,6 +123,7 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					inputCostPer1M: 5,
 					outputCostPer1M: 25,
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.5, writeCostPer1M: 6.25 },
+					fastMultiplier: 2,
 				},
 			],
 			[
@@ -129,6 +132,7 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					inputCostPer1M: 5,
 					outputCostPer1M: 25,
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.5, writeCostPer1M: 6.25 },
+					fastMultiplier: 2,
 				},
 			],
 			[
@@ -137,6 +141,7 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					inputCostPer1M: 4,
 					outputCostPer1M: 20,
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.2, writeCostPer1M: 5 },
+					fastMultiplier: 2,
 				},
 			],
 			[

package/src/pricing/rates.source.json

@@ -19,6 +19,11 @@
 		"inference. Its turns are priced at zero, which is KNOWN-free and therefore",
 		"distinct from unknown. Such a vendor needs no model rows.",
 		"",
+		"fastMultiplier (optional) is the vendor's published multiple of every rate for",
+		"a request served in fast mode (verified 2026-11-10 against the fast-mode page:",
+		"2x on the full context window, stacking with cache pricing). A model without it",
+		"has no published fast price, so a fast request on it is reported as unpriced.",
+		"",
 		"Matching is EXACT on a normalised id (lowercased, one trailing -YYYYMMDD or",
 		"@YYYYMMDD snapshot suffix removed). Deliberately not prefix or substring:",
 		"within one vendor here, ids one character apart differ in price by 4x, so a",
@@ -66,14 +71,16 @@
 					"inputPer1M": 8,
 					"outputPer1M": 40,
 					"cacheReadPer1M": 0.2,
-					"cacheWritePer1M": 10
+					"cacheWritePer1M": 10,
+					"fastMultiplier": 2
 				},
 				{
 					"id": "claude-mythos-5-2",
 					"inputPer1M": 8,
 					"outputPer1M": 40,
 					"cacheReadPer1M": 0.2,
-					"cacheWritePer1M": 10
+					"cacheWritePer1M": 10,
+					"fastMultiplier": 2
 				},
 				{
 					"id": "claude-fable-5-1",
@@ -94,7 +101,8 @@
 					"inputPer1M": 4,
 					"outputPer1M": 20,
 					"cacheReadPer1M": 0.2,
-					"cacheWritePer1M": 5
+					"cacheWritePer1M": 5,
+					"fastMultiplier": 2
 				},
 				{
 					"id": "claude-sonnet-5-5",
@@ -122,14 +130,16 @@
 					"inputPer1M": 5,
 					"outputPer1M": 25,
 					"cacheReadPer1M": 0.5,
-					"cacheWritePer1M": 6.25
+					"cacheWritePer1M": 6.25,
+					"fastMultiplier": 2
 				},
 				{
 					"id": "claude-opus-4-8",
 					"inputPer1M": 5,
 					"outputPer1M": 25,
 					"cacheReadPer1M": 0.5,
-					"cacheWritePer1M": 6.25
+					"cacheWritePer1M": 6.25,
+					"fastMultiplier": 2
 				},
 				{
 					"id": "claude-opus-4-7",

package/src/provider/fallback.ts

@@ -22,10 +22,12 @@
  */
 
 import { GENAI } from '../constants/telemetry/index.js'
+import { DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES } from '../runtime/query/request-rich-content.js'
 import { classifyProviderError, isAbortError } from '../types/provider/errors.js'
 import type {
 	ChatCompletionParams,
 	LLMProvider,
+	ProviderCapabilities,
 	ReasoningEffort,
 	StreamChunk,
 	ThinkingConfig,
@@ -513,7 +515,7 @@ export function withProviderFallback(
 			return first.provider.name
 		},
 		get capabilities() {
-			return first.provider.capabilities
+			return chainCapabilities(members, first.provider.capabilities)
 		},
 		chatStream,
 		...(first.provider.listModels
@@ -604,3 +606,33 @@ export function withProviderFallback(
 			: {}),
 	} as LLMProvider
 }
+
+/**
+ * The head's declarations, with the request rich-content budget narrowed to
+ * what EVERY member can take: a request is built once and may be served by any
+ * of them, so a head with a large budget must not send a fallback more than it
+ * accepts. A member that declares nothing counts as the kernel default. When
+ * no member declares one the head's capabilities are returned untouched.
+ */
+function chainCapabilities(
+	members: readonly { readonly provider: Pick<LLMProvider, 'capabilities'> }[],
+	head: ProviderCapabilities | undefined,
+): ProviderCapabilities | undefined {
+	if (!members.some((m) => m.provider.capabilities?.maxRequestRichContentBytes !== undefined)) {
+		return head
+	}
+	const budget = Math.min(
+		...members.map(
+			(m) =>
+				m.provider.capabilities?.maxRequestRichContentBytes ??
+				DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+		),
+	)
+	return {
+		supportsTools: true,
+		supportsStreaming: true,
+		supportsFunctionCalling: true,
+		...head,
+		maxRequestRichContentBytes: budget,
+	}
+}

package/src/public-runtime.ts

@@ -478,7 +478,7 @@ export type {
 // did nothing.
 export { SESSION_MEMORY_TAG, createMemoryPromoter } from './turn/index.js'
 export type { MemoryPromoterOptions, SessionMemoryCategory } from './turn/index.js'
-export { createMemoryRecallStep } from './turn/memory-recall.js'
+export { createMemoryRecallStep, recalledMemoryIds } from './turn/memory-recall.js'
 export type {
 	MemoryRecallOptions,
 	MemorySelection,

package/src/runtime/query/index.ts

@@ -393,6 +393,29 @@ export interface QueryParams {
 	 */
 	refusalFallback?: 'auto' | 'off'
 
+	/**
+	 * Recorded-context keys (see `RecordedContextItem.key`) to leave out of the
+	 * request when the provider refuses it. On a refusal, before any model
+	 * fallback, the loop re-runs the step once with every entry filed under one
+	 * of these keys left out of the request. The history itself is not changed,
+	 * so nothing is lost for a later turn. The refused request is announced by a
+	 * `model_refusal` event with `outcome: 'withheld'`, and the steps that
+	 * follow, in this turn, see the keys in `PrepareStepContext.withheldKeys` so
+	 * a stage can stop adding what was just set aside. When the entries are
+	 * recalled memories the event carries their ids. A refusal of the retry
+	 * falls through to `refusalFallback` unchanged. Nothing happens when the
+	 * request carried no entry under a listed key. Absent means none.
+	 */
+	withholdOnRefusal?: readonly string[]
+
+	/**
+	 * Recorded-context keys to leave out of every request of this turn from the
+	 * first one, for a host that remembers an earlier `outcome: 'withheld'`
+	 * refusal and does not want the next turn refused again. History is not
+	 * changed. Seen by stages as `PrepareStepContext.withheldKeys`.
+	 */
+	withheldKeys?: readonly string[]
+
 	/**
 	 * Model-visible size cap for a single tool result. Over-budget output is
 	 * spilled to the turn directory and replaced with a head+tail preview
@@ -1918,6 +1941,10 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 				? { maxOutputContinuations: params.maxOutputContinuations }
 				: {}),
 			...(params.refusalFallback !== undefined ? { refusalFallback: params.refusalFallback } : {}),
+			...(params.withholdOnRefusal && params.withholdOnRefusal.length > 0
+				? { withholdOnRefusal: [...params.withholdOnRefusal] }
+				: {}),
+			withheldKeys: new Set(params.withheldKeys ?? []),
 			...(params.inboundMessages ? { inboundMessages: params.inboundMessages } : {}),
 			...(params.reminders ? { reminders: params.reminders } : {}),
 			...(params.durableInbound ? { durableInbound: params.durableInbound } : {}),

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

@@ -30,6 +30,7 @@ import {
 import { getTracer } from '../../../telemetry/runtime-accessors.js'
 import { STRUCTURED_OUTPUT_TOOL_NAME } from '../../../tools/builtins/structuredOutput.js'
 import type { ToolManager } from '../../../toolsets/manager.js'
+import { RECALLED_MEMORY_ENTRY_KEY, recalledMemoryIds } from '../../../turn/memory-recall.js'
 import type { CostInfo, TokenUsage } from '../../../types/common/index.js'
 import { NamzuError } from '../../../types/errors/index.js'
 import type { MessageId, SessionId, TurnId } from '../../../types/ids/index.js'
@@ -40,6 +41,8 @@ import {
 	createRuntimeContextMessage,
 	createSystemMessage,
 	createToolMessage,
+	turnContextEntries,
+	turnContextKey,
 } from '../../../types/message/index.js'
 import { classifyProviderError, readOutputOverflow } from '../../../types/provider/errors.js'
 import type { ChatCompletionResponse, ReasoningEffort } from '../../../types/provider/index.js'
@@ -69,10 +72,10 @@ import {
 	snapshotRequestContext,
 } from '../request-context.js'
 import {
-	DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
 	type RequestImageIdentity,
 	markProviderRejectedImage,
 	projectRequestRichContent,
+	resolveMaxRequestRichContentBytes,
 } from '../request-rich-content.js'
 import { withoutVoidAssistantTurns } from '../request-void-turns.js'
 import { formatSteeringNote, isOperatorUserMessage } from '../steering.js'
@@ -255,6 +258,20 @@ export class IterationOrchestrator {
 	}
 
 	/** Whether a request for `model` may carry images: the driver's catalogue and this run's own evidence agree. */
+	/**
+	 * The request rich-content budget, resolved each time it is read: the
+	 * caller's `turnConfig` override if one was given, else what the provider
+	 * serving now declares. Never written back into `turnConfig`, which would
+	 * turn the first provider's declaration into an override that a resumed
+	 * turn, a nested agent or a later provider then inherits.
+	 */
+	private richContentBudget(): number {
+		return resolveMaxRequestRichContentBytes(
+			this.ctx.turnConfig.maxRequestRichContentBytes,
+			this.ctx.provider.capabilities?.maxRequestRichContentBytes,
+		)
+	}
+
 	private modelReadsImages(model: string): boolean {
 		const serving = this.servingModel(model)
 		return (
@@ -332,6 +349,8 @@ export class IterationOrchestrator {
 	private refusalFallbackUsed = false
 	/** The request has already been re-run on the same model once this turn. */
 	private refusalRetryUsed = false
+	/** The request has already been re-run once without its withheld recorded entries. */
+	private refusalWithholdUsed = false
 	/**
 	 * `turn_end` (and, for a child, `subagent_stop`) fired when the model
 	 * finished and no hook asked for more. `finalizeTurn` then does not fire
@@ -898,7 +917,16 @@ export class IterationOrchestrator {
 							turnId: recorder.turnId,
 							memories: recalled,
 						})
-					const baseMessages = recorder.messages
+					const withheld = this.ctx.withheldKeys
+					// A withheld key is left out of the request only: the history keeps
+					// its entries, so a later turn or a restore still has them.
+					const baseMessages =
+						withheld && withheld.size > 0
+							? recorder.messages.filter((message) => {
+									const key = turnContextKey(message)
+									return key === undefined || !withheld.has(key)
+								})
+							: recorder.messages
 
 					// Step guidance is appended to the REQUEST, never pushed onto
 					// the turn's history: it applies to this step only, and pushing
@@ -967,8 +995,7 @@ export class IterationOrchestrator {
 					if (policyNotice) requestHistory.push(stepContextMessage(policyNotice))
 					const projected = projectRequestRichContent(
 						withoutVoidAssistantTurns(this.projectObservations(requestHistory)),
-						this.ctx.turnConfig.maxRequestRichContentBytes ??
-							DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+						this.richContentBudget(),
 						{ imagesReadable: this.modelReadsImages(stepModel) },
 					)
 					// Request-only data (the context contributions, notes about the
@@ -1197,6 +1224,7 @@ export class IterationOrchestrator {
 							cacheControl: { type: 'auto' },
 							...(turnConfig.thinking ? { thinking: turnConfig.thinking } : {}),
 							...(stepEffort ? { effort: stepEffort } : {}),
+							...(turnConfig.speed ? { speed: turnConfig.speed } : {}),
 							...(!forceFinalize && turnConfig.webSearch
 								? { webSearch: turnConfig.webSearch }
 								: {}),
@@ -3180,6 +3208,42 @@ export class IterationOrchestrator {
 			return 'settled'
 		}
 
+		const withholdKeys = this.ctx.withholdOnRefusal
+		if (
+			!input.forceFinalize &&
+			!this.refusalWithholdUsed &&
+			withholdKeys &&
+			this.ctx.withheldKeys
+		) {
+			const carried = withholdKeys.filter(
+				(key) =>
+					!this.ctx.withheldKeys?.has(key) &&
+					recorder.messages.some((message) => turnContextKey(message) === key),
+			)
+			if (carried.length > 0) {
+				this.refusalWithholdUsed = true
+				for (const key of carried) this.ctx.withheldKeys.add(key)
+				const memoryIds = carried.includes(RECALLED_MEMORY_ENTRY_KEY)
+					? recalledMemoryIds(turnContextEntries(recorder.messages, RECALLED_MEMORY_ENTRY_KEY))
+					: []
+				await this.ctx.emitEvent({
+					type: 'model_refusal',
+					turnId: recorder.turnId,
+					iteration: iterationNum,
+					model: servedBy.model,
+					providerId: servedBy.providerId,
+					outcome: 'withheld',
+					withheldKeys: carried,
+					...(memoryIds.length > 0 ? { withheldMemoryIds: memoryIds } : {}),
+					...(refusal.category ? { category: refusal.category } : {}),
+					...(refusal.explanation ? { explanation: refusal.explanation } : {}),
+				})
+				await closeIteration()
+				yield* this.ctx.drainPending()
+				return 'retry'
+			}
+		}
+
 		if (!input.forceFinalize && !this.refusalFallbackUsed && this.ctx.refusalFallback !== 'off') {
 			const next = await this.refusalFallbackModel(input.stepModel, refusal)
 			if (next !== undefined) {
@@ -3369,7 +3433,7 @@ export class IterationOrchestrator {
 			]
 			const finalMessages = projectRequestRichContent(
 				withoutVoidAssistantTurns(this.projectObservations(finalHistory)),
-				this.ctx.turnConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
+				this.richContentBudget(),
 				{ imagesReadable: this.modelReadsImages(model) },
 			)
 			// The closing directive is the last thing the model reads: after
@@ -3411,6 +3475,7 @@ export class IterationOrchestrator {
 				// is exactly the shape a field goes missing from — so it is tested
 				// separately rather than assumed to have been kept in step.
 				...(this.ctx.turnConfig.effort ? { effort: this.ctx.turnConfig.effort } : {}),
+				...(this.ctx.turnConfig.speed ? { speed: this.ctx.turnConfig.speed } : {}),
 				// Cancellable too: a Stop during the closing summary must not
 				// stream to completion.
 				signal: this.ctx.abortController.signal,

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

@@ -226,6 +226,10 @@ export interface IterationContext {
 	readonly maxOutputContinuations?: number
 	/** See `QueryParams.refusalFallback`. */
 	readonly refusalFallback?: 'auto' | 'off'
+	/** See `QueryParams.withholdOnRefusal`. */
+	readonly withholdOnRefusal?: readonly string[]
+	/** Recorded-context keys left out of the request; grows when a refusal is retried without them. */
+	readonly withheldKeys?: Set<string>
 
 	/**
 	 * What the driver said this model's context window is, resolved once.

package/src/runtime/query/iteration/step-shaping.ts

@@ -162,6 +162,9 @@ export function stepContext(
 			),
 		},
 		steps: steps(),
+		...(ctx.withheldKeys && ctx.withheldKeys.size > 0
+			? { withheldKeys: [...ctx.withheldKeys] }
+			: {}),
 		prepared,
 	}
 }

package/src/runtime/query/prepare-turn.ts

@@ -332,8 +332,13 @@ export async function prepareTurn(params: QueryParams): Promise<PreparedTurn> {
 	const promptCache = params.promptCache
 	const taskScheduler = params.taskScheduler
 	const streamIdleTimeoutMs = resolveStreamIdleTimeoutMs(params.turnConfig.streamIdleTimeoutMs)
-	const maxRequestRichContentBytes = resolveMaxRequestRichContentBytes(
+	// Validated here, at the door, but only the caller's own override is kept on
+	// the turn: the provider's declaration is read where it is used (see
+	// `IterationOrchestrator.richContentBudget`), so it follows the provider
+	// that serves the turn rather than being pinned by the first one.
+	resolveMaxRequestRichContentBytes(
 		params.turnConfig.maxRequestRichContentBytes,
+		params.provider.capabilities?.maxRequestRichContentBytes,
 	)
 	const sandboxTeardownTimeoutMs = resolveSandboxTeardownTimeoutMs(params.sandboxTeardownTimeoutMs)
 	// Persist the EFFECTIVE value, not only an override. A turn replayed after a
@@ -343,7 +348,6 @@ export async function prepareTurn(params: QueryParams): Promise<PreparedTurn> {
 	const turnConfig: TurnConfig = {
 		...params.turnConfig,
 		streamIdleTimeoutMs,
-		maxRequestRichContentBytes,
 	}
 
 	// The turn's one correlated logger, built before anything below needs

package/src/runtime/query/request-rich-content.ts

@@ -12,8 +12,17 @@ export const DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES = 24 * 1024 * 1024
 
 const MAX_REQUEST_RICH_CONTENT_BYTES = Number.MAX_SAFE_INTEGER
 
-export function resolveMaxRequestRichContentBytes(value: number | undefined): number {
-	const resolved = value ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES
+/**
+ * The budget for one turn: the caller's `turnConfig.maxRequestRichContentBytes`
+ * when set, else the one the provider declares for its own wire limit
+ * (`ProviderCapabilities.maxRequestRichContentBytes`), else the kernel default.
+ * The override always wins, so a host can tighten or loosen what a driver declares.
+ */
+export function resolveMaxRequestRichContentBytes(
+	value: number | undefined,
+	providerDeclared?: number,
+): number {
+	const resolved = value ?? providerDeclared ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES
 	if (
 		!Number.isSafeInteger(resolved) ||
 		resolved < 0 ||

package/src/turn/index.ts

@@ -23,7 +23,7 @@ export type { LimitCheckerState, LimitCheckResult } from './LimitChecker.js'
 
 export { SESSION_MEMORY_TAG, createMemoryPromoter } from './memory-promoter.js'
 export type { MemoryPromoterOptions, SessionMemoryCategory } from './memory-promoter.js'
-export { createMemoryRecallStep } from './memory-recall.js'
+export { createMemoryRecallStep, recalledMemoryIds } from './memory-recall.js'
 export type {
 	MemoryRecallOptions,
 	MemorySelection,

package/src/turn/memory-recall.ts

@@ -80,6 +80,12 @@ export interface MemoryRecallOptions {
 	readonly minCoverage?: number
 	/** Upper bound on the selector, in ms; the signal it is given aborts then. Default 2,500. */
 	readonly selectTimeoutMs?: number
+	/**
+	 * Ids recall must not offer, read afresh on every request. A host keeps a
+	 * set-aside list here (records a refused request carried) and lifts it when
+	 * the person restores a record. A throw reads as an empty list.
+	 */
+	readonly excluded?: () => Iterable<string> | Promise<Iterable<string>>
 }
 
 /** What a selector may know about a record: never its body. */
@@ -126,6 +132,27 @@ const OTHERS_PLURAL = (count: number): string =>
 export const RECALLED_MEMORY_ENTRY_KEY = 'memory'
 
 /** The `id@updatedAt` of every record the entries still in the history carry. */
+/**
+ * The ids of the records the `memory` entries carry, in the order they were
+ * recorded and without repeats. `entries` are bodies as `turnContextEntries`
+ * returns them.
+ */
+export function recalledMemoryIds(entries: readonly string[]): string[] {
+	const ids = new Set<string>()
+	for (const entry of entries) {
+		for (const line of entry.split('\n')) {
+			if (!line.startsWith('{')) continue
+			try {
+				const parsed = JSON.parse(line) as { id?: unknown }
+				if (typeof parsed.id === 'string') ids.add(parsed.id)
+			} catch {
+				// a line of the entry that is not a record
+			}
+		}
+	}
+	return [...ids]
+}
+
 function recordedRecords(entries: readonly string[]): Set<string> {
 	const seen = new Set<string>()
 	for (const entry of entries) {
@@ -377,8 +404,12 @@ export function createMemoryRecallStep(options: MemoryRecallOptions): PrepareSte
 		latestUserMessage,
 		contextBudget,
 		signal,
+		withheldKeys,
 	}) => {
 		signal?.throwIfAborted()
+		// A refused request was re-run without the memories it carried; adding
+		// them again would be refused again.
+		if (withheldKeys?.includes(RECALLED_MEMORY_ENTRY_KEY)) return undefined
 		// Leave room for the current request and response. The kernel supplies
 		// an estimate; using one character per remaining token is deliberately
 		// conservative for this optional text, not a billing/tokenizer claim.
@@ -484,6 +515,14 @@ export function createMemoryRecallStep(options: MemoryRecallOptions): PrepareSte
 		}
 		const recall = async (): Promise<Recalled> => {
 			const shown: RecalledMemory[] = []
+			let excludedIds: ReadonlySet<string> = new Set()
+			if (options.excluded) {
+				try {
+					excludedIds = new Set(await options.excluded())
+				} catch {
+					// An unreadable list excludes nothing.
+				}
+			}
 			const page = await options.store.list({
 				query: terms.join(' '),
 				status: 'active',
@@ -501,6 +540,7 @@ export function createMemoryRecallStep(options: MemoryRecallOptions): PrepareSte
 			let block = lead
 			const fresh = page.entries
 				.filter((entry) => entry.status === 'active')
+				.filter((entry) => !excludedIds.has(entry.id))
 				.filter((entry) => !known.has(`${entry.id}@${entry.updatedAt}`))
 			const candidates = fresh.slice(0, shortlist)
 			const picks = await choose(candidates)

package/src/types/agent/base.ts

@@ -226,6 +226,8 @@ export interface BaseAgentConfig {
 	 */
 	thinking?: import('../provider/index.js').ThinkingConfig
 	effort?: import('../provider/index.js').ReasoningEffort
+	/** Inference speed; see {@link import('../session/config.js').TurnConfig.speed}. */
+	speed?: import('../provider/index.js').InferenceSpeed
 	/** How the turn bounds its reasoning; see {@link import('../session/config.js').TurnConfig.reasoning}. */
 	reasoning?: import('../session/config.js').TurnConfig['reasoning']
 	/** Ask once for a check of edits before a turn ends; see {@link import('../session/config.js').TurnConfig.completionAudit}. */

package/src/types/agent/query.ts

@@ -100,6 +100,10 @@ export interface QueryAgentConfig extends BaseAgentConfig {
 	maxOutputContinuations?: QueryParams['maxOutputContinuations']
 	/** See {@link QueryParams.refusalFallback}. */
 	refusalFallback?: QueryParams['refusalFallback']
+	/** See {@link QueryParams.withholdOnRefusal}. */
+	withholdOnRefusal?: QueryParams['withholdOnRefusal']
+	/** See {@link QueryParams.withheldKeys}. */
+	withheldKeys?: QueryParams['withheldKeys']
 	maxToolOutputChars?: number
 	maxToolOutputCharsPerMessage?: number
 	retainedToolPreviewChars?: QueryParams['retainedToolPreviewChars']

package/src/types/common/index.ts

@@ -42,6 +42,14 @@ export interface TokenUsage {
 	 * {@link TokenUsage.cacheTtlMs}.
 	 */
 	cacheWriteTtlTokens?: { fiveMin?: number; oneHour?: number }
+
+	/**
+	 * The speed the provider says served this call, when it says. `'fast'` is a
+	 * premium-priced mode, so pricing reads it per call: a per-call fact like
+	 * {@link TokenUsage.cacheTtlMs}, never summed. Absent means standard or
+	 * unreported.
+	 */
+	speed?: import('../provider/chat.js').InferenceSpeed
 }
 
 export function accumulateTokenUsage(current: TokenUsage, addition: TokenUsage): TokenUsage {
@@ -101,6 +109,9 @@ export function mergeTokenUsage(current: TokenUsage, next: TokenUsage): TokenUsa
 		...(next.cacheWriteTtlTokens !== undefined || current.cacheWriteTtlTokens !== undefined
 			? { cacheWriteTtlTokens: next.cacheWriteTtlTokens ?? current.cacheWriteTtlTokens }
 			: {}),
+		...(next.speed !== undefined || current.speed !== undefined
+			? { speed: next.speed ?? current.speed }
+			: {}),
 	}
 }
 

package/src/types/provider/chat.ts

@@ -106,6 +106,15 @@ export interface ChatCompletionParams {
 	 * that narrower set according to their documented provider policy.
 	 */
 	effort?: ReasoningEffort
+
+	/**
+	 * Inference speed. `'fast'` asks a provider for its premium low-latency
+	 * mode, billed at a multiple of the standard rate; absent and `'standard'`
+	 * are the same request. A driver with no such mode, or a model without it,
+	 * must refuse `'fast'` rather than serve it at standard speed and let the
+	 * caller believe it was honoured.
+	 */
+	speed?: InferenceSpeed
 }
 
 export interface ThinkingConfig {
@@ -174,6 +183,9 @@ export interface ThinkingConfig {
  * transport or leave the vendor to refuse an unknown compatible-endpoint
  * extension explicitly.
  */
+/** `'fast'` is a premium low-latency mode; `'standard'` is the ordinary request. See {@link ChatCompletionParams.speed}. */
+export type InferenceSpeed = 'standard' | 'fast'
+
 export type ReasoningEffort =
 	| 'none'
 	| 'minimal'

package/src/types/provider/config.ts

@@ -170,6 +170,14 @@ export interface ProviderCapabilities {
 	 * or the lifetime is the provider's own and cannot be chosen or read).
 	 */
 	cacheTtl?: readonly ('5m' | '1h')[]
+	/**
+	 * The most base64 characters of inline images and documents this provider
+	 * will take in one request, when its wire limit differs from the kernel's
+	 * default (24 MiB). Counts the encoded value, like
+	 * `turnConfig.maxRequestRichContentBytes`, which still overrides it.
+	 * Absent means the kernel default.
+	 */
+	maxRequestRichContentBytes?: number
 }
 
 export interface ProviderFactoryResult {

package/src/types/provider/index.ts

@@ -5,6 +5,7 @@ export type {
 	ChatCompletionParams,
 	ChatCompletionResponse,
 	ProviderRefusal,
+	InferenceSpeed,
 	ReasoningEffort,
 	ThinkingConfig,
 } from './chat.js'