@adonis-agora/agent 0.1.0

package/dist/src/stores/lucid-schema.d.ts

@@ -0,0 +1,37 @@
+import type { LucidDatabaseLike } from './lucid.js';
+/**
+ * The six agent table names. They match the cross-adapter snake_case contract the reference Drizzle
+ * store uses, so a dashboard or migration can point at any adapter and see the same physical schema.
+ */
+export declare const AGENT_TABLES: {
+    readonly threads: "agent_thread";
+    readonly messages: "agent_message";
+    readonly toolCalls: "agent_tool_call";
+    readonly tokenUsage: "agent_token_usage";
+    readonly modelPricing: "agent_model_pricing";
+    readonly runs: "agent_run";
+};
+/**
+ * `CREATE TABLE IF NOT EXISTS` DDL for the six agent tables plus their indexes, one statement per
+ * array element so each can be issued through Lucid's `rawQuery`. Portable across SQLite / Postgres /
+ * MySQL: quoted identifiers, epoch-ms `BIGINT` timestamps, `INTEGER` booleans (0/1) and `TEXT` JSON
+ * columns — no dialect-only types. A real deployment should prefer the bundled migration stub so the
+ * schema is versioned; this helper lets a store stand itself up in tests and scripts.
+ *
+ * The tool-call PK is the model-supplied `toolCallId` (not a generated id), preserving the invariant
+ * that a persisted tool call is addressable by exactly the id the model emitted.
+ *
+ * The `agent_run` table records each run (turn) lifecycle; `agent_message` / `agent_tool_call` /
+ * `agent_token_usage` each carry a nullable `run_id` correlation column (logically referencing
+ * `agent_run.id`, deliberately WITHOUT a DB-level foreign key — like the reference — so the additive
+ * migration can `ALTER TABLE ADD COLUMN` portably and a row recorded before run tracking shipped can
+ * keep a `null` run_id).
+ */
+export declare function createTableStatements(): string[];
+/**
+ * Idempotently provision the six agent tables through Lucid's async raw runner (`CREATE TABLE IF
+ * NOT EXISTS`). Works on every Lucid dialect. For an AdonisJS app prefer the published migration
+ * (`node ace configure @adonis-agora/agent`); this helper is for standalone use, tests and quick-starts.
+ */
+export declare function createAgentTables(db: LucidDatabaseLike): Promise<void>;
+//# sourceMappingURL=lucid-schema.d.ts.map

package/dist/src/stores/lucid-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lucid-schema.d.ts","sourceRoot":"","sources":["../../../src/stores/lucid-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;CAOf,CAAC;AAEX;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAmGhD;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAI5E"}

package/dist/src/stores/lucid-schema.js

