@sixb/core 0.1.16 → 0.1.17

package/src/ontology/types.ts

@@ -360,6 +360,25 @@ export interface Interface {
   links: ObjectLink[]
 }
 
+/** Compound query shapes prepared by the storage provider, in addition to property flags. */
+export type ObjectQueryIndexDefinition =
+  | {
+      kind: "sort"
+      fields: readonly { propertyId: string; direction?: "asc" | "desc" }[]
+      /** String equality filters preceding the ordered fields. */
+      filters?: readonly string[]
+    }
+  | {
+      kind: "text"
+      propertyId: string
+      /** String filters/facets commonly combined with this substring search. */
+      filters?: readonly string[]
+    }
+
+export interface ObjectTypeQueryMetadata {
+  indexes?: readonly ObjectQueryIndexDefinition[]
+}
+
 /**
  * Canonical ontology node for a real-world asset, system, concept, or process.
  *
@@ -413,6 +432,8 @@ export interface ObjectType {
 
   properties: Property[]
   links: ObjectLink[]
+  /** Query index declarations, prepared automatically after storage migrations. */
+  query?: ObjectTypeQueryMetadata
   /** Search profile for this object type. */
   search?: ObjectTypeSearchMetadata
 }

package/src/ontology/validation/query.ts

@@ -7,6 +7,8 @@ import {
   isFilterableSchema,
   isSortableSchema,
   isTextSchema,
+  queryScalarKindForSchema,
+  resolveQuerySchema,
 } from "../query-capabilities"
 
 type QueryFeature = "filterable" | "sortable" | "text" | "exact" | "facet"
@@ -27,6 +29,7 @@ export function validateQueryMetadata(
     }
 
     validateObjectSearchMetadata(typeId, objectType, valueTypesById)
+    validateQueryIndexes(typeId, objectType, valueTypesById)
   }
 }
 
@@ -250,3 +253,57 @@ function resolveSchema(
   seenValueTypeIds.add(schema.valueTypeId)
   return resolveSchema(resolved, valueTypesById, path, seenValueTypeIds)
 }
+
+function validateQueryIndexes(
+  typeId: string,
+  objectType: ObjectType,
+  valueTypes: ReadonlyMap<string, ValueType>
+): void {
+  for (const index of objectType.query?.indexes ?? []) {
+    const fields =
+      index.kind === "sort" ? index.fields.map((field) => field.propertyId) : [index.propertyId]
+    const filters = index.filters ?? []
+    if (
+      !fields.length ||
+      fields.length + filters.length > 8 ||
+      new Set([...fields, ...filters]).size !== fields.length + filters.length
+    )
+      throw new OntologyValidationError(
+        `[Sixb] Query index on '${typeId}' requires one to eight distinct properties`
+      )
+    if (index.kind === "text" && filters.length > 4)
+      throw new OntologyValidationError(
+        `[Sixb] Text query index on '${typeId}' accepts at most four filters`
+      )
+    for (const id of [...fields, ...filters]) {
+      const property = objectType.properties.find((property) => property.id === id)
+      if (!property)
+        throw new OntologyValidationError(
+          `[Sixb] Query index on '${typeId}' references unknown property '${id}'`
+        )
+      if (property.mode === "telemetry")
+        throw new OntologyValidationError(
+          `[Sixb] Query indexes cannot include telemetry property '${typeId}.${id}'`
+        )
+      const flag = filters.includes(id) ? "filterable" : index.kind === "sort" ? "sortable" : "text"
+      assertPropertyQueryFlag(typeId, property, flag, "query.indexes")
+      if (filters.includes(id)) {
+        const schema = resolveQuerySchema(property.schema, valueTypes)
+        if (!schema || queryScalarKindForSchema(schema) !== "string")
+          throw new OntologyValidationError(
+            `[Sixb] Query index filters must be strings: '${typeId}.${id}'`
+          )
+      }
+    }
+    if (
+      index.kind === "sort" &&
+      index.fields.some(
+        (field) =>
+          field.direction !== undefined && field.direction !== "asc" && field.direction !== "desc"
+      )
+    )
+      throw new OntologyValidationError(
+        `[Sixb] Query index direction must be asc or desc on '${typeId}'`
+      )
+  }
+}

