@namzu/sdk 21.1.0 → 22.0.0

package/dist/utils/cost.d.ts

@@ -1,11 +1,69 @@
 import { ZERO_COST } from '../constants/limits.js';
 import type { CostInfo, TokenUsage } from '../types/common/index.js';
+/**
+ * What a driver's cache tokens cost, and what they mean.
+ *
+ * `promptIncludesCacheReads` is a property of the DRIVER, not of the model, and
+ * it is why this is a nested object rather than two more rate fields. The
+ * drivers in this repository disagree about it: two report `promptTokens`
+ * excluding cache reads and charge them on top, one reports `promptTokens`
+ * already containing them. Applying a read rate without knowing which one you
+ * have is wrong by the entire cache volume, in a direction that changes with
+ * whoever served the turn — so the fact travels with the rates and is never
+ * inferred.
+ */
+export interface CacheRates {
+    /**
+     * `true`: `usage.cachedTokens` is a SUBSET of `usage.promptTokens`, so the
+     * billable input is the difference.
+     * `false`: they are additional to it.
+     */
+    readonly promptIncludesCacheReads: boolean;
+    readonly readCostPer1M: number;
+    /**
+     * Absent when the driver never reports a cache write. Tokens that arrive
+     * anyway are counted as unpriced rather than charged at some neighbouring
+     * rate, so a driver that starts reporting them surfaces as a gap instead of
+     * a quietly wrong total.
+     */
+    readonly writeCostPer1M?: number;
+}
 export interface ModelPricing {
     inputCostPer1M: number;
     outputCostPer1M: number;
+    /**
+     * Absent means the caller declared a two-rate card and gets a two-rate
+     * answer: prompt and completion tokens are priced, and cache tokens are
+     * left inside whichever of those the driver already counted them in. That
+     * is the host-supplied case and it is a declaration, not a guess on our
+     * part. The catalogue always supplies this.
+     */
+    cache?: CacheRates;
 }
 export { ZERO_COST };
-export declare function calculateCost(usage: TokenUsage, pricing: ModelPricing, cacheDiscount?: number): CostInfo;
-export declare function accumulateCost(current: CostInfo, additionalUsage: TokenUsage, pricing: ModelPricing, cacheDiscount?: number): CostInfo;
+export declare function calculateCost(usage: TokenUsage, pricing: ModelPricing): CostInfo;
+export declare function accumulateCost(current: CostInfo, additionalUsage: TokenUsage, pricing: ModelPricing): CostInfo;
+/**
+ * Record tokens that were consumed at a rate nobody has.
+ *
+ * The alternative was to add nothing and leave the total alone, which is how
+ * every run came to report `$0.00` for work that cost real money. Counting the
+ * tokens instead makes the gap a fact the caller can read and the budget guard
+ * can refuse on, rather than an absence that looks like an answer.
+ *
+ * The rate fields go, if they were there: a total that omits part of a run is
+ * not described by any single card.
+ */
+export declare function accumulateUnpricedCost(current: CostInfo, additionalUsage: TokenUsage): CostInfo;
 export declare function formatCost(usd: number): string;
+/**
+ * How a total should be shown, given what is and is not known about it.
+ *
+ * Exists so that no surface has to re-derive the free/unknown distinction from
+ * two fields and get it subtly wrong. `@namzu/cli` printed
+ * `'$0.0000 (this provider reported no price)'` for every run, because every
+ * run was unpriced; now the two cases really are different and the string has
+ * to follow.
+ */
+export declare function describeCost(cost: CostInfo): string;
 //# sourceMappingURL=cost.d.ts.map

