opencode-gateway 0.1.0

package/dist/runtime/mailbox.js

@@ -0,0 +1,112 @@
+import { formatError } from "../utils/error";
+import { deleteInboundAttachmentFiles } from "./attachments";
+const RETRY_DELAY_MS = 1_000;
+export class GatewayMailboxRuntime {
+    executor;
+    store;
+    logger;
+    config;
+    questions;
+    activeMailboxes = new Set();
+    scheduledMailboxes = new Map();
+    constructor(executor, store, logger, config, questions) {
+        this.executor = executor;
+        this.store = store;
+        this.logger = logger;
+        this.config = config;
+        this.questions = questions;
+    }
+    start() {
+        for (const mailboxKey of this.store.listPendingMailboxKeys()) {
+            this.scheduleImmediate(mailboxKey);
+        }
+    }
+    async enqueueInboundMessage(message, sourceKind, externalId) {
+        if (await this.questions.tryHandleInboundMessage(message)) {
+            return;
+        }
+        const prepared = this.executor.prepareInboundMessage(message);
+        const recordedAtMs = Date.now();
+        this.store.enqueueMailboxEntry({
+            mailboxKey: prepared.conversationKey,
+            sourceKind,
+            externalId,
+            sender: message.sender,
+            text: message.text,
+            attachments: message.attachments,
+            replyChannel: message.deliveryTarget.channel,
+            replyTarget: message.deliveryTarget.target,
+            replyTopic: message.deliveryTarget.topic,
+            recordedAtMs,
+        });
+        this.store.appendJournal(createJournalEntry("mailbox_enqueue", recordedAtMs, prepared.conversationKey, {
+            sourceKind,
+            externalId,
+            sender: message.sender,
+            text: message.text,
+            attachments: message.attachments,
+            deliveryTarget: message.deliveryTarget,
+        }));
+        this.scheduleAfterEnqueue(prepared.conversationKey);
+    }
+    scheduleAfterEnqueue(mailboxKey) {
+        if (this.activeMailboxes.has(mailboxKey) || this.scheduledMailboxes.has(mailboxKey)) {
+            return;
+        }
+        this.schedule(mailboxKey, this.config.batchReplies ? this.config.batchWindowMs : 0);
+    }
+    scheduleImmediate(mailboxKey) {
+        if (this.activeMailboxes.has(mailboxKey) || this.scheduledMailboxes.has(mailboxKey)) {
+            return;
+        }
+        this.schedule(mailboxKey, 0);
+    }
+    scheduleRetry(mailboxKey) {
+        if (this.activeMailboxes.has(mailboxKey) || this.scheduledMailboxes.has(mailboxKey)) {
+            return;
+        }
+        this.schedule(mailboxKey, RETRY_DELAY_MS);
+    }
+    schedule(mailboxKey, delayMs) {
+        const handle = setTimeout(() => {
+            this.scheduledMailboxes.delete(mailboxKey);
+            void this.processMailbox(mailboxKey);
+        }, delayMs);
+        this.scheduledMailboxes.set(mailboxKey, handle);
+    }
+    async processMailbox(mailboxKey) {
+        if (this.activeMailboxes.has(mailboxKey)) {
+            return;
+        }
+        this.activeMailboxes.add(mailboxKey);
+        try {
+            const entries = this.store.listMailboxEntries(mailboxKey);
+            if (entries.length === 0) {
+                return;
+            }
+            const batch = this.config.batchReplies ? entries : [entries[0]];
+            await this.executor.executeMailboxEntries(batch);
+            this.store.deleteMailboxEntries(batch.map((entry) => entry.id));
+            await deleteInboundAttachmentFiles(batch, this.logger);
+        }
+        catch (error) {
+            this.logger.log("warn", `mailbox flush failed for ${mailboxKey}: ${formatError(error)}`);
+            this.scheduleRetry(mailboxKey);
+            return;
+        }
+        finally {
+            this.activeMailboxes.delete(mailboxKey);
+        }
+        if (this.store.listMailboxEntries(mailboxKey).length > 0) {
+            this.scheduleImmediate(mailboxKey);
+        }
+    }
+}
+function createJournalEntry(kind, recordedAtMs, conversationKey, payload) {
+    return {
+        kind,
+        recordedAtMs,
+        conversationKey,
+        payload,
+    };
+}

