@namzu/sdk 52.7.0 → 53.1.0

package/src/store/memory/markdown.ts

@@ -53,7 +53,7 @@ import { MemoryRevisionConflictError, assertMemoryRevision, memoryRevision } fro
 
 /**
  * Versioned like every other record this SDK persists. A memory file carries
- * no `schemaVersion` while it is at version 1 — the reference shape has no
+ * no `schemaVersion` while it is at version 1 — the canonical shape has no
  * such field and a hand-written file should not need one — so the stamp only
  * appears once a later build writes a later version, and THIS build refuses
  * that file rather than reading it partially and writing the difference away.

package/src/store/session-log/core.ts

@@ -51,6 +51,7 @@ import {
 	isLeaseLive,
 } from './lease.js'
 import type { SpillReadOptions, SpillRef, SpillStore } from './spill.js'
+import { TOOL_INPUT_RECORD_TYPES, spilledInput, toolInputSlots } from './spilled-input.js'
 
 // ─── public types ─────────────────────────────────────────────────────────
 
@@ -666,6 +667,9 @@ export class SessionLogCore implements SessionLog {
 			? await this.#spillStructuredResults(original)
 			: original
 		const type = candidate.type
+		if (typeof type === 'string' && TOOL_INPUT_RECORD_TYPES.has(type)) {
+			return this.#spillToolInputs(candidate)
+		}
 		if (
 			type !== 'message' &&
 			type !== 'message_replaced' &&
@@ -715,6 +719,30 @@ export class SessionLogCore implements SessionLog {
 		return { ...candidate, content: preview, spill: ref }
 	}
 
+	/**
+	 * A record that carries tool inputs and would not fit a line: each large
+	 * input goes to `tool-results/` and the record keeps a stand-in, so the
+	 * person is still asked and the call is still restored on resume.
+	 */
+	async #spillToolInputs(candidate: Record<string, unknown>): Promise<Record<string, unknown>> {
+		const sizeOf = (record: Record<string, unknown>): number =>
+			Buffer.byteLength(`${JSON.stringify(record)}\n`, 'utf8')
+		if (sizeOf(candidate) <= this.#spillAbove) return candidate
+		const copy = structuredClone(candidate)
+		const slots = toolInputSlots(copy)
+		const bodies = slots.map(({ holder, key }) => JSON.stringify(holder[key]) ?? 'null')
+		// Largest first, and only as many as it takes to fit.
+		const order = slots.map((_, i) => i).sort((a, b) => bodies[b]!.length - bodies[a]!.length)
+		for (const index of order) {
+			const slot = slots[index]!
+			const body = bodies[index]!
+			const ref = await this.#spills.write(`input:${String(candidate.id)}:${index}`, 'text', body)
+			slot.holder[slot.key] = spilledInput(ref, body)
+			if (sizeOf(copy) <= this.#spillAbove) break
+		}
+		return copy
+	}
+
 	async #spillStructuredResults(
 		candidate: Record<string, unknown>,
 	): Promise<Record<string, unknown>> {

package/src/store/session-log/spilled-input.ts

@@ -0,0 +1,90 @@
+import type { SpillRef } from './spill.js'
+
+/**
+ * A tool call's input can be larger than a session-log record may be (a
+ * write of a few megabytes, a batch of large writes). The record that carries
+ * it then holds this stand-in, and the input itself sits in `tool-results/`
+ * under the same rules as any other spilled body.
+ */
+export const SPILLED_INPUT_KEY = '$spilledInput'
+
+/** Characters of the input kept inline beside the reference. */
+const INPUT_PREVIEW_CHARS = 200
+
+export interface SpilledInput {
+	readonly [SPILLED_INPUT_KEY]: SpillRef
+	readonly preview: string
+}
+
+export function spilledInput(ref: SpillRef, json: string): SpilledInput {
+	return { [SPILLED_INPUT_KEY]: ref, preview: json.slice(0, INPUT_PREVIEW_CHARS) }
+}
+
+export function isSpilledInput(value: unknown): value is SpilledInput {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		SPILLED_INPUT_KEY in value &&
+		typeof (value as Record<string, unknown>)[SPILLED_INPUT_KEY] === 'object'
+	)
+}
+
+/** Where a record keeps tool inputs: the holder object and the key of the input in it. */
+export interface InputSlot {
+	readonly holder: Record<string, unknown>
+	readonly key: string
+}
+
+function callSlots(calls: unknown): InputSlot[] {
+	if (!Array.isArray(calls)) return []
+	const slots: InputSlot[] = []
+	for (const call of calls) {
+		if (typeof call === 'object' && call !== null && 'input' in call) {
+			slots.push({ holder: call as Record<string, unknown>, key: 'input' })
+		}
+	}
+	return slots
+}
+
+/** Record types that carry a tool call's whole input. */
+export const TOOL_INPUT_RECORD_TYPES: ReadonlySet<string> = new Set([
+	'tool_review_requested',
+	'decision_requested',
+	'tool_executing',
+	'tool_input_completed',
+])
+
+/**
+ * The input slots of one record. The record is read, never changed; the
+ * caller copies what it replaces.
+ */
+export function toolInputSlots(record: Record<string, unknown>): InputSlot[] {
+	switch (record.type) {
+		case 'tool_review_requested':
+			return callSlots(record.toolCalls)
+		case 'decision_requested': {
+			const request = record.request as { toolCalls?: unknown } | undefined
+			return request ? callSlots(request.toolCalls) : []
+		}
+		case 'tool_executing':
+		case 'tool_input_completed':
+			return 'input' in record ? [{ holder: record, key: 'input' }] : []
+		default:
+			return []
+	}
+}
+
+/**
+ * The input slots of a request read back from a log, with any stand-in
+ * replaced by the input it stands for. Mutates and returns `request`.
+ */
+export async function restoreSpilledRequestInputs<T extends { toolCalls?: unknown }>(
+	request: T,
+	read: (ref: SpillRef) => Promise<string>,
+): Promise<T> {
+	for (const { holder, key } of callSlots(request.toolCalls)) {
+		const value = holder[key]
+		if (isSpilledInput(value)) holder[key] = JSON.parse(await read(value[SPILLED_INPUT_KEY]))
+	}
+	return request
+}

