@dudousxd/nestjs-agent-store-drizzle 0.18.3 → 0.19.0

package/dist/index.js

@@ -16,6 +16,10 @@ var agentThread = sqliteTable("agent_thread", {
   defaultAgent: text("default_agent"),
   /** The model every turn on this thread runs on unless the send names one; `null` → default. */
   model: text("model"),
+  /** Why the thread's message queue stopped draining; `null` → it drains. */
+  queuePause: text("queue_pause", {
+    mode: "json"
+  }).$type(),
   createdAt: integer("created_at", {
     mode: "timestamp_ms"
   }).notNull(),
@@ -109,6 +113,37 @@ var agentToolCall = sqliteTable("agent_tool_call", {
 }, (table) => [
   index("agent_tool_call_message_idx").on(table.messageId)
 ]);
+var agentQueuedMessage = sqliteTable("agent_queued_message", {
+  id: text("id").primaryKey(),
+  threadId: text("thread_id").notNull().references(() => agentThread.id, {
+    onDelete: "cascade"
+  }),
+  /** Who queued it — the turn it starts runs as this actor. */
+  actor: text("actor", {
+    mode: "json"
+  }).$type().notNull(),
+  content: text("content").notNull(),
+  attachments: text("attachments", {
+    mode: "json"
+  }).$type(),
+  agentName: text("agent_name"),
+  model: text("model"),
+  pageContext: text("page_context", {
+    mode: "json"
+  }).$type(),
+  interrupt: integer("interrupt", {
+    mode: "boolean"
+  }).notNull().default(false),
+  position: integer("position").notNull(),
+  createdAt: integer("created_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  updatedAt: integer("updated_at", {
+    mode: "timestamp_ms"
+  }).notNull()
+}, (table) => [
+  index("agent_queued_message_thread_position_idx").on(table.threadId, table.position)
+]);
 var agentTokenUsage = sqliteTable("agent_token_usage", {
   id: text("id").primaryKey(),
   threadId: text("thread_id").notNull().references(() => agentThread.id, {
@@ -234,6 +269,7 @@ var ragIngestionLog = sqliteTable("rag_ingestion_log", {
 var agentSchema = {
   agentThread,
   agentMessage,
+  agentQueuedMessage,
   agentToolCall,
   agentTokenUsage,
   agentModelPricing,
@@ -254,6 +290,7 @@ var statements = [
     active_stream_id TEXT,
     default_agent TEXT,
     model TEXT,
+    queue_pause TEXT,
     created_at INTEGER NOT NULL,
     updated_at INTEGER NOT NULL,
     deleted_at INTEGER
@@ -280,6 +317,22 @@ var statements = [
   )`,
   `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,
+    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,
@@ -440,6 +493,11 @@ var additiveColumns = [
     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",
@@ -461,7 +519,7 @@ __name(ensureAgentSchema, "ensureAgentSchema");
 
 // src/drizzle-agent-store.ts
 import { toolCallApprovalFromRow } from "@dudousxd/nestjs-agent-core";
-import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, lte, sql as sql2 } from "drizzle-orm";
+import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, lte, max, min, or, sql as sql2 } from "drizzle-orm";
 var TURN_MESSAGE_COLUMNS = {
   id: agentMessage.id,
   role: agentMessage.role,
@@ -491,6 +549,7 @@ var DrizzleAgentStore = class {
       activeStreamId: null,
       defaultAgent: null,
       model: null,
+      queuePause: null,
       createdAt: now,
       updatedAt: now,
       deletedAt: null
@@ -597,6 +656,8 @@ var DrizzleAgentStore = class {
       activeStreamId: null,
       defaultAgent: source.defaultAgent,
       model: source.model,
+      // A fork is a new conversation: nothing is waiting on it, and nothing is paused.
+      queuePause: null,
       createdAt: now,
       updatedAt: now,
       deletedAt: null
@@ -726,6 +787,124 @@ var DrizzleAgentStore = class {
       updatedAt: /* @__PURE__ */ new Date()
     }).where(and(eq(agentThread.id, threadId), eq(agentThread.transient, true)));
   }
+  /** 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(and(eq(agentThread.id, threadId), isNull(agentThread.deletedAt)));
+    return thread?.activeStreamId ?? null;
+  }
+  /**
+  * One conditional UPDATE, so of two racing claims exactly one changes the row: set the holder to
+  * `runId` only when there is none, it is already `runId`, or it is `replacing`.
+  */
+  async claimActiveStream(threadId, runId, options = {}) {
+    const holders = [
+      isNull(agentThread.activeStreamId),
+      eq(agentThread.activeStreamId, runId),
+      ...options.replacing !== void 0 ? [
+        eq(agentThread.activeStreamId, options.replacing)
+      ] : []
+    ];
+    const claimed = await this.db.update(agentThread).set({
+      activeStreamId: runId
+    }).where(and(eq(agentThread.id, threadId), or(...holders))).returning({
+      id: agentThread.id
+    });
+    return claimed.length > 0;
+  }
+  async releaseActiveStream(threadId, runId) {
+    const released = await this.db.update(agentThread).set({
+      activeStreamId: null
+    }).where(and(eq(agentThread.id, threadId), eq(agentThread.activeStreamId, runId))).returning({
+      id: agentThread.id
+    });
+    return released.length > 0;
+  }
+  async enqueueMessage(input) {
+    const now = /* @__PURE__ */ new Date();
+    const [edge] = await this.db.select({
+      first: min(agentQueuedMessage.position),
+      last: max(agentQueuedMessage.position)
+    }).from(agentQueuedMessage).where(eq(agentQueuedMessage.threadId, input.threadId));
+    const position = input.at === "head" ? (edge?.first ?? 1) - 1 : (edge?.last ?? -1) + 1;
+    const row = {
+      id: crypto.randomUUID(),
+      threadId: input.threadId,
+      actor: input.actor,
+      content: input.content,
+      attachments: input.attachments !== void 0 && input.attachments.length > 0 ? input.attachments : null,
+      agentName: input.agentName ?? null,
+      model: input.model ?? null,
+      pageContext: input.pageContext ?? null,
+      interrupt: input.interrupt === true,
+      position,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.db.insert(agentQueuedMessage).values(row);
+    return toQueuedMessage(row);
+  }
+  async listQueue(threadId) {
+    const rows = await this.db.select().from(agentQueuedMessage).where(eq(agentQueuedMessage.threadId, threadId)).orderBy(asc(agentQueuedMessage.position), asc(agentQueuedMessage.createdAt));
+    return rows.map(toQueuedMessage);
+  }
+  async getQueuedMessage(id) {
+    const [row] = await this.db.select().from(agentQueuedMessage).where(eq(agentQueuedMessage.id, id));
+    return row === void 0 ? null : toQueuedMessage(row);
+  }
+  async updateQueuedMessage(id, patch) {
+    const updates = {
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (patch.content !== void 0) {
+      updates.content = patch.content;
+    }
+    if (patch.attachments !== void 0) {
+      updates.attachments = patch.attachments === null || patch.attachments.length === 0 ? null : patch.attachments;
+    }
+    await this.db.update(agentQueuedMessage).set(updates).where(eq(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) {
+    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)));
+    order.splice(target, 0, moving);
+    for (const [position, message] of order.entries()) {
+      await this.db.update(agentQueuedMessage).set({
+        position
+      }).where(eq(agentQueuedMessage.id, message.id));
+    }
+    return true;
+  }
+  async removeQueuedMessage(id) {
+    const removed = await this.db.delete(agentQueuedMessage).where(eq(agentQueuedMessage.id, id)).returning({
+      id: agentQueuedMessage.id
+    });
+    return removed.length > 0;
+  }
+  async clearQueue(threadId) {
+    const removed = await this.db.delete(agentQueuedMessage).where(eq(agentQueuedMessage.threadId, threadId)).returning({
+      id: agentQueuedMessage.id
+    });
+    return removed.length;
+  }
+  async queuePause(threadId) {
+    const [thread] = await this.db.select({
+      queuePause: agentThread.queuePause
+    }).from(agentThread).where(eq(agentThread.id, threadId));
+    return thread?.queuePause ?? null;
+  }
+  async setQueuePause(threadId, pause) {
+    await this.db.update(agentThread).set({
+      queuePause: pause
+    }).where(eq(agentThread.id, threadId));
+  }
   async setActiveStream(threadId, runId) {
     await this.db.update(agentThread).set({
       activeStreamId: runId
@@ -1049,6 +1228,32 @@ var DrizzleAgentStore = class {
     };
   }
 };
+function toQueuedMessage(row) {
+  return {
+    id: row.id,
+    threadId: row.threadId,
+    actor: row.actor,
+    content: row.content,
+    ...row.attachments !== null && row.attachments.length > 0 ? {
+      attachments: row.attachments
+    } : {},
+    ...row.agentName !== null ? {
+      agentName: row.agentName
+    } : {},
+    ...row.model !== null ? {
+      model: row.model
+    } : {},
+    ...row.pageContext !== null ? {
+      pageContext: row.pageContext
+    } : {},
+    ...row.interrupt ? {
+      interrupt: true
+    } : {},
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toQueuedMessage, "toQueuedMessage");
 
 // src/drizzle-governance-queries.ts
 import { bucketByActor, bucketByModel, bucketByThread, bucketUsageTrend, dayBoundsUtc, rollupThreadUsage, truncateDetailContent } from "@dudousxd/nestjs-agent-core";
@@ -1889,7 +2094,7 @@ var DrizzlePricingStore = class {
 // src/drizzle-rag-ingestion-log.ts
 import { subscribe, unsubscribe } from "diagnostics_channel";
 import { Injectable, Logger } from "@nestjs/common";
-import { and as and5, asc as asc3, count as count2, desc as desc3, eq as eq5, gt, lt, or } from "drizzle-orm";
+import { and as and5, asc as asc3, count as count2, desc as desc3, eq as eq5, gt, lt, or as or2 } from "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;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -2140,7 +2345,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
     if (cursor === void 0) {
       return base;
     }
-    return and5(base, or(lt(ragIngestionLog.updatedAt, cursor.updatedAt), and5(eq5(ragIngestionLog.updatedAt, cursor.updatedAt), gt(ragIngestionLog.documentId, cursor.documentId))));
+    return and5(base, or2(lt(ragIngestionLog.updatedAt, cursor.updatedAt), and5(eq5(ragIngestionLog.updatedAt, cursor.updatedAt), gt(ragIngestionLog.documentId, cursor.documentId))));
   }
   /**
   * Upsert one outcome. Keyed by document id so the row always reflects the *current* state — a
@@ -2317,6 +2522,7 @@ export {
   agentMemory,
   agentMessage,
   agentModelPricing,
+  agentQueuedMessage,
   agentRun,
   agentSchema,
   agentThread,