@dudousxd/nestjs-agent-store-drizzle 0.23.0 → 0.24.0

package/dist/index.cjs

@@ -10,9 +10,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc4) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc4 = __getOwnPropDesc(from, key)) || desc4.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc4 = __getOwnPropDesc(from, key2)) || desc4.enumerable });
   }
   return to;
 };
@@ -32,17 +32,21 @@ __export(index_exports, {
   DrizzleTokenStreamSink: () => DrizzleTokenStreamSink,
   RAG_INGESTION_LOG_PAGE_ORDER: () => RAG_INGESTION_LOG_PAGE_ORDER,
   agentConfirmToken: () => agentConfirmToken,
+  agentDialectOf: () => agentDialectOf,
   agentMemory: () => agentMemory,
   agentMessage: () => agentMessage,
   agentModelPricing: () => agentModelPricing,
   agentQueuedMessage: () => agentQueuedMessage,
   agentRun: () => agentRun,
   agentSchema: () => agentSchema,
+  agentSchemaDdl: () => agentSchemaDdl,
   agentStreamFrame: () => agentStreamFrame,
   agentThread: () => agentThread,
   agentTokenUsage: () => agentTokenUsage,
   agentToolCall: () => agentToolCall,
   ensureAgentSchema: () => ensureAgentSchema,
+  mysqlAgentSchema: () => mysqlAgentSchema,
+  pgAgentSchema: () => pgAgentSchema,
   ragIngestionLog: () => ragIngestionLog
 });
 module.exports = __toCommonJS(index_exports);
