@sixb/core 0.1.10 → 0.1.12

package/src/storage/ontology/in-memory/vector-indexing.ts

@@ -0,0 +1,179 @@
+import type { MaterializationSession } from "../materializations"
+import type { OntologyVectorIndexingStorage, VectorIndexingWork } from "../vector-indexing"
+
+export class InMemoryVectorIndexingStorage implements OntologyVectorIndexingStorage {
+  constructor(
+    private readonly state: Map<
+      string,
+      VectorIndexingWork & { projectId: string; dispatchAt: string }
+    >,
+    private readonly assertSession: (session: MaterializationSession, projectId: string) => void,
+    private readonly run: <T>(fn: () => T) => Promise<T>
+  ) {}
+
+  async schedule(input: Parameters<OntologyVectorIndexingStorage["schedule"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    if (input.deleted.length) {
+      const deleted = new Set(
+        input.deleted.map((ref) => JSON.stringify([ref.objectTypeId, ref.primaryId]))
+      )
+      for (const [key, work] of this.state) {
+        if (
+          work.projectId === input.projectId &&
+          deleted.has(JSON.stringify([work.ref.objectTypeId, work.ref.primaryId]))
+        )
+          this.state.delete(key)
+      }
+    }
+    for (const request of input.requests) {
+      const key = JSON.stringify([
+        input.projectId,
+        request.ref.objectTypeId,
+        request.ref.primaryId,
+        request.profile,
+      ])
+      this.state.set(
+        key,
+        structuredClone({
+          ...request,
+          projectId: input.projectId,
+          status: "pending",
+          availableAt: input.availableAt,
+          dispatchAt: input.availableAt,
+        })
+      )
+    }
+  }
+
+  async complete(input: Parameters<OntologyVectorIndexingStorage["complete"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    for (const entry of input.entries) {
+      const key = JSON.stringify([
+        input.projectId,
+        entry.ref.objectTypeId,
+        entry.ref.primaryId,
+        entry.profile,
+      ])
+      const work = this.state.get(key)
+      if (
+        work?.configuration === entry.configuration &&
+        work.sourceFingerprint === entry.sourceFingerprint
+      ) {
+        this.state.delete(key)
+      }
+    }
+  }
+
+  async dispatched(input: Parameters<OntologyVectorIndexingStorage["dispatched"]>[0]) {
+    await this.run(() => {
+      for (const [key, work] of this.state)
+        if (work.projectId === input.projectId && input.ids.includes(work.id))
+          this.state.set(key, { ...work, dispatchAt: input.nextDispatchAt })
+    })
+  }
+  async get(input: Parameters<OntologyVectorIndexingStorage["get"]>[0]) {
+    return this.run(() =>
+      structuredClone(
+        [...this.state.values()].find(
+          (work) => work.projectId === input.projectId && work.id === input.id
+        ) ?? null
+      )
+    )
+  }
+
+  async getBatch(input: Parameters<OntologyVectorIndexingStorage["getBatch"]>[0]) {
+    return this.run(() =>
+      structuredClone(
+        [...this.state.values()]
+          .filter((work) => work.projectId === input.projectId && work.batchId === input.batchId)
+          .sort((a, b) => a.id.localeCompare(b.id))
+      )
+    )
+  }
+
+  async getBatchMember(input: Parameters<OntologyVectorIndexingStorage["getBatchMember"]>[0]) {
+    return this.run(() => {
+      const work = this.state.get(
+        JSON.stringify([
+          input.projectId,
+          input.ref.objectTypeId,
+          input.ref.primaryId,
+          input.profile,
+        ])
+      )
+      return work?.batchId === input.batchId ? structuredClone(work) : null
+    })
+  }
+
+  async updateBatch(input: Parameters<OntologyVectorIndexingStorage["updateBatch"]>[0]) {
+    return this.run(() => {
+      const updates = new Map(input.updates.map((update) => [update.id, update]))
+      const matches = [...this.state.entries()].filter(
+        ([, work]) =>
+          work.projectId === input.projectId && updates.get(work.id)?.expectedStatus === work.status
+      )
+      if (input.requireAll && matches.length !== input.updates.length) return false
+      for (const [key, work] of matches) {
+        const update = updates.get(work.id)!
+        this.state.set(
+          key,
+          structuredClone({
+            ...work,
+            status: update.status,
+            availableAt: update.availableAt,
+            values: update.values ?? work.values,
+            error: update.error,
+          })
+        )
+      }
+      return true
+    })
+  }
+
+  async listDue(input: Parameters<OntologyVectorIndexingStorage["listDue"]>[0]) {
+    return this.run(() =>
+      [...this.state.values()]
+        .filter(
+          (work) =>
+            work.projectId === input.projectId &&
+            work.status !== "failed" &&
+            work.dispatchAt <= input.now
+        )
+        .sort((a, b) => a.dispatchAt.localeCompare(b.dispatchAt) || a.id.localeCompare(b.id))
+        .slice(0, input.limit)
+        .map(({ values: _values, ...work }) => structuredClone(work))
+    )
+  }
+
+  async update(input: Parameters<OntologyVectorIndexingStorage["update"]>[0]) {
+    return this.run(() => {
+      for (const [key, work] of this.state) {
+        if (
+          work.projectId !== input.projectId ||
+          work.id !== input.id ||
+          work.status !== input.expectedStatus
+        )
+          continue
+        this.state.set(
+          key,
+          structuredClone({
+            ...work,
+            status: input.status,
+            availableAt: input.availableAt,
+            values: input.values ?? work.values,
+            error: input.error,
+          })
+        )
+        return true
+      }
+      return false
+    })
+  }
+
+  async remove(input: Parameters<OntologyVectorIndexingStorage["remove"]>[0]) {
+    await this.run(() => {
+      for (const [key, work] of this.state)
+        if (work.projectId === input.projectId && work.id === input.id) this.state.delete(key)
+    })
+  }
+}

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

@@ -0,0 +1,73 @@
+import { MaterializationConflictError } from "../../../materialization/errors"
+import type { MaterializationSession } from "../materializations"
+import type { OntologyVectorStorage, StoredObjectVector } from "../vectors"
+
+export function vectorObjectKey(projectId: string, ref: StoredObjectVector["ref"]): string {
+  return JSON.stringify([projectId, ref.objectTypeId, ref.primaryId])
+}
+
+export class InMemoryOntologyVectorStorage implements OntologyVectorStorage {
+  constructor(
+    private readonly state: Map<string, Map<string, StoredObjectVector>>,
+    private readonly assertSession: (
+      session: MaterializationSession,
+      projectId: string,
+      commitId?: string
+    ) => void,
+    private readonly runRootOperation: <T>(run: () => T) => Promise<T>
+  ) {}
+
+  async list(input: Parameters<OntologyVectorStorage["list"]>[0]) {
+    return this.listBatch({ projectId: input.projectId, refs: [input.ref] })
+  }
+
+  async listBatch(input: Parameters<OntologyVectorStorage["listBatch"]>[0]) {
+    return this.runRootOperation(() =>
+      [...new Set(input.refs.map((ref) => vectorObjectKey(input.projectId, ref)))].flatMap((key) =>
+        [...(this.state.get(key)?.values() ?? [])].map(({ values: _values, ...metadata }) =>
+          structuredClone(metadata)
+        )
+      )
+    )
+  }
+
+  async removeBatch(input: Parameters<OntologyVectorStorage["removeBatch"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    for (const entry of input.entries) {
+      await this.remove({ session: input.session, projectId: input.projectId, ...entry })
+    }
+  }
+
+  async write(input: Parameters<OntologyVectorStorage["write"]>[0]) {
+    this.assertSession(input.session, input.projectId, input.value.lastCommitId)
+    const key = vectorObjectKey(input.projectId, input.value.ref)
+    const profiles = this.state.get(key) ?? new Map<string, StoredObjectVector>()
+    this.assertRevision(profiles.get(input.value.profile), input.expectedCommitId)
+    profiles.set(input.value.profile, structuredClone(input.value))
+    this.state.set(key, profiles)
+  }
+
+  async writeBatch(input: Parameters<OntologyVectorStorage["writeBatch"]>[0]): Promise<void> {
+    for (const entry of input.entries) {
+      await this.write({ session: input.session, projectId: input.projectId, ...entry })
+    }
+  }
+
+  async remove(input: Parameters<OntologyVectorStorage["remove"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    const key = vectorObjectKey(input.projectId, input.ref)
+    const profiles = this.state.get(key)
+    this.assertRevision(profiles?.get(input.profile), input.expectedCommitId)
+    profiles?.delete(input.profile)
+    if (profiles?.size === 0) this.state.delete(key)
+  }
+
+  private assertRevision(current: StoredObjectVector | undefined, expected: string | null) {
+    if ((current?.lastCommitId ?? null) !== expected) {
+      throw new MaterializationConflictError(
+        "effective-state",
+        "Vector changed since it was prepared."
+      )
+    }
+  }
+}

package/src/storage/ontology/index.ts

@@ -2,6 +2,8 @@ import type { OntologyCommitStorage } from "./commits"
 import type { OntologyMaterializationStorage } from "./materializations"
 import type { OntologyOutboxStorage } from "./outbox"
 import type { OntologySourceStorage } from "./sources"
+import type { OntologyVectorIndexingStorage } from "./vector-indexing"
+import type { OntologyVectorStorage } from "./vectors"
 
 export type { ProjectionExecution } from "../../materialization/model"
 export type {
@@ -119,9 +121,21 @@ export type {
   TerminalSourceMaterializationSummary,
 } from "./sources"
 
+export type { ObjectVectorState, OntologyVectorStorage, StoredObjectVector } from "./vectors"
+
 export interface OntologyStorage {
+  readonly vectorIndexing?: OntologyVectorIndexingStorage
+  readonly vectors?: OntologyVectorStorage
   readonly commits: OntologyCommitStorage
   readonly sources: OntologySourceStorage
   readonly materializations: OntologyMaterializationStorage
   readonly outbox: OntologyOutboxStorage
 }
+
+export type {
+  OntologyVectorIndexingStorage,
+  VectorIndexingFailureCode,
+  VectorIndexingRequest,
+  VectorIndexingUpdate,
+  VectorIndexingWork,
+} from "./vector-indexing"

package/src/storage/ontology/outbox.ts

@@ -80,6 +80,7 @@ export interface OntologyOutboxSummary {
   readonly maxAttempts: number
 }
 
+/** Each method is atomic on its own, including validation of the entire lease batch. */
 export interface OntologyOutboxStorage {
   /** Selects each claimed batch deterministically; concurrent publishers may complete out of order. */
   claim(input: ClaimOntologyOutboxInput): Promise<readonly ClaimedOntologyOutboxRow[]>

package/src/storage/ontology/vector-indexing.ts

@@ -0,0 +1,98 @@
+import type { SixbFailure } from "../../errors/types"
+import type { OntologyObjectRef } from "../../materialization/model"
+import type { MaterializationSession } from "./materializations"
+
+export const VECTOR_INDEXING_FAILURE_CODES = [
+  "vector.model_unavailable",
+  "vector.response_invalid",
+  "vector.outcome_unknown",
+  "internal.unexpected",
+] as const
+
+export type VectorIndexingFailureCode = (typeof VECTOR_INDEXING_FAILURE_CODES)[number]
+
+/** Latest desired representation; replacing its id fences every older delivery. */
+export interface VectorIndexingRequest {
+  readonly id: string
+  /** Set only by projection materialization; a bounded, immediately durable group. */
+  readonly batchId?: string
+  readonly ref: OntologyObjectRef
+  readonly profile: string
+  readonly configuration: string
+  readonly sourceFingerprint: string
+  readonly sourceCommitId: string
+}
+
+export interface VectorIndexingWork extends VectorIndexingRequest {
+  readonly status: "pending" | "running" | "ready" | "failed"
+  readonly availableAt: string
+  readonly values?: readonly number[]
+  readonly error?: SixbFailure<VectorIndexingFailureCode>
+}
+
+export interface VectorIndexingUpdate {
+  readonly id: string
+  readonly expectedStatus: VectorIndexingWork["status"]
+  readonly status: VectorIndexingWork["status"]
+  readonly availableAt: string
+  readonly values?: readonly number[]
+  readonly error?: SixbFailure<VectorIndexingFailureCode>
+}
+
+/** Durable intent belongs to ontology storage; delivery leases belong to Queues. */
+export interface OntologyVectorIndexingStorage {
+  /** Called inside the transaction that changes the effective object. */
+  schedule(input: {
+    projectId: string
+    session: MaterializationSession
+    requests: readonly VectorIndexingRequest[]
+    deleted: readonly OntologyObjectRef[]
+    availableAt: string
+  }): Promise<void>
+  /** Clear matching intent atomically with a successful automatic or explicit vector write. */
+  complete(input: {
+    projectId: string
+    session: MaterializationSession
+    entries: readonly Pick<
+      VectorIndexingRequest,
+      "ref" | "profile" | "configuration" | "sourceFingerprint"
+    >[]
+  }): Promise<void>
+  dispatched(input: {
+    projectId: string
+    ids: readonly string[]
+    nextDispatchAt: string
+  }): Promise<void>
+  get(input: { projectId: string; id: string }): Promise<VectorIndexingWork | null>
+  getBatch(input: { projectId: string; batchId: string }): Promise<readonly VectorIndexingWork[]>
+  /** Read only the result this kernel batch is allowed to publish. */
+  getBatchMember(input: {
+    projectId: string
+    batchId: string
+    ref: OntologyObjectRef
+    profile: string
+  }): Promise<VectorIndexingWork | null>
+  /** Atomic transitions; requireAll prevents admission if any prepared member was superseded. */
+  updateBatch(input: {
+    projectId: string
+    updates: readonly VectorIndexingUpdate[]
+    requireAll?: boolean
+  }): Promise<boolean>
+  /** Bounded fair redispatch scan. Never scans objects or backfills existing data. */
+  listDue(input: {
+    projectId: string
+    now: string
+    limit: number
+  }): Promise<readonly VectorIndexingWork[]>
+  /** CAS also fences concurrent deliveries and source changes. */
+  update(input: {
+    projectId: string
+    id: string
+    expectedStatus: VectorIndexingWork["status"]
+    status: VectorIndexingWork["status"]
+    availableAt: string
+    values?: readonly number[]
+    error?: SixbFailure<VectorIndexingFailureCode>
+  }): Promise<boolean>
+  remove(input: { projectId: string; id: string }): Promise<void>
+}

package/src/storage/ontology/vectors.ts

@@ -0,0 +1,48 @@
+import type { OntologyObjectRef } from "../../materialization/model"
+import type { MaterializationSession } from "./materializations"
+
+export interface ObjectVectorState {
+  readonly ref: OntologyObjectRef
+  readonly profile: string
+  readonly configuration: string
+  readonly source: readonly string[]
+  readonly sourceFingerprint: string
+  readonly lastCommitId: string
+}
+
+export interface StoredObjectVector extends ObjectVectorState {
+  readonly values: readonly number[]
+}
+
+/** Transactional derived state. Mutations must run inside an ontology materialization transaction. */
+export interface OntologyVectorStorage {
+  list(input: { projectId: string; ref: OntologyObjectRef }): Promise<readonly ObjectVectorState[]>
+  listBatch(input: {
+    projectId: string
+    refs: readonly OntologyObjectRef[]
+  }): Promise<readonly ObjectVectorState[]>
+  removeBatch(input: {
+    session: MaterializationSession
+    projectId: string
+    entries: readonly { ref: OntologyObjectRef; profile: string; expectedCommitId: string }[]
+  }): Promise<void>
+  write(input: {
+    session: MaterializationSession
+    projectId: string
+    value: StoredObjectVector
+    expectedCommitId: string | null
+  }): Promise<void>
+  /** Write a validated set inside the materialization transaction; any conflict aborts it. */
+  writeBatch(input: {
+    session: MaterializationSession
+    projectId: string
+    entries: readonly { value: StoredObjectVector; expectedCommitId: string | null }[]
+  }): Promise<void>
+  remove(input: {
+    session: MaterializationSession
+    projectId: string
+    ref: OntologyObjectRef
+    profile: string
+    expectedCommitId: string
+  }): Promise<void>
+}

package/src/storage/operation-scope.ts

@@ -230,6 +230,7 @@ export function createOntologyOperationScope<T extends OntologyStorage>(
     sources: createOperationScopedFacade(target.sources, scope),
     materializations: createOperationScopedFacade(target.materializations, scope),
     outbox: createOperationScopedFacade(target.outbox, scope),
+    ...(target.vectors ? { vectors: createOperationScopedFacade(target.vectors, scope) } : {}),
   }) as T
 }
 

package/src/storage/types.ts

@@ -50,6 +50,8 @@ export type {
   AgentRunRecord,
   AgentStorage,
   AgentThreadRecord,
+  AgentThreadSandboxParams,
+  AgentThreadSandboxState,
   AppendAgentMessageInput,
   ConfirmAgentRunExecutionOwnershipInput,
   ConversationAgentRunRecord,
@@ -70,6 +72,7 @@ export type {
   SubagentRunRecord,
   SubagentRunResult,
   SubagentRunSpec,
+  TransitionAgentThreadSandboxInput,
 } from "./agents"
 export { AGENT_RUN_FAILURE_CODES, AgentStorageError } from "./agents"
 export type {