package/src/query.ts

@@ -6,6 +6,8 @@
  * top of this module.
  */
 
+export type { ModelRef } from "./models/catalog"
+export type { RerankingModelDefinition, RerankingModelRef } from "./models/reranking-model"
 export type { ObjectQueryPlanningIssue } from "./objects/query/errors"
 export {
   ObjectQueryExecutionError,
@@ -29,6 +31,7 @@ export type {
   ObjectQueryPredicateNot,
   ObjectQueryProject,
   ObjectQueryRefs,
+  ObjectQueryRerank,
   ObjectQueryResultShape,
   ObjectQuerySet,
   ObjectQuerySetOperation,
@@ -68,6 +71,7 @@ export type {
   ObjectQueryFacetBucket,
   ObjectQueryFacetInput,
   ObjectQueryFacetResult,
+  ObjectQueryFacetsResult,
   ObjectQueryListOptions,
   ObjectQueryRow,
   ObjectWhereBuilder,

package/src/queues/in-memory.ts

@@ -109,11 +109,16 @@ function eligibleAt(record: QueueRecord): number {
   return Math.max(record.availableAtMs, record.leaseExpiryMs ?? -Infinity)
 }
 
+// Largest delay `setTimeout` accepts; a waiting claim that wakes early just waits again.
+const MAX_TIMER_DELAY_MS = 2_147_483_647
+
 interface QueueLane {
   // Terminal records remain here for caller-id deduplication, never in the delivery indexes.
   readonly records: Map<string, QueueRecord>
   readonly ready: IndexedHeap<QueueRecord>
   readonly waiting: IndexedHeap<QueueRecord>
+  /** Wakes claims waiting on this lane. */
+  readonly waiters: Set<() => void>
 }
 
 function toClaimedQueueJob<TQueueJob extends QueueJob>(
@@ -175,6 +180,27 @@ class InMemoryQueueStore {
       lane.ready.delete(record)
       lane.waiting.set(record)
     }
+    // Any change can make a job claimable or move the next due time; waiters look again.
+    for (const wake of lane.waiters) wake()
+  }
+
+  /** Resolves when the lane changes, its next delayed job or lease comes due, or `signal` aborts. */
+  waitForWork(projectId: string, queueId: string, signal: AbortSignal): Promise<void> {
+    const lane = this.lane(projectId, queueId)
+    const next = lane.waiting.peek()
+    const dueInMs = next ? eligibleAt(next) - Date.now() : MAX_TIMER_DELAY_MS
+    return new Promise((resolve) => {
+      // Always armed: like a blocking read on a socket, a waiting claim keeps its process alive.
+      const timer = setTimeout(wake, Math.min(dueInMs, MAX_TIMER_DELAY_MS))
+      function wake(): void {
+        clearTimeout(timer)
+        lane.waiters.delete(wake)
+        signal.removeEventListener("abort", wake)
+        resolve()
+      }
+      lane.waiters.add(wake)
+      signal.addEventListener("abort", wake, { once: true })
+    })
   }
 
   takeReady<TQueueJob extends QueueJob>(
@@ -216,6 +242,7 @@ class InMemoryQueueStore {
         waiting: new IndexedHeap(
           (left, right) => eligibleAt(left) - eligibleAt(right) || left.sequence - right.sequence
         ),
+        waiters: new Set(),
       }
       queues.set(queueId, lane)
     }
@@ -263,6 +290,7 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     workerId: string
     limit?: number
     leaseMs?: number
+    signal?: AbortSignal
   }): Promise<readonly ClaimedQueueJob<TQueueJob>[]> {
     assertNonEmpty(params.projectId, "projectId")
     assertNonEmpty(params.workerId, "workerId")
@@ -275,27 +303,34 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     const leaseMs = params.leaseMs ?? 30_000
     assertPositiveNumber(leaseMs, "leaseMs")
 
-    const now = Date.now()
-    const claimedAt = new Date(now).toISOString()
-    // Validate before removing candidates, and cache the same millisecond precision we return.
-    const leaseExpiry = new Date(now + leaseMs)
-    const leaseExpiresAt = leaseExpiry.toISOString()
-    const claimable = this.store.takeReady<TQueueJob>(params.projectId, this.queueId, now, limit)
-
-    return claimable.map((record) => {
-      // Attempts count claims so redelivery after lease expiry or retry is visible to workers.
-      record.job = {
-        ...record.job,
-        attempt: record.job.attempt + 1,
+    for (;;) {
+      if (params.signal?.aborted) return []
+      const now = Date.now()
+      const claimedAt = new Date(now).toISOString()
+      // Validate before removing candidates, and cache the same millisecond precision we return.
+      const leaseExpiry = new Date(now + leaseMs)
+      const leaseExpiresAt = leaseExpiry.toISOString()
+      const claimable = this.store.takeReady<TQueueJob>(params.projectId, this.queueId, now, limit)
+      if (claimable.length === 0 && params.signal) {
+        await this.store.waitForWork(params.projectId, this.queueId, params.signal)
+        continue
       }
-      record.leaseId = randomUUID()
-      record.claimedAt = claimedAt
-      record.leaseExpiresAt = leaseExpiresAt
-      record.leaseExpiryMs = leaseExpiry.getTime()
-      this.store.schedule(params.projectId, record, now)
 
-      return toClaimedQueueJob(record)
-    })
+      return claimable.map((record) => {
+        // Attempts count claims so redelivery after lease expiry or retry is visible to workers.
+        record.job = {
+          ...record.job,
+          attempt: record.job.attempt + 1,
+        }
+        record.leaseId = randomUUID()
+        record.claimedAt = claimedAt
+        record.leaseExpiresAt = leaseExpiresAt
+        record.leaseExpiryMs = leaseExpiry.getTime()
+        this.store.schedule(params.projectId, record, now)
+
+        return toClaimedQueueJob(record)
+      })
+    }
   }
 
   async complete(params: { projectId: string; jobId: string; leaseId: string }): Promise<void> {

package/src/queues/types.ts

@@ -82,12 +82,16 @@ export interface Queue<
    *
    * `leaseMs` is the visibility timeout for this claim. If the lease expires
    * before the job is acknowledged, the job may be delivered again.
+   *
+   * Without `signal`, returns at once, possibly empty. With `signal`, waits for work instead:
+   * it resolves once it claims at least one job, and empty only after `signal` aborts.
    */
   claim(params: {
     projectId: string
     workerId: string
     limit?: number
     leaseMs?: number
+    signal?: AbortSignal
   }): Promise<readonly ClaimedQueueJob<TQueueJob>[]>
 
   /** Acknowledges successful processing and removes the claimed job from delivery. */

package/src/runtime/host.ts

@@ -54,8 +54,10 @@ import {
 import { createOntologyMaterializer, type OntologyMaterializerContract } from "../materializer"
 import type { ModelCatalogInput } from "../models"
 import { bindEmbeddingModels } from "../models/execution/embedding"
+import { bindRerankingModels } from "../models/execution/reranking"
 import { ModelExecutionSession } from "../models/execution/session"
 import { createVectorIndexingRuntime } from "../objects/vectors/indexing"
+import { VectorIndexingDispatcher } from "../objects/vectors/indexing-dispatch"
 import { registerVectorIndexingRuntime } from "../objects/vectors/indexing-runtime"
 import type { PipelineDefinition } from "../pipelines/types"
 import { registerProjectionRegistry } from "../projections/internal"
@@ -88,6 +90,7 @@ import {
   createOntologyMutationRuntime,
   registerOntologyMutationRuntime,
 } from "./ontology-mutations"
+import { getApiPublicOrigin } from "./public-origin"
 import { resolveDefinitions } from "./resolve-definitions"
 import { createBoundSixb, type Sixb, type SixbDependencies } from "./sixb"
 import { StorageReadiness } from "./storage-readiness"
@@ -141,6 +144,7 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
   private readonly webhookRegistry: WebhookRegistry
   private readonly hostContext: SixbHostContext
   private readonly committedFacts: OntologyOutboxDispatcher
+  private readonly vectorIndexing?: VectorIndexingDispatcher
   private readonly eventService: DomainEventService
   private readonly ontologyMaintenance: OntologyMaintenance
   private readonly storageReadiness: StorageReadiness
@@ -234,16 +238,31 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
           ...failure,
         }),
     })