@@ -0,0 +1,139 @@
+/**
+ * The six agent table names. They match the cross-adapter snake_case contract the reference Drizzle
+ * store uses, so a dashboard or migration can point at any adapter and see the same physical schema.
+ */
+export const AGENT_TABLES = {
+    threads: 'agent_thread',
+    messages: 'agent_message',
+    toolCalls: 'agent_tool_call',
+    tokenUsage: 'agent_token_usage',
+    modelPricing: 'agent_model_pricing',
+    runs: 'agent_run',
+};
+/**
+ * `CREATE TABLE IF NOT EXISTS` DDL for the six agent tables plus their indexes, one statement per
+ * array element so each can be issued through Lucid's `rawQuery`. Portable across SQLite / Postgres /
+ * MySQL: quoted identifiers, epoch-ms `BIGINT` timestamps, `INTEGER` booleans (0/1) and `TEXT` JSON
+ * columns — no dialect-only types. A real deployment should prefer the bundled migration stub so the
+ * schema is versioned; this helper lets a store stand itself up in tests and scripts.
+ *
+ * The tool-call PK is the model-supplied `toolCallId` (not a generated id), preserving the invariant
+ * that a persisted tool call is addressable by exactly the id the model emitted.
+ *
+ * The `agent_run` table records each run (turn) lifecycle; `agent_message` / `agent_tool_call` /
+ * `agent_token_usage` each carry a nullable `run_id` correlation column (logically referencing
+ * `agent_run.id`, deliberately WITHOUT a DB-level foreign key — like the reference — so the additive
+ * migration can `ALTER TABLE ADD COLUMN` portably and a row recorded before run tracking shipped can
+ * keep a `null` run_id).
+ */
+export function createTableStatements() {
+    const t = AGENT_TABLES;
+    return [
+        `CREATE TABLE IF NOT EXISTS "${t.threads}" (
+      "id" VARCHAR(255) PRIMARY KEY NOT NULL,
+      "actor_ref" VARCHAR(255) NOT NULL,
+      "tenant_ref" VARCHAR(255) NULL,
+      "title" TEXT NOT NULL,
+      "persona" VARCHAR(255) NOT NULL DEFAULT 'default',
+      "transient" INTEGER NOT NULL DEFAULT 0,
+      "pinned_at" BIGINT NULL,
+      "summary" TEXT NULL,
+      "summary_message_count" INTEGER NOT NULL DEFAULT 0,
+      "active_stream_id" VARCHAR(255) NULL,
+      "created_at" BIGINT NOT NULL,
+      "updated_at" BIGINT NOT NULL,
+      "deleted_at" BIGINT NULL
+    )`,
+        `CREATE INDEX IF NOT EXISTS "${t.threads}_actor_updated_idx" ON "${t.threads}" ("actor_ref", "updated_at")`,
+        `CREATE TABLE IF NOT EXISTS "${t.messages}" (
+      "id" VARCHAR(255) PRIMARY KEY NOT NULL,
+      "thread_id" VARCHAR(255) NOT NULL REFERENCES "${t.threads}" ("id") ON DELETE CASCADE,
+      "role" VARCHAR(255) NOT NULL,
+      "content" TEXT NOT NULL,
+      "tool_calls" TEXT NULL,
+      "tool_results" TEXT NULL,
+      "attachments" TEXT NULL,
+      "follow_ups" TEXT NULL,
+      "usage" TEXT NULL,
+      "persona" VARCHAR(255) NULL,
+      "run_id" VARCHAR(255) NULL,
+      "created_at" BIGINT NOT NULL
+    )`,
+        `CREATE INDEX IF NOT EXISTS "${t.messages}_thread_created_idx" ON "${t.messages}" ("thread_id", "created_at")`,
+        `CREATE INDEX IF NOT EXISTS "${t.messages}_run_idx" ON "${t.messages}" ("run_id")`,
+        `CREATE TABLE IF NOT EXISTS "${t.toolCalls}" (
+      "id" VARCHAR(255) PRIMARY KEY NOT NULL,
+      "message_id" VARCHAR(255) NOT NULL REFERENCES "${t.messages}" ("id") ON DELETE CASCADE,
+      "tool_name" VARCHAR(255) NOT NULL,
+      "tool_type" VARCHAR(255) NOT NULL,
+      "input" TEXT NULL,
+      "output" TEXT NULL,
+      "status" VARCHAR(255) NOT NULL,
+      "executed_by_ref" VARCHAR(255) NULL,
+      "execution_ms" INTEGER NULL,
+      "error" TEXT NULL,
+      "run_id" VARCHAR(255) NULL,
+      "created_at" BIGINT NOT NULL,
+      "executed_at" BIGINT NULL
+    )`,
+        `CREATE INDEX IF NOT EXISTS "${t.toolCalls}_run_idx" ON "${t.toolCalls}" ("run_id")`,
+        `CREATE INDEX IF NOT EXISTS "${t.toolCalls}_status_created_idx" ON "${t.toolCalls}" ("status", "created_at")`,
+        `CREATE TABLE IF NOT EXISTS "${t.tokenUsage}" (
+      "id" VARCHAR(255) PRIMARY KEY NOT NULL,
+      "thread_id" VARCHAR(255) NOT NULL REFERENCES "${t.threads}" ("id") ON DELETE CASCADE,
+      "actor_ref" VARCHAR(255) NOT NULL,
+      "message_id" VARCHAR(255) NULL,
+      "model_id" VARCHAR(255) NOT NULL,
+      "purpose" VARCHAR(255) NOT NULL,
+      "input_tokens" INTEGER NOT NULL,
+      "output_tokens" INTEGER NOT NULL,
+      "cache_write_tokens" INTEGER NULL,
+      "cache_read_tokens" INTEGER NULL,
+      "cost_usd" DOUBLE PRECISION NULL,
+      "run_id" VARCHAR(255) NULL,
+      "created_at" BIGINT NOT NULL
+    )`,
+        `CREATE INDEX IF NOT EXISTS "${t.tokenUsage}_actor_created_idx" ON "${t.tokenUsage}" ("actor_ref", "created_at")`,
+        `CREATE INDEX IF NOT EXISTS "${t.tokenUsage}_run_idx" ON "${t.tokenUsage}" ("run_id")`,
+        `CREATE TABLE IF NOT EXISTS "${t.modelPricing}" (
+      "id" VARCHAR(255) PRIMARY KEY NOT NULL,
+      "model_id" VARCHAR(255) NOT NULL,
+      "input_price_per_1m" DOUBLE PRECISION NOT NULL,
+      "output_price_per_1m" DOUBLE PRECISION NOT NULL,
+      "cache_write_price_per_1m" DOUBLE PRECISION NULL,
+      "cache_read_price_per_1m" DOUBLE PRECISION NULL,
+      "effective_from" BIGINT NOT NULL,
+      "is_current" INTEGER NOT NULL
+    )`,
+        `CREATE TABLE IF NOT EXISTS "${t.runs}" (
+      "id" VARCHAR(255) PRIMARY KEY NOT NULL,
+      "thread_id" VARCHAR(255) NOT NULL REFERENCES "${t.threads}" ("id") ON DELETE CASCADE,
+      "agent_name" VARCHAR(255) NULL,
+      "actor_ref" VARCHAR(255) NOT NULL,
+      "tenant_ref" VARCHAR(255) NULL,
+      "status" VARCHAR(255) NOT NULL,
+      "started_at" BIGINT NOT NULL,
+      "finished_at" BIGINT NULL,
+      "step_count" INTEGER NOT NULL DEFAULT 0,
+      "input_tokens" INTEGER NOT NULL DEFAULT 0,
+      "output_tokens" INTEGER NOT NULL DEFAULT 0,
+      "cost_usd" DOUBLE PRECISION NULL,
+      "error" TEXT NULL,
+      "durable" INTEGER NOT NULL DEFAULT 0
+    )`,
+        `CREATE INDEX IF NOT EXISTS "${t.runs}_started_idx" ON "${t.runs}" ("started_at")`,
+        `CREATE INDEX IF NOT EXISTS "${t.runs}_actor_started_idx" ON "${t.runs}" ("actor_ref", "started_at")`,
+        `CREATE INDEX IF NOT EXISTS "${t.runs}_status_started_idx" ON "${t.runs}" ("status", "started_at")`,
+    ];
+}
+/**
+ * Idempotently provision the six agent tables through Lucid's async raw runner (`CREATE TABLE IF
+ * NOT EXISTS`). Works on every Lucid dialect. For an AdonisJS app prefer the published migration
+ * (`node ace configure @adonis-agora/agent`); this helper is for standalone use, tests and quick-starts.
+ */
+export async function createAgentTables(db) {
+    for (const stmt of createTableStatements()) {
+        await db.rawQuery(stmt);
+    }
+}
+//# sourceMappingURL=lucid-schema.js.map