package/dist/utils/cost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAEpE,MAAM,WAAW,YAAY;IAC5B,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;CACvB;AAED,OAAO,EAAE,SAAS,EAAE,CAAA;AAEpB,wBAAgB,aAAa,CAC5B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,EACrB,aAAa,SAAI,GACf,QAAQ,CAWV;AAED,wBAAgB,cAAc,CAC7B,OAAO,EAAE,QAAQ,EACjB,eAAe,EAAE,UAAU,EAC3B,OAAO,EAAE,YAAY,EACrB,aAAa,SAAI,GACf,QAAQ,CAQV;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI9C"}
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAEpE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,wBAAwB,EAAE,OAAO,CAAA;IAC1C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAChC;AAED,MAAM,WAAW,YAAY;IAC5B,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,UAAU,CAAA;CAClB;AAED,OAAO,EAAE,SAAS,EAAE,CAAA;AAiDpB,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,QAAQ,CAShF;AA0DD,wBAAgB,cAAc,CAC7B,OAAO,EAAE,QAAQ,EACjB,eAAe,EAAE,UAAU,EAC3B,OAAO,EAAE,YAAY,GACnB,QAAQ,CASV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,UAAU,GAAG,QAAQ,CAM/F;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAMnD"}

package/dist/utils/cost.js

@@ -1,23 +1,121 @@
 import { ZERO_COST } from '../constants/limits.js';
 export { ZERO_COST };
