okengine 0.21.1 → 0.23.0

package/src/drivers/ai-stream.test.ts

@@ -6,6 +6,7 @@ import { describe, expect, test } from "bun:test";
 import { withAbortSignal } from "../kernel/abort-scope.ts";
 import { createFx, createFxContext } from "../kernel/fx.ts";
 import { ai, createAiRuntime } from "../elements/ai.ts";
+import { openAnthropic } from "./ai-anthropic.ts";
 import { openOpenaiCompatible } from "./ai-openai-compatible.ts";
 import { mockAiDriver } from "./ai-mock.ts";
 
@@ -44,6 +45,29 @@ describe("openai-compatible SSE stream", () => {
       if (chunk.text) parts.push(chunk.text);
     }
     expect(parts.join("")).toBe("Hello");
+    const bodies: unknown[] = [];
+    const formatFetch = Object.assign(
+      async (_input: string | URL | Request, init?: RequestInit) => {
+        bodies.push(JSON.parse(String(init?.body)));
+        return new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } });
+      },
+      { preconnect: () => {} },
+    ) as typeof fetch;
+    const formatted = await openOpenaiCompatible({
+      apiKey: "sk-test",
+      baseUrl: "https://example.test/v1",
+      fetch: formatFetch,
+    });
+    for await (const _chunk of formatted.stream!({
+      messages: [{ role: "user", content: "hi" }],
+      responseFormat: {
+        type: "json_schema",
+        json_schema: { name: "out", schema: { type: "object" } },
+      },
+    })) {
+      // drain
+    }
+    expect(bodies[0]).toMatchObject({ response_format: { type: "json_object" } });
 
     const ac = new AbortController();
     const iter = client.stream!({
@@ -58,6 +82,44 @@ describe("openai-compatible SSE stream", () => {
   });
 });
 
