@sixb/core 0.1.10 → 0.1.12

package/dist/{chunk-p6a4npdx.js → chunk-ybhz3j9g.js}

@@ -3,20 +3,20 @@ import {
   createSixbError2,
   toSixbFailure2,
   parseSixbFailure2
-} from "./chunk-f4w3yp4f.js";
+} from "./chunk-hzw7yv5g.js";
 import {
   parseActionRunFailure2
-} from "./chunk-b19g04jk.js";
+} from "./chunk-3h7ctayx.js";
 import {
   ActionRunError2,
   assertActionRunExecution2
-} from "./chunk-vsj3mdfj.js";
+} from "./chunk-fc5zfxy1.js";
 import {
   ObjectReadLimitExceededError2,
   snapshotObjectReadExecutionLimits2,
   assertObjectReadFacetCount2,
   assertObjectReadOutputWithinLimit2
-} from "./chunk-dz5h08xv.js";
+} from "./chunk-bbaa1fet.js";
 import {
   assertObjectReaderProject2
 } from "./chunk-v4jbb3rs.js";
@@ -24,9 +24,11 @@ import {
   paginate,
   InMemoryAuthStorage2,
   principalsEqual2
-} from "./chunk-g00bfdq6.js";
+} from "./chunk-2cxv584m.js";
 import {
   AgentStorageError2,
+  transitionAgentThreadSandbox2,
+  snapshotAgentThreadSandboxParams2,
   assertConversationAgentRunSpec2,
   assertAgentRunExecution2,
   assertCreateSubagentRunInput2,
@@ -37,7 +39,7 @@ import {
   assertAgentContextCheckpointAnchors2,
   assertAgentContextCheckpointReplayState2,
   agentContextCheckpointMatchesCreateInput2
-} from "./chunk-7bs40fe1.js";
+} from "./chunk-69266efg.js";
 import {
   InMemoryAiUsageStorage2,
   buildAiAccountingOverview,
@@ -46,7 +48,7 @@ import {
   buildAiModelCallGroups,
   normalizeAiModelCallCostRecord2,
   aiModelCallCostMatchesUsage2
-} from "./chunk-g53f0e4j.js";
+} from "./chunk-xnx96gfy.js";
 import {
   AiLimitStorageError2,
   aiLimitCalendarMonth2,
@@ -87,24 +89,14 @@ import {
   canRequeueSyncRunAfterEnqueueFailure2,
   createTransactionStorageProxy2,
   throwNestedStorageTransaction2
-} from "./chunk-8vj0rjgs.js";
+} from "./chunk-wjffn5m4.js";
 import {
   ExecutionStorageError2,
   prepareExecutionRecord2,
   cloneExecutionRecord
-} from "./chunk-93csa55g.js";
-import {
-  objectRefKey2,
-  linkRefKey2,
-  projectionEntityKey2,
-  telemetryPointKey2,
-  objectRefSortKey2,
-  linkRefSortKey2,
-  linkScopeKey,
-  linkScopeSortKey2,
-  telemetryPointSortKey2
-} from "./chunk-c5rkjrgp.js";
+} from "./chunk-axndsymr.js";
 import {
+  sha256Canonical2,
   createEventId2,
   assertTimestamp2,
   invalidCorrelation2,
@@ -133,7 +125,18 @@ import {
   assertSourceStagedRow2,
   isExactStagingManifest2,
   sourceConflict2
-} from "./chunk-gqh45d2n.js";
+} from "./chunk-hkw8rykk.js";
+import {
+  objectRefKey2,
+  linkRefKey2,
+  projectionEntityKey2,
+  telemetryPointKey2,
+  objectRefSortKey2,
+  linkRefSortKey2,
+  linkScopeKey,
+  linkScopeSortKey2,
+  telemetryPointSortKey2
+} from "./chunk-7ytf06d3.js";
 import {
   createStorageOperationScope2,
   createOperationScopedFacade2,
@@ -142,7 +145,7 @@ import {
   createOntologyOperationScope2,
   createObjectOperationScope2,
   createWorkflowRunOperationScope2
-} from "./chunk-z30bv4ga.js";
+} from "./chunk-yxb4c62x.js";
 import {
   PipelineRunError2,
   assertPipelineRunExecution2
@@ -175,7 +178,7 @@ import {
   assertProjectionMissingTarget2,
   requireTelemetryProjectionRun2,
   assertProjectionRunDurableExecution2
-} from "./chunk-358caqf5.js";
+} from "./chunk-bfjv1adk.js";
 import {
   SyncRunError2,
   assertSyncRunExecution2
@@ -188,7 +191,7 @@ import {
   WorkflowRunError2,
   assertWorkflowRunExecution2,
   assertWorkflowAgentNodeRunExecution2
-} from "./chunk-pr2h4bv4.js";
+} from "./chunk-tg4g4zh0.js";
 import {
   ShareGrantStorageError2,
   normalizeShareGrantCreate2,
@@ -213,11 +216,11 @@ import {
 } from "./chunk-2c4j899j.js";
 import {
   assertPinnedDatasetWatermark2
-} from "./chunk-wjasrj67.js";
+} from "./chunk-3qpcrcj8.js";
 import {
   MaterializationValidationError2,
   MaterializationConflictError2
-} from "./chunk-yv79ncbv.js";
+} from "./chunk-96yw3pwd.js";
 import {
   AGENT_RUN_FAILURE_CODES2
 } from "./chunk-98cw09sw.js";
