@actiondock/core 2.10.0 → 2.11.0

package/dist/storage/sqlite-schema.js

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, chmodSync } from "node:fs";
+import { dirname } from "node:path";
+import { UNSUPPORTED_STORAGE_SCHEMA } from "../errors.js";
+import { STORAGE_SCHEMA_VERSION } from "./types.js";
+/**
+ * 数据库 Schema 定义、初始化与版本校验。
+ */
+export function initSchema(driver, dbPath, recoverOrphans, recoverDeadSessionFn, cleanExpiredRunsFn) {
+    if (dbPath !== ":memory:") {
+        const dir = dirname(dbPath);
+        if (!existsSync(dir)) {
+            try {
+                mkdirSync(dir, { recursive: true, mode: 0o700 });
+                chmodSync(dir, 0o700);
+            }
+            catch {
+                // 忽略系统权限设置失败
+            }
+        }
+    }
+    // 跨进程写并发基线：优先设置 busy_timeout，确保后续 PRAGMA（如 journal_mode = WAL）与表结构初始化在锁争用时能够重试等待
+    driver.exec("PRAGMA busy_timeout = 5000;");
+    driver.exec("PRAGMA journal_mode = WAL;");
+    driver.exec("PRAGMA synchronous = NORMAL;");
+    const versionRes = driver.prepare("PRAGMA user_version;").get();
+    const version = Number(versionRes?.user_version ?? 0);
+    if (version === 0) {
+        driver.transaction(() => {
+            driver.exec(`
+        CREATE TABLE IF NOT EXISTS config (
+          package_id TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value_json TEXT,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (package_id, key)
+        );
+
+        CREATE TABLE IF NOT EXISTS state (
+          package_id TEXT NOT NULL,
+          namespace TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value_json TEXT,
+          updated_at TEXT NOT NULL,
+          expires_at TEXT,
+          PRIMARY KEY (package_id, namespace, key)
+        );
+
+        CREATE TABLE IF NOT EXISTS runs (
+          id TEXT PRIMARY KEY,
+          root_run_id TEXT NOT NULL,
+          parent_run_id TEXT,
+          package_id TEXT NOT NULL,
+          package_instance_id TEXT NOT NULL,
+          action_id TEXT NOT NULL,
+          generation_id TEXT NOT NULL,
+          owner_id TEXT NOT NULL,
+          host_session_id TEXT,
+          host_pid INTEGER,
+          heartbeat_at TEXT,
+          status TEXT NOT NULL,
+          input_json TEXT,
+          output_json TEXT,
+          error_json TEXT,
+          started_at TEXT NOT NULL,
+          finished_at TEXT,
+          duration_ms INTEGER
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_runs_action ON runs(package_id, action_id);
+        CREATE INDEX IF NOT EXISTS idx_runs_root ON runs(root_run_id);
+        CREATE INDEX IF NOT EXISTS idx_runs_started ON runs(started_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_runs_host_session ON runs(host_session_id);
+        CREATE INDEX IF NOT EXISTS idx_state_expires ON state(expires_at);
+
+        CREATE TABLE IF NOT EXISTS idempotency_keys (
+          owner_id TEXT NOT NULL,
+          action_ref TEXT NOT NULL,
+          request_id TEXT NOT NULL,
+          input_digest TEXT NOT NULL,
+          run_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          PRIMARY KEY (owner_id, action_ref, request_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_idemp_run ON idempotency_keys(run_id);
+
+        CREATE TABLE IF NOT EXISTS events (
+          id TEXT PRIMARY KEY,
+          package_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          payload_json TEXT,
+          created_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_events_type ON events(package_id, event_type);
+
+        PRAGMA user_version = ${STORAGE_SCHEMA_VERSION};
+      `);
+        });
+    }
+    else if (version !== STORAGE_SCHEMA_VERSION) {
+        const err = new Error(`UNSUPPORTED_STORAGE_SCHEMA: Database schema version ${version} is incompatible (expected ${STORAGE_SCHEMA_VERSION}). Silent upgrade and database overwriting are strictly prohibited.`);
+        err.code = UNSUPPORTED_STORAGE_SCHEMA;
+        throw err;
+    }
+    // 确保存量旧版本数据库补充新增的列或表
+    if (version !== 0) {
+        try {
+            const columns = driver.prepare("PRAGMA table_info(runs);").all();
+            if (Array.isArray(columns) && !columns.some((c) => c.name === "host_session_id")) {
+                driver.exec("ALTER TABLE runs ADD COLUMN host_session_id TEXT;");
+            }
+            // 存活判定依据列：记录所属宿主进程标识与最后一次活跃心跳，旧库以可空列兼容补充
+            if (Array.isArray(columns) && !columns.some((c) => c.name === "host_pid")) {
+                driver.exec("ALTER TABLE runs ADD COLUMN host_pid INTEGER;");
+            }
+            if (Array.isArray(columns) && !columns.some((c) => c.name === "heartbeat_at")) {
+                driver.exec("ALTER TABLE runs ADD COLUMN heartbeat_at TEXT;");
+            }
+        }
+        catch {
+            // 忽略非结构化表或兼容驱动异常
+        }
+        // 确保 events 表存在以支持新增的审计事件仓储
+        try {
+            driver.exec(`
+        CREATE TABLE IF NOT EXISTS events (
+          id TEXT PRIMARY KEY,
+          package_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          payload_json TEXT,
+          created_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_events_type ON events(package_id, event_type);
+      `);
+        }
+        catch {
+            // 忽略
+        }
+    }
+    if (recoverOrphans) {
+        recoverDeadSessionFn();
+        cleanExpiredRunsFn();
+    }
+}

