@namzu/sdk 21.0.0 → 22.0.0

package/src/pricing/catalogue.generated.ts

@@ -0,0 +1,308 @@
+// GENERATED FILE — DO NOT EDIT.
+//
+// Produced by `node scripts/generate-model-prices.mjs` from
+// `packages/sdk/src/pricing/rates.source.json`, which is the file to edit.
+// 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.
+
+import type { ModelPricing } from '../utils/cost.js'
+
+export interface VendorRates {
+	/** Matched against `LLMProvider.id`. */
+	readonly providerId: string
+	/**
+	 * This driver bills nothing for a token, whatever the model — local
+	 * inference. Its runs are priced at zero, which is KNOWN-free and so
+	 * distinct from a model nobody has a rate for.
+	 */
+	readonly unmetered: boolean
+	/** Keyed by normalised model id. Empty when `unmetered`. */
+	readonly models: ReadonlyMap<string, ModelPricing>
+}
+
+export const VENDOR_RATES: readonly VendorRates[] = [
+	{
+		providerId: 'anthropic',
+		unmetered: false,
+		models: new Map([
+			[
+				'claude-fable-5',
+				{
+					inputCostPer1M: 10,
+					outputCostPer1M: 50,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 1, writeCostPer1M: 12.5 },
+				},
+			],
+			[
+				'claude-haiku-4-5',
+				{
+					inputCostPer1M: 1,
+					outputCostPer1M: 5,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.1, writeCostPer1M: 1.25 },
+				},
+			],
+			[
+				'claude-mythos-5',
+				{
+					inputCostPer1M: 10,
+					outputCostPer1M: 50,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 1, writeCostPer1M: 12.5 },
+				},
+			],
+			[
+				'claude-opus-4-1',
+				{
+					inputCostPer1M: 15,
+					outputCostPer1M: 75,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 1.5, writeCostPer1M: 18.75 },
+				},
+			],
+			[
+				'claude-opus-4-6',
+				{
+					inputCostPer1M: 5,
+					outputCostPer1M: 25,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.5, writeCostPer1M: 6.25 },
+				},
+			],
+			[
+				'claude-opus-4-7',
+				{
+					inputCostPer1M: 5,
+					outputCostPer1M: 25,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.5, writeCostPer1M: 6.25 },
+				},
+			],
+			[
+				'claude-opus-4-8',
+				{
+					inputCostPer1M: 5,
+					outputCostPer1M: 25,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.5, writeCostPer1M: 6.25 },
+				},
+			],
+			[
+				'claude-opus-5',
+				{
+					inputCostPer1M: 5,
+					outputCostPer1M: 25,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.5, writeCostPer1M: 6.25 },
+				},
+			],
+			[
+				'claude-sonnet-4-5',
+				{
+					inputCostPer1M: 3,
+					outputCostPer1M: 15,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.3, writeCostPer1M: 3.75 },
+				},
+			],
+			[
+				'claude-sonnet-4-6',
+				{
+					inputCostPer1M: 3,
+					outputCostPer1M: 15,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.3, writeCostPer1M: 3.75 },
+				},
+			],
+			[
+				'claude-sonnet-5',
+				{
+					inputCostPer1M: 3,
+					outputCostPer1M: 15,
+					cache: { promptIncludesCacheReads: false, readCostPer1M: 0.3, writeCostPer1M: 3.75 },
+				},
+			],
+		]),
+	},
+	{
+		providerId: 'lmstudio',
+		unmetered: true,
+		models: new Map([
+			// none — see `unmetered`.
+		]),
+	},
+	{
+		providerId: 'ollama',
+		unmetered: true,
+		models: new Map([
+			// none — see `unmetered`.
+		]),
+	},
+	{
+		providerId: 'openai',
+		unmetered: false,
+		models: new Map([
+			[
+				'gpt-4.1',
+				{
+					inputCostPer1M: 2,
+					outputCostPer1M: 8,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.5 },
+				},
+			],
+			[
+				'gpt-4.1-mini',
+				{
+					inputCostPer1M: 0.4,
+					outputCostPer1M: 1.6,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.1 },
+				},
+			],
+			[
+				'gpt-4.1-nano',
+				{
+					inputCostPer1M: 0.1,
+					outputCostPer1M: 0.4,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.025 },
+				},
+			],
+			[
+				'gpt-4o',
+				{
+					inputCostPer1M: 2.5,
+					outputCostPer1M: 10,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 1.25 },
+				},
+			],
+			[
+				'gpt-4o-mini',
+				{
+					inputCostPer1M: 0.15,
+					outputCostPer1M: 0.6,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.075 },
+				},
+			],
+			[
+				'gpt-5',
+				{
+					inputCostPer1M: 1.25,
+					outputCostPer1M: 10,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.125 },
+				},
+			],
+			[
+				'gpt-5-mini',
+				{
+					inputCostPer1M: 0.25,
+					outputCostPer1M: 2,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.025 },
+				},
+			],
+			[
+				'gpt-5-nano',
+				{
+					inputCostPer1M: 0.05,
+					outputCostPer1M: 0.4,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.005 },
+				},
+			],
+			[
+				'gpt-5.1',
+				{
+					inputCostPer1M: 1.25,
+					outputCostPer1M: 10,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.125 },
+				},
+			],
+			[
+				'gpt-5.2',
+				{
+					inputCostPer1M: 1.75,
+					outputCostPer1M: 14,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.175 },
+				},
+			],
+			[
+				'gpt-5.4',
+				{
+					inputCostPer1M: 2.5,
+					outputCostPer1M: 15,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.25 },
+				},
+			],
+			[
+				'gpt-5.4-mini',
+				{
+					inputCostPer1M: 0.75,
+					outputCostPer1M: 4.5,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.075 },
+				},
+			],
+			[
+				'gpt-5.4-nano',
+				{
+					inputCostPer1M: 0.2,
+					outputCostPer1M: 1.25,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.02 },
+				},
+			],
+			[
+				'gpt-5.5',
+				{
+					inputCostPer1M: 5,
+					outputCostPer1M: 30,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.5 },
+				},
+			],
+			[
+				'gpt-5.6-luna',
+				{
+					inputCostPer1M: 0.2,
+					outputCostPer1M: 1.2,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.02 },
+				},
+			],
+			[
+				'gpt-5.6-sol',
+				{
+					inputCostPer1M: 5,
+					outputCostPer1M: 30,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.5 },
+				},
+			],
+			[
+				'gpt-5.6-terra',
+				{
+					inputCostPer1M: 2,
+					outputCostPer1M: 12,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.2 },
+				},
+			],
+			[
+				'o1',
+				{
+					inputCostPer1M: 15,
+					outputCostPer1M: 60,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 7.5 },
+				},
+			],
+			[
+				'o3',
+				{
+					inputCostPer1M: 2,
+					outputCostPer1M: 8,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.5 },
+				},
+			],
+			[
+				'o3-mini',
+				{
+					inputCostPer1M: 1.1,
+					outputCostPer1M: 4.4,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.55 },
+				},
+			],
+			[
+				'o4-mini',
+				{
+					inputCostPer1M: 1.1,
+					outputCostPer1M: 4.4,
+					cache: { promptIncludesCacheReads: true, readCostPer1M: 0.275 },
+				},
+			],
+		]),
+	},
+]

