@sixb/core 0.1.16 → 0.1.18

package/src/models/audio/errors.ts

@@ -0,0 +1,19 @@
+import { ModelProviderError } from "../errors"
+import type { TranscriptionModelResponseMetadata } from "./types"
+
+/** Retains billing metadata even when the provider returns an invalid transcript. */
+export class TranscriptionModelResponseError extends ModelProviderError {
+  constructor(
+    message: string,
+    providerId: string,
+    modelId: string,
+    readonly metadata: TranscriptionModelResponseMetadata,
+    options?: ErrorOptions
+  ) {
+    super(message, providerId, modelId, {
+      ...options,
+      code: "invalid_transcription_response",
+      retryable: false,
+    })
+  }
+}

package/src/models/audio/file.ts

@@ -0,0 +1,78 @@
+import { createHash } from "node:crypto"
+import type { BlobStorage, FileRef } from "../../blob-storage/types"
+import { isFileRef } from "../../blob-storage/validation"
+
+/** Snapshot caller-owned metadata before model resolution or storage introduces an await. */
+export function prepareTranscriptionFile(input: FileRef): { audio: FileRef; mediaType: string } {
+  if (!isFileRef(input) || !Number.isSafeInteger(input.sizeBytes) || input.sizeBytes <= 0) {
+    throw new TypeError("[SixbModels] Transcription requires a nonempty FileRef.")
+  }
+
+  const audio = { ...input }
+  const mediaType = audio.mediaType?.split(";", 1)[0]?.trim().toLowerCase()
+  if (!mediaType || !/^audio\/[a-z0-9.+-]+$/.test(mediaType)) {
+    throw new TypeError("[SixbModels] Audio FileRef must declare an audio mediaType.")
+  }
+
+  return { audio, mediaType }
+}
+
+/** Read an already validated reference, bounded by its verified size and the model's limit. */
+export async function readTranscriptionFile(
+  storage: BlobStorage,
+  file: FileRef,
+  signal: AbortSignal
+): Promise<Uint8Array> {
+  const info = await storage.stat(file.blobId)
+  signal.throwIfAborted()
+  if (
+    !info ||
+    info.blobId !== file.blobId ||
+    info.digest !== file.digest ||
+    info.sizeBytes !== file.sizeBytes
+  ) {
+    throw new Error("[SixbModels] Audio reference does not match the stored file.")
+  }
+
+  const stream = await storage.open(file.blobId)
+  const reader = stream.getReader()
+  const cancel = () => {
+    void reader.cancel(signal.reason).catch(() => undefined)
+  }
+  signal.addEventListener("abort", cancel, { once: true })
+
+  let complete = false
+  try {
+    signal.throwIfAborted()
+
+    const bytes = new Uint8Array(file.sizeBytes)
+    const hash = createHash("sha256")
+    let offset = 0
+
+    while (true) {
+      const { value, done } = await reader.read()
+      signal.throwIfAborted()
+      if (done) break
+      if (!(value instanceof Uint8Array) || value.byteLength > bytes.byteLength - offset) {
+        throw new Error("[SixbModels] Audio stream exceeds its declared size.")
+      }
+
+      bytes.set(value, offset)
+      hash.update(value)
+      offset += value.byteLength
+    }
+
+    if (offset !== file.sizeBytes || `sha256:${hash.digest("hex")}` !== file.digest) {
+      throw new Error("[SixbModels] Audio stream does not match its content-addressed reference.")
+    }
+
+    complete = true
+    return bytes
+  } finally {
+    signal.removeEventListener("abort", cancel)
+    if (!complete) {
+      void reader.cancel().catch(() => undefined)
+    }
+    reader.releaseLock()
+  }
+}

package/src/models/audio/runtime.ts

