@sixb/core 0.1.11 → 0.1.13

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

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto"
 import type { ReadonlyJsonObject, RecordAiModelCallInput } from "../../storage"
 import type { ModelCallEndEvent, ModelUsage } from "../events"
-import type { LanguageModel, LanguageModelRequest } from "../language-model"
+import type { LanguageModel } from "../language-model"
 import { ModelUsageRecordingError } from "./errors"
 import {
   normalizeModelCallAccounting,
@@ -9,8 +9,8 @@ import {
   requireAccountingCapabilities,
 } from "./model-call-accounting"
 import {
+  type AiModelCallAdmissionInput,
   aiModelCallOutputTokenAllowance,
-  type BeforeAiModelCall,
   estimateAiModelCallInputTokens,
   estimatedAiModelCallTotalTokens,
 } from "./model-call-admission"
@@ -88,46 +88,58 @@ export class AiModelCallRecorder {
           responseFormat: request.responseFormat,
         })
         const outputTokenAllowance = aiModelCallOutputTokenAllowance(request.maxOutputTokens)
-        let decision: Awaited<ReturnType<BeforeAiModelCall>>
-        try {
-          decision = await this.input.limits.beforeModelCall({
-            ...this.identity(request),
-            requesterGroupIds: this.input.requesterGroupIds,
-            providerId: model.providerId,
-            modelId: model.modelId,
-            costEstimator: model.costEstimator,
-            inputTokens,
-            outputTokenAllowance,
-            estimatedTotalTokens: estimatedAiModelCallTotalTokens(
-              inputTokens,
-              outputTokenAllowance
-            ),
-          })
-        } catch (error) {
-          // Execution boundaries must retain the original coded admission failure.
-          this.admissionError = error
-          throw error
-        }
-        if (decision.reservation === "active") this.reservations.add(request.callId)
+        await this.admitCall({
+          callId: request.callId,
+          providerId: model.providerId,
+          modelId: model.modelId,
+          costEstimator: model.costEstimator,
+          inputTokens,
+          outputTokenAllowance,
+          estimatedTotalTokens: estimatedAiModelCallTotalTokens(inputTokens, outputTokenAllowance),
+        })
         try {
           return await model.stream(request)
         } catch (error) {
-          if (this.reservations.has(request.callId)) {
-            await this.input.limits.markModelCallUnknown(this.identity(request))
-          }
+          await this.markCallUnknown(request.callId)
           throw error
         }
       },
     }
   }
 
