Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

6.1 KB
Raw Blame
import type { PoolClient } from "pg";
import { createPgPool, withPgTransaction } from "../persistence/pg-pool.ts";
import { checkRuleSet, type DecisionHook, type DecisionProvider, type DecisionRule } from "./decisions.ts";

interface DecisionWriter {
  actorId: string;
}

export interface DecisionStore {
  providers(ids?: readonly string[]): Promise<DecisionProvider[]>;
  rules(hook?: DecisionHook): Promise<DecisionRule[]>;
  saveProvider(provider: DecisionProvider, by: DecisionWriter): Promise<void>;
  removeProvider(id: string): Promise<void>;
  saveRule(rule: DecisionRule, by: DecisionWriter): Promise<void>;
  removeRule(id: string): Promise<void>;
}

const SCHEMA = [
  `CREATE TABLE IF NOT EXISTS decision_providers(
    provider_id TEXT   PRIMARY KEY,
    protocol    TEXT   NOT NULL,
    base_url    TEXT,
    credential  TEXT,
    updated_by  TEXT   NOT NULL,
    updated_at  BIGINT NOT NULL
  )`,
  `CREATE TABLE IF NOT EXISTS decision_rules(
    rule_id     TEXT    PRIMARY KEY,
    hook        TEXT    NOT NULL,
    question    TEXT    NOT NULL,
    options     JSON    NOT NULL,
    provider_id TEXT    NOT NULL REFERENCES decision_providers(provider_id),
    model       TEXT    NOT NULL,
    mode        TEXT    NOT NULL CHECK (mode IN ('off', 'observe', 'enforce')),
    on_error    TEXT    NOT NULL,
    updated_by  TEXT    NOT NULL,
    updated_at  BIGINT  NOT NULL
  )`,
  `CREATE INDEX IF NOT EXISTS decision_rules_hook ON decision_rules (hook) WHERE mode <> 'off'`,
];

const toRule = (r: Record<string, unknown>): DecisionRule => ({
  id: r.rule_id as string,
  hook: r.hook as DecisionHook,
  question: r.question as string,
  options: r.options as DecisionRule["options"],
  model: { provider: r.provider_id as string, model: r.model as string },
  mode: r.mode as DecisionRule["mode"],
  onError: r.on_error as string,
});

const RULES = "SELECT * FROM decision_rules";
const CACHE_MS = 10_000;
const MAX_STORED_RULES = 100;
const MAX_PROVIDERS = 20;

export function createPostgresDecisionStore(connectionString: string): DecisionStore {
  const { q, pool } = createPgPool(connectionString, "decisions/0001", SCHEMA);
  const active = new Map<DecisionHook, { at: number; rules: Promise<DecisionRule[]> }>();
  let known: { at: number; providers: Promise<DecisionProvider[]> } | undefined;
  const write = async (fn: (db: PoolClient) => Promise<unknown>) => {
    await withPgTransaction(await pool(), async (db) => {
      await db.query("LOCK TABLE decision_rules IN SHARE ROW EXCLUSIVE MODE");
      await fn(db);
    });
    active.clear();
    known = undefined;
  };
  return {
    async providers(ids) {
      if (!known || Date.now() - known.at >= CACHE_MS) {
        const providers = q("SELECT * FROM decision_providers ORDER BY provider_id").then((rows) =>
          rows.map((r) => ({
            id: r.provider_id as string,
            protocol: r.protocol as DecisionProvider["protocol"],
            ...(r.base_url ? { baseUrl: r.base_url as string, credential: r.credential as string } : {}),
          })),
        );
        known = { at: Date.now(), providers };
        providers.catch(() => (known = undefined));
      }
      const all = await known.providers;
      return ids ? all.filter((p) => ids.includes(p.id)) : all;
    },
    async rules(hook) {
      if (!hook) return (await q(`${RULES} ORDER BY rule_id`)).map(toRule);
      const hit = active.get(hook);
      if (hit && Date.now() - hit.at < CACHE_MS) return hit.rules;
      const rules = q(`${RULES} WHERE hook = $1 AND mode <> 'off' ORDER BY rule_id`, [hook]).then((r) => r.map(toRule));
      active.set(hook, { at: Date.now(), rules });
      rules.catch(() => active.delete(hook));
      return rules;
    },
    saveProvider: (p, by) =>
      write(async (db) => {
        const { rows } = await db.query("SELECT count(*)::int AS n FROM decision_providers WHERE provider_id <> $1", [
          p.id,
        ]);
        if (rows[0].n >= MAX_PROVIDERS)
          throw new Error(`at most ${MAX_PROVIDERS} decision providers; remove one first`);
        await db.query(
          `INSERT INTO decision_providers (provider_id, protocol, base_url, credential, updated_by, updated_at)
           VALUES ($1, $2, $3, $4, $5, $6)
           ON CONFLICT (provider_id) DO UPDATE SET protocol = $2, base_url = $3, credential = $4, updated_by = $5, updated_at = $6`,
          [p.id, p.protocol, p.baseUrl ?? null, p.credential ?? null, by.actorId, Date.now()],
        );
      }),
    async removeProvider(id) {
      try {
        await write((db) => db.query("DELETE FROM decision_providers WHERE provider_id = $1", [id]));
      } catch (error) {
        if ((error as { code?: string }).code === "23503")
          throw new Error(`decision provider ${id} is still used by a rule`, { cause: error });
        throw error;
      }
    },
    saveRule: (rule, by) =>
      write(async (db) => {
        const { rows } = await db.query("SELECT count(*)::int AS n FROM decision_rules WHERE rule_id <> $1", [rule.id]);
        if (rows[0].n >= MAX_STORED_RULES)
          throw new Error(`at most ${MAX_STORED_RULES} decision rules; remove one first`);
        const others = await db.query(`${RULES} WHERE rule_id <> $1 AND mode <> 'off' ORDER BY rule_id`, [rule.id]);
        const error = checkRuleSet([...others.rows.map(toRule), rule]);
        if (error) throw new Error(error);
        await db.query(
          `INSERT INTO decision_rules
             (rule_id, hook, question, options, provider_id, model, mode, on_error, updated_by, updated_at)
           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
           ON CONFLICT (rule_id) DO UPDATE SET hook = $2, question = $3, options = $4, provider_id = $5, model = $6,
             mode = $7, on_error = $8, updated_by = $9, updated_at = $10`,
          [
            rule.id,
            rule.hook,
            rule.question,
            JSON.stringify(rule.options),
            rule.model.provider,
            rule.model.model,
            rule.mode,
            rule.onError,
            by.actorId,
            Date.now(),
          ],
        );
      }),
    removeRule: (id) => write((db) => db.query("DELETE FROM decision_rules WHERE rule_id = $1", [id])),
  };
}