+    const vectorIndexing = this.storage.ontology.vectorIndexing
+    if (
+      vectorIndexing &&
+      definitions.ontology
+        .listObjectTypes()
+        .some((type) => Object.keys(type.search?.vectors ?? {}).length > 0)
+    ) {
+      this.vectorIndexing = new VectorIndexingDispatcher(
+        this.projectId,
+        vectorIndexing,
+        this.queues.vectorIndexing
+      )
+    }
     this.ontologyMaintenance = new OntologyMaintenance({
       projectId: this.projectId,
       storage: this.storage,
       dispatcher: this.committedFacts,
+      vectorIndexing: this.vectorIndexing,
       blobStorage: this.blobStorage,
       options: options.ontologyMaintenance,
     })
 
     this.hostContext = {
       embeddingModels: definitions.models?.embedding,
+      rerankingModels: definitions.models?.reranking,
       projectId: this.projectId,
       broker: this.broker,
       ontology: definitions.ontology,
@@ -277,16 +296,19 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
       capturedScope.execution
     )
     const embeddingModels = bindEmbeddingModels(this.hostContext.embeddingModels, modelExecution)
+    const rerankingModels = bindRerankingModels(this.hostContext.rerankingModels, modelExecution)
     const objectReader = createAuthorizedObjectReader({
       scope: capturedScope,
       ontology: this.hostContext.ontology,
       objectStorage: this.storage.objects,
       embeddingModels,
+      rerankingModels,
     })
 
     const runtime: SixbRuntimeContext = {
       ...this.hostContext,
       embeddingModels,
+      rerankingModels,
       modelExecution,
       runtimeAuthorization: capturedScope.authorization,
       objectReader,
@@ -296,7 +318,10 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
       runtime,
       createOntologyMutationRuntime({
         materializer: this.materializer.withScope(capturedScope),
-        notifyCommittedFacts: () => this.committedFacts.notify(),
+        notifyCommittedFacts: () => {
+          this.committedFacts.notify()
+          this.vectorIndexing?.notify()
+        },
       })
     )
     return createBoundSixb<InferSandboxParams<TParams>>(
@@ -352,6 +377,7 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
   /** Close the runtime broker provider if it owns external resources. */
   async closeBroker(): Promise<void> {
     await this.committedFacts.stop()
+    await this.vectorIndexing?.stop()
     await this.ontologyMaintenance.stop()
     await this.broker.close?.()
   }
@@ -369,6 +395,7 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
         ? {}
         : { connectorConnections: this.connectorService.connectionProcess }),
       blobStorage: this.blobStorage,