package/dist/runtime/opencode-runner.d.ts

@@ -0,0 +1,26 @@
+import type { BindingPromptPart, GatewayBindingModule } from "../binding";
+import type { TextDeliverySession } from "../delivery/text";
+import type { OpencodeSdkAdapter } from "../opencode/adapter";
+import type { OpencodeEventHub } from "../opencode/events";
+export type OpencodeDriverPrompt = {
+    promptKey: string;
+    parts: BindingPromptPart[];
+};
+export type PromptExecutionResult = {
+    sessionId: string;
+    responseText: string;
+    finalText: string | null;
+};
+type GatewayOpencodeRuntimeLike = Pick<OpencodeSdkAdapter, "execute">;
+type TextDeliverySessionLike = Pick<TextDeliverySession, "mode" | "preview">;
+export declare function runOpencodeDriver(options: {
+    module: GatewayBindingModule;
+    opencode: GatewayOpencodeRuntimeLike;
+    events: OpencodeEventHub;
+    conversationKey: string;
+    persistedSessionId: string | null;
+    deliverySession: TextDeliverySessionLike | null;
+    prompts: OpencodeDriverPrompt[];
+    onSessionAvailable?: (sessionId: string) => Promise<void> | void;
+}): Promise<PromptExecutionResult>;
+export {};

package/dist/runtime/opencode-runner.js

@@ -0,0 +1,79 @@
+const DEFAULT_FLUSH_INTERVAL_MS = 400;
+export async function runOpencodeDriver(options) {
+    const driver = new options.module.OpencodeExecutionDriver({
+        conversationKey: options.conversationKey,
+        persistedSessionId: options.persistedSessionId,
+        mode: options.deliverySession?.mode === "progressive" ? "progressive" : "oneshot",
+        flushIntervalMs: DEFAULT_FLUSH_INTERVAL_MS,
+        prompts: options.prompts,
+    });
+    let registration = null;
+    let activeSessionId = null;
+    try {
+        let step = driver.start();
+        for (;;) {
+            if (step.kind === "command") {
+                activeSessionId = await syncSessionContext(activeSessionId, step.command, options.onSessionAvailable);
+                registration = syncDriverRegistration(registration, step.command, driver, options);
+                const result = await options.opencode.execute(step.command);
+                activeSessionId = await syncSessionContext(activeSessionId, result, options.onSessionAvailable);
+                registration = syncDriverRegistration(registration, result, driver, options);
+                step = driver.resume(result);
+                continue;
+            }
+            if (step.kind === "complete") {
+                return {
+                    sessionId: step.sessionId,
+                    responseText: step.responseText,
+                    finalText: step.finalText,
+                };
+            }
+            throw new Error(step.message);
+        }
+    }
+    finally {
+        registration?.dispose();
+        driver.free?.();
+    }
+}
+async function syncSessionContext(currentSessionId, value, onSessionAvailable) {
+    const sessionId = sessionIdFromCommandOrResult(value);
+    if (sessionId === null || sessionId === currentSessionId) {
+        return currentSessionId;
+    }
+    await onSessionAvailable?.(sessionId);
+    return sessionId;
+}
+function syncDriverRegistration(registration, value, driver, options) {
+    const sessionId = sessionIdFromCommandOrResult(value);
+    if (sessionId === null) {
+        return registration;
+    }
+    if (registration !== null) {
+        registration.updateSession(sessionId);
+        return registration;
+    }
+    const deliverySession = options.deliverySession;
+    return options.events.registerDriver(sessionId, driver, async (snapshot) => {
+        if (deliverySession?.mode !== "progressive") {
+            return;
+        }
+        await deliverySession.preview(snapshot);
+    });
+}
+function sessionIdFromCommandOrResult(value) {
+    switch (value.kind) {
+        case "lookupSession":
+        case "waitUntilIdle":
+        case "appendPrompt":
+        case "sendPromptAsync":
+        case "awaitPromptResponse":
+        case "readMessage":
+        case "listMessages":
+            return value.sessionId;
+        case "createSession":
+            return "sessionId" in value ? value.sessionId : null;
+        case "error":
+            return value.sessionId;
+    }
+}

