@namzu/sdk 62.8.0 → 62.10.0

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

@@ -59,6 +59,16 @@ export class DiskLogMedium implements LogMedium {
 		}
 	}
 
+	async identity(): Promise<string | undefined> {
+		try {
+			const stats = await stat(this.file)
+			return `${stats.dev}:${stats.ino}:${this.file}`
+		} catch (error) {
+			if (isErrno(error, 'ENOENT')) return undefined
+			throw error
+		}
+	}
+
 	async read(offset: number, length: number): Promise<Uint8Array> {
 		let handle: FileHandle
 		try {
@@ -76,6 +86,28 @@ export class DiskLogMedium implements LogMedium {
 		}
 	}
 
+	async scan(offset: number, visit: (chunk: Uint8Array) => boolean): Promise<void> {
+		let handle: FileHandle
+		try {
+			handle = await open(this.file, 'r')
+		} catch (error) {
+			if (isErrno(error, 'ENOENT')) return
+			throw error
+		}
+		try {
+			const buffer = Buffer.allocUnsafe(1 << 20)
+			let position = offset
+			for (;;) {
+				const { bytesRead } = await handle.read(buffer, 0, buffer.length, position)
+				if (bytesRead === 0) return
+				position += bytesRead
+				if (visit(buffer.subarray(0, bytesRead))) return
+			}
+		} finally {
+			await handle.close()
+		}
+	}
+
 	async *stream(offset: number): AsyncIterable<Uint8Array> {
 		if ((await this.size()) <= offset) return
 		const stream = createReadStream(this.file, { start: offset, highWaterMark: 1 << 20 })

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

@@ -22,7 +22,10 @@ import type { SpillRef } from './spill.js'
  * override or a structured-output answer is what every reader of the fold
  * sees; the model's raw text stays in the log for audit only.
  *
- * Only `message`, `message_replaced` and `compaction` records move the fold.
+ * `message_edited` is applied the same way as `message_replaced`: a compaction
+ * pass's edit of one message, written under the message's own id.
+ *
+ * Only `message`, `message_replaced`, `message_edited` and `compaction` records move the fold.
  * The live compaction events (`compaction_completed` and the rest) are
  * reports, not instructions.
  */
@@ -118,7 +121,8 @@ export class SessionMessageFold {
 			case 'message':
 				this.#message(record as MessageRecord)
 				return
-			case 'message_replaced': {
+			case 'message_replaced':
+			case 'message_edited': {
 				const spill = (record as { spill?: SpillRef }).spill
 				this.#replacements.set(record.targetMessageId, {
 					message: record.content,
@@ -311,6 +315,18 @@ export class SessionTurnState {
 		return this.#active
 	}
 
+	/**
+	 * An independent copy at the records applied so far. `apply` replaces the
+	 * active turn's object rather than editing it, so the copy may share it.
+	 */
+	clone(): SessionTurnState {
+		const copy = new SessionTurnState()
+		copy.#active = this.#active
+		copy.#lastTurnId = this.#lastTurnId
+		copy.#started = this.#started
+		return copy
+	}
+
 	/** The last turn that started, active or not. */
 	get lastTurnId(): TurnId | undefined {
 		return this.#lastTurnId
@@ -412,5 +428,6 @@ const CLOSES_OR_DECIDES: ReadonlySet<string> = new Set([
 	'audit',
 	'log_repaired',
 	'message_replaced',
+	'message_edited',
 	'session_updated',
 ])

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

@@ -27,7 +27,8 @@ import type { SessionLog } from './core.js'
  *
  * Cost that remains: the state of the "every message ever recorded" reduction
  * holds each message the log ever recorded, superseded and compacted ones
- * included, so it grows with the log and not with the live context, and it
+ * included, and the earlier texts of an edited message (one per edit, until a
+ * replacement clears them), so it grows with the log and not with the live context, and it
  * lives for the life of the process (for the sessions kept). Reading it
  * returns a copy of all of them, which is O(history) per turn. Both are small
  * next to the whole-log walks this file removes, and are left as they are.
@@ -71,6 +72,14 @@ export interface IncrementalFold<S, R> {
 	/** The reduction's name; one cache slot per name and read mode. */
 	readonly name: string
 	readonly mode: 'strict' | 'tolerant'
+	/**
+	 * Strict reductions only: before resuming, hash every byte before the
+	 * resume point against what this process verified (`read({ reverify })`),
+	 * so a resumed read refuses a log altered anywhere, as a read from byte 0
+	 * does, without parsing the prefix again. Off by default: the window the
+	 * header describes then applies.
+	 */
+	readonly reverify?: boolean
 	/** A fresh, empty state. */
 	create(): S
 	/** Fold one record into the state, in place. */
@@ -103,7 +112,11 @@ export async function foldSessionLog<S, R>(
 			}
 			let moved = false
 			try {
-				const walk = log.read({ mode: fold.mode, ...(anchor ? { after: anchor } : {}) })
+				const walk = log.read({
+					mode: fold.mode,
+					...(anchor ? { after: anchor } : {}),
+					...(fold.reverify && fold.mode === 'strict' ? { reverify: true } : {}),
+				})
 				let summary: Awaited<ReturnType<typeof walk.next>>
 				for (;;) {
 					summary = await walk.next()

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

@@ -61,6 +61,7 @@ export {
 	withMessageId,
 } from './fold.js'
 export { type TornTailRepair, repairRecordDraft } from './heal.js'
+export { type IncrementalFold, foldSessionLog } from './incremental.js'
 export {
 	foldChildOutcomes,
 	foldTurnOutcomes,

package/src/store/session-log/verified-prefix.ts

@@ -0,0 +1,243 @@
+import * as crypto from 'node:crypto'
+import type { SessionId } from '../../types/ids/index.js'
+import type { RecordPointer } from '../../types/session/records.js'
+import { LineSplitter, type LogBytes, type SessionLogEntry } from './chain.js'
+import { SessionTurnState } from './fold.js'
+
+/**
+ * What this process has already verified of a session log, so that checking
+ * it again costs the bytes and not the parsing.
+ *
+ * A ledger remembers, for every record this process verified IN FULL (schema,
+ * parse, hash chain, seq, gen, links: everything `SessionLogChain.accept`
+ * checks), the byte length of its line and the SHA-256 of those bytes, plus
+ * the head pointer, the `gen`, the session id and the turn state folded to
+ * the head. A later claim of the same log reads every byte again and hashes
+ * each line; a line whose length and digest equal the remembered ones is
+ * byte-identical to a line that already passed every rule, so it passes them
+ * again without being parsed. Only what lies after the remembered head is
+ * verified in full. Nothing about the file's identity is trusted for
+ * soundness: the content is compared. Any difference (a changed byte, a
+ * shorter file, a replaced file, a line that no longer splits the same way)
+ * makes the caller discard the ledger and verify from byte 0 as before.
+ *
+ * A ledger is fed only from entries that came out of a full verification and
+ * that continue it (`seq` = count + 1 and `prev` equal to the head), so what
+ * it holds is a prefix of one valid chain and nothing else. It costs 36 bytes
+ * per record.
+ */
+
+const DIGEST_BYTES = 32
+/** Logs kept; the least recently used is dropped. */
+const LEDGERS_KEPT = 16
+/** A log with more records than this is not remembered (about 72 MB of digests). */
+const MAX_RECORDS = 1 << 21
+
+/**
+ * The digest of one line as lowercase hex. A string, not a Buffer: a Buffer per
+ * line (82,000 of them in a long log) is native memory the collector has to
+ * chase, and measured about twice the CPU. The one-shot form where Node has it.
+ */
+const hexDigestOf: (line: Uint8Array) => string =
+	typeof crypto.hash === 'function'
+		? (line) => crypto.hash('sha256', line, 'hex')
+		: (line) => crypto.createHash('sha256').update(line).digest('hex')
+
+/** Whether `hex` (64 lowercase hex characters) spells the 32 bytes at `at` in `bytes`. */
+function hexEqualsBytes(hex: string, bytes: Uint8Array, at: number): boolean {
+	if (hex.length !== DIGEST_BYTES * 2) return false
+	for (let i = 0; i < DIGEST_BYTES; i++) {
+		const high = hex.charCodeAt(i * 2)
+		const low = hex.charCodeAt(i * 2 + 1)
+		const value =
+			((high <= 0x39 ? high - 0x30 : high - 0x57) << 4) | (low <= 0x39 ? low - 0x30 : low - 0x57)
+		if (value !== bytes[at + i]) return false
+	}
+	return true
+}
+
+export class VerifiedPrefix {
+	#count = 0
+	#lengths = new Uint32Array(1024)
+	#digests = Buffer.allocUnsafe(1024 * DIGEST_BYTES)
+	#head: RecordPointer | null = null
+	#gen = 0
+	#sessionId: SessionId | undefined
+	#end = 0
+	#dead = false
+	readonly #turns = new SessionTurnState()
+
+	/** Records remembered. */
+	get count(): number {
+		return this.#count
+	}
+	get head(): RecordPointer | null {
+		return this.#head
+	}
+	get gen(): number {
+		return this.#gen
+	}
+	get sessionId(): SessionId | undefined {
+		return this.#sessionId
+	}
+	/** Byte offset just after the last remembered record. */
+	get end(): number {
+		return this.#end
+	}
+	/** The turn state at the head, as its own copy. */
+	turns(): SessionTurnState {
+		return this.#turns.clone()
+	}
+	/** Lengths and digests as they stand now; entries below `count` never change. */
+	get lengths(): Uint32Array {
+		return this.#lengths
+	}
+	get digests(): Buffer {
+		return this.#digests
+	}
+
+	/** Whether the remembered record `seq` is exactly `pointer` (length and digest). */
+	holds(pointer: RecordPointer): boolean {
+		const at = pointer.seq - 1
+		if (at < 0 || at >= this.#count) return false
+		if (this.#lengths[at] !== pointer.length) return false
+		return (
+			this.#digests.toString('hex', at * DIGEST_BYTES, (at + 1) * DIGEST_BYTES) === pointer.sha256
+		)
+	}
+
+	/**
+	 * Remember a record that was verified in full. Ignored unless it continues
+	 * what is held: the next seq, naming the head by its pointer.
+	 */
+	append(entry: SessionLogEntry): void {
+		if (this.#dead) return
+		const { record, pointer } = entry
+		if (pointer.seq !== this.#count + 1 || pointer.offset !== this.#end) return
+		const prev = record.prev
+		if (this.#head === null ? prev !== null : !samePointer(prev, this.#head)) return
+		if (this.#sessionId !== undefined && record.sessionId !== this.#sessionId) return
+		if (this.#count >= MAX_RECORDS) {
+			this.#dead = true
+			return
+		}
+		if (this.#count === this.#lengths.length) {
+			const lengths = new Uint32Array(this.#lengths.length * 2)
+			lengths.set(this.#lengths)
+			this.#lengths = lengths
+			const digests = Buffer.allocUnsafe(this.#digests.length * 2)
+			this.#digests.copy(digests)
+			this.#digests = digests
+		}
+		this.#lengths[this.#count] = pointer.length
+		this.#digests.write(pointer.sha256, this.#count * DIGEST_BYTES, DIGEST_BYTES, 'hex')
+		this.#count += 1
+		this.#head = pointer
+		this.#gen = record.gen
+		this.#end = pointer.offset + pointer.length
+		this.#sessionId ??= record.sessionId
+		this.#turns.apply(record)
+	}
+}
+
+function samePointer(a: RecordPointer | null | undefined, b: RecordPointer): boolean {
+	return (
+		a !== null &&
+		a !== undefined &&
+		a.seq === b.seq &&
+		a.offset === b.offset &&
+		a.length === b.length &&
+		a.sha256 === b.sha256
+	)
+}
+
+const ledgers = new Map<string, VerifiedPrefix>()
+
+/** The ledger of a log, if this process has one; marks it recently used. */
+export function verifiedPrefixOf(key: string): VerifiedPrefix | undefined {
+	const found = ledgers.get(key)
+	if (found !== undefined) {
+		ledgers.delete(key)
+		ledgers.set(key, found)
+	}
+	return found
+}
+
+/** Discard what is remembered of a log and start an empty ledger for it. */
+export function startVerifiedPrefix(key: string): VerifiedPrefix {
+	ledgers.delete(key)
+	if (ledgers.size >= LEDGERS_KEPT) {
+		const oldest = ledgers.keys().next().value
+		if (oldest !== undefined) ledgers.delete(oldest)
+	}
+	const fresh = new VerifiedPrefix()
+	ledgers.set(key, fresh)
+	return fresh
+}
+
+/** Forget every remembered log: what a process that has not read them yet looks like. For tests. */
+export function clearVerifiedPrefixes(): void {
+	ledgers.clear()
+}
+
+/** How many logs are remembered. For tests. */
+export function verifiedPrefixCount(): number {
+	return ledgers.size
+}
+
+/**
+ * Read the first `count` lines of `bytes` and compare each one's length and
+ * SHA-256 with the ledger's. Resolves `true` only when every one is equal.
+ * Parses nothing and keeps nothing. Any difference, a log that ends sooner,
+ * or a fragment no record could be, resolves `false`: the caller then verifies
+ * in full, which says what is wrong.
+ */
+export async function rehashPrefix(
+	bytes: Pick<LogBytes, 'size'> & {
+		stream(offset: number): AsyncIterable<Uint8Array>
+		scan?(offset: number, visit: (chunk: Uint8Array) => boolean): Promise<void>
+	},
+	ledger: VerifiedPrefix,
+	count: number,
+): Promise<boolean> {
+	if (count === 0) return true
+	if (count > ledger.count) return false
+	const lengths = ledger.lengths
+	const digests = ledger.digests
+	if ((await bytes.size()) < endOfLine(lengths, count)) return false
+	const splitter = new LineSplitter(0)
+	let index = 0
+	let matched = false
+	// True once the answer is known. A chunk is read from a buffer the caller of `visit`
+	// may reuse, so nothing here keeps a slice of it: a line is hashed where it stands.
+	const visit = (chunk: Uint8Array): boolean => {
+		for (const { line } of splitter.push(chunk)) {
+			if (line.byteLength !== lengths[index]) return true
+			if (!hexEqualsBytes(hexDigestOf(line), digests, index * DIGEST_BYTES)) return true
+			index += 1
+			if (index === count) {
+				matched = true
+				return true
+			}
+		}
+		return false
+	}
+	try {
+		if (bytes.scan !== undefined) {
+			await bytes.scan(0, visit)
+		} else {
+			for await (const chunk of bytes.stream(0)) if (visit(chunk)) break
+		}
+	} catch (error) {
+		// A fragment longer than any record can be: not the log that was verified.
+		if ((error as { name?: string }).name === 'SessionLogIntegrityError') return false
+		throw error
+	}
+	return matched
+}
+
+function endOfLine(lengths: Uint32Array, count: number): number {
+	let total = 0
+	for (let i = 0; i < count; i++) total += lengths[i] as number
+	return total
+}

package/src/types/connector/mcp.ts

@@ -522,6 +522,25 @@ export interface MCPClientConfig {
 	 * forever — no error, no failure, just a turn that stopped.
 	 */
 	requestTimeoutMs?: number
+	/**
+	 * Treat the deadline as an idle deadline for a tool call that reports
+	 * progress: each accepted `notifications/progress` (one whose value rose)
+	 * re-arms `requestTimeoutMs` for that call. Off by default, which keeps
+	 * the single fixed deadline.
+	 *
+	 * Only a `tools/call` made with `onProgress` carries a progress token, so
+	 * only such a call can be extended. The call is still bounded in total by
+	 * `maxTotalTimeoutMs`, which progress never extends.
+	 */
+	resetTimeoutOnProgress?: boolean
+	/**
+	 * The most a progress-extended call may take in total, counted from when
+	 * the request was issued, in milliseconds. An integer no smaller than
+	 * `requestTimeoutMs`. Defaults to ten times `requestTimeoutMs`
+	 * (`DEFAULT_MCP_TOTAL_TIMEOUT_FACTOR`). Applies only with
+	 * `resetTimeoutOnProgress`.
+	 */
+	maxTotalTimeoutMs?: number
 	/**
 	 * How long `connect()`'s era probe waits for an answer before deciding
 	 * the peer speaks a legacy revision. Defaults to

package/src/types/session/records.ts

@@ -457,6 +457,28 @@ export const MessageReplacedRecordSchema = recordSchema('message_replaced', {
 	]),
 })
 
+/**
+ * A compaction pass changed one message's text in place (a long narration cut
+ * to its first sentence, a large tool result cleared) and the message kept its
+ * id. The fold shows `content` for `targetMessageId` from this record on, in
+ * the message's own position, exactly as it does for `message_replaced`; the
+ * `message` record it targets still holds the original text.
+ *
+ * A record of its own, flagged `ignorable`, and not another `message_replaced`
+ * reason: that record's `reason` is a closed list an earlier release validates
+ * strictly, so a new value would make it refuse the whole log. An earlier
+ * release skips this one and folds the unedited text of the message.
+ * `reason` is free text for the same reason: a later release may name more
+ * kinds of edit without this one refusing its log.
+ */
+export const MessageEditedRecordSchema = inTurn('message_edited', {
+	ignorable: z.literal(true),
+	targetMessageId: messageId,
+	content: messageBody,
+	spill: spill.optional(),
+	reason: text.min(1),
+})
+
 // Checkpoints and human decisions (record-only)
 
 /** `SessionRecordSchema` also holds `throughSeq` below the record's own `seq`. */
@@ -665,6 +687,7 @@ const RECORD_ONLY_SCHEMAS = {
 	session_updated: SessionUpdatedRecordSchema,
 	message: MessageRecordSchema,
 	message_replaced: MessageReplacedRecordSchema,
+	message_edited: MessageEditedRecordSchema,
 	checkpoint_written: CheckpointWrittenRecordSchema,
 	checkpoint_pruned: CheckpointPrunedRecordSchema,
 	decision_requested: DecisionRequestedRecordSchema,
@@ -1085,6 +1108,7 @@ export type SessionStartedRecord = z.infer<typeof SessionStartedRecordSchema>
 export type SessionUpdatedRecord = z.infer<typeof SessionUpdatedRecordSchema>
 export type MessageRecord = z.infer<typeof MessageRecordSchema>
 export type MessageReplacedRecord = z.infer<typeof MessageReplacedRecordSchema>
+export type MessageEditedRecord = z.infer<typeof MessageEditedRecordSchema>
 export type CheckpointWrittenRecord = z.infer<typeof CheckpointWrittenRecordSchema>
 export type CheckpointPrunedRecord = z.infer<typeof CheckpointPrunedRecordSchema>
 export type DecisionRequestedRecord = z.infer<typeof DecisionRequestedRecordSchema>
@@ -1105,6 +1129,7 @@ export type SessionRecordOnly =
 	| SessionUpdatedRecord
 	| MessageRecord
 	| MessageReplacedRecord
+	| MessageEditedRecord
 	| CheckpointWrittenRecord
 	| CheckpointPrunedRecord
 	| DecisionRequestedRecord