@@ -0,0 +1,182 @@
+import { randomUUID } from "node:crypto"
+import { assertProviderAccess } from "../../authorization"
+import type { BlobStorage } from "../../blob-storage/types"
+import type { ExecutionContext } from "../../execution"
+import type { SixbRuntimeContext } from "../../runtime/types"
+import type { ModelCatalog } from "../catalog"
+import type { ModelCallEndEvent } from "../events"
+import type { AiModelCallRecorder } from "../execution/model-call-recorder"
+import type { ModelExecutionSession } from "../execution/session"
+import { estimateModelCall, type ModelMoney } from "../pricing"
+import { assertTranscriptionModel } from "./catalog"
+import { TranscriptionModelResponseError } from "./errors"
+import { prepareTranscriptionFile, readTranscriptionFile } from "./file"
+import type {
+  AudioModelsRuntime,
+  TranscriptionModel,
+  TranscriptionModelResponseMetadata,
+  TranscriptionModelResult,
+} from "./types"
+
+export function createAudioRuntime(
+  runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
+  catalog: ModelCatalog | undefined,
+  session: ModelExecutionSession,
+  blobs: BlobStorage | undefined
+): AudioModelsRuntime {
+  return {
+    async transcribe(input) {
+      assertProviderAccess(runtime, execution, "models.audio.transcribe")
+
+      const { audio, mediaType } = prepareTranscriptionFile(input.audio)
+      if (!blobs) {
+        throw new Error("[SixbModels] Transcription requires blob storage.")
+      }
+
+      const signal = session.signal(input.signal)
+      signal.throwIfAborted()
+
+      const binding = selectModel(catalog, input.model)
+      assertTranscriptionModel(binding)
+      assertFileSupport(binding, audio.sizeBytes, mediaType)
+
+      const accounting = await session.accounting()
+      accounting.assertHealthy()
+
+      const model = binding.resolve ? await binding.resolve() : binding
+      assertTranscriptionModel(model)
+      if (model.providerId !== binding.providerId || model.modelId !== binding.modelId) {
+        throw new TypeError(
+          "[SixbModels] Resolved transcription model identity does not match the selected model."
+        )
+      }
+      assertFileSupport(model, audio.sizeBytes, mediaType)
+
+      signal.throwIfAborted()
+      const bytes = await readTranscriptionFile(blobs, audio, signal)
+      accounting.assertHealthy()
+
+      const reservationCost = estimateReservationCost(model, bytes.byteLength, mediaType)
+      const callId = `call_${randomUUID()}`
+      await accounting.admitCall({
+        callId,
+        providerId: model.providerId,
+        modelId: model.modelId,
+        modelKind: "transcription",
+        inputTokens: { status: "unavailable", reason: "nonTextInput" },
+        outputTokenAllowance: 0,
+        reservationCost,
+      })
+
+      let result: TranscriptionModelResult
+      try {
+        signal.throwIfAborted()
+        result = await model.transcribe({ audio: bytes, mediaType, signal })
+      } catch (error) {
+        await recordTranscription(
+          accounting,
+          model,
+          callId,
+          error instanceof TranscriptionModelResponseError ? error.metadata : {}
+        )
+        throw error
+      }
+
+      // A completed, billable reply must survive cancellation and transcript validation failures.
+      const event = await recordTranscription(accounting, model, callId, result ?? {})
+      signal.throwIfAborted()
+      if (typeof result?.output?.text !== "string") {
+        throw new TranscriptionModelResponseError(
+          "[SixbModels] Invalid transcription response.",
+          model.providerId,
+          model.modelId,
+          result ?? {}
+        )
+      }
+
+      return {
+        output: { text: result.output.text },
+        usage: event.usage,
+        cost: event.cost,
+        callId,
+      }
+    },
+  }
+}
+
+function selectModel(
+  catalog: ModelCatalog | undefined,
+  requested: TranscriptionModel | undefined
+): TranscriptionModel {
+  if (!catalog && requested) return requested
+
+  const transcribers = catalog?.audio?.transcription
+  const selected = requested
+    ? transcribers?.getByRef({ provider: requested.providerId, modelId: requested.modelId })?.model
+    : transcribers?.default.model
+
+  if (!selected) {
+    throw new Error(
+      "[SixbModels] Configure the selected model in models.audio.transcription, or supply a model when no catalog is configured."
+    )
+  }
+
+  return selected
+}
+
+function assertFileSupport(model: TranscriptionModel, sizeBytes: number, mediaType: string): void {
+  if (sizeBytes > model.definition.maxInputBytes) {
+    throw new RangeError(
+      `[SixbModels] Audio exceeds the model's ${model.definition.maxInputBytes}-byte input limit.`
+    )
+  }
+  if (model.definition.mediaTypes && !model.definition.mediaTypes.includes(mediaType)) {
+    throw new TypeError(
+      `[SixbModels] Audio media type '${mediaType}' is not supported by the selected model.`
+    )
+  }
+}
+
+function estimateReservationCost(
+  model: TranscriptionModel,
+  sizeBytes: number,
+  mediaType: string
+): ModelMoney | undefined {
+  try {
+    return model.costEstimator?.estimateReservation?.({ sizeBytes, mediaType })
+  } catch {
+    // Optional pricing cannot bypass an enforced budget: admission fails closed without it.
+    return undefined
+  }
+}
+
+async function recordTranscription(
+  accounting: AiModelCallRecorder,
+  model: TranscriptionModel,
+  callId: string,
+  metadata: TranscriptionModelResponseMetadata
+): Promise<ModelCallEndEvent> {
+  const usage = metadata.usage ?? {}
+  const estimate = estimateModelCall(model, {
+    usage,
+    route: metadata.route,
+    responseModelId: metadata.responseModelId,
+  })
+  const event: ModelCallEndEvent = {
+    callId,
+    modelKind: "transcription",
+    providerId: model.providerId,
+    modelId: model.modelId,
+    responseId: metadata.providerIds?.responseId ?? callId,
+    providerIds: metadata.providerIds,
+    responseModelId: metadata.responseModelId,
+    usage,
+    cost: metadata.reportedCost ? { status: "reported", ...metadata.reportedCost } : estimate,
+    ...(metadata.reportedCost ? { estimate } : {}),
+    route: metadata.route,
+  }
+
+  await accounting.onModelCallEnd(event)
+  return event
+}

