@dudousxd/nestjs-agent-store-drizzle 0.8.2 → 0.10.0

package/dist/index.d.ts

@@ -1,11 +1,14 @@
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-import { MessageRole, ToolCallRequest, ToolResult, MessageUsage, ToolKind, ToolCallStatus, UsagePurpose, AgentStore, CreateThreadInput, ThreadSummary, ThreadDetail, AppendMessageInput, StoredMessage, RecordToolCallInput, UpdateToolCallInput, RecordUsageInput, AgentGovernanceQueries, AgentPricingStore, GovernanceRange, ModelSpendRow, ActorSpendRow, ThreadSpendRow, UsageTrendPoint, ToolCallActivityRow, ThreadActivityRow, RunMetrics, RunAgentBreakdownRow, RunErrorBreakdownRow, RunTrendPoint, RecentRunRow, PendingApprovalRow, ToolStatRow, GovernancePageQuery, ToolCallWhere, GovernancePage, ThreadWhere, RunWhere, ApprovalWhere, GovernanceRunDetail, GovernanceThreadDetailQuery, GovernanceThreadDetail, ModelPriceInput, CurrentModelPrice } from '@dudousxd/nestjs-agent-core';
-import { Type, DynamicModule } from '@nestjs/common';
+import { MessageRole, ToolCallRequest, ToolResult, MessageAttachment, MessageUsage, ToolKind, ToolCallStatus, UsagePurpose, AgentStore, ThreadTurnReader, CreateThreadInput, ThreadSummary, ThreadDetail, ThreadTurnQuery, ThreadTurnPage, UpdateThreadInput, RecordRunStartInput, AppendMessageInput, StoredMessage, RecordToolCallInput, UpdateToolCallInput, RecordUsageInput, AgentGovernanceQueries, AgentPricingStore, GovernanceRange, ModelSpendRow, ActorSpendRow, ThreadSpendRow, UsageTrendPoint, ToolCallActivityRow, ThreadActivityRow, RunMetrics, RunAgentBreakdownRow, RunErrorBreakdownRow, RunTrendPoint, RecentRunRow, PendingApprovalRow, ToolStatRow, GovernancePageQuery, ToolCallWhere, GovernancePage, ThreadWhere, RunWhere, ApprovalWhere, GovernanceRunDetail, GovernanceThreadDetailQuery, GovernanceThreadDetail, MemoryProvider, ListMemoriesInput, MemoryRecord, ForgetMemoryInput, StoreMemoryInput, ModelPriceInput, CurrentModelPrice } from '@dudousxd/nestjs-agent-core';
+export { ThreadTurnPage, ThreadTurnQuery } from '@dudousxd/nestjs-agent-core';
+import { TablesRelationalConfig, SQL } from 'drizzle-orm';
+import { OnModuleInit, OnModuleDestroy, Type, DynamicModule } from '@nestjs/common';
 
 /**
  * Drizzle schema mirroring the MikroORM agent entities (same logical columns/relations):
- * threads, messages, tool calls, token usage, model pricing and run outcomes. Targets the SQLite core so the
+ * threads, messages, tool calls, token usage, model pricing, run outcomes and the RAG ingestion
+ * ledger. Targets the SQLite core so the
  * db-test runs on an in-memory better-sqlite3; timestamps are stored as integer epoch-ms columns
  * (`{ mode: 'timestamp_ms' }`) which Drizzle round-trips to/from JS `Date`, and the model-facing
  * message extras (tool calls/results, follow-ups, usage) live in JSON `text` columns.
@@ -131,6 +134,25 @@ declare const agentThread: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         }, {}, {
             length: number | undefined;
         }>;
+        defaultAgent: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "default_agent";
+            tableName: "agent_thread";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
             name: "created_at";
             tableName: "agent_thread";
@@ -309,6 +331,25 @@ declare const agentMessage: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         }, {}, {
             $type: ToolResult[];
         }>;
+        attachments: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "attachments";
+            tableName: "agent_message";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: MessageAttachment[];
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: MessageAttachment[];
+        }>;
         followUps: drizzle_orm_sqlite_core.SQLiteColumn<{
             name: "follow_ups";
             tableName: "agent_message";
@@ -366,6 +407,25 @@ declare const agentMessage: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         }, {}, {
             length: number | undefined;
         }>;
+        runId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "run_id";
+            tableName: "agent_message";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
             name: "created_at";
             tableName: "agent_message";
@@ -386,7 +446,13 @@ declare const agentMessage: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
     };
     dialect: "sqlite";
 }>;
-/** A tool call requested during an assistant turn. The pk is the model-supplied `toolCallId`. */
+/**
+ * A tool call requested during an assistant turn. The pk is the model-supplied `toolCallId`.
+ *
+ * `messageId` carries its own index rather than relying on the foreign key: MySQL indexes a foreign
+ * key column for you, Postgres does not — and every message-scoped read here filters on it (the
+ * thread reader's `IN (…)` over a turn's calls, and `truncateFrom`'s delete).
+ */
 declare const agentToolCall: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
     name: "agent_tool_call";
     schema: undefined;
@@ -1006,8 +1072,14 @@ declare const agentModelPricing: drizzle_orm_sqlite_core.SQLiteTableWithColumns<
     };
     dialect: "sqlite";
 }>;
