Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

3.5 KB
Raw Blame
import { unitVector, type MemoryEmbedder } from "../model/embeddings.ts";
import type { LeaderLease } from "../persistence/leader-lease.ts";
import { reportFailure } from "../util/errors.ts";
import type { MemoryVectorStore } from "./postgres-vector-store.ts";

export function createMemoryVectorIndexer(opts: {
  resolve: () => Promise<
    { embedder: MemoryEmbedder; store: Pick<MemoryVectorStore, "missing" | "put" | "prune"> } | undefined
  >;
  leaderLease: LeaderLease;
  onError?: (error: unknown) => void;
  now?: () => number;
}) {
  const onError = opts.onError ?? ((error: unknown) => reportFailure("memory vector index", error));
  let pending: Promise<void> | undefined;
  let active: AbortController | undefined;
  let model: string | undefined;
  let dimensions: number | undefined;
  let afterId: string | undefined;
  let nextProbeAt = 0;
  async function run(): Promise<void> {
    const controller = (active = new AbortController());
    await opts.leaderLease.hold("memory:vector-index", async (lost) => {
      const current = await opts.resolve();
      if (!current) return;
      void lost.then(() => controller.abort());
      const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(60_000)]);
      signal.throwIfAborted();
      const { embedder, store } = current;
      const now = (opts.now ?? Date.now)();
      if (model !== embedder.id || dimensions === undefined || now >= nextProbeAt) {
        const probe = await embedder.embed(["Memory index dimension probe."], signal);
        if (probe.length !== 1) throw new Error("Invalid memory index dimension probe");
        const width = unitVector(probe[0]).length;
        if (width > 16000) throw new Error("Memory embedding exceeds pgvector dimensions");
        if (model !== embedder.id || dimensions !== width) afterId = undefined;
        model = embedder.id;
        dimensions = width;
        nextProbeAt = now + 10 * 60_000;
      }
      try {
        do {
          signal.throwIfAborted();
          const facts = await store.missing(embedder.id, 64, dimensions, signal, afterId);
          afterId = facts.at(-1)?.factId;
          if (!facts.length) break;
          const vectors = await embedder.embed(
            facts.map((fact) => fact.text.slice(0, 8000)),
            signal,
          );
          if (vectors.length !== facts.length) throw new Error("Invalid memory index embedding count");
          const rows = facts.map((fact, i) => ({
            scope: fact.scope,
            factId: fact.factId,
            hash: fact.hash,
            model: embedder.id,
            vector: unitVector(vectors[i]),
          }));
          if (rows.some((row) => row.vector.length !== dimensions)) {
            dimensions = undefined;
            nextProbeAt = 0;
            afterId = undefined;
            throw new Error("Memory embedding dimensions changed during indexing");
          }
          signal.throwIfAborted();
          await store.put(rows, signal);
          if (facts.length < 64) break;
        } while ((opts.now ?? Date.now)() - now < 20_000);
      } finally {
        if (!signal.aborted) await store.prune(embedder.id, 200, dimensions, signal).catch(onError);
      }
    });
  }
  return {
    stop(): Promise<void> {
      active?.abort();
      return pending ?? Promise.resolve();
    },
    tick(): Promise<void> {
      pending ??= run()
        .catch(onError)
        .finally(() => {
          pending = undefined;
          active = undefined;
        });
      return pending;
    },
  };
}