package/src/pricing/index.ts

@@ -0,0 +1,78 @@
+/**
+ * Rate lookup for a run's tokens.
+ *
+ * The kernel had a cost calculation and no data to feed it: `costInfo` moved
+ * only when a host passed `pricing` to `query()`, no shipped surface passed
+ * one, and so every run reported a total of zero. `runConfig.costLimitUsd` is
+ * enforced against that same total, which made a declared budget a budget that
+ * could never trigger.
+ *
+ * This is the data. It is IN-TREE and versioned at build time rather than
+ * fetched, so a cost number is reproducible from a commit and an offline run
+ * still prices correctly — a runtime fetch gives neither. See
+ * `scripts/generate-model-prices.mjs` for why the source is reviewed rather
+ * than refreshed, and `rates.source.json` for the rates themselves.
+ */
+
+import type { ModelPricing } from '../utils/cost.js'
+import { VENDOR_RATES } from './catalogue.generated.js'
+
+export type { VendorRates } from './catalogue.generated.js'
+export { VENDOR_RATES }
+
+/** A driver that bills nothing per token resolves to this. */
+const UNMETERED: ModelPricing = { inputCostPer1M: 0, outputCostPer1M: 0 }
+
+const BY_PROVIDER = new Map(VENDOR_RATES.map((vendor) => [vendor.providerId, vendor]))
+
+/**
+ * A dated snapshot suffix, in the two shapes vendors actually ship:
+ * `claude-sonnet-4-5-20250929` and `claude-opus-4-5@20251101`. Stripping it
+ * is the ONLY normalisation, because a snapshot of a model is that model at
+ * that model's rate — the vendor prices the family, not the date.
+ */
+const SNAPSHOT_SUFFIX = /[-@]\d{8}$/
+
+/** Lowercase, snapshot suffix removed. Exported because tests assert it. */
+export function normaliseModelId(model: string): string {
+	return model.toLowerCase().replace(SNAPSHOT_SUFFIX, '')
+}
+
+/**
+ * The rate card for a model, or `undefined` when nobody here has one.
+ *
+ * `undefined` is a real answer and the caller must keep it distinct from a
+ * rate of zero. Zero means this run genuinely costs nothing — the local
+ * drivers, which bill per token exactly never. `undefined` means the total is
+ * unknowable, and a caller that flattens the two reproduces the defect this
+ * whole module exists to remove, one level down.
+ *
+ * ## Matching is exact, and that is the point
+ *
+ * The neighbouring context-window table matches on longest substring, and it
+ * is right to: a window guessed one size small costs a compaction pass. A rate
+ * guessed one row across costs the caller money and moves their budget. Inside
+ * a single vendor here, ids one character apart differ in price by 4x and by
+ * 24x. So a near-miss is not a degraded answer, it is a wrong one, and this
+ * returns `undefined` instead — which is safe by construction, because
+ * `undefined` refuses rather than proceeds.
+ *
+ * The cost of exactness is stated rather than hidden: a model the vendor has
+ * released since this table was reviewed is unpriced until somebody adds the
+ * row. That is a visible, fixable gap. A silently wrong total is neither.
+ */
+export function resolveModelPricing(
+	providerId: string,
+	model: string | undefined,
+): ModelPricing | undefined {
+	const vendor = BY_PROVIDER.get(providerId)
+	if (vendor === undefined) return undefined
+	// Checked before the model id, deliberately. An unmetered driver bills
+	// nothing whatever it is asked to run, and its models are whatever the
+	// operator has pulled onto the machine — enumerable by nobody. Requiring a
+	// row for each would make every local run unpriced, which would report
+	// "cost unknown" about the one case where the cost is known exactly.
+	if (vendor.unmetered) return UNMETERED
+	if (model === undefined) return undefined
+	return vendor.models.get(normaliseModelId(model))
+}

