@ai-setting/roy-agent-core 1.7.52 → 1.7.55

package/dist/env/session/session-message-converter.d.ts

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Session Message Converter
+ *
+ * Converts between SessionMessage (storage format) and AI SDK ModelMessage (LLM format).
+ *
+ * This module provides a class-based API for message conversion.
+ */
+import type { SessionMessage } from "./types";
+interface ModelMessage {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string | ModelContentPart[];
+}
+/**
+ * Content part for AI SDK ModelMessage
+ */
+type ModelContentPart = TextContentPart | ReasoningContentPart | ToolCallContentPart | ToolResultContentPart | FileContentPart | ImageContentPart;
+interface TextContentPart {
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+}
+interface ReasoningContentPart {
+    type: "reasoning";
+    text: string;
+    reasoningType?: "core" | "effort" | "summary";
+}
+interface ToolCallContentPart {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+}
+interface ToolResultContentPart {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: string;
+}
+interface FileContentPart {
+    type: "file";
+    url: string;
+    mimeType?: string;
+    filename?: string;
+}
+/**
+ * AI SDK v6 image part (lossless round-trip with `ImagePart`).
+ *
+ * @see https://ai-sdk.dev/docs/reference/ai-sdk-core/image-part
+ *
+ * The `image` field accepts `string | URL | Uint8Array` (and `DataContent`,
+ * which is itself a union that includes `Uint8Array`). We widen the local
+ * type to `Uint8Array` so that legacy `{type:"Buffer", data:[]}` payloads
+ * recovered from SQLite can be rehydrated into a typed array instead of
+ * a plain object. This unblocks the B1 round-trip regression.
+ */
+interface ImageContentPart {
+    type: "image";
+    /** Image data — base64/data URL, raw bytes, or a remote URL */
+    image: string | URL | Uint8Array;
+    /** Optional MIME type (e.g. "image/png") */
+    mimeType?: string;
+}
+/**
+ * SessionMessageConverter
+ *
+ * Converts between SessionMessage (storage format) and AI SDK ModelMessage (LLM format).
+ *
+ * @example
+ * ```typescript
+ * const converter = new SessionMessageConverter();
+ * const modelMsg = converter.toModelMessage(sessionMsg);
+ * const sessionMsg = converter.fromModelMessage(modelMsg);
+ * ```
+ */
+export declare class SessionMessageConverter {
+    /**
+     * Convert a SessionMessage to AI SDK ModelMessage format
+     *
+     * @param msg - SessionMessage to convert
+     * @returns ModelMessage compatible with AI SDK v6
+     */
+    toModelMessage(msg: SessionMessage): ModelMessage;
+    /**
+     * Convert an AI SDK ModelMessage to SessionMessage format
+     *
+     * @param aiMsg - AI SDK ModelMessage to convert (accepts any object with role and content)
+     * @param options - Optional sessionID and messageID
+     * @returns SessionMessage compatible with storage format
+     *
+     * 设置 metadata.type 以便后续正确过滤：
+     * - "tool_call": assistant 消息包含 tool-call parts
+     * - "tool_result": tool 消息
+     */
+    fromModelMessage(aiMsg: {
+        role: string;
+        content: unknown;
+        [key: string]: unknown;
+    }, options?: {
+        sessionID?: string;
+        messageID?: string;
+    }): SessionMessage;
+    /**
+     * Convert a list of SessionMessages to AI SDK history format
+     *
+     * @param messages - Array of SessionMessages to convert
+     * @returns Array of ModelMessages filtered by archived status
+     */
+    sessionToHistory(messages: SessionMessage[]): ModelMessage[];
+    /**
+     * Extract provider-specific options from SessionMessage
+     *
+     * Some models (e.g., DeepSeek R1, Kimi k2.5) require reasoning configuration
+     * through providerOptions.
+     *
+     * @param msg - SessionMessage to extract options from
+     * @returns Provider-specific options object for LLM calls
+     */
+    extractProviderOptions(msg: SessionMessage): Record<string, unknown>;
+    /**
+     * Migrate old format message to new format
+     *
+     * Handles backward compatibility by converting old messages with just content
+     * to new format with proper parts array.
+     *
+     * @param oldMsg - Message in possibly old format
+     * @returns Message in new format with parts array
+     */
+    migrateMessage(oldMsg: Partial<SessionMessage>): SessionMessage;
+}
+export declare function toModelMessage(msg: SessionMessage): ModelMessage;
+export declare function fromModelMessage(aiMsg: {
+    role: string;
+    content: unknown;
+    [key: string]: unknown;
+}, options?: {
+    sessionID?: string;
+    messageID?: string;
+}): SessionMessage;
+export declare function sessionToHistory(messages: SessionMessage[]): ModelMessage[];
+export declare function extractProviderOptions(msg: SessionMessage): Record<string, unknown>;
+export declare function migrateMessage(oldMsg: Partial<SessionMessage>): SessionMessage;
+export {};

