@sixb/core 0.1.11 → 0.1.12

package/src/datasets/write.ts

@@ -1,6 +1,5 @@
 import type { BlobStorage, FileRef } from "../blob-storage"
 import { isFileRef } from "../blob-storage"
-import { isPlainRecord } from "../json"
 import type { DatasetMergeCommitResult } from "../lake-storage/merge"
 import { getDatasetMergeChangeValidationError } from "../lake-storage/merge-validation"
 import type {
@@ -11,7 +10,7 @@ import type {
 } from "../lake-storage/types"
 import type { MergeChange } from "./changes"
 import type { DatasetDefinition } from "./types"
-import { getDatasetRowValidationError } from "./validation"
+import { getDatasetRowValidationFailure } from "./validation"
 
 export interface DatasetWriteValue {
   readonly value: unknown
@@ -161,19 +160,17 @@ async function validateRow(
   input: WriteDatasetInput,
   itemIndex: number
 ): Promise<DatasetRow> {
-  if (!isPlainRecord(value)) {
-    throw new Error(
-      `${sourceLabel(input)} returned an invalid row at item ${itemIndex}. Dataset rows must be plain objects.`
-    )
-  }
-  const validationError = getDatasetRowValidationError(value, input.dataset)
+  const validationError = getDatasetRowValidationFailure(value, input.dataset)
   if (validationError) {
     throw new Error(
-      `${sourceLabel(input)} returned an invalid row at item ${itemIndex}. ${validationError}`
+      `${sourceLabel(input)} returned an invalid row at item ${itemIndex}. ${validationError.message}`,
+      { cause: validationError }
     )
   }
-  await verifyRowFileRefs(value, input, itemIndex)
-  return value
+  // The validator above establishes the row shape.
+  const row = value as DatasetRow
+  await verifyRowFileRefs(row, input, itemIndex)
+  return row
 }
 
 async function validateMergeChange(

package/src/error-reporting/capability.ts

@@ -4,10 +4,12 @@ import {
   type ReportEventDeliveryFailureInput,
   type ReportRuleEvaluationFailureInput,
   type ReportRunFailureInput,
+  type ReportVectorIndexingFailureInput,
   reportActionPhaseFailure as reportActionPhaseFailureWith,
   reportEventDeliveryFailure as reportEventDeliveryFailureWith,
   reportRuleEvaluationFailure as reportRuleEvaluationFailureWith,
   reportRunFailure as reportRunFailureWith,
+  reportVectorIndexingFailure as reportVectorIndexingFailureWith,
 } from "./reports"
 import type { SixbErrorHandler } from "./types"
 
@@ -48,6 +50,7 @@ export type {
   ReportEventDeliveryFailureInput,
   ReportRuleEvaluationFailureInput,
   ReportRunFailureInput,
+  ReportVectorIndexingFailureInput,
 }
 
 export function reportActionPhaseFailure(
@@ -85,3 +88,11 @@ export function reportRuleEvaluationFailure(
 export async function flushSixbErrors(host: unknown, timeoutMs?: number): Promise<void> {
   await resolveSixbErrorReporter(host).flush(timeoutMs)
 }
+
+export function reportVectorIndexingFailure(
+  host: object,
+  error: unknown,
+  input: ReportVectorIndexingFailureInput
+): void {
+  reportVectorIndexingFailureWith(resolveSixbErrorReporter(host), error, input)
+}

package/src/error-reporting/reports.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto"
 import { captureSixbFailure } from "../errors/internal"
 import type { SixbFailure } from "../errors/types"
 import type { ActionRunFailure } from "../storage/action-runs"
+import type { VectorIndexingFailureCode } from "../storage/ontology/vector-indexing"
 import type { ErrorReporter } from "./reporter"
 import type { SixbFailedRun } from "./types"
 
@@ -170,3 +171,25 @@ export function reportRuleEvaluationFailure(
     ...(input.subject === undefined ? {} : { subject: input.subject }),
   })
 }
+
+export interface ReportVectorIndexingFailureInput {
+  readonly projectId: string
+  readonly indexingId: string
+  readonly failure: SixbFailure<VectorIndexingFailureCode>
+  readonly objectTypeId: string
+  readonly primaryId: string
+  readonly profile: string
+}
+
+export function reportVectorIndexingFailure(
+  reporter: ErrorReporter,
+  error: unknown,
+  input: ReportVectorIndexingFailureInput
+): void {
+  reporter.report(error, {
+    ...input,
+    type: "vector.indexing.failed",
+    occurredAt: input.failure.at,
+    notificationId: `vector-indexing:${input.projectId}:${input.indexingId}`,
+  })
+}

package/src/error-reporting/types.ts

@@ -1,6 +1,7 @@
 import type { SixbFailure } from "../errors/types"
 import type { ActionRunFailure } from "../storage/action-runs"
 import type { AgentRunFailureCode } from "../storage/agents"
+import type { VectorIndexingFailureCode } from "../storage/ontology/vector-indexing"
 import type { PipelineRunFailureCode } from "../storage/pipeline-runs"
 import type { ProjectionRunFailureCode } from "../storage/projection-runs"
 import type { SyncRunFailureCode } from "../storage/sync-runs"
@@ -166,12 +167,22 @@ export interface SixbRuleEvaluationFailedContext
   readonly subject?: { readonly objectTypeId: string; readonly primaryId: string }
 }
 
+/** A terminal automatic-indexing failure, correlated with its persisted request and profile. */
+export interface SixbVectorIndexingFailedContext
+  extends SixbFailureContext<"vector.indexing.failed"> {
+  readonly failure: SixbFailure<VectorIndexingFailureCode>
+  readonly indexingId: string
+  readonly objectTypeId: string
+  readonly primaryId: string
+  readonly profile: string
+}
+
 /**
  * Context supplied to the global Sixb error handler, discriminated by `type`.
- *
  * Failure notifications never change the outcome of the operation they observe.
  */
 export type SixbErrorContext =
+  | SixbVectorIndexingFailedContext
   | SixbActionPhaseFailedContext
   | SixbRunFailedContext
   | SixbEventDeliveryFailedContext

package/src/errors/catalog.ts

@@ -130,6 +130,18 @@ export const SIXB_ERROR_DEFINITIONS = {
     publicMessage: "Execution was cancelled.",
     retryable: false,
   },
+  "vector.model_unavailable": {
+    publicMessage: "The embedding model configured for this vector profile is unavailable.",
+    retryable: false,
+  },
+  "vector.response_invalid": {
+    publicMessage: "The embedding response is invalid for this vector profile.",
+    retryable: false,
+  },
+  "vector.outcome_unknown": {
+    publicMessage: "The embedding call was interrupted; its outcome and charges may be unknown.",
+    retryable: false,
+  },
   "sync.execution_failed": {
     publicMessage: "Sync execution failed.",
     retryable: false,

package/src/errors/failure-message.ts

@@ -0,0 +1,15 @@
+const messages = new WeakMap<object, string>()
+
+/**
+ * Mark a framework-authored explanation for durable diagnostics. Use schema metadata and fixed
+ * text only, never exception messages, input values, provider payloads, or arbitrary object keys.
+ * Identity-based storage prevents an external error from opting in with a lookalike property.
+ */
+export function withFailureMessage<T extends Error>(error: T, message: string): T {
+  messages.set(error, message)
+  return error
+}
+
+export function failureMessage(error: object): string | undefined {
+  return messages.get(error)
+}

package/src/errors/internal.ts

@@ -1,5 +1,7 @@
 import { cloneJsonValue, isJsonValue, isPlainRecord, type ReadonlyJsonValue } from "../json"
+import { ActionRunFailedError } from "../objects/action/errors"
 import { SIXB_ERROR_CODES, SIXB_ERROR_DEFINITIONS } from "./catalog"
+import { failureMessage } from "./failure-message"
 import { createFailureRedactor } from "./redaction"
 import type { SixbErrorCode, SixbFailure } from "./types"
 
@@ -135,10 +137,15 @@ export function toSixbFailure(
   const code = error.code
   const redactor = createFailureRedactor()
   const details = error.details === undefined ? undefined : redactor.context(error.details)
-  const { detail, truncated } = findFailureDetail(error, code)
+  const { detail, truncated, redacted } = findFailureDetail(error, code)
   const summary = SIXB_ERROR_DEFINITIONS[code].publicMessage
+  const explanation = detail?.message ?? summary
   const message = truncateUtf8(
-    redactor.text(detail && detail.message !== summary ? `${summary} ${detail.message}` : summary),
+    redactor.text(
+      explanation === summary || explanation.startsWith(`${summary} `)
+        ? explanation
+        : `${summary} ${explanation}`
+    ),
     SIXB_FAILURE_MAX_MESSAGE_BYTES
   )
   const failure: SixbFailure = {
@@ -148,7 +155,7 @@ export function toSixbFailure(
     at: failureTimestamp(options.at),
     ...(details === undefined ? {} : { details: cloneJsonValue(details, "Sixb failure details") }),
     ...(detail?.httpStatus === undefined ? {} : { httpStatus: detail.httpStatus }),
-    ...(redactor.redacted ? { redacted: true } : {}),
+    ...(redactor.redacted || redacted ? { redacted: true } : {}),
     ...(message.truncated || truncated || redactor.truncated ? { truncated: true } : {}),
   }
 
@@ -177,47 +184,72 @@ function isHttpStatus(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599
 }
 
-/** Select one explanation along the causal chain; unrelated aggregate errors stay separate. */
+/** Follow the causal chain without exposing arbitrary messages or discarding deeper statuses. */
 function findFailureDetail(
   error: SixbCodedError,
   boundaryCode: SixbErrorCode
-): { detail?: { message: string; httpStatus?: number }; truncated: boolean } {
+): {
+  detail?: { message: string; httpStatus?: number }
+  truncated: boolean
+  redacted: boolean
+} {
   const seen = new Set<object>()
+  const messages = new Set<string>()
+  let catalogMessage: string | undefined
+  let httpStatus: number | undefined
+  let truncated = false
+  let redacted = false
   let current: unknown = error
   while (typeof current === "object" && current !== null && !seen.has(current)) {
-    if (seen.size === 8) return { truncated: true }
-    seen.add(current)
-    if (
-      isSixbError(current) &&
-      current.code !== boundaryCode &&
-      current.code !== "internal.unexpected"
-    ) {
-      return {
-        detail: { message: SIXB_ERROR_DEFINITIONS[current.code].publicMessage },
-        truncated: false,
-      }
+    if (seen.size === 8) {
+      truncated = true
+      break
     }
+    seen.add(current)
+    const explanation = failureMessage(current)
+    if (explanation) messages.add(explanation)
     try {
-      // Read only data properties: arbitrary messages and getters remain private.
+      if (current instanceof ActionRunFailedError) {
+        // This is an already durable child failure, not arbitrary provider prose. Revalidate it
+        // before propagation; do not copy its context over the parent's identity or retry policy.
+        const child = parseSixbFailure(Object.getOwnPropertyDescriptor(current, "error")?.value)
+        messages.add(child.message)
+        httpStatus ??= child.httpStatus
+        redacted ||= child.redacted === true
+        truncated ||= child.truncated === true
+      }
+      if (
+        isSixbError(current) &&
+        current.code !== boundaryCode &&
+        current.code !== "internal.unexpected"
+      ) {
+        catalogMessage = SIXB_ERROR_DEFINITIONS[current.code].publicMessage
+      }
+      // Read data properties only: provider accessors, messages and payloads remain private.
       const status =
         Object.getOwnPropertyDescriptor(current, "status")?.value ??
         Object.getOwnPropertyDescriptor(current, "statusCode")?.value
-      if (isHttpStatus(status)) {
-        return {
-          detail: { message: `Upstream request returned HTTP ${status}.`, httpStatus: status },
-          truncated: false,
-        }
-      }
+      if (httpStatus === undefined && isHttpStatus(status)) httpStatus = status
       const code = Object.getOwnPropertyDescriptor(current, "code")?.value
       if (typeof code === "string" && Object.hasOwn(NETWORK_MESSAGES, code)) {
-        return { detail: { message: NETWORK_MESSAGES[code] }, truncated: false }
+        messages.add(NETWORK_MESSAGES[code])
       }
       current = Object.getOwnPropertyDescriptor(current, "cause")?.value
     } catch {
       break
     }
   }
-  return { truncated: false }
+  if (messages.size === 0 && catalogMessage) messages.add(catalogMessage)
+  if (httpStatus !== undefined) {
+    const statusMessage = `Upstream request returned HTTP ${httpStatus}.`
+    if (![...messages].some((message) => message.includes(statusMessage)))
+      messages.add(statusMessage)
+  }
+  return {
+    ...(messages.size === 0 ? {} : { detail: { message: [...messages].join(" "), httpStatus } }),
+    truncated,
+    redacted,
+  }
 }
 
 /** Serializes a validated failure for durable storage. */

package/src/execution/authorization.ts

@@ -14,6 +14,7 @@ import type {
   CompiledSelectedObjectReadScope,
   SelectedObjectReadScope,
 } from "../storage/objects/types"
+import { kernelOperationFromId, kernelOperationId } from "./kernel-operation"
 import {
   type AuthorizablePrincipal,
   type AuthorizationRef,
@@ -443,7 +444,8 @@ function assertResolvedAuthorizationMatchesExecution(
         resolved.ref.type !== "kernel" ||
         execution.requestedBy !== undefined ||
         resolved.ref.operation.type !== execution.executor.operation.type ||
-        resolved.ref.operation.recoveryId !== execution.executor.operation.recoveryId
+        kernelOperationId(resolved.ref.operation) !==
+          kernelOperationId(execution.executor.operation)
       ) {
         throw invalidExecutionAuthority(
           execution.id,
@@ -546,6 +548,9 @@ function snapshotExecutionExecutor(
 
 function snapshotExecutionSource(source: ExecutionContext["source"]): ExecutionContext["source"] {
   switch (source.type) {
+    case "ontologyCommit":
+      assertNonEmpty(source.commitId, "Execution source commit id")
+      return Object.freeze({ type: source.type, commitId: source.commitId })
     case "http":
       assertNonEmpty(source.requestId, "Execution source request id")
       return Object.freeze({ type: "http", requestId: source.requestId })
@@ -704,11 +709,13 @@ function snapshotTrustedPrimitive(primitive: TrustedPrimitiveRef): TrustedPrimit
 }
 
 function snapshotKernelOperation(operation: KernelOperation): KernelOperation {
-  if (operation.type !== "ontology.recover") {
-    throw new Error(`[Sixb] Unknown kernel operation '${operation.type}'.`)
+  if (operation.type !== "ontology.recover" && operation.type !== "ontology.indexVectors") {
+    throw new Error(
+      `[Sixb] Unknown kernel operation '${String((operation as { type?: unknown }).type)}'.`
+    )
   }
-  assertNonEmpty(operation.recoveryId, "Kernel recovery id")
-  return Object.freeze({ type: operation.type, recoveryId: operation.recoveryId })
+  assertNonEmpty(kernelOperationId(operation), "Kernel operation id")
+  return Object.freeze(kernelOperationFromId(operation.type, kernelOperationId(operation)))
 }
 
 /** Validate, bound, and detach exact delegated Action targets before registering authority. */

package/src/execution/authorized-object-reader.ts

@@ -1,6 +1,7 @@
 import { assertAuthorized, isAllowed } from "../authorization"
 import { AuthorizationError } from "../authorization/errors"
 import type { AuthorizationContext } from "../authorization/types"
+import type { EmbeddingModelCatalog } from "../models/catalog"
 import {
   type AuthorizedOntologySelection,
   type AuthorizedOntologyView,
@@ -84,6 +85,7 @@ class AuthorizedObjectReaderImpl {
   readonly #authority: ResolvedExecutionAuthority
   readonly #runtime: RuntimeReadAuthorization
   readonly #ontology: OntologyRegistry
+  readonly #embeddingModels?: EmbeddingModelCatalog
   #ontologyView?: AuthorizedOntologyView
   readonly #storage: ObjectReadStorage
   readonly #delegatedObjectTypeIds?: ReadonlySet<string>
@@ -95,6 +97,7 @@ class AuthorizedObjectReaderImpl {
     input: {
       readonly scope: ExecutionScope
       readonly ontology: OntologyRegistry
+      readonly embeddingModels?: EmbeddingModelCatalog
       readonly storage: ObjectReadStorage
       readonly authority: ResolvedExecutionAuthority
     }
@@ -106,6 +109,7 @@ class AuthorizedObjectReaderImpl {
     this.#authorization = input.scope.authorization
     this.#authority = input.authority
     this.#ontology = input.ontology
+    this.#embeddingModels = input.embeddingModels
     this.#storage = input.storage
     this.#delegatedObjectTypeIds =
       input.authority.type === "delegated"
@@ -316,6 +320,7 @@ class AuthorizedObjectReaderImpl {
           query: executionQuery,
           ...(includeTotal === undefined ? {} : { includeTotal }),
           projectId: this.#runtime.projectId,
+          signal: input.signal,
         },
         this.#queryExecutorOptions()
       )
@@ -459,10 +464,15 @@ class AuthorizedObjectReaderImpl {
       // The selected storage instance is the private execution capability. Passing the delegated
       // runtime token into the generic executor would either reject this admitted query or tempt a
       // forgeable bypass flag; neither is needed at this nominal boundary.
-      return { ontology: this.#ontology, storage: this.#storage }
+      return {
+        ontology: this.#ontology,
+        storage: this.#storage,
+        embeddingModels: this.#embeddingModels,
+      }
     }
     return {
       ontology: this.#ontology,
+      embeddingModels: this.#embeddingModels,
       storage: this.#storage,
       runtimeAuthorization: this.#runtime.runtimeAuthorization,
       ...(this.#runtime.authorization === undefined
@@ -546,6 +556,7 @@ export type AuthorizedObjectReader = AuthorizedObjectReaderImpl
 export function createAuthorizedObjectReader(input: {
   readonly scope: ExecutionScope
   readonly ontology: OntologyRegistry
+  readonly embeddingModels?: EmbeddingModelCatalog
   readonly objectStorage: ObjectStorage
 }): AuthorizedObjectReader {
   const scope = captureExecutionScope(input.scope)
@@ -555,6 +566,7 @@ export function createAuthorizedObjectReader(input: {
   const reader = new AuthorizedObjectReaderImpl(readerConstructionKey, {
     scope,
     ontology: input.ontology,
+    embeddingModels: input.embeddingModels,
     storage,
     authority,
   })
@@ -681,7 +693,30 @@ function snapshotFacetRequests(facets: readonly ObjectFacetRequest[]): ObjectFac
 /** Capture one serializable query before either authorization or execution sees it. */
 function snapshotAuthoredQuery(query: ObjectQuery): ObjectQuery {
   try {
-    return structuredClone(query)
+    const snapshot = structuredClone(query)
+    const pending = [snapshot]
+    const seen = new Set<ObjectQuery>()
+    for (const node of pending) {
+      if (seen.has(node)) continue
+      seen.add(node)
+      if (
+        node.kind === "vector" &&
+        (typeof node.vector !== "string" ||
+          typeof node.profile !== "string" ||
+          "propertyId" in node)
+      ) {
+        throw new ObjectQueryValidationError([
+          {
+            path: "$",
+            code: "invalid_vector_search_input",
+            message: "Vector search requires a named profile and search text",
+          },
+        ])
+      }
+      if ("input" in node) pending.push(node.input)
+      if (node.kind === "set") pending.push(...node.inputs)
+    }
+    return snapshot
   } catch (error) {
     if (error instanceof ObjectQueryValidationError) throw error
     throw new ObjectQueryValidationError([

package/src/execution/kernel-operation.ts

@@ -0,0 +1,27 @@
+import type { KernelOperation } from "./types"
+
+export function kernelOperationId(operation: KernelOperation): string {
+  switch (operation.type) {
+    case "ontology.recover":
+      return operation.recoveryId
+    case "ontology.indexVectors":
+      return operation.indexingId
+    default:
+      return unknownOperation(operation)
+  }
+}
+
+export function kernelOperationFromId(type: KernelOperation["type"], id: string): KernelOperation {
+  switch (type) {
+    case "ontology.recover":
+      return { type, recoveryId: id }
+    case "ontology.indexVectors":
+      return { type, indexingId: id }
+    default:
+      return unknownOperation(type)
+  }
+}
+
+function unknownOperation(_operation: never): never {
+  throw new Error("[Sixb] Unknown kernel operation.")
+}

package/src/execution/scopes.ts

@@ -197,6 +197,8 @@ function sourceIdentifier(source: ExecutionSource): {
   readonly value: string
 } {
   switch (source.type) {
+    case "ontologyCommit":
+      return { label: "Execution source commit id", value: source.commitId }
     case "http":
       return { label: "Execution source request id", value: source.requestId }
     case "webhook":

package/src/execution/types.ts

@@ -26,10 +26,9 @@ export interface SharedAccessDelegationRef {
   readonly sessionId: string
 }
 
-export type KernelOperation = {
-  readonly type: "ontology.recover"
-  readonly recoveryId: string
-}
+export type KernelOperation =
+  | { readonly type: "ontology.recover"; readonly recoveryId: string }
+  | { readonly type: "ontology.indexVectors"; readonly indexingId: string }
 
 /** Workload currently executing. This is provenance and never grants authority by itself. */
 export type ExecutionExecutor =
@@ -49,6 +48,7 @@ export type ExecutionExecutor =
  * An `execution` source is the single logical parent of a nested execution.
  */
 export type ExecutionSource =
+  | { readonly type: "ontologyCommit"; readonly commitId: string }
   | { readonly type: "http"; readonly requestId: string }
   | { readonly type: "webhook"; readonly deliveryId: string }
   | { readonly type: "schedule"; readonly eventId: string }

package/src/index.ts

@@ -27,6 +27,7 @@ export type {
   ObjectTypeSearchMetadata,
   ObjectTypeWithPropertyTokens,
   ObjectTypeWithTokens,
+  ObjectVectorSearchProfile,
   Ontology,
   OntologyDefinitionCatalog,
   OntologyRegistryOptions,
@@ -600,6 +601,7 @@ export type {
   SandboxFileRecord,
   SandboxNetworkPolicy,
   SandboxNetworkTarget,
+  SandboxRequestCredential,
   SandboxSessionOptions,
   SandboxStatus,
 } from "./sandboxes"
@@ -897,6 +899,7 @@ export type {
   SixbRunFailedContext,
   SixbRunFailureByKind,
   SixbRunIdentityByKind,
+  SixbVectorIndexingFailedContext,
 } from "./error-reporting/types"
 export type { SixbErrorCode, SixbFailure } from "./errors/types"
 export type { EventsRuntime } from "./events/execution"
@@ -922,6 +925,10 @@ export type {
   ObjectQueryLinksResult,
   ObjectsRuntime,
 } from "./objects/execution"
+export type {
+  ObjectVectorHandle,
+  VectorProfileName,
+} from "./objects/vectors/types"
 export type { PipelineRunsRuntime, PipelinesRuntime } from "./pipelines/execution"
 export type {
   ProjectionRunsRuntime,
@@ -990,6 +997,7 @@ export type {
   WebhookRunFailureCode,
   WorkflowRunFailureCode,
 } from "./storage"
+export type { VectorIndexingFailureCode } from "./storage/ontology/vector-indexing"
 export type { SyncRunsRuntime, SyncsRuntime } from "./syncs/execution"
 export type {
   LatestWorkflowRunListResult,
@@ -1066,16 +1074,51 @@ export {
   MAX_AGENT_APP_STATE_TOTAL_BYTES,
   MAX_AGENT_CONTEXT_ENTRIES,
 } from "./agents"
-export type { AgentThreadRecord, ListAgentThreadsResult } from "./storage/agents"
+export type { SandboxSourceAuth, SandboxSourceCredentials } from "./sandboxes/auth"
+export type {
+  SandboxConfig,
+  SandboxDefinition,
+  SandboxEnvironment,
+  SandboxResolveContext,
+  SandboxSource,
+} from "./sandboxes/configuration"
+export type { ParamOptions } from "./shared/params/builders"
+export type { InferParams, ParamConfig, ParamsConfig } from "./shared/params/types"
+export type {
+  AgentThreadRecord,
+  AgentThreadSandboxParams,
+  AgentThreadSandboxState,
+  ListAgentThreadsResult,
+} from "./storage/agents"
 
 // ── Models ──────────────────────────────────────────────────
 
 export type {
+  EmbeddingBatchLimits,
+  EmbeddingModel,
+  EmbeddingModelCatalog,
+  EmbeddingModelDefinition,
+  EmbeddingModelEntry,
+  EmbeddingModelRef,
+  EmbeddingModelRequest,
+  EmbeddingModelResponseMetadata,
+  EmbeddingModelResult,
   LanguageModelCatalog,
   LanguageModelEntry,
   LanguageModelRef,
+  ModelCallCost,
   ModelCatalog,
   ModelCatalogInput,
+  ModelCostComponent,
+  ModelCostEstimate,
+  ModelCostEstimator,
+  ModelCostMeter,
+  ModelMoney,
+  ModelProviderIds,
+  ModelRef,
+  ModelReportedCost,
+  ModelRoute,
+  ModelUsage,
 } from "./models"
 export type {
   InferLanguageModelOutput,
@@ -1098,6 +1141,22 @@ export type {
   ActionParamDescriptor,
   ActionPhaseDescriptor,
 } from "./actions/descriptor"
+export type { DecisionAnswerSchema, DecisionOutputShape } from "./models/decision/output"
+export { decisionOutput } from "./models/decision/output"
+export { question } from "./models/decision/questions"
+export type {
+  ChoiceQuestion,
+  DecisionAnswer,
+  DecisionAnswers,
+  DecisionContent,
+  DecisionEvaluateInput,
+  DecisionEvaluateResult,
+  DecisionModelsRuntime,
+  DecisionQuestion,
+  DecisionQuestions,
+  ProbabilityQuestion,
+  ScoreQuestion,
+} from "./models/decision/types"
 export type {
   ForeignKeyDescriptor,
   LinkProjectionDefinition,

package/src/lake-storage/in-memory.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto"
 import { isDeepStrictEqual } from "node:util"
 import type { DatasetDefinition, DatasetSchema, MergeChange } from "../datasets"
-import { getDatasetRowValidationError } from "../datasets/validation"
+import { getDatasetRowValidationFailure } from "../datasets/validation"
 import { resolveDatasetChangeColumns } from "./changes"
 import { mergeStrictDatasetDefinition } from "./definition-updates"
 import { LakeConcurrencyError, LakeStorageError } from "./errors"
@@ -113,9 +113,11 @@ class InMemoryLakeWriteSession implements LakeWriteSession {
     const stagedRows: DatasetRow[] = []
     const stagedPrimaryKeys = new Set<string>()
     for await (const row of rows) {
-      const validationError = getDatasetRowValidationError(row, this.input.dataset)
+      const validationError = getDatasetRowValidationFailure(row, this.input.dataset)
       if (validationError) {
-        throw new LakeStorageError(`[LakeStorage] ${validationError}`)
+        throw new LakeStorageError(`[LakeStorage] ${validationError.message}`, {
+          cause: validationError,
+        })
       }
 
       if (getDatasetPrimaryKeyColumns(this.input.dataset) !== null) {

package/src/materialization/errors.ts

@@ -24,8 +24,8 @@ function prefixMessage(message: string): string {
 export class MaterializationValidationError extends OntologyValidationError {
   readonly name: string = "MaterializationValidationError"
 
-  constructor(message: string) {
-    super(prefixMessage(message))
+  constructor(message: string, options?: ErrorOptions) {
+    super(prefixMessage(message), options)
   }
 }