@sixb/core 0.1.20 → 0.1.22

package/src/models/pricing.ts

@@ -1,5 +1,12 @@
 import type { ModelRoute, ModelUsage } from "./events"
-import type { LanguageModelRateCard, ModelTokenPrice } from "./rate-card"
+import {
+  type ModelPricingDimensions,
+  type ModelRateCard,
+  type ModelTokenPrice,
+  type ModelVariantPrice,
+  modelVariantPrices,
+  resolveModelVariantPrice,
+} from "./rate-card"
 
 /** Optional local financial enrichment cannot discard a completed, billable call. */
 export function estimateModelCall(
@@ -42,11 +49,15 @@ export interface ModelCostEstimator {
     readonly usage: ModelUsage
     readonly route?: ModelRoute
     readonly responseModelId?: string
+    /** The request's size, quality, style or voice tier, for prices that vary with them. */
+    readonly dimensions?: ModelPricingDimensions
   }): ModelCostEstimate
 }
 
 export type ModelCostMeter =
   | "audio.input.milliseconds"
+  | "characters.input"
+  | "images.output"
   | "tokens.input.total"
   | "tokens.input.uncached"
   | "tokens.input.cacheRead"
@@ -54,12 +65,18 @@ export type ModelCostMeter =
   | "tokens.input.cacheWrite5m"
   | "tokens.input.cacheWrite1h"
   | "tokens.output.total"
+  | "tokens.output.text"
+  | "tokens.output.reasoning"
+  | "tokens.output.image"
+  | "tokens.output.audio"
 
 export interface ModelCostComponent {
   readonly meter: ModelCostMeter
   readonly quantity: string
   readonly rateAmountNanosPerMillion: string
   readonly chargeAmountNanos: string
+  /** The price variant that applied, such as `1024x1024 · high`. Display only. */
+  readonly variant?: string
 }
 
 export type ModelCallCost =
@@ -71,21 +88,41 @@ export type ModelCallCost =
     }
   | {
       readonly status: "unpriceable"
-      readonly reason: "missing-rate-card" | "missing-usage" | "inconsistent-usage"
+      readonly reason:
+        | "missing-rate-card"
+        | "missing-usage"
+        | "inconsistent-usage"
+        | "unsupported-pricing-dimension"
       readonly missingMeters?: readonly ModelCostMeter[]
     }
 
