@namzu/sdk 45.1.0 → 48.0.0

package/src/pricing/catalogue.generated.ts

@@ -5,7 +5,7 @@
 // CI re-runs the generator and fails on any difference, so a hand edit here is
 // reverted by the next run at best and reported as drift at worst.
 //
-// 4 vendors, 32 priced models.
+// 4 vendors, 35 priced models.
 
 import type { ModelPricing } from '../utils/cost.js'
 
@@ -35,6 +35,14 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 1, writeCostPer1M: 12.5 },
 				},
 			],
+			[
+				'claude-fable-5-1',
+				{
+					inputCostPer1M: 10,
+					outputCostPer1M: 50,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.25, writeCostPer1M: 12.5 },
+				},
+			],
 			[
 				'claude-haiku-4-5',
 				{
@@ -51,6 +59,14 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 1, writeCostPer1M: 12.5 },
 				},
 			],
+			[
+				'claude-mythos-5-1',
+				{
+					inputCostPer1M: 10,
+					outputCostPer1M: 50,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.25, writeCostPer1M: 12.5 },
+				},
+			],
 			[
 				'claude-opus-4-1',
 				{
@@ -91,6 +107,14 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.5, writeCostPer1M: 6.25 },
 				},
 			],
+			[
+				'claude-opus-5-5',
+				{
+					inputCostPer1M: 4,
+					outputCostPer1M: 20,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.2, writeCostPer1M: 5 },
+				},
+			],
 			[
 				'claude-sonnet-4-5',
 				{
@@ -110,9 +134,9 @@ export const VENDOR_RATES: readonly VendorRates[] = [
 			[
 				'claude-sonnet-5',
 				{
-					inputCostPer1M: 3,
-					outputCostPer1M: 15,
-					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.3, writeCostPer1M: 3.75 },
+					inputCostPer1M: 2,
+					outputCostPer1M: 10,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.2, writeCostPer1M: 2.5 },
 				},
 			],
 		]),

package/src/pricing/rates.source.json