-/** A run's lifecycle status. Not part of the core SPI (that surfaces `string`) — internal only. */
-type AgentRunStatus = 'running' | 'completed' | 'failed';
+/**
+ * A run's lifecycle status. Not part of the core SPI (that surfaces `string`) — internal only.
+ *
+ * `cancelled` is a third TERMINAL, not a flavour of `failed`: someone asked the run to stop and it
+ * did. A reliability read that folded it into `failed` would page whoever is on call for model
+ * failures every time a user pressed Stop.
+ */
+type AgentRunStatus = 'running' | 'completed' | 'failed' | 'cancelled';
 /**
  * One recorded run (turn) outcome — the durable half of what `aviary:agent:*` diagnostics report
  * ephemerally. Written by {@link import('./drizzle-agent-store.js').DrizzleAgentStore.recordRunStart}/
@@ -1241,192 +1313,955 @@ declare const agentRun: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         }, {}, {
             length: number | undefined;
         }>;
+        parentRunId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "parent_run_id";
+            tableName: "agent_run";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
     };
     dialect: "sqlite";
 }>;
-/** The six agent tables as one schema object, ready for `drizzle(client, { schema })`. */
-declare const agentSchema: {
-    agentThread: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: "agent_thread";
-        schema: undefined;
-        columns: {
-            id: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "id";
-                tableName: "agent_thread";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
-                notNull: true;
-                hasDefault: false;
-                isPrimaryKey: true;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {
-                length: number | undefined;
-            }>;
-            actorRef: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "actor_ref";
-                tableName: "agent_thread";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
-                notNull: true;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {
-                length: number | undefined;
-            }>;
-            tenantRef: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "tenant_ref";
-                tableName: "agent_thread";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
-                notNull: false;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {
-                length: number | undefined;
-            }>;
-            title: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "title";
-                tableName: "agent_thread";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
-                notNull: true;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {
-                length: number | undefined;
-            }>;
-            transient: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "transient";
-                tableName: "agent_thread";
-                dataType: "boolean";
-                columnType: "SQLiteBoolean";
-                data: boolean;
-                driverParam: number;
-                notNull: true;
-                hasDefault: true;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: undefined;
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
-            activeStreamId: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "active_stream_id";
-                tableName: "agent_thread";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
-                notNull: false;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {
-                length: number | undefined;
-            }>;
-            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "created_at";
-                tableName: "agent_thread";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
-                driverParam: number;
-                notNull: true;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: undefined;
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
-            updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "updated_at";
-                tableName: "agent_thread";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
-                driverParam: number;
-                notNull: true;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: undefined;
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
-            deletedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "deleted_at";
-                tableName: "agent_thread";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
-                driverParam: number;
-                notNull: false;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: undefined;
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
-        };
-        dialect: "sqlite";
-    }>;
-    agentMessage: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: "agent_message";
-        schema: undefined;
-        columns: {
-            id: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "id";
-                tableName: "agent_message";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
+/**
+ * One thing the assistant believes, held at one scope — the row behind a core `MemoryRecord`.
+ *
+ * `scope` is an OPAQUE token the host mints (`actor:…`, `tenant:…`, whatever axis a deployment scopes
+ * by), which is what lets this package own the table at all: there is nothing here for a host to
+ * relate its own entities to, so owning the rows takes nothing away from it.
+ *
+ * The origin is flattened into columns rather than stored as JSON so a host's console can filter and
+ * sweep on it. `originThreadId` is deliberately NOT a foreign key — unlike every other table here,
+ * which cascades off `agent_thread`: a memory outlives the conversation it came from, and a cascade
+ * would delete beliefs when a transcript aged out.
+ *
+ * One unique index, on (`scope`, `key`) — what `write` upserts against, and what makes a duplicate
+ * answer to one question impossible rather than merely unlikely. It doubles as the index every read
+ * uses: `list` filters `scope in (…)`, which is that index's leading column, so a second index on
+ * `scope` alone would be maintained on every write and read by nothing.
+ */
+declare const agentMemory: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: "agent_memory";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "id";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scope: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "scope";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        key: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "key";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        text: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "text";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        originAuthor: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "origin_author";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "agent" | "human";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+            $type: "agent" | "human";
+        }>;
+        originThreadId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "origin_thread_id";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        originRunId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "origin_run_id";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        originActorRef: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "origin_actor_ref";
+            tableName: "agent_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        pinned: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "pinned";
+            tableName: "agent_memory";
+            dataType: "boolean";
+            columnType: "SQLiteBoolean";
+            data: boolean;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "created_at";
+            tableName: "agent_memory";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "updated_at";
+            tableName: "agent_memory";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/** The terminal states an ingestion attempt can land in. Mirrors `MediaIngestOutcome`. */
+type RagIngestionStatus = 'ingested' | 'skipped' | 'failed' | 'removed';
+/**
+ * The latest ingestion outcome for one RAG document — one row per document id, overwritten on
+ * re-ingest by {@link import('./drizzle-rag-ingestion-log.js').DrizzleRagIngestionLog}.
+ *
+ * This exists because the vector store can only enumerate what it *has*: a document whose extraction
+ * produced no text, whose mime type had no extractor, or whose embedding call blew up has zero chunks
+ * and is therefore invisible to `VectorStore.listDocuments()`. Without this table, a scanned PDF that
+ * silently failed to index is indistinguishable from one that was never uploaded.
+ *
+ * `collection` / `ownerType` / `ownerId` are opaque strings copied off the diagnostics payload — this
+ * package never interprets them, and deliberately has no foreign key to a host's own collection
+ * table, which it cannot know about. The index on (`collection`, `updated_at`) is what the
+ * per-collection listing reads.
+ */
+declare const ragIngestionLog: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: "rag_ingestion_log";
+    schema: undefined;
+    columns: {
+        documentId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "document_id";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "status";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: RagIngestionStatus;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+            $type: RagIngestionStatus;
+        }>;
+        collection: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "collection";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        ownerType: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "owner_type";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        ownerId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "owner_id";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        source: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "source";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        mimeType: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "mime_type";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        size: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "size";
+            tableName: "rag_ingestion_log";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        chunks: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "chunks";
+            tableName: "rag_ingestion_log";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        reason: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "reason";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        error: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "error";
+            tableName: "rag_ingestion_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "created_at";
+            tableName: "rag_ingestion_log";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "updated_at";
+            tableName: "rag_ingestion_log";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/** The tables this store owns, as one schema object, ready for `drizzle(client, { schema })`. */
+declare const agentSchema: {
+    agentThread: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "agent_thread";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "id";
+                tableName: "agent_thread";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            actorRef: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "actor_ref";
+                tableName: "agent_thread";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            tenantRef: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "tenant_ref";
+                tableName: "agent_thread";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            title: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "title";
+                tableName: "agent_thread";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            transient: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "transient";
+                tableName: "agent_thread";
+                dataType: "boolean";
+                columnType: "SQLiteBoolean";
+                data: boolean;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            activeStreamId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "active_stream_id";
+                tableName: "agent_thread";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            defaultAgent: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "default_agent";
+                tableName: "agent_thread";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "created_at";
+                tableName: "agent_thread";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "updated_at";
+                tableName: "agent_thread";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            deletedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "deleted_at";
+                tableName: "agent_thread";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+    agentMessage: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "agent_message";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "id";
+                tableName: "agent_message";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            threadId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "thread_id";
+                tableName: "agent_message";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            role: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "role";
+                tableName: "agent_message";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: MessageRole;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+                $type: MessageRole;
+            }>;
+            content: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "content";
+                tableName: "agent_message";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            toolCalls: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "tool_calls";
+                tableName: "agent_message";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: ToolCallRequest[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: ToolCallRequest[];
+            }>;
+            toolResults: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "tool_results";
+                tableName: "agent_message";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: ToolResult[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: ToolResult[];
+            }>;
+            attachments: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "attachments";
+                tableName: "agent_message";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: MessageAttachment[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: MessageAttachment[];
+            }>;
+            followUps: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "follow_ups";
+                tableName: "agent_message";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: string[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            usage: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "usage";
+                tableName: "agent_message";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: MessageUsage;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: MessageUsage;
+            }>;
+            agentName: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "agent_name";
+                tableName: "agent_message";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            runId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "run_id";
+                tableName: "agent_message";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "created_at";
+                tableName: "agent_message";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+    agentToolCall: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "agent_tool_call";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "id";
+                tableName: "agent_tool_call";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
                 notNull: true;
                 hasDefault: false;
                 isPrimaryKey: true;
@@ -1439,9 +2274,9 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            threadId: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "thread_id";
-                tableName: "agent_message";
+            messageId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "message_id";
+                tableName: "agent_tool_call";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -1458,12 +2293,12 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            role: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "role";
-                tableName: "agent_message";
+            toolName: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "tool_name";
+                tableName: "agent_tool_call";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: MessageRole;
+                data: string;
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;
@@ -1476,14 +2311,13 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
-                $type: MessageRole;
             }>;