-/** Reserve at the highest configured token rates, before cache usage and the final tier are known. */
+type Unpriceable = Extract<ModelCallCost, { status: "unpriceable" }>
+
+type TokenRateCard = ModelRateCard & {
+  readonly input: ModelTokenPrice
+  readonly output: ModelTokenPrice
+}
+
+function pricesTokens(card: ModelRateCard): card is TokenRateCard {
+  return card.input !== undefined && card.output !== undefined
+}
+
+/**
+ * Reserve at the highest rates the request could be billed at, before cache usage, the final tier
+ * and the produced media are known. Undefined when a meter the card bills has no bound.
+ */
 export function estimateModelReservation(input: {
-  readonly inputTokens: number
-  readonly outputTokens: number
-  readonly rateCard?: LanguageModelRateCard
+  readonly inputTokens?: number
+  readonly outputTokens?: number
+  readonly outputImages?: number
+  readonly inputCharacters?: number
+  readonly dimensions?: ModelPricingDimensions
+  readonly rateCard?: ModelRateCard
 }): ModelMoney | undefined {
   if (!input.rateCard) return undefined
-  if (![input.inputTokens, input.outputTokens].every((n) => Number.isSafeInteger(n) && n >= 0)) {
-    throw new TypeError(
-      "[Sixb] Model reservation token estimates must be nonnegative safe integers."
-    )
+  const counts = [input.inputTokens, input.outputTokens, input.outputImages, input.inputCharacters]
+  if (!counts.every((n) => n === undefined || (Number.isSafeInteger(n) && n >= 0))) {
+    throw new TypeError("[Sixb] Model reservation estimates must be nonnegative safe integers.")
   }
   const maxRate = (prices: readonly (ModelTokenPrice | undefined)[]) => {
     const rates = prices.flatMap((price) =>
@@ -95,43 +132,76 @@ export function estimateModelReservation(input: {
           ? [price]
           : [price.default, ...price.tiers.map((tier) => tier.price)]
     )
-    return rates.reduce((max, price) => {
-      const rate = decimalDollarsToNanos(price)
-      return rate > max ? rate : max
-    }, 0n)
+    return highestRate(rates)
   }
   const card = input.rateCard
-  const inputRate = maxRate([
-    card.input,
-    card.cacheReadInput,
-    card.cacheWriteInput,
-    card.cacheWriteInput5m,
-    card.cacheWriteInput1h,
-  ])
-  const outputRate = maxRate([card.output])
-  const charge = (tokens: number, rate: bigint) => (BigInt(tokens) * rate + 999_999n) / 1_000_000n
-  return {
-    currency: "USD",
-    amountNanos: (
-      charge(input.inputTokens, inputRate) + charge(input.outputTokens, outputRate)
-    ).toString(),
+  const charge = (quantity: number, rate: bigint) =>
+    (BigInt(quantity) * rate + 999_999n) / 1_000_000n
+
+  let total = 0n
+  if (pricesTokens(card)) {
+    if (input.inputTokens === undefined || input.outputTokens === undefined) return undefined
+    const inputRate = maxRate([
+      card.input,
+      card.cacheReadInput,
+      card.cacheWriteInput,
+      card.cacheWriteInput5m,
+      card.cacheWriteInput1h,
+    ])
+    const outputRate = maxRate([card.output, card.imageOutput, card.audioOutput])
+    total += charge(input.inputTokens, inputRate) + charge(input.outputTokens, outputRate)
+  }
+  if (card.images !== undefined) {
+    if (input.outputImages === undefined) return undefined
+    total += BigInt(input.outputImages) * reservationPrice(card.images, input.dimensions)
+  }
+  // Nothing measures an audio file's duration before it is sent.
+  if (card.audioInputSeconds !== undefined) return undefined
+  if (card.characters !== undefined) {
+    if (input.inputCharacters === undefined) return undefined
+    total += charge(input.inputCharacters, reservationPrice(card.characters, input.dimensions))
   }
+  return { currency: "USD", amountNanos: total.toString() }
 }
 
-/** Prefer the provider's bill over rate-card estimates, then rate complete token meters locally. */
+function reservationPrice(
+  price: ModelVariantPrice,
+  dimensions: ModelPricingDimensions | undefined
+): bigint {
+  const resolved = resolveModelVariantPrice(price, dimensions)
+  // The default applies to unknown dimensions; reserving it could fall short of a variant.
+  return resolved?.variant !== undefined || typeof price === "string"
+    ? decimalDollarsToNanos(resolved!.price)
+    : highestRate(modelVariantPrices(price))
+}
+
+function highestRate(prices: readonly string[]): bigint {
+  return prices.reduce((max, price) => {
+    const rate = decimalDollarsToNanos(price)
+    return rate > max ? rate : max
+  }, 0n)
+}
+
+/**
+ * Prefer the provider's bill over rate-card estimates, then rate the call locally. A call is
+ * billed by tokens, by units (images, characters) or both; every quantity must be covered by one.
+ */
 export function rateModelCall(input: {
   readonly usage: ModelUsage
-  readonly rateCard?: LanguageModelRateCard
+  readonly rateCard?: ModelRateCard
+  readonly dimensions?: ModelPricingDimensions
   readonly reported?: undefined
 }): ModelCostEstimate
 export function rateModelCall(input: {
   readonly usage: ModelUsage
-  readonly rateCard?: LanguageModelRateCard
+  readonly rateCard?: ModelRateCard
+  readonly dimensions?: ModelPricingDimensions
   readonly reported?: ModelReportedCost
 }): ModelCallCost
 export function rateModelCall(input: {
   readonly usage: ModelUsage
-  readonly rateCard?: LanguageModelRateCard
+  readonly rateCard?: ModelRateCard
+  readonly dimensions?: ModelPricingDimensions
   readonly reported?: ModelReportedCost
 }): ModelCallCost {
   if (input.reported) {
@@ -147,6 +217,76 @@ export function rateModelCall(input: {
   if (!validUsageCounters(usage)) {
     return { status: "unpriceable", reason: "inconsistent-usage" }
   }
+
+  const units = rateUnits(usage, rateCard, input.dimensions)
+  if (!Array.isArray(units)) return units
+  const tokens = pricesTokens(rateCard) ? rateTokens(usage, rateCard) : []
+  if (!Array.isArray(tokens)) return tokens
+
+  const components = [...tokens, ...units]
+  const total = components.reduce((sum, entry) => sum + BigInt(entry.chargeAmountNanos), 0n)
+  return {
+    status: "rated",
+    money: { currency: rateCard.currency, amountNanos: total.toString() },
+    components,
+  }
+}
+
+function rateUnits(
+  usage: ModelUsage,
+  rateCard: ModelRateCard,
+  dimensions: ModelPricingDimensions | undefined
+): ModelCostComponent[] | Unpriceable {
+  // Without token prices, a count the card doesn't price is a charge nothing covers.
+  if (!pricesTokens(rateCard)) {
+    const unpriced: ModelCostMeter[] = [
+      ...((usage.outputImages ?? 0) > 0 && rateCard.images === undefined
+        ? (["images.output"] as const)
+        : []),
+      ...((usage.inputCharacters ?? 0) > 0 && rateCard.characters === undefined
+        ? (["characters.input"] as const)
+        : []),
+    ]
+    if (unpriced.length > 0) {
+      return { status: "unpriceable", reason: "missing-rate-card", missingMeters: unpriced }
+    }
+  }
+
+  // Each card price, its meter, and the power of ten from its unit to nanos per million units.
+  // Audio duration is charged only where a card prices it: speech reports the duration of
+  // the audio it made, which nothing bills.
+  const components: ModelCostComponent[] = []
+  const missing: ModelCostMeter[] = []
+  for (const [meter, quantity, price, exponent] of [
+    ["images.output", usage.outputImages, rateCard.images, 15],
+    ["characters.input", usage.inputCharacters, rateCard.characters, 9],
+    ["audio.input.milliseconds", usage.audioDurationMs, rateCard.audioInputSeconds, 12],
+  ] as const) {
+    if (price === undefined) continue
+    if (quantity === undefined) {
+      missing.push(meter)
+      continue
+    }
+    // A priced call that produced nothing keeps its zero-quantity component.
+    if (quantity === 0 && pricesTokens(rateCard)) continue
+    const resolved = resolveModelVariantPrice(price, dimensions) ?? (quantity === 0 ? zero : null)
+    if (!resolved) return { status: "unpriceable", reason: "unsupported-pricing-dimension" }
+    components.push(
+      componentAtRate(meter, quantity, scaledDecimal(resolved.price, exponent), resolved.variant)
+    )
+  }
+  if (missing.length > 0) {
+    return { status: "unpriceable", reason: "missing-usage", missingMeters: missing }
+  }
+  return components
+}
+
+const zero: { readonly price: string; readonly variant?: string } = { price: "0" }
+
+function rateTokens(
+  usage: ModelUsage,
+  rateCard: TokenRateCard
+): ModelCostComponent[] | Unpriceable {
   if (usage.inputTokens === undefined || usage.outputTokens === undefined) {
     return {
       status: "unpriceable",
@@ -211,15 +351,79 @@ export function rateModelCall(input: {
       )
     }
   }
-  components.push(
-    component("tokens.output.total", usage.outputTokens, rateCard.output, usage.inputTokens)
-  )
-  const total = components.reduce((sum, entry) => sum + BigInt(entry.chargeAmountNanos), 0n)
-  return {
-    status: "rated",
-    money: { currency: rateCard.currency, amountNanos: total.toString() },
-    components,
+
+  const output = rateOutputTokens(usage, usage.outputTokens, usage.inputTokens, rateCard)
+  if (!Array.isArray(output)) return output
+  return [...components, ...output]
+}
+
+/**
+ * Output tokens split by what bills them: per-image prices cover image tokens, media token prices
+ * bill their own share, and the rest is text and reasoning. Splitting requires those counts.
+ */
+function rateOutputTokens(
+  usage: ModelUsage,
+  outputTokens: number,
+  tierTokens: number,
+  rateCard: TokenRateCard
+): ModelCostComponent[] | Unpriceable {
+  const imagesCoverTokens = rateCard.images !== undefined && (usage.outputImages ?? 0) > 0
+  const missing: ModelCostMeter[] = []
+  if (
+    (imagesCoverTokens || rateCard.imageOutput !== undefined) &&
+    usage.imageOutputTokens === undefined
+  ) {
+    missing.push("tokens.output.image")
+  }
+  if (rateCard.audioOutput !== undefined && usage.audioOutputTokens === undefined) {
+    missing.push("tokens.output.audio")
   }
+  if (missing.length > 0) {
+    return { status: "unpriceable", reason: "missing-usage", missingMeters: missing }
+  }
+
+  const covered = imagesCoverTokens ? usage.imageOutputTokens! : 0
+  const media: ModelCostComponent[] = []
+  if (!imagesCoverTokens && rateCard.imageOutput !== undefined && usage.imageOutputTokens! > 0) {
+    media.push(
+      component("tokens.output.image", usage.imageOutputTokens!, rateCard.imageOutput, tierTokens)
+    )
+  }
+  if (rateCard.audioOutput !== undefined && usage.audioOutputTokens! > 0) {
+    media.push(
+      component("tokens.output.audio", usage.audioOutputTokens!, rateCard.audioOutput, tierTokens)
+    )
+  }
+  if (covered === 0 && media.length === 0) {
+    return [component("tokens.output.total", outputTokens, rateCard.output, tierTokens)]
+  }
+
+  const remainder =
+    outputTokens - covered - media.reduce((sum, entry) => sum + Number(entry.quantity), 0)
+  if (remainder < 0) return { status: "unpriceable", reason: "inconsistent-usage" }
+  const text = usage.textOutputTokens
+  const reasoning = usage.reasoningOutputTokens
+  if (remainder > 0 && text === undefined) {
+    return { status: "unpriceable", reason: "missing-usage", missingMeters: ["tokens.output.text"] }
+  }
+  if (remainder > 0 && text! + (reasoning ?? 0) !== remainder) {
+    return reasoning === undefined
+      ? {
+          status: "unpriceable",
+          reason: "missing-usage",
+          missingMeters: ["tokens.output.reasoning"],
+        }
+      : { status: "unpriceable", reason: "inconsistent-usage" }
+  }
+  return [
+    ...(remainder > 0 && text! > 0
+      ? [component("tokens.output.text", text!, rateCard.output, tierTokens)]
+      : []),
+    ...(remainder > 0 && (reasoning ?? 0) > 0
+      ? [component("tokens.output.reasoning", reasoning!, rateCard.output, tierTokens)]
+      : []),
+    ...media,
+  ]
 }
 
 type PartitionResult =
@@ -235,7 +439,7 @@ type PartitionResult =
     }
   | Extract<ModelCallCost, { status: "unpriceable" }>
 
-function partitionInputUsage(usage: ModelUsage, rateCard: LanguageModelRateCard): PartitionResult {
+function partitionInputUsage(usage: ModelUsage, rateCard: ModelRateCard): PartitionResult {
   const hasSpecificWrites =
     usage.cacheWrite5mInputTokens !== undefined || usage.cacheWrite1hInputTokens !== undefined
   const cacheWriteSpecific =
@@ -360,13 +564,22 @@ function component(
   price: ModelTokenPrice,
   tierTokens: number
 ): ModelCostComponent {
-  const rate = decimalDollarsToNanos(resolvePrice(price, tierTokens))
+  return componentAtRate(meter, quantity, decimalDollarsToNanos(resolvePrice(price, tierTokens)))
+}
+
+function componentAtRate(
+  meter: ModelCostMeter,
+  quantity: number,
+  rate: bigint,
+  variant?: string
+): ModelCostComponent {
   const charge = (BigInt(quantity) * rate + 500_000n) / 1_000_000n
   return {
     meter,
     quantity: quantity.toString(),
     rateAmountNanosPerMillion: rate.toString(),
     chargeAmountNanos: charge.toString(),
+    ...(variant ? { variant } : {}),
   }
 }
 
@@ -380,6 +593,14 @@ function resolvePrice(price: ModelTokenPrice, tokens: number): string {
   )
 }
 
+/** A decimal price times 10^exponent, rounded half up at the first dropped digit. */
+function scaledDecimal(value: string, exponent: number): bigint {
+  const [whole = "0", fraction = ""] = value.split(".")
+  const kept = fraction.slice(0, exponent).padEnd(exponent, "0")
+  const roundUp = Number(fraction[exponent] ?? "0") >= 5
+  return BigInt(whole) * 10n ** BigInt(exponent) + BigInt(kept) + (roundUp ? 1n : 0n)
+}
+
 function decimalDollarsToNanos(value: string): bigint {
   const [whole = "0", fraction = ""] = value.split(".")
   const nanos = fraction.slice(0, 9).padEnd(9, "0")

package/src/models/rate-card.ts

@@ -1,4 +1,4 @@
-/** Decimal USD per million tokens. Strings keep provider prices exact. */
+/** Decimal USD. Strings keep provider prices exact. */
 export type ModelUnitPrice = string
 
 export interface ModelPricingTier {
@@ -11,28 +11,92 @@ export type ModelTokenPrice =
   | ModelUnitPrice
   | { readonly default: ModelUnitPrice; readonly tiers: readonly ModelPricingTier[] }
 
-export interface LanguageModelRateCard {
+/** Request facts a price can depend on, such as an image's size or a voice's tier. */
+export interface ModelPricingDimensions {
+  readonly size?: string
+  readonly quality?: string
+  readonly style?: string
+  readonly voiceTier?: string
+}
+
+export interface ModelPriceVariant extends ModelPricingDimensions {
+  readonly price: ModelUnitPrice
+}
+
+/**
+ * One price, or prices that vary with the request. Every variant names the same dimensions; a
+ * request no variant matches is billed at `default`, and is unpriceable without one.
+ */
+export type ModelVariantPrice =
+  | ModelUnitPrice
+  | { readonly default?: ModelUnitPrice; readonly variants: readonly ModelPriceVariant[] }
+
+/**
+ * What one provider bills for one model. A card lists only the meters its provider charges:
+ * token prices come as an input and output pair, per million tokens.
+ */
+export interface ModelRateCard {
   readonly currency: "USD"
-  readonly unit: "million-tokens"
-  readonly input: ModelTokenPrice
-  readonly output: ModelTokenPrice
+  readonly input?: ModelTokenPrice
+  readonly output?: ModelTokenPrice
   readonly cacheReadInput?: ModelTokenPrice
   readonly cacheWriteInput?: ModelTokenPrice
   readonly cacheWriteInput5m?: ModelTokenPrice
   readonly cacheWriteInput1h?: ModelTokenPrice
+  /** Output tokens that encode images, when billed apart from other output. */
+  readonly imageOutput?: ModelTokenPrice
+  /** Output tokens that encode audio, when billed apart from other output. */
+  readonly audioOutput?: ModelTokenPrice
+  /** Per generated image. Image output tokens are then not billed as tokens. */
+  readonly images?: ModelVariantPrice
+  /** Per million input characters. */
+  readonly characters?: ModelVariantPrice
+  /** Per second of input audio, as transcription bills. */
+  readonly audioInputSeconds?: ModelVariantPrice
 }
 
+const PRICING_DIMENSIONS = ["size", "quality", "style", "voiceTier"] as const
+
+const TOKEN_DETAIL_FIELDS = [
+  "cacheReadInput",
+  "cacheWriteInput",
+  "cacheWriteInput5m",
+  "cacheWriteInput1h",
+  "imageOutput",
+  "audioOutput",
+] as const
+
 /** Validate and snapshot provider-owned pricing independently of operational metadata. */
-export function defineModelRateCard(rateCard: LanguageModelRateCard): LanguageModelRateCard {
+export function defineModelRateCard(rateCard: ModelRateCard): ModelRateCard {
   assertRecord(rateCard, "rate card")
-  if (rateCard.currency !== "USD" || rateCard.unit !== "million-tokens") {
-    throw new TypeError("[Sixb] Model rate cards must use USD per million tokens.")
+  if (rateCard.currency !== "USD") {
+    throw new TypeError("[Sixb] Model rate cards must use USD.")
   }
+
+  const tokens = rateCard.input !== undefined || rateCard.output !== undefined
+  if (tokens && (rateCard.input === undefined || rateCard.output === undefined)) {
+    throw new TypeError("[Sixb] Model rate cards must price input and output tokens together.")
+  }
+  if (!tokens && TOKEN_DETAIL_FIELDS.some((field) => rateCard[field] !== undefined)) {
+    throw new TypeError("[Sixb] Model rate card token details require input and output prices.")
+  }
+  if (
+    !tokens &&
+    rateCard.images === undefined &&
+    rateCard.characters === undefined &&
+    rateCard.audioInputSeconds === undefined
+  ) {
+    throw new TypeError("[Sixb] Model rate cards must price tokens, images, characters or audio.")
+  }
+  if (rateCard.images !== undefined && rateCard.imageOutput !== undefined) {
+    throw new TypeError(
+      "[Sixb] Model rate cards bill image output per image or per token, not both."
+    )
+  }
+
   return Object.freeze({
     currency: "USD",
-    unit: "million-tokens",
-    input: tokenPrice(rateCard.input),
-    output: tokenPrice(rateCard.output),
+    ...(tokens ? { input: tokenPrice(rateCard.input), output: tokenPrice(rateCard.output) } : {}),
     ...(rateCard.cacheReadInput === undefined
       ? {}
       : { cacheReadInput: tokenPrice(rateCard.cacheReadInput) }),
@@ -45,10 +109,95 @@ export function defineModelRateCard(rateCard: LanguageModelRateCard): LanguageMo
     ...(rateCard.cacheWriteInput1h === undefined
       ? {}
       : { cacheWriteInput1h: tokenPrice(rateCard.cacheWriteInput1h) }),
+    ...(rateCard.imageOutput === undefined
+      ? {}
+      : { imageOutput: tokenPrice(rateCard.imageOutput) }),
+    ...(rateCard.audioOutput === undefined
+      ? {}
+      : { audioOutput: tokenPrice(rateCard.audioOutput) }),
+    ...(rateCard.images === undefined ? {} : { images: variantPrice(rateCard.images, "images") }),
+    ...(rateCard.characters === undefined
+      ? {}
+      : { characters: variantPrice(rateCard.characters, "characters") }),
+    ...(rateCard.audioInputSeconds === undefined
+      ? {}
+      : { audioInputSeconds: variantPrice(rateCard.audioInputSeconds, "audioInputSeconds") }),
+  })
+}
+
+/** @internal The price for a request, and the variant that set it. */
+export function resolveModelVariantPrice(
+  price: ModelVariantPrice,
+  dimensions: ModelPricingDimensions | undefined
+): { readonly price: ModelUnitPrice; readonly variant?: string } | undefined {
+  if (typeof price === "string") return { price }
+  const variant = price.variants.find((candidate) =>
+    PRICING_DIMENSIONS.every(
+      (dimension) =>
+        candidate[dimension] === undefined || candidate[dimension] === dimensions?.[dimension]
+    )
+  )
+  if (variant) {
+    const label = PRICING_DIMENSIONS.flatMap((dimension) => variant[dimension] ?? []).join(" · ")
+    return { price: variant.price, variant: label }
+  }
+  return price.default === undefined ? undefined : { price: price.default }
+}
+
+/** @internal Every price a request could be billed at, for conservative reservations. */
+export function modelVariantPrices(price: ModelVariantPrice): readonly ModelUnitPrice[] {
+  if (typeof price === "string") return [price]
+  return [
+    ...(price.default === undefined ? [] : [price.default]),
+    ...price.variants.map((variant) => variant.price),
+  ]
+}
+
+function variantPrice(value: ModelVariantPrice, field: string): ModelVariantPrice {
+  if (typeof value === "string") return price(value)
+  assertRecord(value, `${field} price`)
+  if (!Array.isArray(value.variants) || value.variants.length === 0) {
+    throw new TypeError(`[Sixb] Model ${field} price variants must be a nonempty array.`)
+  }
+
+  let shape: string | undefined
+  const seen = new Set<string>()
+  const variants = value.variants.map((variant): ModelPriceVariant => {
+    assertRecord(variant, `${field} price variant`)
+    const dimensions: { -readonly [K in keyof ModelPricingDimensions]: string } = {}
+    for (const dimension of PRICING_DIMENSIONS) {
+      const named = variant[dimension]
+      if (named === undefined) continue
+      if (typeof named !== "string" || !named.trim()) {
+        throw new TypeError(`[Sixb] Model ${field} price variant ${dimension} must be nonblank.`)
+      }
+      dimensions[dimension] = named
+    }
+
+    // One shared set of dimensions means a request matches at most one variant.
+    const key = Object.keys(dimensions).join(",")
+    if (!key || (shape !== undefined && key !== shape)) {
+      throw new TypeError(
+        `[Sixb] Model ${field} price variants must all name the same pricing dimensions.`
+      )
+    }
+    shape = key
+    const identity = JSON.stringify(Object.values(dimensions))
+    if (seen.has(identity)) {
+      throw new TypeError(`[Sixb] Model ${field} price variants must be distinct.`)
+    }
+    seen.add(identity)
+
+    return Object.freeze({ ...dimensions, price: price(variant.price) })
+  })
+
+  return Object.freeze({
+    ...(value.default === undefined ? {} : { default: price(value.default) }),
+    variants: Object.freeze(variants),
   })
 }
 
-function tokenPrice(value: ModelTokenPrice): ModelTokenPrice {
+function tokenPrice(value: ModelTokenPrice | undefined): ModelTokenPrice {
   if (typeof value === "string") return price(value)
   assertRecord(value, "token price")
   if (!Array.isArray(value.tiers)) throw new TypeError("[Sixb] Model price tiers must be an array.")

package/src/objects/authorized-ontology-view.ts

@@ -377,6 +377,7 @@ function snapshotProperty(property: Property): Property {
     required: property.required,
     nullable: property.nullable,
     primary: property.primary,
+    unique: property.unique,
     mode: property.mode,
     semanticType: property.semanticType,
     query: snapshotPropertyQuery(property.query),