@sixb/core 0.1.11 → 0.1.13

package/src/runtime/host.ts

@@ -53,12 +53,21 @@ import {
 } from "../maintenance"
 import { createOntologyMaterializer, type OntologyMaterializerContract } from "../materializer"
 import type { ModelCatalogInput } from "../models"
+import { bindEmbeddingModels } from "../models/execution/embedding"
+import { ModelExecutionSession } from "../models/execution/session"
+import { createVectorIndexingRuntime } from "../objects/vectors/indexing"
+import { registerVectorIndexingRuntime } from "../objects/vectors/indexing-runtime"
 import type { PipelineDefinition } from "../pipelines/types"
 import { registerProjectionRegistry } from "../projections/internal"
 import type { ProjectionDefinition } from "../projections/types"
 import type { Queues } from "../queues"
 import type { RuleDefinition } from "../rules"
 import type { SandboxFactory } from "../sandboxes"
+import {
+  createSandboxDefinition,
+  type InferSandboxParams,
+  type SandboxDefinition,
+} from "../sandboxes/configuration"
 import { type SchedulerController, SchedulerRuntime } from "../scheduler"
 import type { ScheduleDefinition } from "../schedules"
 import type {
@@ -67,6 +76,7 @@ import type {
   RoleDefinition,
   SecurityDefinitionCatalog,
 } from "../security"
+import type { ParamsConfig } from "../shared/params/types"
 import type { ShareDefinition } from "../shares"
 import type { Storage } from "../storage"
 import type { SyncDefinition } from "../syncs"
@@ -83,15 +93,15 @@ import { createBoundSixb, type Sixb, type SixbDependencies } from "./sixb"
 import { StorageReadiness } from "./storage-readiness"
 import type { OntologySource, SixbHostContext, SixbRuntimeContext } from "./types"
 
-export interface SixbHostOptions<TOntologySources extends readonly OntologySource[]> {
+export interface SixbHostOptions<in out TParams extends ParamsConfig = ParamsConfig> {
   id?: string
-  ontology: TOntologySources
+  ontology: readonly OntologySource[]
   broker: Broker
   storage: Storage
   lakeStorage: LakeStorage
   blobStorage: BlobStorage
   queues: Queues
-  sandboxes?: SandboxFactory
+  sandboxes?: SandboxFactory<TParams>
   /** Optional process-level output provider. Omit for broker-only logging. */
   logger?: LoggerProvider
   /** Broker capture controls, independent from the output provider. */
@@ -123,9 +133,10 @@ export interface SixbHostOptions<TOntologySources extends readonly OntologySourc
   auth?: SixbAuthConfig
 }
 
-export class SixbHost<
-  TOntologySources extends readonly OntologySource[] = readonly OntologySource[],
-> {
+// Invariant by declaration, like `SixbHostOptions`: left to measurement, TypeScript probes `TParams`
+// through the whole bound SDK and overflows (TS2589) on code as ordinary as a function typed to
+// return `SixbHost` that returns `new SixbHost(options)`.
+export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
   readonly projectId: string
   private readonly webhookRegistry: WebhookRegistry
   private readonly hostContext: SixbHostContext
@@ -135,6 +146,7 @@ export class SixbHost<
   private readonly storageReadiness: StorageReadiness
   private readonly connectorService: ConnectorService
   private readonly materializer: OntologyMaterializerContract
+  readonly sandboxDefinition?: SandboxDefinition
   readonly definitions: SixbDefinitions
   readonly broker: Broker
   readonly events: DomainEventLog
@@ -143,12 +155,12 @@ export class SixbHost<
   readonly lakeStorage: LakeStorage
   readonly blobStorage: BlobStorage
   readonly queues: Queues
-  readonly sandboxes?: SandboxFactory
+  readonly sandboxes?: Pick<SandboxFactory, "create" | "resume">
   readonly projectRoot: string
   readonly scheduler: SchedulerController
   readonly auth: AuthRuntime
 
-  constructor(options: SixbHostOptions<TOntologySources>) {
+  constructor(options: SixbHostOptions<TParams>) {
     const errorReporter = attachSixbErrorReporter(this, options.onError)
     this.projectId = options.id ?? "default"
     this.broker = options.broker
@@ -174,6 +186,10 @@ export class SixbHost<
 
     const definitions = resolveDefinitions(options)
     this.definitions = definitions
+    this.sandboxDefinition =
+      options.sandboxes?.configuration === undefined
+        ? undefined
+        : createSandboxDefinition(options.sandboxes.configuration, definitions.ontology)
     registerProjectionRegistry(this, definitions.projections)
 
     this.auth = new AuthRuntime({
@@ -222,10 +238,12 @@ export class SixbHost<
       projectId: this.projectId,
       storage: this.storage,
       dispatcher: this.committedFacts,
+      blobStorage: this.blobStorage,
       options: options.ontologyMaintenance,
     })
 
     this.hostContext = {
+      embeddingModels: definitions.models?.embedding,
       projectId: this.projectId,
       broker: this.broker,
       ontology: definitions.ontology,
@@ -236,6 +254,10 @@ export class SixbHost<
     }
     registerProjectionRegistry(this.hostContext, definitions.projections)
     shareSixbErrorReporter(this, this.hostContext)
+    registerVectorIndexingRuntime(
+      this,
+      createVectorIndexingRuntime(this.hostContext, this.materializer)
+    )
     this.scheduler = new SchedulerRuntime({
       schedules: definitions.schedules.list(),
       events: this.eventService,
@@ -243,21 +265,29 @@ export class SixbHost<
   }
 
   /** Bind an existing opaque scope. This method never creates or escalates authority. */
-  withScope(scope: ExecutionScope): Sixb<TOntologySources> {
+  withScope(scope: ExecutionScope): Sixb<InferSandboxParams<TParams>> {
     const capturedScope = captureExecutionScope(scope)
     const authorization = resolveExecutionScopeAuthorization(this.projectId, capturedScope)
     if (authorization.type === "unrestricted" && authorization.ref.type === "kernel") {
       throw new Error("[Sixb] Kernel authority cannot be bound to the domain SDK.")
     }
 
+    const modelExecution = new ModelExecutionSession(
+      { ...this.hostContext, runtimeAuthorization: capturedScope.authorization },
+      capturedScope.execution
+    )
+    const embeddingModels = bindEmbeddingModels(this.hostContext.embeddingModels, modelExecution)
     const objectReader = createAuthorizedObjectReader({
       scope: capturedScope,
       ontology: this.hostContext.ontology,
       objectStorage: this.storage.objects,
+      embeddingModels,
     })
 
     const runtime: SixbRuntimeContext = {
       ...this.hostContext,
+      embeddingModels,
+      modelExecution,
       runtimeAuthorization: capturedScope.authorization,
       objectReader,
       ...(authorization.type === "principal" ? { authorization: authorization.context } : {}),
@@ -269,7 +299,7 @@ export class SixbHost<
         notifyCommittedFacts: () => this.committedFacts.notify(),
       })
     )
-    return createBoundSixb<TOntologySources>(
+    return createBoundSixb<InferSandboxParams<TParams>>(
       runtime,
       this.sixbDependencies(),
       capturedScope.execution
@@ -329,6 +359,10 @@ export class SixbHost<
   private sixbDependencies(): SixbDependencies {
     return {
       definitions: this.definitions,
+      sandbox: this.sandboxDefinition && {
+        definition: this.sandboxDefinition,
+        supportsPersistence: typeof this.sandboxes?.resume === "function",
+      },
       logging: this.logging,
       connectorService: this.connectorService,
       ...(this.connectorService.connectionProcess === undefined

package/src/runtime/index.ts

@@ -42,6 +42,9 @@ export type {
   ObjectQueryFacetResult,
   ObjectQueryListOptions,
   ObjectQueryRow,
+  ObjectReadByIdHandle,
+  ObjectReader,
+  ObjectReadSet,
   ObjectSet,
   ObjectSetListInput,
   ObjectSetQueryPropertyToken,
@@ -49,8 +52,6 @@ export type {
   ObjectWhereClause,
   OntologyDocumentInput,
   OntologySource,
-  RegisteredObjectType,
-  RegisteredValueTypes,
   TelemetryAppendInput,
   TelemetryChannel,
   TelemetryHistoryInput,

package/src/runtime/internal.ts

@@ -10,6 +10,9 @@ export type {
 } from "../connectors/connections/contracts"
 export type { ConnectorConnectionsRuntime } from "../connectors/connections/execution"
 export type { AuthorizedObjectReader } from "../execution/authorized-object-reader"
+export { VectorIndexingDeferred } from "../objects/vectors/indexing"
+export type { VectorIndexingRuntime } from "../objects/vectors/indexing-runtime"
+export { getVectorIndexingRuntime } from "../objects/vectors/indexing-runtime"
 export type { OntologyMutationRuntime } from "./ontology-mutations"
 export {
   createOntologyMutationRuntime,

package/src/runtime/resolve-definitions.ts

@@ -7,6 +7,7 @@ import type { ConnectorDefinition } from "../connectors"
 import type { DatasetDefinition } from "../datasets/types"
 import { assertDatasetDefinition } from "../datasets/validation"
 import { createModelCatalog, type ModelCatalogInput } from "../models"
+import { sameEmbeddingModel } from "../models/embedding-model"
 import { OntologyRegistry } from "../ontology"
 import type { PipelineDefinition } from "../pipelines/types"
 import { ProjectionRegistry } from "../projections"
@@ -70,6 +71,23 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
   })
 
   const models = options.models === undefined ? undefined : createModelCatalog(options.models)
+  for (const type of ontology.listObjectTypes()) {
+    for (const [name, profile] of Object.entries(type.search?.vectors ?? {})) {
+      const registered = models?.embedding.getByRef({
+        provider: profile.model.providerId,
+        modelId: profile.model.modelId,
+      })
+      if (!registered || !sameEmbeddingModel(registered.model, profile.model)) {
+        throw new Error(
+          "[Sixb] Vector profile " +
+            type.id +
+            "." +
+            name +
+            " requires its model in models.embedding with matching identity and dimensions."
+        )
+      }
+    }
+  }
   const tools = createAgentToolCatalog(options.tools)
   const connectorsById = indexUniqueDefinitions("connector", options.connectors ?? [])
 
@@ -147,7 +165,7 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
     workflowIds: new Set(workflowsById.keys()),
     syncIds: new Set(syncsById.keys()),
     pipelineIds: new Set(pipelinesById.keys()),
-    agentAvailable: models !== undefined,
+    agentAvailable: models?.language !== undefined,
     connectorIds: new Set(connectorsById.keys()),
     shareIds: new Set(sharesById.keys()),
     getSubTypes: (objectTypeId) => ontology.listSubTypes(objectTypeId),

package/src/runtime/sixb.ts

@@ -22,20 +22,19 @@ import { createObjectsRuntime, type ObjectsRuntime } from "../objects/execution"
 import { createPipelinesRuntime, type PipelinesRuntime } from "../pipelines/execution"
 import { createProjectionsRuntime, type ProjectionsRuntime } from "../projections/execution"
 import { createRulesRuntime, type RulesRuntime } from "../rules/execution"
+import type { SandboxDefinition } from "../sandboxes/configuration"
 import { createSchedulesRuntime, type SchedulesRuntime } from "../schedules/execution"
 import { createSharesRuntime, type SharesRuntime } from "../shares/execution"
 import { createSyncsRuntime, type SyncsRuntime } from "../syncs/execution"
 import { createWorkflowsRuntime, type WorkflowsRuntime } from "../workflows/execution"
 import type { SixbDefinitions } from "./definitions"
 import { shareOntologyMutationRuntime } from "./ontology-mutations"
-import type { OntologySource, SixbRuntimeContext } from "./types"
+import type { SixbRuntimeContext } from "./types"
 
 /** Domain SDK bound to one immutable execution and one registered runtime authority. */
-export interface Sixb<
-  TOntologySources extends readonly OntologySource[] = readonly OntologySource[],
-> {
+export interface Sixb<TParams extends Record<string, unknown> = Record<string, unknown>> {
   readonly execution: ExecutionContext
-  readonly objects: ObjectsRuntime<TOntologySources>
+  readonly objects: ObjectsRuntime
   readonly actions: ActionsRuntime
   readonly datasets: DatasetsRuntime
   readonly workflows: WorkflowsRuntime
@@ -43,7 +42,7 @@ export interface Sixb<
   readonly pipelines: PipelinesRuntime
   readonly projections: ProjectionsRuntime
   readonly rules: RulesRuntime
-  readonly agent: AgentRuntime
+  readonly agent: AgentRuntime<TParams>
   readonly models: ModelsRuntime
   readonly aiUsage: AiUsageRuntime
   readonly events: EventsRuntime
@@ -57,6 +56,10 @@ export interface Sixb<
 const boundSixbInstances = new WeakSet<object>()
 
 export interface SixbDependencies {
+  readonly sandbox?: {
+    readonly definition: SandboxDefinition
+    readonly supportsPersistence: boolean
+  }
   readonly definitions: SixbDefinitions
   readonly logging: LoggingService
   readonly connectorService: ConnectorService
@@ -65,11 +68,11 @@ export interface SixbDependencies {
   readonly lakeStorage: LakeStorage
 }
 
-export function createBoundSixb<TOntologySources extends readonly OntologySource[]>(
+export function createBoundSixb<TParams extends Record<string, unknown> = Record<string, unknown>>(
   runtime: SixbRuntimeContext,
   dependencies: SixbDependencies,
   execution: ExecutionContext
-): Sixb<TOntologySources> {
+): Sixb<TParams> {
   resolveExecutionScopeAuthorization(runtime.projectId, {
     execution,
     authorization: runtime.runtimeAuthorization,
@@ -78,9 +81,9 @@ export function createBoundSixb<TOntologySources extends readonly OntologySource
     reader: runtime.objectReader,
     scope: { execution, authorization: runtime.runtimeAuthorization },
   })
-  const sixb: Sixb<TOntologySources> = {
+  const sixb: Sixb<TParams> = {
     execution,
-    ...createExecutionFacades<TOntologySources>(runtime, execution, dependencies),
+    ...createExecutionFacades<TParams>(runtime, execution, dependencies),
   }
   shareOntologyMutationRuntime(runtime, sixb)
   if (dependencies.connectorConnections) {
@@ -94,19 +97,19 @@ export function createBoundSixb<TOntologySources extends readonly OntologySource
 }
 
 /** Internal nominal guard for execution boundaries that accept a narrow structural host. */
-export function isBoundSixb<
-  TOntologySources extends readonly OntologySource[] = readonly OntologySource[],
->(value: unknown): value is Sixb<TOntologySources> {
+export function isBoundSixb<TParams extends Record<string, unknown> = Record<string, unknown>>(
+  value: unknown
+): value is Sixb<TParams> {
   return typeof value === "object" && value !== null && boundSixbInstances.has(value)
 }
 
-function createExecutionFacades<TOntologySources extends readonly OntologySource[]>(
+function createExecutionFacades<TParams extends Record<string, unknown>>(
   runtime: SixbRuntimeContext,
   execution: ExecutionContext,
   dependencies: SixbDependencies
-): Omit<Sixb<TOntologySources>, "execution"> {
+): Omit<Sixb<TParams>, "execution"> {
   return {
-    objects: createObjectsRuntime<TOntologySources>(runtime, execution),
+    objects: createObjectsRuntime(runtime, execution),
     actions: createActionsRuntime(runtime, execution),
     datasets: createDatasetsRuntime(
       runtime,
@@ -120,7 +123,12 @@ function createExecutionFacades<TOntologySources extends readonly OntologySource
     pipelines: createPipelinesRuntime(runtime, execution, dependencies.definitions.pipelines),
     projections: createProjectionsRuntime(runtime, dependencies.definitions.projections),
     rules: createRulesRuntime(runtime, dependencies.definitions.rules),
-    agent: createAgentRuntime(runtime, execution, dependencies.definitions.models),
+    agent: createAgentRuntime<TParams>(
+      runtime,
+      execution,
+      dependencies.definitions.models,
+      dependencies.sandbox
+    ),
     models: createModelsRuntime(runtime, execution, dependencies.definitions.models),
     aiUsage: createAiUsageRuntime(runtime, dependencies.definitions.security),
     events: createEventsRuntime(runtime),