package/dist/session/context.d.ts

@@ -0,0 +1,10 @@
+import type { BindingDeliveryTarget } from "../binding";
+import type { SqliteStore } from "../store/sqlite";
+export declare class GatewaySessionContext {
+    private readonly store;
+    constructor(store: SqliteStore);
+    replaceReplyTargets(sessionId: string, conversationKey: string, targets: BindingDeliveryTarget[], recordedAtMs: number): void;
+    listReplyTargets(sessionId: string): BindingDeliveryTarget[];
+    getDefaultReplyTarget(sessionId: string): BindingDeliveryTarget | null;
+    buildSystemPrompt(sessionId: string): string | null;
+}

package/dist/session/context.js

@@ -0,0 +1,44 @@
+export class GatewaySessionContext {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    replaceReplyTargets(sessionId, conversationKey, targets, recordedAtMs) {
+        this.store.replaceSessionReplyTargets({
+            sessionId,
+            conversationKey,
+            targets,
+            recordedAtMs,
+        });
+    }
+    listReplyTargets(sessionId) {
+        return this.store.listSessionReplyTargets(sessionId);
+    }
+    getDefaultReplyTarget(sessionId) {
+        return this.store.getDefaultSessionReplyTarget(sessionId);
+    }
+    buildSystemPrompt(sessionId) {
+        const targets = this.listReplyTargets(sessionId);
+        if (targets.length === 0) {
+            return null;
+        }
+        if (targets.length === 1) {
+            const target = targets[0];
+            return [
+                "Gateway context:",
+                `- Current message source channel: ${target.channel}`,
+                `- Current reply target id: ${target.target}`,
+                `- Current reply topic: ${target.topic ?? "none"}`,
+                "- Unless the user explicitly asks otherwise, channel-aware actions should default to this target.",
+                "- If the user asks to start a fresh channel session, use channel_new_session.",
+            ].join("\n");
+        }
+        return [
+            "Gateway context:",
+            `- This session currently fans out to ${targets.length} reply targets.`,
+            ...targets.map((target, index) => `- Target ${index + 1}: channel=${target.channel}, id=${target.target}, topic=${target.topic ?? "none"}`),
+            "- If a tool needs a single explicit target, do not guess; ask the user or use explicit tool arguments.",
+            "- If the user asks to start a fresh channel session for this route, use channel_new_session.",
+        ].join("\n");
+    }
+}

package/dist/session/conversation-key.d.ts

@@ -0,0 +1,3 @@
+import type { BindingDeliveryTarget, GatewayContract } from "../binding";
+import type { GatewayMailboxRouter } from "../mailbox/router";
+export declare function resolveConversationKeyForTarget(target: BindingDeliveryTarget, router: GatewayMailboxRouter, contract: Pick<GatewayContract, "conversationKeyForDeliveryTarget">): string;

package/dist/session/conversation-key.js

@@ -0,0 +1,3 @@
+export function resolveConversationKeyForTarget(target, router, contract) {
+    return router.resolve(target) ?? contract.conversationKeyForDeliveryTarget(target);
+}

package/dist/session/switcher.d.ts