+      apiPublicOrigin: () => getApiPublicOrigin(this),
       lakeStorage: this.lakeStorage,
     }
   }

package/src/runtime/index.ts

@@ -40,6 +40,7 @@ export type {
   ObjectQueryFacetBucket,
   ObjectQueryFacetInput,
   ObjectQueryFacetResult,
+  ObjectQueryFacetsResult,
   ObjectQueryListOptions,
   ObjectQueryRow,
   ObjectReadByIdHandle,

package/src/runtime/internal.ts

@@ -20,4 +20,5 @@ export {
   registerOntologyMutationRuntime,
   shareOntologyMutationRuntime,
 } from "./ontology-mutations"
+export { setApiPublicOrigin } from "./public-origin"
 export type { SixbHostContext, SixbRuntimeContext } from "./types"

package/src/runtime/public-origin.ts

@@ -0,0 +1,33 @@
+/**
+ * The origin the API is reachable at from outside, for features that hand out absolute URLs a
+ * third party will fetch. It is deployment topology, not app configuration: the API server
+ * records the `publicOrigin` it was started with, and the CLI records `SIXB_API_PUBLIC_ORIGIN`
+ * for worker processes. A process that never learns it cannot issue such URLs.
+ */
+
+const apiPublicOrigins = new WeakMap<object, string>()
+
+/** Record where the API is reachable. A host served by several servers keeps the latest one. */
+export function setApiPublicOrigin(host: object, origin: string): void {
+  apiPublicOrigins.set(host, normalizeOrigin(origin))
+}
+
+export function getApiPublicOrigin(host: object): string | undefined {
+  return apiPublicOrigins.get(host)
+}
+
+function normalizeOrigin(value: string): string {
+  let url: URL
+  try {
+    url = new URL(value)
+  } catch {
+    throw new Error(`[Sixb] Invalid API public origin: '${value}'.`)
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("[Sixb] The API public origin must use http or https.")
+  }
+  if (url.pathname !== "/" || url.search || url.hash) {
+    throw new Error("[Sixb] The API public origin must be an origin, not a full URL.")
+  }
+  return url.origin
+}

package/src/runtime/sixb.ts

@@ -65,6 +65,7 @@ export interface SixbDependencies {
   readonly connectorService: ConnectorService
   readonly connectorConnections?: ConnectorConnectionProcess
   readonly blobStorage: BlobStorage
+  readonly apiPublicOrigin: () => string | undefined
   readonly lakeStorage: LakeStorage
 }
 
@@ -129,13 +130,23 @@ function createExecutionFacades<TParams extends Record<string, unknown>>(
       dependencies.definitions.models,
       dependencies.sandbox
     ),
-    models: createModelsRuntime(runtime, execution, dependencies.definitions.models),
+    models: createModelsRuntime(
+      runtime,
+      execution,
+      dependencies.definitions.models,
+      dependencies.blobStorage
+    ),
     aiUsage: createAiUsageRuntime(runtime, dependencies.definitions.security),
     events: createEventsRuntime(runtime),
     logs: createLogsRuntime(runtime, dependencies.logging),
     schedules: createSchedulesRuntime(runtime, dependencies.definitions.schedules),
     shares: createSharesRuntime(runtime, execution, dependencies.definitions.shares),
     connector: createConnectorRuntime(runtime, execution, dependencies.connectorService),
-    blobs: createBlobsRuntime(runtime, execution, dependencies.blobStorage),
+    blobs: createBlobsRuntime(
+      runtime,
+      execution,
+      dependencies.blobStorage,
+      dependencies.apiPublicOrigin
+    ),
   }
 }