-            content: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "content";
-                tableName: "agent_message";
+            toolType: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "tool_type";
+                tableName: "agent_tool_call";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: string;
+                data: ToolKind;
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;
@@ -1496,13 +2330,14 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
+                $type: ToolKind;
             }>;
-            toolCalls: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "tool_calls";
-                tableName: "agent_message";
+            input: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "input";
+                tableName: "agent_tool_call";
                 dataType: "json";
                 columnType: "SQLiteTextJson";
-                data: ToolCallRequest[];
+                data: unknown;
                 driverParam: string;
                 notNull: false;
                 hasDefault: false;
@@ -1513,15 +2348,13 @@ declare const agentSchema: {
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {
-                $type: ToolCallRequest[];
-            }>;
-            toolResults: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "tool_results";
-                tableName: "agent_message";
+            }, {}, {}>;
+            output: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "output";
+                tableName: "agent_tool_call";
                 dataType: "json";
                 columnType: "SQLiteTextJson";
-                data: ToolResult[];
+                data: unknown;
                 driverParam: string;
                 notNull: false;
                 hasDefault: false;
@@ -1532,35 +2365,53 @@ declare const agentSchema: {
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
+            }, {}, {}>;
+            status: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "status";
+                tableName: "agent_tool_call";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: ToolCallStatus;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
             }, {}, {
-                $type: ToolResult[];
+                length: number | undefined;
+                $type: ToolCallStatus;
             }>;
-            followUps: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "follow_ups";
-                tableName: "agent_message";
-                dataType: "json";
-                columnType: "SQLiteTextJson";
-                data: string[];
+            executedByRef: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "executed_by_ref";
+                tableName: "agent_tool_call";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
                 driverParam: string;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
             }, {}, {
-                $type: string[];
+                length: number | undefined;
             }>;
-            usage: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "usage";
-                tableName: "agent_message";
-                dataType: "json";
-                columnType: "SQLiteTextJson";
-                data: MessageUsage;
-                driverParam: string;
+            executionMs: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "execution_ms";
+                tableName: "agent_tool_call";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
@@ -1570,12 +2421,63 @@ declare const agentSchema: {
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
+            }, {}, {}>;
+            error: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "error";
+                tableName: "agent_tool_call";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
             }, {}, {
-                $type: MessageUsage;
+                length: number | undefined;
             }>;
-            agentName: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "agent_name";
-                tableName: "agent_message";
+            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "created_at";
+                tableName: "agent_tool_call";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            executedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "executed_at";
+                tableName: "agent_tool_call";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            runId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "run_id";
+                tableName: "agent_tool_call";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -1592,40 +2494,61 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "created_at";
-                tableName: "agent_message";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
-                driverParam: number;
-                notNull: true;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: undefined;
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
-        };
-        dialect: "sqlite";
-    }>;
-    agentToolCall: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: "agent_tool_call";
-        schema: undefined;
-        columns: {
-            id: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "id";
-                tableName: "agent_tool_call";
+        };
+        dialect: "sqlite";
+    }>;
+    agentTokenUsage: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "agent_token_usage";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "id";
+                tableName: "agent_token_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            threadId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "thread_id";
+                tableName: "agent_token_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            actorRef: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "actor_ref";
+                tableName: "agent_token_usage";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;
-                isPrimaryKey: true;
+                isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
                 enumValues: [string, ...string[]];
@@ -1637,12 +2560,12 @@ declare const agentSchema: {
             }>;
             messageId: drizzle_orm_sqlite_core.SQLiteColumn<{
                 name: "message_id";
-                tableName: "agent_tool_call";
+                tableName: "agent_token_usage";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
                 driverParam: string;
-                notNull: true;
+                notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -1654,9 +2577,9 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            toolName: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "tool_name";
-                tableName: "agent_tool_call";
+            modelId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "model_id";
+                tableName: "agent_token_usage";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -1673,12 +2596,12 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            toolType: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "tool_type";
-                tableName: "agent_tool_call";
+            purpose: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "purpose";
+                tableName: "agent_token_usage";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: ToolKind;
+                data: UsagePurpose;
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;
@@ -1691,15 +2614,49 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
-                $type: ToolKind;
+                $type: UsagePurpose;
             }>;
-            input: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "input";
-                tableName: "agent_tool_call";
-                dataType: "json";
-                columnType: "SQLiteTextJson";
-                data: unknown;
-                driverParam: string;
+            inputTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "input_tokens";
+                tableName: "agent_token_usage";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            outputTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "output_tokens";
+                tableName: "agent_token_usage";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            cacheWriteTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "cache_write_tokens";
+                tableName: "agent_token_usage";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
@@ -1710,13 +2667,13 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            output: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "output";
-                tableName: "agent_tool_call";
-                dataType: "json";
-                columnType: "SQLiteTextJson";
-                data: unknown;
-                driverParam: string;
+            cacheReadTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "cache_read_tokens";
+                tableName: "agent_token_usage";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
@@ -1727,16 +2684,57 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            status: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "status";
-                tableName: "agent_tool_call";
+            costUsd: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "cost_usd";
+                tableName: "agent_token_usage";
+                dataType: "number";
+                columnType: "SQLiteReal";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "created_at";
+                tableName: "agent_token_usage";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+    agentModelPricing: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "agent_model_pricing";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "id";
+                tableName: "agent_model_pricing";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: ToolCallStatus;
+                data: string;
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;
-                isPrimaryKey: false;
+                isPrimaryKey: true;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
                 enumValues: [string, ...string[]];
@@ -1745,16 +2743,15 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
-                $type: ToolCallStatus;
             }>;
-            executedByRef: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "executed_by_ref";
-                tableName: "agent_tool_call";
+            modelId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "model_id";
+                tableName: "agent_model_pricing";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
                 driverParam: string;
-                notNull: false;
+                notNull: true;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -1766,11 +2763,45 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            executionMs: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "execution_ms";
-                tableName: "agent_tool_call";
+            inputPricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "input_price_per_1m";
+                tableName: "agent_model_pricing";
                 dataType: "number";
-                columnType: "SQLiteInteger";
+                columnType: "SQLiteReal";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            outputPricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "output_price_per_1m";
+                tableName: "agent_model_pricing";
+                dataType: "number";
+                columnType: "SQLiteReal";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            cacheWritePricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "cache_write_price_per_1m";
+                tableName: "agent_model_pricing";
+                dataType: "number";
+                columnType: "SQLiteReal";
                 data: number;
                 driverParam: number;
                 notNull: false;
@@ -1783,28 +2814,26 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            error: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "error";
-                tableName: "agent_tool_call";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
+            cacheReadPricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "cache_read_price_per_1m";
+                tableName: "agent_model_pricing";
+                dataType: "number";
+                columnType: "SQLiteReal";
+                data: number;
+                driverParam: number;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
+                enumValues: undefined;
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {
-                length: number | undefined;
-            }>;
-            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "created_at";
-                tableName: "agent_tool_call";
+            }, {}, {}>;
+            effectiveFrom: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "effective_from";
+                tableName: "agent_model_pricing";
                 dataType: "date";
                 columnType: "SQLiteTimestamp";
                 data: Date;