@@ -117,6 +121,12 @@ var agentMessage = (0, import_sqlite_core.sqliteTable)("agent_message", {
   feedback: (0, import_sqlite_core.text)("feedback", {
     mode: "json"
   }).$type(),
+  /**
+   * The message's place in its thread, 1-based, assigned on append — what orders a transcript.
+   * `created_at` cannot: two messages of one turn routinely share a timestamp, and the uuid that
+   * broke the tie is random. `null` on a row from before the column; those sort first.
+   */
+  seq: (0, import_sqlite_core.integer)("seq"),
   createdAt: (0, import_sqlite_core.integer)("created_at", {
     mode: "timestamp_ms"
   }).notNull()
@@ -351,303 +361,721 @@ var agentSchema = {
   agentRun,
   agentMemory,
   ragIngestionLog,
-  agentConfirmToken
+  agentConfirmToken,
+  agentStreamFrame
 };
 
 // src/ensure-schema.ts
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_mysql_core3 = require("drizzle-orm/mysql-core");
+var import_pg_core3 = require("drizzle-orm/pg-core");
+var import_sqlite_core2 = require("drizzle-orm/sqlite-core");
+
+// src/dialect.ts
 var import_drizzle_orm = require("drizzle-orm");
-var statements = [
-  `CREATE TABLE IF NOT EXISTS agent_thread (
-    id TEXT PRIMARY KEY NOT NULL,
-    actor_ref TEXT NOT NULL,
-    tenant_ref TEXT,
-    title TEXT NOT NULL,
-    transient INTEGER NOT NULL DEFAULT 0,
-    active_stream_id TEXT,
-    default_agent TEXT,
-    model TEXT,
-    persona TEXT,
-    queue_pause TEXT,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL,
-    deleted_at INTEGER
-  )`,
-  `CREATE INDEX IF NOT EXISTS agent_thread_actor_updated_idx
-    ON agent_thread (actor_ref, updated_at)`,
-  `CREATE TABLE IF NOT EXISTS agent_message (
-    id TEXT PRIMARY KEY NOT NULL,
-    thread_id TEXT NOT NULL REFERENCES agent_thread(id) ON DELETE CASCADE,
-    role TEXT NOT NULL,
-    content TEXT NOT NULL,
-    tool_calls TEXT,
-    tool_results TEXT,
-    attachments TEXT,
-    follow_ups TEXT,
-    usage TEXT,
-    agent_name TEXT,
-    persona TEXT,
-    run_id TEXT,
-    reasoning TEXT,
-    reasoning_ms INTEGER,
-    ui TEXT,
-    feedback TEXT,
-    created_at INTEGER NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS agent_message_thread_created_idx
-    ON agent_message (thread_id, created_at)`,
-  `CREATE TABLE IF NOT EXISTS agent_queued_message (
-    id TEXT PRIMARY KEY NOT NULL,
-    thread_id TEXT NOT NULL REFERENCES agent_thread(id) ON DELETE CASCADE,
-    actor TEXT NOT NULL,
-    content TEXT NOT NULL,
-    attachments TEXT,
-    agent_name TEXT,
-    persona TEXT,
-    model TEXT,
-    page_context TEXT,
-    interrupt INTEGER NOT NULL DEFAULT 0,
-    position INTEGER NOT NULL,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS agent_queued_message_thread_position_idx
-    ON agent_queued_message (thread_id, position)`,
-  `CREATE TABLE IF NOT EXISTS agent_tool_call (
-    id TEXT PRIMARY KEY NOT NULL,
-    message_id TEXT NOT NULL REFERENCES agent_message(id) ON DELETE CASCADE,
-    tool_name TEXT NOT NULL,
-    tool_type TEXT NOT NULL,
-    input TEXT,
-    output TEXT,
-    status TEXT NOT NULL,
-    executed_by_ref TEXT,
-    execution_ms INTEGER,
-    error TEXT,
-    created_at INTEGER NOT NULL,
-    executed_at INTEGER,
-    run_id TEXT,
-    approver TEXT,
-    expires_at INTEGER,
-    remember INTEGER,
-    decided_via TEXT
-  )`,
-  `CREATE INDEX IF NOT EXISTS agent_tool_call_message_idx
-    ON agent_tool_call (message_id)`,
-  `CREATE TABLE IF NOT EXISTS agent_token_usage (
-    id TEXT PRIMARY KEY NOT NULL,
-    thread_id TEXT NOT NULL REFERENCES agent_thread(id) ON DELETE CASCADE,
-    actor_ref TEXT NOT NULL,
-    message_id TEXT,
-    model_id TEXT NOT NULL,
-    purpose TEXT NOT NULL,
-    input_tokens INTEGER NOT NULL,
-    output_tokens INTEGER NOT NULL,
-    cache_write_tokens INTEGER,
-    cache_read_tokens INTEGER,
-    cost_usd REAL,
-    created_at INTEGER NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS agent_token_usage_actor_created_idx
-    ON agent_token_usage (actor_ref, created_at)`,
-  `CREATE TABLE IF NOT EXISTS agent_model_pricing (
-    id TEXT PRIMARY KEY NOT NULL,
-    model_id TEXT NOT NULL,
-    input_price_per_1m REAL NOT NULL,
-    output_price_per_1m REAL NOT NULL,
-    cache_write_price_per_1m REAL,
-    cache_read_price_per_1m REAL,
-    effective_from INTEGER NOT NULL,
-    is_current INTEGER NOT NULL
-  )`,
-  `CREATE TABLE IF NOT EXISTS agent_run (
-    id TEXT PRIMARY KEY NOT NULL,
-    thread_id TEXT NOT NULL REFERENCES agent_thread(id) ON DELETE CASCADE,
-    actor_ref TEXT NOT NULL,
-    agent_name TEXT,
-    status TEXT NOT NULL,
-    duration_ms INTEGER,
-    error_code TEXT,
-    error_message TEXT,
-    retries INTEGER NOT NULL DEFAULT 0,
-    started_at INTEGER NOT NULL,
-    settled_at INTEGER,
-    prompt_hash TEXT,
-    parent_run_id TEXT
-  )`,
-  `CREATE INDEX IF NOT EXISTS agent_run_started_idx
-    ON agent_run (started_at)`,
-  // `key` and `text` are quoted: both are keywords in at least one engine this DDL is read by, and
-  // they are the SPI's own field names, which is worth more here than dodging the quoting.
-  `CREATE TABLE IF NOT EXISTS agent_memory (
-    id TEXT PRIMARY KEY NOT NULL,
-    scope TEXT NOT NULL,
-    "key" TEXT NOT NULL,
-    "text" TEXT NOT NULL,
-    origin_author TEXT NOT NULL,
-    origin_thread_id TEXT,
-    origin_run_id TEXT,
-    origin_actor_ref TEXT,
-    pinned INTEGER NOT NULL DEFAULT 0,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL
-  )`,
-  `CREATE UNIQUE INDEX IF NOT EXISTS agent_memory_scope_key_uq
-    ON agent_memory (scope, "key")`,
-  `CREATE TABLE IF NOT EXISTS rag_ingestion_log (
-    document_id TEXT PRIMARY KEY NOT NULL,
-    status TEXT NOT NULL,
-    collection TEXT,
-    owner_type TEXT,
-    owner_id TEXT,
-    source TEXT,
-    mime_type TEXT,
-    size INTEGER,
-    chunks INTEGER,
-    reason TEXT,
-    error TEXT,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS rag_ingestion_log_collection_idx
-    ON rag_ingestion_log (collection, updated_at)`,
-  `CREATE TABLE IF NOT EXISTS agent_stream_frame (
-    run_id TEXT NOT NULL,
-    seq INTEGER NOT NULL,
-    frame TEXT,
-    error TEXT,
-    created_at INTEGER NOT NULL,
-    PRIMARY KEY (run_id, seq)
-  )`,
-  `CREATE TABLE IF NOT EXISTS agent_confirm_token (
-    hash TEXT PRIMARY KEY NOT NULL,
-    actor_ref TEXT NOT NULL,
-    tool TEXT NOT NULL,
-    expires_at INTEGER NOT NULL,
-    created_at INTEGER NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS agent_confirm_token_expires_idx
-    ON agent_confirm_token (expires_at)`
-];
-var additiveColumns = [
-  {
-    table: "agent_message",
-    column: "run_id",
-    ddl: "ALTER TABLE agent_message ADD COLUMN run_id TEXT"
-  },
-  {
-    table: "agent_message",
-    column: "attachments",
-    ddl: "ALTER TABLE agent_message ADD COLUMN attachments TEXT"
-  },
-  {
-    table: "agent_thread",
-    column: "default_agent",
-    ddl: "ALTER TABLE agent_thread ADD COLUMN default_agent TEXT"
-  },
-  {
-    table: "agent_run",
-    column: "parent_run_id",
-    ddl: "ALTER TABLE agent_run ADD COLUMN parent_run_id TEXT"
-  },
-  {
-    table: "agent_message",
-    column: "reasoning",
-    ddl: "ALTER TABLE agent_message ADD COLUMN reasoning TEXT"
-  },
-  {
-    table: "agent_message",
-    column: "reasoning_ms",
-    ddl: "ALTER TABLE agent_message ADD COLUMN reasoning_ms INTEGER"
-  },
-  {
-    table: "agent_message",
-    column: "ui",
-    ddl: "ALTER TABLE agent_message ADD COLUMN ui TEXT"
-  },
-  {
-    table: "agent_message",
-    column: "feedback",
-    ddl: "ALTER TABLE agent_message ADD COLUMN feedback TEXT"
-  },
-  {
-    table: "agent_thread",
-    column: "model",
-    ddl: "ALTER TABLE agent_thread ADD COLUMN model TEXT"
-  },
-  {
-    table: "agent_tool_call",
-    column: "approver",
-    ddl: "ALTER TABLE agent_tool_call ADD COLUMN approver TEXT"
-  },
-  {
-    table: "agent_tool_call",
-    column: "expires_at",
-    ddl: "ALTER TABLE agent_tool_call ADD COLUMN expires_at INTEGER"
-  },
-  {
-    table: "agent_tool_call",
-    column: "remember",
-    ddl: "ALTER TABLE agent_tool_call ADD COLUMN remember INTEGER"
-  },
-  {
-    table: "agent_thread",
-    column: "queue_pause",
-    ddl: "ALTER TABLE agent_thread ADD COLUMN queue_pause TEXT"
-  },
-  {
-    table: "agent_tool_call",
-    column: "decided_via",
-    ddl: "ALTER TABLE agent_tool_call ADD COLUMN decided_via TEXT"
-  },
-  {
-    table: "agent_thread",
-    column: "persona",
-    ddl: "ALTER TABLE agent_thread ADD COLUMN persona TEXT"
-  },
-  {
-    table: "agent_message",
-    column: "persona",
-    ddl: "ALTER TABLE agent_message ADD COLUMN persona TEXT"
-  },
-  {
-    table: "agent_queued_message",
-    column: "persona",
-    ddl: "ALTER TABLE agent_queued_message ADD COLUMN persona TEXT"
+var import_mysql_core2 = require("drizzle-orm/mysql-core");
+var import_pg_core2 = require("drizzle-orm/pg-core");
+
+// src/schema-mysql.ts
+var import_mysql_core = require("drizzle-orm/mysql-core");
+var ts = /* @__PURE__ */ __name((name) => (0, import_mysql_core.datetime)(name, {
+  mode: "date",
+  fsp: 3
+}), "ts");
+var key = /* @__PURE__ */ __name((name) => (0, import_mysql_core.varchar)(name, {
+  length: 255
+}), "key");
+var agentThread2 = (0, import_mysql_core.mysqlTable)("agent_thread", {
+  id: key("id").primaryKey(),
+  actorRef: key("actor_ref").notNull(),
+  tenantRef: key("tenant_ref"),
+  title: key("title").notNull(),
+  transient: (0, import_mysql_core.boolean)("transient").notNull().default(false),
+  activeStreamId: key("active_stream_id"),
+  defaultAgent: key("default_agent"),
+  model: key("model"),
+  /** The persona a send on this thread runs under when it names none; `null` → the agent's default. */
+  persona: key("persona"),
+  queuePause: (0, import_mysql_core.json)("queue_pause").$type(),
+  createdAt: ts("created_at").notNull(),
+  updatedAt: ts("updated_at").notNull(),
+  deletedAt: ts("deleted_at")
+}, (table) => [
+  (0, import_mysql_core.index)("agent_thread_actor_updated_idx").on(table.actorRef, table.updatedAt)
+]);
+var agentMessage2 = (0, import_mysql_core.mysqlTable)("agent_message", {
+  id: key("id").primaryKey(),
+  threadId: key("thread_id").notNull().references(() => agentThread2.id, {
+    onDelete: "cascade"
+  }),
+  role: key("role").$type().notNull(),
+  content: (0, import_mysql_core.longtext)("content").notNull(),
+  toolCalls: (0, import_mysql_core.json)("tool_calls").$type(),
+  toolResults: (0, import_mysql_core.json)("tool_results").$type(),
+  attachments: (0, import_mysql_core.json)("attachments").$type(),
+  followUps: (0, import_mysql_core.json)("follow_ups").$type(),
+  usage: (0, import_mysql_core.json)("usage").$type(),
+  agentName: key("agent_name"),
+  /** The persona the turn that wrote this message ran under; `null` → none. */
+  persona: key("persona"),
+  runId: key("run_id"),
+  reasoning: (0, import_mysql_core.longtext)("reasoning"),
+  reasoningMs: (0, import_mysql_core.int)("reasoning_ms"),
+  ui: (0, import_mysql_core.json)("ui").$type(),
+  feedback: (0, import_mysql_core.json)("feedback").$type(),
+  seq: (0, import_mysql_core.int)("seq"),
+  createdAt: ts("created_at").notNull()
+}, (table) => [
+  (0, import_mysql_core.index)("agent_message_thread_created_idx").on(table.threadId, table.createdAt)
+]);
+var agentToolCall2 = (0, import_mysql_core.mysqlTable)("agent_tool_call", {
+  id: key("id").primaryKey(),
+  messageId: key("message_id").notNull().references(() => agentMessage2.id, {
+    onDelete: "cascade"
+  }),
+  toolName: key("tool_name").notNull(),
+  toolType: key("tool_type").$type().notNull(),
+  input: (0, import_mysql_core.json)("input"),
+  output: (0, import_mysql_core.json)("output"),
+  status: key("status").$type().notNull(),
+  executedByRef: key("executed_by_ref"),
+  executionMs: (0, import_mysql_core.int)("execution_ms"),
+  error: (0, import_mysql_core.longtext)("error"),
+  createdAt: ts("created_at").notNull(),
+  executedAt: ts("executed_at"),
+  runId: key("run_id"),
+  approver: key("approver"),
+  expiresAt: ts("expires_at"),
+  remember: (0, import_mysql_core.boolean)("remember"),
+  decidedVia: key("decided_via")
+}, (table) => [
+  (0, import_mysql_core.index)("agent_tool_call_message_idx").on(table.messageId)
+]);
+var agentQueuedMessage2 = (0, import_mysql_core.mysqlTable)("agent_queued_message", {
+  id: key("id").primaryKey(),
+  threadId: key("thread_id").notNull().references(() => agentThread2.id, {
+    onDelete: "cascade"
+  }),
+  actor: (0, import_mysql_core.json)("actor").$type().notNull(),
+  content: (0, import_mysql_core.longtext)("content").notNull(),
+  attachments: (0, import_mysql_core.json)("attachments").$type(),
+  agentName: key("agent_name"),
+  /** The persona the send resolved — what the message starts under. */
+  persona: key("persona"),
+  model: key("model"),
+  pageContext: (0, import_mysql_core.json)("page_context").$type(),
+  interrupt: (0, import_mysql_core.boolean)("interrupt").notNull().default(false),
+  position: (0, import_mysql_core.int)("position").notNull(),
+  createdAt: ts("created_at").notNull(),
+  updatedAt: ts("updated_at").notNull()
+}, (table) => [
+  (0, import_mysql_core.index)("agent_queued_message_thread_position_idx").on(table.threadId, table.position)
+]);
+var agentTokenUsage2 = (0, import_mysql_core.mysqlTable)("agent_token_usage", {
+  id: key("id").primaryKey(),
+  threadId: key("thread_id").notNull().references(() => agentThread2.id, {
+    onDelete: "cascade"
+  }),
+  actorRef: key("actor_ref").notNull(),
+  messageId: key("message_id"),
+  modelId: key("model_id").notNull(),
+  purpose: key("purpose").$type().notNull(),
+  inputTokens: (0, import_mysql_core.int)("input_tokens").notNull(),
+  outputTokens: (0, import_mysql_core.int)("output_tokens").notNull(),
+  cacheWriteTokens: (0, import_mysql_core.int)("cache_write_tokens"),
+  cacheReadTokens: (0, import_mysql_core.int)("cache_read_tokens"),
+  costUsd: (0, import_mysql_core.double)("cost_usd"),
+  createdAt: ts("created_at").notNull()
+}, (table) => [
+  (0, import_mysql_core.index)("agent_token_usage_actor_created_idx").on(table.actorRef, table.createdAt)
+]);
+var agentModelPricing2 = (0, import_mysql_core.mysqlTable)("agent_model_pricing", {
+  id: key("id").primaryKey(),
+  modelId: key("model_id").notNull(),
+  inputPricePer1m: (0, import_mysql_core.double)("input_price_per_1m").notNull(),
+  outputPricePer1m: (0, import_mysql_core.double)("output_price_per_1m").notNull(),
+  cacheWritePricePer1m: (0, import_mysql_core.double)("cache_write_price_per_1m"),
+  cacheReadPricePer1m: (0, import_mysql_core.double)("cache_read_price_per_1m"),
+  effectiveFrom: ts("effective_from").notNull(),
+  isCurrent: (0, import_mysql_core.boolean)("is_current").notNull()
+});
+var agentRun2 = (0, import_mysql_core.mysqlTable)("agent_run", {
+  id: key("id").primaryKey(),
+  threadId: key("thread_id").notNull().references(() => agentThread2.id, {
+    onDelete: "cascade"
+  }),
+  actorRef: key("actor_ref").notNull(),
+  agentName: key("agent_name"),
+  status: key("status").$type().notNull(),
+  durationMs: (0, import_mysql_core.int)("duration_ms"),
+  errorCode: key("error_code"),
+  errorMessage: (0, import_mysql_core.longtext)("error_message"),
+  retries: (0, import_mysql_core.int)("retries").notNull().default(0),
+  startedAt: ts("started_at").notNull(),
+  settledAt: ts("settled_at"),
+  promptHash: key("prompt_hash"),
+  parentRunId: key("parent_run_id")
+}, (table) => [
+  (0, import_mysql_core.index)("agent_run_started_idx").on(table.startedAt)
+]);
+var agentMemory2 = (0, import_mysql_core.mysqlTable)("agent_memory", {
+  id: key("id").primaryKey(),
+  scope: key("scope").notNull(),
+  key: key("key").notNull(),
+  text: (0, import_mysql_core.longtext)("text").notNull(),
+  originAuthor: key("origin_author").$type().notNull(),
+  originThreadId: key("origin_thread_id"),
+  originRunId: key("origin_run_id"),
+  originActorRef: key("origin_actor_ref"),
+  pinned: (0, import_mysql_core.boolean)("pinned").notNull().default(false),
+  createdAt: ts("created_at").notNull(),
+  updatedAt: ts("updated_at").notNull()
+}, (table) => [
+  (0, import_mysql_core.uniqueIndex)("agent_memory_scope_key_uq").on(table.scope, table.key)
+]);
+var ragIngestionLog2 = (0, import_mysql_core.mysqlTable)("rag_ingestion_log", {
+  documentId: key("document_id").primaryKey(),
+  status: key("status").$type().notNull(),
+  collection: key("collection"),
+  ownerType: key("owner_type"),
+  ownerId: key("owner_id"),
+  source: (0, import_mysql_core.longtext)("source"),
+  mimeType: key("mime_type"),
+  size: (0, import_mysql_core.bigint)("size", {
+    mode: "number"
+  }),
+  chunks: (0, import_mysql_core.int)("chunks"),
+  reason: key("reason"),
+  error: (0, import_mysql_core.longtext)("error"),
+  createdAt: ts("created_at").notNull(),
+  updatedAt: ts("updated_at").notNull()
+}, (table) => [
+  (0, import_mysql_core.index)("rag_ingestion_log_collection_idx").on(table.collection, table.updatedAt)
+]);
+var agentConfirmToken2 = (0, import_mysql_core.mysqlTable)("agent_confirm_token", {
+  hash: key("hash").primaryKey(),
+  actorRef: key("actor_ref").notNull(),
+  tool: key("tool").notNull(),
+  expiresAt: (0, import_mysql_core.bigint)("expires_at", {
+    mode: "number"
+  }).notNull(),
+  createdAt: (0, import_mysql_core.bigint)("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  (0, import_mysql_core.index)("agent_confirm_token_expires_idx").on(table.expiresAt)
+]);
+var agentStreamFrame2 = (0, import_mysql_core.mysqlTable)("agent_stream_frame", {
+  runId: key("run_id").notNull(),
+  seq: (0, import_mysql_core.int)("seq").notNull(),
+  frame: (0, import_mysql_core.longtext)("frame"),
+  error: (0, import_mysql_core.longtext)("error"),
+  createdAt: (0, import_mysql_core.bigint)("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  (0, import_mysql_core.primaryKey)({
+    columns: [
+      table.runId,
+      table.seq
+    ]
+  })
+]);
+var mysqlAgentSchema = {
+  agentThread: agentThread2,
+  agentMessage: agentMessage2,
+  agentQueuedMessage: agentQueuedMessage2,
+  agentToolCall: agentToolCall2,
+  agentTokenUsage: agentTokenUsage2,
+  agentModelPricing: agentModelPricing2,
+  agentRun: agentRun2,
+  agentMemory: agentMemory2,
+  ragIngestionLog: ragIngestionLog2,
+  agentConfirmToken: agentConfirmToken2,
+  agentStreamFrame: agentStreamFrame2
+};
+
+// src/schema-pg.ts
+var import_pg_core = require("drizzle-orm/pg-core");
+var ts2 = /* @__PURE__ */ __name((name) => (0, import_pg_core.timestamp)(name, {
+  withTimezone: true,
+  precision: 3,
+  mode: "date"
+}), "ts");
+var agentThread3 = (0, import_pg_core.pgTable)("agent_thread", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  actorRef: (0, import_pg_core.text)("actor_ref").notNull(),
+  tenantRef: (0, import_pg_core.text)("tenant_ref"),
+  title: (0, import_pg_core.text)("title").notNull(),
+  transient: (0, import_pg_core.boolean)("transient").notNull().default(false),
+  activeStreamId: (0, import_pg_core.text)("active_stream_id"),
+  defaultAgent: (0, import_pg_core.text)("default_agent"),
+  model: (0, import_pg_core.text)("model"),
+  /** The persona a send on this thread runs under when it names none; `null` → the agent's default. */
+  persona: (0, import_pg_core.text)("persona"),
+  queuePause: (0, import_pg_core.jsonb)("queue_pause").$type(),
+  createdAt: ts2("created_at").notNull(),
+  updatedAt: ts2("updated_at").notNull(),
+  deletedAt: ts2("deleted_at")
+}, (table) => [
+  (0, import_pg_core.index)("agent_thread_actor_updated_idx").on(table.actorRef, table.updatedAt)
+]);
+var agentMessage3 = (0, import_pg_core.pgTable)("agent_message", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  threadId: (0, import_pg_core.text)("thread_id").notNull().references(() => agentThread3.id, {
+    onDelete: "cascade"
+  }),
+  role: (0, import_pg_core.text)("role").$type().notNull(),
+  content: (0, import_pg_core.text)("content").notNull(),
+  toolCalls: (0, import_pg_core.jsonb)("tool_calls").$type(),
+  toolResults: (0, import_pg_core.jsonb)("tool_results").$type(),
+  attachments: (0, import_pg_core.jsonb)("attachments").$type(),
+  followUps: (0, import_pg_core.jsonb)("follow_ups").$type(),
+  usage: (0, import_pg_core.jsonb)("usage").$type(),
+  agentName: (0, import_pg_core.text)("agent_name"),
+  /** The persona the turn that wrote this message ran under; `null` → none. */
+  persona: (0, import_pg_core.text)("persona"),
+  runId: (0, import_pg_core.text)("run_id"),
+  reasoning: (0, import_pg_core.text)("reasoning"),
+  reasoningMs: (0, import_pg_core.integer)("reasoning_ms"),
+  ui: (0, import_pg_core.jsonb)("ui").$type(),
+  feedback: (0, import_pg_core.jsonb)("feedback").$type(),
+  seq: (0, import_pg_core.integer)("seq"),
+  createdAt: ts2("created_at").notNull()
+}, (table) => [
+  (0, import_pg_core.index)("agent_message_thread_created_idx").on(table.threadId, table.createdAt)
+]);
+var agentToolCall3 = (0, import_pg_core.pgTable)("agent_tool_call", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  messageId: (0, import_pg_core.text)("message_id").notNull().references(() => agentMessage3.id, {
+    onDelete: "cascade"
+  }),
+  toolName: (0, import_pg_core.text)("tool_name").notNull(),
+  toolType: (0, import_pg_core.text)("tool_type").$type().notNull(),
+  input: (0, import_pg_core.jsonb)("input"),
+  output: (0, import_pg_core.jsonb)("output"),
+  status: (0, import_pg_core.text)("status").$type().notNull(),
+  executedByRef: (0, import_pg_core.text)("executed_by_ref"),
+  executionMs: (0, import_pg_core.integer)("execution_ms"),
+  error: (0, import_pg_core.text)("error"),
+  createdAt: ts2("created_at").notNull(),
+  executedAt: ts2("executed_at"),
+  runId: (0, import_pg_core.text)("run_id"),
+  approver: (0, import_pg_core.text)("approver"),
+  expiresAt: ts2("expires_at"),
+  remember: (0, import_pg_core.boolean)("remember"),
+  decidedVia: (0, import_pg_core.text)("decided_via")
+}, (table) => [
+  (0, import_pg_core.index)("agent_tool_call_message_idx").on(table.messageId)
+]);
+var agentQueuedMessage3 = (0, import_pg_core.pgTable)("agent_queued_message", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  threadId: (0, import_pg_core.text)("thread_id").notNull().references(() => agentThread3.id, {
+    onDelete: "cascade"
+  }),
+  actor: (0, import_pg_core.jsonb)("actor").$type().notNull(),
+  content: (0, import_pg_core.text)("content").notNull(),
+  attachments: (0, import_pg_core.jsonb)("attachments").$type(),
+  agentName: (0, import_pg_core.text)("agent_name"),
+  /** The persona the send resolved — what the message starts under. */
+  persona: (0, import_pg_core.text)("persona"),
+  model: (0, import_pg_core.text)("model"),
+  pageContext: (0, import_pg_core.jsonb)("page_context").$type(),
+  interrupt: (0, import_pg_core.boolean)("interrupt").notNull().default(false),
+  position: (0, import_pg_core.integer)("position").notNull(),
+  createdAt: ts2("created_at").notNull(),
+  updatedAt: ts2("updated_at").notNull()
+}, (table) => [
+  (0, import_pg_core.index)("agent_queued_message_thread_position_idx").on(table.threadId, table.position)
+]);
+var agentTokenUsage3 = (0, import_pg_core.pgTable)("agent_token_usage", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  threadId: (0, import_pg_core.text)("thread_id").notNull().references(() => agentThread3.id, {
+    onDelete: "cascade"
+  }),
+  actorRef: (0, import_pg_core.text)("actor_ref").notNull(),
+  messageId: (0, import_pg_core.text)("message_id"),
+  modelId: (0, import_pg_core.text)("model_id").notNull(),
+  purpose: (0, import_pg_core.text)("purpose").$type().notNull(),
+  inputTokens: (0, import_pg_core.integer)("input_tokens").notNull(),
+  outputTokens: (0, import_pg_core.integer)("output_tokens").notNull(),
+  cacheWriteTokens: (0, import_pg_core.integer)("cache_write_tokens"),
+  cacheReadTokens: (0, import_pg_core.integer)("cache_read_tokens"),
+  costUsd: (0, import_pg_core.doublePrecision)("cost_usd"),
+  createdAt: ts2("created_at").notNull()
+}, (table) => [
+  (0, import_pg_core.index)("agent_token_usage_actor_created_idx").on(table.actorRef, table.createdAt)
+]);
+var agentModelPricing3 = (0, import_pg_core.pgTable)("agent_model_pricing", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  modelId: (0, import_pg_core.text)("model_id").notNull(),
+  inputPricePer1m: (0, import_pg_core.doublePrecision)("input_price_per_1m").notNull(),
+  outputPricePer1m: (0, import_pg_core.doublePrecision)("output_price_per_1m").notNull(),
+  cacheWritePricePer1m: (0, import_pg_core.doublePrecision)("cache_write_price_per_1m"),
+  cacheReadPricePer1m: (0, import_pg_core.doublePrecision)("cache_read_price_per_1m"),
+  effectiveFrom: ts2("effective_from").notNull(),
+  isCurrent: (0, import_pg_core.boolean)("is_current").notNull()
+});
+var agentRun3 = (0, import_pg_core.pgTable)("agent_run", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  threadId: (0, import_pg_core.text)("thread_id").notNull().references(() => agentThread3.id, {
+    onDelete: "cascade"
+  }),
+  actorRef: (0, import_pg_core.text)("actor_ref").notNull(),
+  agentName: (0, import_pg_core.text)("agent_name"),
+  status: (0, import_pg_core.text)("status").$type().notNull(),
+  durationMs: (0, import_pg_core.integer)("duration_ms"),
+  errorCode: (0, import_pg_core.text)("error_code"),
+  errorMessage: (0, import_pg_core.text)("error_message"),
+  retries: (0, import_pg_core.integer)("retries").notNull().default(0),
+  startedAt: ts2("started_at").notNull(),
+  settledAt: ts2("settled_at"),
+  promptHash: (0, import_pg_core.text)("prompt_hash"),
+  parentRunId: (0, import_pg_core.text)("parent_run_id")
+}, (table) => [
+  (0, import_pg_core.index)("agent_run_started_idx").on(table.startedAt)
+]);
+var agentMemory3 = (0, import_pg_core.pgTable)("agent_memory", {
+  id: (0, import_pg_core.text)("id").primaryKey(),
+  scope: (0, import_pg_core.text)("scope").notNull(),
+  key: (0, import_pg_core.text)("key").notNull(),
+  text: (0, import_pg_core.text)("text").notNull(),
+  originAuthor: (0, import_pg_core.text)("origin_author").$type().notNull(),
+  originThreadId: (0, import_pg_core.text)("origin_thread_id"),
+  originRunId: (0, import_pg_core.text)("origin_run_id"),
+  originActorRef: (0, import_pg_core.text)("origin_actor_ref"),
+  pinned: (0, import_pg_core.boolean)("pinned").notNull().default(false),
+  createdAt: ts2("created_at").notNull(),
+  updatedAt: ts2("updated_at").notNull()
+}, (table) => [
+  (0, import_pg_core.uniqueIndex)("agent_memory_scope_key_uq").on(table.scope, table.key)
+]);
+var ragIngestionLog3 = (0, import_pg_core.pgTable)("rag_ingestion_log", {
+  documentId: (0, import_pg_core.text)("document_id").primaryKey(),
+  status: (0, import_pg_core.text)("status").$type().notNull(),
+  collection: (0, import_pg_core.text)("collection"),
+  ownerType: (0, import_pg_core.text)("owner_type"),
+  ownerId: (0, import_pg_core.text)("owner_id"),
+  source: (0, import_pg_core.text)("source"),
+  mimeType: (0, import_pg_core.text)("mime_type"),
+  size: (0, import_pg_core.bigint)("size", {
+    mode: "number"
+  }),
+  chunks: (0, import_pg_core.integer)("chunks"),
+  reason: (0, import_pg_core.text)("reason"),
+  error: (0, import_pg_core.text)("error"),
+  createdAt: ts2("created_at").notNull(),
+  updatedAt: ts2("updated_at").notNull()
+}, (table) => [
+  (0, import_pg_core.index)("rag_ingestion_log_collection_idx").on(table.collection, table.updatedAt)
+]);
+var agentConfirmToken3 = (0, import_pg_core.pgTable)("agent_confirm_token", {
+  hash: (0, import_pg_core.text)("hash").primaryKey(),
+  actorRef: (0, import_pg_core.text)("actor_ref").notNull(),
+  tool: (0, import_pg_core.text)("tool").notNull(),
+  expiresAt: (0, import_pg_core.bigint)("expires_at", {
+    mode: "number"
+  }).notNull(),
+  createdAt: (0, import_pg_core.bigint)("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  (0, import_pg_core.index)("agent_confirm_token_expires_idx").on(table.expiresAt)
+]);
+var agentStreamFrame3 = (0, import_pg_core.pgTable)("agent_stream_frame", {
+  runId: (0, import_pg_core.text)("run_id").notNull(),
+  seq: (0, import_pg_core.integer)("seq").notNull(),
+  frame: (0, import_pg_core.text)("frame"),
+  error: (0, import_pg_core.text)("error"),
+  createdAt: (0, import_pg_core.bigint)("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  (0, import_pg_core.primaryKey)({
+    columns: [
+      table.runId,
+      table.seq
+    ]
+  })
+]);
+var pgAgentSchema = {
+  agentThread: agentThread3,
+  agentMessage: agentMessage3,
+  agentQueuedMessage: agentQueuedMessage3,
+  agentToolCall: agentToolCall3,
+  agentTokenUsage: agentTokenUsage3,
+  agentModelPricing: agentModelPricing3,
+  agentRun: agentRun3,
+  agentMemory: agentMemory3,
+  ragIngestionLog: ragIngestionLog3,
+  agentConfirmToken: agentConfirmToken3,
+  agentStreamFrame: agentStreamFrame3
+};
+
+// src/dialect.ts
+function agentDialectOf(db) {
+  if ((0, import_drizzle_orm.is)(db, import_pg_core2.PgDatabase)) return "postgres";
+  if ((0, import_drizzle_orm.is)(db, import_mysql_core2.MySqlDatabase)) return "mysql";
+  return "sqlite";
+}
+__name(agentDialectOf, "agentDialectOf");
+function agentTablesFor(dialect) {
+  if (dialect === "postgres") return pgAgentSchema;
+  if (dialect === "mysql") return mysqlAgentSchema;
+  return agentSchema;
+}
+__name(agentTablesFor, "agentTablesFor");
+function asBuilder(db) {
+  return db;
+}
+__name(asBuilder, "asBuilder");
+async function affectedRows(dialect, statement, column) {
+  if (dialect !== "mysql") {
+    return (await statement.returning({
+      affected: column
+    })).length;
+  }
+  return mysqlAffectedRows(await statement);
+}
+__name(affectedRows, "affectedRows");
+function mysqlAffectedRows(result) {
+  const header = Array.isArray(result) ? result[0] : result;
+  const counts = header;
+  const count3 = counts?.affectedRows ?? counts?.rowsAffected;
+  return typeof count3 === "number" ? count3 : 0;
+}
+__name(mysqlAffectedRows, "mysqlAffectedRows");
+async function runSql(db, dialect, statement) {
+  if (dialect === "sqlite") {
+    await db.run(statement);
+    return;
   }
-];
-async function ensureAgentSchema(db) {
-  for (const statement of statements) {
-    await db.run(import_drizzle_orm.sql.raw(statement));
+  if (dialect === "postgres") {
+    await db.execute(statement);
+    return;
+  }
+  await db.execute(statement);
+}
+__name(runSql, "runSql");
+async function querySql(db, dialect, statement) {
+  if (dialect === "sqlite") {
+    return db.all(statement);
   }
-  for (const { table, column, ddl } of additiveColumns) {
-    const existing = await db.all(import_drizzle_orm.sql.raw(`PRAGMA table_info(${table})`));
-    if (!existing.some((row) => row.name === column)) {
-      await db.run(import_drizzle_orm.sql.raw(ddl));
+  const result = dialect === "postgres" ? await db.execute(statement) : await db.execute(statement);
+  if (dialect === "mysql") {
+    return Array.isArray(result) ? result[0] : [];
+  }
+  return Array.isArray(result) ? result : result.rows ?? [];
+}
+__name(querySql, "querySql");
+function isUniqueViolation(error) {
+  for (let current = error; current !== null && typeof current === "object"; ) {
+    const { code, errno } = current;
+    if (code === "23505" || code === "ER_DUP_ENTRY" || errno === 1062 || code === "ER_LOCK_DEADLOCK" || errno === 1213 || typeof code === "string" && code.startsWith("SQLITE_CONSTRAINT")) {
+      return true;
     }
+    current = current.cause;
+  }
+  return false;
+}
+__name(isUniqueViolation, "isUniqueViolation");
+function upsert(dialect, insert, target, set) {
+  if (dialect === "mysql") {
+    return insert.onDuplicateKeyUpdate({
+      set
+    });
+  }
+  return insert.onConflictDoUpdate({
+    target,
+    set
+  });
+}
+__name(upsert, "upsert");
+
+// src/ensure-schema.ts
+async function ensureAgentSchema(db) {
+  const dialect = agentDialectOf(db);
+  if (dialect === "postgres") {
+    await db.transaction(async (tx) => {
+      await tx.execute(import_drizzle_orm2.sql.raw(`select pg_advisory_xact_lock(hashtext('${LOCK_NAME}'))`));
+      await heal(tx, dialect);
+    });
+    return;
+  }
+  if (dialect === "mysql") {
+    await db.transaction(async (tx) => {
+      await tx.execute(import_drizzle_orm2.sql.raw(`select get_lock('${LOCK_NAME}', 30)`));
+      try {
+        await heal(tx, dialect);
+      } finally {
+        await tx.execute(import_drizzle_orm2.sql.raw(`select release_lock('${LOCK_NAME}')`));
+      }
+    });
+    return;
   }
+  await heal(db, dialect);
 }
 __name(ensureAgentSchema, "ensureAgentSchema");
+var LOCK_NAME = "nestjs_agent_schema";
+var MYSQL_TABLE_OPTIONS = "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin";
+function tableSpec(dialect, table) {
+  const config = dialect === "postgres" ? (0, import_pg_core3.getTableConfig)(table) : dialect === "mysql" ? (0, import_mysql_core3.getTableConfig)(table) : (0, import_sqlite_core2.getTableConfig)(table);
+  const columns = config.columns;
+  const compositeKey = config.primaryKeys[0]?.columns.map((column) => column.name);
+  return {
+    name: config.name,
+    columns,
+    primaryKey: compositeKey ?? columns.filter((column) => column.primary).map((c) => c.name),
+    foreignKeys: config.foreignKeys.map((foreignKey) => {
+      const reference = foreignKey.reference();
+      return {
+        columns: reference.columns.map((column) => column.name),
+        table: (0, import_drizzle_orm2.getTableName)(reference.foreignTable),
+        foreignColumns: reference.foreignColumns.map((column) => column.name),
+        ...foreignKey.onDelete !== void 0 ? {
+          onDelete: foreignKey.onDelete
+        } : {}
+      };
+    }),
+    indexes: config.indexes.map((index4) => ({
+      name: String(index4.config.name),
+      unique: index4.config.unique === true,
+      columns: index4.config.columns.map((column) => String(column.name))
+    }))
+  };
+}
+__name(tableSpec, "tableSpec");
+function quote(dialect, identifier) {
+  return dialect === "mysql" ? `\`${identifier}\`` : `"${identifier}"`;
+}
+__name(quote, "quote");
+function literal(dialect, value) {
+  if (typeof value === "boolean") {
+    return dialect === "sqlite" ? value ? "1" : "0" : value ? "true" : "false";
+  }
+  if (typeof value === "number") return String(value);
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+__name(literal, "literal");
+function columnDefinition(dialect, column) {
+  const parts = [
+    quote(dialect, column.name),
+    column.getSQLType()
+  ];
+  if (column.notNull) parts.push("NOT NULL");
+  if (column.hasDefault && column.default !== void 0) {
+    parts.push(`DEFAULT ${literal(dialect, column.default)}`);
+  }
+  return parts.join(" ");
+}
+__name(columnDefinition, "columnDefinition");
+function createTableSql(dialect, spec) {
+  const q = /* @__PURE__ */ __name((identifier) => quote(dialect, identifier), "q");
+  const lines = spec.columns.map((column) => columnDefinition(dialect, column));
+  lines.push(`PRIMARY KEY (${spec.primaryKey.map(q).join(", ")})`);
+  for (const foreignKey of spec.foreignKeys) {
+    lines.push(`FOREIGN KEY (${foreignKey.columns.map(q).join(", ")}) REFERENCES ${q(foreignKey.table)} (${foreignKey.foreignColumns.map(q).join(", ")})${foreignKey.onDelete !== void 0 ? ` ON DELETE ${foreignKey.onDelete.toUpperCase()}` : ""}`);
+  }
+  const options = dialect === "mysql" ? ` ${MYSQL_TABLE_OPTIONS}` : "";
+  return `CREATE TABLE IF NOT EXISTS ${q(spec.name)} (
+  ${lines.join(",\n  ")}
+)${options}`;
+}
+__name(createTableSql, "createTableSql");
+function agentSchemaDdl(dialect) {
+  const statements = [];
+  for (const spec of specs(dialect)) {
+    statements.push(createTableSql(dialect, spec));
+    for (const index4 of spec.indexes) {
+      statements.push(createIndexSql(dialect, spec.name, index4));
+    }
+  }
+  return statements;
+}
+__name(agentSchemaDdl, "agentSchemaDdl");
+function createIndexSql(dialect, table, index4) {
+  const q = /* @__PURE__ */ __name((identifier) => quote(dialect, identifier), "q");
+  const guard = dialect === "mysql" ? "" : "IF NOT EXISTS ";
+  return `CREATE ${index4.unique ? "UNIQUE " : ""}INDEX ${guard}${q(index4.name)} ON ${q(table)} (${index4.columns.map(q).join(", ")})`;
+}
+__name(createIndexSql, "createIndexSql");
+function specs(dialect) {
+  const all = Object.values(agentTablesFor(dialect)).map((table) => tableSpec(dialect, table));
+  const ordered = [];
+  const placed = /* @__PURE__ */ new Set();
+  while (ordered.length < all.length) {
+    const ready = all.filter((spec) => !placed.has(spec.name) && spec.foreignKeys.every((key2) => key2.table === spec.name || placed.has(key2.table)));
+    if (ready.length === 0) throw new Error("agent schema: circular foreign keys");
+    for (const spec of ready) {
+      ordered.push(spec);
+      placed.add(spec.name);
+    }
+  }
+  return ordered;
+}
+__name(specs, "specs");
+async function existingColumns(db, dialect, table) {
+  const rows = dialect === "sqlite" ? await querySql(db, dialect, import_drizzle_orm2.sql.raw(`PRAGMA table_info("${table}")`)) : await querySql(db, dialect, import_drizzle_orm2.sql`select column_name as name from information_schema.columns where table_schema = ${import_drizzle_orm2.sql.raw(dialect === "mysql" ? "database()" : "current_schema()")} and table_name = ${table}`);
+  return new Set(rows.map((row) => String(row.name)));
+}
+__name(existingColumns, "existingColumns");
+async function indexExists(db, dialect, table, index4) {
+  let query;
+  if (dialect === "sqlite") {
+    query = import_drizzle_orm2.sql`select name from sqlite_master where type = 'index' and name = ${index4}`;
+  } else if (dialect === "postgres") {
+    query = import_drizzle_orm2.sql`select indexname as name from pg_indexes where schemaname = current_schema() and indexname = ${index4}`;
+  } else {
+    query = import_drizzle_orm2.sql`select index_name as name from information_schema.statistics where table_schema = database() and table_name = ${table} and index_name = ${index4}`;
+  }
+  return (await querySql(db, dialect, query)).length > 0;
+}
+__name(indexExists, "indexExists");
+async function heal(db, dialect) {
+  for (const spec of specs(dialect)) {
+    await runSql(db, dialect, import_drizzle_orm2.sql.raw(createTableSql(dialect, spec)));
+    const present = await existingColumns(db, dialect, spec.name);
+    for (const column of spec.columns) {
+      if (!present.has(column.name)) {
+        await runSql(db, dialect, import_drizzle_orm2.sql.raw(`ALTER TABLE ${quote(dialect, spec.name)} ADD COLUMN ${columnDefinition(dialect, column)}`));
+      }
+    }
+    for (const index4 of spec.indexes) {
+      if (!await indexExists(db, dialect, spec.name, index4.name)) {
+        await runSql(db, dialect, import_drizzle_orm2.sql.raw(createIndexSql(dialect, spec.name, index4)));
+      }
+    }
+  }
+}
+__name(heal, "heal");
 
 // src/drizzle-agent-store.ts
 var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
-var import_drizzle_orm2 = require("drizzle-orm");
-var TURN_MESSAGE_COLUMNS = {
-  id: agentMessage.id,
-  role: agentMessage.role,
-  content: agentMessage.content,
-  agentName: agentMessage.agentName,
-  toolCalls: agentMessage.toolCalls,
-  toolResults: agentMessage.toolResults,
-  attachments: agentMessage.attachments,
-  createdAt: agentMessage.createdAt
-};
+var import_drizzle_orm3 = require("drizzle-orm");
+function turnMessageColumns(message) {
+  return {
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    agentName: message.agentName,
+    toolCalls: message.toolCalls,
+    toolResults: message.toolResults,
+    attachments: message.attachments,
+    createdAt: message.createdAt
+  };
+}
+__name(turnMessageColumns, "turnMessageColumns");
 var DrizzleAgentStore = class {
   static {
     __name(this, "DrizzleAgentStore");
   }
   db;
+  dialect;
+  t;
   constructor(db) {
-    this.db = db;
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
   }
   async createThread(input) {
     const now = /* @__PURE__ */ new Date();
@@ -666,15 +1094,15 @@ var DrizzleAgentStore = class {
       updatedAt: now,
       deletedAt: null
     };
-    await this.db.insert(agentThread).values(thread);
+    await this.db.insert(this.t.agentThread).values(thread);
     return this.toSummary(thread);
   }
   async getThread(threadId) {
-    const [thread] = await this.db.select().from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+    const [thread] = await this.db.select().from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     if (thread === void 0) {
       return null;
     }
-    const messages = await this.db.select().from(agentMessage).where((0, import_drizzle_orm2.eq)(agentMessage.threadId, threadId)).orderBy((0, import_drizzle_orm2.asc)(agentMessage.createdAt), (0, import_drizzle_orm2.asc)(agentMessage.id));
+    const messages = await this.db.select().from(this.t.agentMessage).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, threadId)).orderBy(...this.messageOrder());
     const last = messages[messages.length - 1];
     const approvals = await this.approvalsFor(messages.map((message) => message.id));
     return {
@@ -707,16 +1135,16 @@ var DrizzleAgentStore = class {
   */
   async loadThreadForTurn(query) {
     const [thread] = await this.db.select({
-      title: agentThread.title,
-      defaultAgent: agentThread.defaultAgent
-    }).from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, query.threadId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+      title: this.t.agentThread.title,
+      defaultAgent: this.t.agentThread.defaultAgent
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, query.threadId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     if (thread === void 0) {
       return null;
     }
     const messages = await this.loadTurnWindow(query.threadId, query.messageLimit);
     const [answered] = await this.db.select({
-      id: agentMessage.id
-    }).from(agentMessage).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentMessage.threadId, query.threadId), (0, import_drizzle_orm2.eq)(agentMessage.role, "assistant"))).limit(1);
+      id: this.t.agentMessage.id
+    }).from(this.t.agentMessage).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, query.threadId), (0, import_drizzle_orm3.eq)(this.t.agentMessage.role, "assistant"))).limit(1);
     return {
       title: thread.title,
       defaultAgent: thread.defaultAgent,
@@ -732,30 +1160,30 @@ var DrizzleAgentStore = class {
     if (limit !== void 0 && limit <= 0) {
       return [];
     }
-    const window = this.db.select(TURN_MESSAGE_COLUMNS).from(agentMessage).where((0, import_drizzle_orm2.eq)(agentMessage.threadId, threadId)).orderBy((0, import_drizzle_orm2.desc)(agentMessage.createdAt), (0, import_drizzle_orm2.desc)(agentMessage.id));
+    const window = this.db.select(turnMessageColumns(this.t.agentMessage)).from(this.t.agentMessage).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, threadId)).orderBy(...this.messageOrderNewestFirst());
     const rows = limit === void 0 ? await window : await window.limit(limit);
     return rows.reverse().map((row) => this.toStoredMessage(row));
   }
   async listThreads(actorRef, limit = 50) {
-    const threads = await this.db.select().from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.actorRef, actorRef), (0, import_drizzle_orm2.eq)(agentThread.transient, false), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt))).orderBy((0, import_drizzle_orm2.desc)(agentThread.updatedAt)).limit(limit);
+    const threads = await this.db.select().from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.actorRef, actorRef), (0, import_drizzle_orm3.eq)(this.t.agentThread.transient, false), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt))).orderBy((0, import_drizzle_orm3.desc)(this.t.agentThread.updatedAt)).limit(limit);
     const summaries = [];
     for (const thread of threads) {
-      const [last] = await this.db.select().from(agentMessage).where((0, import_drizzle_orm2.eq)(agentMessage.threadId, thread.id)).orderBy((0, import_drizzle_orm2.desc)(agentMessage.createdAt), (0, import_drizzle_orm2.desc)(agentMessage.id)).limit(1);
+      const [last] = await this.db.select().from(this.t.agentMessage).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, thread.id)).orderBy(...this.messageOrderNewestFirst()).limit(1);
       summaries.push(this.toSummary(thread, last?.content));
     }
     return summaries;
   }
   async softDeleteThread(threadId) {
-    await this.db.update(agentThread).set({
+    await this.db.update(this.t.agentThread).set({
       deletedAt: /* @__PURE__ */ new Date()
-    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
   }
   async forkThread(threadId, fromMessageId) {
-    const [source] = await this.db.select().from(agentThread).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+    const [source] = await this.db.select().from(this.t.agentThread).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
     if (source === void 0) {
       throw new Error(`thread ${threadId} not found`);
     }
-    const messages = await this.db.select().from(agentMessage).where((0, import_drizzle_orm2.eq)(agentMessage.threadId, threadId)).orderBy((0, import_drizzle_orm2.asc)(agentMessage.createdAt), (0, import_drizzle_orm2.asc)(agentMessage.id));
+    const messages = await this.db.select().from(this.t.agentMessage).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, threadId)).orderBy(...this.messageOrder());
     const cutoff = messages.findIndex((message) => message.id === fromMessageId);
     const kept = cutoff >= 0 ? messages.slice(0, cutoff + 1) : messages;
     const now = /* @__PURE__ */ new Date();
@@ -775,10 +1203,12 @@ var DrizzleAgentStore = class {
       updatedAt: now,
       deletedAt: null
     };
-    await this.db.insert(agentThread).values(fork);
+    await this.db.insert(this.t.agentThread).values(fork);
     if (kept.length > 0) {
-      await this.db.insert(agentMessage).values(kept.map((message) => ({
+      await this.db.insert(this.t.agentMessage).values(kept.map((message, index4) => ({
         id: crypto.randomUUID(),
+        // Numbered afresh in the order just read, so the copy reads back in the original's order.
+        seq: index4 + 1,
         threadId: fork.id,
         role: message.role,
         content: message.content,
@@ -803,21 +1233,21 @@ var DrizzleAgentStore = class {
   }
   async ownerOfThread(threadId) {
     const [thread] = await this.db.select({
-      actorRef: agentThread.actorRef
-    }).from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+      actorRef: this.t.agentThread.actorRef
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     return thread?.actorRef ?? null;
   }
   async ownerOfToolCall(toolCallId) {
     const [row] = await this.db.select({
-      actorRef: agentThread.actorRef
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm2.eq)(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, (0, import_drizzle_orm2.eq)(agentMessage.threadId, agentThread.id)).where((0, import_drizzle_orm2.eq)(agentToolCall.id, toolCallId));
+      actorRef: this.t.agentThread.actorRef
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm3.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).innerJoin(this.t.agentThread, (0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, this.t.agentThread.id)).where((0, import_drizzle_orm3.eq)(this.t.agentToolCall.id, toolCallId));
     return row?.actorRef ?? null;
   }
   async runForToolCall(toolCallId) {
     const [row] = await this.db.select({
-      runId: agentToolCall.runId,
-      activeStreamId: agentThread.activeStreamId
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm2.eq)(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, (0, import_drizzle_orm2.eq)(agentMessage.threadId, agentThread.id)).where((0, import_drizzle_orm2.eq)(agentToolCall.id, toolCallId));
+      runId: this.t.agentToolCall.runId,
+      activeStreamId: this.t.agentThread.activeStreamId
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm3.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).innerJoin(this.t.agentThread, (0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, this.t.agentThread.id)).where((0, import_drizzle_orm3.eq)(this.t.agentToolCall.id, toolCallId));
     return row?.runId ?? row?.activeStreamId ?? null;
   }
   /**
@@ -831,16 +1261,16 @@ var DrizzleAgentStore = class {
       return byMessage;
     }
     const rows = await this.db.select({
-      id: agentToolCall.id,
-      messageId: agentToolCall.messageId,
-      status: agentToolCall.status,
-      approver: agentToolCall.approver,
-      expiresAt: agentToolCall.expiresAt,
-      remember: agentToolCall.remember,
-      executedByRef: agentToolCall.executedByRef,
-      decidedVia: agentToolCall.decidedVia,
-      error: agentToolCall.error
-    }).from(agentToolCall).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.inArray)(agentToolCall.messageId, messageIds), (0, import_drizzle_orm2.isNotNull)(agentToolCall.approver))).orderBy((0, import_drizzle_orm2.asc)(agentToolCall.createdAt), (0, import_drizzle_orm2.asc)(agentToolCall.id));
+      id: this.t.agentToolCall.id,
+      messageId: this.t.agentToolCall.messageId,
+      status: this.t.agentToolCall.status,
+      approver: this.t.agentToolCall.approver,
+      expiresAt: this.t.agentToolCall.expiresAt,
+      remember: this.t.agentToolCall.remember,
+      executedByRef: this.t.agentToolCall.executedByRef,
+      decidedVia: this.t.agentToolCall.decidedVia,
+      error: this.t.agentToolCall.error
+    }).from(this.t.agentToolCall).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.inArray)(this.t.agentToolCall.messageId, messageIds), (0, import_drizzle_orm3.isNotNull)(this.t.agentToolCall.approver))).orderBy((0, import_drizzle_orm3.asc)(this.t.agentToolCall.createdAt), (0, import_drizzle_orm3.asc)(this.t.agentToolCall.id));
     for (const row of rows) {
       const approval = (0, import_nestjs_agent_core.toolCallApprovalFromRow)({
         ...row,
@@ -858,22 +1288,22 @@ var DrizzleAgentStore = class {
   /** Tools whose approval someone asked to remember in this thread. */
   async rememberedApprovals(threadId) {
     const rows = await this.db.selectDistinct({
-      toolName: agentToolCall.toolName
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm2.eq)(agentToolCall.messageId, agentMessage.id)).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentMessage.threadId, threadId), (0, import_drizzle_orm2.eq)(agentToolCall.remember, true)));
+      toolName: this.t.agentToolCall.toolName
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm3.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, threadId), (0, import_drizzle_orm3.eq)(this.t.agentToolCall.remember, true)));
     return rows.map((row) => row.toolName);
   }
   async toolCallInput(toolCallId) {
     const [row] = await this.db.select({
-      input: agentToolCall.input
-    }).from(agentToolCall).where((0, import_drizzle_orm2.eq)(agentToolCall.id, toolCallId));
+      input: this.t.agentToolCall.input
+    }).from(this.t.agentToolCall).where((0, import_drizzle_orm3.eq)(this.t.agentToolCall.id, toolCallId));
     return row?.input ?? null;
   }
   async toolCallApproval(toolCallId) {
     const [row] = await this.db.select({
-      status: agentToolCall.status,
-      approver: agentToolCall.approver,
-      expiresAt: agentToolCall.expiresAt
-    }).from(agentToolCall).where((0, import_drizzle_orm2.eq)(agentToolCall.id, toolCallId));
+      status: this.t.agentToolCall.status,
+      approver: this.t.agentToolCall.approver,
+      expiresAt: this.t.agentToolCall.expiresAt
+    }).from(this.t.agentToolCall).where((0, import_drizzle_orm3.eq)(this.t.agentToolCall.id, toolCallId));
     if (row === void 0) {
       return null;
     }
@@ -885,27 +1315,67 @@ var DrizzleAgentStore = class {
   }
   async ownerOfActiveStream(runId) {
     const [thread] = await this.db.select({
-      actorRef: agentThread.actorRef
-    }).from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.activeStreamId, runId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+      actorRef: this.t.agentThread.actorRef
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.activeStreamId, runId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     return thread?.actorRef ?? null;
   }
   async setTitle(threadId, title) {
-    await this.db.update(agentThread).set({
+    await this.db.update(this.t.agentThread).set({
       title,
       updatedAt: /* @__PURE__ */ new Date()
-    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
   }
   async promoteThread(threadId) {
-    await this.db.update(agentThread).set({
+    await this.db.update(this.t.agentThread).set({
       transient: false,
       updatedAt: /* @__PURE__ */ new Date()
-    }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.eq)(agentThread.transient, true)));
+    }).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.eq)(this.t.agentThread.transient, true)));
+  }
+  /** Who holds the thread's stream right now, deleted or not. */
+  async activeHolder(threadId) {
+    const [thread] = await this.db.select({
+      activeStreamId: this.t.agentThread.activeStreamId
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
+    return thread?.activeStreamId ?? null;
+  }
+  /**
+  * A thread's messages in the order they were appended: by `seq`, which append assigns. A row from
+  * before `seq` existed has none and counts as 0 — first, since every such row is older than every
+  * numbered one — and those order among themselves by `created_at`, then `id`, as they always did.
+  * `coalesce` rather than `nulls first`, which MySQL cannot spell and Postgres defaults the other way.
+  */
+  messageOrder() {
+    const message = this.t.agentMessage;
+    return [
+      (0, import_drizzle_orm3.asc)(import_drizzle_orm3.sql`coalesce(${message.seq}, 0)`),
+      (0, import_drizzle_orm3.asc)(message.createdAt),
+      (0, import_drizzle_orm3.asc)(message.id)
+    ];
+  }
+  /** {@link messageOrder}, newest first. */
+  messageOrderNewestFirst() {
+    const message = this.t.agentMessage;
+    return [
+      (0, import_drizzle_orm3.desc)(import_drizzle_orm3.sql`coalesce(${message.seq}, 0)`),
+      (0, import_drizzle_orm3.desc)(message.createdAt),
+      (0, import_drizzle_orm3.desc)(message.id)
+    ];
+  }
+  /**
+  * The next `seq` in a thread: one past its highest. Two appends racing on ONE thread can draw the
+  * same number — the turn loop never does that, and the tie then falls back to `created_at`, `id`.
+  */
+  async nextMessageSeq(threadId) {
+    const [row] = await this.db.select({
+      last: (0, import_drizzle_orm3.max)(this.t.agentMessage.seq)
+    }).from(this.t.agentMessage).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, threadId));
+    return Number(row?.last ?? 0) + 1;
   }
   /** The run streaming the thread, or `null` — a projection of the one column. */
   async activeRunForThread(threadId) {
     const [thread] = await this.db.select({
-      activeStreamId: agentThread.activeStreamId
-    }).from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+      activeStreamId: this.t.agentThread.activeStreamId
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     return thread?.activeStreamId ?? null;
   }
   /**
@@ -914,33 +1384,32 @@ var DrizzleAgentStore = class {
   */
   async claimActiveStream(threadId, runId, options = {}) {
     const holders = [
-      (0, import_drizzle_orm2.isNull)(agentThread.activeStreamId),
-      (0, import_drizzle_orm2.eq)(agentThread.activeStreamId, runId),
+      (0, import_drizzle_orm3.isNull)(this.t.agentThread.activeStreamId),
+      (0, import_drizzle_orm3.eq)(this.t.agentThread.activeStreamId, runId),
       ...options.replacing !== void 0 ? [
-        (0, import_drizzle_orm2.eq)(agentThread.activeStreamId, options.replacing)
+        (0, import_drizzle_orm3.eq)(this.t.agentThread.activeStreamId, options.replacing)
       ] : []
     ];
-    const claimed = await this.db.update(agentThread).set({
+    const claimed = await affectedRows(this.dialect, this.db.update(this.t.agentThread).set({
       activeStreamId: runId
-    }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.or)(...holders))).returning({
-      id: agentThread.id
-    });
-    return claimed.length > 0;
+    }).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.or)(...holders))), this.t.agentThread.id);
+    if (claimed > 0) {
+      return true;
+    }
+    return await this.activeHolder(threadId) === runId;
   }
   async releaseActiveStream(threadId, runId) {
-    const released = await this.db.update(agentThread).set({
+    const released = await affectedRows(this.dialect, this.db.update(this.t.agentThread).set({
       activeStreamId: null
-    }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.eq)(agentThread.activeStreamId, runId))).returning({
-      id: agentThread.id
-    });
-    return released.length > 0;
+    }).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.eq)(this.t.agentThread.activeStreamId, runId))), this.t.agentThread.id);
+    return released > 0;
   }
   async enqueueMessage(input) {
     const now = /* @__PURE__ */ new Date();
     const [edge] = await this.db.select({
-      first: (0, import_drizzle_orm2.min)(agentQueuedMessage.position),
-      last: (0, import_drizzle_orm2.max)(agentQueuedMessage.position)
-    }).from(agentQueuedMessage).where((0, import_drizzle_orm2.eq)(agentQueuedMessage.threadId, input.threadId));
+      first: (0, import_drizzle_orm3.min)(this.t.agentQueuedMessage.position),
+      last: (0, import_drizzle_orm3.max)(this.t.agentQueuedMessage.position)
+    }).from(this.t.agentQueuedMessage).where((0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.threadId, input.threadId));
     const position = input.at === "head" ? (edge?.first ?? 1) - 1 : (edge?.last ?? -1) + 1;
     const row = {
       id: crypto.randomUUID(),
@@ -957,15 +1426,15 @@ var DrizzleAgentStore = class {
       createdAt: now,
       updatedAt: now
     };
-    await this.db.insert(agentQueuedMessage).values(row);
+    await this.db.insert(this.t.agentQueuedMessage).values(row);
     return toQueuedMessage(row);
   }
   async listQueue(threadId) {
-    const rows = await this.db.select().from(agentQueuedMessage).where((0, import_drizzle_orm2.eq)(agentQueuedMessage.threadId, threadId)).orderBy((0, import_drizzle_orm2.asc)(agentQueuedMessage.position), (0, import_drizzle_orm2.asc)(agentQueuedMessage.createdAt));
+    const rows = await this.db.select().from(this.t.agentQueuedMessage).where((0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.threadId, threadId)).orderBy((0, import_drizzle_orm3.asc)(this.t.agentQueuedMessage.position), (0, import_drizzle_orm3.asc)(this.t.agentQueuedMessage.createdAt));
     return rows.map(toQueuedMessage);
   }
   async getQueuedMessage(id) {
-    const [row] = await this.db.select().from(agentQueuedMessage).where((0, import_drizzle_orm2.eq)(agentQueuedMessage.id, id));
+    const [row] = await this.db.select().from(this.t.agentQueuedMessage).where((0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.id, id));
     return row === void 0 ? null : toQueuedMessage(row);
   }
   async updateQueuedMessage(id, patch) {
@@ -981,52 +1450,47 @@ var DrizzleAgentStore = class {
     if (patch.interrupt !== void 0) {
       updates.interrupt = patch.interrupt;
     }
-    await this.db.update(agentQueuedMessage).set(updates).where((0, import_drizzle_orm2.eq)(agentQueuedMessage.id, id));
+    await this.db.update(this.t.agentQueuedMessage).set(updates).where((0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.id, id));
     return this.getQueuedMessage(id);
   }
   /** Rewrites the thread's positions as 0..n-1 in the new order — a queue is a handful of rows. */
-  async moveQueuedMessage(id, index2) {
+  async moveQueuedMessage(id, index4) {
     const moving = await this.getQueuedMessage(id);
     if (moving === null) {
       return false;
     }
     const order = (await this.listQueue(moving.threadId)).filter((message) => message.id !== id);
-    const target = Math.max(0, Math.min(order.length, Math.trunc(index2)));
+    const target = Math.max(0, Math.min(order.length, Math.trunc(index4)));
     order.splice(target, 0, moving);
     for (const [position, message] of order.entries()) {
-      await this.db.update(agentQueuedMessage).set({
+      await this.db.update(this.t.agentQueuedMessage).set({
         position
-      }).where((0, import_drizzle_orm2.eq)(agentQueuedMessage.id, message.id));
+      }).where((0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.id, message.id));
     }
     return true;
   }
   async removeQueuedMessage(id) {
-    const removed = await this.db.delete(agentQueuedMessage).where((0, import_drizzle_orm2.eq)(agentQueuedMessage.id, id)).returning({
-      id: agentQueuedMessage.id
-    });
-    return removed.length > 0;
+    const removed = await affectedRows(this.dialect, this.db.delete(this.t.agentQueuedMessage).where((0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.id, id)), this.t.agentQueuedMessage.id);
+    return removed > 0;
   }
   async clearQueue(threadId) {
-    const removed = await this.db.delete(agentQueuedMessage).where((0, import_drizzle_orm2.eq)(agentQueuedMessage.threadId, threadId)).returning({
-      id: agentQueuedMessage.id
-    });
-    return removed.length;
+    return affectedRows(this.dialect, this.db.delete(this.t.agentQueuedMessage).where((0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.threadId, threadId)), this.t.agentQueuedMessage.id);
   }
   async queuePause(threadId) {
     const [thread] = await this.db.select({
-      queuePause: agentThread.queuePause
-    }).from(agentThread).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+      queuePause: this.t.agentThread.queuePause
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
     return thread?.queuePause ?? null;
   }
   async setQueuePause(threadId, pause) {
-    await this.db.update(agentThread).set({
+    await this.db.update(this.t.agentThread).set({
       queuePause: pause
-    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
   }
   async setActiveStream(threadId, runId) {
-    await this.db.update(agentThread).set({
+    await this.db.update(this.t.agentThread).set({
       activeStreamId: runId
-    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
   }
   /**
   * Patch a thread's `title` and/or `defaultAgent`. Each field is only touched when PRESENT in
@@ -1052,7 +1516,7 @@ var DrizzleAgentStore = class {
       return;
     }
     updates.updatedAt = /* @__PURE__ */ new Date();
-    await this.db.update(agentThread).set(updates).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+    await this.db.update(this.t.agentThread).set(updates).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId));
   }
   /**
   * The thread's default agent, projected — the caller wants one nullable scalar to decide which
@@ -1062,21 +1526,21 @@ var DrizzleAgentStore = class {
   /** The thread's pinned model, projected like {@link defaultAgentForThread}. */
   async modelForThread(threadId) {
     const [thread] = await this.db.select({
-      model: agentThread.model
-    }).from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+      model: this.t.agentThread.model
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     return thread?.model ?? null;
   }
   /** The thread's pinned persona, projected like {@link defaultAgentForThread}. */
   async personaForThread(threadId) {
     const [thread] = await this.db.select({
-      persona: agentThread.persona
-    }).from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+      persona: this.t.agentThread.persona
+    }).from(agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     return thread?.persona ?? null;
   }
   async defaultAgentForThread(threadId) {
     const [thread] = await this.db.select({
-      defaultAgent: agentThread.defaultAgent
-    }).from(agentThread).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(agentThread.deletedAt)));
+      defaultAgent: this.t.agentThread.defaultAgent
+    }).from(this.t.agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.id, threadId), (0, import_drizzle_orm3.isNull)(this.t.agentThread.deletedAt)));
     return thread?.defaultAgent ?? null;
   }
   /**
@@ -1101,7 +1565,7 @@ var DrizzleAgentStore = class {
       promptHash: run.promptHash ?? null,
       parentRunId: run.parentRunId ?? null
     };
-    await this.db.insert(agentRun).values(runRow);
+    await this.db.insert(this.t.agentRun).values(runRow);
   }
   /** Settle a run's outcome. A no-op when the run is unknown (mirrors `setTitle`/`updateThread`). */
   async recordRunEnd(end) {
@@ -1118,16 +1582,16 @@ var DrizzleAgentStore = class {
     if (end.errorMessage !== void 0) {
       updates.errorMessage = end.errorMessage;
     }
-    await this.db.update(agentRun).set(updates).where((0, import_drizzle_orm2.eq)(agentRun.id, end.runId));
+    await this.db.update(this.t.agentRun).set(updates).where((0, import_drizzle_orm3.eq)(this.t.agentRun.id, end.runId));
   }
   /** Bump the run's llm-step retry counter. Atomic `retries = retries + 1`, no read-modify-write. */
   async bumpRunRetries(runId) {
-    await this.db.update(agentRun).set({
-      retries: import_drizzle_orm2.sql`${agentRun.retries} + 1`
-    }).where((0, import_drizzle_orm2.eq)(agentRun.id, runId));
+    await this.db.update(this.t.agentRun).set({
+      retries: import_drizzle_orm3.sql`${this.t.agentRun.retries} + 1`
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentRun.id, runId));
   }
   async appendMessage(input) {
-    const [thread] = await this.db.select().from(agentThread).where((0, import_drizzle_orm2.eq)(agentThread.id, input.threadId));
+    const [thread] = await this.db.select().from(this.t.agentThread).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, input.threadId));
     if (thread === void 0) {
       throw new Error(`thread ${input.threadId} not found`);
     }