package/dist/storage/sqlite-state.d.ts

@@ -0,0 +1,33 @@
+import { type Logger } from "@actiondock/sdk";
+import type { SqliteDriver, StateEntry } from "./types.js";
+import type { Clock } from "./clock.js";
+export declare class SqliteStateStore {
+    private statementCache;
+    private driver;
+    private packageId;
+    private dbPath;
+    private clock;
+    private logger?;
+    private logWarnFn?;
+    constructor(driver: SqliteDriver, packageId: string, dbPath: string, clock: Clock, logger?: Logger, logWarnFn?: (msg: string) => void);
+    private logWarn;
+    private getStatement;
+    getState<T = unknown>(namespace: string, key: string): Promise<T | undefined>;
+    private findMatchingStateRows;
+    findState<T = unknown>(targetKey: string, namespace?: string): Promise<StateEntry | undefined>;
+    setState<T = unknown>(namespace: string, key: string, value: T, ttl?: number): Promise<void>;
+    deleteState(namespace: string, key: string): Promise<boolean>;
+    deleteStateSmart(targetKey: string, namespace?: string): Promise<boolean>;
+    cleanExpiredState(isClosed: boolean): Promise<number>;
+    clearState(options?: {
+        namespace?: string;
+        all?: boolean;
+        prefix?: string;
+    }): Promise<number>;
+    listStateKeys(namespace?: string | null, prefix?: string, isClosed?: boolean): Promise<string[]>;
+    listStateEntries(options?: {
+        namespace?: string;
+        prefix?: string;
+    }, isClosed?: boolean): Promise<StateEntry[]>;
+    close(): void;
+}

package/dist/storage/sqlite-state.js