package/dist/src/stores/lucid-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lucid-schema.js","sourceRoot":"","sources":["../../../src/stores/lucid-schema.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,eAAe;IACzB,SAAS,EAAE,iBAAiB;IAC5B,UAAU,EAAE,mBAAmB;IAC/B,YAAY,EAAE,qBAAqB;IACnC,IAAI,EAAE,WAAW;CACT,CAAC;AAEX;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,qBAAqB;IACnC,MAAM,CAAC,GAAG,YAAY,CAAC;IACvB,OAAO;QACL,+BAA+B,CAAC,CAAC,OAAO;;;;;;;;;;;;;;MActC;QACF,+BAA+B,CAAC,CAAC,OAAO,2BAA2B,CAAC,CAAC,OAAO,+BAA+B;QAC3G,+BAA+B,CAAC,CAAC,QAAQ;;sDAES,CAAC,CAAC,OAAO;;;;;;;;;;;MAWzD;QACF,+BAA+B,CAAC,CAAC,QAAQ,4BAA4B,CAAC,CAAC,QAAQ,+BAA+B;QAC9G,+BAA+B,CAAC,CAAC,QAAQ,iBAAiB,CAAC,CAAC,QAAQ,cAAc;QAClF,+BAA+B,CAAC,CAAC,SAAS;;uDAES,CAAC,CAAC,QAAQ;;;;;;;;;;;;MAY3D;QACF,+BAA+B,CAAC,CAAC,SAAS,iBAAiB,CAAC,CAAC,SAAS,cAAc;QACpF,+BAA+B,CAAC,CAAC,SAAS,4BAA4B,CAAC,CAAC,SAAS,4BAA4B;QAC7G,+BAA+B,CAAC,CAAC,UAAU;;sDAEO,CAAC,CAAC,OAAO;;;;;;;;;;;;MAYzD;QACF,+BAA+B,CAAC,CAAC,UAAU,2BAA2B,CAAC,CAAC,UAAU,+BAA+B;QACjH,+BAA+B,CAAC,CAAC,UAAU,iBAAiB,CAAC,CAAC,UAAU,cAAc;QACtF,+BAA+B,CAAC,CAAC,YAAY;;;;;;;;;MAS3C;QACF,+BAA+B,CAAC,CAAC,IAAI;;sDAEa,CAAC,CAAC,OAAO;;;;;;;;;;;;;MAazD;QACF,+BAA+B,CAAC,CAAC,IAAI,qBAAqB,CAAC,CAAC,IAAI,kBAAkB;QAClF,+BAA+B,CAAC,CAAC,IAAI,2BAA2B,CAAC,CAAC,IAAI,+BAA+B;QACrG,+BAA+B,CAAC,CAAC,IAAI,4BAA4B,CAAC,CAAC,IAAI,4BAA4B;KACpG,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,EAAqB;IAC3D,KAAK,MAAM,IAAI,IAAI,qBAAqB,EAAE,EAAE,CAAC;QAC3C,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;AACH,CAAC"}