@@ -1819,14 +2848,14 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            executedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "executed_at";
-                tableName: "agent_tool_call";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
+            isCurrent: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "is_current";
+                tableName: "agent_model_pricing";
+                dataType: "boolean";
+                columnType: "SQLiteBoolean";
+                data: boolean;
                 driverParam: number;
-                notNull: false;
+                notNull: true;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -1836,35 +2865,16 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            runId: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "run_id";
-                tableName: "agent_tool_call";
-                dataType: "string";
-                columnType: "SQLiteText";
-                data: string;
-                driverParam: string;
-                notNull: false;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {
-                length: number | undefined;
-            }>;
         };
         dialect: "sqlite";
     }>;
-    agentTokenUsage: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: "agent_token_usage";
+    agentRun: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "agent_run";
         schema: undefined;
         columns: {
             id: drizzle_orm_sqlite_core.SQLiteColumn<{
                 name: "id";
-                tableName: "agent_token_usage";
+                tableName: "agent_run";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -1883,7 +2893,7 @@ declare const agentSchema: {
             }>;
             threadId: drizzle_orm_sqlite_core.SQLiteColumn<{
                 name: "thread_id";
-                tableName: "agent_token_usage";
+                tableName: "agent_run";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -1902,7 +2912,7 @@ declare const agentSchema: {
             }>;
             actorRef: drizzle_orm_sqlite_core.SQLiteColumn<{
                 name: "actor_ref";
-                tableName: "agent_token_usage";
+                tableName: "agent_run";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -1919,9 +2929,9 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            messageId: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "message_id";
-                tableName: "agent_token_usage";
+            agentName: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "agent_name";
+                tableName: "agent_run";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -1938,12 +2948,12 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            modelId: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "model_id";
-                tableName: "agent_token_usage";
+            status: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "status";
+                tableName: "agent_run";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: string;
+                data: AgentRunStatus;
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;
@@ -1956,15 +2966,33 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
+                $type: AgentRunStatus;
             }>;
-            purpose: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "purpose";
-                tableName: "agent_token_usage";
+            durationMs: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "duration_ms";
+                tableName: "agent_run";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            errorCode: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "error_code";
+                tableName: "agent_run";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: UsagePurpose;
+                data: string;
                 driverParam: string;
-                notNull: true;
+                notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -1975,34 +3003,35 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
-                $type: UsagePurpose;
             }>;
-            inputTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "input_tokens";
-                tableName: "agent_token_usage";
-                dataType: "number";
-                columnType: "SQLiteInteger";
-                data: number;
-                driverParam: number;
-                notNull: true;
+            errorMessage: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "error_message";
+                tableName: "agent_run";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {}>;
-            outputTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "output_tokens";
-                tableName: "agent_token_usage";
+            }, {}, {
+                length: number | undefined;
+            }>;
+            retries: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "retries";
+                tableName: "agent_run";
                 dataType: "number";
                 columnType: "SQLiteInteger";
                 data: number;
                 driverParam: number;
                 notNull: true;
-                hasDefault: false;
+                hasDefault: true;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
@@ -2011,14 +3040,14 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            cacheWriteTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "cache_write_tokens";
-                tableName: "agent_token_usage";
-                dataType: "number";
-                columnType: "SQLiteInteger";
-                data: number;
+            startedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "started_at";
+                tableName: "agent_run";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
                 driverParam: number;
-                notNull: false;
+                notNull: true;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -2028,12 +3057,12 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            cacheReadTokens: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "cache_read_tokens";
-                tableName: "agent_token_usage";
-                dataType: "number";
-                columnType: "SQLiteInteger";
-                data: number;
+            settledAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "settled_at";
+                tableName: "agent_run";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
                 driverParam: number;
                 notNull: false;
                 hasDefault: false;
@@ -2045,50 +3074,54 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            costUsd: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "cost_usd";
-                tableName: "agent_token_usage";
-                dataType: "number";
-                columnType: "SQLiteReal";
-                data: number;
-                driverParam: number;
+            promptHash: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "prompt_hash";
+                tableName: "agent_run";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {}>;
-            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "created_at";
-                tableName: "agent_token_usage";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
-                driverParam: number;
-                notNull: true;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            parentRunId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "parent_run_id";
+                tableName: "agent_run";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {}>;
+            }, {}, {
+                length: number | undefined;
+            }>;
         };
         dialect: "sqlite";
     }>;
-    agentModelPricing: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: "agent_model_pricing";
+    agentMemory: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "agent_memory";
         schema: undefined;
         columns: {
             id: drizzle_orm_sqlite_core.SQLiteColumn<{
                 name: "id";
-                tableName: "agent_model_pricing";
+                tableName: "agent_memory";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -2105,9 +3138,9 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            modelId: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "model_id";
-                tableName: "agent_model_pricing";
+            scope: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "scope";
+                tableName: "agent_memory";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -2124,66 +3157,130 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            inputPricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "input_price_per_1m";
-                tableName: "agent_model_pricing";
-                dataType: "number";
-                columnType: "SQLiteReal";
-                data: number;
-                driverParam: number;
+            key: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "key";
+                tableName: "agent_memory";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
                 notNull: true;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {}>;
-            outputPricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "output_price_per_1m";
-                tableName: "agent_model_pricing";
-                dataType: "number";
-                columnType: "SQLiteReal";
-                data: number;
-                driverParam: number;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            text: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "text";
+                tableName: "agent_memory";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
                 notNull: true;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {}>;
-            cacheWritePricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "cache_write_price_per_1m";
-                tableName: "agent_model_pricing";
-                dataType: "number";
-                columnType: "SQLiteReal";
-                data: number;
-                driverParam: number;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            originAuthor: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "origin_author";
+                tableName: "agent_memory";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: "agent" | "human";
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+                $type: "agent" | "human";
+            }>;
+            originThreadId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "origin_thread_id";
+                tableName: "agent_memory";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            originRunId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "origin_run_id";
+                tableName: "agent_memory";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            originActorRef: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "origin_actor_ref";
+                tableName: "agent_memory";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {}>;
-            cacheReadPricePer1m: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "cache_read_price_per_1m";
-                tableName: "agent_model_pricing";
-                dataType: "number";
-                columnType: "SQLiteReal";
-                data: number;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            pinned: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "pinned";
+                tableName: "agent_memory";
+                dataType: "boolean";
+                columnType: "SQLiteBoolean";
+                data: boolean;
                 driverParam: number;
-                notNull: false;
-                hasDefault: false;
+                notNull: true;
+                hasDefault: true;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
@@ -2192,9 +3289,9 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            effectiveFrom: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "effective_from";
-                tableName: "agent_model_pricing";
+            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "created_at";
+                tableName: "agent_memory";
                 dataType: "date";
                 columnType: "SQLiteTimestamp";
                 data: Date;
@@ -2209,12 +3306,12 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            isCurrent: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "is_current";
-                tableName: "agent_model_pricing";
-                dataType: "boolean";
-                columnType: "SQLiteBoolean";
-                data: boolean;
+            updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "updated_at";
+                tableName: "agent_memory";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
                 driverParam: number;
                 notNull: true;
                 hasDefault: false;
@@ -2229,13 +3326,13 @@ declare const agentSchema: {
         };
         dialect: "sqlite";
     }>;