package/src/pricing/rates.source.json

@@ -0,0 +1,206 @@
+{
+  "about": [
+    "The reviewed input to scripts/generate-model-prices.mjs. Edit THIS file, never",
+    "catalogue.generated.ts — the generator overwrites that file and a CI gate",
+    "re-derives it from this one and fails on any difference.",
+    "",
+    "A rate here is a commercial fact about a vendor's published list price. It is",
+    "entered by a human who read that vendor's own pricing page, and `verified` is",
+    "the date they read it. It is NOT fetched at build time: an auto-refreshing",
+    "generator would change every consumer's reported cost AND every consumer's",
+    "costLimitUsd behaviour on an unrelated commit, with no review and no diff.",
+    "",
+    "Absent is a real answer. A model with no row here reports UNKNOWN cost, not",
+    "zero, and a run that sets runConfig.costLimitUsd against it is refused rather",
+    "than run without a budget. So the correct move when a rate cannot be",
+    "established is to leave the row out, never to approximate it.",
+    "",
+    "unmetered: true means this driver bills nothing by construction — local",
+    "inference. Its runs are priced at zero, which is KNOWN-free and therefore",
+    "distinct from unknown. Such a vendor needs no model rows.",
+    "",
+    "Matching is EXACT on a normalised id (lowercased, one trailing -YYYYMMDD or",
+    "@YYYYMMDD snapshot suffix removed). Deliberately not prefix or substring:",
+    "within one vendor here, ids one character apart differ in price by 4x, so a",
+    "near-miss would misprice silently. A miss reports unknown, which is safe."
+  ],
+  "cacheTokensAre": [
+    "Two of the four rates only mean anything alongside a fact about the DRIVER,",
+    "not about the model: whether the prompt-token count it reports already",
+    "contains the tokens it read from cache.",
+    "",
+    "The drivers in this repository disagree, and it is measured, not assumed:",
+    "  packages/providers/anthropic/src/client.ts parseUsage — promptTokens is",
+    "    input_tokens, which EXCLUDES cache reads and cache writes.",
+    "  packages/providers/bedrock/src/client.ts parseBedrockUsage — same.",
+    "  packages/providers/openai/src/client.ts parseUsage — promptTokens is",
+    "    prompt_tokens, which INCLUDES cached_tokens.",
+    "",
+    "So the same TokenUsage shape carries two incompatible meanings, and a rate",
+    "applied without knowing which one is off by the whole cache-read volume. The",
+    "fact is a property of the driver, and the driver's identity is in hand at the",
+    "moment cost is accumulated — so it is declared here, per vendor, once.",
+    "",
+    "promptIncludesCacheReads   true  => billable input is promptTokens minus",
+    "                                    cachedTokens.",
+    "                           false => billable input is promptTokens, and",
+    "                                    cachedTokens are charged on top.",
+    "",
+    "reportsCacheWrites declares whether the driver ever produces a non-zero",
+    "cacheWriteTokens. When false, model rows carry no write rate — a rate for a",
+    "quantity nothing produces is a declaration nothing drives. If such a driver",
+    "later does report writes, those tokens are counted as unpriced rather than",
+    "quietly charged at some other rate, so the contradiction surfaces."
+  ],
+  "vendors": [
+    {
+      "providerId": "anthropic",
+      "unmetered": false,
+      "verified": "2026-08-10",
+      "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 run inside a promotional window is over-reported rather than mis-modelled.",
+      "models": [
+        {
+          "id": "claude-fable-5",
+          "inputPer1M": 10,
+          "outputPer1M": 50,
+          "cacheReadPer1M": 1,
+          "cacheWritePer1M": 12.5
+        },
+        {
+          "id": "claude-mythos-5",
+          "inputPer1M": 10,
+          "outputPer1M": 50,
+          "cacheReadPer1M": 1,
+          "cacheWritePer1M": 12.5
+        },
+        {
+          "id": "claude-opus-5",
+          "inputPer1M": 5,
+          "outputPer1M": 25,
+          "cacheReadPer1M": 0.5,
+          "cacheWritePer1M": 6.25
+        },
+        {
+          "id": "claude-opus-4-8",
+          "inputPer1M": 5,
+          "outputPer1M": 25,
+          "cacheReadPer1M": 0.5,
+          "cacheWritePer1M": 6.25
+        },
+        {
+          "id": "claude-opus-4-7",
+          "inputPer1M": 5,
+          "outputPer1M": 25,
+          "cacheReadPer1M": 0.5,
+          "cacheWritePer1M": 6.25
+        },
+        {
+          "id": "claude-opus-4-6",
+          "inputPer1M": 5,
+          "outputPer1M": 25,
+          "cacheReadPer1M": 0.5,
+          "cacheWritePer1M": 6.25
+        },
+        {
+          "id": "claude-sonnet-5",
+          "inputPer1M": 3,
+          "outputPer1M": 15,
+          "cacheReadPer1M": 0.3,
+          "cacheWritePer1M": 3.75
+        },
+        {
+          "id": "claude-sonnet-4-6",
+          "inputPer1M": 3,
+          "outputPer1M": 15,
+          "cacheReadPer1M": 0.3,
+          "cacheWritePer1M": 3.75
+        },
+        {
+          "id": "claude-haiku-4-5",
+          "inputPer1M": 1,
+          "outputPer1M": 5,
+          "cacheReadPer1M": 0.1,
+          "cacheWritePer1M": 1.25
+        },
+        {
+          "id": "claude-sonnet-4-5",
+          "inputPer1M": 3,
+          "outputPer1M": 15,
+          "cacheReadPer1M": 0.3,
+          "cacheWritePer1M": 3.75
+        },
+        {
+          "id": "claude-opus-4-1",
+          "inputPer1M": 15,
+          "outputPer1M": 75,
+          "cacheReadPer1M": 1.5,
+          "cacheWritePer1M": 18.75
+        }
+      ]
+    },
+    {
+      "providerId": "openai",
+      "unmetered": false,
+      "verified": "2026-08-10",
+      "promptIncludesCacheReads": true,
+      "reportsCacheWrites": false,
+      "note": "Vendor list prices for text models, cached-input rate included. The driver hard-codes cacheWriteTokens to zero, so no write rate is carried. Embedding models are omitted (no output rate, and a chat run never reaches one), as are models whose cached-input rate was not published alongside the others — an unestablished rate is left out rather than approximated, which is the rule this whole file follows.",
+      "models": [
+        { "id": "gpt-5.6-sol", "inputPer1M": 5, "outputPer1M": 30, "cacheReadPer1M": 0.5 },
+        { "id": "gpt-5.6-terra", "inputPer1M": 2, "outputPer1M": 12, "cacheReadPer1M": 0.2 },
+        { "id": "gpt-5.6-luna", "inputPer1M": 0.2, "outputPer1M": 1.2, "cacheReadPer1M": 0.02 },
+        { "id": "gpt-5.5", "inputPer1M": 5, "outputPer1M": 30, "cacheReadPer1M": 0.5 },
+        { "id": "gpt-5.4", "inputPer1M": 2.5, "outputPer1M": 15, "cacheReadPer1M": 0.25 },
+        { "id": "gpt-5.4-mini", "inputPer1M": 0.75, "outputPer1M": 4.5, "cacheReadPer1M": 0.075 },
+        { "id": "gpt-5.4-nano", "inputPer1M": 0.2, "outputPer1M": 1.25, "cacheReadPer1M": 0.02 },
+        { "id": "gpt-5.2", "inputPer1M": 1.75, "outputPer1M": 14, "cacheReadPer1M": 0.175 },
+        { "id": "gpt-5.1", "inputPer1M": 1.25, "outputPer1M": 10, "cacheReadPer1M": 0.125 },
+        { "id": "gpt-5", "inputPer1M": 1.25, "outputPer1M": 10, "cacheReadPer1M": 0.125 },
+        { "id": "gpt-5-mini", "inputPer1M": 0.25, "outputPer1M": 2, "cacheReadPer1M": 0.025 },
+        { "id": "gpt-5-nano", "inputPer1M": 0.05, "outputPer1M": 0.4, "cacheReadPer1M": 0.005 },
+        { "id": "gpt-4.1", "inputPer1M": 2, "outputPer1M": 8, "cacheReadPer1M": 0.5 },
+        { "id": "gpt-4.1-mini", "inputPer1M": 0.4, "outputPer1M": 1.6, "cacheReadPer1M": 0.1 },
+        { "id": "gpt-4.1-nano", "inputPer1M": 0.1, "outputPer1M": 0.4, "cacheReadPer1M": 0.025 },
+        { "id": "gpt-4o", "inputPer1M": 2.5, "outputPer1M": 10, "cacheReadPer1M": 1.25 },
+        { "id": "gpt-4o-mini", "inputPer1M": 0.15, "outputPer1M": 0.6, "cacheReadPer1M": 0.075 },
+        { "id": "o1", "inputPer1M": 15, "outputPer1M": 60, "cacheReadPer1M": 7.5 },
+        { "id": "o3", "inputPer1M": 2, "outputPer1M": 8, "cacheReadPer1M": 0.5 },
+        { "id": "o3-mini", "inputPer1M": 1.1, "outputPer1M": 4.4, "cacheReadPer1M": 0.55 },
+        { "id": "o4-mini", "inputPer1M": 1.1, "outputPer1M": 4.4, "cacheReadPer1M": 0.275 }
+      ]
+    },
+    {
+      "providerId": "ollama",
+      "unmetered": true,
+      "verified": "2026-08-10",
+      "note": "Local inference. Nothing is billed for a token, whatever the model, so there is no model list to keep current.",
+      "models": []
+    },
+    {
+      "providerId": "lmstudio",
+      "unmetered": true,
+      "verified": "2026-08-10",
+      "note": "Local inference. Same as above.",
+      "models": []
+    }
+  ],
+  "absent": [
+    "Drivers deliberately carrying no rows, so that a run through them reports",
+    "unknown rather than a number nobody checked:",
+    "",
+    "  bedrock    — partner-operated, on a separate rate card from the vendor whose",
+    "               models it serves. Entering the vendor's own rates against it",
+    "               would be the exact class of quiet wrongness this file exists to",
+    "               stop.",
+    "  openrouter — routes to arbitrary upstreams and publishes per-model rates from",
+    "               its own catalogue endpoint at run time. That is a live source",
+    "               and a static table cannot be one.",
+    "  http       — a driver for whatever endpoint the host points it at. There is",
+    "               no vendor to have a price.",
+    "",
+    "Adding one is a normal change: add the vendor here with the rows and the date",
+    "they were read, run the generator, commit both files."
+  ]
+}

