@sixb/core 0.1.11 → 0.1.12

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

@@ -87,6 +87,7 @@ export interface ExecutionObjectByIdHandle<
   TObjectType extends ObjectTypeWithPropertyTokens,
   TValueTypes extends readonly ValueType[],
 > {
+  vector: ObjectByIdHandle<TObjectType, TValueTypes>["vector"]
   get: ObjectByIdHandle<TObjectType, TValueTypes>["get"]
   listLinks: ObjectByIdHandle<TObjectType, TValueTypes>["listLinks"]
   requestAction: ObjectByIdHandle<TObjectType, TValueTypes>["requestAction"]
@@ -184,6 +185,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,

package/src/objects/query/executor.ts

@@ -1,5 +1,6 @@
 import { type AuthorizationContext, assertAuthorized } from "../../authorization"
 import type { RuntimeAuthorization } from "../../execution/types"
+import type { EmbeddingModelCatalog } from "../../models/catalog"
 import type { OntologyRegistry } from "../../ontology"
 import type {
   CountObjectsResult,
@@ -17,6 +18,7 @@ import type {
   QueryObjectsResult,
 } from "../../storage"
 import { linkBatchKey, MAX_OBJECT_READ_FACETS, objectBatchKey } from "../../storage"
+import { resolveVectorSearchText } from "../vectors/resolve-query"
 import {
   ObjectQueryExecutionError,
   ObjectQueryPlanningError,
@@ -50,6 +52,7 @@ export interface QueryExecutorOptions
     | "hasFacetObjects"
   > {
   ontology: OntologyRegistry
+  embeddingModels?: EmbeddingModelCatalog
   storage: ObjectReadStorage
   maxLimit?: number
   maxPageSize?: number
@@ -68,6 +71,7 @@ export interface QueryExecutorOptions
 }
 
 export interface ExecuteObjectQueryInput {
+  signal?: AbortSignal
   projectId: string
   query: ObjectQuery
   includeTotal?: boolean
@@ -179,7 +183,12 @@ export async function executeObjectQuery(
     }
     const result = await options.storage.queryObjects({
       projectId: input.projectId,
-      query: plan.query,
+      query: await resolveVectorSearchText(
+        plan.query,
+        options.ontology,
+        options.embeddingModels,
+        input.signal
+      ),
       includeTotal: input.includeTotal,
     })
     return { ...result, plan }
@@ -244,7 +253,7 @@ export async function countObjects(
     }
     const result = await options.storage.countObjects({
       projectId: input.projectId,
-      query: plan.query,
+      query: await resolveVectorSearchText(plan.query, options.ontology, options.embeddingModels),
     })
     return { ...result, plan }
   }
@@ -305,7 +314,7 @@ export async function existsObjects(
     }
     const result = await options.storage.existsObjects({
       projectId: input.projectId,
-      query: plan.query,
+      query: await resolveVectorSearchText(plan.query, options.ontology, options.embeddingModels),
     })
     return { ...result, plan }
   }
@@ -367,7 +376,7 @@ export async function facetObjects(
     }
     const result = await options.storage.facetObjects({
       projectId: input.projectId,
-      query: plan.query,
+      query: await resolveVectorSearchText(plan.query, options.ontology, options.embeddingModels),
       facets,
     })
     return { ...result, plan }

package/src/objects/query/explain.ts

@@ -119,8 +119,13 @@ function buildExplainNode(query: ObjectQuery, path: string): ObjectQueryExplainN
       return {
         path,
         kind: query.kind,
-        summary: `vector ${query.propertyId} k=${query.k}`,
-        details: { propertyId: query.propertyId, dimensions: query.vector.length, k: query.k },
+        summary: `vector profile ${query.profile} k=${query.k}`,
+        details: {
+          profile: query.profile,
+          input: typeof query.vector === "string" ? "text" : "vector",
+          dimensions: typeof query.vector === "string" ? undefined : query.vector.length,
+          k: query.k,
+        },
         children: [buildExplainNode(query.input, `${path}.input`)],
       }
     case "traverse":

package/src/objects/query/index.ts

@@ -1,3 +1,5 @@
+export { normalizeVector, vectorSearchCandidateLimit } from "../vectors/profile"
+export { hasVectorProfile, isVectorProfileQuery } from "../vectors/query"
 export type { ObjectQueryPlanningIssue } from "./errors"
 export {
   ObjectQueryExecutionError,

package/src/objects/query/ir.ts

@@ -77,8 +77,12 @@ export interface ObjectQueryText {
 export interface ObjectQueryVector {
   kind: "vector"
   input: ObjectQuery
-  vector: readonly number[]
-  propertyId: string
+  /** Text is embedded by the server using the named profile's model before storage execution. */
+  vector: readonly number[] | string
+  profile: string
+  /** Populated by canonical validation, never trusted from the wire. */
+  configuration?: string
+  source?: readonly string[]
   k: number
 }
 

package/src/objects/query/normalize.ts

@@ -39,7 +39,11 @@ function normalizeNode(query: ObjectQuery): ObjectQuery {
           : undefined,
       }
     case "vector":
-      return { ...query, input: normalizeObjectQuery(query.input), vector: [...query.vector] }
+      return {
+        ...query,
+        input: normalizeObjectQuery(query.input),
+        vector: typeof query.vector === "string" ? query.vector : [...query.vector],
+      }
     case "traverse":
       return { ...query, input: normalizeObjectQuery(query.input) }
     case "set":