@@ -517,7 +520,7 @@ function normalizeFailure(failure) {
   return failure ? parseSixbFailure2(failure, AGENT_RUN_FAILURE_CODES2) : undefined;
 }
 function key(projectId, id) {
-  return `${projectId}:${id}`;
+  return JSON.stringify([projectId, id]);
 }
 function clone(value) {
   return structuredClone(value);
@@ -544,7 +547,18 @@ class InMemoryAgentThreadStore {
   constructor(state) {
     this.state = state;
   }
+  async transitionSandbox(input) {
+    const threadKey = key(input.projectId, input.id);
+    const thread = this.state.threads.get(threadKey) ?? null;
+    const run = input.action === "recreate" ? null : this.state.runs.get(key(input.projectId, input.runId)) ?? null;
+    const sandboxState = transitionAgentThreadSandbox2(thread, run, input);
+    if (!thread)
+      throw new AgentStorageError2("thread_not_found", "[Sixb] Thread not found.");
+    this.state.threads.set(threadKey, { ...thread, sandboxState: clone(sandboxState) });
+    return clone(sandboxState);
+  }
   async create(input) {
+    const sandboxParams = input.sandboxParams === undefined ? undefined : snapshotAgentThreadSandboxParams2(input.sandboxParams);
     const threadKey = key(input.projectId, input.id);
     if (this.state.threads.has(threadKey)) {
       throw new AgentStorageError2("duplicate_id", `[Sixb] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
@@ -554,6 +568,7 @@ class InMemoryAgentThreadStore {
       id: input.id,
       projectId: input.projectId,
       ownerPrincipal: clone(input.ownerPrincipal),
+      ...sandboxParams === undefined ? {} : { sandboxParams },
       ...input.title === undefined ? {} : { title: input.title },
       status: input.status ?? "active",
       activeRunId: null,
@@ -1794,6 +1809,9 @@ class InMemoryConnectorConnectionStorage2 {
     this.connectionRuns.set(run.id, finished);
     return structuredClone(finished);
   }
+  async listPendingConnectionRuns(input) {
+    return [...this.connectionRuns.values()].filter((run) => run.projectId === input.projectId && run.connectorId === input.connectorId && (run.status === "running" || run.status === "waiting" && run.waitingFor === "account_selection")).map((run) => structuredClone(run));
+  }
   async getConnectionRun(input) {
     const run = this.currentConnectionRun(input.runId);
     return sameConnectionRunScope(run, input) ? structuredClone(run) : null;
@@ -2105,21 +2123,10 @@ class InMemoryConnectorConnectionStorage2 {
     return { ...result, run: structuredClone(succeeded) };
   }
   putConnectionNow(input, now) {
-    let authorization = this.authorizations.get(input.authorizationId);
+    const authorization = this.authorizations.get(input.authorizationId);
     if (!sameAuthorizationScope(authorization, input) || !isSelectable(authorization.status) || authorization.credentialMutation?.kind === "reauthorization") {
       throw authorizationConflict();
     }
-    if (authorization.status === "pending_selection" && authorization.selectionExpiresAt.getTime() <= now.getTime()) {
-      authorization = {
-        ...authorization,
-        status: "revocation_pending",
-        selectionExpiresAt: undefined,
-        revision: authorization.revision + 1,
-        updatedAt: now
-      };
-      this.authorizations.set(authorization.id, authorization);
-      throw authorizationConflict();
-    }
     const account = authorization.accounts.find((candidate) => candidate.id === input.account.id);
     if (!account) {
       throw new ConnectorConnectionStorageError2("authorization_conflict", "[Sixb] Connector connection account is not exposed by its authorization.");
@@ -2257,6 +2264,8 @@ class InMemoryConnectorConnectionStorage2 {
     const run = this.connectionRuns.get(runId);
     if (!run || run.status !== "waiting" && run.status !== "running")
       return run;
+    if (run.status === "waiting" && run.waitingFor === "account_selection")
+      return run;
     const now = this.now();
     if (run.expiresAt.getTime() > now.getTime())
       return run;
@@ -2266,9 +2275,6 @@ class InMemoryConnectorConnectionStorage2 {
         this.attempts.delete(attempt.id);
     }
     if (run.status === "waiting") {
-      if (run.kind === "connect" && run.waitingFor === "account_selection") {
-        this.markPendingAuthorizationForCleanup(run.connectorId, run.authorizationId, now);
-      }
       const expired = expireConnectionRun(run, now);
       this.connectionRuns.set(run.id, expired);
       return expired;
@@ -2594,6 +2600,25 @@ class InMemoryExecutionStorage {
   }
 }
 
+// src/objects/vectors/query.ts
+function hasVectorProfile2(query) {
+  if (query.kind === "vector")
+    return true;
+  if (query.kind === "set")
+    return query.inputs.some(hasVectorProfile2);
+  return "input" in query && hasVectorProfile2(query.input);
+}
+function isVectorProfileQuery2(query) {
+  if (query.kind === "limit" || query.kind === "project")
+    return isVectorProfileQuery2(query.input);
+  if (query.kind !== "vector" || !query.profile)
+    return false;
+  let input = query.input;
+  while (input.kind === "filter")
+    input = input.input;
+  return input.kind === "start" && !input.includeSubtypes;
+}
+
 // src/storage/objects/keys.ts
 function objectBatchKey2(objectTypeId, primaryId) {
   return JSON.stringify([objectTypeId, primaryId]);
@@ -2734,6 +2759,54 @@ function compareStrings2(left, right) {
   return 0;
 }
 
+// src/objects/vectors/profile.ts
+var MAX_VECTOR_K = 1000;
+var VECTOR_INPUT_VERSION = 1;
+function vectorConfiguration(profile) {
+  return sha256Canonical2({
+    format: VECTOR_INPUT_VERSION,
+    sources: [...profile.source],
+    provider: profile.model.providerId,
+    model: profile.model.modelId,
+    representation: profile.model.definition.representation ?? { name: profile.model.modelId },
+    dimensions: profile.model.definition.dimensions,
+    metric: "cosine",
+    precision: "float32",
+    normalization: "l2-v1"
+  });
+}
+function vectorSources(source, properties) {
+  const values = Object.create(null);
+  for (const key of source) {
+    const value = properties[key];
+    if (value !== undefined && value !== null && typeof value !== "string") {
+      throw new MaterializationValidationError2(`Vector source must be text: ${key}`);
+    }
+    values[key] = typeof value === "string" ? value : null;
+  }
+  const text = JSON.stringify(source.map((key) => [key, values[key]]));
+  return { text, sourceFingerprint: sha256Canonical2(text) };
+}
+function normalizeVector2(values, dimensions) {
+  if (!Array.isArray(values) || values.length !== dimensions) {
+    throw new MaterializationValidationError2(`Vector dimension mismatch; expected ${dimensions}`);
+  }
+  const normalized = Array.from(values, (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isFinite(Math.fround(value))) {
+      throw new MaterializationValidationError2("Vector values must be finite float32 numbers.");
+    }
+    return Math.fround(value);
+  });
+  if (!normalized.some((value) => value !== 0)) {
+    throw new MaterializationValidationError2("Cosine search requires a nonzero vector.");
+  }
+  const norm = Math.hypot(...normalized);
+  return Object.freeze(normalized.map((value) => Math.fround(value / norm)));
+}
+function vectorSearchCandidateLimit2(dimensions) {
+  return Math.min(1e4, Math.floor(16000000 / dimensions));
+}
+
 // src/storage/objects/in-memory/query.ts
 var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   queryObjects: true,
@@ -2821,17 +2894,23 @@ function evaluateObjectQuery(query, source) {
       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": {
@@ -3110,9 +3189,6 @@ function compareSortField(left, right, field) {
     return 0;
   return field.direction === "desc" ? -comparison : comparison;
 }
-function compareEntriesByRelevance(left, right) {
-  return right.score - left.score || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row));
-}
 function projectRow(row, properties) {
   const projected = {};
   for (const propertyId of properties) {
@@ -3355,9 +3431,10 @@ function resolveSelectedReadUniverse(source, plan, limits) {
     }
     links.set(key, redactLinkRow(selected.row, selected.propertyIds));
   }
-  return createReadUniverse(source.projectId, objects, links, objectProperties);
+  return createReadUniverse(source, objects, links, objectProperties);
 }
-function createReadUniverse(projectId, objects, links, objectProperties) {
+function createReadUniverse(source, objects, links, objectProperties) {
+  const projectId = source.projectId;
   const linksBySource = new Map;
   for (const link of links.values()) {
     const key = sourceLinkBucketKey(link.projectId, link.sourceTypeId, link.sourceId);
@@ -3371,6 +3448,13 @@ function createReadUniverse(projectId, objects, links, objectProperties) {
     links,
     linksBySource,
     objectProperties,
+    getVector: (ref, profile) => {
+      const key = rowIdentityKeyParts(ref.objectTypeId, ref.primaryId);
+      if (!objects.has(key))
+        return;
+      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) => objects.get(rowIdentityKeyParts(objectTypeId, primaryId)),
     outgoingLinks: (objectTypeId, primaryId) => linksBySource.get(sourceLinkBucketKey(projectId, objectTypeId, primaryId)) ?? [],
@@ -3434,7 +3518,10 @@ function createInMemorySelectedReader(source, params, queryCapabilities) {
       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),
+          ...hasVectorProfile2(input.query) ? { score: entry.score } : {}
+        })),
         hasMore: result.hasMore,
         nextPageToken: result.nextPageToken,
         ...input.includeTotal === false ? {} : { total: result.total }
@@ -3562,8 +3649,12 @@ function getInMemoryObjectMaterializerAdapter(storage) {
 class InMemoryObjectStorage {
   rows = new Map;
   links = new Map;
+  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),
       applyExactObject: (row, projectId) => this.applyExactObject(row, projectId),
@@ -3660,6 +3751,7 @@ class InMemoryObjectStorage {
   readSource(projectId) {
     return {
       projectId,
+      getVector: (ref, profile) => this.vectorReader?.(projectId, ref, profile),
       objectsOfType: (objectTypeId) => [
         ...this.rows.get(objectRowKey(projectId, objectTypeId))?.values() ?? []
       ],
@@ -3671,7 +3763,10 @@ class InMemoryObjectStorage {
   async queryObjects(params) {
     const result = evaluateObjectQuery(params.query, this.readSource(params.projectId));
     return {
-      objects: result.entries.map((entry) => entry.row),
+      objects: result.entries.map((entry) => ({
+        ...entry.row,
+        ...hasVectorProfile2(params.query) ? { score: entry.score } : {}
+      })),
       hasMore: result.hasMore,
       nextPageToken: result.nextPageToken,
       ...params.includeTotal === false ? {} : { total: result.total }
@@ -3863,6 +3958,8 @@ function* allLinkRows(buckets) {
 // src/storage/ontology/in-memory/shared-state.ts
 function createInMemoryOntologyState() {
   return {
+    vectors: new Map,
+    vectorIndexing: new Map,
     commitsById: new Map,
     commitIdByIdempotency: new Map,
     commitIdByOrigin: new Map,
@@ -3940,10 +4037,20 @@ function restoreOntologyState(target, snapshot) {
   }
 }
 function insertBounded(values, value, limit, compare) {
-  let index = values.findIndex((candidate) => compare(value, candidate) < 0);
-  if (index < 0)
-    index = values.length;
-  values.splice(index, 0, value);
+  if (limit <= 0)
+    return;
+  if (values.length >= limit && compare(value, values[values.length - 1]) >= 0)
+    return;
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (compare(value, values[middle]) < 0)
+      high = middle;
+    else
+      low = middle + 1;
+  }
+  values.splice(low, 0, value);
   if (values.length > limit)
     values.pop();
 }
@@ -5139,6 +5246,12 @@ class InMemoryOntologyMaterializationStorage {
     this.releaseSession(session);
     return { commit: structuredClone(record) };
   }
+  assertVectorSession(session, projectId, commitId) {
+    const active = this.requireSession(session);
+    if (active.header.commit.projectId !== projectId || commitId !== undefined && active.header.commit.id !== commitId) {
+      throw new MaterializationValidationError2("Vector mutation does not belong to this materialization session.");
+    }
+  }
   requireSession(session) {
     const value = this.sessions.get(session.providerToken);
     if (!value || !value.active || !this.getTransactionToken() || this.getTransactionToken() !== value.transactionToken) {
@@ -5999,9 +6112,188 @@ function registerInMemoryOntologyStorageTestingAdapter(storage, adapter) {
   testingAdapters.set(storage, adapter);
 }
 
+// src/storage/ontology/in-memory/vector-indexing.ts
+class InMemoryVectorIndexingStorage {
+  state;
+  assertSession;
+  run;
+  constructor(state, assertSession, run) {
+    this.state = state;
+    this.assertSession = assertSession;
+    this.run = run;
+  }
+  async schedule(input) {
+    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) {
+    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) {
+    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) {
+    return this.run(() => structuredClone([...this.state.values()].find((work) => work.projectId === input.projectId && work.id === input.id) ?? null));
+  }
+  async getBatch(input) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    await this.run(() => {
+      for (const [key, work] of this.state)
+        if (work.projectId === input.projectId && work.id === input.id)
+          this.state.delete(key);
+    });
+  }
+}
+
+// src/storage/ontology/in-memory/vectors.ts
+function vectorObjectKey(projectId, ref) {
+  return JSON.stringify([projectId, ref.objectTypeId, ref.primaryId]);
+}
+
+class InMemoryOntologyVectorStorage {
+  state;
+  assertSession;
+  runRootOperation;
+  constructor(state, assertSession, runRootOperation) {
+    this.state = state;
+    this.assertSession = assertSession;
+    this.runRootOperation = runRootOperation;
+  }
+  async list(input) {
+    return this.listBatch({ projectId: input.projectId, refs: [input.ref] });
+  }
+  async listBatch(input) {
+    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) {
+    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) {
+    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;
+    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) {
+    for (const entry of input.entries) {
+      await this.write({ session: input.session, projectId: input.projectId, ...entry });
+    }
+  }
+  async remove(input) {
+    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);
+  }
+  assertRevision(current, expected) {
+    if ((current?.lastCommitId ?? null) !== expected) {
+      throw new MaterializationConflictError2("effective-state", "Vector changed since it was prepared.");
+    }
+  }
+}
+
 // src/storage/ontology/in-memory/index.ts
 class InMemoryOntologyStorage {
   state = createInMemoryOntologyState();
+  vectorIndexing;
+  vectors;
   commits;
   sources;
   materializations;
@@ -6012,6 +6304,9 @@ class InMemoryOntologyStorage {
     snapshot: () => this.snapshot()
   };
   constructor(objects, timeseries, options) {
+    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, options.runRootOperation, options.assertSourceMaterializationExecution);
     this.outbox = new InMemoryOntologyOutboxStorage(this.state, options.runRootOperation);
@@ -8319,6 +8614,13 @@ function assertAppliedPrefix(migrations, rows) {
   }
   return [...rows].sort((a, b) => a.version - b.version);
 }
-export { InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, FileUploadSessionError2, InMemoryFileUploadSessions2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2 };
+// src/storage/ontology/vector-indexing.ts
+var VECTOR_INDEXING_FAILURE_CODES2 = [
+  "vector.model_unavailable",
+  "vector.response_invalid",
+  "vector.outcome_unknown",
+  "internal.unexpected"
+];
+export { InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, FileUploadSessionError2, InMemoryFileUploadSessions2, hasVectorProfile2, isVectorProfileQuery2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, MAX_VECTOR_K, vectorConfiguration, vectorSources, normalizeVector2, vectorSearchCandidateLimit2, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2, VECTOR_INDEXING_FAILURE_CODES2 };
 
-//# debugId=E15B3DF7CD823E3C64756E2164756E21
+//# debugId=4C175241D0B9EA3264756E2164756E21