-    agentRun: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: "agent_run";
+    ragIngestionLog: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "rag_ingestion_log";
         schema: undefined;
         columns: {
-            id: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "id";
-                tableName: "agent_run";
+            documentId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "document_id";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -2252,12 +3349,12 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            threadId: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "thread_id";
-                tableName: "agent_run";
+            status: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "status";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: string;
+                data: RagIngestionStatus;
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;
@@ -2270,15 +3367,16 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
+                $type: RagIngestionStatus;
             }>;
-            actorRef: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "actor_ref";
-                tableName: "agent_run";
+            collection: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "collection";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
                 driverParam: string;
-                notNull: true;
+                notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -2290,9 +3388,9 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            agentName: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "agent_name";
-                tableName: "agent_run";
+            ownerType: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "owner_type";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -2309,14 +3407,14 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            status: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "status";
-                tableName: "agent_run";
+            ownerId: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "owner_id";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: AgentRunStatus;
+                data: string;
                 driverParam: string;
-                notNull: true;
+                notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -2327,28 +3425,10 @@ declare const agentSchema: {
                 generated: undefined;
             }, {}, {
                 length: number | undefined;
-                $type: AgentRunStatus;
             }>;
-            durationMs: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "duration_ms";
-                tableName: "agent_run";
-                dataType: "number";
-                columnType: "SQLiteInteger";
-                data: number;
-                driverParam: number;
-                notNull: false;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: undefined;
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
-            errorCode: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "error_code";
-                tableName: "agent_run";
+            source: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "source";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -2365,9 +3445,9 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            errorMessage: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "error_message";
-                tableName: "agent_run";
+            mimeType: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "mime_type";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -2384,15 +3464,15 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
-            retries: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "retries";
-                tableName: "agent_run";
+            size: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "size";
+                tableName: "rag_ingestion_log";
                 dataType: "number";
                 columnType: "SQLiteInteger";
                 data: number;
                 driverParam: number;
-                notNull: true;
-                hasDefault: true;
+                notNull: false;
+                hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
@@ -2401,14 +3481,14 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            startedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "started_at";
-                tableName: "agent_run";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
+            chunks: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "chunks";
+                tableName: "rag_ingestion_log";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
                 driverParam: number;
-                notNull: true;
+                notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
@@ -2418,26 +3498,28 @@ declare const agentSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            settledAt: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "settled_at";
-                tableName: "agent_run";
-                dataType: "date";
-                columnType: "SQLiteTimestamp";
-                data: Date;
-                driverParam: number;
+            reason: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "reason";
+                tableName: "rag_ingestion_log";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
                 notNull: false;
                 hasDefault: false;
                 isPrimaryKey: false;
                 isAutoincrement: false;
                 hasRuntimeDefault: false;
-                enumValues: undefined;
+                enumValues: [string, ...string[]];
                 baseColumn: never;
                 identity: undefined;
                 generated: undefined;
-            }, {}, {}>;
-            promptHash: drizzle_orm_sqlite_core.SQLiteColumn<{
-                name: "prompt_hash";
-                tableName: "agent_run";
+            }, {}, {
+                length: number | undefined;
+            }>;
+            error: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "error";
+                tableName: "rag_ingestion_log";
                 dataType: "string";
                 columnType: "SQLiteText";
                 data: string;
@@ -2454,6 +3536,40 @@ declare const agentSchema: {
             }, {}, {
                 length: number | undefined;
             }>;
+            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "created_at";
+                tableName: "rag_ingestion_log";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "updated_at";
+                tableName: "rag_ingestion_log";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: "sqlite";
     }>;