@@ -56,11 +56,32 @@
 		{
 			"providerId": "anthropic",
 			"unmetered": false,
-			"verified": "2026-08-10",
+			"verified": "2026-09-24",
 			"promptIncludesCacheReads": false,
 			"reportsCacheWrites": true,
-			"note": "The last two rows exist because the driver's own offline catalogue offers those models and this table did not price them — a lookup-key gap that reads as `cost unknown` and is invisible to the generator's own check, which only proves the module matches this file. `providers/anthropic` asserts the two lists agree. Vendor list prices. Cache read is the vendor's published 0.1x of the input rate; cache write is its published 1.25x for the five-minute entry, which is the default TTL and the one the driver's `cacheControl: { type: 'auto' }` asks for. A time-limited introductory rate applied to one model at the time of entry; this table has no time dimension and records the list rate, so a turn inside a promotional window is over-reported rather than mis-modelled.",
+			"note": "The last two rows exist because the driver's own offline catalogue offers those models and this table did not price them — a lookup-key gap that reads as `cost unknown` and is invisible to the generator's own check, which only proves the module matches this file. `providers/anthropic` asserts the two lists agree. Vendor list prices, every row checked against its pricing page on the `verified` date. Cache read is the vendor's published 0.1x of the input rate, except on the three models it prices differently: 0.05x on claude-opus-5-5 and 0.025x on claude-fable-5-1 and claude-mythos-5-1, entered at the published rate rather than derived. Cache write is its published 1.25x for the five-minute entry, which is the default TTL and the one the driver's `cacheControl: { type: 'auto' }` asks for. claude-sonnet-5 launched at an introductory $2/$10 with $3/$15 scheduled from 2026-09-01, and this table recorded the scheduled rate; the vendor has since made $2/$10 the standard price and cancelled the increase. The table has no time dimension, so a future promotional window is still recorded at the list rate and over-reported rather than mis-modelled.",
 			"models": [
+				{
+					"id": "claude-fable-5-1",
+					"inputPer1M": 10,
+					"outputPer1M": 50,
+					"cacheReadPer1M": 0.25,
+					"cacheWritePer1M": 12.5
+				},
+				{
+					"id": "claude-mythos-5-1",
+					"inputPer1M": 10,
+					"outputPer1M": 50,
+					"cacheReadPer1M": 0.25,
+					"cacheWritePer1M": 12.5
+				},
+				{
+					"id": "claude-opus-5-5",
+					"inputPer1M": 4,
+					"outputPer1M": 20,
+					"cacheReadPer1M": 0.2,
+					"cacheWritePer1M": 5
+				},
 				{
 					"id": "claude-fable-5",
 					"inputPer1M": 10,
@@ -105,10 +126,10 @@
 				},
 				{
 					"id": "claude-sonnet-5",
-					"inputPer1M": 3,
-					"outputPer1M": 15,
-					"cacheReadPer1M": 0.3,
-					"cacheWritePer1M": 3.75
+					"inputPer1M": 2,
+					"outputPer1M": 10,
+					"cacheReadPer1M": 0.2,
+					"cacheWritePer1M": 2.5
 				},
 				{
 					"id": "claude-sonnet-4-6",

package/src/probe/errors.ts

@@ -1,10 +1,13 @@
+import { RegistryCollisionError } from '../registry/collision.js'
 import type { VetoableEventKind } from '../types/probe/index.js'
 
-export class ProbeNameCollisionError extends Error {
+export class ProbeNameCollisionError extends RegistryCollisionError {
 	readonly probeName: string
 
 	constructor(probeName: string) {
 		super(
+			'ProbeRegistry',
+			probeName,
 			`Probe name "${probeName}" is already registered. Pass { override: true } to replace, or pick a different name.`,
 		)
 		this.name = 'ProbeNameCollisionError'

package/src/prompt/coding-agent-doctrine.ts

@@ -97,14 +97,20 @@ When you have understood the task, reply with the plan: what you would change, i
 
 /**
  * Appended after {@link CODING_AGENT_DELEGATION_DOCTRINE} only for a host
- * session that has an orchestration mode turned on. See
- * {@link CodingAgentDoctrineOptions.orchestrate}: this text is a stronger
+ * session that has hypermode (its multi-agent mode) turned on. See
+ * {@link CodingAgentDoctrineOptions.hypermode}: this text is a stronger
  * restatement of the existing delegation rule, not a new capability — it
  * creates no roster, starts no work by itself, and names no tool the base
  * doctrine did not already name.
  */
-export const CODING_AGENT_ORCHESTRATE_DOCTRINE = `### Orchestrate mode
-This session has orchestrate mode on: treat delegation through \`Agent\` as the default for substantive work, not the exception. Before doing multi-step work yourself, ask whether an independent piece of it — a lookup, a draft, a check — could run as its own delegation, and prefer delegating it when the answer is yes. This changes only how eagerly you reach for \`Agent\` on work you would otherwise do inline; it does not mount a roster or start any delegation by itself. Agents in the same phase are launched in the same response, each with \`run_in_background: true\` when you mean to wait for them together; a phase is never started one agent at a time.`
+export const CODING_AGENT_HYPERMODE_DOCTRINE = `### Hypermode
+This session has hypermode on: treat delegation through \`Agent\` as the default for substantive work, not the exception. Before doing multi-step work yourself, ask whether an independent piece of it — a lookup, a draft, a check — could run as its own delegation, and prefer delegating it when the answer is yes. This changes only how eagerly you reach for \`Agent\` on work you would otherwise do inline; it does not mount a roster or start any delegation by itself. Agents in the same phase are launched in the same response, each with \`run_in_background: true\` when you mean to wait for them together; a phase is never started one agent at a time.`
+
+/**
+ * @deprecated Renamed {@link CODING_AGENT_HYPERMODE_DOCTRINE}; the mode it
+ * describes is now called hypermode. Same value. Removed in the next major.
+ */
+export const CODING_AGENT_ORCHESTRATE_DOCTRINE = CODING_AGENT_HYPERMODE_DOCTRINE
 
 export const CODING_AGENT_DOCTRINE_CONTRIBUTION_ID = 'namzu.coding-agent-doctrine'
 
@@ -116,15 +122,21 @@ export interface CodingAgentDoctrineOptions {
 	 */
 	delegation?: boolean
 	/**
-	 * Append {@link CODING_AGENT_ORCHESTRATE_DOCTRINE} after the delegation
-	 * rules, for a host session whose operator turned on an orchestration
-	 * mode. Default `false`, and ignored when `delegation` is `false` — a
-	 * sub-agent prompt never carries delegation guidance of any strength.
+	 * Append {@link CODING_AGENT_HYPERMODE_DOCTRINE} after the delegation
+	 * rules, for a host session whose operator turned hypermode on. Default
+	 * `false`, and ignored when `delegation` is `false` — a sub-agent prompt
+	 * never carries delegation guidance of any strength.
 	 * Display/prompt-only: it creates no scheduling, no roster and no kernel
 	 * behaviour change, the same guarantee the `workflow`/`phase` labels on
 	 * `agent_pending` make. With this left at its default the rendered text
 	 * is byte-identical to before this option existed.
 	 */
+	hypermode?: boolean
+	/**
+	 * @deprecated Renamed {@link CodingAgentDoctrineOptions.hypermode}. Still
+	 * honoured: either flag set to `true` appends the text. Removed in the
+	 * next major.
+	 */
 	orchestrate?: boolean
 }
 
@@ -140,8 +152,8 @@ export function codingAgentDoctrineContribution(
 	const text = [
 		CODING_AGENT_WORKING_DOCTRINE,
 		options.delegation === false ? undefined : CODING_AGENT_DELEGATION_DOCTRINE,
-		options.delegation !== false && options.orchestrate
-			? CODING_AGENT_ORCHESTRATE_DOCTRINE
+		options.delegation !== false && (options.hypermode || options.orchestrate)
+			? CODING_AGENT_HYPERMODE_DOCTRINE
 			: undefined,
 	]
 		.filter((part): part is string => Boolean(part))

package/src/prompt/contributions.ts

@@ -1,4 +1,5 @@
 import { renderSkillsSection } from '../persona/assembler.js'
+import { RegistryCollisionError } from '../registry/collision.js'
 import type { AgentRuntimeContext } from '../types/agent/base.js'
 import type { Skill } from '../types/skills/index.js'
 
@@ -112,11 +113,15 @@ export interface PromptContribution {
 }
 
 /** Two contributions claiming one id. */
-export class PromptContributionCollisionError extends Error {
+export class PromptContributionCollisionError extends RegistryCollisionError {
 	readonly details: { id: string }
 
 	constructor(details: { id: string }) {
-		super(`A prompt contribution with id "${details.id}" is already registered.`)
+		super(
+			'PromptContributionRegistry',
+			details.id,
+			`A prompt contribution with id "${details.id}" is already registered.`,
+		)
 		this.name = 'PromptContributionCollisionError'
 		this.details = details
 	}
@@ -145,6 +150,11 @@ export class PromptContributionRegistry {
 		this.byId.set(contribution.id, contribution)
 	}
 
+	/** Revoke one contribution when its owner is disabled or uninstalled. */
+	unregister(id: string): boolean {
+		return this.byId.delete(id)
+	}
+
 	has(id: string): boolean {
 		return this.byId.has(id)
 	}

package/src/prompt/index.ts

@@ -16,6 +16,7 @@ export type {
 export {
 	CODING_AGENT_DELEGATION_DOCTRINE,
 	CODING_AGENT_DOCTRINE_CONTRIBUTION_ID,
+	CODING_AGENT_HYPERMODE_DOCTRINE,
 	CODING_AGENT_ORCHESTRATE_DOCTRINE,
 	CODING_AGENT_WORKING_DOCTRINE,
 	PLAN_MODE_DOCTRINE,

package/src/provider/collect-chat-completion.ts

@@ -1,8 +1,33 @@
 import { mergeTokenUsage } from '../types/common/index.js'
-import type { ReasoningBlock } from '../types/message/index.js'
+import type { ReasoningBlock, ToolInputError } from '../types/message/index.js'
 import type { ChatCompletionResponse } from '../types/provider/chat.js'
 import type { StreamChunk } from '../types/provider/stream.js'
 import { StreamTextAccumulator } from './stream-text.js'
+import {
+	INTERLEAVED_TOOL_INPUT_PARSE_ERROR,
+	ToolCallIndexer,
+	describeToolCallFramingViolation,
+	isUnindexedFragment,
+	toolCallFramingViolation,
+} from './tool-call-framing.js'
+
+/**
+ * Whether a streamed argument buffer could still be receiving more of a
+ * call's arguments right now: empty, or not yet a complete JSON value. Used
+ * only by `ToolCallIndexer.placeUnindexedFragment` to tell which open calls
+ * could still be an id-less fragment's target — not to validate a finished
+ * call, so it does not need the offset-finding `parseToolArguments` the turn
+ * loop uses for the message a model is shown.
+ */
+function canAcceptMoreText(buffer: string): boolean {
+	if (!buffer) return true
+	try {
+		JSON.parse(buffer)
+		return false
+	} catch {
+		return true
+	}
+}
 
 /**
  * Drains a {@link StreamChunk} async iterable into the equivalent
@@ -18,7 +43,12 @@ import { StreamTextAccumulator } from './stream-text.js'
  * - ordinary text is concatenated in delta order; identified public text
  *   items are preserved and explicit final-answer items select the settled text;
  * - tool calls are bucketed by `index` into the existing
- *   `Array<{ id, function: { name, arguments } }>` shape;
+ *   `Array<{ id, function: { name, arguments } }>` shape. Arguments that
+ *   arrive before the call's id belong to the call at their index and are
+ *   kept; the id is filled in when it arrives. A stream that puts a second
+ *   call id on an index is refused with an error naming the violation, as
+ *   the turn loop refuses it: the second call's arguments used to be
+ *   appended to the first's, which left one call no tool could run;
  * - reasoning blocks are bucketed by `index` the same way, because the
  *   assembled message is the thing a caller replays and
  *   {@link ReasoningBlock} is documented as replayed verbatim. This was
@@ -41,6 +71,7 @@ export async function collectChatCompletion(
 	const text = new StreamTextAccumulator()
 	let replayState: unknown
 	let finishReason: ChatCompletionResponse['finishReason'] = 'stop'
+	let finishDetail: ChatCompletionResponse['finishDetail']
 	let usage: ChatCompletionResponse['usage'] = {
 		promptTokens: 0,
 		completionTokens: 0,
@@ -49,7 +80,12 @@ export async function collectChatCompletion(
 		cacheWriteTokens: 0,
 	}
 
-	const toolBuckets = new Map<number, { id: string; name: string; argsBuf: string }>()
+	const toolBuckets = new Map<
+		number,
+		{ id: string; name: string; argsBuf: string; unreadable?: boolean }
+	>()
+	// Places a fragment that came without an index; see `ToolCallIndexer`.
+	const toolIndexer = new ToolCallIndexer()
 	// Same bucketing rule the turn loop uses (`runtime/query/iteration/
 	// stream-turn.ts`), so a message assembled here and a message assembled
 	// there carry the same blocks in the same order.
@@ -81,18 +117,47 @@ export async function collectChatCompletion(
 		}
 
 		for (const tc of chunk.delta.toolCalls ?? []) {
-			const bucket = toolBuckets.get(tc.index) ?? {
-				id: '',
-				name: '',
-				argsBuf: '',
+			if (isUnindexedFragment(tc)) {
+				// Neither an id nor an index: never a guess. Evaluated fresh for
+				// THIS fragment, not decided once when some call opened.
+				const placement = toolIndexer.placeUnindexedFragment((i) =>
+					canAcceptMoreText(toolBuckets.get(i)?.argsBuf ?? ''),
+				)
+				if (typeof placement === 'number') {
+					const bucket = toolBuckets.get(placement) ?? { id: '', name: '', argsBuf: '' }
+					if (tc.function?.name) bucket.name = tc.function.name
+					if (tc.function?.arguments) bucket.argsBuf += tc.function.arguments
+					toolBuckets.set(placement, bucket)
+				} else {
+					// More than one open call could still have taken this
+					// fragment, or none could: every candidate is unreadable, and
+					// the fragment itself is attributed to none of them —
+					// appending it to a guess is exactly the splice this exists
+					// to refuse.
+					for (const candidate of placement.candidates) {
+						const bucket = toolBuckets.get(candidate.index)
+						if (bucket) bucket.unreadable = true
+					}
+				}
+				continue
 			}
-			if (tc.id) bucket.id = tc.id
+			const index = toolIndexer.indexOf(tc)
+			const open = toolBuckets.get(index)
+			const violation = toolCallFramingViolation(open, tc, index)
+			if (violation) {
+				throw new Error(`Provider stream error: ${describeToolCallFramingViolation(violation)}`)
+			}
+			const bucket = open ?? { id: '', name: '', argsBuf: '' }
+			if (tc.id && !bucket.id) bucket.id = tc.id
 			if (tc.function?.name) bucket.name = tc.function.name
 			if (tc.function?.arguments) bucket.argsBuf += tc.function.arguments
-			toolBuckets.set(tc.index, bucket)
+			toolBuckets.set(index, bucket)
 		}
 
-		if (chunk.finishReason) finishReason = chunk.finishReason
+		if (chunk.finishReason) {
+			finishReason = chunk.finishReason
+			finishDetail = chunk.finishReason === 'length' ? chunk.finishDetail : undefined
+		}
 		// Merge (per-field max), not last-write-wins: a late frame that omits
 		// input/cache tokens must not zero the counts captured earlier in the stream.
 		if (chunk.usage) usage = mergeTokenUsage(usage, chunk.usage)
@@ -103,7 +168,26 @@ export async function collectChatCompletion(
 		.map(([, b]) => ({
 			id: b.id,
 			type: 'function' as const,
-			function: { name: b.name, arguments: b.argsBuf },
+			// An interleaved call is never returned with the buffer it
+			// accumulated: that buffer may hold another call's spliced-in
+			// fragments, or may simply be missing whatever an id-less
+			// fragment carried elsewhere instead. Normalized to `{}`, exactly
+			// as the turn loop normalizes any other unreadable call.
+			function: { name: b.name, arguments: b.unreadable ? '{}' : b.argsBuf },
+			...(b.unreadable
+				? {
+						metadata: {
+							inputTruncated: true,
+							partialArguments: b.argsBuf,
+							inputError: {
+								reason: 'malformed',
+								parseError: INTERLEAVED_TOOL_INPUT_PARSE_ERROR,
+								length: b.argsBuf.length,
+								precedingLength: 0,
+							} satisfies ToolInputError,
+						},
+					}
+				: {}),
 		}))
 
 	const reasoningBlocks: ReasoningBlock[] = [...reasoningBuckets.entries()]
@@ -122,6 +206,7 @@ export async function collectChatCompletion(
 			...(replayState !== undefined ? { replayState } : {}),
 		},
 		finishReason,
+		...(finishDetail ? { finishDetail } : {}),
 		usage,
 	}
 }

package/src/provider/mock.ts

@@ -129,8 +129,15 @@ export class MockLLMProvider implements LLMProvider {
 			}
 
 			// Arguments arrive as JSON fragments, which is what forces the
-			// consumer's partial-JSON buffering to be exercised.
-			const args = call.rawArguments ?? JSON.stringify(call.args ?? {})
+			// consumer's partial-JSON buffering to be exercised. A truncated
+			// call stops halfway, as the output limit stops a real one: it
+			// used to send every fragment and only withhold the block close,
+			// so the arguments parsed and nothing was truncated at all.
+			const fullArgs = call.rawArguments ?? JSON.stringify(call.args ?? {})
+			const args =
+				call.truncateArguments === true
+					? fullArgs.slice(0, Math.max(1, Math.floor(fullArgs.length / 2)))
+					: fullArgs
 			const step = call.argChunkSize ?? Math.max(1, Math.ceil(args.length / 3))
 			for (let i = 0; i < args.length; i += step) {
 				yield {
@@ -143,15 +150,26 @@ export class MockLLMProvider implements LLMProvider {
 				throw new Error(call.throwAfterArguments)
 			}
 
-			if (call.truncateArguments !== true) {
-				yield { id, delta: { toolCallEnd: { index, id: callId } } }
-			}
+			// An output limit stops the response where it is, so nothing the
+			// script puts after a truncated call is streamed. It used to go on
+			// to the next call, which made the cut call one the model had
+			// moved on from: malformed, not truncated.
+			if (call.truncateArguments === true) break
+			yield { id, delta: { toolCallEnd: { index, id: callId } } }
 		}
 
 		yield {
 			id,
 			delta: {},
-			finishReason: turn.finishReason ?? (toolCalls.length > 0 ? 'tool_calls' : 'stop'),
+			finishReason:
+				turn.finishReason ??
+				// A call cut off mid-JSON is what the output limit does, and the
+				// finish reason is how a consumer tells that from malformed JSON.
+				(toolCalls.some((call) => call.truncateArguments === true)
+					? 'length'
+					: toolCalls.length > 0
+						? 'tool_calls'
+						: 'stop'),
 			usage: { ...EMPTY_USAGE, ...turn.usage },
 		}
 	}

package/src/provider/registry.ts

@@ -1,3 +1,4 @@
+import { RegistryCollisionError } from '../registry/collision.js'
 import type {
 	LLMProvider,
 	LLMProviderConstructor,
@@ -23,11 +24,13 @@ export class UnknownProviderError extends Error {
 	}
 }
 
-export class DuplicateProviderError extends Error {
+export class DuplicateProviderError extends RegistryCollisionError {
 	readonly providerType: string
 
 	constructor(providerType: string) {
 		super(
+			'ProviderRegistry',
+			providerType,
 			`Provider type "${providerType}" is already registered. Pass { replace: true } to override an existing registration.`,
 		)
 		this.name = 'DuplicateProviderError'