@namzu/sdk 58.1.0 → 59.0.0

package/src/public-types.ts

@@ -800,6 +800,21 @@ export type {
 	ResolvePeerRuntimeDirOptions,
 } from './peers/dir.js'
 export type { PeerRecord } from './peers/record.js'
+export type { AccountBoundRecord } from './types/session/records.js'
+export type {
+	Account,
+	AccountBoundReason,
+	AccountCredentialReaders,
+	AccountId,
+	AccountLockOptions,
+	AccountLockSyncOptions,
+	AccountRegistry,
+	AccountRegistryOptions,
+	AccountSource,
+	BoundAccount,
+	NewAccount,
+	ResolvedAccountCredential,
+} from './account/index.js'
 export type {
 	ListLivePeersOptions,
 	PeerLivenessOptions,

package/src/runtime/query/executor.ts

@@ -13,6 +13,7 @@ import { buildProbeContext } from '../../probe/context.js'
 import { ProbeVetoError } from '../../probe/errors.js'
 import { probe as defaultProbeRegistry } from '../../probe/registry.js'
 import type { ProbeEnforcement } from '../../probe/registry.js'
+import { ToolResultHalted } from '../../registry/tool/screen.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
 import {
 	effectiveBashWorkingDirectory,
@@ -3131,11 +3132,16 @@ export class ToolExecutor {
 	}
 
 	/**
-	 * One execution attempt, with a throw materialized as an error result.
+	 * One execution attempt, with a throw materialized as an error result —
+	 * except `ToolResultHalted`, which this deliberately lets through.
 	 *
 	 * an unhandled throw from `tools.execute(...)` used to
 	 * propagate up to `result.ts` as `turn_failed` without emitting a
-	 * terminal `tool_completed`, leaving UI cards stuck in `executing`.
+	 * terminal `tool_completed`, leaving UI cards stuck in `executing`. That
+	 * is still right for a tool that merely broke. It is wrong for a screen
+	 * that said `halt`: `screen.ts` throws `ToolResultHalted` instead of
+	 * returning it so a catch this generic cannot flatten it into a failed
+	 * `ToolResult` the model reads and works around.
 	 *
 	 * The return is the full `ToolResult`, not a narrowed literal: the
 	 * narrow version silently DROPPED `content`, so a tool returning an
@@ -3151,6 +3157,8 @@ export class ToolExecutor {
 		try {
 			return await this.executeWithDeadline(toolName, input, toolContext, prepared)
 		} catch (err) {
+			if (err instanceof ToolResultHalted) throw err
+
 			const message = toErrorMessage(err)
 			this.log.warn('Tool execution threw', {
 				[NAMZU.TURN_ID]: this.config.turnId,

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

@@ -8,9 +8,9 @@
  *   line and a `breaker_open` event, no sentence); a pass the provider forces
  *   by rejecting the prompt is not gated, so the reactive ladder still runs.
  * - Three compactions in a row, each followed by the history regaining all
- *   space shed within three iterations: something in the loop (a huge file
- *   read, a tool that prints without limit) refills the window faster than a
- *   summary can empty it. The turn stops, because carrying on buys the same wall.
+ *   space shed within three iterations: conversation growth refills the space
+ *   freed. Even small outputs can do this when a summary leaves little room.
+ *   The turn stops, because carrying on buys the same wall.
  *
  * Off unless `compactionConfig.circuitBreaker` is true: stopping compaction,
  * and above all stopping a turn, is not something a host had before.
@@ -49,12 +49,12 @@ export const COMPACTION_REFILL_ITERATIONS = 3
 export const COMPACTION_REFILL_LIMIT = 3
 
 /**
- * One short line, shown once, when the turn stops on refills. It names the
- * cause and a step that keeps the conversation: starting over is never
- * offered here.
+ * Shown once when the turn stops on refills. Explain context pressure without
+ * inferring the size of any individual output; suggest steps that preserve
+ * the conversation.
  */
 export const COMPACTION_REFILL_MESSAGE =
-	'The context filled up again right after being compacted, three times in a row. A file being read or a tool output is probably too large for the context window. Try reading it in smaller parts.'
+	'The context filled up again right after being compacted, three times in a row. Compaction may have left too little room, even for small outputs. Check the configured model context window; limit tool output or read files in smaller parts.'
 
 export class CompactionBreaker {
 	private failures = 0

package/src/runtime/query/tool-output-budget.ts

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto'
 import { mkdirSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { digest, spillManifest } from '../../store/evidence/format.js'
+import { copyString } from '../../utils/copy-string.js'
 
 /**
  * Model-visible size cap for a single tool result.
@@ -304,8 +305,9 @@ export function applyToolOutputBudget(opts: ApplyToolOutputBudgetOptions): ToolO
 	if (preview !== undefined && retained?.integrity) {
 		const condensed = [preview, recovery].filter(Boolean).join('\n\n')
 		if (effectiveTextBudget === undefined || condensed.length <= effectiveTextBudget) {
+			const visible = withNotice(condensed)
 			return {
-				output: withNotice(condensed),
+				output: effectiveTextBudget === undefined ? visible : copyString(visible),
 				originalLength,
 				truncated: true,
 				spillPath,
@@ -318,8 +320,10 @@ export function applyToolOutputBudget(opts: ApplyToolOutputBudgetOptions): ToolO
 	}
 
 	return {
-		output: withNotice(
-			boundedPreview(output, effectiveTextBudget ?? textBudget, opts.toolName, recovery),
+		output: copyString(
+			withNotice(
+				boundedPreview(output, effectiveTextBudget ?? textBudget, opts.toolName, recovery),
+			),
 		),
 		originalLength,
 		truncated: true,
@@ -471,7 +475,7 @@ function previewForMessageBudget(
 			spilledAt,
 		].join('\n')
 		return {
-			output,
+			output: copyString(output),
 			originalLength: item.output.length,
 			spillPath: (spilledAt.split('\n')[0] as string).slice(SPILL_MARKER.length + 1),
 		}

package/src/tools/text-window.ts

@@ -1,4 +1,5 @@
 import type { ToolTextWindow } from '../types/tool/presentation.js'
+import { copyString } from '../utils/copy-string.js'
 
 /** Lines kept from the start and from the end of a long text. */
 export const WINDOW_HEAD_LINES = 80
@@ -36,7 +37,7 @@ export function windowText(
 	const lines = body.length === 0 ? [] : body.split('\n')
 	const totalLines = lines.length
 	if (totalLines <= WINDOW_HEAD_LINES + WINDOW_TAIL_LINES && body.length <= WINDOW_HALF_CHARS * 2) {
-		return { head: body, totalLines, totalBytes }
+		return { head: copyString(body), totalLines, totalBytes }
 	}
 	const headLines = lines.slice(0, WINDOW_HEAD_LINES)
 	const tailLines =
@@ -47,8 +48,8 @@ export function windowText(
 	const tail = clipTail(tailLines.join('\n'), WINDOW_HALF_CHARS)
 	const omittedLines = totalLines - headLines.length - tailLines.length
 	return {
-		head,
-		...(tail ? { tail } : {}),
+		head: copyString(head),
+		...(tail ? { tail: copyString(tail) } : {}),
 		...(omittedLines > 0 ? { omittedLines } : {}),
 		totalLines,
 		totalBytes,

package/src/types/errors/catalog.ts

@@ -164,6 +164,12 @@ export const DEFAULT_ERROR_RULES: readonly ErrorCatalogRule[] = [
 		message: 'The provider rejected the credentials for this turn.',
 		hint: 'Check that the API key is set, is not expired, and belongs to the account the model is billed to. Retrying will not help until it changes.',
 	},
+	{
+		id: 'provider.usage_limit',
+		when: (facts) => facts.code === 'usage_limit',
+		message: 'The account has used up its allowance until the limit resets.',
+		hint: 'Waiting inside this turn cannot help. Continue on another account or provider, or resume after the reset time the provider reported.',
+	},
 	{
 		id: 'provider.rate_limit',
 		when: (facts) => facts.code === 'rate_limit' || facts.status === 429,

package/src/types/provider/errors.ts

@@ -15,6 +15,12 @@
 export type ProviderErrorCode =
 	/** 429. Back off; honour `retryAfterMs` when the server sent one. */
 	| 'rate_limit'
+	/**
+	 * The account's usage allowance is spent until a later reset, as opposed to
+	 * a momentary burst limit. Waiting inside this turn cannot help, so it is
+	 * not retried; a host may offer another account instead.
+	 */
+	| 'usage_limit'
 	/** 529 / 503 — the model is up but saturated. Back off. */
 	| 'overloaded'
 	/** Any other 5xx. Back off. */
@@ -487,7 +493,10 @@ const STRUCTURAL_CODES: Readonly<Record<string, ProviderErrorCode>> = {
 	string_above_max_length: 'context_length_exceeded',
 	rate_limit_exceeded: 'rate_limit',
 	rate_limit_error: 'rate_limit',
-	insufficient_quota: 'rate_limit',
+	insufficient_quota: 'usage_limit',
+	usage_limit_reached: 'usage_limit',
+	usage_limit_exceeded: 'usage_limit',
+	billing_error: 'usage_limit',
 	overloaded_error: 'overloaded',
 	content_filter: 'content_filter',
 	content_policy_violation: 'content_filter',
@@ -497,6 +506,24 @@ const STRUCTURAL_CODES: Readonly<Record<string, ProviderErrorCode>> = {
 	model_not_found: 'not_found',
 }
 
+/**
+ * Is this exact provider code, or the provider's own complaint, a spent
+ * allowance? The codes are the vendors' identifiers (`insufficient_quota`,
+ * `usage_limit_reached`, `usage_limit_exceeded`, `billing_error`); the
+ * sentences are the two vendors that word it only in prose: an exhausted
+ * prepaid balance and an exhausted plan allowance.
+ */
+const USAGE_LIMIT_DETAIL: readonly RegExp[] = [
+	/credit balance is too low/i,
+	/exceeded your current quota/i,
+	/usage limit (?:has been )?(?:reached|exceeded)/i,
+]
+
+export function isUsageLimitSignal(code: string | undefined, detail: string | undefined): boolean {
+	if (code !== undefined && STRUCTURAL_CODES[code.toLowerCase()] === 'usage_limit') return true
+	return detail !== undefined && USAGE_LIMIT_DETAIL.some((re) => re.test(detail))
+}
+
 function codeFromStructure(err: unknown): ProviderErrorCode | undefined {
 	for (const link of causeChain(err)) {
 		for (const field of [link.code, link.type, (link.error as { type?: unknown })?.type]) {
@@ -556,6 +583,8 @@ function classifyFromProviderRequestError(
 	const candidate = err as Error & {
 		kind?: unknown
 		providerId?: unknown
+		providerCode?: unknown
+		detail?: unknown
 		status?: unknown
 		retryAfterMs?: unknown
 		shouldRetry?: unknown
@@ -563,15 +592,23 @@ function classifyFromProviderRequestError(
 	if (typeof candidate.kind !== 'string') return undefined
 	const mapped = KIND_TO_CODE[candidate.kind]
 	if (!mapped) return undefined
+	// A throttle or an invalid request that says the allowance is spent is not
+	// a burst limit: resending the same request cannot succeed.
+	const spent =
+		(candidate.kind === 'throttle' || candidate.kind === 'bad_request') &&
+		isUsageLimitSignal(
+			typeof candidate.providerCode === 'string' ? candidate.providerCode : undefined,
+			typeof candidate.detail === 'string' ? candidate.detail : undefined,
+		)
 
 	const retryAfterMs =
 		typeof candidate.retryAfterMs === 'number' ? candidate.retryAfterMs : readRetryAfterMs(err, now)
 
 	return new ProviderError({
-		code: mapped.code,
+		code: spent ? 'usage_limit' : mapped.code,
 		message: err.message,
 		// The provider saying "do not resend" beats the kind's own verdict.
-		retryable: candidate.shouldRetry === false ? false : mapped.retryable,
+		retryable: spent || candidate.shouldRetry === false ? false : mapped.retryable,
 		cause: err,
 		...(typeof candidate.providerId === 'string'
 			? { providerId: candidate.providerId }

package/src/types/session/records.ts

@@ -576,6 +576,19 @@ export const BudgetBoundRecordSchema = inTurn('budget_bound', {
 	accountId: text.min(1),
 })
 
+/**
+ * The account a session's provider calls run under. Written when a session is
+ * bound to an account other than the provider's `default`, and again on each
+ * switch; never inside an open turn's work, only between turns. Replay reads
+ * the last one. A build that predates this record refuses a log holding it, so
+ * a session that never leaves the default account never writes one.
+ */
+export const AccountBoundRecordSchema = recordSchema('account_bound', {
+	accountId: text.min(1),
+	provider: text.min(1),
+	reason: z.enum(['start', 'user_switch', 'limit_switch']),
+})
+
 export const LogRepairedRecordSchema = recordSchema('log_repaired', {
 	truncatedBytes: positive,
 	lastGoodSeq: positive,
@@ -612,6 +625,7 @@ const RECORD_ONLY_SCHEMAS = {
 	child_session_ended: ChildSessionEndedRecordSchema,
 	audit: AuditRecordSchema,
 	budget_bound: BudgetBoundRecordSchema,
+	account_bound: AccountBoundRecordSchema,
 	log_repaired: LogRepairedRecordSchema,
 } as const
 
@@ -982,6 +996,7 @@ export type CompactionRecord = z.infer<typeof CompactionRecordSchema>
 export type ChildSessionEndedRecord = z.infer<typeof ChildSessionEndedRecordSchema>
 export type AuditRecord = z.infer<typeof AuditRecordSchema>
 export type BudgetBoundRecord = z.infer<typeof BudgetBoundRecordSchema>
+export type AccountBoundRecord = z.infer<typeof AccountBoundRecordSchema>
 export type LogRepairedRecord = z.infer<typeof LogRepairedRecordSchema>
 
 export type SessionRecordOnly =
@@ -998,6 +1013,7 @@ export type SessionRecordOnly =
 	| ChildSessionEndedRecord
 	| AuditRecord
 	| BudgetBoundRecord
+	| AccountBoundRecord
 	| LogRepairedRecord
 
 /** One line of a session log. */

package/src/utils/copy-string.ts

@@ -0,0 +1,11 @@
+/**
+ * Give retained text its own backing storage instead of keeping a source slice
+ * alive. Call only after bounding the text: copying a whole tool result would
+ * briefly double its memory. UTF-16 preserves every JavaScript code unit,
+ * including lone surrogates that a UTF-8 round trip would replace.
+ *
+ * @internal
+ */
+export function copyString(text: string): string {
+	return Buffer.from(text, 'utf16le').toString('utf16le')
+}