package/src/runtime/types.ts

@@ -16,7 +16,7 @@ import type { Broker } from "../broker"
 import type { DomainEventLog } from "../events"
 import type { RuntimeAuthorization } from "../execution"
 import type { AuthorizedObjectReader } from "../execution/authorized-object-reader"
-import type { EmbeddingModelCatalog } from "../models"
+import type { EmbeddingModelCatalog, RerankingModelCatalog, RerankingModelRef } from "../models"
 import type { ModelExecutionSession } from "../models/execution/session"
 import type {
   ObjectQuery,
@@ -58,6 +58,7 @@ import type { ActionRunRecord, ObjectLinkRow, Storage } from "../storage"
  */
 export interface SixbHostContext {
   readonly embeddingModels?: EmbeddingModelCatalog
+  readonly rerankingModels?: RerankingModelCatalog
   readonly projectId: string
   readonly broker: Broker
   readonly ontology: OntologyRegistry
@@ -414,6 +415,12 @@ export type ObjectQueryFacetBucket = {
   count: number
 }
 
+/** Total and facet buckets are calculated from the same matching set. */
+export type ObjectQueryFacetsResult = {
+  total: number
+  facets: ObjectQueryFacetResult[]
+}
+
 export type ObjectQueryFacetResult = {
   propertyId: string
   buckets: ObjectQueryFacetBucket[]
@@ -669,6 +676,9 @@ export interface ObjectQueryBuilder<
     options: { k: number }
   ): ObjectQueryBuilder<TObjectType, TRow>
 
+  /** Reorder up to 100 vector candidates with an explicitly registered server-side model. */
+  rerank(options: { model: RerankingModelRef }): ObjectQueryBuilder<TObjectType, TRow>
+
   /** Follow an outgoing link and make the linked object type the current result type. */
   traverse<TLinkToken extends LinkToken<TObjectType["id"], string, LinkTargetObjectTypeIdValue>>(
     link: TLinkToken,
@@ -750,7 +760,7 @@ export interface ObjectQueryBuilder<
   exists(): Promise<boolean>
 
   /** Count matching objects by configured facetable properties. */
-  facets(input: readonly ObjectQueryFacetInput<TObjectType>[]): Promise<ObjectQueryFacetResult[]>
+  facets(input: readonly ObjectQueryFacetInput<TObjectType>[]): Promise<ObjectQueryFacetsResult>
 
   /** Execute this query with an outer limit of one and return the first object. */
   first(): Promise<Simplify<TRow> | null>

package/src/storage/ai-cost/analytics.ts

@@ -68,6 +68,7 @@ export interface AiAccountingAggregateFragment {
     readonly cacheWriteInputTokens: AiAccountingUsageMeterFragment
     readonly textOutputTokens: AiAccountingUsageMeterFragment
     readonly reasoningOutputTokens: AiAccountingUsageMeterFragment
+    readonly audioDurationMs: AiAccountingUsageMeterFragment
   }
   readonly costs: {
     readonly amount?: AiMoney
@@ -406,6 +407,7 @@ const AGGREGATE_USAGE_FIELDS = [
   "cacheWriteInputTokens",
   "textOutputTokens",
   "reasoningOutputTokens",
+  "audioDurationMs",
 ] as const
 
 type AggregateUsageField = (typeof AGGREGATE_USAGE_FIELDS)[number]

package/src/storage/ai-cost/codec.ts

@@ -110,7 +110,8 @@ function billableMeter(value: unknown): AiBillableMeter {
     value !== "tokens.input.cacheWrite1h" &&
     value !== "tokens.output.total" &&
     value !== "tokens.output.text" &&
-    value !== "tokens.output.reasoning"
+    value !== "tokens.output.reasoning" &&
+    value !== "audio.input.milliseconds"
   ) {
     throw invalidDetails()
   }

package/src/storage/ai-cost/types.ts

@@ -6,6 +6,7 @@ import type {
 
 /** Token meters supported by deterministic local rate cards. */
 export type AiBillableMeter =
+  | "audio.input.milliseconds"
   | "tokens.input.total"
   | "tokens.input.uncached"
   | "tokens.input.cacheRead"

package/src/storage/ai-cost/validation.ts

@@ -15,8 +15,8 @@ import type {
 } from "./types"
 
 const SIGNED_INT64_MAX = 9_223_372_036_854_775_807n
-const TOKENS_PER_MILLION = 1_000_000n
-const HALF_MILLION = TOKENS_PER_MILLION / 2n
+const UNITS_PER_MILLION = 1_000_000n
+const HALF_MILLION = UNITS_PER_MILLION / 2n
 const MAX_NUMERIC_TEXT_LENGTH = 128
 const METER_ORDER: Readonly<Record<AiBillableMeter, number>> = {
   "tokens.input.total": 0,
@@ -28,6 +28,7 @@ const METER_ORDER: Readonly<Record<AiBillableMeter, number>> = {
   "tokens.output.total": 6,
   "tokens.output.text": 7,
   "tokens.output.reasoning": 8,
+  "audio.input.milliseconds": 9,
 }
 const METERS = new Set(Object.keys(METER_ORDER) as AiBillableMeter[])
 const UNPRICEABLE_REASONS = new Set<AiUnpriceableReason>([
@@ -120,11 +121,7 @@ export function aiModelCallCostMatchesUsage(
     const components = new Map(
       record.estimate.components.map((component) => [component.meter, component])
     )
-    if (
-      !inputComponentsMatchUsage(components, usage) ||
-      !outputComponentsMatchUsage(components, usage)
-    )
-      return false
+    if (!componentsMatchUsage(components, usage)) return false
   }
   if (record.status === "unpriceable") return true
   if (record.components.length === 0 && isExternalValuationSource(record.priceSource.sourceId)) {
@@ -133,6 +130,22 @@ export function aiModelCallCostMatchesUsage(
 
   const usage = normalizeAiModelCallUsage(usageRecord.usage)
   const components = new Map(record.components.map((component) => [component.meter, component]))
+  return componentsMatchUsage(components, usage)
+}
+
+function componentsMatchUsage(
+  components: ReadonlyMap<AiBillableMeter, AiCostComponent>,
+  usage: AiModelCallUsage
+): boolean {
+  const audio = components.get("audio.input.milliseconds")
+  if (audio) {
+    return (
+      components.size === 1 &&
+      usage.audioDurationMs !== undefined &&
+      BigInt(audio.quantity) === BigInt(usage.audioDurationMs)
+    )
+  }
+
   return (
     inputComponentsMatchUsage(components, usage) && outputComponentsMatchUsage(components, usage)
   )
@@ -362,7 +375,7 @@ function calculateComponent(
 ): AiCostComponent {
   const normalizedQuantity = parseQuantity(quantity, `${meter} quantity`)
   const rate = parseNonnegativeInt64(rateAmountNanosPerMillion, `${meter} rate`)
-  const charge = (normalizedQuantity * rate + HALF_MILLION) / TOKENS_PER_MILLION
+  const charge = (normalizedQuantity * rate + HALF_MILLION) / UNITS_PER_MILLION
   assertSignedInt64(charge, `${meter} charge`)
   return {
     meter,

package/src/storage/ai-limits/in-memory.ts

@@ -8,6 +8,7 @@ import {
   AiLimitOperationLock,
   aiLimitAccountingEntryAppliesToSubject,
   aiLimitAmountKey,
+  aiLimitMeterApplies,
   aiLimitPolicyDimensionKey,
   aiLimitQuantityFromAmount,
   aiLimitReservationBuckets,
@@ -227,7 +228,12 @@ export class InMemoryAiLimitStorage implements AiLimitStorage {
       const unavailablePolicies: AiLimitPolicyStatus[] = []
       const unavailableReasons = new Set<"missingEstimate" | "incompleteAccounting">()
       for (const policy of enabledPolicies) {
-        if (!subjectKeys.has(aiLimitSubjectKey(policy.subject))) continue
+        if (
+          !subjectKeys.has(aiLimitSubjectKey(policy.subject)) ||
+          !aiLimitMeterApplies(policy.limit.meter, request.modelKind)
+        ) {
+          continue
+        }
         const limit = normalizeAiLimitAmount(policy.limit)
         const estimate = estimates.get(aiLimitAmountKey(limit))
         const status = await this.policyStatus(policy, request.period)
@@ -268,7 +274,8 @@ export class InMemoryAiLimitStorage implements AiLimitStorage {
       const buckets = aiLimitReservationBuckets(
         enabledPolicies,
         request.subjects,
-        request.estimates
+        request.estimates,
+        request.modelKind
       )
       if (buckets.length === 0) return { status: "notRequired" }
       for (const bucket of buckets) {
@@ -601,6 +608,7 @@ export class InMemoryAiLimitStorage implements AiLimitStorage {
       attempt: record.attempt,
       callId: record.callId,
       occurredAt: new Date(record.occurredAt),
+      ...(record.modelKind === undefined ? {} : { modelKind: record.modelKind }),
       ...(record.usage.totalTokens === undefined ? {} : { totalTokens: record.usage.totalTokens }),
       requesterGroupIds: [...record.requesterGroupIds],
       ...(requester?.type === "user" || requester?.type === "serviceAccount"