package/src/public-runtime.ts

@@ -49,10 +49,18 @@ export * from './utils/id.js'
 
 export {
 	accumulateCost,
+	accumulateUnpricedCost,
 	calculateCost,
+	describeCost,
 	formatCost,
 	ZERO_COST,
 } from './utils/cost.js'
+
+// The price catalogue. Exported because a driver package has to be able to ask
+// whether the models it offers an operator are ones the kernel can price —
+// `sdk ← providers` means the SDK's own tests can never reach a real driver's
+// model list, so that check lives in the driver and needs this.
+export { normaliseModelId, resolveModelPricing, VENDOR_RATES } from './pricing/index.js'
 export { toErrorMessage } from './utils/error.js'
 export { configureLogger, getRootLogger, Logger } from './utils/logger.js'
 export { buildToolResultHashes, hashToolResult } from './utils/hash.js'
@@ -141,6 +149,37 @@ export type {
 	DrainRunsParams,
 	DrainRunsResult,
 } from './run/index.js'
+// A `ReviewAnswer` that runs shell commands, so "don't finish until the
+// build passes" needs no TypeScript. `reviewAnswer` was the seam for this
+// and nothing shipped supplied one. Skips re-running a command whose
+// failure the workspace has not changed since — the difference between a
+// bounded loop and one that spends its whole budget confirming a failure it
+// already reported.
+export {
+	DEFAULT_GATE_MAX_RETRIES,
+	DEFAULT_GATE_OUTPUT_CHARS,
+	DEFAULT_GATE_TIMEOUT_MS,
+	FINGERPRINT_MAX_BYTES,
+	FINGERPRINT_TIMEOUT_MS,
+	clipOutput,
+	createCommandGate,
+	fingerprintWorkspace,
+} from './run/index.js'
+export type {
+	CommandGateOptions,
+	FingerprintExec,
+	GateExec,
+	WorkspaceFingerprintOptions,
+} from './run/index.js'
+// The default `promoteMemory`: write what a run learned into a MemoryStore,
+// or write NOTHING. The hook was invoked at settle with the compaction
+// extractor's already-structured output and no shipped app supplied it, so
+// that structure was serialized into one system message and dropped when
+// the run ended. A run that learned nothing leaves no record at all — the
+// model reads this store, so noise here is context spent on a run that did
+// nothing.
+export { RUN_MEMORY_TAG, createMemoryPromoter } from './run/index.js'
+export type { MemoryPromoterOptions } from './run/index.js'
 
 // ─── personas, skills, advisory ──────────────────────────────────────────
 

package/src/public-types.ts

@@ -98,7 +98,9 @@ export type {
 
 export type { AdvisoryCallContext, AdvisoryExecutionResult } from './advisory/index.js'
 
-export type { ModelPricing } from './utils/cost.js'
+export type { CacheRates, ModelPricing } from './utils/cost.js'
+export type { VendorRates } from './pricing/index.js'
+export type { PricingSubject } from './manager/run/persistence.js'
 export type { FrontmatterValue, ParsedFrontmatter } from './utils/frontmatter.js'
 export type { Logger } from './utils/logger.js'
 export type { ShellCompressOptions, ShellCompressResult } from './utils/shell-compress.js'