@@ -2463,15 +3579,22 @@ declare const agentSchema: {
  * driver (better-sqlite3, libsql, D1, …) in either sync or async result mode; the host app owns
  * the connection and passes the `drizzle(...)` instance in.
  */
-type AgentDrizzleDb = BaseSQLiteDatabase<'sync' | 'async', unknown>;
+type AgentDrizzleDb = BaseSQLiteDatabase<'sync' | 'async', unknown, Record<string, unknown>, TablesRelationalConfig>;
 /** A persisted thread row as Drizzle selects it. */
 type AgentThreadRow = typeof agentThread.$inferSelect;
 /** A persisted message row as Drizzle selects it. */
 type AgentMessageRow = typeof agentMessage.$inferSelect;
 /** A persisted run row as Drizzle selects it. */
 type AgentRunRow = typeof agentRun.$inferSelect;
+/** A persisted memory row as Drizzle selects it. */
+type AgentMemoryRow = typeof agentMemory.$inferSelect;
+/** A persisted RAG ingestion outcome as Drizzle selects it. */
+type RagIngestionLogRow = typeof ragIngestionLog.$inferSelect;
 
-/** Runs the `CREATE TABLE IF NOT EXISTS` DDL above against the supplied Drizzle SQLite db. */
+/**
+ * Runs the `CREATE TABLE IF NOT EXISTS` DDL above against the supplied Drizzle SQLite db, then adds
+ * any column missing from a table that already existed.
+ */
 declare function ensureAgentSchema(db: AgentDrizzleDb): Promise<void>;
 
 /**
@@ -2480,11 +3603,30 @@ declare function ensureAgentSchema(db: AgentDrizzleDb): Promise<void>;
  * owns the connection). Behaviour mirrors {@link import('@dudousxd/nestjs-agent-store-mikro-orm')}
  * exactly (fork/truncate/quota/active-stream/soft-delete semantics) so the two are interchangeable.
  */
-declare class DrizzleAgentStore implements AgentStore {
+declare class DrizzleAgentStore implements AgentStore, ThreadTurnReader {
     private readonly db;
     constructor(db: AgentDrizzleDb);
     createThread(input: CreateThreadInput): Promise<ThreadSummary>;
     getThread(threadId: string): Promise<ThreadDetail | null>;
+    /**
+     * The window a turn reads off a thread: its newest `messageLimit` messages (oldest first), the
+     * title, the default agent, and whether the thread has EVER been answered.
+     *
+     * {@link getThread} is the wrong read for a turn. It materializes the transcript — every message,
+     * every attachment, every tool output the thread ever recorded — and the run then journals what it
+     * loaded, so a long thread pays for its whole history on every turn and again on every replay.
+     *
+     * `hasAssistantMessage` is answered over the WHOLE thread, not the returned page: it answers "has
+     * this conversation been answered before?", and a thread whose window happens to hold only the
+     * user's last questions has still been answered. `null` when the thread is unknown or
+     * soft-deleted, same as {@link getThread}.
+     */
+    loadThreadForTurn(query: ThreadTurnQuery): Promise<ThreadTurnPage | null>;
+    /**
+     * The newest `limit` messages of a thread, oldest first, projected to the columns a model turn
+     * reads. Read newest-first so the LIMIT is the database's job, then reversed for the prompt.
+     */
+    private loadTurnWindow;
     listThreads(actorRef: string, limit?: number): Promise<ThreadSummary[]>;
     softDeleteThread(threadId: string): Promise<void>;
     forkThread(threadId: string, fromMessageId: string): Promise<ThreadSummary>;
@@ -2495,18 +3637,30 @@ declare class DrizzleAgentStore implements AgentStore {
     setTitle(threadId: string, title: string): Promise<void>;
     promoteThread(threadId: string): Promise<void>;
     setActiveStream(threadId: string, runId: string | null): Promise<void>;
-    /** Persist the start of a run (turn). Replay-safe: called under a durable localStep. */
-    recordRunStart(run: {
-        runId: string;
-        threadId: string;
-        actorRef: string;
-        agentName?: string;
-        promptHash?: string;
-    }): Promise<void>;
+    /**
+     * Patch a thread's `title` and/or `defaultAgent`. Each field is only touched when PRESENT in
+     * `patch` — `defaultAgent: null` clears it (falls back to the app default), while an omitted
+     * `defaultAgent` leaves whatever is stored untouched. A no-op (including `updatedAt`) when the
+     * patch is empty or the thread doesn't exist.
+     */
+    updateThread(threadId: string, patch: UpdateThreadInput): Promise<void>;
+    /**
+     * The thread's default agent, projected — the caller wants one nullable scalar to decide which
+     * agent answers the next turn, and {@link getThread} would materialize the whole transcript to
+     * hand it over. `null` when the thread is unknown, soft-deleted, or has no default set.
+     */
+    defaultAgentForThread(threadId: string): Promise<string | null>;
+    /**
+     * Persist the start of a run (turn). Replay-safe: called under a durable localStep.
+     *
+     * Takes the SPI's own {@link RecordRunStartInput} rather than a hand-copied shape: a field added
+     * to the input is otherwise accepted and dropped, silently, by every adapter that re-declares it.
+     */
+    recordRunStart(run: RecordRunStartInput): Promise<void>;
     /** Settle a run's outcome. A no-op when the run is unknown (mirrors `setTitle`/`updateThread`). */
     recordRunEnd(end: {
         runId: string;
-        status: 'completed' | 'failed';
+        status: 'completed' | 'failed' | 'cancelled';
         durationMs?: number;
         errorCode?: string;
         errorMessage?: string;
@@ -2514,9 +3668,24 @@ declare class DrizzleAgentStore implements AgentStore {
     /** Bump the run's llm-step retry counter. Atomic `retries = retries + 1`, no read-modify-write. */
     bumpRunRetries(runId: string): Promise<void>;
     appendMessage(input: AppendMessageInput): Promise<StoredMessage>;
+    setMessageToolResults(messageId: string, results: ToolResult[]): Promise<void>;
     truncateFrom(threadId: string, messageId: string): Promise<void>;
     recordToolCall(input: RecordToolCallInput): Promise<void>;
     updateToolCall(input: UpdateToolCallInput): Promise<void>;
+    /**
+     * Of `mediaIds`, the ones a surviving message in one of this actor's threads still carries.
+     *
+     * Reads the `attachments` JSON back out and matches in memory rather than pushing the match into
+     * SQL: the column holds an array of objects, and every dialect this adapter's sibling targets
+     * spells that query differently (`jsonb` containment, `json_table`, `json_each`), while none of
+     * them can use an index for it anyway. The scan is bounded by ONE actor's attachment-bearing
+     * messages, which is a small set — attachments are rare, and a message without one is excluded
+     * by the `is not null` before any JSON is parsed.
+     *
+     * Soft-deleted threads are deliberately included: their message rows survive, so the bytes they
+     * point at are still reachable from stored state and are not garbage.
+     */
+    referencedMediaIds(actorRef: string, mediaIds: readonly string[]): Promise<string[]>;
     recordUsage(input: RecordUsageInput): Promise<void>;
     quotaToday(actorRef: string, day: string): Promise<{
         usedTokens: number;
@@ -2626,6 +3795,72 @@ declare class DrizzleGovernanceQueries implements AgentGovernanceQueries {
     private toolCallCountsByMessage;
 }
 
+/**
+ * {@link MemoryProvider} backed by Drizzle, over the `agent_memory` table this package's
+ * `ensureAgentSchema` creates. The host app owns and supplies the db handle.
+ *
+ * `search` IS NOT IMPLEMENTED, and that is a decision rather than an omission. It is optional on the
+ * SPI, and what it buys is a block filled by relevance once the applicable set outgrows
+ * `maxMemories` — which needs an index over the memories themselves, and an index is the half a
+ * general-purpose table cannot supply: the shape depends entirely on what a deployment already runs
+ * (pgvector, a full-text index, a hybrid service), and picking one here would make this adapter
+ * require infrastructure most hosts do not have for a ceiling most of them never reach. Without
+ * `search`, `list` reads the applicable scopes whole and the ceiling never bites.
+ *
+ * The signal that it is worth building is `MemoryDigest.omitted` going non-zero — and
+ * `pinnedOmitted` especially, which means a standing policy stopped reaching any prompt. Both are on
+ * the `aviary:agent:memory.resolved` diagnostic. A host that gets there implements `search` against
+ * its own index and passes it as the provider, or wraps this one.
+ */
+declare class DrizzleMemoryProvider implements MemoryProvider {
+    private readonly db;
+    constructor(db: AgentDrizzleDb);
+    /**
+     * Every memory visible at `scopes` — asked on EVERY turn, so it is one indexed `scope in (…)`
+     * against the leading column of the (`scope`, `key`) unique index.
+     *
+     * The scope filter is in the QUERY. The library drops out-of-scope records it is handed, but that
+     * is a backstop: a memory held for another actor or another tenant is never selected here, so it
+     * is unreachable rather than outranked.
+     */
+    list({ scopes }: ListMemoriesInput): Promise<MemoryRecord[]>;
+    /**
+     * Delete one, and only from the actor's OWN scope.
+     *
+     * `memoryForgetVerdict` already holds the library's endpoint to that rule; the `where` repeats it
+     * because `forget` takes an id and nothing else, so a caller reaching this provider by any other
+     * path would otherwise delete a tenant's or the deployment's memory by knowing one id.
+     *
+     * `false` where nothing matched — which covers "no such id" and "not yours" identically, so the
+     * answer cannot be used to find out which memories exist about other people.
+     */
+    forget({ id, ctx }: ForgetMemoryInput): Promise<boolean>;
+    /**
+     * Upsert on (`scope`, `key`) — one statement, against the unique index, rather than a read
+     * followed by a write: two turns concluding the same key at once would otherwise race to a
+     * duplicate-key insert and one of them would fail the `remember` tool.
+     *
+     * The conflict `set` names exactly what a rewrite may change, so `pinned`, `createdAt` and `id`
+     * are left alone by construction rather than by an exclusion anyone could forget to extend.
+     * Dropping `pinned` would silently unpin a row the next time the agent restated the fact;
+     * rewriting `createdAt` would lose when the belief was first formed; reassigning `id` would
+     * invalidate the delete handle a person was already shown.
+     */
+    write({ key, text, scope, origin, ctx }: StoreMemoryInput): Promise<MemoryRecord>;
+    /**
+     * Make one memory always-on, or stop it being one. The operator act the SPI has no method for, on
+     * purpose: a pin grants a fact a permanent place in every future prompt, so nothing an agent can
+     * reach may set it. Authorize it in your own console — this takes no `ScopeContext` because it is
+     * not an actor's act on their own memory.
+     *
+     * `false` where there is no such id.
+     */
+    pin({ id, pinned }: {
+        id: string;
+        pinned: boolean;
+    }): Promise<boolean>;
+}
+
 /**
  * {@link AgentPricingStore} backed by Drizzle ORM — the write side of the pricing table
  * {@link import('./drizzle-governance-queries.js').DrizzleGovernanceQueries} joins against. A POJO
@@ -2639,6 +3874,190 @@ declare class DrizzlePricingStore implements AgentPricingStore {
     listCurrentPrices(): Promise<CurrentModelPrice[]>;
 }
 
+/**
+ * The paging order: newest first, tiebroken on the primary key.
+ *
+ * `updatedAt` alone is not a total order — a bulk upload stamps every document of the batch with the
+ * same second — and a database is free to return tied rows in a different sequence for each
+ * LIMIT/OFFSET query. A tie straddling a page boundary then hands a caller sweeping the table a row
+ * in *neither* page (or the same row twice), which is how an orphan-sweep leaves an S3 object behind
+ * with its log row already gone, and how a reconcile re-embeds documents it already has.
+ * `documentId` is the table's primary key, so appending it makes the order total and the pages
+ * disjoint.
+ *
+ * Exported because it is a contract, not an implementation detail: a caller that polls page 1 for a
+ * document it just rewrote depends on `updated_at desc`, and a caller that pages depends on the
+ * tiebreaker. Spread it into a query of your own (`.orderBy(...RAG_INGESTION_LOG_PAGE_ORDER)`) to
+ * read this table the way {@link DrizzleRagIngestionLog} does — and to keep `iterate`'s keyset
+ * arithmetic, which is derived from exactly this order, in view.
+ */
+declare const RAG_INGESTION_LOG_PAGE_ORDER: SQL[];
+/** The coordinates half of a log query: which rows, with nothing said about paging. */
+interface RagIngestionLogWhere {
+    collection?: string;
+    status?: RagIngestionStatus;
+}
+interface RagIngestionLogQuery extends RagIngestionLogWhere {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Where a sweep left off: the ordering column plus the primary key, i.e. one point in
+ * {@link RAG_INGESTION_LOG_PAGE_ORDER}. Not an opaque token — it is two column values, so a caller
+ * may persist it across processes and resume from it.
+ */
+interface RagIngestionLogCursor {
+    updatedAt: Date;
+    documentId: string;
+}
+interface RagIngestionLogIterateOptions {
+    /**
+     * Rows fetched per round-trip. Defaults to 200; anything under 1 or non-finite falls back to
+     * that default rather than being honoured — a batch of 0 would fetch nothing and never advance.
+     */
+    batchSize?: number;
+    /** Resume strictly after this point in the order, e.g. a cursor persisted by an earlier sweep. */
+    after?: RagIngestionLogCursor;
+}
+/**
+ * Records the outcome of every RAG ingestion into `rag_ingestion_log`, by subscribing to the
+ * `aviary:rag:*` diagnostics channels `@dudousxd/nestjs-agent-rag-media` publishes — the Drizzle
+ * counterpart of `MikroOrmRagIngestionLog`, with the same columns, ordering and write semantics, so
+ * a console built on one adapter reads the other.
+ *
+ * It answers the question a vector store structurally cannot: *which documents failed to index, and
+ * why*. A skipped or failed document produces no chunks, so it is invisible to
+ * `VectorStore.listDocuments()` — the index only knows about successes. Pair the two for a complete
+ * picture: the store is the truth about what is retrievable, this table is the truth about what was
+ * attempted.
+ *
+ * Writes are best-effort and never throw: this runs detached from any request, on a diagnostics
+ * channel, so a failed write must not take down the ingestion that triggered it. A lost row costs
+ * observability, not data — the vector store remains the system of record.
+ */
+declare class DrizzleRagIngestionLog implements OnModuleInit, OnModuleDestroy {
+    private readonly db;
+    private readonly logger;
+    private teardowns;
+    private readonly inFlight;
+    constructor(db: AgentDrizzleDb);
+    onModuleInit(): void;
+    onModuleDestroy(): Promise<void>;
+    /** Await every in-flight write — for graceful shutdown and deterministic tests. */
+    settle(): Promise<void>;
+    /** The latest recorded outcome per document, newest first. */
+    list(query?: RagIngestionLogQuery): Promise<RagIngestionLogRow[]>;
+    /**
+     * The same page plus the unpaginated total, so a caller can tell "these are all of them" from
+     * "these are the first N". A list that silently truncates reads as complete when it isn't.
+     *
+     * Offset paging is only sound over a table nobody is deleting from underneath you: a row removed
+     * behind the cursor shifts everything after it back by one, so the next page starts one row late
+     * and that row is never seen. Use {@link iterate} for any sweep that deletes.
+     */
+    listPage(query?: RagIngestionLogQuery): Promise<{
+        rows: RagIngestionLogRow[];
+        total: number;
+    }>;
+    /**
+     * Every matching row, newest first, streamed in batches — the sweep-safe way to walk this table.
+     *
+     * Paging is *keyset*, not offset: each batch asks for the rows that sort strictly after the last
+     * row yielded, using `(updatedAt, documentId)` — one point in
+     * {@link RAG_INGESTION_LOG_PAGE_ORDER}, which is total because it ends in the primary key. A
+     * cursor made of column values does not move when rows leave the table, which is what makes this
+     * delete-safe *by construction* rather than by the caller carefully advancing an offset by only
+     * the rows it kept.
+     *
+     * **The guarantee, stated once:** a row is yielded exactly when — at the moment the batch that
+     * would contain it is fetched — the row exists, matches `where`, and sorts strictly after the
+     * last row already yielded. Everything below is a consequence of that one sentence.
+     *
+     * What you can rely on:
+     * - **Deleting rows while iterating is safe.** Delete any row you like — the one just yielded, the
+     *   whole batch, rows you have not reached yet — and every row that is still there when the sweep
+     *   reaches its position is visited exactly once. Nothing is skipped and nothing is repeated,
+     *   because deleting a row moves no *other* row's `(updatedAt, documentId)`. (Rows you delete
+     *   *ahead* of the cursor are simply never visited, which is the point of deleting them.)
+     * - **Ties are safe.** A bulk upload stamps a whole batch with the same `updatedAt`; the
+     *   `documentId` tiebreaker keeps consecutive batches disjoint even when every row ties.
+     * - **Each row is yielded at most once**, for as long as `updatedAt` only ever moves forward —
+     *   which is what `record()` does, since it always stamps `now`.
+     *
+     * What this is **not**: a snapshot, or a repeatable read. The sweep observes the table as it is
+     * when each batch is fetched, so:
+     * - A row **inserted** mid-sweep by `record()` is stamped `now`. The order is newest-first, so it
+     *   sorts ahead of a cursor the sweep has already moved past, and is not visited. A sweep
+     *   therefore never sees documents ingested after it started — the behaviour an orphan sweep
+     *   wants, since a document that arrived while you were sweeping is not an orphan. (A *direct*
+     *   insert with a backdated `updatedAt` lands ahead of the cursor and **is** visited; nothing in
+     *   this class writes one.)
+     * - A row **re-ingested** mid-sweep has its `updatedAt` bumped to `now`, moving it ahead of the
+     *   cursor for the same reason. If the sweep had already passed it, it is not visited twice; if it
+     *   had not, it is **missed for this pass**. That is the honest limit: against a concurrent
+     *   writer `iterate` guarantees "at most once", not "at least once". Sweeps that must not miss a
+     *   concurrently-rewritten row should be idempotent and run again.
+     * - Only a row whose `updatedAt` moves *backwards* — which needs a direct write — can be yielded
+     *   twice.
+     * - `collection` / `status` are re-evaluated per batch, so a row that stops matching mid-sweep
+     *   stops being visited.
+     *
+     * There is no `limit`/`offset` here on purpose: `where` says *which* rows, `options` says how the
+     * sweep is run. A sweep that stops early stops by `break`ing out of the `for await`.
+     */
+    iterate(where?: RagIngestionLogWhere, options?: RagIngestionLogIterateOptions): AsyncGenerator<RagIngestionLogRow, void, undefined>;
+    /**
+     * Just the document ids of the matching rows, in {@link RAG_INGESTION_LOG_PAGE_ORDER}.
+     *
+     * Returns **all** of them — no 200-row cap, unlike `list` — by sweeping on {@link iterate}'s
+     * keyset internally, so it is correct against concurrent deletes for the same reason `iterate`
+     * is. What the cap protects against is hydrating an unbounded number of wide rows (`error` is a
+     * TEXT column); this selects two columns — the id, plus the `updatedAt` the cursor needs — and
+     * keeps only the ids, so the peak footprint is one batch of two-column rows plus a list of
+     * strings whose size *is* the answer the caller asked for.
+     *
+     * For callers that need the id set of a collection and nothing else: an orphan sweep unioning the
+     * log against the vector store's own document list.
+     */
+    listDocumentIds(where?: RagIngestionLogWhere, options?: {
+        batchSize?: number;
+    }): Promise<string[]>;
+    /** The latest recorded outcome for one document, or null if it was never attempted. */
+    get(documentId: string): Promise<RagIngestionLogRow | null>;
+    /** Forget one document's record. Returns whether a row was actually removed. */
+    remove(documentId: string): Promise<boolean>;
+    /** Forget every record for a collection — for when the collection itself is deleted. */
+    removeByCollection(collection: string): Promise<number>;
+    /**
+     * The keyset sweep both {@link iterate} and {@link listDocumentIds} are made of. `page` decides
+     * how wide a row is — whole rows for `iterate`, two columns for `listDocumentIds` — and the
+     * `R extends RagIngestionLogCursor` bound says the only thing the sweep needs back: a row it can
+     * read the next cursor off.
+     *
+     * The cursor advances **per yielded row**, not per batch, so a consumer that `break`s mid-batch
+     * leaves it on the last row it actually saw. It is two column values read off that row, so a row
+     * leaving the table cannot move it — the whole reason this is delete-safe by construction.
+     */
+    private sweep;
+    private where;
+    /**
+     * The coordinates filter AND'd with "strictly after `cursor` in
+     * {@link RAG_INGESTION_LOG_PAGE_ORDER}".
+     *
+     * The order is `updatedAt desc, documentId asc`, so "after" means an older timestamp, or the same
+     * timestamp and a larger id. Both halves are needed: the `<` alone would re-yield every row tied
+     * with the cursor, and dropping the tie branch would skip them instead.
+     */
+    private keyset;
+    /**
+     * Upsert one outcome. Keyed by document id so the row always reflects the *current* state — a
+     * retry that succeeds overwrites the failure it replaces, rather than leaving a stale error next
+     * to a working document.
+     */
+    private record;
+    private track;
+}
+
 /** Options for {@link DrizzleAgentStoreModule.forRoot}. The app owns and supplies the db handle. */
 interface DrizzleAgentStoreModuleOptions {
     /** A Drizzle SQLite database instance (`drizzle(client, { schema: agentSchema })`). */
@@ -2649,6 +4068,18 @@ interface DrizzleAgentStoreModuleOptions {
      * table the single source of cost truth without touching `agent_model_pricing`.
      */
     pricingStore?: Type<AgentPricingStore>;
+    /**
+     * Record every RAG ingestion outcome into `rag_ingestion_log` by subscribing to the `aviary:rag:*`
+     * diagnostics channels (default `true`, matching the MikroORM adapter). This is the only place a
+     * *failed* or *skipped* document is visible — one that produced no chunks doesn't exist as far as
+     * `VectorStore.listDocuments()` is concerned. Set `false` if you don't ingest media into RAG, or
+     * record outcomes yourself.
+     *
+     * The table has to exist: `ensureAgentSchema` creates it, or write the `CREATE TABLE` into
+     * your own migrations. Writes are best-effort, so a missing table costs a warning per ingestion
+     * rather than a failed ingestion.
+     */
+    ragIngestionLog?: boolean;
 }
 /**
  * Binds {@link DrizzleAgentStore} to the {@link AGENT_STORE} token consumed by
@@ -2671,4 +4102,4 @@ declare class DrizzleAgentStoreModule {
     static forRoot(options: DrizzleAgentStoreModuleOptions): DynamicModule;
 }
 
-export { type AgentDrizzleDb, type AgentMessageRow, type AgentRunRow, type AgentRunStatus, type AgentThreadRow, DrizzleAgentStore, DrizzleAgentStoreModule, type DrizzleAgentStoreModuleOptions, DrizzleGovernanceQueries, DrizzlePricingStore, agentMessage, agentModelPricing, agentRun, agentSchema, agentThread, agentTokenUsage, agentToolCall, ensureAgentSchema };
+export { type AgentDrizzleDb, type AgentMemoryRow, type AgentMessageRow, type AgentRunRow, type AgentRunStatus, type AgentThreadRow, DrizzleAgentStore, DrizzleAgentStoreModule, type DrizzleAgentStoreModuleOptions, DrizzleGovernanceQueries, DrizzleMemoryProvider, DrizzlePricingStore, DrizzleRagIngestionLog, RAG_INGESTION_LOG_PAGE_ORDER, type RagIngestionLogCursor, type RagIngestionLogIterateOptions, type RagIngestionLogQuery, type RagIngestionLogRow, type RagIngestionLogWhere, type RagIngestionStatus, agentMemory, agentMessage, agentModelPricing, agentRun, agentSchema, agentThread, agentTokenUsage, agentToolCall, ensureAgentSchema, ragIngestionLog };