-  private identity(request: Pick<LanguageModelRequest, "callId">) {
-    return {
+  /** Admit one provider attempt, independently of its language or embedding protocol. */
+  async admitCall(
+    call: Omit<
+      AiModelCallAdmissionInput,
+      "projectId" | "executionId" | "attempt" | "requesterGroupIds"
+    >
+  ): Promise<void> {
+    this.assertHealthy()
+    try {
+      const decision = await this.input.limits.beforeModelCall({
+        ...call,
+        projectId: this.input.projectId,
+        executionId: this.input.executionId,
+        attempt: this.input.attempt,
+        requesterGroupIds: this.input.requesterGroupIds,
+      })
+      if (decision.reservation === "active") this.reservations.add(call.callId)
+    } catch (error) {
+      // Execution boundaries must retain the original coded admission failure.
+      this.admissionError = error
+      throw error
+    }
+  }
+
+  /** Keep an unresolved reservation when an attempted call's billable outcome is unknown. */
+  private async markCallUnknown(callId: string): Promise<void> {
+    if (!this.reservations.has(callId)) return
+    await this.input.limits.markModelCallUnknown({
       projectId: this.input.projectId,
       executionId: this.input.executionId,
       attempt: this.input.attempt,
-      callId: request.callId,
-    }
+      callId,
+    })
   }
 
   readonly onModelCallEnd = async (event: ModelCallEndEvent): Promise<void> => {

package/src/models/execution/session.ts

@@ -0,0 +1,81 @@
+import type { ExecutionContext, RuntimeAuthorization } from "../../execution"
+import { ensureExecutionRecord, executionRecordInputFromRuntime } from "../../execution/durable"
+import type { SixbHostContext } from "../../runtime/types"
+import type { ModelExecutionAttempt } from "./binding"
+import { requireAccountingCapabilities } from "./model-call-accounting"
+import { createAiModelCallLimitController } from "./model-call-limits"
+import { AiModelCallRecorder } from "./model-call-recorder"
+import { enqueueAiModelCallRecovery } from "./recovery-queue"
+
+/** One accounting boundary shared by all model protocols in a bound execution. */
+export class ModelExecutionSession {
+  private binding?: ModelExecutionAttempt
+  private recorder?: Promise<AiModelCallRecorder>
+
+  constructor(
+    private readonly runtime: SixbHostContext & { runtimeAuthorization: RuntimeAuthorization },
+    private readonly execution: ExecutionContext
+  ) {}
+
+  bind(input: ModelExecutionAttempt): void {
+    if (this.binding) throw new Error("[SixbModels] Execution attempt is already bound.")
+    this.binding = { ...input }
+  }
+
+  signal(signal?: AbortSignal): AbortSignal {
+    const binding = this.requireBinding()
+    return signal ? AbortSignal.any([binding.signal, signal]) : binding.signal
+  }
+
+  async admitEmbeddingCall(admit: () => Promise<void>): Promise<void> {
+    const admission = this.requireBinding().embeddingAdmission
+    if (admission) await admission(admit)
+    else await admit()
+  }
+
+  accounting(): Promise<AiModelCallRecorder> {
+    this.requireBinding()
+    this.recorder ??= this.createRecorder()
+    return this.recorder
+  }
+
+  private requireBinding(): ModelExecutionAttempt {
+    if (!this.binding) {
+      throw new Error(
+        "[SixbModels] Model calls require a bound request or worker execution attempt."
+      )
+    }
+    return this.binding
+  }
+
+  private async createRecorder(): Promise<AiModelCallRecorder> {
+    const runtime = this.runtime
+    const execution = this.execution
+    const { attempt } = this.requireBinding()
+    const storage = {
+      ...requireAccountingCapabilities(runtime.storage),
+      transaction: runtime.storage.transaction.bind(runtime.storage),
+    }
+    const { requesterGroupIds } = await ensureExecutionRecord(
+      runtime.storage.executions,
+      executionRecordInputFromRuntime({
+        execution,
+        runtimeAuthorization: runtime.runtimeAuthorization,
+      })
+    )
+    return new AiModelCallRecorder({
+      storage,
+      projectId: runtime.projectId,
+      executionId: execution.id,
+      attempt,
+      requesterGroupIds,
+      limits: createAiModelCallLimitController({
+        storage,
+        projectId: runtime.projectId,
+        requestedBy: execution.requestedBy,
+        requesterGroupIds,
+      }),
+      recoverAiModelCall: (input) => enqueueAiModelCallRecovery(runtime.queues.agents, input),
+    })
+  }
+}

package/src/models/execution.ts

@@ -1,17 +1,14 @@
 import { runModelLoop } from "../agents/model-loop"
 import { assertProviderAccess } from "../authorization"
 import type { ExecutionContext } from "../execution"
-import { ensureExecutionRecord, executionRecordInputFromRuntime } from "../execution/durable"
 import type { SixbRuntimeContext } from "../runtime/types"
 import type { ModelCatalog } from "./catalog"
+import { createDecisionRuntime } from "./decision/runtime"
 import { ModelProviderError, ModelStreamError, UnsupportedModelFeatureError } from "./errors"
 import type { ModelCallEndEvent } from "./events"
-import { type ModelExecutionAttempt, registerModelExecutionBinding } from "./execution/binding"
-import { requireAccountingCapabilities } from "./execution/model-call-accounting"
+import { registerModelExecutionBinding } from "./execution/binding"
 import { aiModelCallOutputTokenAllowance } from "./execution/model-call-admission"
-import { createAiModelCallLimitController } from "./execution/model-call-limits"
-import { AiModelCallRecorder } from "./execution/model-call-recorder"
-import { enqueueAiModelCallRecovery } from "./execution/recovery-queue"
+import { ModelExecutionSession } from "./execution/session"
 import type {
   InferLanguageModelOutput,
   LanguageModelGenerateInput,
@@ -29,41 +26,7 @@ export function createModelsRuntime(
   execution: ExecutionContext,
   catalog: ModelCatalog | undefined
 ): ModelsRuntime {
-  let binding: ModelExecutionAttempt | undefined
-  let recorder: Promise<AiModelCallRecorder> | undefined
-
-  async function createRecorder(): Promise<AiModelCallRecorder> {
-    const storage = {
-      ...requireAccountingCapabilities(runtime.storage),
-      transaction: runtime.storage.transaction.bind(runtime.storage),
-    }
-    if (!binding) {
-      throw new Error(
-        "[SixbModels] Generation requires a bound request or worker execution attempt."
-      )
-    }
-    const { requesterGroupIds } = await ensureExecutionRecord(
-      runtime.storage.executions,
-      executionRecordInputFromRuntime({
-        execution,
-        runtimeAuthorization: runtime.runtimeAuthorization,
-      })
-    )
-    return new AiModelCallRecorder({
-      storage,
-      projectId: runtime.projectId,
-      executionId: execution.id,
-      attempt: binding.attempt,
-      requesterGroupIds,
-      limits: createAiModelCallLimitController({
-        storage,
-        projectId: runtime.projectId,
-        requestedBy: execution.requestedBy,
-        requesterGroupIds,
-      }),
-      recoverAiModelCall: (input) => enqueueAiModelCallRecovery(runtime.queues.agents, input),
-    })
-  }
+  const session = runtime.modelExecution ?? new ModelExecutionSession(runtime, execution)
 
   function generate<const TShape extends LanguageModelOutputShape | undefined = undefined>(
     input: LanguageModelGenerateInput<TShape>
@@ -77,21 +40,16 @@ export function createModelsRuntime(
   ): Promise<LanguageModelGenerateResult<unknown>> {
     assertProviderAccess(runtime, execution, "models.language.generate")
     const messages = generationMessages(input)
-    if (!binding) {
-      throw new Error(
-        "[SixbModels] Generation requires a bound request or worker execution attempt."
-      )
-    }
-    const signal = input.signal ? AbortSignal.any([binding.signal, input.signal]) : binding.signal
+    const signal = session.signal(input.signal)
     signal.throwIfAborted()
     const selected = input.model
       ? catalog
-        ? catalog.language.getByRef({
+        ? catalog.language?.getByRef({
             provider: input.model.providerId,
             modelId: input.model.modelId,
           })?.model
         : input.model
-      : catalog?.language.default.model
+      : catalog?.language?.default.model
     if (!selected) {
       throw new Error(
         input.model
@@ -121,8 +79,7 @@ export function createModelsRuntime(
     if (typeof input.reasoning === "object" && input.reasoning.budgetTokens >= maxOutputTokens) {
       throw new TypeError("[SixbModels] Output allowance must exceed the reasoning token budget.")
     }
-    recorder ??= createRecorder()
-    const accounting = await recorder
+    const accounting = await session.accounting()
     accounting.assertHealthy()
     signal.throwIfAborted()
     let event: ModelCallEndEvent | undefined
@@ -165,9 +122,10 @@ export function createModelsRuntime(
 
   const models: ModelsRuntime = {
     language: { generate },
+    decision: createDecisionRuntime(runtime, execution, catalog, session),
   }
   registerModelExecutionBinding(models, (input) => {
-    binding = { attempt: input.attempt, signal: input.signal }
+    session.bind(input)
   })
   return models
 }

package/src/models/generation-types.ts

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

package/src/models/index.ts

@@ -1,21 +1,58 @@
 export type { JsonObject, JsonPrimitive, JsonValue } from "../json"
 export { assertJsonObject, assertJsonValue, isJsonObject, isJsonValue } from "../json"
 export type {
+  EmbeddingModelCatalog,
+  EmbeddingModelEntry,
   LanguageModelCatalog,
   LanguageModelDefinitionCatalog,
   LanguageModelEntry,
   LanguageModelRef,
   ModelCatalog,
+  ModelCatalogFor,
   ModelCatalogInput,
   ModelDefinitionCatalog,
+  ModelRef,
 } from "./catalog"
 export { createModelCatalog } from "./catalog"
+export type { DecisionModelCatalog, DecisionModelEntry } from "./decision/catalog"
+export { DecisionModelResponseError } from "./decision/errors"
+export type { DecisionAnswerSchema, DecisionOutputShape } from "./decision/output"
+export { decisionOutput } from "./decision/output"
+export { question } from "./decision/questions"
+export type {
+  ChoiceQuestion,
+  DecisionAnswer,
+  DecisionAnswers,
+  DecisionContent,
+  DecisionEvaluateInput,
+  DecisionEvaluateResult,
+  DecisionModel,
+  DecisionModelDefinition,
+  DecisionModelRequest,
+  DecisionModelResponseMetadata,
+  DecisionModelResult,
+  DecisionModelsRuntime,
+  DecisionQuestion,
+  DecisionQuestions,
+  ProbabilityQuestion,
+  ScoreQuestion,
+} from "./decision/types"
 export type {
   LanguageModelDefinition,
   ModelDefinition,
   ModelKind,
 } from "./definitions"
 export { defineLanguageModel } from "./definitions"
+export type {
+  EmbeddingBatchLimits,
+  EmbeddingModel,
+  EmbeddingModelDefinition,
+  EmbeddingModelRef,
+  EmbeddingModelRequest,
+  EmbeddingModelResponseMetadata,
+  EmbeddingModelResult,
+} from "./embedding-model"
+export { EmbeddingModelResponseError } from "./embedding-model"
 export {
   ModelCatalogUnavailableError,
   ModelProviderError,

package/src/models/pricing.ts

@@ -1,10 +1,9 @@
 import type { ModelRoute, ModelUsage } from "./events"
-import type { LanguageModel } from "./language-model"
 import type { LanguageModelRateCard, ModelTokenPrice } from "./rate-card"
 
 /** Optional local financial enrichment cannot discard a completed, billable call. */
 export function estimateModelCall(
-  model: LanguageModel,
+  model: { readonly costEstimator?: ModelCostEstimator },
   input: Parameters<ModelCostEstimator["estimate"]>[0]
 ): ModelCostEstimate {
   try {

package/src/objects/authorized-ontology-view.ts

@@ -15,6 +15,7 @@ import type {
   Schema,
   ValueType,
 } from "../ontology/types"
+import { snapshotVectorProfiles } from "../ontology/vector-profiles"
 import type { CompiledSelectedObjectReadScope } from "../storage/objects/types"
 
 /** Public ontology operations that may cross an execution-bound authorization boundary. */
@@ -393,7 +394,6 @@ function snapshotPropertyQuery(
     text: query.text,
     exact: query.exact,
     facet: query.facet,
-    vector: query.vector,
     weight: query.weight,
   }
 }
@@ -412,17 +412,21 @@ function projectSearch(
   const defaultText =
     options.preserveEmpty || selectedDefaultText?.length ? selectedDefaultText : undefined
   const exact = options.preserveEmpty || selectedExact?.length ? selectedExact : undefined
-  const vector =
-    search.vector &&
-    visiblePropertyIds.has(search.vector.property) &&
-    search.vector.source.every((propertyId) => visiblePropertyIds.has(propertyId))
-      ? { property: search.vector.property, source: [...search.vector.source] }
-      : undefined
+  const vectors =
+    search.vectors === undefined
+      ? undefined
+      : snapshotVectorProfiles(
+          Object.fromEntries(
+            Object.entries(search.vectors).filter(([, profile]) =>
+              profile.source.every((id) => visiblePropertyIds.has(id))
+            )
+          )
+        )
   const projected: ObjectTypeSearchMetadata = {
+    ...(vectors === undefined || Object.keys(vectors).length === 0 ? {} : { vectors }),
     ...(title === undefined ? {} : { title }),
     ...(defaultText === undefined ? {} : { defaultText }),
     ...(exact === undefined ? {} : { exact }),
-    ...(vector === undefined ? {} : { vector }),
   }
   return Object.keys(projected).length > 0 || options.preserveEmpty ? projected : undefined
 }

package/src/objects/execution.ts

@@ -4,17 +4,15 @@ import {
   assertAuthorizedObjectReaderBinding,
   getAuthorizedOntologyView,
 } from "../execution/authorized-object-reader"
-import type { ValueType } from "../ontology"
 import type { ObjectTypeWithPropertyTokens } from "../ontology/tokens"
 import { assertObjectTypeRegistered } from "../ontology/validation/properties"
 import { shareOntologyMutationRuntime } from "../runtime/ontology-mutations"
 import type {
   ListResult,
   ObjectByIdHandle,
+  ObjectReadByIdHandle,
+  ObjectReadSet,
   ObjectSet,
-  OntologySource,
-  RegisteredObjectType,
-  RegisteredValueTypes,
   SixbRuntimeContext,
 } from "../runtime/types"
 import type {
@@ -83,45 +81,28 @@ export interface ExecutionObjectOperations {
   ): Promise<void>
 }
 
-export interface ExecutionObjectByIdHandle<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
-> {
-  get: ObjectByIdHandle<TObjectType, TValueTypes>["get"]
-  listLinks: ObjectByIdHandle<TObjectType, TValueTypes>["listLinks"]
-  requestAction: ObjectByIdHandle<TObjectType, TValueTypes>["requestAction"]
-  requestActionAndWait: ObjectByIdHandle<TObjectType, TValueTypes>["requestActionAndWait"]
-  link: ObjectByIdHandle<TObjectType, TValueTypes>["link"]
-  unlink: ObjectByIdHandle<TObjectType, TValueTypes>["unlink"]
-  delete: ObjectByIdHandle<TObjectType, TValueTypes>["delete"]
-  restore: ObjectByIdHandle<TObjectType, TValueTypes>["restore"]
-  telemetry: ObjectByIdHandle<TObjectType, TValueTypes>["telemetry"]
+export interface ExecutionObjectByIdHandle<TObjectType extends ObjectTypeWithPropertyTokens>
+  extends ObjectReadByIdHandle<TObjectType> {
+  vector: ObjectByIdHandle<TObjectType>["vector"]
+  requestAction: ObjectByIdHandle<TObjectType>["requestAction"]
+  requestActionAndWait: ObjectByIdHandle<TObjectType>["requestActionAndWait"]
+  link: ObjectByIdHandle<TObjectType>["link"]
+  unlink: ObjectByIdHandle<TObjectType>["unlink"]
+  delete: ObjectByIdHandle<TObjectType>["delete"]
+  restore: ObjectByIdHandle<TObjectType>["restore"]
+  telemetry: ObjectByIdHandle<TObjectType>["telemetry"]
 }
 
-export interface ExecutionObjectSet<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
-  TRegisteredObjectTypes extends ObjectTypeWithPropertyTokens = TObjectType,
-> {
-  get: ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>["get"]
-  list: ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>["list"]
-  query: ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>["query"]
-  requestAction: ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>["requestAction"]
-  requestActionAndWait: ObjectSet<
-    TObjectType,
-    TValueTypes,
-    TRegisteredObjectTypes
-  >["requestActionAndWait"]
-  upsert: ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>["upsert"]
-  upsertLink: ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>["upsertLink"]
-  removeLink: ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>["removeLink"]
-  appendTelemetryBatch: ObjectSet<
-    TObjectType,
-    TValueTypes,
-    TRegisteredObjectTypes
-  >["appendTelemetryBatch"]
+export interface ExecutionObjectSet<TObjectType extends ObjectTypeWithPropertyTokens>
+  extends ObjectReadSet<TObjectType> {
+  requestAction: ObjectSet<TObjectType>["requestAction"]
+  requestActionAndWait: ObjectSet<TObjectType>["requestActionAndWait"]
+  upsert: ObjectSet<TObjectType>["upsert"]
+  upsertLink: ObjectSet<TObjectType>["upsertLink"]
+  removeLink: ObjectSet<TObjectType>["removeLink"]
+  appendTelemetryBatch: ObjectSet<TObjectType>["appendTelemetryBatch"]
 
-  byId(id: string): ExecutionObjectByIdHandle<TObjectType, TValueTypes>
+  byId(id: string): ExecutionObjectByIdHandle<TObjectType>
 }
 
 /** Public input for querying physical links incident to an object query result. */
@@ -130,15 +111,10 @@ export type ObjectQueryLinksInput = Omit<ExecuteObjectQueryLinksInput, "projectI
 /** Public result returned by {@link ObjectsRuntime.queryLinks}. */
 export type ObjectQueryLinksResult = ExecuteObjectQueryLinksResult
 
-export interface ObjectsRuntime<TOntologySources extends readonly OntologySource[]>
-  extends ExecutionObjectOperations {
-  <TObjectType extends RegisteredObjectType<TOntologySources>>(
+export interface ObjectsRuntime extends ExecutionObjectOperations {
+  <TObjectType extends ObjectTypeWithPropertyTokens>(
     objectType: TObjectType
-  ): ExecutionObjectSet<
-    TObjectType,
-    RegisteredValueTypes<TOntologySources>,
-    RegisteredObjectType<TOntologySources>
-  >
+  ): ExecutionObjectSet<TObjectType>
   executeQuery(input: Omit<ExecuteObjectQueryInput, "projectId">): Promise<ExecuteObjectQueryResult>
   queryLinks(input: ObjectQueryLinksInput): Promise<ObjectQueryLinksResult>
   count(input: Omit<ExecuteObjectCountInput, "projectId">): Promise<ExecuteObjectCountResult>
@@ -169,10 +145,10 @@ export interface ObjectsRuntime<TOntologySources extends readonly OntologySource
   }): Promise<TimeseriesPoint | null>
 }
 
-export function createObjectsRuntime<TOntologySources extends readonly OntologySource[]>(
+export function createObjectsRuntime(
   runtime: SixbRuntimeContext,
   execution: ExecutionContext
-): ObjectsRuntime<TOntologySources> {
+): ObjectsRuntime {
   const runtimeAuthorization = runtime.runtimeAuthorization
   const objectReader = runtime.objectReader
   assertAuthorizedObjectReaderBinding({
@@ -184,6 +160,7 @@ export function createObjectsRuntime<TOntologySources extends readonly OntologyS
     projectId: runtime.projectId,
     broker: runtime.broker,
     ontology: runtime.ontology,
+    embeddingModels: runtime.embeddingModels,
     actionRegistry: runtime.actionRegistry,
     events: runtime.events,
     storage: runtime.storage,
@@ -197,17 +174,13 @@ export function createObjectsRuntime<TOntologySources extends readonly OntologyS
   Object.freeze(capturedRuntime)
   const ontologyView = () => getAuthorizedOntologyView(objectReader)
   const objects = Object.assign(
-    <TObjectType extends RegisteredObjectType<TOntologySources>>(objectType: TObjectType) => {
+    <TObjectType extends ObjectTypeWithPropertyTokens>(objectType: TObjectType) => {
       assertObjectTypeRegistered(capturedRuntime.ontology.getObjectTypesById(), objectType)
-      return createObjectSet<
-        TObjectType,
-        RegisteredObjectType<TOntologySources>,
-        RegisteredValueTypes<TOntologySources>
-      >({ ...capturedRuntime, execution, objectType }) as ExecutionObjectSet<
-        TObjectType,
-        RegisteredValueTypes<TOntologySources>,
-        RegisteredObjectType<TOntologySources>
-      >
+      return createObjectSet<TObjectType>({
+        ...capturedRuntime,
+        execution,
+        objectType,
+      }) as ExecutionObjectSet<TObjectType>
     },
     {
       listTypes: () => ontologyView().listObjectTypes(),
@@ -317,5 +290,5 @@ export function createObjectsRuntime<TOntologySources extends readonly OntologyS
     }
   )
 
-  return objects as ObjectsRuntime<TOntologySources>
+  return objects as ObjectsRuntime
 }