package/dist/env/session/session-store.d.ts

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview Session Store Interface
+ */
+import type { Session, CreateSessionOptions, UpdateSessionOptions, ListSessionsOptions, SessionMessage, SessionCheckpoint, // (new)
+GetMessagesOptions, // (new)
+SearchMessagesOptions, // (new)
+MessageMatch } from "./types";
+/**
+ * Session Store Interface
+ * Defines the contract for session storage implementations
+ */
+export interface SessionStore {
+    /**
+     * Create a new session
+     */
+    create(options: CreateSessionOptions): Promise<Session>;
+    /**
+     * Get a session by ID
+     */
+    get(id: string): Promise<Session | undefined>;
+    /**
+     * List sessions with optional filtering
+     */
+    list(options?: ListSessionsOptions): Promise<Session[]>;
+    /**
+     * Update a session
+     */
+    update(id: string, updates: UpdateSessionOptions): Promise<boolean>;
+    /**
+     * Delete a session
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Get total session count (without pagination)
+     */
+    getCount(): Promise<number>;
+    /**
+     * Add a message to a session
+     */
+    addMessage(sessionId: string, message: {
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    /**
+     * Add multiple messages to a session atomically (single transaction).
+     *
+     * Layer 3 of sessions.db fix: one BEGIN/COMMIT block per call, instead
+     * of N×2 separate statements (each `addMessage` does an INSERT plus a
+     * UPDATE on `session` for `message_count`). This eliminates the lock-
+     * amplification problem that triggered `database is locked` storms in
+     * production. If any row fails (e.g. FK violation), the whole batch is
+     * rolled back.
+     *
+     * @returns Array of generated message IDs in input order. Empty array
+     *   for an empty input array.
+     */
+    addMessages(sessionId: string, messages: Array<{
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }>): Promise<string[]>;
+    /**
+     * Update an existing message by id
+     */
+    updateMessage(sessionId: string, messageId: string, updates: {
+        metadata?: Record<string, unknown>;
+        parts?: unknown[];
+        content?: string;
+    }): Promise<boolean>;
+    /**
+     * Get messages from a session
+     * @param sessionId - Session ID
+     * @param offset - Starting index
+     * @param limit - Number of messages to return
+     * @param options - Additional options (includeArchived, fromCheckpointId, reverse)
+     */
+    getMessages(sessionId: string, offset?: number, limit?: number, options?: GetMessagesOptions): Promise<SessionMessage[]>;
+    /**
+     * Get message indexes by role
+     * @param sessionId - Session ID
+     * @param role - Role to filter by
+     */
+    getMessageIndexes(sessionId: string, role: string): Promise<number[]>;
+    /**
+     * Get message count for a session
+     * @param sessionId - Session ID
+     * @param includeArchived - Whether to include archived messages
+     */
+    getMessageCount(sessionId: string, includeArchived?: boolean): Promise<number>;
+    /**
+     * Save a checkpoint to session metadata
+     */
+    saveCheckpoint(sessionId: string, checkpoint: SessionCheckpoint): Promise<void>;
+    /**
+     * Get all checkpoints for a session
+     */
+    getCheckpoints(sessionId: string): Promise<SessionCheckpoint[]>;
+    /**
+     * Get a specific checkpoint
+     */
+    getCheckpoint(sessionId: string, checkpointId: string): Promise<SessionCheckpoint | undefined>;
+    /**
+     * Delete a checkpoint and restore archived messages
+     */
+    deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean>;
+    /**
+     * Archive messages (mark as archived for compact)
+     * @returns Number of messages archived
+     */
+    archiveMessages(sessionId: string, checkpointId: string, beforeIndex: number): Promise<number>;
+    /**
+     * Get active (non-archived) messages only
+     */
+    getActiveMessages(sessionId: string, offset?: number, limit?: number): Promise<SessionMessage[]>;
+    /**
+     * Close and cleanup resources
+     */
+    close(): Promise<void>;
+    /**
+     * Search messages across all sessions
+     *
+     * @param options - Search options including query, session filter, time range
+     * @returns Array of message matches
+     */
+    searchMessages(options: SearchMessagesOptions): Promise<MessageMatch[]>;
+}
+/**
+ * Base class for `SessionStore` implementations that do NOT need to
+ * override `addMessages`. The default implementation simply loops over
+ * `addMessage`, which keeps the per-message retry policy from
+ * `SessionComponent` in effect but loses the BEGIN/COMMIT batching
+ * optimization. Implementations that want the optimization (such as
+ * SQLiteSessionStore) should override `addMessages`.
+ *
+ * Code Review note: adding `addMessages` as a required interface
+ * method would break downstream `SessionStore` implementations at
+ * compile time. Providing a default here keeps the contract additive.
+ */
+export declare abstract class BaseSessionStore implements SessionStore {
+    abstract create(options: CreateSessionOptions): Promise<Session>;
+    abstract get(id: string): Promise<Session | undefined>;
+    abstract list(options?: ListSessionsOptions): Promise<Session[]>;
+    abstract update(id: string, updates: UpdateSessionOptions): Promise<boolean>;
+    abstract delete(id: string): Promise<boolean>;
+    abstract getCount(): Promise<number>;
+    abstract addMessage(sessionId: string, message: {
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    abstract updateMessage(sessionId: string, messageId: string, updates: {
+        metadata?: Record<string, unknown>;
+        parts?: unknown[];
+        content?: string;
+    }): Promise<boolean>;
+    abstract getMessages(sessionId: string, offset?: number, limit?: number, options?: GetMessagesOptions): Promise<SessionMessage[]>;
+    abstract getMessageIndexes(sessionId: string, role: string): Promise<number[]>;
+    abstract getMessageCount(sessionId: string, includeArchived?: boolean): Promise<number>;
+    abstract saveCheckpoint(sessionId: string, checkpoint: SessionCheckpoint): Promise<void>;
+    abstract getCheckpoints(sessionId: string): Promise<SessionCheckpoint[]>;
+    abstract getCheckpoint(sessionId: string, checkpointId: string): Promise<SessionCheckpoint | undefined>;
+    abstract deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean>;
+    abstract archiveMessages(sessionId: string, checkpointId: string, beforeIndex: number): Promise<number>;
+    abstract getActiveMessages(sessionId: string, offset?: number, limit?: number): Promise<SessionMessage[]>;
+    abstract close(): Promise<void>;
+    abstract searchMessages(options: SearchMessagesOptions): Promise<MessageMatch[]>;
+    /**
+     * Default batch implementation: sequential `addMessage` calls.
+     *
+     * Subclasses are strongly encouraged to override this with a real
+     * transaction (see SQLiteSessionStore.addMessages), because:
+     *   1. atomicity: a partial failure here will leave the session in an
+     *      inconsistent state;
+     *   2. contention: N separate transactions mean N separate chances to
+     *      hit SQLITE_BUSY, which is exactly the failure mode the Layer 1
+     *      + Layer 2 fix tries to prevent.
+     */
+    addMessages(sessionId: string, messages: Array<{
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }>): Promise<string[]>;
+}

package/dist/env/session/storage/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Session Storage Index
+ */
+export { MemorySessionStore } from "./memory";
+export { SQLiteSessionStore, getDefaultSessionDbPath, getDefaultDataDir } from "./sqlite";

package/dist/env/session/storage/index.js

@@ -3,9 +3,9 @@ import {
   SQLiteSessionStore,
   getDefaultDataDir,
   getDefaultSessionDbPath
-} from "../../../shared/@ai-setting/roy-agent-core-h93v6p6y.js";
-import"../../../shared/@ai-setting/roy-agent-core-pk1b3kvf.js";
-import"../../../shared/@ai-setting/roy-agent-core-zy3hqfwg.js";
+} from "../../../shared/@ai-setting/roy-agent-core-7qy3nffr.js";
+import"../../../shared/@ai-setting/roy-agent-core-2b8jtv7m.js";
+import"../../../shared/@ai-setting/roy-agent-core-0hq21px2.js";
 import"../../../shared/@ai-setting/roy-agent-core-8seq65bp.js";
 import"../../../shared/@ai-setting/roy-agent-core-jnszp0jq.js";
 import"../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";

package/dist/env/session/storage/memory.d.ts

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Memory Session Store
+ *
+ * In-memory implementation of SessionStore with checkpoint support
+ */
+import type { Session, CreateSessionOptions, UpdateSessionOptions, ListSessionsOptions, SessionMessage, SessionCheckpoint, GetMessagesOptions, SearchMessagesOptions, MessageMatch } from "../types";
+import { BaseSessionStore } from "../session-store";
+/**
+ * Memory-based Session Store with checkpoint support
+ */
+export interface MemorySessionStoreOptions {
+    /** Maximum retained messages per session; oldest messages are discarded. */
+    maxMessagesPerSession?: number;
+    /** Maximum retained checkpoints per session; oldest checkpoints are discarded. */
+    maxCheckpointsPerSession?: number;
+    /**
+     * Task #2539 — 精细化裁剪开关。
+     * 默认 true（向后兼容）：保留所有 message 直到 maxMessagesPerSession 触发。
+     * 设为 false 后，saveCheckpoint / endSessionCleanup 会按 checkpoint 对齐裁剪
+     * messages（保留「最新 checkpoint 之后」的消息，旧 checkpoint 之前的消息直接释放）；
+     * 同时将 checkpoint 数组裁剪到仅保留最新 1 个（覆盖 maxCheckpointsPerSession）。
+     */
+    keepAllMessagesUntilCompaction?: boolean;
+}
+export interface MemorySessionStoreEndCleanupOptions {
+    /**
+     * Task #2539 — 终态清理时是否按 checkpoint 对齐裁剪 messages。
+     * 不传则使用 store 的默认 keepAllMessagesUntilCompaction。
+     */
+    keepAllMessagesUntilCompaction?: boolean;
+    /**
+     * Task #2539 — 终态清理时保留多少个最新 checkpoint（默认 1）。
+     * 设为 0 等同于 "完全丢弃所有 checkpoint"（不推荐，会丢失所有 checkpoint context）。
+     */
+    keepLatestCheckpoints?: number;
+}
+export declare class MemorySessionStore extends BaseSessionStore {
+    private readonly maxMessagesPerSession;
+    private readonly maxCheckpointsPerSession;
+    /**
+     * Task #2539 — 默认值缓存，避免每次 endSessionCleanup 都访问 options。
+     */
+    private readonly defaultKeepAllMessagesUntilCompaction;
+    private sessions;
+    private messages;
+    private checkpoints;
+    private messageConverter;
+    constructor(options?: MemorySessionStoreOptions);
+    private trimMessages;
+    create(options: CreateSessionOptions): Promise<Session>;
+    get(id: string): Promise<Session | undefined>;
+    list(options?: ListSessionsOptions): Promise<Session[]>;
+    update(id: string, updates: UpdateSessionOptions): Promise<boolean>;
+    delete(id: string): Promise<boolean>;
+    getCount(): Promise<number>;
+    addMessage(sessionId: string, message: {
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    /**
+     * Layer 3 (MemorySessionStore): batch version. Memory has no real
+     * "transaction" — we just append all rows and update the count once.
+     */
+    addMessages(sessionId: string, messages: Array<{
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }>): Promise<string[]>;
+    updateMessage(sessionId: string, messageId: string, updates: {
+        metadata?: Record<string, unknown>;
+        parts?: unknown[];
+        content?: string;
+    }): Promise<boolean>;
+    getMessages(sessionId: string, offset?: number, limit?: number, options?: GetMessagesOptions): Promise<SessionMessage[]>;
+    getMessageCount(sessionId: string, includeArchived?: boolean): Promise<number>;
+    getMessageIndexes(sessionId: string, role: string): Promise<number[]>;
+    saveCheckpoint(sessionId: string, checkpoint: SessionCheckpoint): Promise<void>;
+    /**
+     * Task #2539 — 累积裁剪偏移量（per-session）。
+     * checkpoint 的 messageIndex 是相对「初始 push 顺序」的索引；当 messages 被多次裁剪后，
+     * 后续的 checkpoint 仍以原始 messageIndex 调用 truncateMessagesBeforeIndex。
+     * 用 truncOffsets 把原始索引换算到当前数组中的位置，裁完后更新偏移 + 同步 cps messageIndex。
+     */
+    private readonly messageTruncOffsets;
+    /**
+     * Task #2539 — 裁掉「原始位置 < originalBeforeIndex」的 message（保留之后所有 message）。
+     * 与 archiveMessages 不同：archiveMessages 只置 isArchived 标记；本方法直接 splice 释放对象。
+     * originalBeforeIndex 是相对于「该 session 初始 message 顺序」的索引（与 checkpoint.messageIndex 同语义）。
+     * 多次调用累加裁剪（不会重复裁已被裁掉的部分）。
+     */
+    private truncateMessagesBeforeIndex;
+    /**
+     * Task #2539 — sub session 终态（success / error / cancel / timeout）触发时调用。
+     * 默认保留最近 1 个 checkpoint + 其后消息；其它 checkpoint 及其前 message 全部释放。
+     *
+     * 设计目标（避免纯 splice 硬截断）：
+     * - keepAllMessagesUntilCompaction=true（默认）→ 保留所有 message，裁旧 checkpoint 至 maxCheckpointsPerSession
+     * - keepAllMessagesUntilCompaction=false → 仅保留最新 1 个 checkpoint + 其后 message
+     * - keepLatestCheckpoints 控制保留多少个最新 checkpoint（默认 1）
+     *
+     * 幂等：重复调用 endSessionCleanup(sessionId) 结果稳定。
+     * 不存在的 sessionId：no-op，不报错。
+     */
+    endSessionCleanup(sessionId: string, opts?: MemorySessionStoreEndCleanupOptions): Promise<void>;
+    getCheckpoints(sessionId: string): Promise<SessionCheckpoint[]>;
+    getCheckpoint(sessionId: string, checkpointId: string): Promise<SessionCheckpoint | undefined>;
+    deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean>;
+    archiveMessages(sessionId: string, checkpointId: string, beforeIndex: number): Promise<number>;
+    getActiveMessages(sessionId: string, offset?: number, limit?: number): Promise<SessionMessage[]>;
+    searchMessages(options: SearchMessagesOptions): Promise<MessageMatch[]>;
+    /**
+     * Parse simple query into terms
+     */
+    private parseQuery;
+    close(): Promise<void>;
+}

package/dist/env/session/storage/sqlite.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview SQLite Session Store
+ *
+ * SQLite-based implementation of SessionStore with checkpoint support.
+ *
+ * 根据运行环境自动选择 SQLite 实现：
+ * - Bun 运行时：使用 bun:sqlite
+ * - Node.js/Electron：使用 better-sqlite3
+ */
+import type { Session, CreateSessionOptions, UpdateSessionOptions, ListSessionsOptions, SessionMessage, SessionCheckpoint, GetMessagesOptions, SearchMessagesOptions, MessageMatch } from "../types";
+import { BaseSessionStore } from "../session-store";
+/**
+ * Get default data directory for session storage
+ */
+declare function getDefaultDataDir(): string;
+/**
+ * Get default database path for session storage
+ */
+declare function getDefaultSessionDbPath(): string;
+/**
+ * SQLite-based Session Store with checkpoint support
+ *
+ * Provides persistent storage for sessions and messages using SQLite.
+ * Follows the same interface as MemorySessionStore but persists to disk.
+ */
+export declare class SQLiteSessionStore extends BaseSessionStore {
+    private db;
+    private dbPath;
+    private initialized;
+    private sessionsCache;
+    private messagesCache;
+    private checkpointsCache;
+    private messageConverter;
+    constructor(dbPath?: string);
+    private initialize;
+    create(options: CreateSessionOptions): Promise<Session>;
+    get(id: string): Promise<Session | undefined>;
+    list(options?: ListSessionsOptions): Promise<Session[]>;
+    getCount(): Promise<number>;
+    update(id: string, updates: UpdateSessionOptions): Promise<boolean>;
+    delete(id: string): Promise<boolean>;
+    addMessage(sessionId: string, message: {
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    /**
+     * Layer 3: batch insert messages in a single transaction.
+     *
+     * The previous per-message path issued N×2 statements (INSERT message +
+     * UPDATE session), each grabbing the write lock independently. Under
+     * React-driven async fan-out, that lock amplification turned short
+     * contentions into full SQLITE_BUSY storms.
+     *
+     * This path:
+     *  1. Validates the session exists (cheap, indexed SELECT)
+     *  2. Opens a single transaction (BEGIN)
+     *  3. Inserts all N rows in one batch (parameterized prepared stmt)
+     *  4. Recomputes messageCount ONCE via COUNT(*) and issues ONE session
+     *     UPDATE
+     *  5. Commits (or ROLLBACK on any error — preserves atomicity)
+     *
+     * Errors (FK violation, etc.) propagate to the caller; the txn is
+     * rolled back so the DB stays consistent. Empty input is a no-op.
+     */
+    addMessages(sessionId: string, messages: Array<{
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }>): Promise<string[]>;
+    /**
+     * Single-attempt body of `addMessages`, extracted so the retry loop
+     * can call it without a recursion hazard.
+     */
+    private addMessagesOnce;
+    updateMessage(sessionId: string, messageId: string, updates: {
+        metadata?: Record<string, unknown>;
+        parts?: unknown[];
+        content?: string;
+    }): Promise<boolean>;
+    getMessages(sessionId: string, offset?: number, limit?: number, options?: GetMessagesOptions): Promise<SessionMessage[]>;
+    /**
+     * Run a PRAGMA and log if the engine reports a different value than
+     * requested. Read-only PRAGMAs (`journal_mode`, `busy_timeout`,
+     * `synchronous`, `wal_autocheckpoint`) all return the *current* value
+     * as the first row, so a single `prepare().get()` is enough.
+     */
+    private applyPragma;
+    getMessageCount(sessionId: string, includeArchived?: boolean): Promise<number>;
+    getMessageIndexes(sessionId: string, role: string): Promise<number[]>;
+    saveCheckpoint(sessionId: string, checkpoint: SessionCheckpoint): Promise<void>;
+    getCheckpoints(sessionId: string): Promise<SessionCheckpoint[]>;
+    getCheckpoint(sessionId: string, checkpointId: string): Promise<SessionCheckpoint | undefined>;
+    deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean>;
+    archiveMessages(sessionId: string, checkpointId: string, beforeIndex: number): Promise<number>;
+    getActiveMessages(sessionId: string, offset?: number, limit?: number): Promise<SessionMessage[]>;
+    searchMessages(options: SearchMessagesOptions): Promise<MessageMatch[]>;
+    /**
+     * Parse simple query into terms
+     */
+    private parseQuery;
+    close(): Promise<void>;
+    private rowToSession;
+    private rowToMessage;
+}
+export { getDefaultSessionDbPath, getDefaultDataDir };