@@ -0,0 +1,25 @@
+import type { BindingDeliveryTarget, GatewayContract } from "../binding";
+import type { GatewayMailboxRouter } from "../mailbox/router";
+import type { OpencodeSdkAdapter } from "../opencode/adapter";
+import type { SqliteStore } from "../store/sqlite";
+import type { GatewaySessionContext } from "./context";
+export type ChannelSessionSwitchResult = {
+    channel: string;
+    target: string;
+    topic: string | null;
+    conversationKey: string;
+    previousSessionId: string | null;
+    newSessionId: string;
+    effectiveOn: "next_message";
+};
+export declare class ChannelSessionSwitcher {
+    private readonly store;
+    private readonly sessions;
+    private readonly router;
+    private readonly contract;
+    private readonly opencode;
+    private readonly telegramEnabled;
+    constructor(store: SqliteStore, sessions: GatewaySessionContext, router: GatewayMailboxRouter, contract: Pick<GatewayContract, "conversationKeyForDeliveryTarget">, opencode: Pick<OpencodeSdkAdapter, "createFreshSession">, telegramEnabled: boolean);
+    hasEnabledChannel(): boolean;
+    createAndSwitchSession(target: BindingDeliveryTarget, title: string | null): Promise<ChannelSessionSwitchResult>;
+}

package/dist/session/switcher.js

@@ -0,0 +1,59 @@
+import { resolveConversationKeyForTarget } from "./conversation-key";
+export class ChannelSessionSwitcher {
+    store;
+    sessions;
+    router;
+    contract;
+    opencode;
+    telegramEnabled;
+    constructor(store, sessions, router, contract, opencode, telegramEnabled) {
+        this.store = store;
+        this.sessions = sessions;
+        this.router = router;
+        this.contract = contract;
+        this.opencode = opencode;
+        this.telegramEnabled = telegramEnabled;
+    }
+    hasEnabledChannel() {
+        return this.telegramEnabled;
+    }
+    async createAndSwitchSession(target, title) {
+        assertSupportedTarget(target, this.telegramEnabled);
+        const conversationKey = resolveConversationKeyForTarget(target, this.router, this.contract);
+        const previousSessionId = this.store.getSessionBinding(conversationKey);
+        const recordedAtMs = Date.now();
+        const newSessionId = await this.opencode.createFreshSession(defaultSessionTitle(title, target));
+        if (previousSessionId !== null) {
+            this.store.deletePendingQuestionsForSession(previousSessionId);
+            this.store.clearSessionReplyTargets(previousSessionId);
+        }
+        this.store.putSessionBinding(conversationKey, newSessionId, recordedAtMs);
+        this.sessions.replaceReplyTargets(newSessionId, conversationKey, [target], recordedAtMs);
+        return {
+            channel: target.channel,
+            target: target.target,
+            topic: target.topic,
+            conversationKey,
+            previousSessionId,
+            newSessionId,
+            effectiveOn: "next_message",
+        };
+    }
+}
+function assertSupportedTarget(target, telegramEnabled) {
+    if (target.channel !== "telegram") {
+        throw new Error(`unsupported channel for session switching: ${target.channel}`);
+    }
+    if (!telegramEnabled) {
+        throw new Error("telegram is not enabled");
+    }
+}
+function defaultSessionTitle(title, target) {
+    const normalized = title?.trim() ?? "";
+    if (normalized.length > 0) {
+        return normalized;
+    }
+    return target.topic === null
+        ? `Gateway ${target.channel}:${target.target}`
+        : `Gateway ${target.channel}:${target.target} topic ${target.topic}`;
+}

package/dist/store/migrations.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from "bun:sqlite";
+export declare function migrateGatewayDatabase(db: Database): void;

package/dist/store/migrations.js

