@ixo/oracle-runtime-workers 0.12.0 → 0.15.0

package/src/do/run-store.ts

@@ -14,10 +14,15 @@
  *   - `turn_tool_marks`: one row per tool call, written BEFORE the tool runs
  *     (`started`) and updated when it returns (`done`). This is what makes a
  *     resume safe: a started-but-unfinished write call is never re-executed.
+ *   - `turn_write_claims`: one row per write whose outcome is not known yet
+ *     (tool-execution.ts), keyed by the fingerprint of the tool name and
+ *     arguments. Released by a returned outcome; kept by an abort, a deadline
+ *     or a dropped connection, so the same write is not repeated blindly by
+ *     a later call — across sessions of the user, until the run retention.
  *
  * Cost shape (SQLite-backed DO storage bills rows written or deleted): a run
  * costs 1 insert + ~2 updates, a segment 1 insert + 1 delete, a tool call
- * 1 insert + 1 update.
+ * 1 insert + 1 update, a write 1 insert + 1 delete more.
  */
 import type { DoSqliteDatabase } from '../sqlite/database';
 import type { PackedSegment } from './run-buffer';
@@ -39,11 +44,64 @@ export const ACTIVE_RUN_STATUSES: ReadonlySet<RunStatus> = new Set([
 
 export type ToolEffect = 'read' | 'write';
 
+/** The columns a run's row is updated with. */
+export type RunPatch = Partial<
+  Pick<
+    RunRecord,
+    | 'status'
+    | 'attempts'
+    | 'generation'
+    | 'nextAttemptAt'
+    | 'checkpointId'
+    | 'startCheckpointId'
+    | 'lastSeq'
+    | 'partialText'
+    | 'messageId'
+    | 'error'
+    | 'taskRunId'
+    | 'instanceId'
+    | 'usage'
+    | 'request'
+  >
+>;
+
+/**
+ * `record` as its row reads after `update(patch)` stamped `updatedAt`, so a
+ * writer keeps its copy current without reading the row back. Like
+ * `update`, a field whose value is `undefined` is left as it was.
+ */
+export function patchRunRecord(
+  record: RunRecord,
+  patch: RunPatch,
+  updatedAt: string,
+): RunRecord {
+  const next: RunRecord = { ...record, updatedAt };
+  if (patch.status !== undefined) next.status = patch.status;
+  if (patch.attempts !== undefined) next.attempts = patch.attempts;
+  if (patch.generation !== undefined) next.generation = patch.generation;
+  if (patch.nextAttemptAt !== undefined)
+    next.nextAttemptAt = patch.nextAttemptAt;
+  if (patch.checkpointId !== undefined) next.checkpointId = patch.checkpointId;
+  if (patch.startCheckpointId !== undefined) {
+    next.startCheckpointId = patch.startCheckpointId;
+    next.startRecorded = true;
+  }
+  if (patch.lastSeq !== undefined) next.lastSeq = patch.lastSeq;
+  if (patch.partialText !== undefined) next.partialText = patch.partialText;
+  if (patch.messageId !== undefined) next.messageId = patch.messageId;
+  if (patch.error !== undefined) next.error = patch.error;
+  if (patch.taskRunId !== undefined) next.taskRunId = patch.taskRunId;
+  if (patch.instanceId !== undefined) next.instanceId = patch.instanceId;
+  if (patch.usage !== undefined) next.usage = patch.usage;
+  if (patch.request !== undefined) next.request = patch.request;
+  return next;
+}
+
 export interface RunRecord {
   runId: string;
   sessionId: string;
   requestId: string;
-  client: 'portal' | 'matrix';
+  client: 'portal' | 'matrix' | 'channel';
   status: RunStatus;
   startedAt: string;
   updatedAt: string;
@@ -62,6 +120,15 @@ export interface RunRecord {
   nextAttemptAt: number | null;
   /** Checkpoint id observed when the run (or its last attempt) started. */
   checkpointId: string | null;
+  /**
+   * Checkpoint id of the session when the run began executing (at begin, or
+   * when it was dequeued) — before the graph wrote the run's input. Unlike
+   * `checkpointId` it is never moved by a recovery, so it answers whether
+   * the graph ever persisted anything for this run (`runHasCheckpointed`).
+   */
+  startCheckpointId: string | null;
+  /** `startCheckpointId` was recorded (rows written before it existed: false). */
+  startRecorded: boolean;
   /** Highest frame sequence packed into a segment. */
   lastSeq: number;
   /** The reply so far, kept when the run ends without a committed reply. */
@@ -73,6 +140,22 @@ export interface RunRecord {
   taskRunId: string | null;
   /** Instance that owns the run — a different instance at boot means an orphan. */
   instanceId: string;
+  /** JSON: the turn's budget usage (`TurnUsage`), written once when the run ends. */
+  usage: string | null;
+}
+
+/**
+ * A write whose outcome the ledger still has to account for (tool-execution.ts).
+ * `pending`: started, no known outcome yet. `warned`: an identical write was
+ * refused since and the model was told; a later turn may run it again.
+ */
+export interface WriteClaimRecord {
+  fingerprint: string;
+  toolName: string;
+  runId: string;
+  sessionId: string;
+  startedAt: string;
+  state: 'pending' | 'warned';
 }
 
 export interface ToolMark {
@@ -91,6 +174,9 @@ export interface ToolMark {
 /** Rows of ended runs are kept a week (a re-join that late gets 404). */
 export const RUN_RETENTION_MS = 7 * 24 * 3600 * 1000;
 
+/** An ended run last touched before the cutoff (the one bound parameter). */
+export const STALE_RUN_FILTER = `status IN ('finished','aborted','interrupted','failed') AND updated_at < ?`;
+
 /**
  * Sequence-number space of one attempt. A cursor is `after=<seq>`; the
  * next attempt starts numbering at the next multiple of this, above any
@@ -152,6 +238,32 @@ export function runDurabilityConfig(
   };
 }
 
+/** The session's checkpoint moved on from `since` (an unreadable checkpoint, `null`, never counts). */
+export function checkpointAdvanced(
+  since: string | null,
+  currentCheckpointId: string | null,
+): boolean {
+  return currentCheckpointId !== null && currentCheckpointId !== since;
+}
+
+/**
+ * Whether the graph persisted anything for this run, judged by the same
+ * comparison as `decideRecovery`'s progress, against the checkpoint the run
+ * started from. `true` → the next attempt resumes from the checkpoint;
+ * `false` → the graph never saw the input, so the attempt runs fresh with it.
+ * A row without a recorded start (written before it was stored) resumes, as
+ * every recovery did then.
+ */
+export function runHasCheckpointed(
+  run: Pick<RunRecord, 'startCheckpointId' | 'startRecorded'>,
+  currentCheckpointId: string | null,
+): boolean {
+  return (
+    !run.startRecorded ||
+    checkpointAdvanced(run.startCheckpointId, currentCheckpointId)
+  );
+}
+
 export type RecoveryDecision =
   | { action: 'schedule'; at: number; attempts: number }
   | { action: 'interrupt'; attempts: number };
@@ -168,8 +280,7 @@ export function decideRecovery(
   now: number,
   config: Pick<RunDurabilityConfig, 'recoveryAttempts' | 'recoveryDelaysMs'>,
 ): RecoveryDecision {
-  const progressed =
-    currentCheckpointId !== null && currentCheckpointId !== run.checkpointId;
+  const progressed = checkpointAdvanced(run.checkpointId, currentCheckpointId);
   const spent = progressed ? 0 : run.attempts;
   if (spent >= config.recoveryAttempts)
     return { action: 'interrupt', attempts: spent };
@@ -191,12 +302,24 @@ type RunRow = {
   generation: number;
   next_attempt_at: number | null;
   checkpoint_id: string | null;
+  start_checkpoint_id: string | null;
+  start_recorded: number;
   last_seq: number;
   partial_text: string | null;
   message_id: string | null;
   error: string | null;
   task_run_id: string | null;
   instance_id: string;
+  usage: string | null;
+} & Record<string, string | number | null>;
+
+type ClaimRow = {
+  fingerprint: string;
+  tool_name: string;
+  run_id: string;
+  session_id: string;
+  started_at: string;
+  state: string;
 } & Record<string, string | number | null>;
 
 type MarkRow = {
@@ -217,14 +340,17 @@ type SegmentRow = {
 } & Record<string, string | number | null>;
 
 const RUN_COLUMNS =
-  'run_id, session_id, request_id, client, status, started_at, updated_at, request, attempts, generation, next_attempt_at, checkpoint_id, last_seq, partial_text, message_id, error, task_run_id, instance_id';
+  'run_id, session_id, request_id, client, status, started_at, updated_at, request, attempts, generation, next_attempt_at, checkpoint_id, start_checkpoint_id, start_recorded, last_seq, partial_text, message_id, error, task_run_id, instance_id, usage';
 
 function toRecord(row: RunRow): RunRecord {
   return {
     runId: row.run_id,
     sessionId: row.session_id,
     requestId: row.request_id,
-    client: row.client === 'matrix' ? 'matrix' : 'portal',
+    client:
+      row.client === 'matrix' || row.client === 'channel'
+        ? row.client
+        : 'portal',
     status: row.status as RunStatus,
     startedAt: row.started_at,
     updatedAt: row.updated_at,
@@ -234,12 +360,26 @@ function toRecord(row: RunRow): RunRecord {
     nextAttemptAt:
       row.next_attempt_at === null ? null : Number(row.next_attempt_at),
     checkpointId: row.checkpoint_id,
+    startCheckpointId: row.start_checkpoint_id,
+    startRecorded: Number(row.start_recorded) === 1,
     lastSeq: Number(row.last_seq),
     partialText: row.partial_text,
     messageId: row.message_id,
     error: row.error,
     taskRunId: row.task_run_id,
     instanceId: row.instance_id,
+    usage: row.usage,
+  };
+}
+
+function toClaim(row: ClaimRow): WriteClaimRecord {
+  return {
+    fingerprint: row.fingerprint,
+    toolName: row.tool_name,
+    runId: row.run_id,
+    sessionId: row.session_id,
+    startedAt: row.started_at,
+    state: row.state === 'warned' ? 'warned' : 'pending',
   };
 }
 
@@ -303,6 +443,16 @@ export class RunStore {
       await this.db.run(
         `ALTER TABLE turn_runs ADD COLUMN generation INTEGER NOT NULL DEFAULT 0`,
       );
+    if (!columns.some((c) => c.name === 'usage'))
+      await this.db.run(`ALTER TABLE turn_runs ADD COLUMN usage TEXT`);
+    if (!columns.some((c) => c.name === 'start_checkpoint_id'))
+      await this.db.run(
+        `ALTER TABLE turn_runs ADD COLUMN start_checkpoint_id TEXT`,
+      );
+    if (!columns.some((c) => c.name === 'start_recorded'))
+      await this.db.run(
+        `ALTER TABLE turn_runs ADD COLUMN start_recorded INTEGER NOT NULL DEFAULT 0`,
+      );
     await this.db.run(
       `CREATE INDEX IF NOT EXISTS idx_turn_runs_session ON turn_runs(session_id, started_at)`,
     );
@@ -326,22 +476,105 @@ export class RunStore {
         attempts INTEGER NOT NULL DEFAULT 1,
         PRIMARY KEY (run_id, tool_call_id)
       ) WITHOUT ROWID`);
-    // Ended runs older than the retention window: their segments are gone
-    // already (cutover); drop the rows and marks in one pass per boot.
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS turn_write_claims (
+        fingerprint TEXT PRIMARY KEY,
+        tool_name TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        state TEXT NOT NULL DEFAULT 'pending'
+      ) WITHOUT ROWID`);
+    await this.db.run(`CREATE TABLE IF NOT EXISTS channel_run_tombstones (
+      run_id TEXT PRIMARY KEY, status TEXT NOT NULL
+    ) WITHOUT ROWID`);
+    // The Reply Plan a finished chat-surface run delivers (chat delivery).
+    await this.db.run(`CREATE TABLE IF NOT EXISTS turn_run_plans (
+      run_id TEXT PRIMARY KEY, plan TEXT NOT NULL
+    ) WITHOUT ROWID`);
+    // Boot pruning looks rows up by age: these keep it a range seek, not a
+    // scan of every run and claim, on every boot.
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_turn_runs_updated ON turn_runs(updated_at)`,
+    );
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_turn_write_claims_started ON turn_write_claims(started_at)`,
+    );
+    await this.pruneEnded();
+  }
+
+  /**
+   * Ended runs older than the retention window: their segments are gone
+   * already (cutover); drop the rows, marks, plans and leftover segments in
+   * one transaction per boot, set-based. A channel run leaves a tombstone
+   * (its id and final status) and loses its receipt (channels/turns.ts):
+   * from then on the tombstone alone refuses a replay (410).
+   */
+  private async pruneEnded(): Promise<void> {
     const cutoff = new Date(this.now() - RUN_RETENTION_MS).toISOString();
-    const stale = await this.db.exec<{ run_id: string }>(
-      `SELECT run_id FROM turn_runs WHERE status IN ('finished','aborted','interrupted','failed') AND updated_at < ?`,
-      [cutoff],
+    await this.db.run(`DELETE FROM turn_write_claims WHERE started_at < ?`, [
+      cutoff,
+    ]);
+    const stale = `SELECT run_id FROM turn_runs WHERE ${STALE_RUN_FILTER}`;
+    if (await this.db.get(`${stale} LIMIT 1`, [cutoff]))
+      await this.db.transaction(async () => {
+        await this.db.run(
+          `INSERT OR IGNORE INTO channel_run_tombstones (run_id, status)
+           SELECT run_id, status FROM turn_runs WHERE client = 'channel' AND ${STALE_RUN_FILTER}`,
+          [cutoff],
+        );
+        for (const table of [
+          'turn_tool_marks',
+          'turn_run_plans',
+          'turn_run_segments',
+        ])
+          await this.db.run(`DELETE FROM ${table} WHERE run_id IN (${stale})`, [
+            cutoff,
+          ]);
+        await this.db.run(`DELETE FROM turn_runs WHERE ${STALE_RUN_FILTER}`, [
+          cutoff,
+        ]);
+      });
+    // Every receipt whose run is tombstoned, this boot or an earlier one
+    // that stopped before getting here. Driven by the receipts (at most the
+    // retention window of them), one key lookup each into the tombstones,
+    // which are never pruned and never scanned. The table exists once the
+    // object has served a channel turn.
+    const receipts = await this.db.get<{ name: string }>(
+      `SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'channel_requests'`,
     );
-    for (const row of stale) {
-      await this.db.run(`DELETE FROM turn_tool_marks WHERE run_id = ?`, [
-        row.run_id,
-      ]);
-      await this.db.run(`DELETE FROM turn_run_segments WHERE run_id = ?`, [
-        row.run_id,
-      ]);
-      await this.db.run(`DELETE FROM turn_runs WHERE run_id = ?`, [row.run_id]);
-    }
+    if (receipts)
+      await this.db.run(
+        `DELETE FROM channel_requests WHERE EXISTS (
+           SELECT 1 FROM channel_run_tombstones t WHERE t.run_id = channel_requests.run_id
+         )`,
+      );
+  }
+
+  /** Record the Reply Plan (JSON) a chat-surface run finished with. */
+  async setPlan(runId: string, plan: string): Promise<void> {
+    await this.setup();
+    await this.db.run(
+      'INSERT OR REPLACE INTO turn_run_plans (run_id, plan) VALUES (?, ?)',
+      [runId, plan],
+    );
+  }
+
+  async getPlan(runId: string): Promise<string | null> {
+    await this.setup();
+    const row = await this.db.get<{ plan: string }>(
+      'SELECT plan FROM turn_run_plans WHERE run_id = ?',
+      [runId],
+    );
+    return row?.plan ?? null;
+  }
+
+  async wasChannelRunPruned(runId: string): Promise<boolean> {
+    await this.setup();
+    return !!(await this.db.get<{ run_id: string }>(
+      'SELECT run_id FROM channel_run_tombstones WHERE run_id = ?',
+      [runId],
+    ));
   }
 
   private iso(): string {
@@ -354,18 +587,18 @@ export class RunStore {
     runId: string;
     sessionId: string;
     requestId: string;
-    client: 'portal' | 'matrix';
+    client: 'portal' | 'matrix' | 'channel';
     status: 'queued' | 'running';
     request: string;
     checkpointId: string | null;
     taskRunId?: string | null;
     instanceId: string;
-  }): Promise<void> {
+  }): Promise<RunRecord> {
     await this.setup();
     const at = this.iso();
     await this.db.run(
       `INSERT INTO turn_runs (${RUN_COLUMNS})
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?, 0, NULL, NULL, NULL, ?, ?)`,
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?, ?, 1, 0, NULL, NULL, NULL, ?, ?, NULL)`,
       [
         input.runId,
         input.sessionId,
@@ -376,10 +609,34 @@ export class RunStore {
         at,
         input.request,
         input.checkpointId,
+        input.checkpointId,
         input.taskRunId ?? null,
         input.instanceId,
       ],
     );
+    return {
+      runId: input.runId,
+      sessionId: input.sessionId,
+      requestId: input.requestId,
+      client: input.client,
+      status: input.status,
+      startedAt: at,
+      updatedAt: at,
+      request: input.request,
+      attempts: 0,
+      generation: 0,
+      nextAttemptAt: null,
+      checkpointId: input.checkpointId,
+      startCheckpointId: input.checkpointId,
+      startRecorded: true,
+      lastSeq: 0,
+      partialText: null,
+      messageId: null,
+      error: null,
+      taskRunId: input.taskRunId ?? null,
+      instanceId: input.instanceId,
+      usage: null,
+    };
   }
 
   async get(runId: string): Promise<RunRecord | undefined> {
@@ -444,51 +701,55 @@ export class RunStore {
     return rows.map(toRecord);
   }
 
-  async update(
-    runId: string,
-    patch: Partial<
-      Pick<
-        RunRecord,
-        | 'status'
-        | 'attempts'
-        | 'generation'
-        | 'nextAttemptAt'
-        | 'checkpointId'
-        | 'lastSeq'
-        | 'partialText'
-        | 'messageId'
-        | 'error'
-        | 'taskRunId'
-        | 'instanceId'
-      >
-    >,
-  ): Promise<void> {
+  /** Write `patch` to the run's row; returns the `updatedAt` it stamped. */
+  async update(runId: string, patch: RunPatch): Promise<string> {
     await this.setup();
+    const updatedAt = this.iso();
     const sets: string[] = ['updated_at = ?'];
-    const params: Array<string | number | null> = [this.iso()];
+    const params: Array<string | number | null> = [updatedAt];
     const column: Record<string, string> = {
+      request: 'request',
       status: 'status',
       attempts: 'attempts',
       generation: 'generation',
       nextAttemptAt: 'next_attempt_at',
       checkpointId: 'checkpoint_id',
+      startCheckpointId: 'start_checkpoint_id',
       lastSeq: 'last_seq',
       partialText: 'partial_text',
       messageId: 'message_id',
       error: 'error',
       taskRunId: 'task_run_id',
       instanceId: 'instance_id',
+      usage: 'usage',
     };
     for (const [key, value] of Object.entries(patch)) {
       if (value === undefined) continue;
       sets.push(`${column[key]} = ?`);
       params.push(value);
     }
+    // Writing the start checkpoint records it (a row from before the column).
+    if (patch.startCheckpointId !== undefined) sets.push('start_recorded = 1');
     params.push(runId);
     await this.db.run(
       `UPDATE turn_runs SET ${sets.join(', ')} WHERE run_id = ?`,
       params,
     );
+    return updatedAt;
+  }
+
+  /**
+   * A run's end in one transaction: its row takes the terminal `patch` and
+   * its segments are dropped (the reply, or the partial text, is in the row
+   * and the transcript now). Returns the `updatedAt` it stamped.
+   */
+  async close(runId: string, patch: RunPatch): Promise<string> {
+    await this.setup();
+    return this.db.transaction(async () => {
+      const updatedAt = await this.update(runId, patch);
+      await this.deleteSegments(runId);
+      return updatedAt;
+    });
   }
 
   // ── segments ────────────────────────────────────────────────────────────
@@ -601,4 +862,85 @@ export class RunStore {
     );
     return rows.map(toMark);
   }
+
+  // ── write claims ────────────────────────────────────────────────────────
+
+  /**
+   * Claim a write before it runs. `claimed` when no identical write is
+   * outstanding. `blocked` when one is: a `pending` claim becomes `warned`
+   * (owned by this run, so the same turn stays blocked); a claim already
+   * `warned` by an earlier run is released to this run — the user was told
+   * and asked again.
+   */
+  async claimWrite(input: {
+    fingerprint: string;
+    toolName: string;
+    runId: string;
+    sessionId: string;
+  }): Promise<
+    | { status: 'claimed' }
+    | { status: 'blocked'; toolName: string; since: string }
+  > {
+    await this.setup();
+    const inserted = await this.db.run(
+      `INSERT OR IGNORE INTO turn_write_claims (fingerprint, tool_name, run_id, session_id, started_at, state)
+       VALUES (?, ?, ?, ?, ?, 'pending')`,
+      [
+        input.fingerprint,
+        input.toolName,
+        input.runId,
+        input.sessionId,
+        this.iso(),
+      ],
+    );
+    if (inserted.changes === 1) return { status: 'claimed' };
+    const existing = await this.getClaim(input.fingerprint);
+    if (!existing) return { status: 'claimed' };
+    if (existing.state === 'warned' && existing.runId !== input.runId) {
+      await this.db.run(
+        `UPDATE turn_write_claims SET run_id = ?, session_id = ?, started_at = ?, state = 'pending' WHERE fingerprint = ?`,
+        [input.runId, input.sessionId, this.iso(), input.fingerprint],
+      );
+      return { status: 'claimed' };
+    }
+    if (existing.state === 'pending')
+      await this.db.run(
+        `UPDATE turn_write_claims SET state = 'warned', run_id = ? WHERE fingerprint = ? AND state = 'pending'`,
+        [input.runId, input.fingerprint],
+      );
+    return {
+      status: 'blocked',
+      toolName: existing.toolName,
+      since: existing.startedAt,
+    };
+  }
+
+  /** The write returned an outcome (or a known failure): nothing to account for. */
+  async releaseWrite(fingerprint: string, runId: string): Promise<void> {
+    await this.setup();
+    await this.db.run(
+      `DELETE FROM turn_write_claims WHERE fingerprint = ? AND run_id = ?`,
+      [fingerprint, runId],
+    );
+  }
+
+  async getClaim(fingerprint: string): Promise<WriteClaimRecord | undefined> {
+    await this.setup();
+    const row = await this.db.get<ClaimRow>(
+      `SELECT fingerprint, tool_name, run_id, session_id, started_at, state
+       FROM turn_write_claims WHERE fingerprint = ?`,
+      [fingerprint],
+    );
+    return row ? toClaim(row) : undefined;
+  }
+
+  /** Outstanding claims, oldest first (operator inspection). */
+  async listClaims(): Promise<WriteClaimRecord[]> {
+    await this.setup();
+    const rows = await this.db.exec<ClaimRow>(
+      `SELECT fingerprint, tool_name, run_id, session_id, started_at, state
+       FROM turn_write_claims ORDER BY started_at ASC`,
+    );
+    return rows.map(toClaim);
+  }
 }

package/src/do/secrets-adapter.ts

@@ -3,21 +3,33 @@
  * gateway) to the core's `SecretsAdapter` shape — the same mapping the Node
  * runtime's `ambient-factory` performs over its `SecretsService`:
  * `getIndex` lists names (plugins never see event ids), `getValues` decrypts
- * only the requested names. Degrades exactly like Node when the oracle has no
+ * only the requested names, and `getAll` decrypts every listed name from one
+ * read of the room state. Degrades exactly like Node when the oracle has no
  * P-256 key seated: the index still lists, values come back empty.
+ *
+ * The runtime's own LLM credentials (BYO API keys, the ChatGPT OAuth tokens
+ * with their refresh token) share the room but are not the user's tool
+ * secrets: plugins neither list nor read them. The sandbox forwards every
+ * secret it sees to code the model writes, where a prompt injection could
+ * send it anywhere. The BYO service reads them from the service directly.
  */
 import type { SecretsAdapter } from '../core/runtime-context';
+import { isRuntimeOnlySecret } from '../llm/byo-catalog';
 import type { SecretIndex } from '../plugin-api/types';
 import type { WorkersSecretsService } from '../secrets/secrets-service';
 
 export function createSecretsAdapter(
-  service: WorkersSecretsService,
+  service: Pick<
+    WorkersSecretsService,
+    'getIndex' | 'getValues' | 'getValuesFor'
+  >,
 ): SecretsAdapter {
   return {
     async getIndex(roomId: string): Promise<SecretIndex> {
       const entries = await service.getIndex(roomId);
       const index: Record<string, { key: string }> = {};
       for (const entry of entries) {
+        if (isRuntimeOnlySecret(entry.name)) continue;
         index[entry.name] = { key: entry.name };
       }
       return index satisfies SecretIndex;
@@ -26,7 +38,14 @@ export function createSecretsAdapter(
       roomId: string,
       keys: string[],
     ): Promise<Record<string, string>> {
-      return service.getValues(roomId, keys);
+      const allowed = keys.filter((key) => !isRuntimeOnlySecret(key));
+      return allowed.length > 0 ? service.getValues(roomId, allowed) : {};
+    },
+    async getAll(roomId: string): Promise<Record<string, string>> {
+      const entries = (await service.getIndex(roomId)).filter(
+        (entry) => !isRuntimeOnlySecret(entry.name),
+      );
+      return entries.length > 0 ? service.getValuesFor(roomId, entries) : {};
     },
   };
 }