package/dist/src/stores/lucid.d.ts

@@ -0,0 +1,73 @@
+import type { AgentStore, AppendMessageInput, CreateThreadInput, RecordRunEndInput, RecordRunStartInput, RecordToolCallInput, RecordUsageInput, UpdateToolCallInput } from '../spi/agent-store.js';
+import type { StoredMessage, ThreadDetail, ThreadSummary } from '../types.js';
+/** The chainable query-builder surface the store leans on (Knex-shaped). */
+export interface LucidQueryBuilderLike {
+    where(column: string, value: unknown): this;
+    where(column: string, operator: string, value: unknown): this;
+    whereNull(column: string): this;
+    orderBy(column: string, direction: 'asc' | 'desc'): this;
+    limit(value: number): this;
+    offset(value: number): this;
+    first(): Promise<Record<string, unknown> | null>;
+    select(...columns: string[]): Promise<Record<string, unknown>[]>;
+    update(row: Record<string, unknown>): Promise<unknown>;
+    delete(): Promise<unknown>;
+}
+export interface LucidInsertBuilderLike {
+    insert(row: Record<string, unknown>): Promise<unknown>;
+}
+/** A query client — the base connection or a transaction client (both expose `from`/`table`). */
+export interface LucidClientLike {
+    from(table: string): LucidQueryBuilderLike;
+    table(table: string): LucidInsertBuilderLike;
+}
+/** The `Database` facade slice: a client plus raw SQL (DDL) and transactions. */
+export interface LucidDatabaseLike extends LucidClientLike {
+    rawQuery(sql: string, bindings?: unknown[]): Promise<unknown>;
+    transaction<T>(callback: (trx: LucidClientLike) => Promise<T>): Promise<T>;
+}
+export interface LucidAgentStoreOptions {
+    /**
+     * Run {@link createAgentTables} on first use so the tables exist without a migration. Convenient
+     * for tests/scripts; production should run the published migration. Default `false`.
+     */
+    autoCreateTables?: boolean;
+}
+/**
+ * A production-grade, persistent {@link AgentStore} backed by AdonisJS **Lucid** (Knex) over the five
+ * agent tables (threads, messages, tool calls, token usage, model pricing). JSON payloads are stored
+ * as TEXT and timestamps as epoch-ms integers, so it is portable across SQLite / Postgres / MySQL and
+ * is the behavioral twin of the in-memory store.
+ *
+ * `forkThread` / `truncateFrom` run in a transaction (cheap safety); `truncateFrom` deletes the
+ * doomed messages' tool calls explicitly (not only via FK cascade) so it works on SQLite even without
+ * `PRAGMA foreign_keys=ON`. The tool-call PK is always the model-supplied `toolCallId`.
+ *
+ * Usually you don't construct this directly: `config/agent.ts` selects it via `stores.lucid({ ... })`
+ * and the provider builds it, lazily importing `@adonisjs/lucid` only when the `lucid` store is chosen.
+ */
+export declare class LucidAgentStore implements AgentStore {
+    private readonly db;
+    private readonly autoCreateTables;
+    private ready;
+    constructor(db: LucidDatabaseLike, options?: LucidAgentStoreOptions);
+    private init;
+    createThread(input: CreateThreadInput): Promise<ThreadSummary>;
+    getThread(threadId: string): Promise<ThreadDetail | null>;
+    listThreads(actorRef: string, limit?: number): Promise<ThreadSummary[]>;
+    softDeleteThread(threadId: string): Promise<void>;
+    forkThread(threadId: string, fromMessageId: string): Promise<ThreadSummary>;
+    setTitle(threadId: string, title: string): Promise<void>;
+    setActiveStream(threadId: string, runId: string | null): Promise<void>;
+    appendMessage(input: AppendMessageInput): Promise<StoredMessage>;
+    truncateFrom(threadId: string, messageId: string): Promise<void>;
+    recordToolCall(input: RecordToolCallInput): Promise<void>;
+    updateToolCall(input: UpdateToolCallInput): Promise<void>;
+    recordUsage(input: RecordUsageInput): Promise<void>;
+    recordRunStart(input: RecordRunStartInput): Promise<void>;
+    recordRunEnd(input: RecordRunEndInput): Promise<void>;
+    quotaToday(actorRef: string, day: string): Promise<{
+        usedTokens: number;
+    }>;
+}
+//# sourceMappingURL=lucid.d.ts.map