@@ -0,0 +1,183 @@
+const LATEST_SCHEMA_VERSION = 6;
+export function migrateGatewayDatabase(db) {
+    db.exec("PRAGMA journal_mode = WAL;");
+    db.exec("PRAGMA foreign_keys = ON;");
+    let currentVersion = readUserVersion(db);
+    if (currentVersion > LATEST_SCHEMA_VERSION) {
+        throw new Error(`unsupported gateway database schema version: ${currentVersion}`);
+    }
+    if (currentVersion === 0) {
+        migrateToV1(db);
+        currentVersion = 1;
+    }
+    if (currentVersion === 1) {
+        migrateToV2(db);
+        currentVersion = 2;
+    }
+    if (currentVersion === 2) {
+        migrateToV3(db);
+        currentVersion = 3;
+    }
+    if (currentVersion === 3) {
+        migrateToV4(db);
+        currentVersion = 4;
+    }
+    if (currentVersion === 4) {
+        migrateToV5(db);
+        currentVersion = 5;
+    }
+    if (currentVersion === 5) {
+        migrateToV6(db);
+    }
+}
+function readUserVersion(db) {
+    const row = db.query("PRAGMA user_version;").get();
+    return row?.user_version ?? 0;
+}
+function migrateToV1(db) {
+    db.exec(`
+        CREATE TABLE session_bindings (
+            conversation_key TEXT PRIMARY KEY NOT NULL,
+            session_id TEXT NOT NULL,
+            updated_at_ms INTEGER NOT NULL
+        );
+
+        CREATE TABLE runtime_journal (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            kind TEXT NOT NULL,
+            recorded_at_ms INTEGER NOT NULL,
+            conversation_key TEXT,
+            payload_json TEXT NOT NULL
+        );
+
+        CREATE INDEX runtime_journal_kind_recorded_at_ms_idx
+            ON runtime_journal (kind, recorded_at_ms);
+    `);
+    db.exec("PRAGMA user_version = 1;");
+}
+function migrateToV2(db) {
+    db.exec(`
+        CREATE TABLE kv_state (
+            key TEXT PRIMARY KEY NOT NULL,
+            value TEXT NOT NULL,
+            updated_at_ms INTEGER NOT NULL
+        );
+    `);
+    db.exec("PRAGMA user_version = 2;");
+}
+function migrateToV3(db) {
+    db.exec(`
+        CREATE TABLE cron_jobs (
+            id TEXT PRIMARY KEY NOT NULL,
+            schedule TEXT NOT NULL,
+            prompt TEXT NOT NULL,
+            delivery_channel TEXT,
+            delivery_target TEXT,
+            delivery_topic TEXT,
+            enabled INTEGER NOT NULL,
+            next_run_at_ms INTEGER NOT NULL,
+            created_at_ms INTEGER NOT NULL,
+            updated_at_ms INTEGER NOT NULL
+        );
+
+        CREATE INDEX cron_jobs_enabled_next_run_at_ms_idx
+            ON cron_jobs (enabled, next_run_at_ms);
+
+        CREATE TABLE cron_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            job_id TEXT NOT NULL,
+            scheduled_for_ms INTEGER NOT NULL,
+            started_at_ms INTEGER NOT NULL,
+            finished_at_ms INTEGER,
+            status TEXT NOT NULL,
+            response_text TEXT,
+            error_message TEXT
+        );
+
+        CREATE INDEX cron_runs_job_id_started_at_ms_idx
+            ON cron_runs (job_id, started_at_ms DESC);
+
+        CREATE INDEX cron_runs_status_started_at_ms_idx
+            ON cron_runs (status, started_at_ms DESC);
+    `);
+    db.exec("PRAGMA user_version = 3;");
+}
+function migrateToV4(db) {
+    db.exec(`
+        CREATE TABLE mailbox_entries (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            mailbox_key TEXT NOT NULL,
+            source_kind TEXT NOT NULL,
+            external_id TEXT NOT NULL,
+            sender TEXT NOT NULL,
+            body TEXT NOT NULL,
+            reply_channel TEXT,
+            reply_target TEXT,
+            reply_topic TEXT,
+            created_at_ms INTEGER NOT NULL
+        );
+
+        CREATE UNIQUE INDEX mailbox_entries_source_kind_external_id_idx
+            ON mailbox_entries (source_kind, external_id);
+
+        CREATE INDEX mailbox_entries_mailbox_key_id_idx
+            ON mailbox_entries (mailbox_key, id);
+    `);
+    db.exec("PRAGMA user_version = 4;");
+}
+function migrateToV5(db) {
+    db.exec(`
+        CREATE TABLE mailbox_entry_attachments (
+            mailbox_entry_id INTEGER NOT NULL REFERENCES mailbox_entries(id) ON DELETE CASCADE,
+            ordinal INTEGER NOT NULL,
+            kind TEXT NOT NULL,
+            mime_type TEXT NOT NULL,
+            file_name TEXT,
+            local_path TEXT NOT NULL,
+            PRIMARY KEY (mailbox_entry_id, ordinal)
+        );
+
+        CREATE INDEX mailbox_entry_attachments_entry_id_ordinal_idx
+            ON mailbox_entry_attachments (mailbox_entry_id, ordinal);
+    `);
+    db.exec("PRAGMA user_version = 5;");
+}
+function migrateToV6(db) {
+    db.exec(`
+        CREATE TABLE session_reply_targets (
+            session_id TEXT NOT NULL,
+            ordinal INTEGER NOT NULL,
+            conversation_key TEXT NOT NULL,
+            delivery_channel TEXT NOT NULL,
+            delivery_target TEXT NOT NULL,
+            delivery_topic TEXT NOT NULL,
+            updated_at_ms INTEGER NOT NULL,
+            PRIMARY KEY (session_id, ordinal)
+        );
+
+        CREATE INDEX session_reply_targets_conversation_key_updated_at_ms_idx
+            ON session_reply_targets (conversation_key, updated_at_ms DESC);
+
+        CREATE TABLE pending_questions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            request_id TEXT NOT NULL,
+            session_id TEXT NOT NULL,
+            delivery_channel TEXT NOT NULL,
+            delivery_target TEXT NOT NULL,
+            delivery_topic TEXT NOT NULL,
+            question_json TEXT NOT NULL,
+            telegram_message_id INTEGER,
+            created_at_ms INTEGER NOT NULL
+        );
+
+        CREATE UNIQUE INDEX pending_questions_request_target_topic_idx
+            ON pending_questions (request_id, delivery_channel, delivery_target, delivery_topic);
+
+        CREATE INDEX pending_questions_target_topic_created_at_ms_idx
+            ON pending_questions (delivery_channel, delivery_target, delivery_topic, created_at_ms);
+
+        CREATE INDEX pending_questions_session_id_created_at_ms_idx
+            ON pending_questions (session_id, created_at_ms);
+    `);
+    db.exec(`PRAGMA user_version = ${LATEST_SCHEMA_VERSION};`);
+}

