@sixb/core 0.1.11 → 0.1.13

package/src/storage/index.ts

@@ -75,6 +75,8 @@ export type {
   AgentStorage,
   AgentStorageErrorCode,
   AgentThreadRecord,
+  AgentThreadSandboxParams,
+  AgentThreadSandboxState,
   AgentThreadStatus,
   AgentThreadStore,
   AppendAgentMessageInput,
@@ -99,6 +101,7 @@ export type {
   SubagentRunRecord,
   SubagentRunResult,
   SubagentRunSpec,
+  TransitionAgentThreadSandboxInput,
 } from "./agents"
 export {
   AGENT_RUN_DIAGNOSTIC_CODES,
@@ -117,6 +120,7 @@ export type {
   AiAccountingOverview,
   AiAccountingRange,
   AiAccountingTimeBucket,
+  AiAccountingUsage,
   AiAccountingWorkflowBreakdown,
   AiBillableMeter,
   AiBillingIdentity,
@@ -195,7 +199,6 @@ export type {
 export { AiUsageStorageError, aggregateAiModelCallUsage, InMemoryAiUsageStorage } from "./ai-usage"
 export type {
   AccessTokenRecord,
-  AccessTokenSubjectType,
   AuthAccessTokenStore,
   AuthDeviceAuthorizationStore,
   AuthGroupMembershipStore,
@@ -209,6 +212,7 @@ export type {
   AuthStorageErrorCode,
   AuthUserIdentityStore,
   AuthUserStore,
+  BearerSessionState,
   CompleteAuthSessionInput,
   CompleteDeviceAuthorizationInput,
   CompleteDeviceAuthorizationResult,
@@ -240,6 +244,7 @@ export type {
   MagicLinkRecord,
   OidcAuthorizationAttemptRecord,
   ReconcileAuthServiceAccountGroupMembershipsInput,
+  RotateSessionRefreshTokenResult,
   ServiceAccountGroupMembershipRecord,
   ServiceAccountRecord,
   ServiceAccountStatus,
@@ -353,6 +358,7 @@ export type {
   FileUploadSessionStore,
   FileUploadStatus,
   FileUploadStrategy,
+  ListAbandonedFileUploadSessionsInput,
 } from "./file-upload-sessions"
 export {
   DEFAULT_FILE_UPLOAD_SESSION_TTL_MS,
@@ -503,6 +509,7 @@ export type {
   MaterializationWorkEntityKind,
   MaterializationWorkPage,
   MaterializationWorkRecord,
+  ObjectVectorState,
   OntologyCommitOriginSelector,
   OntologyCommitRecord,
   OntologyCommitRunSelector,
@@ -521,6 +528,7 @@ export type {
   OntologySourceRecord,
   OntologySourceStorage,
   OntologyStorage,
+  OntologyVectorStorage,
   ProjectionOntologyCommitIntent,
   PurgePublishedOntologyOutboxInput,
   ReadMaterializationObjectExistenceInput,
@@ -538,6 +546,7 @@ export type {
   StoredLinkOverride,
   StoredLinkSlotOverride,
   StoredObjectOverride,
+  StoredObjectVector,
   StoredSourceAssertion,
   StoredSourceLinkAssertion,
   StoredSourceObjectAssertion,
@@ -551,6 +560,14 @@ export type {
   TerminalSourceMaterializationSummary,
 } from "./ontology"
 export { ONTOLOGY_OUTBOX_FAILURE_CODES } from "./ontology"
+export type {
+  OntologyVectorIndexingStorage,
+  VectorIndexingFailureCode,
+  VectorIndexingRequest,
+  VectorIndexingUpdate,
+  VectorIndexingWork,
+} from "./ontology/vector-indexing"
+export { VECTOR_INDEXING_FAILURE_CODES } from "./ontology/vector-indexing"
 export type {
   FinishPipelineRunInput,
   FinishPipelineStepRunInput,
@@ -667,7 +684,6 @@ export type {
   TimeseriesPoint,
   TimeseriesStorage,
 } from "./timeseries"
-
 export type { Storage, StorageTransactionOptions } from "./types"
 export type {
   FinishWebhookRunInput,
@@ -696,7 +712,6 @@ export type {
   ListWorkflowInterventionsInput,
   ListWorkflowInterventionsResult,
   SubmitWorkflowInterventionInput,
-  WorkflowInterventionActor,
   WorkflowInterventionRecord,
   WorkflowInterventionStatus,
   WorkflowInterventionStorage,

package/src/storage/objects/in-memory/query.ts

@@ -2,11 +2,13 @@ import type {
   ObjectQuery,
   ObjectQueryPredicate,
   ObjectQuerySortField,
+  QueryScalarKind,
 } from "../../../objects/query"
 import {
   compareQueryScalarValues,
   queryScalarValuesEqual,
 } from "../../../objects/query/scalar-values"
+import { vectorSources } from "../../../objects/vectors/profile"
 import type { LinkBatchKey } from "../keys"
 import {
   compareObjectLinkCursors,
@@ -81,6 +83,7 @@ export const IN_MEMORY_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     decimal: { equality: true, ordering: true },
     date: { equality: true, ordering: true },
     timestamp: { equality: true, ordering: true },
+    userRef: { equality: true },
   },
   limits: {
     totalCount: true,
@@ -132,17 +135,36 @@ export function evaluateObjectQuery(
       return completeEvaluation(scoredEntries)
     }
     case "vector": {
+      if (typeof query.vector === "string")
+        throw new Error("[Sixb] Vector search text must be embedded before storage execution.")
+      const vector = query.vector
       const input = evaluateObjectQuery(query.input, source)
       const scoredEntries = input.entries.flatMap((entry) => {
-        const score = vectorSimilarity(entry.row.properties[query.propertyId], query.vector)
-        return score === null ? [] : [{ ...entry, score: entry.score + score }]
+        const stored = source.getVector?.(entry.row, query.profile)
+        if (
+          !stored ||
+          !query.configuration ||
+          stored.configuration !== query.configuration ||
+          vectorSources(stored.source, entry.row.properties).sourceFingerprint !==
+            stored.sourceFingerprint
+        )
+          return []
+        const score = vectorSimilarity(stored.values, vector)
+        return score === null
+          ? []
+          : [{ ...entry, score: entry.score + Math.max(-1, Math.min(1, score)) }]
       })
-      scoredEntries.sort(compareEntriesByRelevance)
+      scoredEntries.sort(
+        (a, b) =>
+          b.score - a.score ||
+          Buffer.compare(Buffer.from(a.row.objectTypeId), Buffer.from(b.row.objectTypeId)) ||
+          Buffer.compare(Buffer.from(a.row.primaryId), Buffer.from(b.row.primaryId))
+      )
       const limit = Math.max(0, query.k)
       return {
         entries: scoredEntries.slice(0, limit),
-        total: scoredEntries.length,
-        hasMore: limit < scoredEntries.length,
+        total: Math.min(limit, scoredEntries.length),
+        hasMore: false,
       }
     }
     case "traverse": {
@@ -403,17 +425,25 @@ function matchesPredicate(row: ObjectRow, predicate: ObjectQueryPredicate): bool
       return predicate.value ? exists : !exists
     }
     case "contains":
-      return containsValue(row.properties[predicate.propertyId], predicate.value)
+      return containsValue(
+        row.properties[predicate.propertyId],
+        predicate.value,
+        predicate.scalarKind
+      )
   }
 }
 
-function containsValue(actual: unknown, expected: unknown): boolean {
+function containsValue(
+  actual: unknown,
+  expected: unknown,
+  itemScalarKind: QueryScalarKind | undefined
+): boolean {
   if (typeof actual === "string" && typeof expected === "string") {
     return actual.includes(expected)
   }
 
   if (Array.isArray(actual)) {
-    return actual.some((item) => queryScalarValuesEqual(item, expected))
+    return actual.some((item) => queryScalarValuesEqual(item, expected, itemScalarKind))
   }
 
   if (isPlainObject(actual) && typeof expected === "string") {
@@ -539,12 +569,6 @@ function compareSortField(
   return field.direction === "desc" ? -comparison : comparison
 }
 
-function compareEntriesByRelevance(left: QueryEntry, right: QueryEntry): number {
-  return (
-    right.score - left.score || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row))
-  )
-}
-
 function projectRow(row: ObjectRow, properties: readonly string[]): ObjectRow {
   const projected: Record<string, unknown> = {}
   for (const propertyId of properties) {

package/src/storage/objects/in-memory/read-scope.ts

@@ -137,15 +137,16 @@ export function resolveSelectedReadUniverse(
     links.set(key, redactLinkRow(selected.row, selected.propertyIds))
   }
 
-  return createReadUniverse(source.projectId, objects, links, objectProperties)
+  return createReadUniverse(source, objects, links, objectProperties)
 }
 
 function createReadUniverse(
-  projectId: string,
+  source: InMemoryReadSource,
   objects: ReadonlyMap<string, ObjectRow>,
   links: ReadonlyMap<string, ObjectLinkRow>,
   objectProperties: ReadonlyMap<string, ReadonlySet<string>>
 ): InMemoryReadUniverse {
+  const projectId = source.projectId
   const linksBySource = new Map<string, ObjectLinkRow[]>()
   for (const link of links.values()) {
     const key = sourceLinkBucketKey(link.projectId, link.sourceTypeId, link.sourceId)
@@ -159,6 +160,12 @@ function createReadUniverse(
     links,
     linksBySource,
     objectProperties,
+    getVector: (ref, profile) => {
+      const key = rowIdentityKeyParts(ref.objectTypeId, ref.primaryId)
+      if (!objects.has(key)) return undefined
+      const value = source.getVector?.(ref, profile)
+      return value?.source.every((id) => objectProperties.get(key)?.has(id)) ? value : undefined
+    },
     objectsOfType: (objectTypeId) =>
       [...objects.values()].filter((row) => row.objectTypeId === objectTypeId),
     getObject: (objectTypeId, primaryId) =>

package/src/storage/objects/in-memory/read-source.ts

@@ -1,8 +1,13 @@
+import type { StoredObjectVector } from "../../ontology/vectors"
 import type { ObjectLinkRow, ObjectRow } from "../types"
 
 /** Project-bound read input shared by ordinary and selected in-memory queries. */
 export interface InMemoryReadSource {
   readonly projectId: string
+  getVector?(
+    ref: { objectTypeId: string; primaryId: string },
+    profile: string
+  ): StoredObjectVector | undefined
   objectsOfType(objectTypeId: string): readonly ObjectRow[]
   getObject(objectTypeId: string, primaryId: string): ObjectRow | undefined
   outgoingLinks(objectTypeId: string, primaryId: string): Iterable<ObjectLinkRow>

package/src/storage/objects/in-memory/selected-reader.ts

@@ -1,3 +1,4 @@
+import { hasVectorProfile } from "../../../objects/vectors/query"
 import {
   assertObjectReadFacetCount,
   assertObjectReadOutputWithinLimit,
@@ -74,7 +75,10 @@ export function createInMemorySelectedReader(
       const universe = resolveSelectedReadUniverse(source, plan, limits)
       const result = evaluateObjectQuery(input.query, universe)
       return visible({
-        objects: result.entries.map((entry) => structuredClone(entry.row)),
+        objects: result.entries.map((entry) => ({
+          ...structuredClone(entry.row),
+          ...(hasVectorProfile(input.query) ? { score: entry.score } : {}),
+        })),
         hasMore: result.hasMore,
         nextPageToken: result.nextPageToken,
         ...(input.includeTotal === false ? {} : { total: result.total }),

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

@@ -1,4 +1,6 @@
 import type { EffectiveLinkSnapshot, EffectiveObjectSnapshot } from "../../../materialization/model"
+import { hasVectorProfile } from "../../../objects/vectors/query"
+import type { StoredObjectVector } from "../../ontology/vectors"
 import type { ObjectReadExecutionLimits } from "../execution-limits"
 import { type LinkBatchKey, type ObjectBatchKey, objectBatchKey } from "../keys"
 import type {
@@ -44,7 +46,14 @@ export interface InMemoryObjectStorageSnapshot {
   readonly links: Map<string, Map<string, ObjectLinkRow>>
 }
 
+type VectorReader = (
+  projectId: string,
+  ref: { objectTypeId: string; primaryId: string },
+  profile: string
+) => StoredObjectVector | undefined
+
 interface InMemoryObjectMaterializerAdapter {
+  setVectorReader(reader: VectorReader): void
   getExactObjectRow(projectId: string, objectTypeId: string, primaryId: string): ObjectRow | null
   getExactLinkRow(
     projectId: string,
@@ -92,8 +101,13 @@ export class InMemoryObjectStorage implements ObjectStorage {
   private readonly rows = new Map<string, Map<string, ObjectRow>>()
   private readonly links = new Map<string, Map<string, ObjectLinkRow>>()
 
+  private vectorReader?: VectorReader
+
   constructor() {
     materializerAdapters.set(this, {
+      setVectorReader: (reader) => {
+        this.vectorReader = reader
+      },
       getExactObjectRow: (projectId, objectTypeId, primaryId) =>
         this.getExactObjectRow(projectId, objectTypeId, primaryId),
       getExactLinkRow: (projectId, ref) => this.getExactLinkRow(projectId, ref),
@@ -243,6 +257,7 @@ export class InMemoryObjectStorage implements ObjectStorage {
     // Keep indexed access live across writes and snapshot restores; do not capture individual buckets.
     return {
       projectId,
+      getVector: (ref, profile) => this.vectorReader?.(projectId, ref, profile),
       objectsOfType: (objectTypeId) => [
         ...(this.rows.get(objectRowKey(projectId, objectTypeId))?.values() ?? []),
       ],
@@ -257,7 +272,10 @@ export class InMemoryObjectStorage implements ObjectStorage {
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
     const result = evaluateObjectQuery(params.query, this.readSource(params.projectId))
     return {
-      objects: result.entries.map((entry) => entry.row),
+      objects: result.entries.map((entry) => ({
+        ...entry.row,
+        ...(hasVectorProfile(params.query) ? { score: entry.score } : {}),
+      })),
       hasMore: result.hasMore,
       nextPageToken: result.nextPageToken,
       ...(params.includeTotal === false ? {} : { total: result.total }),

package/src/storage/objects/types.ts

@@ -14,6 +14,8 @@ import type { LinkBatchKey, ObjectBatchKey } from "./keys"
  */
 
 export interface ObjectRow {
+  /** Cosine similarity, present only on named vector query results. */
+  score?: number
   projectId: string
   objectTypeId: string
   primaryId: string

package/src/storage/ontology/commits.ts

@@ -1,4 +1,5 @@
-import type { EventActor } from "../../events/envelope"
+import type { AuthorizablePrincipal } from "../../execution/types"
+import type { EventExecutor } from "../../materialization/events"
 import type {
   EditCommitResult,
   OntologyMaterializationOrigin,
@@ -57,7 +58,10 @@ interface OntologyCommitFields {
   readonly requestHash: string
   readonly executionId: string
   readonly origin: OntologyMaterializationOrigin
-  readonly actor?: EventActor
+  /** Principal on whose behalf the execution ran, copied from `ExecutionRecord.requestedBy`. */
+  readonly requestedBy?: AuthorizablePrincipal
+  /** Workload that wrote the commit, copied from its execution. */
+  readonly executor: EventExecutor
   readonly ontologyRevision: string
   readonly projectionRevision?: string
   readonly ownershipHash?: string
@@ -68,6 +72,7 @@ export interface EditOntologyCommitIntent {
   readonly kind: "edit"
   readonly mode: "atomic" | "continue"
   readonly operationCount: number
+  readonly vectorWriteCount?: number
 }
 
 export interface ProjectionOntologyCommitIntent {

package/src/storage/ontology/in-memory/index.ts

@@ -1,4 +1,5 @@
 import type { InMemoryObjectStorage } from "../../objects/in-memory"
+import { getInMemoryObjectMaterializerAdapter } from "../../objects/in-memory"
 import type { InMemoryTimeseriesStorage } from "../../timeseries/store"
 import type { OntologyStorage } from ".."
 import type { ProviderMaterializationTransactionLifecycle } from "../provider"
@@ -29,8 +30,13 @@ interface InMemoryOntologyStorageOptions {
   readonly executionExists: (projectId: string, executionId: string) => Promise<boolean>
 }
 
+import { InMemoryVectorIndexingStorage } from "./vector-indexing"
+import { InMemoryOntologyVectorStorage, vectorObjectKey } from "./vectors"
+
 export class InMemoryOntologyStorage implements OntologyStorage {
   private readonly state = createInMemoryOntologyState()
+  readonly vectorIndexing: InMemoryVectorIndexingStorage
+  readonly vectors: InMemoryOntologyVectorStorage
   readonly commits: InMemoryOntologyCommitStorage
   readonly sources: InMemoryOntologySourceStorage
   readonly materializations: InMemoryOntologyMaterializationStorage
@@ -46,6 +52,20 @@ export class InMemoryOntologyStorage implements OntologyStorage {
     timeseries: InMemoryTimeseriesStorage,
     options: InMemoryOntologyStorageOptions
   ) {
+    this.vectorIndexing = new InMemoryVectorIndexingStorage(
+      this.state.vectorIndexing,
+      (session, projectId) => this.materializations.assertVectorSession(session, projectId),
+      options.runRootOperation
+    )
+    this.vectors = new InMemoryOntologyVectorStorage(
+      this.state.vectors,
+      (session, projectId, commitId) =>
+        this.materializations.assertVectorSession(session, projectId, commitId),
+      options.runRootOperation
+    )
+    getInMemoryObjectMaterializerAdapter(objects).setVectorReader((projectId, ref, profile) =>
+      this.state.vectors.get(vectorObjectKey(projectId, ref))?.get(profile)
+    )
     this.commits = new InMemoryOntologyCommitStorage(this.state, options.runRootOperation)
     this.sources = new InMemoryOntologySourceStorage(
       this.state,

package/src/storage/ontology/in-memory/materializations.ts

@@ -64,6 +64,9 @@ import type {
 import type { OntologyMaterializationEvent } from "../outbox"
 import {
   appendScopeSnapshot,
+  assertExpectedLinkRevision,
+  assertExpectedLinkScopeRevision,
+  assertExpectedObjectRevision,
   assertMaterializationHeader,
   finishScopeAccumulator,
   type ProviderMaterializationTransactionLifecycle,
@@ -217,12 +220,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
         expectedScopeRevisions.get(key) ??
         this.computeEffectiveLinkScope(input.commit.projectId, expected.source, expected.linkId)
       expectedScopeRevisions.set(key, current)
-      if (current.fingerprint !== expected.fingerprint) {
-        throw new MaterializationConflictError(
-          "effective-state",
-          `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`
-        )
-      }
+      assertExpectedLinkScopeRevision(current.fingerprint, expected)
     }
     for (const expected of input.expected.points) this.assertPoint(expected, input.commit.projectId)
 
@@ -814,6 +812,19 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     return { commit: structuredClone(record) }
   }
 
+  /** @internal Share the existing transaction/session fence with derived vector writes. */
+  assertVectorSession(session: MaterializationSession, projectId: string, commitId?: string): void {
+    const active = this.requireSession(session)
+    if (
+      active.header.commit.projectId !== projectId ||
+      (commitId !== undefined && active.header.commit.id !== commitId)
+    ) {
+      throw new MaterializationValidationError(
+        "Vector mutation does not belong to this materialization session."
+      )
+    }
+  }
+
   private requireSession(session: MaterializationSession): SessionState {
     const value = this.sessions.get(session.providerToken)
     if (
@@ -1026,20 +1037,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       expected.ref.objectTypeId,
       expected.ref.primaryId
     )
-    if (!expected.exists) {
-      if (row)
-        throw new MaterializationConflictError(
-          "effective-state",
-          `Expected object ${objectRefKey(expected.ref)} to be absent.`
-        )
-      return
-    }
-    if (!row || row.version !== expected.version || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError(
-        "effective-state",
-        `Expected object ${objectRefKey(expected.ref)} changed.`
-      )
-    }
+    assertExpectedObjectRevision(row ?? null, expected)
   }
 
   private async assertLink(expected: ExpectedLinkRevision, projectId: string): Promise<void> {
@@ -1054,20 +1052,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       targetTypeId: expected.ref.target.objectTypeId,
       targetId: expected.ref.target.primaryId,
     })
-    if (!expected.exists) {
-      if (row)
-        throw new MaterializationConflictError(
-          "effective-state",
-          `Expected link ${linkRefKey(expected.ref)} to be absent.`
-        )
-      return
-    }
-    if (!row || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError(
-        "effective-state",
-        `Expected link ${linkRefKey(expected.ref)} changed.`
-      )
-    }
+    assertExpectedLinkRevision(row?.lastCommitId, expected)
   }
 
   private assertPoint(expected: ExpectedTimeseriesPointRevision, projectId: string): void {

package/src/storage/ontology/in-memory/shared-state.ts

@@ -18,6 +18,8 @@ import type {
   StoredSourceAssertion,
   StoredSourceLinkAssertion,
 } from "../sources"
+import type { VectorIndexingWork } from "../vector-indexing"
+import type { StoredObjectVector } from "../vectors"
 
 export interface InMemorySourceRoot {
   readonly root: ProjectionEntityRef
@@ -49,6 +51,11 @@ export interface InMemoryStoredLinkSlotOverride extends Omit<StoredLinkSlotOverr
 }
 
 export interface InMemoryOntologyState {
+  readonly vectorIndexing: Map<
+    string,
+    VectorIndexingWork & { projectId: string; dispatchAt: string }
+  >
+  readonly vectors: Map<string, Map<string, StoredObjectVector>>
   readonly commitsById: Map<string, OntologyCommitRecord>
   readonly commitIdByIdempotency: Map<string, string>
   readonly commitIdByOrigin: Map<string, string>
@@ -73,6 +80,8 @@ export interface InMemoryOntologyStorageTestHooks {
 
 export function createInMemoryOntologyState(): InMemoryOntologyState {
   return {
+    vectors: new Map(),
+    vectorIndexing: new Map(),
     commitsById: new Map(),
     commitIdByIdempotency: new Map(),
     commitIdByOrigin: new Map(),