package/dist/src/stores/lucid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lucid.d.ts","sourceRoot":"","sources":["../../../src/stores/lucid.ts"],"names":[],"mappings":"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"}

package/dist/src/stores/lucid.js

@@ -0,0 +1,400 @@
+import { AGENT_TABLES, createAgentTables } from './lucid-schema.js';
+function toInt(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'bigint')
+        return Number(value);
+    if (typeof value === 'string')
+        return Number.parseInt(value, 10) || 0;
+    return 0;
+}
+function msToIso(value) {
+    return new Date(toInt(value)).toISOString();
+}
+function safeJson(value) {
+    if (value === undefined || value === null)
+        return null;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+}
+function parseJson(text) {
+    if (typeof text !== 'string' || text.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A production-grade, persistent {@link AgentStore} backed by AdonisJS **Lucid** (Knex) over the five
+ * agent tables (threads, messages, tool calls, token usage, model pricing). JSON payloads are stored
+ * as TEXT and timestamps as epoch-ms integers, so it is portable across SQLite / Postgres / MySQL and
+ * is the behavioral twin of the in-memory store.
+ *
+ * `forkThread` / `truncateFrom` run in a transaction (cheap safety); `truncateFrom` deletes the
+ * doomed messages' tool calls explicitly (not only via FK cascade) so it works on SQLite even without
+ * `PRAGMA foreign_keys=ON`. The tool-call PK is always the model-supplied `toolCallId`.
+ *
+ * Usually you don't construct this directly: `config/agent.ts` selects it via `stores.lucid({ ... })`
+ * and the provider builds it, lazily importing `@adonisjs/lucid` only when the `lucid` store is chosen.
+ */
+export class LucidAgentStore {
+    db;
+    autoCreateTables;
+    ready = null;
+    constructor(db, options = {}) {
+        this.db = db;
+        this.autoCreateTables = options.autoCreateTables ?? false;
+    }
+    init() {
+        if (this.ready === null) {
+            this.ready = this.autoCreateTables ? createAgentTables(this.db) : Promise.resolve();
+        }
+        return this.ready;
+    }
+    async createThread(input) {
+        await this.init();
+        const id = crypto.randomUUID();
+        const now = Date.now();
+        await this.db.table(AGENT_TABLES.threads).insert({
+            id,
+            actor_ref: input.actor.id,
+            tenant_ref: input.actor.tenantRef ?? null,
+            title: input.title ?? 'New chat',
+            persona: input.persona,
+            transient: input.transient ? 1 : 0,
+            pinned_at: null,
+            summary: null,
+            summary_message_count: 0,
+            active_stream_id: null,
+            created_at: now,
+            updated_at: now,
+            deleted_at: null,
+        });
+        return {
+            id,
+            title: input.title ?? 'New chat',
+            persona: input.persona,
+            transient: input.transient ?? false,
+            createdAt: new Date(now).toISOString(),
+            updatedAt: new Date(now).toISOString(),
+        };
+    }
+    async getThread(threadId) {
+        await this.init();
+        const row = await this.db
+            .from(AGENT_TABLES.threads)
+            .where('id', threadId)
+            .whereNull('deleted_at')
+            .first();
+        if (row === null || row === undefined)
+            return null;
+        const messageRows = await this.db
+            .from(AGENT_TABLES.messages)
+            .where('thread_id', threadId)
+            .orderBy('created_at', 'asc')
+            .select('*');
+        const messages = messageRows.map(rowToMessage);
+        const last = messages[messages.length - 1];
+        const activeStreamId = row.active_stream_id;
+        return {
+            ...threadRowToSummary(row, last?.content),
+            messages,
+            ...(typeof activeStreamId === 'string' ? { activeStreamId } : {}),
+        };
+    }
+    async listThreads(actorRef, limit = 50) {
+        await this.init();
+        const rows = await this.db
+            .from(AGENT_TABLES.threads)
+            .where('actor_ref', actorRef)
+            .where('transient', 0)
+            .whereNull('deleted_at')
+            .orderBy('updated_at', 'desc')
+            .limit(limit)
+            .select('*');
+        return rows.map((row) => threadRowToSummary(row));
+    }
+    async softDeleteThread(threadId) {
+        await this.init();
+        await this.db
+            .from(AGENT_TABLES.threads)
+            .where('id', threadId)
+            .update({ deleted_at: Date.now() });
+    }
+    async forkThread(threadId, fromMessageId) {
+        await this.init();
+        return this.db.transaction(async (trx) => {
+            const source = await trx.from(AGENT_TABLES.threads).where('id', threadId).first();
+            if (source === null || source === undefined) {
+                throw new Error(`thread ${threadId} not found`);
+            }
+            const messageRows = await trx
+                .from(AGENT_TABLES.messages)
+                .where('thread_id', threadId)
+                .orderBy('created_at', 'asc')
+                .select('*');
+            const cutoff = messageRows.findIndex((m) => String(m.id) === fromMessageId);
+            const kept = cutoff >= 0 ? messageRows.slice(0, cutoff + 1) : messageRows;
+            const id = crypto.randomUUID();
+            const now = Date.now();
+            const title = String(source.title);
+            const persona = String(source.persona);
+            await trx.table(AGENT_TABLES.threads).insert({
+                id,
+                actor_ref: source.actor_ref,
+                tenant_ref: source.tenant_ref ?? null,
+                title,
+                persona,
+                transient: 0,
+                pinned_at: null,
+                summary: null,
+                summary_message_count: 0,
+                active_stream_id: null,
+                created_at: now,
+                updated_at: now,
+                deleted_at: null,
+            });
+            for (const m of kept) {
+                // New message id: the message PK is unique, so a fork copies content under fresh ids.
+                await trx.table(AGENT_TABLES.messages).insert({
+                    id: crypto.randomUUID(),
+                    thread_id: id,
+                    role: m.role,
+                    content: m.content,
+                    tool_calls: m.tool_calls ?? null,
+                    tool_results: m.tool_results ?? null,
+                    attachments: m.attachments ?? null,
+                    follow_ups: m.follow_ups ?? null,
+                    usage: m.usage ?? null,
+                    persona: m.persona ?? null,
+                    created_at: toInt(m.created_at),
+                });
+            }
+            return {
+                id,
+                title,
+                persona,
+                transient: false,
+                createdAt: new Date(now).toISOString(),
+                updatedAt: new Date(now).toISOString(),
+            };
+        });
+    }
+    async setTitle(threadId, title) {
+        await this.init();
+        await this.db
+            .from(AGENT_TABLES.threads)
+            .where('id', threadId)
+            .update({ title, updated_at: Date.now() });
+    }
+    async setActiveStream(threadId, runId) {
+        await this.init();
+        await this.db
+            .from(AGENT_TABLES.threads)
+            .where('id', threadId)
+            .update({ active_stream_id: runId });
+    }
+    async appendMessage(input) {
+        await this.init();
+        const id = crypto.randomUUID();
+        const now = Date.now();
+        await this.db.table(AGENT_TABLES.messages).insert({
+            id,
+            thread_id: input.threadId,
+            role: input.role,
+            content: input.content,
+            tool_calls: safeJson(input.toolCalls),
+            tool_results: safeJson(input.toolResults),
+            attachments: safeJson(input.attachments),
+            follow_ups: safeJson(input.followUps),
+            usage: safeJson(input.usage),
+            persona: input.persona ?? null,
+            run_id: input.runId ?? null,
+            created_at: now,
+        });
+        // Keep the thread's `updated_at` in step so list ordering reflects the latest activity.
+        await this.db
+            .from(AGENT_TABLES.threads)
+            .where('id', input.threadId)
+            .update({ updated_at: now });
+        return {
+            id,
+            role: input.role,
+            content: input.content,
+            createdAt: new Date(now).toISOString(),
+            ...(input.toolCalls !== undefined ? { toolCalls: input.toolCalls } : {}),
+            ...(input.toolResults !== undefined ? { toolResults: input.toolResults } : {}),
+            ...(input.attachments !== undefined ? { attachments: input.attachments } : {}),
+            ...(input.followUps !== undefined ? { followUps: input.followUps } : {}),
+            ...(input.usage !== undefined ? { usage: input.usage } : {}),
+        };
+    }
+    async truncateFrom(threadId, messageId) {
+        await this.init();
+        await this.db.transaction(async (trx) => {
+            const rows = await trx
+                .from(AGENT_TABLES.messages)
+                .where('thread_id', threadId)
+                .orderBy('created_at', 'asc')
+                .select('id');
+            const cutoff = rows.findIndex((m) => String(m.id) === messageId);
+            if (cutoff < 0)
+                return;
+            const doomed = rows.slice(cutoff).map((m) => String(m.id));
+            for (const mid of doomed) {
+                // Delete tool calls explicitly (works on SQLite without FK cascade), then the message.
+                await trx.from(AGENT_TABLES.toolCalls).where('message_id', mid).delete();
+                await trx.from(AGENT_TABLES.messages).where('id', mid).delete();
+            }
+        });
+    }
+    async recordToolCall(input) {
+        await this.init();
+        // PK = the model-supplied toolCallId (never a generated id).
+        await this.db.table(AGENT_TABLES.toolCalls).insert({
+            id: input.toolCallId,
+            message_id: input.messageId,
+            tool_name: input.toolName,
+            tool_type: input.toolType,
+            input: safeJson(input.input),
+            output: null,
+            status: input.status,
+            executed_by_ref: null,
+            execution_ms: null,
+            error: null,
+            run_id: input.runId ?? null,
+            created_at: Date.now(),
+            executed_at: null,
+        });
+    }
+    async updateToolCall(input) {
+        await this.init();
+        const patch = { status: input.status };
+        if (input.output !== undefined)
+            patch.output = safeJson(input.output);
+        if (input.error !== undefined)
+            patch.error = input.error;
+        if (input.executionMs !== undefined)
+            patch.execution_ms = input.executionMs;
+        if (input.executedByRef !== undefined)
+            patch.executed_by_ref = input.executedByRef;
+        if (input.status === 'executed' || input.status === 'failed')
+            patch.executed_at = Date.now();
+        await this.db.from(AGENT_TABLES.toolCalls).where('id', input.toolCallId).update(patch);
+    }
+    async recordUsage(input) {
+        await this.init();
+        await this.db.table(AGENT_TABLES.tokenUsage).insert({
+            id: crypto.randomUUID(),
+            thread_id: input.threadId,
+            actor_ref: input.actorRef,
+            message_id: input.messageId ?? null,
+            model_id: input.modelId,
+            purpose: input.purpose,
+            input_tokens: input.usage.inputTokens,
+            output_tokens: input.usage.outputTokens,
+            cache_write_tokens: input.usage.cacheWriteTokens ?? null,
+            cache_read_tokens: input.usage.cacheReadTokens ?? null,
+            cost_usd: input.costUsd ?? null,
+            run_id: input.runId ?? null,
+            created_at: Date.now(),
+        });
+    }
+    async recordRunStart(input) {
+        await this.init();
+        await this.db.table(AGENT_TABLES.runs).insert({
+            id: input.runId,
+            thread_id: input.threadId,
+            agent_name: input.agentName ?? null,
+            actor_ref: input.actor.id,
+            tenant_ref: input.actor.tenantRef ?? null,
+            status: 'running',
+            started_at: Date.now(),
+            finished_at: null,
+            step_count: 0,
+            input_tokens: 0,
+            output_tokens: 0,
+            cost_usd: null,
+            error: null,
+            durable: input.durable ? 1 : 0,
+        });
+    }
+    async recordRunEnd(input) {
+        await this.init();
+        const patch = {
+            status: input.status,
+            finished_at: input.finishedAt ?? Date.now(),
+        };
+        if (input.stepCount !== undefined)
+            patch.step_count = input.stepCount;
+        if (input.inputTokens !== undefined)
+            patch.input_tokens = input.inputTokens;
+        if (input.outputTokens !== undefined)
+            patch.output_tokens = input.outputTokens;
+        if (input.costUsd !== undefined)
+            patch.cost_usd = input.costUsd;
+        if (input.error !== undefined)
+            patch.error = input.error;
+        // First terminal wins: only settle a run still `running`, so a late `completed` from the loop can
+        // never overwrite a `failed`/`cancelled` the runner already recorded (idempotent under replay too).
+        await this.db
+            .from(AGENT_TABLES.runs)
+            .where('id', input.runId)
+            .where('status', 'running')
+            .update(patch);
+    }
+    async quotaToday(actorRef, day) {
+        await this.init();
+        // Inclusive UTC day window over epoch-ms `created_at`. Cache tokens are subsets of input/output
+        // and are NEVER re-added, so summing input+output is the whole-day token spend.
+        const start = Date.parse(`${day}T00:00:00.000Z`);
+        const end = Date.parse(`${day}T23:59:59.999Z`);
+        const rows = await this.db
+            .from(AGENT_TABLES.tokenUsage)
+            .where('actor_ref', actorRef)
+            .where('created_at', '>=', start)
+            .where('created_at', '<=', end)
+            .select('input_tokens', 'output_tokens');
+        const usedTokens = rows.reduce((sum, row) => sum + toInt(row.input_tokens) + toInt(row.output_tokens), 0);
+        return { usedTokens };
+    }
+}
+function threadRowToSummary(row, lastPreview) {
+    const pinnedAt = row.pinned_at;
+    return {
+        id: String(row.id),
+        title: String(row.title),
+        persona: String(row.persona),
+        transient: toInt(row.transient) !== 0,
+        createdAt: msToIso(row.created_at),
+        updatedAt: msToIso(row.updated_at),
+        ...(pinnedAt !== null && pinnedAt !== undefined ? { pinnedAt: msToIso(pinnedAt) } : {}),
+        ...(lastPreview !== undefined ? { lastMessagePreview: lastPreview.slice(0, 120) } : {}),
+    };
+}
+function rowToMessage(row) {
+    const toolCalls = parseJson(row.tool_calls);
+    const toolResults = parseJson(row.tool_results);
+    const attachments = parseJson(row.attachments);
+    const followUps = parseJson(row.follow_ups);
+    const usage = parseJson(row.usage);
+    return {
+        id: String(row.id),
+        role: String(row.role),
+        content: String(row.content),
+        createdAt: msToIso(row.created_at),
+        ...(toolCalls !== undefined ? { toolCalls } : {}),
+        ...(toolResults !== undefined ? { toolResults } : {}),
+        ...(attachments !== undefined ? { attachments } : {}),
+        ...(followUps !== undefined ? { followUps } : {}),
+        ...(usage !== undefined ? { usage } : {}),
+    };
+}
+//# sourceMappingURL=lucid.js.map