package/dist/store/sqlite.d.ts

@@ -0,0 +1,127 @@
+import { Database } from "bun:sqlite";
+import type { BindingDeliveryTarget } from "../binding";
+import type { GatewayQuestionInfo, PendingQuestionRecord } from "../questions/types";
+export type RuntimeJournalKind = "inbound_message" | "cron_dispatch" | "delivery" | "mailbox_enqueue" | "mailbox_flush";
+export type CronRunStatus = "running" | "succeeded" | "failed" | "abandoned";
+export type RuntimeJournalEntry = {
+    kind: RuntimeJournalKind;
+    recordedAtMs: number;
+    conversationKey: string | null;
+    payload: unknown;
+};
+export type CronJobRecord = {
+    id: string;
+    schedule: string;
+    prompt: string;
+    deliveryChannel: string | null;
+    deliveryTarget: string | null;
+    deliveryTopic: string | null;
+    enabled: boolean;
+    nextRunAtMs: number;
+    createdAtMs: number;
+    updatedAtMs: number;
+};
+export type MailboxEntryRecord = {
+    id: number;
+    mailboxKey: string;
+    sourceKind: string;
+    externalId: string;
+    sender: string;
+    text: string | null;
+    attachments: MailboxEntryAttachmentRecord[];
+    replyChannel: string | null;
+    replyTarget: string | null;
+    replyTopic: string | null;
+    createdAtMs: number;
+};
+export type MailboxEntryAttachmentRecord = {
+    kind: "image";
+    ordinal: number;
+    mimeType: string;
+    fileName: string | null;
+    localPath: string;
+};
+export type PersistCronJobInput = {
+    id: string;
+    schedule: string;
+    prompt: string;
+    deliveryChannel: string | null;
+    deliveryTarget: string | null;
+    deliveryTopic: string | null;
+    enabled: boolean;
+    nextRunAtMs: number;
+    recordedAtMs: number;
+};
+export type PersistMailboxEntryInput = {
+    mailboxKey: string;
+    sourceKind: string;
+    externalId: string;
+    sender: string;
+    text: string | null;
+    attachments: PersistMailboxEntryAttachmentInput[];
+    replyChannel: string | null;
+    replyTarget: string | null;
+    replyTopic: string | null;
+    recordedAtMs: number;
+};
+export type PersistMailboxEntryAttachmentInput = {
+    kind: "image";
+    mimeType: string;
+    fileName: string | null;
+    localPath: string;
+};
+export type PersistSessionReplyTargetsInput = {
+    sessionId: string;
+    conversationKey: string;
+    targets: BindingDeliveryTarget[];
+    recordedAtMs: number;
+};
+export type PersistPendingQuestionInput = {
+    requestId: string;
+    sessionId: string;
+    questions: GatewayQuestionInfo[];
+    targets: Array<{
+        deliveryTarget: BindingDeliveryTarget;
+        telegramMessageId: number | null;
+    }>;
+    recordedAtMs: number;
+};
+export declare class SqliteStore {
+    private readonly db;
+    constructor(db: Database);
+    getSessionBinding(conversationKey: string): string | null;
+    putSessionBinding(conversationKey: string, sessionId: string, recordedAtMs: number): void;
+    putSessionBindingIfUnchanged(conversationKey: string, expectedSessionId: string | null, nextSessionId: string, recordedAtMs: number): boolean;
+    deleteSessionBinding(conversationKey: string): void;
+    clearSessionReplyTargets(sessionId: string): void;
+    replaceSessionReplyTargets(input: PersistSessionReplyTargetsInput): void;
+    listSessionReplyTargets(sessionId: string): BindingDeliveryTarget[];
+    getDefaultSessionReplyTarget(sessionId: string): BindingDeliveryTarget | null;
+    appendJournal(entry: RuntimeJournalEntry): void;
+    replacePendingQuestion(input: PersistPendingQuestionInput): void;
+    deletePendingQuestion(requestId: string): void;
+    deletePendingQuestionsForSession(sessionId: string): void;
+    getPendingQuestionForTarget(target: BindingDeliveryTarget): PendingQuestionRecord | null;
+    getPendingQuestionForTelegramMessage(target: BindingDeliveryTarget, telegramMessageId: number): PendingQuestionRecord | null;
+    hasMailboxEntry(sourceKind: string, externalId: string): boolean;
+    enqueueMailboxEntry(input: PersistMailboxEntryInput): void;
+    listPendingMailboxKeys(): string[];
+    listMailboxEntries(mailboxKey: string): MailboxEntryRecord[];
+    deleteMailboxEntries(ids: number[]): void;
+    getTelegramUpdateOffset(): number | null;
+    putTelegramUpdateOffset(offset: number, recordedAtMs: number): void;
+    getStateValue(key: string): string | null;
+    putStateValue(key: string, value: string, recordedAtMs: number): void;
+    upsertCronJob(input: PersistCronJobInput): void;
+    getCronJob(id: string): CronJobRecord | null;
+    listCronJobs(): CronJobRecord[];
+    listOverdueCronJobs(nowMs: number): CronJobRecord[];
+    listDueCronJobs(nowMs: number, limit: number): CronJobRecord[];
+    removeCronJob(id: string): boolean;
+    updateCronJobNextRun(id: string, nextRunAtMs: number, recordedAtMs: number): void;
+    insertCronRun(jobId: string, scheduledForMs: number, startedAtMs: number): number;
+    finishCronRun(runId: number, status: Exclude<CronRunStatus, "running">, finishedAtMs: number, responseText: string | null, errorMessage: string | null): void;
+    abandonRunningCronRuns(finishedAtMs: number): number;
+    close(): void;
+}
+export declare function openSqliteStore(path: string): Promise<SqliteStore>;