@sixb/core 0.1.16 → 0.1.17

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"
@@ -9,6 +14,7 @@ import {
 } from "./definitions"
 import { assertEmbeddingModel, type EmbeddingModel } from "./embedding-model"
 import type { LanguageModel } from "./language-model"
+import { assertRerankingModel, type RerankingModel } from "./reranking-model"
 
 /** Stable identity of a configured provider binding. */
 export interface ModelRef {
@@ -27,6 +33,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 +62,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 +86,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 +107,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(

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
@@ -47,6 +47,25 @@ Direct provider calls bypass this session. Webhook handlers have no bound model
 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
 
 Decision evaluation in `../decision/runtime.ts` uses the same session and recorder. It snapshots JSON input/questions

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
 }
 

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

@@ -157,6 +157,7 @@ export class AiModelCallRecorder {
         providerId: event.providerId,
         ...(event.providerIds === undefined ? {} : { providerIds: event.providerIds }),
         requestedModelId: event.modelId,
+        ...(event.modelKind === undefined ? {} : { modelKind: event.modelKind }),
         ...(event.requestedReasoning === undefined
           ? {}
           : { requestedReasoning: event.requestedReasoning }),

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

@@ -73,6 +73,7 @@ function toQueuePayload(record: RecordAiModelCallInput): AiModelCallRecordPayloa
       ? {}
       : { providerIds: structuredClone(record.providerIds) }),
     requestedModelId: record.requestedModelId,
+    ...(record.modelKind === undefined ? {} : { modelKind: record.modelKind }),
     ...(record.requestedReasoning === undefined
       ? {}
       : { requestedReasoning: structuredClone(record.requestedReasoning) }),

package/src/models/execution/reranking.ts

@@ -0,0 +1,137 @@
+import { randomUUID } from "node:crypto"
+import type { RerankingModelCatalog } from "../catalog"
+import { indexModelBindings } from "../catalog-index"
+import { estimateModelCall } from "../pricing"
+import {
+  assertRerankingModel,
+  type RerankingModel,
+  type RerankingModelRequest,
+  RerankingModelResponseError,
+  type RerankingModelResponseMetadata,
+  type RerankingModelResult,
+  validateRerankingResults,
+} from "../reranking-model"
+import type { AiModelCallRecorder } from "./model-call-recorder"
+import type { ModelExecutionSession } from "./session"
+
+export function bindRerankingModels(
+  catalog: RerankingModelCatalog | undefined,
+  session: ModelExecutionSession
+): RerankingModelCatalog | undefined {
+  if (!catalog) return undefined
+  return indexModelBindings(
+    catalog.list().map(({ model }) =>
+      Object.freeze({
+        providerId: model.providerId,
+        modelId: model.modelId,
+        definition: model.definition,
+        rerank: (input: RerankingModelRequest) => executeReranking(session, model, input),
+      })
+    ),
+    "reranking",
+    assertRerankingModel
+  )
+}
+
+async function executeReranking(
+  session: ModelExecutionSession,
+  binding: RerankingModel,
+  input: RerankingModelRequest
+): Promise<RerankingModelResult> {
+  const query = input.query
+  if (
+    typeof query !== "string" ||
+    !query.trim() ||
+    !Array.isArray(input.documents) ||
+    input.documents.some((text) => typeof text !== "string" || !text.trim())
+  ) {
+    throw new TypeError("[SixbModels] Reranking requires a query and nonempty document strings.")
+  }
+  const documents = [...input.documents]
+  const signal = AbortSignal.any([session.signal(input.signal), AbortSignal.timeout(30_000)])
+  signal.throwIfAborted()
+  if (documents.length === 0) return { results: [] }
+
+  const accounting = await session.accounting()
+  accounting.assertHealthy()
+  const model = (await binding.resolve?.()) ?? binding
+  assertRerankingModel(model)
+  if (model.providerId !== binding.providerId || model.modelId !== binding.modelId) {
+    throw new TypeError(
+      "[SixbModels] Resolved reranking model identity does not match its binding."
+    )
+  }
+  signal.throwIfAborted()
+
+  // Rerankers compare each document with the query. Count the query for each pair;
+  // this is the shared admission heuristic, never a substitute for reported usage.
+  const encoder = new TextEncoder()
+  const queryBytes = encoder.encode(query).byteLength
+  const tokens = documents.reduce(
+    (sum, text) => sum + Math.ceil((queryBytes + encoder.encode(text).byteLength) / 4),
+    0
+  )
+  const callId = `call_${randomUUID()}`
+  await accounting.admitCall({
+    callId,
+    providerId: model.providerId,
+    modelId: model.modelId,
+    modelKind: "reranking",
+    costEstimator: model.costEstimator,
+    inputTokens: { status: "estimated", tokens, method: "utf8BytesDividedByFour" },
+    outputTokenAllowance: 0,
+    estimatedTotalTokens: tokens,
+  })
+
+  let result: RerankingModelResult
+  try {
+    signal.throwIfAborted()
+    result = await model.rerank({ query, documents, signal })
+  } catch (error) {
+    const metadata = error instanceof RerankingModelResponseError ? error.metadata : {}
+    await recordReranking(accounting, model, callId, metadata)
+    throw error
+  }
+
+  // A malformed or cancelled response can still be billable.
+  await recordReranking(accounting, model, callId, result ?? {})
+  signal.throwIfAborted()
+  try {
+    return { ...result, results: validateRerankingResults(result?.results, documents.length) }
+  } catch (cause) {
+    throw new RerankingModelResponseError(
+      "[SixbModels] Invalid reranking response.",
+      model.providerId,
+      model.modelId,
+      result ?? {},
+      { cause }
+    )
+  }
+}
+
+async function recordReranking(
+  accounting: AiModelCallRecorder,
+  model: RerankingModel,
+  callId: string,
+  metadata: RerankingModelResponseMetadata
+): Promise<void> {
+  const usage = { ...metadata.usage, outputTokens: metadata.usage?.outputTokens ?? 0 }
+  const estimate = estimateModelCall(model, {
+    usage,
+    route: metadata.route,
+    responseModelId: metadata.responseModelId,
+  })
+  await accounting.onModelCallEnd({
+    callId,
+    modelKind: "reranking",
+    providerId: model.providerId,
+    modelId: model.modelId,
+    responseId: metadata.providerIds?.responseId ?? callId,
+    responseModelId: metadata.responseModelId,
+    providerIds: metadata.providerIds,
+    usage,
+    cost: metadata.reportedCost ? { status: "reported", ...metadata.reportedCost } : estimate,
+    ...(metadata.reportedCost ? { estimate } : {}),
+    route: metadata.route,
+  })
+}

package/src/models/execution/usage.ts

@@ -4,6 +4,7 @@ import type { ModelUsage } from "../events"
 /** Map one provider-neutral model call into Sixb's durable accounting vocabulary. */
 export function aiModelCallUsageFromModel(usage: ModelUsage): AiModelCallUsageInput {
   return {
+    ...(usage.audioDurationMs === undefined ? {} : { audioDurationMs: usage.audioDurationMs }),
     ...(usage.inputTokens === undefined ? {} : { inputTokens: usage.inputTokens }),
     ...(usage.outputTokens === undefined ? {} : { outputTokens: usage.outputTokens }),
     ...(usage.uncachedInputTokens === undefined

package/src/models/execution.ts

@@ -1,7 +1,9 @@
 import { runModelLoop } from "../agents/model-loop"
 import { assertProviderAccess } from "../authorization"
+import type { BlobStorage } from "../blob-storage/types"
 import type { ExecutionContext } from "../execution"
 import type { SixbRuntimeContext } from "../runtime/types"
+import { createAudioRuntime } from "./audio/runtime"
 import type { ModelCatalog } from "./catalog"
 import { createDecisionRuntime } from "./decision/runtime"
 import { ModelProviderError, ModelStreamError, UnsupportedModelFeatureError } from "./errors"
@@ -24,7 +26,8 @@ import { resolveLanguageModel } from "./resolve"
 export function createModelsRuntime(
   runtime: SixbRuntimeContext,
   execution: ExecutionContext,
-  catalog: ModelCatalog | undefined
+  catalog: ModelCatalog | undefined,
+  blobs?: BlobStorage
 ): ModelsRuntime {
   const session = runtime.modelExecution ?? new ModelExecutionSession(runtime, execution)
 
@@ -123,6 +126,7 @@ export function createModelsRuntime(
   const models: ModelsRuntime = {
     language: { generate },
     decision: createDecisionRuntime(runtime, execution, catalog, session),
+    audio: createAudioRuntime(runtime, execution, catalog, session, blobs),
   }
   registerModelExecutionBinding(models, (input) => {
     session.bind(input)

package/src/models/generation-types.ts

@@ -1,4 +1,5 @@
 import type { InferSchemaOrRef, SchemaOrRef } from "../ontology"
+import type { AudioModelsRuntime } from "./audio/types"
 import type { DecisionModelsRuntime } from "./decision/types"
 import type { ModelFinishReason, ModelUsage } from "./events"
 import type { LanguageModel, ModelReasoning } from "./language-model"
@@ -47,6 +48,7 @@ export interface LanguageModelsRuntime {
 }
 
 export interface ModelsRuntime {
+  readonly audio: AudioModelsRuntime
   readonly language: LanguageModelsRuntime
   readonly decision: DecisionModelsRuntime
 }

package/src/models/index.ts

@@ -1,5 +1,25 @@
+export type { FileRef } from "../blob-storage/types"
 export type { JsonObject, JsonPrimitive, JsonValue } from "../json"
 export { assertJsonObject, assertJsonValue, isJsonObject, isJsonValue } from "../json"
+export type {
+  AudioModelCatalog,
+  AudioModelCatalogInput,
+  TranscriptionModelCatalog,
+  TranscriptionModelEntry,
+} from "./audio/catalog"
+export { TranscriptionModelResponseError } from "./audio/errors"
+export type {
+  AudioModelsRuntime,
+  AudioTranscribeInput,
+  AudioTranscribeResult,
+  TranscriptionCostEstimator,
+  TranscriptionModel,
+  TranscriptionModelDefinition,
+  TranscriptionModelRequest,
+  TranscriptionModelResponseMetadata,
+  TranscriptionModelResult,
+  TranscriptionOutput,
+} from "./audio/types"
 export type {
   EmbeddingModelCatalog,
   EmbeddingModelEntry,
@@ -12,6 +32,8 @@ export type {
   ModelCatalogInput,
   ModelDefinitionCatalog,
   ModelRef,
+  RerankingModelCatalog,
+  RerankingModelEntry,
 } from "./catalog"
 export { createModelCatalog } from "./catalog"
 export type { DecisionModelCatalog, DecisionModelEntry } from "./decision/catalog"
@@ -131,4 +153,14 @@ export type {
   ModelUnitPrice,
 } from "./rate-card"
 export { defineModelRateCard } from "./rate-card"
+export type {
+  RerankingModel,
+  RerankingModelDefinition,
+  RerankingModelRef,
+  RerankingModelRequest,
+  RerankingModelResponseMetadata,
+  RerankingModelResult,
+  RerankingResult,
+} from "./reranking-model"
+export { RerankingModelResponseError } from "./reranking-model"
 export type { ModelOutput, ModelTool, ModelToolExecutionContext } from "./tools"

package/src/models/pricing.ts

@@ -3,7 +3,7 @@ import type { LanguageModelRateCard, ModelTokenPrice } from "./rate-card"
 
 /** Optional local financial enrichment cannot discard a completed, billable call. */
 export function estimateModelCall(
-  model: { readonly costEstimator?: ModelCostEstimator },
+  model: { readonly costEstimator?: Pick<ModelCostEstimator, "estimate"> },
   input: Parameters<ModelCostEstimator["estimate"]>[0]
 ): ModelCostEstimate {
   try {
@@ -46,6 +46,7 @@ export interface ModelCostEstimator {
 }
 
 export type ModelCostMeter =
+  | "audio.input.milliseconds"
   | "tokens.input.total"
   | "tokens.input.uncached"
   | "tokens.input.cacheRead"

package/src/models/reranking-model.ts

@@ -0,0 +1,114 @@
+import type { ModelDefinition } from "./definitions"
+import { ModelProviderError } from "./errors"
+import type { ModelProviderIds, ModelRoute, ModelUsage } from "./events"
+import type { ModelCostEstimator, ModelReportedCost } from "./pricing"
+
+export interface RerankingModelDefinition extends ModelDefinition {
+  readonly kind: "reranking"
+}
+
+/** Serializable identity; the server resolves its own registered binding. */
+export interface RerankingModelRef {
+  readonly providerId: string
+  readonly modelId: string
+  readonly definition: RerankingModelDefinition
+}
+
+export interface RerankingModelRequest {
+  readonly query: string
+  readonly documents: readonly string[]
+  readonly signal?: AbortSignal
+}
+
+export interface RerankingModelResponseMetadata {
+  readonly usage?: ModelUsage
+  readonly providerIds?: ModelProviderIds
+  readonly responseModelId?: string
+  readonly reportedCost?: ModelReportedCost
+  readonly route?: ModelRoute
+}
+
+export interface RerankingResult {
+  /** Position in the original documents array. */
+  readonly index: number
+  /** Provider relevance score, not a calibrated probability. */
+  readonly score: number
+}
+
+export interface RerankingModelResult extends RerankingModelResponseMetadata {
+  /** One result per input document; Sixb validates completeness and orders by score. */
+  readonly results: readonly RerankingResult[]
+}
+
+export interface RerankingModel extends RerankingModelRef {
+  readonly costEstimator?: ModelCostEstimator
+  resolve?(): Promise<RerankingModel>
+  rerank(request: RerankingModelRequest): Promise<RerankingModelResult>
+}
+
+export function assertRerankingModel(model: RerankingModel): void {
+  if (
+    !model ||
+    typeof model !== "object" ||
+    typeof model.rerank !== "function" ||
+    !validIdentifier(model.providerId) ||
+    !validIdentifier(model.modelId) ||
+    model.definition?.kind !== "reranking" ||
+    model.definition.providerId !== model.providerId ||
+    model.definition.modelId !== model.modelId
+  ) {
+    throw new TypeError("[Sixb] Expected a RerankingModel with a valid identity and rerank method.")
+  }
+}
+
+export function validateRerankingResults(
+  results: unknown,
+  documentCount: number
+): RerankingResult[] {
+  if (!Array.isArray(results) || results.length !== documentCount) {
+    throw new TypeError("[SixbModels] Reranking must return one result per document.")
+  }
+  const seen = new Set<number>()
+  const validated = results.map((result: unknown) => {
+    if (!result || typeof result !== "object") {
+      throw new TypeError("[SixbModels] Invalid reranking result.")
+    }
+    const index: unknown = Reflect.get(result, "index")
+    const score: unknown = Reflect.get(result, "score")
+    if (
+      typeof index !== "number" ||
+      !Number.isSafeInteger(index) ||
+      index < 0 ||
+      index >= documentCount ||
+      seen.has(index) ||
+      typeof score !== "number" ||
+      !Number.isFinite(score)
+    ) {
+      throw new TypeError("[SixbModels] Reranking requires unique valid indices and finite scores.")
+    }
+    seen.add(index)
+    return { index, score }
+  })
+  // Stable ties preserve candidate rank, independent of the provider's response ordering.
+  return validated.sort((left, right) => right.score - left.score || left.index - right.index)
+}
+
+function validIdentifier(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0 && value.trim() === value
+}
+
+export class RerankingModelResponseError extends ModelProviderError {
+  constructor(
+    message: string,
+    providerId: string,
+    modelId: string,
+    readonly metadata: RerankingModelResponseMetadata,
+    options?: { cause?: unknown }
+  ) {
+    super(message, providerId, modelId, {
+      code: "invalid_reranking_response",
+      retryable: false,
+      cause: options?.cause,
+    })
+  }
+}