package/src/models/audio/types.ts

@@ -0,0 +1,69 @@
+import type { FileRef } from "../../blob-storage/types"
+import type { ModelDefinition } from "../definitions"
+import type { ModelProviderIds, ModelRoute, ModelUsage } from "../events"
+import type { ModelCallCost, ModelCostEstimator, ModelMoney, ModelReportedCost } from "../pricing"
+
+export interface TranscriptionModelDefinition extends ModelDefinition {
+  readonly kind: "transcription"
+  /** Bounds memory consumption before a file is opened. Providers may impose lower limits. */
+  readonly maxInputBytes: number
+  /** Omitted when the provider does not publish a reliable format list. */
+  readonly mediaTypes?: readonly string[]
+}
+
+export interface TranscriptionModelRequest {
+  readonly audio: Uint8Array
+  readonly mediaType: string
+  readonly signal?: AbortSignal
+}
+
+export interface TranscriptionOutput {
+  readonly text: string
+}
+
+export interface TranscriptionModelResponseMetadata {
+  readonly usage?: ModelUsage
+  readonly providerIds?: ModelProviderIds
+  readonly responseModelId?: string
+  readonly reportedCost?: ModelReportedCost
+  readonly route?: ModelRoute
+}
+
+export interface TranscriptionModelResult extends TranscriptionModelResponseMetadata {
+  readonly output: TranscriptionOutput
+}
+
+export interface TranscriptionCostEstimator extends Pick<ModelCostEstimator, "estimate"> {
+  /** Return undefined if the request cannot be priced safely before inference. */
+  estimateReservation?(input: {
+    readonly sizeBytes: number
+    readonly mediaType: string
+  }): ModelMoney | undefined
+}
+
+/** Provider binding. Resolving it may fetch metadata, but must never perform inference. */
+export interface TranscriptionModel {
+  readonly providerId: string
+  readonly modelId: string
+  readonly definition: TranscriptionModelDefinition
+  readonly costEstimator?: TranscriptionCostEstimator
+  resolve?(): Promise<TranscriptionModel>
+  transcribe(request: TranscriptionModelRequest): Promise<TranscriptionModelResult>
+}
+
+export interface AudioTranscribeInput {
+  readonly audio: FileRef
+  readonly model?: TranscriptionModel
+  readonly signal?: AbortSignal
+}
+
+export interface AudioTranscribeResult {
+  readonly output: TranscriptionOutput
+  readonly usage: ModelUsage
+  readonly cost: ModelCallCost
+  readonly callId: string
+}
+
+export interface AudioModelsRuntime {
+  transcribe(input: AudioTranscribeInput): Promise<AudioTranscribeResult>
+}