-export function calculateCost(usage, pricing, cacheDiscount = 0) {
-    const inputCost = (usage.promptTokens / 1_000_000) * pricing.inputCostPer1M;
-    const outputCost = (usage.completionTokens / 1_000_000) * pricing.outputCostPer1M;
-    const gross = inputCost + outputCost;
+function priceUsage(usage, pricing) {
+    const perMillion = (tokens, rate) => (tokens / 1_000_000) * rate;
+    const cache = pricing.cache;
+    if (cache === undefined) {
+        return {
+            cost: perMillion(usage.promptTokens, pricing.inputCostPer1M) +
+                perMillion(usage.completionTokens, pricing.outputCostPer1M),
+            cacheDiscount: 0,
+            unpriced: 0,
+        };
+    }
+    // Never negative: a driver that reports more cached tokens than prompt
+    // tokens is contradicting itself, and clamping keeps that from turning into
+    // a credit on the bill.
+    const billableInput = cache.promptIncludesCacheReads
+        ? Math.max(0, usage.promptTokens - usage.cachedTokens)
+        : usage.promptTokens;
+    const writesRated = cache.writeCostPer1M !== undefined;
+    return {
+        cost: perMillion(billableInput, pricing.inputCostPer1M) +
+            perMillion(usage.completionTokens, pricing.outputCostPer1M) +
+            perMillion(usage.cachedTokens, cache.readCostPer1M) +
+            (writesRated ? perMillion(usage.cacheWriteTokens, cache.writeCostPer1M) : 0),
+        // Reported, not subtracted. The saving is already inside `cost` — the
+        // reads were charged at the read rate rather than the input rate — so
+        // taking it off again would double-count it. This field was previously
+        // declared, defaulted to zero at both call sites, and passed by nobody;
+        // it now carries the one quantity it was always named for.
+        cacheDiscount: perMillion(usage.cachedTokens, pricing.inputCostPer1M - cache.readCostPer1M),
+        unpriced: writesRated ? 0 : usage.cacheWriteTokens,
+    };
+}
+export function calculateCost(usage, pricing) {
+    const priced = priceUsage(usage, pricing);
     return {
         inputCostPer1M: pricing.inputCostPer1M,
         outputCostPer1M: pricing.outputCostPer1M,
-        totalCost: gross - cacheDiscount,
-        cacheDiscount,
+        totalCost: priced.cost,
+        cacheDiscount: priced.cacheDiscount,
+        unpricedTokens: priced.unpriced,
     };
 }
-export function accumulateCost(current, additionalUsage, pricing, cacheDiscount = 0) {
-    const additional = calculateCost(additionalUsage, pricing, cacheDiscount);
-    return {
+/**
+ * Whether `current` is a total nothing has been added to yet.
+ *
+ * All three conditions, not one. A run whose only turn so far was unpriced has
+ * a zero total and no rate fields too, and adopting the next turn's rate card
+ * as though it described the whole total would be exactly the wrong claim.
+ *
+ * This predicate is only sound while every writer of a `CostInfo` goes through
+ * this module or states the truth in its vocabulary. One did not:
+ * `projectEmergencyToCheckpoint` wrote `ZERO_COST` beside a real, non-zero
+ * `tokenUsage`, which is byte-identical to a fresh total — so a run resumed
+ * from an emergency dump would have adopted its next turn's rate card as
+ * covering spend that happened before the crash. That projection now records
+ * the pre-crash tokens as unpriced, which is both true and, usefully, not
+ * fresh-shaped.
+ */
+function isFresh(current) {
+    return (current.totalCost === 0 &&
+        current.unpricedTokens === 0 &&
+        current.inputCostPer1M === undefined &&
+        current.outputCostPer1M === undefined);
+}
+/**
+ * The rate fields that honestly describe `current + pricing`.
+ *
+ * Kept when one card still covers the whole total; dropped when it does not.
+ * Dropping rather than overwriting is the change: the previous version wrote
+ * the incoming card over whatever was there, so a run that swapped models
+ * reported the last card applied as though it had priced every token.
+ *
+ * Equal-but-distinct cards are treated as one, deliberately. Two models at the
+ * same published rate produce a total that a single rate card DOES describe,
+ * which is the only claim these two fields make — they name a rate, not a
+ * model, and `Run.steps[].servedBy` carries which model served each turn.
+ */
+function ratesFor(current, pricing) {
+    const incoming = {
         inputCostPer1M: pricing.inputCostPer1M,
         outputCostPer1M: pricing.outputCostPer1M,
-        totalCost: current.totalCost + additional.totalCost,
-        cacheDiscount: current.cacheDiscount + additional.cacheDiscount,
+    };
+    if (isFresh(current))
+        return incoming;
+    if (current.inputCostPer1M === pricing.inputCostPer1M &&
+        current.outputCostPer1M === pricing.outputCostPer1M) {
+        return incoming;
+    }
+    return {};
+}
+export function accumulateCost(current, additionalUsage, pricing) {
+    const priced = priceUsage(additionalUsage, pricing);
+    const rates = priced.unpriced > 0 ? {} : ratesFor(current, pricing);
+    return {
+        ...rates,
+        totalCost: current.totalCost + priced.cost,
+        cacheDiscount: current.cacheDiscount + priced.cacheDiscount,
+        unpricedTokens: current.unpricedTokens + priced.unpriced,
+    };
+}
+/**
+ * Record tokens that were consumed at a rate nobody has.
+ *
+ * The alternative was to add nothing and leave the total alone, which is how
+ * every run came to report `$0.00` for work that cost real money. Counting the
+ * tokens instead makes the gap a fact the caller can read and the budget guard
+ * can refuse on, rather than an absence that looks like an answer.
+ *
+ * The rate fields go, if they were there: a total that omits part of a run is
+ * not described by any single card.
+ */
+export function accumulateUnpricedCost(current, additionalUsage) {
+    return {
+        totalCost: current.totalCost,
+        cacheDiscount: current.cacheDiscount,
+        unpricedTokens: current.unpricedTokens + additionalUsage.totalTokens,
     };
 }
 export function formatCost(usd) {
@@ -27,4 +125,21 @@ export function formatCost(usd) {
         return `$${usd.toFixed(4)}`;
     return `$${usd.toFixed(2)}`;
 }
+/**
+ * How a total should be shown, given what is and is not known about it.
+ *
+ * Exists so that no surface has to re-derive the free/unknown distinction from
+ * two fields and get it subtly wrong. `@namzu/cli` printed
+ * `'$0.0000 (this provider reported no price)'` for every run, because every
+ * run was unpriced; now the two cases really are different and the string has
+ * to follow.
+ */
+export function describeCost(cost) {
+    if (cost.unpricedTokens === 0)
+        return formatCost(cost.totalCost);
+    if (cost.totalCost === 0) {
+        return `unknown (${cost.unpricedTokens} tokens at no known rate)`;
+    }
+    return `at least ${formatCost(cost.totalCost)} (${cost.unpricedTokens} tokens at no known rate)`;
+}
 //# sourceMappingURL=cost.js.map

package/dist/utils/cost.js.map

@@ -1 +1 @@
-{"version":3,"file":"cost.js","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAQlD,OAAO,EAAE,SAAS,EAAE,CAAA;AAEpB,MAAM,UAAU,aAAa,CAC5B,KAAiB,EACjB,OAAqB,EACrB,aAAa,GAAG,CAAC;IAEjB,MAAM,SAAS,GAAG,CAAC,KAAK,CAAC,YAAY,GAAG,SAAS,CAAC,GAAG,OAAO,CAAC,cAAc,CAAA;IAC3E,MAAM,UAAU,GAAG,CAAC,KAAK,CAAC,gBAAgB,GAAG,SAAS,CAAC,GAAG,OAAO,CAAC,eAAe,CAAA;IACjF,MAAM,KAAK,GAAG,SAAS,GAAG,UAAU,CAAA;IAEpC,OAAO;QACN,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,eAAe,EAAE,OAAO,CAAC,eAAe;QACxC,SAAS,EAAE,KAAK,GAAG,aAAa;QAChC,aAAa;KACb,CAAA;AACF,CAAC;AAED,MAAM,UAAU,cAAc,CAC7B,OAAiB,EACjB,eAA2B,EAC3B,OAAqB,EACrB,aAAa,GAAG,CAAC;IAEjB,MAAM,UAAU,GAAG,aAAa,CAAC,eAAe,EAAE,OAAO,EAAE,aAAa,CAAC,CAAA;IACzE,OAAO;QACN,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,eAAe,EAAE,OAAO,CAAC,eAAe;QACxC,SAAS,EAAE,OAAO,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS;QACnD,aAAa,EAAE,OAAO,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa;KAC/D,CAAA;AACF,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,GAAW;IACrC,IAAI,GAAG,KAAK,CAAC;QAAE,OAAO,OAAO,CAAA;IAC7B,IAAI,GAAG,GAAG,IAAI;QAAE,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAA;IAC3C,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAA;AAC5B,CAAC"}
+{"version":3,"file":"cost.js","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@namzu/sdk",
-  "version": "21.1.0",
+  "version": "22.0.0",
   "description": "Open-source AI agent SDK with a built-in runtime. Nothing between you and your agents.",
   "license": "FSL-1.1-MIT",
   "type": "module",

package/src/advisory/executor.ts

@@ -1,5 +1,6 @@
-import { CHARS_PER_TOKEN } from '../constants/limits.js'
+import { CHARS_PER_TOKEN, ZERO_COST } from '../constants/limits.js'
 import { assembleSystemPrompt } from '../persona/assembler.js'
+import { resolveModelPricing } from '../pricing/index.js'
 import { collect } from '../provider/collect.js'
 
 import type { AdvisorDefinition, AdvisoryBudget } from '../types/advisory/config.js'
@@ -7,7 +8,7 @@ import type { AdvisoryRequest, AdvisoryResult } from '../types/advisory/result.j
 import type { CostInfo, TokenUsage } from '../types/common/index.js'
 import { type Message, createSystemMessage, createUserMessage } from '../types/message/index.js'
 import type { LLMToolSchema } from '../types/tool/index.js'
-import { calculateCost } from '../utils/cost.js'
+import { accumulateUnpricedCost, calculateCost } from '../utils/cost.js'
 import { type Logger, getRootLogger } from '../utils/logger.js'
 import { ADVISORY_RESPONSE_CONTRACT, parseAdvisoryResponse } from './parse.js'
 
@@ -221,16 +222,22 @@ export class AdvisoryExecutor {
 	}
 
 	/**
-	 * Cost for one call, from the advisor's own pricing.
+	 * Cost for one call, from the advisor's own pricing, then the catalogue.
 	 *
-	 * Zero when the advisor carries none — which is honest, not a
-	 * placeholder: a cost CAP over unpriced advisors is refused at
-	 * construction, so nothing enforces against this zero.
+	 * When neither has a rate this reports the tokens as UNPRICED rather than
+	 * as a cost of zero. The previous version returned a zero rate card and a
+	 * zero total, defended on the grounds that a cost CAP over unpriced
+	 * advisors is refused at construction so nothing enforces against it — true
+	 * of the cap, and beside the point for the reader. `AdvisoryResult.cost` is
+	 * reported to the host, and `$0.00` for a call that cost real money is the
+	 * exact defect this change exists to remove; it does not become acceptable
+	 * because the number happens to be unenforced.
 	 */
 	private computeCost(advisor: AdvisorDefinition, usage: TokenUsage): CostInfo {
-		if (!advisor.pricing) {
-			return { inputCostPer1M: 0, outputCostPer1M: 0, totalCost: 0, cacheDiscount: 0 }
+		const pricing = advisor.pricing ?? resolveModelPricing(advisor.provider.id, advisor.model)
+		if (!pricing) {
+			return accumulateUnpricedCost(ZERO_COST, usage)
 		}
-		return calculateCost(usage, advisor.pricing)
+		return calculateCost(usage, pricing)
 	}
 }

package/src/constants/limits.ts

@@ -1,10 +1,22 @@
 import type { CostInfo, TokenUsage } from '../types/common/index.js'
 
+/**
+ * The starting value for a run: nothing accumulated, nothing unpriced.
+ *
+ * Carries NO rate fields, and that is load-bearing rather than tidy. It is what
+ * lets {@link import('../utils/cost.js').accumulateCost} tell "fresh" from
+ * "already spans two rate cards" without a separate marker: a fresh total has
+ * no rates AND no unpriced tokens AND a zero total, and no accumulated one can
+ * have all three.
+ *
+ * It also stops reading as a rate card of zero. `inputCostPer1M: 0` on a run
+ * nobody has priced says the model is free, which was exactly the confusion
+ * `unpricedTokens` was added to end.
+ */
 export const ZERO_COST: CostInfo = {
-	inputCostPer1M: 0,
-	outputCostPer1M: 0,
 	totalCost: 0,
 	cacheDiscount: 0,
+	unpricedTokens: 0,
 }
 
 export const CHARS_PER_TOKEN = 4

package/src/manager/agent/lifecycle.ts

@@ -48,8 +48,8 @@ import type { ThreadManager } from '../thread/lifecycle.js'
  *
  * Phase 9 Known Delta #5: fields are now unconditional required. The legacy
  * "run without deps" compat branch was removed; every `AgentManager` consumer
- * (SDK internals, `@namzu/agents`, `@namzu/api`, `@namzu/cli`) MUST wire the
- * full set before instantiating. Convention #0 (no workarounds): the
+ * (SDK internals and `@namzu/cli`; the list here once also named two packages
+ * that do not exist) MUST wire the full set before instantiating. Convention #0 (no workarounds): the
  * partially-wired mode was a migration-window bridge; 0.2.0 closes it.
  *
  * `workspaceRegistry` is required but may be empty — spawns without a

package/src/manager/run/persistence.ts

@@ -1,5 +1,6 @@
 import { AUTO_CONTINUATION_USER_MESSAGE } from '../../constants/continuation.js'
 import { EMPTY_TOKEN_USAGE } from '../../constants/limits.js'
+import { resolveModelPricing } from '../../pricing/index.js'
 import { DiskCheckpointStore } from '../../store/run/checkpoint-disk.js'
 import { RunDiskStore } from '../../store/run/disk.js'
 import { type CostInfo, type TokenUsage, accumulateTokenUsage } from '../../types/common/index.js'
@@ -11,10 +12,28 @@ import type { EmergencySaveData } from '../../types/run/emergency.js'
 import type { Run, RunPersistenceConfig, StepResult, StopReason } from '../../types/run/index.js'
 import type { RunStore } from '../../types/run/store.js'
 import type { ProjectId, ThreadId } from '../../types/session/ids.js'
-import { type ModelPricing, ZERO_COST, accumulateCost } from '../../utils/cost.js'
+import {
+	type ModelPricing,
+	ZERO_COST,
+	accumulateCost,
+	accumulateUnpricedCost,
+} from '../../utils/cost.js'
 import { generateEmergencySaveId } from '../../utils/id.js'
 import type { Logger } from '../../utils/logger.js'
 
+/**
+ * The pair a rate lookup needs: which driver, running which model.
+ *
+ * `model` may be absent because a driver can be pointed at whatever the host
+ * configured and some report nothing back. Absent resolves to no rate, which
+ * is the honest answer, EXCEPT for a driver that bills nothing whatever it
+ * runs — see `resolveModelPricing`.
+ */
+export interface PricingSubject {
+	readonly providerId: string
+	readonly model: string | undefined
+}
+
 export class RunPersistence {
 	private run: Run
 	private runStore: RunStore
@@ -266,12 +285,38 @@ export class RunPersistence {
 		this.run.messages.push(message)
 	}
 
-	accumulateUsage(usage: TokenUsage): void {
+	/**
+	 * Who served the tokens being accumulated, so a rate can be found for them.
+	 *
+	 * Both fields are required. The previous signature took usage alone and
+	 * priced it from one table the run was constructed with, which is why the
+	 * only way to get a non-zero cost was for a host to pass that table — and
+	 * no shipped surface did. Naming the subject at every call site is what
+	 * lets the catalogue answer, and it makes a site that cannot say who served
+	 * a compile error rather than a silent misattribution.
+	 */
+	private resolvePricing(servedBy: PricingSubject): ModelPricing | undefined {
+		// A host-supplied table wins. It is a deliberate declaration about this
+		// run, and `query()` already refuses to accept one alongside a provider
+		// chain of more than one member, so it cannot be silently spread across
+		// two rate cards here.
+		if (this.pricing) return this.pricing
+		return resolveModelPricing(servedBy.providerId, servedBy.model)
+	}
+
+	accumulateUsage(usage: TokenUsage, servedBy: PricingSubject): void {
 		this.run.tokenUsage = accumulateTokenUsage(this.run.tokenUsage, usage)
 
-		if (this.pricing) {
-			this.run.costInfo = accumulateCost(this.run.costInfo, usage, this.pricing)
-		}
+		const pricing = this.resolvePricing(servedBy)
+		// No rate is not the same as a rate of zero, and the difference is the
+		// whole point of this change. Tokens nobody can price are counted as
+		// such, so `costInfo.unpricedTokens` distinguishes "this cost nothing"
+		// from "nobody knows what this cost" — and so the budget guard can
+		// refuse rather than pass a limit it cannot measure.
+		this.run.costInfo =
+			pricing === undefined
+				? accumulateUnpricedCost(this.run.costInfo, usage)
+				: accumulateCost(this.run.costInfo, usage, pricing)
 	}
 
 	/**
@@ -287,8 +332,8 @@ export class RunPersistence {
 	 * plain {@link accumulateUsage} instead: their prompts are not the
 	 * run's context, and letting them write here would corrupt the signal.
 	 */
-	recordTurnUsage(usage: TokenUsage): void {
-		this.accumulateUsage(usage)
+	recordTurnUsage(usage: TokenUsage, servedBy: PricingSubject): void {
+		this.accumulateUsage(usage, servedBy)
 		this._lastPromptTokens = usage.promptTokens
 		// How much of the history that number covers. The loop pushes the
 		// assistant message and its tool results AFTER this call, so without
@@ -393,6 +438,21 @@ export class RunPersistence {
 		this.run.metadata.servingProvider = providerId
 	}
 
+	/**
+	 * Who is serving right now, for a side-channel call that has no provenance
+	 * of its own.
+	 *
+	 * The main loop does not use this — it reads `servedBy` off the turn, which
+	 * is exact. Compaction and the closing summary go through the same wrapped
+	 * provider without recording who answered, and this is the best available
+	 * answer for them: the fallback decorator reports the head member's id
+	 * whoever is actually serving, so asking the provider would hand back the
+	 * declaration rather than the fact.
+	 */
+	get servingProviderId(): string {
+		return this.run.metadata.servingProvider ?? this.run.metadata.provider
+	}
+
 	clearLastPromptTokens(): void {
 		this._lastPromptTokens = undefined
 		this._lastPromptMessageCount = undefined