+describe("anthropic messages stream", () => {
+  test("text deltas, input_json_delta, and message_delta usage", async () => {
+    const sse = [
+      'data: {"type":"message_start","message":{"usage":{"input_tokens":4,"output_tokens":1}}}',
+      'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Ok"}}',
+      'data: {"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"toolu_1","name":"orders.get","input":{}}}',
+      'data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\\"id\\":"}}',
+      'data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"\\"14\\"}"}}',
+      'data: {"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{"output_tokens":6}}',
+      'data: {"type":"message_stop"}',
+      "",
+    ].join("\n");
+    const fetchFn = Object.assign(
+      async () =>
+        new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } }),
+      { preconnect: () => {} },
+    ) as typeof fetch;
+    const client = await openAnthropic({
+      apiKey: "sk-test",
+      fetch: fetchFn,
+    });
+    const texts: string[] = [];
+    const args: string[] = [];
+    let usage: { inputTokens?: number; outputTokens?: number } | undefined;
+    for await (const chunk of client.stream!({
+      messages: [{ role: "user", content: "status" }],
+      tools: [{ name: "orders.get" }],
+    })) {
+      if (chunk.text) texts.push(chunk.text);
+      if (chunk.toolCall?.argumentsDelta) args.push(chunk.toolCall.argumentsDelta);
+      if (chunk.usage) usage = chunk.usage;
+    }
+    expect(texts.join("")).toBe("Ok");
+    expect(args.join("")).toBe('{"id":"14"}');
+    expect(usage).toEqual({ inputTokens: 4, outputTokens: 6 });
+  });
+});
+
 describe("fx.stream uses ambient AbortSignal", () => {
   test("race abort cancels in-flight stream fetch", async () => {
     let sawAbort = false;

package/src/drivers/ai-types.ts

@@ -66,10 +66,30 @@ export interface AiCompleteResult {
   readonly external?: DriverExternal;
 }
 
+/** One tool-call fragment inside a model stream. */
+export interface AiStreamToolCallDelta {
+  /** Provider index for this call within the turn. */
+  readonly index: number;
+  readonly id?: string;
+  readonly name?: string;
+  /** Partial JSON arguments. Empty when the call is only announced. */
+  readonly argumentsDelta?: string;
+}
+
 /** One streamed token / delta from a model. */
 export interface AiStreamChunk {
   readonly text: string;
   readonly done?: boolean;
+  readonly toolCall?: AiStreamToolCallDelta;
+  readonly usage?: {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cost?: number;
+  };
+  /** Provider payload. Present on the terminal chunk when the driver has one. */
+  readonly raw?: unknown;
+  /** Egress identity, matching {@link AiCompleteResult.external}. */
+  readonly external?: DriverExternal;
 }
 
 /** Embedding request. */

package/src/drivers/journal-postgres.ts

@@ -7,6 +7,22 @@
  * completed journal steps replay instead of re-running).
  */
 
+import {
+  createPostgresIdempotencyStore,
+  IDEM_ATTACH_SQL,
+  IDEM_COMPLETE_SQL,
+  IDEM_DELETE_EXPIRED_ONE_SQL,
+  IDEM_FORFEIT_SQL,
+  IDEM_INSERT_SQL,
+  IDEM_PURGE_SQL,
+  IDEM_RECLAIM_SQL,
+  IDEM_REMOVE_SQL,
+  IDEM_RENEW_SQL,
+  IDEM_SELECT_SQL,
+} from "../kernel/idempotency-store.ts";
+import type { DecisionLabelStore } from "../kernel/decision-label-store.ts";
+import type { AgentEventStore } from "../kernel/agent-event-store.ts";
+import { lazyRequire } from "../kernel/lazy-require.ts";
 import {
   JOURNAL_DEFAULT_LEASE_MS,
   type JournalEntry,
@@ -199,6 +215,26 @@ async function ensureSchema(sql: PostgresJournalSql): Promise<void> {
   await sql.exec(
     `CREATE INDEX IF NOT EXISTS oke_journal_runs_lease ON oke_journal_runs (status, lease_expires_at)`,
   );
+  await sql.exec(`CREATE TABLE IF NOT EXISTS oke_idempotency (
+    tenant TEXT NOT NULL DEFAULT '',
+    principal TEXT NOT NULL,
+    flow TEXT NOT NULL,
+    key TEXT NOT NULL,
+    fingerprint TEXT NOT NULL,
+    status TEXT NOT NULL,
+    claim_token TEXT NOT NULL,
+    lease_expires_at BIGINT NOT NULL,
+    run_id TEXT,
+    response_status INTEGER,
+    response_headers TEXT,
+    response_body TEXT,
+    created_at BIGINT NOT NULL,
+    expires_at BIGINT NOT NULL,
+    PRIMARY KEY (tenant, principal, flow, key)
+  )`);
+  await sql.exec(
+    `CREATE INDEX IF NOT EXISTS oke_idempotency_expires ON oke_idempotency (expires_at)`,
+  );
 }
 
 /**
@@ -208,9 +244,63 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
   /** Force-kill mid-transaction (drops uncommitted state). */
   killActiveTransaction(): void;
 } {
-  type State = { rows: JournalDbRow[] };
+  type IdemDbRow = {
+    tenant: string;
+    principal: string;
+    flow: string;
+    key: string;
+    fingerprint: string;
+    status: string;
+    claim_token: string;
+    lease_expires_at: number;
+    run_id: string | null;
+    response_status: number | null;
+    response_headers: string | null;
+    response_body: string | null;
+    created_at: number;
+    expires_at: number;
+  };
+  type LabelDbRow = {
+    decision_id: string;
+    question: string;
+    value: string;
+    propensity: number;
+    reviewer: string;
+    locale: string | null;
+    model: string | null;
+    tenant: string | null;
+    score: number | null;
+    loss: number | null;
+    raw: string | null;
+    at: number;
+    input: string | null;
+    review_id?: string | null;
+  };
+  type State = {
+    rows: JournalDbRow[];
+    idem: IdemDbRow[];
+    labels: LabelDbRow[];
+    drift: { decision_id: string; suspended: number; certified_at: number }[];
+    candidates: { decision_id: string; body: string }[];
+    agentRuns: { run_id: string; header: string; sweep_claim_at: number | null }[];
+    agentEvents: {
+      run_id: string;
+      seq: number;
+      event: string;
+      event_type: string | null;
+      event_name: string | null;
+    }[];
+  };
 
-  let committed: State = { rows: [] };
+  let committed: State = {
+    rows: [],
+    idem: [],
+    labels: [],
+    drift: [],
+    candidates: [],
+    agentRuns: [],
+    agentEvents: [],
+  };
   let active: { state: State; locked: Set<string>; done: boolean } | null = null;
   /** Run ids held by other active transactions (SKIP LOCKED). */
   const heldByTxn = new Set<string>();
@@ -222,7 +312,24 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
   }
 
   function cloneState(s: State): State {
-    return { rows: s.rows.map((r) => ({ ...r })) };
+    return {
+      rows: s.rows.map((r) => ({ ...r })),
+      idem: s.idem.map((r) => ({ ...r })),
+      labels: s.labels.map((r) => ({ ...r })),
+      drift: s.drift.map((r) => ({ ...r })),
+      candidates: s.candidates.map((r) => ({ ...r })),
+      agentRuns: s.agentRuns.map((r) => ({ ...r })),
+      agentEvents: s.agentEvents.map((r) => ({ ...r })),
+    };
+  }
+
+  function idemPk(row: IdemDbRow, params: readonly unknown[], offset = 0): boolean {
+    return (
+      row.tenant === String(params[offset]) &&
+      row.principal === String(params[offset + 1]) &&
+      row.flow === String(params[offset + 2]) &&
+      row.key === String(params[offset + 3])
+    );
   }
 
   function claimable(r: JournalDbRow, holder: string, cutoff: number): boolean {
@@ -309,6 +416,71 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
         return state.rows.map((r) => ({ ...r }));
       }
 
+      if (text === IDEM_SELECT_SQL) {
+        return state.idem
+          .filter((row) => idemPk(row, params))
+          .map((row) => ({ ...row }) as Record<string, unknown>);
+      }
+
+      if (/FROM\s+oke_decision_labels/i.test(text)) {
+        let labels = state.labels;
+        let arg = 0;
+        if (/decision_id\s*=\s*\?/i.test(text)) {
+          const id = String(params[arg++] ?? "");
+          labels = labels.filter((row) => row.decision_id === id);
+        }
+        if (/tenant\s+IS\s+NOT\s+DISTINCT\s+FROM\s+\?/i.test(text)) {
+          const tenant = params[arg] ?? null;
+          labels = labels.filter((row) => row.tenant === tenant);
+        }
+        return labels.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_decision_drift/i.test(text)) {
+        return state.drift.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_decision_candidates/i.test(text)) {
+        if (/decision_id\s*=\s*\?/i.test(text)) {
+          const id = String(params[0] ?? "");
+          return state.candidates
+            .filter((row) => row.decision_id === id)
+            .map((row) => ({ ...row }));
+        }
+        return state.candidates.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_agent_run\b/i.test(text)) {
+        if (!/WHERE/i.test(text)) return state.agentRuns.map((row) => ({ ...row }));
+        const id = String(params[0] ?? "");
+        return state.agentRuns.filter((row) => row.run_id === id).map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_agent_event\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        if (/MAX\s*\(\s*seq\s*\)/i.test(text)) {
+          const max = state.agentEvents
+            .filter((row) => row.run_id === id)
+            .reduce((highest, row) => Math.max(highest, row.seq), 0);
+          return [{ max_seq: max }];
+        }
+        if (/event_type\s*=/i.test(text)) {
+          const eventType = String(params[1] ?? "");
+          const eventName = String(params[2] ?? "");
+          return state.agentEvents
+            .filter(
+              (row) =>
+                row.run_id === id && row.event_type === eventType && row.event_name === eventName,
+            )
+            .map((row) => ({ ...row }));
+        }
+        const after = /seq\s*>\s*\?/i.test(text) ? Number(params[1] ?? 0) : 0;
+        return state.agentEvents
+          .filter((row) => row.run_id === id && row.seq > after)
+          .sort((a, b) => a.seq - b.seq)
+          .map((row) => ({ ...row }));
+      }
+
       throw new Error(`postgres journal fake: unsupported query: ${sql}`);
     },
     async exec(sql, params = []) {
@@ -388,6 +560,209 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
         return { changes: 0 };
       }
 
+      if (text === IDEM_PURGE_SQL) {
+        const now = Number(params[0]);
+        const before = state.idem.length;
+        state.idem = state.idem.filter((row) => row.expires_at > now);
+        return { changes: before - state.idem.length };
+      }
+      if (text === IDEM_DELETE_EXPIRED_ONE_SQL) {
+        const now = Number(params[4]);
+        const idx = state.idem.findIndex((row) => idemPk(row, params) && row.expires_at <= now);
+        if (idx < 0) return { changes: 0 };
+        state.idem.splice(idx, 1);
+        return { changes: 1 };
+      }
+      if (text === IDEM_INSERT_SQL) {
+        if (state.idem.some((row) => idemPk(row, params))) return { changes: 0 };
+        state.idem.push({
+          tenant: String(params[0]),
+          principal: String(params[1]),
+          flow: String(params[2]),
+          key: String(params[3]),
+          fingerprint: String(params[4]),
+          status: "in_progress",
+          claim_token: String(params[5]),
+          lease_expires_at: Number(params[6]),
+          run_id: null,
+          response_status: null,
+          response_headers: null,
+          response_body: null,
+          created_at: Number(params[7]),
+          expires_at: Number(params[8]),
+        });
+        return { changes: 1 };
+      }
+      if (text === IDEM_RECLAIM_SQL) {
+        const row = state.idem.find(
+          (candidate) =>
+            idemPk(candidate, params, 2) && candidate.claim_token === String(params[6]),
+        );
+        if (row === undefined || row.status !== "in_progress") return { changes: 0 };
+        row.claim_token = String(params[0]);
+        row.lease_expires_at = Number(params[1]);
+        return { changes: 1 };
+      }
+      if (text === IDEM_COMPLETE_SQL) {
+        const row = state.idem.find(
+          (candidate) =>
+            idemPk(candidate, params, 4) && candidate.claim_token === String(params[8]),
+        );
+        if (row === undefined) return { changes: 0 };
+        row.status = "completed";
+        row.response_status = Number(params[0]);
+        row.response_headers = params[1] === null ? null : String(params[1]);
+        row.response_body = params[2] === null ? null : String(params[2]);
+        if (params[3] !== null && params[3] !== undefined) row.run_id = String(params[3]);
+        return { changes: 1 };
+      }
+      if (text === IDEM_REMOVE_SQL) {
+        const idx = state.idem.findIndex(
+          (candidate) => idemPk(candidate, params) && candidate.claim_token === String(params[4]),
+        );
+        if (idx < 0) return { changes: 0 };
+        state.idem.splice(idx, 1);
+        return { changes: 1 };
+      }
+      if (text === IDEM_RENEW_SQL) {
+        const row = state.idem.find(
+          (candidate) =>
+            idemPk(candidate, params, 1) &&
+            candidate.claim_token === String(params[5]) &&
+            candidate.status === "in_progress",
+        );
+        if (row === undefined) return { changes: 0 };
+        row.lease_expires_at = Number(params[0]);
+        return { changes: 1 };
+      }
+      if (text === IDEM_ATTACH_SQL) {
+        const row = state.idem.find(
+          (candidate) =>
+            idemPk(candidate, params, 1) && candidate.claim_token === String(params[5]),
+        );
+        if (row === undefined) return { changes: 0 };
+        row.run_id = String(params[0]);
+        return { changes: 1 };
+      }
+      if (/^INSERT\s+INTO\s+oke_decision_labels\b/i.test(text)) {
+        state.labels.push({
+          decision_id: String(params[0]),
+          question: String(params[1]),
+          value: String(params[2]),
+          propensity: Number(params[3]),
+          reviewer: String(params[4]),
+          locale: params[5] === null || params[5] === undefined ? null : String(params[5]),
+          model: params[6] === null || params[6] === undefined ? null : String(params[6]),
+          tenant: params[7] === null || params[7] === undefined ? null : String(params[7]),
+          score: params[8] === null || params[8] === undefined ? null : Number(params[8]),
+          loss: params[9] === null || params[9] === undefined ? null : Number(params[9]),
+          raw: params[10] === null || params[10] === undefined ? null : String(params[10]),
+          at: Number(params[11]),
+          input: params[12] === null || params[12] === undefined ? null : String(params[12]),
+          review_id: params[13] === null || params[13] === undefined ? null : String(params[13]),
+        });
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_decision_candidates\b/i.test(text)) {
+        const decisionId = String(params[0]);
+        const body = String(params[1]);
+        const idx = state.candidates.findIndex((row) => row.decision_id === decisionId);
+        if (idx >= 0) state.candidates[idx] = { decision_id: decisionId, body };
+        else state.candidates.push({ decision_id: decisionId, body });
+        return { changes: 1 };
+      }
+
+      if (/^UPDATE\s+oke_decision_drift\b/i.test(text)) return { changes: 0 };
+
+      if (/^DELETE\s+FROM\s+oke_decision_drift\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.drift.length;
+        state.drift = state.drift.filter((row) => row.decision_id !== id);
+        return { changes: before - state.drift.length };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_decision_drift\b/i.test(text)) {
+        const decisionId = String(params[0]);
+        const next = {
+          decision_id: decisionId,
+          suspended: Number(params[1]),
+          certified_at: Number(params[2] ?? 0),
+        };
+        const idx = state.drift.findIndex((row) => row.decision_id === decisionId);
+        if (idx >= 0) state.drift[idx] = next;
+        else state.drift.push(next);
+        return { changes: 1 };
+      }
+
+      if (/^UPDATE\s+oke_agent_run\s+SET\s+sweep_claim_at\b/i.test(text)) {
+        const until = Number(params[0]);
+        const runId = String(params[1] ?? "");
+        const now = Number(params[2]);
+        const row = state.agentRuns.find((candidate) => candidate.run_id === runId);
+        if (!row) return { changes: 0 };
+        if (row.sweep_claim_at !== null && row.sweep_claim_at > now) return { changes: 0 };
+        row.sweep_claim_at = until;
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_agent_run\b/i.test(text)) {
+        const runId = String(params[0]);
+        const existing = state.agentRuns.find((row) => row.run_id === runId);
+        const next = {
+          run_id: runId,
+          header: String(params[1]),
+          sweep_claim_at: existing?.sweep_claim_at ?? null,
+        };
+        const idx = state.agentRuns.findIndex((row) => row.run_id === runId);
+        if (idx >= 0) state.agentRuns[idx] = next;
+        else state.agentRuns.push(next);
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_agent_event\b/i.test(text)) {
+        const runId = String(params[0]);
+        const seq = Number(params[1]);
+        if (state.agentEvents.some((row) => row.run_id === runId && row.seq === seq)) {
+          throw new Error(`duplicate key value violates unique constraint "oke_agent_event_pkey"`);
+        }
+        state.agentEvents.push({
+          run_id: runId,
+          seq,
+          event: String(params[2]),
+          event_type: params[3] === undefined || params[3] === null ? null : String(params[3]),
+          event_name: params[4] === undefined || params[4] === null ? null : String(params[4]),
+        });
+        return { changes: 1 };
+      }
+
+      if (/^DELETE\s+FROM\s+oke_agent_event\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.agentEvents.length;
+        state.agentEvents = state.agentEvents.filter((row) => row.run_id !== id);
+        return { changes: before - state.agentEvents.length };
+      }
+
+      if (/^DELETE\s+FROM\s+oke_agent_run\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.agentRuns.length;
+        state.agentRuns = state.agentRuns.filter((row) => row.run_id !== id);
+        return { changes: before - state.agentRuns.length };
+      }
+
+      if (text === IDEM_FORFEIT_SQL) {
+        const row = state.idem.find(
+          (candidate) =>
+            idemPk(candidate, params, 1) &&
+            candidate.claim_token === String(params[5]) &&
+            candidate.status === "in_progress",
+        );
+        if (row === undefined) return { changes: 0 };
+        row.claim_token = String(params[0]);
+        row.lease_expires_at = 0;
+        return { changes: 1 };
+      }
+
       throw new Error(`postgres journal fake: unsupported exec: ${sql}`);
     },
     async begin(fn) {
@@ -441,6 +816,61 @@ export type PostgresJournalStore = JournalStore &
     close(): Promise<void>;
   };
 
+/**
+ * Open decision tables on first use so a journal without decisions stays empty.
+ *
+ * @param sql - Journal SQL client
+ */
+function loadDecisionLabelModule(): typeof import("../kernel/decision-label-store.ts") {
+  return lazyRequire(`${import.meta.dir}/../kernel`, ["decision", "label", "store"].join("-"));
+}
+
+function loadAgentEventModule(): typeof import("../kernel/agent-event-store.ts") {
+  return lazyRequire(`${import.meta.dir}/../kernel`, ["agent", "event", "store"].join("-"));
+}
+
+function lazyDecisionLabels(sql: PostgresJournalSql): DecisionLabelStore {
+  let pending: Promise<DecisionLabelStore> | undefined;
+  const ready = (): Promise<DecisionLabelStore> => {
+    pending ??= loadDecisionLabelModule().createPostgresDecisionLabelStore(sql);
+    return pending;
+  };
+  return {
+    insert: (label, at) => ready().then((store) => store.insert(label, at)),
+    list: (decision, tenant) => ready().then((store) => store.list(decision, tenant)),
+    drift: () => ready().then((store) => store.drift()),
+    setDrift: (decision, record) => ready().then((store) => store.setDrift(decision, record)),
+    putCandidate: (decision, entry) => ready().then((store) => store.putCandidate(decision, entry)),
+    getCandidate: (decision) => ready().then((store) => store.getCandidate(decision)),
+    listCandidates: () => ready().then((store) => store.listCandidates()),
+  };
+}
+
+/**
+ * Open the agent event tables on first use.
+ *
+ * @param sql - Journal SQL client
+ */
+function lazyAgentEvents(sql: PostgresJournalSql): AgentEventStore {
+  let pending: Promise<AgentEventStore> | undefined;
+  const ready = (): Promise<AgentEventStore> => {
+    pending ??= loadAgentEventModule().createPostgresAgentEventStore(sql);
+    return pending;
+  };
+  return {
+    read: (runId) => ready().then((store) => store.read(runId)),
+    readAfter: (runId, afterSeq) => ready().then((store) => store.readAfter(runId, afterSeq)),
+    maxSeq: (runId) => ready().then((store) => store.maxSeq(runId)),
+    readHeader: (runId) => ready().then((store) => store.readHeader(runId)),
+    truncated: (runId) => ready().then((store) => store.truncated(runId)),
+    claim: (runId) => ready().then((store) => store.claim(runId)),
+    listHeaders: () => ready().then((store) => store.listHeaders()),
+    writeHeader: (header) => ready().then((store) => store.writeHeader(header)),
+    append: (runId, row) => ready().then((store) => store.append(runId, row)),
+    remove: (runId) => ready().then((store) => store.remove(runId)),
+  };
+}
+
 /**
  * Open a postgres-backed JournalStore (multi-host durable-run coordination).
  *
@@ -460,6 +890,9 @@ export async function createPostgresJournalStore(
 
   const store: PostgresJournalStore = {
     sql,
+    idempotency: createPostgresIdempotencyStore(sql),
+    decisions: lazyDecisionLabels(sql),
+    agentEvents: lazyAgentEvents(sql),
     async get(runId) {
       const rows = await sql.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [runId]);
       if (!rows[0]) return undefined;
@@ -480,6 +913,25 @@ export async function createPostgresJournalStore(
         return true;
       });
     },
+    async cas(runId, instanceId, now, leaseMs, update) {
+      return sql.begin(async (tx) => {
+        const claimed = await tx.query(CLAIM_LEASE_SQL, [runId, instanceId, now]);
+        const row = claimed[0];
+        if (!row) {
+          const exists = await tx.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [runId]);
+          const held = exists[0];
+          if (!held) return "missing";
+          const current = rowToRun(held);
+          return { lease: true, leaseExpiresAt: current.leaseExpiresAt };
+        }
+        const current = rowToRun(row);
+        const next = update(current) ?? current;
+        next.lockedBy = instanceId;
+        next.leaseExpiresAt = now + leaseMs;
+        await tx.exec(UPSERT_SQL, runToParams(next));
+        return "ok";
+      });
+    },
     async releaseLease(runId, instanceId) {
       await sql.exec(RELEASE_LEASE_SQL, [runId, instanceId]);
     },

package/src/drivers/meilisearch.ts

@@ -22,6 +22,7 @@ import type {
   TextIndexStore,
 } from "./types.ts";
 import { hostFromUrl } from "./external.ts";
+import { requestSignal } from "../kernel/abort-scope.ts";
 
 /** Error thrown when the remote Meilisearch is unreachable / unhealthy / errors. */
 export class MeilisearchUnavailableError extends Error {
@@ -134,6 +135,7 @@ export async function openMeilisearchIndex(
       res = await fetchFn(`${url}${path}`, {
         ...init,
         headers: { ...headers, ...(init?.headers ?? {}) },
+        signal: requestSignal(init?.signal ?? null),
       });
     } catch (err) {
       throw new MeilisearchUnavailableError(

package/src/drivers/memory-ddl.test.ts

@@ -0,0 +1,18 @@
+/**
+ * Memory SQL accepts the DDL identity boot issues on the shared connection.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { ensureIdentityTables } from "../auth/identity-sql.ts";
+import { memorySqlDriver } from "./memory.ts";
+
+describe("memory sql DDL", () => {
+  test("CREATE INDEX IF NOT EXISTS does not reject identity tables", async () => {
+    const conn = await memorySqlDriver.connect({ role: "primary" });
+    await ensureIdentityTables(conn);
+    await ensureIdentityTables(conn);
+    const rows = await conn.query("SELECT id FROM oke_credentials");
+    expect(rows).toEqual([]);
+    await conn.close();
+  });
+});