package/src/models/catalog.ts

@@ -1,4 +1,9 @@
 import { RuntimeError } from "../runtime/errors"
+import {
+  type AudioModelCatalog,
+  type AudioModelCatalogInput,
+  createAudioCatalog,
+} from "./audio/catalog"
 import { indexModelBindings } from "./catalog-index"
 import { createDecisionCatalog, type DecisionModelCatalog } from "./decision/catalog"
 import type { DecisionModel } from "./decision/types"
@@ -8,7 +13,12 @@ import {
   type ModelDefinition,
 } from "./definitions"
 import { assertEmbeddingModel, type EmbeddingModel } from "./embedding-model"
-import type { LanguageModel } from "./language-model"
+import {
+  type LanguageModel,
+  MODEL_REASONING_LEVELS,
+  modelReasoningSupportIssue,
+} from "./language-model"
+import { assertRerankingModel, type RerankingModel } from "./reranking-model"
 
 /** Stable identity of a configured provider binding. */
 export interface ModelRef {
@@ -27,6 +37,15 @@ export interface EmbeddingModelCatalog {
   getByRef(ref: ModelRef): EmbeddingModelEntry | null
 }
 
+export interface RerankingModelEntry extends ModelRef {
+  readonly model: RerankingModel
+}
+
+export interface RerankingModelCatalog {
+  list(): readonly RerankingModelEntry[]
+  getByRef(ref: ModelRef): RerankingModelEntry | null
+}
+
 /** The configured language models, with the project default. */
 export interface LanguageModelCatalog {
   readonly default: LanguageModelEntry
@@ -47,17 +66,22 @@ export interface LanguageModelEntry extends LanguageModelRef {
 
 /** Models a project allows Sixb to use, organized by technical model kind. */
 export interface ModelCatalog {
+  readonly audio?: AudioModelCatalog
   readonly language?: LanguageModelCatalog
   readonly decision?: DecisionModelCatalog
   readonly embedding: EmbeddingModelCatalog
+  readonly reranking?: RerankingModelCatalog
 }
 
 export interface ModelCatalogInput {
+  readonly audio?: AudioModelCatalogInput
   /** Ordered; the first entry is the project default. */
   readonly language?: readonly LanguageModel[]
   /** Ordered; the first entry is the project default decision model. */
   readonly decision?: readonly DecisionModel[]
   readonly embedding?: readonly EmbeddingModel[]
+  /** Available rerankers; no default model and no automatic activation. */
+  readonly reranking?: readonly RerankingModel[]
 }
 
 // Only statically required inputs make their corresponding catalogs required.
@@ -66,7 +90,14 @@ type ConfiguredModelKinds<TInput> = {
 }[keyof ModelCatalog]
 
 export type ModelCatalogFor<TInput extends ModelCatalogInput> = ModelCatalog &
-  Required<Pick<ModelCatalog, ConfiguredModelKinds<TInput>>>
+  Required<Pick<ModelCatalog, ConfiguredModelKinds<TInput>>> &
+  ([TInput] extends [{ readonly audio: { readonly transcription: readonly unknown[] } }]
+    ? {
+        readonly audio: AudioModelCatalog & {
+          readonly transcription: NonNullable<AudioModelCatalog["transcription"]>
+        }
+      }
+    : unknown)
 
 /** Build an immutable catalog while preserving each family's default and empty-list rules. */
 export function createModelCatalog<TInput extends ModelCatalogInput>(
@@ -80,12 +111,32 @@ export function createModelCatalog(input: ModelCatalogInput): ModelCatalog {
   const language = createLanguageCatalog(input.language)
   const embedding = createEmbeddingCatalog(input.embedding)
   const decision = createDecisionCatalog(input.decision)
-
-  if (!language && !decision && embedding.list().length === 0) {
-    throw new RuntimeError("[Sixb] Configure at least one language, embedding or decision model.")
+  const audio = createAudioCatalog(input.audio)
+  const reranking = createRerankingCatalog(input.reranking)
+
+  if (
+    !language &&
+    !decision &&
+    !audio &&
+    embedding.list().length === 0 &&
+    !reranking?.list().length
+  ) {
+    throw new RuntimeError(
+      "[Sixb] Configure at least one language, embedding, decision, audio or reranking model."
+    )
   }
 
-  return Object.freeze({ language, embedding, decision })
+  return Object.freeze({ language, embedding, decision, audio, reranking })
+}
+
+function createRerankingCatalog(
+  models: readonly RerankingModel[] | undefined
+): RerankingModelCatalog | undefined {
+  if (models === undefined) return undefined
+  if (!Array.isArray(models)) {
+    throw new RuntimeError("[Sixb] models.reranking must be an array of reranking models.")
+  }
+  return indexModelBindings(models, "reranking", assertRerankingModel)
 }
 
 function createLanguageCatalog(
@@ -96,7 +147,10 @@ function createLanguageCatalog(
     throw new RuntimeError("[Sixb] 'models.language' must be an array of Sixb language models.")
   }
 
-  const index = indexModelBindings(models, "language", assertLanguageModel)
+  const index = indexModelBindings(models, "language", (model, position) => {
+    assertLanguageModel(model, position)
+    assertDefaultReasoning(model, position)
+  })
   const [defaultEntry] = index.list()
   if (!defaultEntry) {
     throw new RuntimeError(
@@ -117,6 +171,23 @@ function createEmbeddingCatalog(
   return indexModelBindings(models ?? [], "embedding", assertEmbeddingModel)
 }
 
+// Capabilities known without catalog I/O. Unknown support is accepted: providers fall back to their
+// default when a resolved model turns out not to support the level.
+function assertDefaultReasoning(model: LanguageModel, index: number): void {
+  const reasoning: unknown = model.defaultReasoning
+  if (reasoning === undefined) return
+  if (!(MODEL_REASONING_LEVELS as readonly unknown[]).includes(reasoning)) {
+    throw invalidLanguageModel(
+      index,
+      `expected 'defaultReasoning' to be one of: ${MODEL_REASONING_LEVELS.join(", ")}`
+    )
+  }
+  const issue = modelReasoningSupportIssue(model.definition.capabilities.reasoning, reasoning)
+  if (issue !== undefined) {
+    throw invalidLanguageModel(index, `default reasoning '${reasoning}' cannot be used: ${issue}`)
+  }
+}
+
 function assertLanguageModel(model: unknown, index: number): asserts model is LanguageModel {
   if ((typeof model !== "object" && typeof model !== "function") || model === null) {
     throw invalidLanguageModel(index, "expected a Sixb LanguageModel instance")

package/src/models/definitions.ts

@@ -5,7 +5,14 @@ import {
   type ModelReasoningCapabilities,
 } from "./language-model"
 
-export type ModelKind = "language" | "image" | "video" | "embedding" | "decision"
+export type ModelKind =
+  | "language"
+  | "image"
+  | "video"
+  | "embedding"
+  | "decision"
+  | "transcription"
+  | "reranking"
 
 /** Common catalog identity shared by every present and future model runtime. */
 export interface ModelDefinition {

package/src/models/events.ts

@@ -46,6 +46,8 @@ export type ModelFinishReason =
   | "unknown"
 
 export interface ModelUsage {
+  /** Audio content duration in milliseconds, rounded to the nearest millisecond. Not billed duration. */
+  readonly audioDurationMs?: number
   readonly inputTokens?: number
   readonly outputTokens?: number
   readonly uncachedInputTokens?: number
@@ -168,6 +170,7 @@ export type ModelUiChunk =
   | { readonly type: "error"; readonly errorText: string }
 
 export interface ModelCallEndEvent {
+  readonly modelKind?: import("./definitions").ModelKind
   readonly providerIds?: ModelProviderIds
   /** Retained independently when the selected display cost is provider-reported. */
   readonly estimate?: ModelCostEstimate

package/src/models/execution/README.md

@@ -1,6 +1,6 @@
 # Model execution accounting
 
-Internal execution and accounting shared by language, embedding and decision calls. Application usage is
+Internal execution and accounting shared by language, embedding, decision and reranking calls. Application usage is
 documented in [Usage and limits](../../../../../docs/models/usage-and-limits.md).
 
 ## Execution boundary
@@ -43,9 +43,29 @@ unknown input usage and unresolved capacity. Inference is never retried here.
 replays accounting only, never inference; see the
 [worker recovery contract](../../../../agent-worker/docs/usage-accounting.md).
 
-Direct provider calls bypass this session. Webhook handlers have no bound model execution attempt;
-they must dispatch an action for accounted calls. A process crash before accounting is captured
-can still leave provider billing outside the ledger.
+An Agent run binds its own recorder to its SDK, so calls from its tools share the run's admission,
+failure state and cancellation. Direct provider calls bypass this session. Webhook handlers have no
+bound model execution attempt; they must dispatch an action for accounted calls. A process crash
+before accounting is captured can still leave provider billing outside the ledger.
+
+## Reranking flow
+
+`reranking.ts` binds the registered catalog to the same session. Object queries resolve only that
+catalog, after semantic authorization and before query embedding. The query executor retrieves
+authorized vector candidates first and sends only profile source text; inference holds no storage
+transaction. Outer limits and property selection apply after ranking.
+
+Admission estimates the UTF-8 bytes of each query/document pair divided by four, rounded up, with
+zero output allowance. Actual provider meters are preserved. This is a heuristic, not a tokenizer or provider context guarantee. Calls have
+the shared 30-second cancellation bound, with no inference retry. Accounting precedes cancellation
+and ranking validation. A complete permutation with finite scores is required; ties preserve the
+candidate order. `RerankingModelResponseError` carries metadata from malformed billable responses.
+
+Provider charges remain distinct from token usage: absent tokens stay unknown. Token limits
+neither admit nor count reranking or transcription calls (`aiLimitMeterApplies` in the limit
+storage helpers), so their unmetered records cannot make a token meter unavailable. Reported
+costs reconcile monetary reservations; missing tariffs fail admission under cost limits. Recovery
+remains the existing accounting-only replay.
 
 ## Decision flow
 

package/src/models/execution/binding.ts

@@ -1,10 +1,16 @@
 import type { ModelsRuntime } from "../generation-types"
+import type { AiModelCallRecorder } from "./model-call-recorder"
 
 export interface ModelExecutionAttempt {
   readonly attempt: number
   readonly signal: AbortSignal
   /** Internal durable fence around admission; it must invoke admit exactly once to proceed. */
   readonly embeddingAdmission?: (admit: () => Promise<void>) => Promise<void>
+  /**
+   * Accounting the execution attempt already owns, such as an Agent run's. Calls then share its
+   * admission and failure state instead of opening a second recorder for the same attempt.
+   */
+  readonly accounting?: AiModelCallRecorder
 }
 
 const bindings = new WeakMap<ModelsRuntime, (input: ModelExecutionAttempt) => void>()

package/src/models/execution/model-call-admission.ts

@@ -1,5 +1,6 @@
 import type { AiModelCallReservationIdentity } from "../../storage"
-import type { ModelCostEstimator } from "../pricing"
+import type { ModelKind } from "../definitions"
+import type { ModelCostEstimator, ModelMoney } from "../pricing"
 
 /** Default output ceiling when a call and its resolved model supply no limit. */
 export const AI_MODEL_CALL_OUTPUT_TOKEN_ALLOWANCE = 4_096
@@ -24,7 +25,11 @@ export interface AiModelCallAdmissionInput {
   readonly callId: string
   readonly providerId: string
   readonly modelId: string
+  /** Selects the applicable limit meters; transcription and reranking skip token limits. */
+  readonly modelKind?: ModelKind
   readonly costEstimator?: ModelCostEstimator
+  /** A non-token estimate, computed by the resolved binding before inference. */
+  readonly reservationCost?: ModelMoney
   readonly inputTokens: AiModelCallInputTokenEstimate
   readonly outputTokenAllowance: number
   readonly estimatedTotalTokens?: number

package/src/models/execution/model-call-limits.ts

@@ -12,6 +12,7 @@ import {
   aiUsageLimitUnavailableError,
   applicableAiLimitPolicies,
 } from "../../storage/ai-limits/enforcement"
+import { aiLimitMeterApplies } from "../../storage/ai-limits/provider"
 import type {
   AiModelCallAdmissionDecision,
   AiModelCallAdmissionInput,
@@ -41,7 +42,9 @@ export function createAiModelCallLimitController(input: {
         const policies = await input.storage.aiLimits.listPolicies({
           projectId: input.projectId,
         })
-        applicable = applicableAiLimitPolicies(policies, subjects)
+        applicable = applicableAiLimitPolicies(policies, subjects).filter((policy) =>
+          aiLimitMeterApplies(policy.limit.meter, admission.modelKind)
+        )
       } catch (error) {
         throw limitStorageUnavailable(error)
       }
@@ -63,6 +66,7 @@ export function createAiModelCallLimitController(input: {
           ...reservationIdentity(admission),
           subjects,
           estimates,
+          ...(admission.modelKind === undefined ? {} : { modelKind: admission.modelKind }),
         })
       } catch (error) {
         throw limitStorageUnavailable(error)
@@ -94,24 +98,30 @@ function reservationEstimates(
   input: AiModelCallAdmissionInput,
   needsCost: boolean
 ): readonly AiLimitQuantity[] {
-  if (input.inputTokens.status !== "estimated" || input.estimatedTotalTokens === undefined) {
-    return []
+  const estimates: AiLimitQuantity[] = []
+  if (input.inputTokens.status === "estimated" && input.estimatedTotalTokens !== undefined) {
+    estimates.push({ meter: "tokens.total", amount: input.estimatedTotalTokens })
   }
-  const estimates: AiLimitQuantity[] = [
-    { meter: "tokens.total", amount: input.estimatedTotalTokens },
-  ]
+
   if (needsCost) {
     try {
-      const money = input.costEstimator?.estimateReservation?.({
-        inputTokens: input.inputTokens.tokens,
-        outputTokens: input.outputTokenAllowance,
-      })
-      if (money) estimates.push({ meter: "cost.catalogEstimated", amount: money })
+      let money = input.reservationCost
+      if (money == null && input.inputTokens.status === "estimated") {
+        money = input.costEstimator?.estimateReservation?.({
+          inputTokens: input.inputTokens.tokens,
+          outputTokens: input.outputTokenAllowance,
+        })
+      }
+
+      if (money) {
+        estimates.push({ meter: "cost.catalogEstimated", amount: money })
+      }
     } catch {
       // An unavailable price must not prevent a token-only policy from being evaluated.
       return estimates
     }
   }
+
   return estimates
 }