@@ -0,0 +1,270 @@
+import { decodeStateKey, encodeStateKey } from "@actiondock/sdk";
+import { safeParseStoredJson } from "./utils.js";
+import { ActionDockError, AMBIGUOUS_STATE_KEY } from "../errors.js";
+import { IDEMPOTENCY_RETENTION_MS } from "./types.js";
+export class SqliteStateStore {
+    statementCache = new Map();
+    driver;
+    packageId;
+    dbPath;
+    clock;
+    logger;
+    logWarnFn;
+    constructor(driver, packageId, dbPath, clock, logger, logWarnFn) {
+        this.driver = driver;
+        this.packageId = packageId;
+        this.dbPath = dbPath;
+        this.clock = clock;
+        this.logger = logger;
+        this.logWarnFn = logWarnFn;
+    }
+    logWarn(message) {
+        if (this.logWarnFn) {
+            this.logWarnFn(message);
+        }
+        else if (this.logger) {
+            this.logger.warn(message);
+        }
+        else {
+            console.warn(message);
+        }
+    }
+    getStatement(sql) {
+        let stmt = this.statementCache.get(sql);
+        if (!stmt) {
+            stmt = this.driver.prepare(sql);
+            this.statementCache.set(sql, stmt);
+        }
+        return stmt;
+    }
+    async getState(namespace, key) {
+        const stmt = this.getStatement("SELECT value_json, expires_at FROM state WHERE package_id = ? AND namespace = ? AND key = ?");
+        const row = stmt.get(this.packageId, namespace, key);
+        if (!row || row.value_json === undefined || row.value_json === null) {
+            return undefined;
+        }
+        if (row.expires_at) {
+            const expires = new Date(row.expires_at).getTime();
+            if (this.clock.now().getTime() >= expires) {
+                this.deleteState(namespace, key).catch((err) => {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    this.logWarn(`[actiondock] expired state lazy delete failed (namespace='${namespace}' key='${key}'): ${reason}`);
+                });
+                return undefined;
+            }
+        }
+        return safeParseStoredJson(row.value_json, `state db=${this.dbPath} package=${this.packageId} namespace=${namespace} key=${key}`);
+    }
+    async findMatchingStateRows(targetKey) {
+        let decoded;
+        try {
+            decoded = decodeStateKey(targetKey);
+        }
+        catch {
+            // ignore
+        }
+        const candidateStmt = this.getStatement(`
+      SELECT namespace, key, value_json, updated_at, expires_at FROM state
+      WHERE package_id = ? AND (
+        (CASE WHEN ? IS NOT NULL THEN (namespace = ? AND key = ?) ELSE 0 END)
+        OR (CASE WHEN namespace = '' THEN key ELSE namespace || ':' || key END) = ?
+        OR key = ?
+      )
+    `);
+        const rawResult = candidateStmt.all(this.packageId, decoded ? 1 : null, decoded?.namespace ?? "", decoded?.key ?? "", targetKey, targetKey);
+        const rawRows = Array.isArray(rawResult) ? rawResult : [];
+        const now = this.clock.now().getTime();
+        const uniqueMap = new Map();
+        for (const r of rawRows) {
+            if (r.expires_at && now >= new Date(r.expires_at).getTime()) {
+                const ns = r.namespace;
+                const k = r.key;
+                this.deleteState(ns, k).catch((err) => {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    this.logWarn(`[actiondock] expired state lazy delete failed (namespace='${ns}' key='${k}'): ${reason}`);
+                });
+                continue;
+            }
+            uniqueMap.set(`${r.namespace}\0${r.key}`, r);
+        }
+        return Array.from(uniqueMap.values());
+    }
+    async findState(targetKey, namespace) {
+        if (namespace !== undefined) {
+            const val = await this.getState(namespace, targetKey);
+            if (val === undefined)
+                return undefined;
+            const stmt = this.getStatement("SELECT updated_at, expires_at FROM state WHERE package_id = ? AND namespace = ? AND key = ?");
+            const row = stmt.get(this.packageId, namespace, targetKey);
+            return {
+                packageId: this.packageId,
+                namespace,
+                key: targetKey,
+                fullKey: encodeStateKey(namespace, targetKey),
+                value: val,
+                updatedAt: row?.updated_at || this.clock.now().toISOString(),
+                expiresAt: row?.expires_at,
+            };
+        }
+        const matchingRows = await this.findMatchingStateRows(targetKey);
+        if (matchingRows.length > 1) {
+            throw new ActionDockError(AMBIGUOUS_STATE_KEY, `Ambiguous state key '${targetKey}': matches ${matchingRows.length} entries (${matchingRows.map((r) => `${r.namespace}:${r.key}`).join(", ")})`);
+        }
+        if (matchingRows.length === 0) {
+            return undefined;
+        }
+        const row = matchingRows[0];
+        const parsedVal = safeParseStoredJson(row.value_json, `state db=${this.dbPath} package=${this.packageId} namespace=${row.namespace} key=${row.key}`);
+        return {
+            packageId: this.packageId,
+            namespace: row.namespace,
+            key: row.key,
+            fullKey: encodeStateKey(row.namespace, row.key),
+            value: parsedVal,
+            updatedAt: row.updated_at,
+            expiresAt: row.expires_at,
+        };
+    }
+    async setState(namespace, key, value, ttl) {
+        const stmt = this.getStatement(`
+      INSERT INTO state (package_id, namespace, key, value_json, updated_at, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(package_id, namespace, key) DO UPDATE SET
+        value_json = excluded.value_json,
+        updated_at = excluded.updated_at,
+        expires_at = excluded.expires_at
+    `);
+        const valJson = JSON.stringify(value);
+        const now = this.clock.now();
+        const updatedAt = now.toISOString();
+        let expiresAt = null;
+        if (typeof ttl === "number" && ttl > 0) {
+            expiresAt = new Date(now.getTime() + ttl * 1000).toISOString();
+        }
+        stmt.run(this.packageId, namespace, key, valJson, updatedAt, expiresAt);
+    }
+    async deleteState(namespace, key) {
+        const stmt = this.getStatement("DELETE FROM state WHERE package_id = ? AND namespace = ? AND key = ?");
+        const res = stmt.run(this.packageId, namespace, key);
+        return res.changes > 0;
+    }
+    async deleteStateSmart(targetKey, namespace) {
+        if (namespace !== undefined) {
+            return this.deleteState(namespace, targetKey);
+        }
+        const matchingRows = await this.findMatchingStateRows(targetKey);
+        if (matchingRows.length > 1) {
+            throw new ActionDockError(AMBIGUOUS_STATE_KEY, `Ambiguous state key '${targetKey}': matches ${matchingRows.length} entries for deletion (${matchingRows.map((r) => `${r.namespace}:${r.key}`).join(", ")})`);
+        }
+        if (matchingRows.length === 1) {
+            return this.deleteState(matchingRows[0].namespace, matchingRows[0].key);
+        }
+        return this.deleteState("", targetKey);
+    }
+    async cleanExpiredState(isClosed) {
+        if (isClosed)
+            return 0;
+        try {
+            const now = this.clock.now();
+            const stmt = this.getStatement("DELETE FROM state WHERE package_id = ? AND expires_at IS NOT NULL AND expires_at <= ?");
+            const res = stmt.run(this.packageId, now.toISOString());
+            const retentionCutoff = new Date(now.getTime() - IDEMPOTENCY_RETENTION_MS).toISOString();
+            try {
+                this.getStatement("DELETE FROM idempotency_keys WHERE created_at < ?").run(retentionCutoff);
+            }
+            catch (err) {
+                this.logWarn(`[actiondock] idempotency retention cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return res.changes;
+        }
+        catch (err) {
+            this.logWarn(`[actiondock] cleanExpiredState failed: ${err instanceof Error ? err.message : String(err)}`);
+            return 0;
+        }
+    }
+    async clearState(options = {}) {
+        let sql = "DELETE FROM state WHERE package_id = ?";
+        const params = [this.packageId];
+        if (options.namespace !== undefined) {
+            sql += " AND namespace = ?";
+            params.push(options.namespace);
+        }
+        if (options.prefix) {
+            sql += " AND key LIKE ? ESCAPE '\\'";
+            const escapedPrefix = options.prefix.replace(/([%_\\])/g, "\\$1");
+            params.push(`${escapedPrefix}%`);
+        }
+        const stmt = this.getStatement(sql);
+        const res = stmt.run(...params);
+        return res.changes;
+    }
+    async listStateKeys(namespace, prefix, isClosed) {
+        await this.cleanExpiredState(isClosed || false);
+        let sql = "SELECT namespace, key, expires_at FROM state WHERE package_id = ?";
+        const params = [this.packageId];
+        if (namespace !== null && namespace !== undefined) {
+            sql += " AND namespace = ?";
+            params.push(namespace);
+        }
+        if (prefix) {
+            sql += " AND key LIKE ? ESCAPE '\\'";
+            const escapedPrefix = prefix.replace(/([%_\\])/g, "\\$1");
+            params.push(`${escapedPrefix}%`);
+        }
+        const stmt = this.getStatement(sql);
+        const rawResult = stmt.all(...params);
+        const rows = Array.isArray(rawResult) ? rawResult : [];
+        const now = this.clock.now().getTime();
+        const result = [];
+        for (const row of rows) {
+            if (row.expires_at && now >= new Date(row.expires_at).getTime()) {
+                continue;
+            }
+            if (namespace !== null && namespace !== undefined) {
+                result.push(row.key);
+            }
+            else {
+                result.push(encodeStateKey(row.namespace, row.key));
+            }
+        }
+        return result;
+    }
+    async listStateEntries(options = {}, isClosed) {
+        await this.cleanExpiredState(isClosed || false);
+        let sql = "SELECT namespace, key, value_json, updated_at, expires_at FROM state WHERE package_id = ?";
+        const params = [this.packageId];
+        if (options.namespace !== undefined) {
+            sql += " AND namespace = ?";
+            params.push(options.namespace);
+        }
+        if (options.prefix) {
+            sql += " AND key LIKE ? ESCAPE '\\'";
+            const escapedPrefix = options.prefix.replace(/([%_\\])/g, "\\$1");
+            params.push(`${escapedPrefix}%`);
+        }
+        const stmt = this.getStatement(sql);
+        const rawResult = stmt.all(...params);
+        const rows = Array.isArray(rawResult) ? rawResult : [];
+        const now = this.clock.now().getTime();
+        const results = [];
+        for (const row of rows) {
+            if (row.expires_at && now >= new Date(row.expires_at).getTime()) {
+                continue;
+            }
+            const parsedVal = safeParseStoredJson(row.value_json, `state db=${this.dbPath} package=${this.packageId} namespace=${row.namespace} key=${row.key}`);
+            results.push({
+                packageId: this.packageId,
+                namespace: row.namespace,
+                key: row.key,
+                fullKey: encodeStateKey(row.namespace, row.key),
+                value: parsedVal,
+                updatedAt: row.updated_at,
+                expiresAt: row.expires_at,
+            });
+        }
+        return results;
+    }
+    close() {
+        this.statementCache.clear();
+    }
+}

package/dist/storage/sqlite.d.ts

@@ -1,72 +1,39 @@
-import { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, type RuntimeError, type RunRecord } from "@actiondock/sdk";
+import { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, type Logger, type RuntimeError, type RunRecord } from "@actiondock/sdk";
 import { type IdempotencyCheckResult, type IdempotencyRecord, type RunsRetentionPolicy, type RuntimeStorage, type StateEntry, type StorageOptions, type TerminalRunStatus } from "./types.js";
 export { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, };
-/**
- * 统一 SQLite 运行时存储实现。
- * 通过 SqliteDriver 抽象驱动，解耦底层具体运行时引擎。
- *
- * 跨进程并发模型：
- * - 同一数据目录下的 runtime.db 允许持有者进程（serve、mcp、ad run 等执行宿主）
- *   与旁观查询进程（ad state、ad runs、ad config 等只读命令）并发打开。
- * - 死亡会话遗留非终态运行记录的收割（recoverDeadSessionRuns）仅由显式声明
- *   持有者身份的打开方执行：StorageOptions.recoverOrphans 为 true 时构造阶段收割，
- *   宿主接管路径亦可显式调用 recoverDeadSessionRuns 收敛死亡会话记录。
- * - 旁观打开（默认 recoverOrphans 为 false）保持只读语义，绝不收敛其他进程的在途
- *   running 记录，防止查询进程把执行宿主的在途运行误收割为 interrupted，导致持有者
- *   侧终态结算静默丢失。
- * - updateRun 以 WHERE id = ? AND status = 'running' 条件更新；若命中零行且新状态
- *   为终态，说明记录已被其他持有者或恢复流程改写，此处输出告警保证状态漂移可观测。
- */
+export interface SqliteStorageOptions extends StorageOptions {
+    logger?: Logger;
+}
 export declare class SqliteRuntimeStorage implements RuntimeStorage {
     private driver;
     private packageId;
     private clock;
+    private logger?;
     private isClosed;
-    private statementCache;
     private dbPath;
     private recoverOrphans;
     private retentionPolicy?;
-    private lastRunsCleanupAt;
-    private runInsertCount;
-    private static readonly RUNS_CLEANUP_INTERVAL_MS;
-    private static readonly RUNS_CLEANUP_BATCH_THRESHOLD;
+    private runsStore;
+    private stateStore;
+    private configStore;
+    private eventsStore;
     get isOpen(): boolean;
     get closed(): boolean;
-    constructor(options: StorageOptions);
-    /**
-     * 初始化数据库结构并执行严格版本校验。
-     *
-     * 规则：
-     * - 空数据目录首次初始化在单个事务中完成完整 Schema 构建。
-     * - 若创建事务失败则拒绝启动且不留下残缺表。
-     * - 打开旧版本或不兼容版本的数据库时，在写事务前直接抛出 UNSUPPORTED_STORAGE_SCHEMA 异常并拒绝启动。
-     */
+    private logWarn;
+    constructor(options: SqliteStorageOptions);
     private init;
-    /**
-     * 收敛死亡会话遗留的非终态运行任务。
-     */
-    recoverDeadSessionRuns(currentHostSessionId?: string): number;
-    /**
-     * 获取或复用预编译 SQL 语句缓存。
-     */
-    private getStatement;
+    recoverDeadSessionRuns(currentHostSessionId?: string, options?: {
+        probe?: import("./run-liveness.js").ProcessLivenessProbe;
+    }): number;
     getConfig<T = unknown>(key: string): T | undefined;
     listConfig(): Record<string, unknown>;
     setConfig(key: string, value: unknown): void;
     deleteConfig(key: string): boolean;
     getState<T = unknown>(namespace: string, key: string): Promise<T | undefined>;
-    private findMatchingStateRows;
     findState<T = unknown>(targetKey: string, namespace?: string): Promise<StateEntry | undefined>;
     setState<T = unknown>(namespace: string, key: string, value: T, ttl?: number): Promise<void>;
     deleteState(namespace: string, key: string): Promise<boolean>;
     deleteStateSmart(targetKey: string, namespace?: string): Promise<boolean>;
-    /**
-     * 清理已过期的状态记录。
-     *
-     * 同时按 TargetInfo.idempotencyPolicy 声明的 24 小时保留窗口，
-     * 清理 idempotency_keys 表中超过保留期的幂等去重记录，
-     * 保证承诺的 retentionMs 策略与实际清理逻辑一致。
-     */
     cleanExpiredState(): Promise<number>;
     clearState(options?: {
         namespace?: string;
@@ -85,25 +52,31 @@ export declare class SqliteRuntimeStorage implements RuntimeStorage {
         actionId?: string;
         status?: string;
         limit?: number;
+        offset?: number;
     }): RunRecord[];
+    countRuns(options?: {
+        actionId?: string;
+        status?: string;
+        requestIds?: string[];
+    }): number;
     clearRuns(options?: {
         actionId?: string;
         status?: string;
         olderThanMs?: number;
         keep?: number;
     }): number;
-    /**
-     * 按保留策略清理过期的终态运行记录与超出容量限制的最旧运行记录。
-     *
-     * 包含：
-     * - 基于时间：删除早于 maxAgeMs 的终态记录（保留 minRetainRuns 保底数量）。
-     * - 基于数量：若终态记录总数超过 maxRuns，按时间由旧至新淘汰超出部分。
-     * - 级联清理孤立的幂等去重记录。
-     */
     cleanExpiredRuns(policy?: RunsRetentionPolicy): number;
-    private resolveRetentionPolicy;
+    touchRunHeartbeat(runIds: string[]): number;
     checkAndRecordIdempotency(record: IdempotencyRecord): IdempotencyCheckResult;
     getIdempotencyRecord(ownerId: string, actionRef: string, requestId: string): IdempotencyRecord | undefined;
-    private mapRunRecord;
+    listRunsByRequestIds(requestIds: string[]): RunRecord[];
+    countRunsByRequestIds(requestIds: string[], options?: {
+        actionId?: string;
+        status?: string;
+    }): number;
+    getRunRequestIds(runIds: string[]): Record<string, string>;
+    getRunWithRequestId(id: string): RunRecord | null;
+    appendEvent(eventType: string, payload: unknown): void;
+    queryEvents(eventType?: string): any[];
     close(): Promise<void>;
 }