package/src/tools/builtins/bash.ts

@@ -52,8 +52,7 @@ const DEFAULT_BASH_MAX_BUFFER_BYTES = readPositiveIntEnv(
  *
  * So the tool declares a ceiling and the executor is given a deadline above
  * it (see `timeoutMs` on the definition), which makes this the only clock
- * that can fire in practice. A request past the ceiling is CLAMPED to it, as
- * the reference terminal does: the command still runs, and a timeout reports
+ * that can fire in practice. A request past the ceiling is CLAMPED to it: the command still runs, and a timeout reports
  * the deadline that was actually applied, so the number the model sees on a
  * timeout is the one that fired.
  */

package/src/tools/builtins/edit-match.ts

@@ -9,18 +9,17 @@
  * carries the same transformation across to `new_string` so the replacement
  * stays consistent with what it replaced.
  *
- * The strategies and their order are a faithful port of the reference client's
- * file-edit resolver (the `lje`/`b`/`_`/`L`/`k`/`R`/`C`/`cDs`/`ipt`/`H`/`Q`/`N`
- * functions in its shipped bundle), so an edit that lands there lands here:
+ * The strategies and their order are fixed as follows, so an edit that matches
+ * under one of them matches here:
  *
  *   1. exact
  *   2. curly vs straight quotes, both directions
  *   3. `\uXXXX` escape in `old_string`, character in the file
  *   4. character in `old_string`, `\uXXXX` escape in the file
  *
- * The reference also expands a map of its own prompt delimiters (`<fnr>` →
- * `<function_results>`, `\n\nH:` → `\n\nHuman:`, …). That is deliberately NOT
- * ported: those tokens are artifacts of that client's own transcript format,
+ * Prompt delimiters from a transcript format (`<fnr>` →
+ * `<function_results>`, `\n\nH:` → `\n\nHuman:`, …) are deliberately NOT
+ * expanded: those tokens are artifacts of a transcript format,
  * not a mismatch a Namzu model produces against a real source file.
  *
  * Pure by construction, like `edit-apply`: every function here is from strings

package/src/types/provider/errors.ts

@@ -337,7 +337,7 @@ function codeFromMessage(message: string, status?: number): ProviderErrorCode |
 		// overflow rescue tests for by exact equality. The turn died holding
 		// the remedy.
 		m.includes('too long for') ||
-		// The reference terminal's own wordings (its `context window` and
+		// Known wordings: `context window` and
 		// `input length and max_tokens exceed context limit` matchers).
 		// Only where the status cannot say otherwise: a 429, 5xx or 401 that
 		// mentions the window is still a rate limit, a server fault or an auth