@sixb/core 0.1.16 → 0.1.18

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

@@ -70,6 +70,16 @@ export class AiModelCallRecorder {
       })
   }
 
+  /** The execution every call this recorder admits is attributed to. */
+  get executionId(): string {
+    return this.input.executionId
+  }
+
+  /** The execution attempt every call this recorder admits is attributed to. */
+  get attempt(): number {
+    return this.input.attempt
+  }
+
   /** Wrap the resolved model so all calls in an execution share admission. */
   wrapModel(model: LanguageModel): LanguageModel {
     return {
@@ -157,6 +167,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/session.ts

@@ -34,8 +34,8 @@ export class ModelExecutionSession {
   }
 
   accounting(): Promise<AiModelCallRecorder> {
-    this.requireBinding()
-    this.recorder ??= this.createRecorder()
+    const { accounting } = this.requireBinding()
+    this.recorder ??= accounting ? Promise.resolve(accounting) : this.createRecorder()
     return this.recorder
   }
 

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)
 
@@ -42,6 +45,7 @@ export function createModelsRuntime(
     const messages = generationMessages(input)
     const signal = session.signal(input.signal)
     signal.throwIfAborted()
+    // The catalog's binding is the configured one, default reasoning included.
     const selected = input.model
       ? catalog
         ? catalog.language?.getByRef({
@@ -67,6 +71,9 @@ export function createModelsRuntime(
       input.reasoning
     )
     if (reasoningIssue) throw new UnsupportedModelFeatureError(`[SixbModels] ${reasoningIssue}.`)
+    // The default was checked against the capabilities known at startup; like any request, a level
+    // the resolved model turns out not to support falls back to the provider default.
+    const reasoning = input.reasoning ?? selected.defaultReasoning
     if (output && model.definition.capabilities.nativeStructuredOutput === false) {
       throw new UnsupportedModelFeatureError(
         "[SixbModels] Model does not support native structured output."
@@ -76,7 +83,7 @@ export function createModelsRuntime(
       aiModelCallOutputTokenAllowance(input.maxOutputTokens ?? model.definition.maxOutputTokens),
       model.definition.maxOutputTokens ?? Infinity
     )
-    if (typeof input.reasoning === "object" && input.reasoning.budgetTokens >= maxOutputTokens) {
+    if (typeof reasoning === "object" && reasoning.budgetTokens >= maxOutputTokens) {
       throw new TypeError("[SixbModels] Output allowance must exceed the reasoning token budget.")
     }
     const accounting = await session.accounting()
@@ -89,7 +96,7 @@ export function createModelsRuntime(
       maxSteps: 1,
       rejectLocalToolCalls: true,
       maxOutputTokens,
-      reasoning: input.reasoning,
+      reasoning,
       caching: input.caching,
       signal,
       onModelCallEnd: async (completed: ModelCallEndEvent) => {
@@ -123,6 +130,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/language-model.ts

@@ -83,6 +83,12 @@ export interface LanguageModel {
   readonly modelId: string
   readonly definition: LanguageModelDefinition
   readonly costEstimator?: ModelCostEstimator
+  /**
+   * Reasoning Sixb applies whenever this model runs without an explicit choice: chat turns, AI
+   * workflow steps, subagents, and direct generation. Providers set it from their model options;
+   * Sixb checks it against `definition.capabilities` at startup.
+   */
+  readonly defaultReasoning?: ModelReasoningLevel
   /**
    * Return an executable model pinned to operational metadata, preserving model identity.
    * `offline` requires a local snapshot without catalog I/O. Workers retain this model

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,
+    })
+  }
+}

package/src/objects/context/index.ts

@@ -1,6 +1,7 @@
 export { requireLinkDefinition, resolveLinkContext, resolveObjectContext } from "./resolve"
 export type {
   ExecutionObjectContext,
+  ObjectSetContext,
   ResolvedLinkBatchItem,
   ResolvedLinkContext,
   ResolvedObjectContext,

package/src/objects/context/types.ts

@@ -4,6 +4,7 @@
  * Context hierarchy: SixbRuntimeContext → ResolvedObjectContext → ResolvedLinkContext
  */
 
+import type { BlobStorage } from "../../blob-storage"
 import type { ExecutionContext } from "../../execution"
 import type { ObjectLink } from "../../ontology"
 import type { ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
@@ -20,6 +21,12 @@ export interface ExecutionObjectContext extends ResolvedObjectContext {
   readonly execution: ExecutionContext
 }
 
+/** An object set's operations, which also open the files its objects reference. */
+export interface ObjectSetContext extends ExecutionObjectContext {
+  /** Opened only once a FileRef is resolved in a row read with the caller's permissions. */
+  readonly blobStorage: Pick<BlobStorage, "stat" | "open">
+}
+
 /** Resolved context for link operations. */
 export interface ResolvedLinkContext extends ResolvedObjectContext {
   readonly linkDefinition: ObjectLink

package/src/objects/execution.ts

@@ -1,3 +1,4 @@
+import type { BlobStorage } from "../blob-storage"
 import { shareSixbErrorReporter } from "../error-reporting/capability"
 import type { ExecutionContext } from "../execution"
 import {
@@ -147,7 +148,8 @@ export interface ObjectsRuntime extends ExecutionObjectOperations {
 
 export function createObjectsRuntime(
   runtime: SixbRuntimeContext,
-  execution: ExecutionContext
+  execution: ExecutionContext,
+  blobStorage: Pick<BlobStorage, "stat" | "open">
 ): ObjectsRuntime {
   const runtimeAuthorization = runtime.runtimeAuthorization
   const objectReader = runtime.objectReader
@@ -180,6 +182,7 @@ export function createObjectsRuntime(
         ...capturedRuntime,
         execution,
         objectType,
+        blobStorage,
       }) as ExecutionObjectSet<TObjectType>
     },
     {

package/src/objects/materializer-adapter.ts

@@ -25,6 +25,7 @@ import type { ObjectTypeWithPropertyTokens } from "../ontology/tokens"
 import {
   assertKnownProperties,
   assertLinkTargetType,
+  assertValidFileRefs,
   normalizeLinkProperties,
   normalizeObjectProperties,
   validateLinkProperties,
@@ -146,6 +147,7 @@ export function normalizeRuntimeObject(input: {
   const { objectType, primaryPropertyId, properties, valueTypesById } = input
   assertKnownProperties(objectType, properties)
   validateObjectProperties(objectType, properties, valueTypesById)
+  assertValidFileRefs(properties, objectType.id)
 
   const primaryValue = properties[primaryPropertyId]
   if (primaryValue === undefined || primaryValue === null) {
@@ -185,6 +187,7 @@ export function normalizeRuntimeLink(input: {
   const { objectType, linkDefinition, linkId, targetTypeId, properties, valueTypesById } = input
   assertLinkTargetType(objectType.id, linkId, linkDefinition, targetTypeId, input.isValidLinkTarget)
   validateLinkProperties(objectType, linkDefinition, properties, undefined, valueTypesById)
+  assertValidFileRefs(properties, `${objectType.id}.${linkId}`)
   const normalized = normalizeLinkProperties(objectType, linkDefinition, properties, valueTypesById)
   if (normalized === undefined) return undefined
   return normalizeJsonProperties(normalized, `${objectType.id}.${linkId} properties`)

package/src/objects/object/upsert-batch.ts

@@ -52,6 +52,9 @@ export async function upsertObjectBatch(
         ],
       }
     },
-    value: ([outcome]) => toObjectRow(ctx.projectId, requireEffectiveObject(outcome)),
+    value: ([outcome]) =>
+      ctx.objectReader.redactWrittenRow(
+        toObjectRow(ctx.projectId, requireEffectiveObject(outcome))
+      ),
   })
 }

package/src/objects/object/upsert.ts

@@ -34,5 +34,7 @@ export async function upsertObject(
   const commit = await commitRuntimeOperations(ctx, [
     objectUpsertOperation({ id: runtimeOperationId(0), ref, properties: normalized.properties }),
   ])
-  return toObjectRow(ctx.projectId, requireEffectiveObject(commit.outcomes[0]))
+  return ctx.objectReader.redactWrittenRow(
+    toObjectRow(ctx.projectId, requireEffectiveObject(commit.outcomes[0]))
+  )
 }