@@ -1149,47 +1613,48 @@ var DrizzleAgentStore = class {
       reasoningMs: input.reasoningMs ?? null,
       ui: input.ui ?? null,
       feedback: null,
+      seq: await this.nextMessageSeq(input.threadId),
       createdAt: now
     };
-    await this.db.insert(agentMessage).values(message);
-    await this.db.update(agentThread).set({
+    await this.db.insert(this.t.agentMessage).values(message);
+    await this.db.update(this.t.agentThread).set({
       updatedAt: now
-    }).where((0, import_drizzle_orm2.eq)(agentThread.id, input.threadId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentThread.id, input.threadId));
     return this.toStoredMessage(message);
   }
   async setMessageToolResults(messageId, results) {
-    await this.db.update(agentMessage).set({
+    await this.db.update(this.t.agentMessage).set({
       toolResults: results
-    }).where((0, import_drizzle_orm2.eq)(agentMessage.id, messageId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.id, messageId));
   }
   async setMessageUi(messageId, ui) {
-    await this.db.update(agentMessage).set({
+    await this.db.update(this.t.agentMessage).set({
       ui: ui.length > 0 ? ui : null
-    }).where((0, import_drizzle_orm2.eq)(agentMessage.id, messageId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.id, messageId));
   }
   async threadOfMessage(messageId) {
     const [row] = await this.db.select({
-      threadId: agentMessage.threadId
-    }).from(agentMessage).where((0, import_drizzle_orm2.eq)(agentMessage.id, messageId)).limit(1);
+      threadId: this.t.agentMessage.threadId
+    }).from(this.t.agentMessage).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.id, messageId)).limit(1);
     return row?.threadId ?? null;
   }
   async setMessageFeedback(messageId, feedback) {
-    await this.db.update(agentMessage).set({
+    await this.db.update(this.t.agentMessage).set({
       feedback
-    }).where((0, import_drizzle_orm2.eq)(agentMessage.id, messageId));
+    }).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.id, messageId));
   }
   async truncateFrom(threadId, messageId) {
-    const messages = await this.db.select().from(agentMessage).where((0, import_drizzle_orm2.eq)(agentMessage.threadId, threadId)).orderBy((0, import_drizzle_orm2.asc)(agentMessage.createdAt), (0, import_drizzle_orm2.asc)(agentMessage.id));
+    const messages = await this.db.select().from(this.t.agentMessage).where((0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, threadId)).orderBy(...this.messageOrder());
     const cutoff = messages.findIndex((message) => message.id === messageId);
     if (cutoff < 0) {
       return;
     }
     const doomedIds = messages.slice(cutoff).map((message) => message.id);
-    await this.db.delete(agentToolCall).where((0, import_drizzle_orm2.inArray)(agentToolCall.messageId, doomedIds));
-    await this.db.delete(agentMessage).where((0, import_drizzle_orm2.inArray)(agentMessage.id, doomedIds));
+    await this.db.delete(this.t.agentToolCall).where((0, import_drizzle_orm3.inArray)(this.t.agentToolCall.messageId, doomedIds));
+    await this.db.delete(this.t.agentMessage).where((0, import_drizzle_orm3.inArray)(this.t.agentMessage.id, doomedIds));
   }
   async recordToolCall(input) {
-    await this.db.insert(agentToolCall).values({
+    await this.db.insert(this.t.agentToolCall).values({
       id: input.toolCallId,
       messageId: input.messageId,
       toolName: input.toolName,
@@ -1234,18 +1699,18 @@ var DrizzleAgentStore = class {
     if (input.status === "executed" || input.status === "auto_executed") {
       updates.executedAt = /* @__PURE__ */ new Date();
     }
-    await this.db.update(agentToolCall).set(updates).where((0, import_drizzle_orm2.eq)(agentToolCall.id, input.toolCallId));
+    await this.db.update(this.t.agentToolCall).set(updates).where((0, import_drizzle_orm3.eq)(this.t.agentToolCall.id, input.toolCallId));
   }
   async toolCallOutcomes(toolCallIds) {
     if (toolCallIds.length === 0) {
       return [];
     }
     const rows = await this.db.select({
-      id: agentToolCall.id,
-      status: agentToolCall.status,
-      output: agentToolCall.output,
-      error: agentToolCall.error
-    }).from(agentToolCall).where((0, import_drizzle_orm2.inArray)(agentToolCall.id, [
+      id: this.t.agentToolCall.id,
+      status: this.t.agentToolCall.status,
+      output: this.t.agentToolCall.output,
+      error: this.t.agentToolCall.error
+    }).from(this.t.agentToolCall).where((0, import_drizzle_orm3.inArray)(this.t.agentToolCall.id, [
       ...toolCallIds
     ]));
     return rows.map((row) => ({
@@ -1260,14 +1725,14 @@ var DrizzleAgentStore = class {
     }));
   }
   async failUnsettledToolCalls(runId, error) {
-    const pending = (0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentToolCall.runId, runId), (0, import_drizzle_orm2.eq)(agentToolCall.status, "pending_approval"));
+    const pending = (0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentToolCall.runId, runId), (0, import_drizzle_orm3.eq)(this.t.agentToolCall.status, "pending_approval"));
     const rows = await this.db.select({
-      id: agentToolCall.id
-    }).from(agentToolCall).where(pending);
+      id: this.t.agentToolCall.id
+    }).from(this.t.agentToolCall).where(pending);
     if (rows.length === 0) {
       return 0;
     }
-    await this.db.update(agentToolCall).set({
+    await this.db.update(this.t.agentToolCall).set({
       status: "failed",
       error
     }).where(pending);
@@ -1292,11 +1757,11 @@ var DrizzleAgentStore = class {
       return [];
     }
     const rows = await this.db.select({
-      attachments: agentMessage.attachments
-    }).from(agentMessage).innerJoin(agentThread, (0, import_drizzle_orm2.eq)(agentMessage.threadId, agentThread.id)).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.actorRef, actorRef), (0, import_drizzle_orm2.isNotNull)(agentMessage.attachments)));
+      attachments: this.t.agentMessage.attachments
+    }).from(this.t.agentMessage).innerJoin(this.t.agentThread, (0, import_drizzle_orm3.eq)(this.t.agentMessage.threadId, this.t.agentThread.id)).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.actorRef, actorRef), (0, import_drizzle_orm3.isNotNull)(this.t.agentMessage.attachments)));
     const queued = await this.db.select({
-      attachments: agentQueuedMessage.attachments
-    }).from(agentQueuedMessage).innerJoin(agentThread, (0, import_drizzle_orm2.eq)(agentQueuedMessage.threadId, agentThread.id)).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.actorRef, actorRef), (0, import_drizzle_orm2.isNotNull)(agentQueuedMessage.attachments)));
+      attachments: this.t.agentQueuedMessage.attachments
+    }).from(this.t.agentQueuedMessage).innerJoin(this.t.agentThread, (0, import_drizzle_orm3.eq)(this.t.agentQueuedMessage.threadId, this.t.agentThread.id)).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentThread.actorRef, actorRef), (0, import_drizzle_orm3.isNotNull)(this.t.agentQueuedMessage.attachments)));
     const wanted = new Set(mediaIds);
     const found = /* @__PURE__ */ new Set();
     for (const row of [
@@ -1314,7 +1779,7 @@ var DrizzleAgentStore = class {
     ].filter((mediaId) => found.has(mediaId));
   }
   async recordUsage(input) {
-    await this.db.insert(agentTokenUsage).values({
+    await this.db.insert(this.t.agentTokenUsage).values({
       id: crypto.randomUUID(),
       threadId: input.threadId,
       actorRef: input.actorRef,
@@ -1335,7 +1800,7 @@ var DrizzleAgentStore = class {
   async usageBetween(actorRef, fromDay, toDay) {
     const start = /* @__PURE__ */ new Date(`${fromDay}T00:00:00.000Z`);
     const end = /* @__PURE__ */ new Date(`${toDay}T23:59:59.999Z`);
-    const rows = await this.db.select().from(agentTokenUsage).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentTokenUsage.actorRef, actorRef), (0, import_drizzle_orm2.gte)(agentTokenUsage.createdAt, start), (0, import_drizzle_orm2.lte)(agentTokenUsage.createdAt, end)));
+    const rows = await this.db.select().from(this.t.agentTokenUsage).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(this.t.agentTokenUsage.actorRef, actorRef), (0, import_drizzle_orm3.gte)(this.t.agentTokenUsage.createdAt, start), (0, import_drizzle_orm3.lte)(this.t.agentTokenUsage.createdAt, end)));
     const usedTokens = rows.reduce((sum2, row) => sum2 + row.inputTokens + row.outputTokens, 0);
     const costUsd = rows.reduce((sum2, row) => sum2 + (row.costUsd ?? 0), 0);
     return {
@@ -1437,7 +1902,7 @@ __name(toQueuedMessage, "toQueuedMessage");
 
 // src/drizzle-governance-queries.ts
 var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
-var import_drizzle_orm3 = require("drizzle-orm");
+var import_drizzle_orm4 = require("drizzle-orm");
 var UNCLASSIFIED_ERROR_CODE = "unknown";
 var DEFAULT_AGENT_BUCKET = "(default)";
 var TOOL_CALL_STATUSES = [
@@ -1550,11 +2015,15 @@ var DrizzleGovernanceQueries = class {
   static {
     __name(this, "DrizzleGovernanceQueries");
   }
-  db;
   pricingStore;
+  db;
+  dialect;
+  t;
   constructor(db, pricingStore) {
-    this.db = db;
     this.pricingStore = pricingStore;
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
   }
   async loadPricing() {
     const prices = await this.pricingStore.listCurrentPrices();
@@ -1571,7 +2040,7 @@ var DrizzleGovernanceQueries = class {
   }
   async usageInRange(range) {
     const { start, end } = (0, import_nestjs_agent_core2.dayBoundsUtc)(range);
-    const rows = await this.db.select().from(agentTokenUsage).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentTokenUsage.createdAt, start), (0, import_drizzle_orm3.lte)(agentTokenUsage.createdAt, end)));
+    const rows = await this.db.select().from(this.t.agentTokenUsage).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.gte)(this.t.agentTokenUsage.createdAt, start), (0, import_drizzle_orm4.lte)(this.t.agentTokenUsage.createdAt, end)));
     return rows.map(toUsageInput);
   }
   async spendByModel(range) {
@@ -1596,7 +2065,7 @@ var DrizzleGovernanceQueries = class {
     if (threadIds.length === 0) {
       return [];
     }
-    const threads = await this.db.select().from(agentThread).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.inArray)(agentThread.id, threadIds), (0, import_drizzle_orm3.isNull)(agentThread.deletedAt)));
+    const threads = await this.db.select().from(this.t.agentThread).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.inArray)(this.t.agentThread.id, threadIds), (0, import_drizzle_orm4.isNull)(this.t.agentThread.deletedAt)));
     const threadsById = new Map(threads.map((thread) => [
       thread.id,
       {
@@ -1615,14 +2084,14 @@ var DrizzleGovernanceQueries = class {
   }
   async recentToolCalls(limit) {
     const rows = await this.db.select({
-      toolCallId: agentToolCall.id,
-      toolName: agentToolCall.toolName,
-      toolType: agentToolCall.toolType,
-      status: agentToolCall.status,
-      threadId: agentMessage.threadId,
-      createdAt: agentToolCall.createdAt,
-      runId: agentToolCall.runId
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).orderBy((0, import_drizzle_orm3.desc)(agentToolCall.createdAt), (0, import_drizzle_orm3.desc)(agentToolCall.id)).limit(limit);
+      toolCallId: this.t.agentToolCall.id,
+      toolName: this.t.agentToolCall.toolName,
+      toolType: this.t.agentToolCall.toolType,
+      status: this.t.agentToolCall.status,
+      threadId: this.t.agentMessage.threadId,
+      createdAt: this.t.agentToolCall.createdAt,
+      runId: this.t.agentToolCall.runId
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm4.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).orderBy((0, import_drizzle_orm4.desc)(this.t.agentToolCall.createdAt), (0, import_drizzle_orm4.desc)(this.t.agentToolCall.id)).limit(limit);
     return rows.map((row) => ({
       toolCallId: row.toolCallId,
       toolName: row.toolName,
@@ -1650,9 +2119,9 @@ var DrizzleGovernanceQueries = class {
       return rollups;
     }
     const messageCounts = await this.db.select({
-      threadId: agentMessage.threadId,
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentMessage).where((0, import_drizzle_orm3.inArray)(agentMessage.threadId, threadIds)).groupBy(agentMessage.threadId);
+      threadId: this.t.agentMessage.threadId,
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentMessage).where((0, import_drizzle_orm4.inArray)(this.t.agentMessage.threadId, threadIds)).groupBy(this.t.agentMessage.threadId);
     for (const row of messageCounts) {
       const bucket = rollups.get(row.threadId);
       if (bucket !== void 0) {
@@ -1660,10 +2129,10 @@ var DrizzleGovernanceQueries = class {
       }
     }
     const usageTotals = await this.db.select({
-      threadId: agentTokenUsage.threadId,
-      inputTokens: (0, import_drizzle_orm3.sum)(agentTokenUsage.inputTokens),
-      outputTokens: (0, import_drizzle_orm3.sum)(agentTokenUsage.outputTokens)
-    }).from(agentTokenUsage).where((0, import_drizzle_orm3.inArray)(agentTokenUsage.threadId, threadIds)).groupBy(agentTokenUsage.threadId);
+      threadId: this.t.agentTokenUsage.threadId,
+      inputTokens: (0, import_drizzle_orm4.sum)(this.t.agentTokenUsage.inputTokens),
+      outputTokens: (0, import_drizzle_orm4.sum)(this.t.agentTokenUsage.outputTokens)
+    }).from(this.t.agentTokenUsage).where((0, import_drizzle_orm4.inArray)(this.t.agentTokenUsage.threadId, threadIds)).groupBy(this.t.agentTokenUsage.threadId);
     for (const row of usageTotals) {
       const bucket = rollups.get(row.threadId);
       if (bucket !== void 0) {
@@ -1688,12 +2157,12 @@ var DrizzleGovernanceQueries = class {
     });
   }
   async recentThreads(limit) {
-    const threads = await this.db.select().from(agentThread).where((0, import_drizzle_orm3.isNull)(agentThread.deletedAt)).orderBy((0, import_drizzle_orm3.desc)(agentThread.updatedAt), (0, import_drizzle_orm3.desc)(agentThread.id)).limit(limit);
+    const threads = await this.db.select().from(this.t.agentThread).where((0, import_drizzle_orm4.isNull)(this.t.agentThread.deletedAt)).orderBy((0, import_drizzle_orm4.desc)(this.t.agentThread.updatedAt), (0, import_drizzle_orm4.desc)(this.t.agentThread.id)).limit(limit);
     return this.toThreadActivityRows(threads);
   }
   async runsInRange(range) {
     const { start, end } = (0, import_nestjs_agent_core2.dayBoundsUtc)(range);
-    return this.db.select().from(agentRun).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentRun.startedAt, start), (0, import_drizzle_orm3.lte)(agentRun.startedAt, end)));
+    return this.db.select().from(this.t.agentRun).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.gte)(this.t.agentRun.startedAt, start), (0, import_drizzle_orm4.lte)(this.t.agentRun.startedAt, end)));
   }
   async runMetrics(range) {
     const runs = await this.runsInRange(range);
@@ -1750,7 +2219,7 @@ var DrizzleGovernanceQueries = class {
   }
   async runErrors(range) {
     const { start, end } = (0, import_nestjs_agent_core2.dayBoundsUtc)(range);
-    const runs = await this.db.select().from(agentRun).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentRun.startedAt, start), (0, import_drizzle_orm3.lte)(agentRun.startedAt, end), (0, import_drizzle_orm3.eq)(agentRun.status, "failed")));
+    const runs = await this.db.select().from(this.t.agentRun).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.gte)(this.t.agentRun.startedAt, start), (0, import_drizzle_orm4.lte)(this.t.agentRun.startedAt, end), (0, import_drizzle_orm4.eq)(this.t.agentRun.status, "failed")));
     const byError = /* @__PURE__ */ new Map();
     for (const run of runs) {
       const errorCode = run.errorCode ?? UNCLASSIFIED_ERROR_CODE;
@@ -1790,7 +2259,7 @@ var DrizzleGovernanceQueries = class {
     return result;
   }
   async recentRuns(limit) {
-    const runs = await this.db.select().from(agentRun).orderBy((0, import_drizzle_orm3.desc)(agentRun.startedAt), (0, import_drizzle_orm3.desc)(agentRun.id)).limit(limit);
+    const runs = await this.db.select().from(this.t.agentRun).orderBy((0, import_drizzle_orm4.desc)(this.t.agentRun.startedAt), (0, import_drizzle_orm4.desc)(this.t.agentRun.id)).limit(limit);
     return runs.map(toRecentRunRow);
   }
   /**
@@ -1800,16 +2269,16 @@ var DrizzleGovernanceQueries = class {
   */
   async pendingApprovals(limit) {
     const rows = await this.db.select({
-      toolCallId: agentToolCall.id,
-      toolName: agentToolCall.toolName,
-      input: agentToolCall.input,
-      threadId: agentThread.id,
-      threadTitle: agentThread.title,
-      actorRef: agentThread.actorRef,
-      agentName: agentMessage.agentName,
-      requestedAt: agentToolCall.createdAt,
-      runId: agentToolCall.runId
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, (0, import_drizzle_orm3.eq)(agentMessage.threadId, agentThread.id)).where((0, import_drizzle_orm3.eq)(agentToolCall.status, "pending_approval")).orderBy(agentToolCall.createdAt, agentToolCall.id).limit(limit);
+      toolCallId: this.t.agentToolCall.id,
+      toolName: this.t.agentToolCall.toolName,
+      input: this.t.agentToolCall.input,
+      threadId: this.t.agentThread.id,
+      threadTitle: this.t.agentThread.title,
+      actorRef: this.t.agentThread.actorRef,
+      agentName: this.t.agentMessage.agentName,
+      requestedAt: this.t.agentToolCall.createdAt,
+      runId: this.t.agentToolCall.runId
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm4.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).innerJoin(this.t.agentThread, (0, import_drizzle_orm4.eq)(this.t.agentMessage.threadId, this.t.agentThread.id)).where((0, import_drizzle_orm4.eq)(this.t.agentToolCall.status, "pending_approval")).orderBy(this.t.agentToolCall.createdAt, this.t.agentToolCall.id).limit(limit);
     return rows.map((row) => ({
       toolCallId: row.toolCallId,
       toolName: row.toolName,
@@ -1831,11 +2300,11 @@ var DrizzleGovernanceQueries = class {
   */
   async toolStats(range) {
     const { start, end } = (0, import_nestjs_agent_core2.dayBoundsUtc)(range);
-    const calls = await this.db.select().from(agentToolCall).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentToolCall.createdAt, start), (0, import_drizzle_orm3.lte)(agentToolCall.createdAt, end)));
+    const calls = await this.db.select().from(this.t.agentToolCall).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.gte)(this.t.agentToolCall.createdAt, start), (0, import_drizzle_orm4.lte)(this.t.agentToolCall.createdAt, end)));
     const byTool = /* @__PURE__ */ new Map();
     for (const call of calls) {
-      const key = `${call.toolName} ${call.toolType}`;
-      const bucket = byTool.get(key) ?? {
+      const key2 = `${call.toolName} ${call.toolType}`;
+      const bucket = byTool.get(key2) ?? {
         toolName: call.toolName,
         toolType: call.toolType,
         calls: 0,
@@ -1849,7 +2318,7 @@ var DrizzleGovernanceQueries = class {
       if (call.executionMs != null) {
         bucket.executionMs.push(call.executionMs);
       }
-      byTool.set(key, bucket);
+      byTool.set(key2, bucket);
     }
     const result = [];
     for (const bucket of byTool.values()) {
@@ -1881,19 +2350,19 @@ var DrizzleGovernanceQueries = class {
     if (filters?.toolType !== void 0 && !isToolKind(filters.toolType)) {
       return emptyPage(query);
     }
-    const whereClause = (0, import_drizzle_orm3.and)(filters?.toolName !== void 0 ? (0, import_drizzle_orm3.eq)(agentToolCall.toolName, filters.toolName) : void 0, filters?.toolType !== void 0 && isToolKind(filters.toolType) ? (0, import_drizzle_orm3.eq)(agentToolCall.toolType, filters.toolType) : void 0, filters?.status !== void 0 && isToolCallStatus(filters.status) ? (0, import_drizzle_orm3.eq)(agentToolCall.status, filters.status) : void 0, filters?.threadId !== void 0 ? (0, import_drizzle_orm3.eq)(agentMessage.threadId, filters.threadId) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm3.gte)(agentToolCall.createdAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm3.lte)(agentToolCall.createdAt, dayEndUtc(filters.toDay)) : void 0);
+    const whereClause = (0, import_drizzle_orm4.and)(filters?.toolName !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentToolCall.toolName, filters.toolName) : void 0, filters?.toolType !== void 0 && isToolKind(filters.toolType) ? (0, import_drizzle_orm4.eq)(this.t.agentToolCall.toolType, filters.toolType) : void 0, filters?.status !== void 0 && isToolCallStatus(filters.status) ? (0, import_drizzle_orm4.eq)(this.t.agentToolCall.status, filters.status) : void 0, filters?.threadId !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentMessage.threadId, filters.threadId) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm4.gte)(this.t.agentToolCall.createdAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm4.lte)(this.t.agentToolCall.createdAt, dayEndUtc(filters.toDay)) : void 0);
     const [totalRow] = await this.db.select({
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).where(whereClause);
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm4.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).where(whereClause);
     const rows = await this.db.select({
-      toolCallId: agentToolCall.id,
-      toolName: agentToolCall.toolName,
-      toolType: agentToolCall.toolType,
-      status: agentToolCall.status,
-      threadId: agentMessage.threadId,
-      createdAt: agentToolCall.createdAt,
-      runId: agentToolCall.runId
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).where(whereClause).orderBy((0, import_drizzle_orm3.desc)(agentToolCall.createdAt), (0, import_drizzle_orm3.desc)(agentToolCall.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+      toolCallId: this.t.agentToolCall.id,
+      toolName: this.t.agentToolCall.toolName,
+      toolType: this.t.agentToolCall.toolType,
+      status: this.t.agentToolCall.status,
+      threadId: this.t.agentMessage.threadId,
+      createdAt: this.t.agentToolCall.createdAt,
+      runId: this.t.agentToolCall.runId
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm4.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).where(whereClause).orderBy((0, import_drizzle_orm4.desc)(this.t.agentToolCall.createdAt), (0, import_drizzle_orm4.desc)(this.t.agentToolCall.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
     return {
       rows: rows.map((row) => ({
         toolCallId: row.toolCallId,
@@ -1917,11 +2386,11 @@ var DrizzleGovernanceQueries = class {
   */
   async threadsPage(query) {
     const filters = query.where;
-    const whereClause = (0, import_drizzle_orm3.and)((0, import_drizzle_orm3.isNull)(agentThread.deletedAt), filters?.actorRef !== void 0 ? (0, import_drizzle_orm3.eq)(agentThread.actorRef, filters.actorRef) : void 0, filters?.title !== void 0 ? (0, import_drizzle_orm3.like)(import_drizzle_orm3.sql`lower(${agentThread.title})`, `%${filters.title.toLowerCase()}%`) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm3.gte)(agentThread.updatedAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm3.lte)(agentThread.updatedAt, dayEndUtc(filters.toDay)) : void 0);
+    const whereClause = (0, import_drizzle_orm4.and)((0, import_drizzle_orm4.isNull)(this.t.agentThread.deletedAt), filters?.actorRef !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentThread.actorRef, filters.actorRef) : void 0, filters?.title !== void 0 ? (0, import_drizzle_orm4.like)(import_drizzle_orm4.sql`lower(${this.t.agentThread.title})`, `%${filters.title.toLowerCase()}%`) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm4.gte)(this.t.agentThread.updatedAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm4.lte)(this.t.agentThread.updatedAt, dayEndUtc(filters.toDay)) : void 0);
     const [totalRow] = await this.db.select({
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentThread).where(whereClause);
-    const threads = await this.db.select().from(agentThread).where(whereClause).orderBy((0, import_drizzle_orm3.desc)(agentThread.updatedAt), (0, import_drizzle_orm3.desc)(agentThread.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentThread).where(whereClause);
+    const threads = await this.db.select().from(this.t.agentThread).where(whereClause).orderBy((0, import_drizzle_orm4.desc)(this.t.agentThread.updatedAt), (0, import_drizzle_orm4.desc)(this.t.agentThread.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
     const rows = await this.toThreadActivityRows(threads);
     return {
       rows,
@@ -1939,11 +2408,11 @@ var DrizzleGovernanceQueries = class {
     if (filters?.status !== void 0 && !isRunStatus(filters.status)) {
       return emptyPage(query);
     }
-    const whereClause = (0, import_drizzle_orm3.and)(filters?.agentName !== void 0 ? (0, import_drizzle_orm3.eq)(agentRun.agentName, filters.agentName) : void 0, filters?.status !== void 0 && isRunStatus(filters.status) ? (0, import_drizzle_orm3.eq)(agentRun.status, filters.status) : void 0, filters?.errorCode !== void 0 ? (0, import_drizzle_orm3.eq)(agentRun.errorCode, filters.errorCode) : void 0, filters?.threadId !== void 0 ? (0, import_drizzle_orm3.eq)(agentRun.threadId, filters.threadId) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm3.gte)(agentRun.startedAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm3.lte)(agentRun.startedAt, dayEndUtc(filters.toDay)) : void 0);
+    const whereClause = (0, import_drizzle_orm4.and)(filters?.agentName !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentRun.agentName, filters.agentName) : void 0, filters?.status !== void 0 && isRunStatus(filters.status) ? (0, import_drizzle_orm4.eq)(this.t.agentRun.status, filters.status) : void 0, filters?.errorCode !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentRun.errorCode, filters.errorCode) : void 0, filters?.threadId !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentRun.threadId, filters.threadId) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm4.gte)(this.t.agentRun.startedAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm4.lte)(this.t.agentRun.startedAt, dayEndUtc(filters.toDay)) : void 0);
     const [totalRow] = await this.db.select({
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentRun).where(whereClause);
-    const runs = await this.db.select().from(agentRun).where(whereClause).orderBy((0, import_drizzle_orm3.desc)(agentRun.startedAt), (0, import_drizzle_orm3.desc)(agentRun.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentRun).where(whereClause);
+    const runs = await this.db.select().from(this.t.agentRun).where(whereClause).orderBy((0, import_drizzle_orm4.desc)(this.t.agentRun.startedAt), (0, import_drizzle_orm4.desc)(this.t.agentRun.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
     return {
       rows: runs.map(toRecentRunRow),
       total: totalRow?.value ?? 0,
@@ -1963,21 +2432,21 @@ var DrizzleGovernanceQueries = class {
   */
   async approvalsPage(query) {
     const filters = query.where;
-    const whereClause = (0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(agentToolCall.status, "pending_approval"), filters?.toolName !== void 0 ? (0, import_drizzle_orm3.eq)(agentToolCall.toolName, filters.toolName) : void 0, filters?.threadId !== void 0 ? (0, import_drizzle_orm3.eq)(agentThread.id, filters.threadId) : void 0, filters?.actorRef !== void 0 ? (0, import_drizzle_orm3.eq)(agentThread.actorRef, filters.actorRef) : void 0, filters?.agentName !== void 0 ? (0, import_drizzle_orm3.eq)(agentMessage.agentName, filters.agentName) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm3.gte)(agentToolCall.createdAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm3.lte)(agentToolCall.createdAt, dayEndUtc(filters.toDay)) : void 0);
+    const whereClause = (0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(this.t.agentToolCall.status, "pending_approval"), filters?.toolName !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentToolCall.toolName, filters.toolName) : void 0, filters?.threadId !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentThread.id, filters.threadId) : void 0, filters?.actorRef !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentThread.actorRef, filters.actorRef) : void 0, filters?.agentName !== void 0 ? (0, import_drizzle_orm4.eq)(this.t.agentMessage.agentName, filters.agentName) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm4.gte)(this.t.agentToolCall.createdAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm4.lte)(this.t.agentToolCall.createdAt, dayEndUtc(filters.toDay)) : void 0);
     const [totalRow] = await this.db.select({
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, (0, import_drizzle_orm3.eq)(agentMessage.threadId, agentThread.id)).where(whereClause);
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm4.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).innerJoin(this.t.agentThread, (0, import_drizzle_orm4.eq)(this.t.agentMessage.threadId, this.t.agentThread.id)).where(whereClause);
     const rows = await this.db.select({
-      toolCallId: agentToolCall.id,
-      toolName: agentToolCall.toolName,
-      input: agentToolCall.input,
-      threadId: agentThread.id,
-      threadTitle: agentThread.title,
-      actorRef: agentThread.actorRef,
-      agentName: agentMessage.agentName,
-      requestedAt: agentToolCall.createdAt,
-      runId: agentToolCall.runId
-    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, (0, import_drizzle_orm3.eq)(agentMessage.threadId, agentThread.id)).where(whereClause).orderBy((0, import_drizzle_orm3.asc)(agentToolCall.createdAt), (0, import_drizzle_orm3.asc)(agentToolCall.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+      toolCallId: this.t.agentToolCall.id,
+      toolName: this.t.agentToolCall.toolName,
+      input: this.t.agentToolCall.input,
+      threadId: this.t.agentThread.id,
+      threadTitle: this.t.agentThread.title,
+      actorRef: this.t.agentThread.actorRef,
+      agentName: this.t.agentMessage.agentName,
+      requestedAt: this.t.agentToolCall.createdAt,
+      runId: this.t.agentToolCall.runId
+    }).from(this.t.agentToolCall).innerJoin(this.t.agentMessage, (0, import_drizzle_orm4.eq)(this.t.agentToolCall.messageId, this.t.agentMessage.id)).innerJoin(this.t.agentThread, (0, import_drizzle_orm4.eq)(this.t.agentMessage.threadId, this.t.agentThread.id)).where(whereClause).orderBy((0, import_drizzle_orm4.asc)(this.t.agentToolCall.createdAt), (0, import_drizzle_orm4.asc)(this.t.agentToolCall.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
     return {
       rows: rows.map((row) => ({
         toolCallId: row.toolCallId,
@@ -2002,13 +2471,13 @@ var DrizzleGovernanceQueries = class {
   */
   async runDetail(runId) {
     const [row] = await this.db.select({
-      run: agentRun,
-      thread: agentThread
-    }).from(agentRun).innerJoin(agentThread, (0, import_drizzle_orm3.eq)(agentRun.threadId, agentThread.id)).where((0, import_drizzle_orm3.eq)(agentRun.id, runId)).limit(1);
+      run: this.t.agentRun,
+      thread: this.t.agentThread
+    }).from(this.t.agentRun).innerJoin(this.t.agentThread, (0, import_drizzle_orm4.eq)(this.t.agentRun.threadId, this.t.agentThread.id)).where((0, import_drizzle_orm4.eq)(this.t.agentRun.id, runId)).limit(1);
     if (row === void 0) {
       return null;
     }
-    const toolCalls = await this.db.select().from(agentToolCall).where((0, import_drizzle_orm3.eq)(agentToolCall.runId, runId)).orderBy((0, import_drizzle_orm3.asc)(agentToolCall.createdAt), (0, import_drizzle_orm3.asc)(agentToolCall.id));
+    const toolCalls = await this.db.select().from(this.t.agentToolCall).where((0, import_drizzle_orm4.eq)(this.t.agentToolCall.runId, runId)).orderBy((0, import_drizzle_orm4.asc)(this.t.agentToolCall.createdAt), (0, import_drizzle_orm4.asc)(this.t.agentToolCall.id));
     return {
       run: toRecentRunRow(row.run),
       thread: {
@@ -2027,22 +2496,27 @@ var DrizzleGovernanceQueries = class {
   * message. Soft-deleted threads are returned with `deleted: true`; an audit still needs them.
   */
   async threadDetail(query) {
-    const [thread] = await this.db.select().from(agentThread).where((0, import_drizzle_orm3.eq)(agentThread.id, query.threadId)).limit(1);
+    const [thread] = await this.db.select().from(this.t.agentThread).where((0, import_drizzle_orm4.eq)(this.t.agentThread.id, query.threadId)).limit(1);
     if (thread === void 0) {
       return null;
     }
     const pricing = await this.loadPricing();
-    const usageRows = await this.db.select().from(agentTokenUsage).where((0, import_drizzle_orm3.eq)(agentTokenUsage.threadId, thread.id));
+    const usageRows = await this.db.select().from(this.t.agentTokenUsage).where((0, import_drizzle_orm4.eq)(this.t.agentTokenUsage.threadId, thread.id));
     const usage = (0, import_nestjs_agent_core2.rollupThreadUsage)(usageRows.map(toUsageInput), pricing);
     const [messageCountRow] = await this.db.select({
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentMessage).where((0, import_drizzle_orm3.eq)(agentMessage.threadId, thread.id));
-    const messages = await this.db.select().from(agentMessage).where((0, import_drizzle_orm3.eq)(agentMessage.threadId, thread.id)).orderBy((0, import_drizzle_orm3.desc)(agentMessage.createdAt), (0, import_drizzle_orm3.desc)(agentMessage.id)).limit(query.messageLimit);
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentMessage).where((0, import_drizzle_orm4.eq)(this.t.agentMessage.threadId, thread.id));
+    const messages = await this.db.select().from(this.t.agentMessage).where((0, import_drizzle_orm4.eq)(this.t.agentMessage.threadId, thread.id)).orderBy(
+      // Append order (see DrizzleAgentStore's message order), newest first.
+      (0, import_drizzle_orm4.desc)(import_drizzle_orm4.sql`coalesce(${this.t.agentMessage.seq}, 0)`),
+      (0, import_drizzle_orm4.desc)(this.t.agentMessage.createdAt),
+      (0, import_drizzle_orm4.desc)(this.t.agentMessage.id)
+    ).limit(query.messageLimit);
     const toolCallCounts = await this.toolCallCountsByMessage(messages.map((message) => message.id));
     const [runTotalRow] = await this.db.select({
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentRun).where((0, import_drizzle_orm3.eq)(agentRun.threadId, thread.id));
-    const runs = await this.db.select().from(agentRun).where((0, import_drizzle_orm3.eq)(agentRun.threadId, thread.id)).orderBy((0, import_drizzle_orm3.desc)(agentRun.startedAt), (0, import_drizzle_orm3.desc)(agentRun.id)).limit(query.runLimit);
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentRun).where((0, import_drizzle_orm4.eq)(this.t.agentRun.threadId, thread.id));
+    const runs = await this.db.select().from(this.t.agentRun).where((0, import_drizzle_orm4.eq)(this.t.agentRun.threadId, thread.id)).orderBy((0, import_drizzle_orm4.desc)(this.t.agentRun.startedAt), (0, import_drizzle_orm4.desc)(this.t.agentRun.id)).limit(query.runLimit);
     return {
       thread: {
         threadId: thread.id,
@@ -2077,9 +2551,9 @@ var DrizzleGovernanceQueries = class {
       return counts;
     }
     const rows = await this.db.select({
-      messageId: agentToolCall.messageId,
-      value: (0, import_drizzle_orm3.count)()
-    }).from(agentToolCall).where((0, import_drizzle_orm3.inArray)(agentToolCall.messageId, messageIds)).groupBy(agentToolCall.messageId);
+      messageId: this.t.agentToolCall.messageId,
+      value: (0, import_drizzle_orm4.count)()
+    }).from(this.t.agentToolCall).where((0, import_drizzle_orm4.inArray)(this.t.agentToolCall.messageId, messageIds)).groupBy(this.t.agentToolCall.messageId);
     for (const row of rows) {
       counts.set(row.messageId, row.value);
     }
@@ -2089,7 +2563,7 @@ var DrizzleGovernanceQueries = class {
 
 // src/drizzle-memory-provider.ts
 var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
-var import_drizzle_orm4 = require("drizzle-orm");
+var import_drizzle_orm5 = require("drizzle-orm");
 function toRecord(row) {
   return {
     id: row.id,
@@ -2118,8 +2592,12 @@ var DrizzleMemoryProvider = class {
     __name(this, "DrizzleMemoryProvider");
   }
   db;
+  dialect;
+  t;
   constructor(db) {
-    this.db = db;
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
   }
   /**
   * Every memory visible at `scopes` — asked on EVERY turn, so it is one indexed `scope in (…)`
@@ -2133,7 +2611,7 @@ var DrizzleMemoryProvider = class {
     if (scopes.length === 0) {
       return [];
     }
-    const rows = await this.db.select().from(agentMemory).where((0, import_drizzle_orm4.inArray)(agentMemory.scope, [
+    const rows = await this.db.select().from(this.t.agentMemory).where((0, import_drizzle_orm5.inArray)(this.t.agentMemory.scope, [
       ...scopes
     ]));
     return rows.map(toRecord);
@@ -2149,10 +2627,8 @@ var DrizzleMemoryProvider = class {
   * answer cannot be used to find out which memories exist about other people.
   */
   async forget({ id, ctx }) {
-    const deleted = await this.db.delete(agentMemory).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(agentMemory.id, id), (0, import_drizzle_orm4.eq)(agentMemory.scope, (0, import_nestjs_agent_core3.actorScope)(ctx.actor)))).returning({
-      id: agentMemory.id
-    });
-    return deleted.length > 0;
+    const deleted = await affectedRows(this.dialect, this.db.delete(this.t.agentMemory).where((0, import_drizzle_orm5.and)((0, import_drizzle_orm5.eq)(this.t.agentMemory.id, id), (0, import_drizzle_orm5.eq)(this.t.agentMemory.scope, (0, import_nestjs_agent_core3.actorScope)(ctx.actor)))), this.t.agentMemory.id);
+    return deleted > 0;
   }
   /**
   * Upsert on (`scope`, `key`) — one statement, against the unique index, rather than a read
@@ -2165,7 +2641,7 @@ var DrizzleMemoryProvider = class {
   * rewriting `createdAt` would lose when the belief was first formed; reassigning `id` would
   * invalidate the delete handle a person was already shown.
   */
-  async write({ key, text: text2, scope, origin, ctx }) {
+  async write({ key: key2, text: text3, scope, origin, ctx }) {
     assertAuthorMayWriteScope({
       scope,
       origin,
@@ -2178,28 +2654,40 @@ var DrizzleMemoryProvider = class {
       originRunId: origin.runId ?? null,
       originActorRef: origin.actorRef ?? null
     };
-    const [row] = await this.db.insert(agentMemory).values({
+    const memory = this.t.agentMemory;
+    const set = {
+      text: text3,
+      ...columns,
+      updatedAt: now
+    };
+    const insert = this.db.insert(memory).values({
       id: crypto.randomUUID(),
       scope,
-      key,
-      text: text2,
+      key: key2,
+      text: text3,
       ...columns,
       pinned: false,
       createdAt: now,
       updatedAt: now
-    }).onConflictDoUpdate({
-      target: [
-        agentMemory.scope,
-        agentMemory.key
-      ],
-      set: {
-        text: text2,
-        ...columns,
-        updatedAt: now
-      }
-    }).returning();
+    });
+    let row;
+    if (this.dialect === "mysql") {
+      await upsert(this.dialect, insert, [
+        memory.scope,
+        memory.key
+      ], set);
+      [row] = await this.db.select().from(memory).where((0, import_drizzle_orm5.and)((0, import_drizzle_orm5.eq)(memory.scope, scope), (0, import_drizzle_orm5.eq)(memory.key, key2)));
+    } else {
+      [row] = await insert.onConflictDoUpdate({
+        target: [
+          memory.scope,
+          memory.key
+        ],
+        set
+      }).returning();
+    }
     if (row === void 0) {
-      throw new Error(`DrizzleMemoryProvider: the upsert of "${key}" at "${scope}" returned no row; the driver does not support RETURNING on conflict.`);
+      throw new Error(`DrizzleMemoryProvider: the upsert of "${key2}" at "${scope}" returned no row; the driver does not support RETURNING on conflict.`);
     }
     return toRecord(row);
   }
@@ -2212,13 +2700,11 @@ var DrizzleMemoryProvider = class {
   * `false` where there is no such id.
   */
   async pin({ id, pinned }) {
-    const updated = await this.db.update(agentMemory).set({
+    const updated = await affectedRows(this.dialect, this.db.update(this.t.agentMemory).set({
       pinned,
       updatedAt: /* @__PURE__ */ new Date()
-    }).where((0, import_drizzle_orm4.eq)(agentMemory.id, id)).returning({
-      id: agentMemory.id
-    });
-    return updated.length > 0;
+    }).where((0, import_drizzle_orm5.eq)(this.t.agentMemory.id, id)), this.t.agentMemory.id);
+    return updated > 0;
   }
 };
 function assertAuthorMayWriteScope({ scope, origin, ctx }) {
@@ -2230,20 +2716,24 @@ function assertAuthorMayWriteScope({ scope, origin, ctx }) {
 __name(assertAuthorMayWriteScope, "assertAuthorMayWriteScope");
 
 // src/drizzle-pricing-store.ts
-var import_drizzle_orm5 = require("drizzle-orm");
+var import_drizzle_orm6 = require("drizzle-orm");
 var DrizzlePricingStore = class {
   static {
     __name(this, "DrizzlePricingStore");
   }
   db;
+  dialect;
+  t;
   constructor(db) {
-    this.db = db;
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
   }
   async upsertModelPrice(input) {
-    await this.db.update(agentModelPricing).set({
+    await this.db.update(this.t.agentModelPricing).set({
       isCurrent: false
-    }).where((0, import_drizzle_orm5.and)((0, import_drizzle_orm5.eq)(agentModelPricing.modelId, input.modelId), (0, import_drizzle_orm5.eq)(agentModelPricing.isCurrent, true)));
-    await this.db.insert(agentModelPricing).values({
+    }).where((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(this.t.agentModelPricing.modelId, input.modelId), (0, import_drizzle_orm6.eq)(this.t.agentModelPricing.isCurrent, true)));
+    await this.db.insert(this.t.agentModelPricing).values({
       id: crypto.randomUUID(),
       modelId: input.modelId,
       inputPricePer1m: input.inputPricePer1m,
@@ -2255,7 +2745,7 @@ var DrizzlePricingStore = class {
     });
   }
   async listCurrentPrices() {
-    const rows = await this.db.select().from(agentModelPricing).where((0, import_drizzle_orm5.eq)(agentModelPricing.isCurrent, true));
+    const rows = await this.db.select().from(this.t.agentModelPricing).where((0, import_drizzle_orm6.eq)(this.t.agentModelPricing.isCurrent, true));
     return rows.map((row) => ({
       modelId: row.modelId,
       inputPricePer1m: row.inputPricePer1m,
@@ -2273,52 +2763,47 @@ var DrizzlePricingStore = class {
 
 // src/drizzle-token-stream-sink.ts
 var import_nestjs_agent_core4 = require("@dudousxd/nestjs-agent-core");
-var import_drizzle_orm6 = require("drizzle-orm");
-function isUniqueViolation(error) {
-  for (let current = error; current !== null && typeof current === "object"; ) {
-    const code = current.code;
-    if (typeof code === "string" && code.startsWith("SQLITE_CONSTRAINT")) return true;
-    current = current.cause;
-  }
-  return false;
-}
-__name(isUniqueViolation, "isUniqueViolation");
+var import_drizzle_orm7 = require("drizzle-orm");
 var DrizzleStreamFrameTable = class {
   static {
     __name(this, "DrizzleStreamFrameTable");
   }
   db;
+  dialect;
+  t;
   constructor(db) {
-    this.db = db;
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
   }
   async append(runId, row) {
-    await this.db.run(import_drizzle_orm6.sql`INSERT INTO agent_stream_frame (run_id, seq, frame, error, created_at)
+    await runSql(this.db, this.dialect, import_drizzle_orm7.sql`INSERT INTO agent_stream_frame (run_id, seq, frame, error, created_at)
           SELECT ${runId}, COALESCE(MAX(seq), 0) + 1, ${row.frame}, ${row.error}, ${row.createdAt}
           FROM agent_stream_frame WHERE run_id = ${runId}`);
   }
   async read(runId, after, limit) {
     return this.db.select({
-      seq: agentStreamFrame.seq,
-      frame: agentStreamFrame.frame,
-      error: agentStreamFrame.error
-    }).from(agentStreamFrame).where((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(agentStreamFrame.runId, runId), (0, import_drizzle_orm6.gt)(agentStreamFrame.seq, after))).orderBy((0, import_drizzle_orm6.asc)(agentStreamFrame.seq)).limit(limit);
+      seq: this.t.agentStreamFrame.seq,
+      frame: this.t.agentStreamFrame.frame,
+      error: this.t.agentStreamFrame.error
+    }).from(this.t.agentStreamFrame).where((0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(this.t.agentStreamFrame.runId, runId), (0, import_drizzle_orm7.gt)(this.t.agentStreamFrame.seq, after))).orderBy((0, import_drizzle_orm7.asc)(this.t.agentStreamFrame.seq)).limit(limit);
   }
   async has(runId) {
     const rows = await this.db.select({
-      seq: agentStreamFrame.seq
-    }).from(agentStreamFrame).where((0, import_drizzle_orm6.eq)(agentStreamFrame.runId, runId)).limit(1);
+      seq: this.t.agentStreamFrame.seq
+    }).from(this.t.agentStreamFrame).where((0, import_drizzle_orm7.eq)(this.t.agentStreamFrame.runId, runId)).limit(1);
     return rows.length > 0;
   }
   async remove(runIds) {
     if (runIds.length === 0) return;
-    await this.db.delete(agentStreamFrame).where((0, import_drizzle_orm6.inArray)(agentStreamFrame.runId, [
+    await this.db.delete(this.t.agentStreamFrame).where((0, import_drizzle_orm7.inArray)(this.t.agentStreamFrame.runId, [
       ...runIds
     ]));
   }
   async lapsedRuns(cutoff) {
     const rows = await this.db.select({
-      runId: agentStreamFrame.runId
-    }).from(agentStreamFrame).groupBy(agentStreamFrame.runId).having((0, import_drizzle_orm6.lt)((0, import_drizzle_orm6.max)(agentStreamFrame.createdAt), cutoff));
+      runId: this.t.agentStreamFrame.runId
+    }).from(this.t.agentStreamFrame).groupBy(this.t.agentStreamFrame.runId).having((0, import_drizzle_orm7.lt)((0, import_drizzle_orm7.max)(this.t.agentStreamFrame.createdAt), cutoff));
     return rows.map((row) => row.runId);
   }
   isUniqueViolation(error) {
@@ -2335,54 +2820,60 @@ var DrizzleTokenStreamSink = class extends import_nestjs_agent_core4.SqlTokenStr
 };
 
 // src/drizzle-confirm-token-store.ts
-var import_drizzle_orm7 = require("drizzle-orm");
+var import_drizzle_orm8 = require("drizzle-orm");
 var DrizzleConfirmTokenStore = class {
   static {
     __name(this, "DrizzleConfirmTokenStore");
   }
   db;
+  dialect;
+  t;
   constructor(db) {
-    this.db = db;
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
   }
   async claim(input) {
-    const inserted = await this.db.insert(agentConfirmToken).values({
+    const row = {
       hash: input.hash,
       actorRef: input.actorRef,
       tool: input.tool,
       expiresAt: input.expiresAt,
       createdAt: Date.now()
-    }).onConflictDoNothing().returning({
-      hash: agentConfirmToken.hash
-    });
-    return inserted.length === 1;
+    };
+    const table = this.t.agentConfirmToken;
+    if (this.dialect === "mysql") {
+      const insert = this.db.insert(table);
+      return mysqlAffectedRows(await insert.ignore().values(row)) === 1;
+    }
+    const inserted = await affectedRows(this.dialect, this.db.insert(table).values(row).onConflictDoNothing(), table.hash);
+    return inserted === 1;
   }
   async release(hash) {
-    await this.db.delete(agentConfirmToken).where((0, import_drizzle_orm7.eq)(agentConfirmToken.hash, hash));
+    await this.db.delete(this.t.agentConfirmToken).where((0, import_drizzle_orm8.eq)(this.t.agentConfirmToken.hash, hash));
   }
   async purgeExpired(now = Date.now()) {
-    const purged = await this.db.delete(agentConfirmToken).where((0, import_drizzle_orm7.lt)(agentConfirmToken.expiresAt, now)).returning({
-      hash: agentConfirmToken.hash
-    });
-    return purged.length;
+    const table = this.t.agentConfirmToken;
+    return affectedRows(this.dialect, this.db.delete(table).where((0, import_drizzle_orm8.lt)(table.expiresAt, now)), table.hash);
   }
 };
 
 // src/drizzle-rag-ingestion-log.ts
 var import_node_diagnostics_channel = require("diagnostics_channel");
 var import_common = require("@nestjs/common");
-var import_drizzle_orm8 = require("drizzle-orm");
-function _ts_decorate(decorators, target, key, desc4) {
-  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+var import_drizzle_orm9 = require("drizzle-orm");
+function _ts_decorate(decorators, target, key2, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key2) : desc4, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
-    r = Reflect.decorate(decorators, target, key, desc4);
+    r = Reflect.decorate(decorators, target, key2, desc4);
   } else {
     for (var i = decorators.length - 1; i >= 0; i--) {
       if (d = decorators[i]) {
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key2, r) : d(target, key2)) || r;
       }
     }
   }
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+  return c > 3 && r && Object.defineProperty(target, key2, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
 function _ts_metadata(metadataKey, metadataValue) {
@@ -2418,8 +2909,8 @@ function num(value) {
 }
 __name(num, "num");
 var RAG_INGESTION_LOG_PAGE_ORDER = [
-  (0, import_drizzle_orm8.desc)(ragIngestionLog.updatedAt),
-  (0, import_drizzle_orm8.asc)(ragIngestionLog.documentId)
+  (0, import_drizzle_orm9.desc)(ragIngestionLog.updatedAt),
+  (0, import_drizzle_orm9.asc)(ragIngestionLog.documentId)
 ];
 var DEFAULT_PAGE_SIZE = 200;
 var DEFAULT_BATCH_SIZE = 200;
@@ -2428,20 +2919,27 @@ function batches(batchSize) {
   return Number.isFinite(requested) && requested >= 1 ? requested : DEFAULT_BATCH_SIZE;
 }
 __name(batches, "batches");
-var CURSOR_COLUMNS = {
-  documentId: ragIngestionLog.documentId,
-  updatedAt: ragIngestionLog.updatedAt
-};
+function cursorColumns(log) {
+  return {
+    documentId: log.documentId,
+    updatedAt: log.updatedAt
+  };
+}
+__name(cursorColumns, "cursorColumns");
 var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
   static {
     __name(this, "DrizzleRagIngestionLog");
   }
-  db;
   logger = new import_common.Logger(_DrizzleRagIngestionLog.name);
   teardowns = [];
   inFlight = /* @__PURE__ */ new Set();
+  db;
+  dialect;
+  t;
   constructor(db) {
-    this.db = db;
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
   }
   onModuleInit() {
     for (const channel of CHANNELS) {
@@ -2470,7 +2968,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
   }
   /** The latest recorded outcome per document, newest first. */
   async list(query = {}) {
-    const rows = this.db.select().from(ragIngestionLog).where(this.where(query)).orderBy(...RAG_INGESTION_LOG_PAGE_ORDER).limit(query.limit ?? DEFAULT_PAGE_SIZE);
+    const rows = this.db.select().from(this.t.ragIngestionLog).where(this.where(query)).orderBy(...RAG_INGESTION_LOG_PAGE_ORDER).limit(query.limit ?? DEFAULT_PAGE_SIZE);
     return query.offset === void 0 ? rows : rows.offset(query.offset);
   }
   /**
@@ -2483,8 +2981,8 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
   */
   async listPage(query = {}) {
     const [totalRow] = await this.db.select({
-      value: (0, import_drizzle_orm8.count)()
-    }).from(ragIngestionLog).where(this.where(query));
+      value: (0, import_drizzle_orm9.count)()
+    }).from(this.t.ragIngestionLog).where(this.where(query));
     return {
       rows: await this.list(query),
       total: totalRow?.value ?? 0
@@ -2537,7 +3035,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
   * sweep is run. A sweep that stops early stops by `break`ing out of the `for await`.
   */
   iterate(where = {}, options = {}) {
-    return this.sweep(where, batches(options.batchSize), options.after, (filter, limit) => this.db.select().from(ragIngestionLog).where(filter).orderBy(...RAG_INGESTION_LOG_PAGE_ORDER).limit(limit));
+    return this.sweep(where, batches(options.batchSize), options.after, (filter, limit) => this.db.select().from(this.t.ragIngestionLog).where(filter).orderBy(...RAG_INGESTION_LOG_PAGE_ORDER).limit(limit));
   }
   /**
   * Just the document ids of the matching rows, in {@link RAG_INGESTION_LOG_PAGE_ORDER}.
@@ -2554,7 +3052,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
   */
   async listDocumentIds(where = {}, options = {}) {
     const ids = [];
-    const rows = this.sweep(where, batches(options.batchSize), void 0, (filter, limit) => this.db.select(CURSOR_COLUMNS).from(ragIngestionLog).where(filter).orderBy(...RAG_INGESTION_LOG_PAGE_ORDER).limit(limit));
+    const rows = this.sweep(where, batches(options.batchSize), void 0, (filter, limit) => this.db.select(cursorColumns(this.t.ragIngestionLog)).from(this.t.ragIngestionLog).where(filter).orderBy(...RAG_INGESTION_LOG_PAGE_ORDER).limit(limit));
     for await (const row of rows) {
       ids.push(row.documentId);
     }
@@ -2562,22 +3060,18 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
   }
   /** The latest recorded outcome for one document, or null if it was never attempted. */
   async get(documentId) {
-    const [row] = await this.db.select().from(ragIngestionLog).where((0, import_drizzle_orm8.eq)(ragIngestionLog.documentId, documentId));
+    const [row] = await this.db.select().from(this.t.ragIngestionLog).where((0, import_drizzle_orm9.eq)(this.t.ragIngestionLog.documentId, documentId));
     return row ?? null;
   }
   /** Forget one document's record. Returns whether a row was actually removed. */
   async remove(documentId) {
-    const removed = await this.db.delete(ragIngestionLog).where((0, import_drizzle_orm8.eq)(ragIngestionLog.documentId, documentId)).returning({
-      documentId: ragIngestionLog.documentId
-    });
-    return removed.length > 0;
+    const removed = await affectedRows(this.dialect, this.db.delete(this.t.ragIngestionLog).where((0, import_drizzle_orm9.eq)(this.t.ragIngestionLog.documentId, documentId)), this.t.ragIngestionLog.documentId);
+    return removed > 0;
   }
   /** Forget every record for a collection — for when the collection itself is deleted. */
   async removeByCollection(collection) {
-    const removed = await this.db.delete(ragIngestionLog).where((0, import_drizzle_orm8.eq)(ragIngestionLog.collection, collection)).returning({
-      documentId: ragIngestionLog.documentId
-    });
-    return removed.length;
+    const removed = await affectedRows(this.dialect, this.db.delete(this.t.ragIngestionLog).where((0, import_drizzle_orm9.eq)(this.t.ragIngestionLog.collection, collection)), this.t.ragIngestionLog.documentId);
+    return removed;
   }
   /**
   * The keyset sweep both {@link iterate} and {@link listDocumentIds} are made of. `page` decides
@@ -2606,7 +3100,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
     }
   }
   where(query) {
-    return (0, import_drizzle_orm8.and)(query.collection !== void 0 ? (0, import_drizzle_orm8.eq)(ragIngestionLog.collection, query.collection) : void 0, query.status !== void 0 ? (0, import_drizzle_orm8.eq)(ragIngestionLog.status, query.status) : void 0);
+    return (0, import_drizzle_orm9.and)(query.collection !== void 0 ? (0, import_drizzle_orm9.eq)(this.t.ragIngestionLog.collection, query.collection) : void 0, query.status !== void 0 ? (0, import_drizzle_orm9.eq)(this.t.ragIngestionLog.status, query.status) : void 0);
   }
   /**
   * The coordinates filter AND'd with "strictly after `cursor` in
@@ -2621,7 +3115,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
     if (cursor === void 0) {
       return base;
     }
-    return (0, import_drizzle_orm8.and)(base, (0, import_drizzle_orm8.or)((0, import_drizzle_orm8.lt)(ragIngestionLog.updatedAt, cursor.updatedAt), (0, import_drizzle_orm8.and)((0, import_drizzle_orm8.eq)(ragIngestionLog.updatedAt, cursor.updatedAt), (0, import_drizzle_orm8.gt)(ragIngestionLog.documentId, cursor.documentId))));
+    return (0, import_drizzle_orm9.and)(base, (0, import_drizzle_orm9.or)((0, import_drizzle_orm9.lt)(this.t.ragIngestionLog.updatedAt, cursor.updatedAt), (0, import_drizzle_orm9.and)((0, import_drizzle_orm9.eq)(this.t.ragIngestionLog.updatedAt, cursor.updatedAt), (0, import_drizzle_orm9.gt)(this.t.ragIngestionLog.documentId, cursor.documentId))));
   }
   /**
   * Upsert one outcome. Keyed by document id so the row always reflects the *current* state — a
@@ -2669,14 +3163,11 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
           size
         } : {}
       };
-      await this.db.insert(ragIngestionLog).values({
+      await upsert(this.dialect, this.db.insert(this.t.ragIngestionLog).values({
         documentId,
         createdAt: now,
         ...outcome
-      }).onConflictDoUpdate({
-        target: ragIngestionLog.documentId,
-        set: outcome
-      });
+      }), this.t.ragIngestionLog.documentId, outcome);
     } catch (error) {
       this.logger.warn(`Could not record RAG ingestion outcome for ${documentId}: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -2699,18 +3190,18 @@ DrizzleRagIngestionLog = _ts_decorate([
 // src/drizzle-agent-store.module.ts
 var import_nestjs_agent_core5 = require("@dudousxd/nestjs-agent-core");
 var import_common2 = require("@nestjs/common");
-function _ts_decorate2(decorators, target, key, desc4) {
-  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+function _ts_decorate2(decorators, target, key2, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key2) : desc4, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
-    r = Reflect.decorate(decorators, target, key, desc4);
+    r = Reflect.decorate(decorators, target, key2, desc4);
   } else {
     for (var i = decorators.length - 1; i >= 0; i--) {
       if (d = decorators[i]) {
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key2, r) : d(target, key2)) || r;
       }
     }
   }
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+  return c > 3 && r && Object.defineProperty(target, key2, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
 var DrizzleAgentStoreModule = class _DrizzleAgentStoreModule {
@@ -2811,17 +3302,21 @@ DrizzleAgentStoreModule = _ts_decorate2([
   DrizzleTokenStreamSink,
   RAG_INGESTION_LOG_PAGE_ORDER,
   agentConfirmToken,
+  agentDialectOf,
   agentMemory,
   agentMessage,
   agentModelPricing,
   agentQueuedMessage,
   agentRun,
   agentSchema,
+  agentSchemaDdl,
   agentStreamFrame,
   agentThread,
   agentTokenUsage,
   agentToolCall,
   ensureAgentSchema,
+  mysqlAgentSchema,
+  pgAgentSchema,
   ragIngestionLog
 });
 //# sourceMappingURL=index.cjs.map