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

package/README.md

@@ -124,6 +124,23 @@ ALTER TABLE agent_tool_call ADD COLUMN expires_at INTEGER;
 ALTER TABLE agent_tool_call ADD COLUMN remember INTEGER;
 ALTER TABLE agent_tool_call ADD COLUMN decided_via TEXT;
 CREATE INDEX agent_tool_call_message_idx ON agent_tool_call (message_id);
+-- the chat message queue
+ALTER TABLE agent_thread ADD COLUMN queue_pause TEXT;
+CREATE TABLE 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 agent_queued_message_thread_position_idx ON agent_queued_message (thread_id, position);
 ```
 
 The index is not optional on Postgres: `agent_tool_call.message_id` carries a foreign key, and

package/dist/index.cjs

@@ -31,6 +31,7 @@ __export(index_exports, {
   agentMemory: () => agentMemory,
   agentMessage: () => agentMessage,
   agentModelPricing: () => agentModelPricing,
+  agentQueuedMessage: () => agentQueuedMessage,
   agentRun: () => agentRun,
   agentSchema: () => agentSchema,
   agentThread: () => agentThread,
@@ -56,6 +57,10 @@ var agentThread = (0, import_sqlite_core.sqliteTable)("agent_thread", {
   defaultAgent: (0, import_sqlite_core.text)("default_agent"),
   /** The model every turn on this thread runs on unless the send names one; `null` → default. */
   model: (0, import_sqlite_core.text)("model"),
+  /** Why the thread's message queue stopped draining; `null` → it drains. */
+  queuePause: (0, import_sqlite_core.text)("queue_pause", {
+    mode: "json"
+  }).$type(),
   createdAt: (0, import_sqlite_core.integer)("created_at", {
     mode: "timestamp_ms"
   }).notNull(),
@@ -149,6 +154,37 @@ var agentToolCall = (0, import_sqlite_core.sqliteTable)("agent_tool_call", {
 }, (table) => [
   (0, import_sqlite_core.index)("agent_tool_call_message_idx").on(table.messageId)
 ]);
+var agentQueuedMessage = (0, import_sqlite_core.sqliteTable)("agent_queued_message", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  threadId: (0, import_sqlite_core.text)("thread_id").notNull().references(() => agentThread.id, {
+    onDelete: "cascade"
+  }),
+  /** Who queued it — the turn it starts runs as this actor. */
+  actor: (0, import_sqlite_core.text)("actor", {
+    mode: "json"
+  }).$type().notNull(),
+  content: (0, import_sqlite_core.text)("content").notNull(),
+  attachments: (0, import_sqlite_core.text)("attachments", {
+    mode: "json"
+  }).$type(),
+  agentName: (0, import_sqlite_core.text)("agent_name"),
+  model: (0, import_sqlite_core.text)("model"),
+  pageContext: (0, import_sqlite_core.text)("page_context", {
+    mode: "json"
+  }).$type(),
+  interrupt: (0, import_sqlite_core.integer)("interrupt", {
+    mode: "boolean"
+  }).notNull().default(false),
+  position: (0, import_sqlite_core.integer)("position").notNull(),
+  createdAt: (0, import_sqlite_core.integer)("created_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  updatedAt: (0, import_sqlite_core.integer)("updated_at", {
+    mode: "timestamp_ms"
+  }).notNull()
+}, (table) => [
+  (0, import_sqlite_core.index)("agent_queued_message_thread_position_idx").on(table.threadId, table.position)
+]);
 var agentTokenUsage = (0, import_sqlite_core.sqliteTable)("agent_token_usage", {
   id: (0, import_sqlite_core.text)("id").primaryKey(),
   threadId: (0, import_sqlite_core.text)("thread_id").notNull().references(() => agentThread.id, {
@@ -274,6 +310,7 @@ var ragIngestionLog = (0, import_sqlite_core.sqliteTable)("rag_ingestion_log", {
 var agentSchema = {
   agentThread,
   agentMessage,
+  agentQueuedMessage,
   agentToolCall,
   agentTokenUsage,
   agentModelPricing,
@@ -294,6 +331,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
@@ -320,6 +358,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,
@@ -480,6 +534,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",
@@ -531,6 +590,7 @@ var DrizzleAgentStore = class {
       activeStreamId: null,
       defaultAgent: null,
       model: null,
+      queuePause: null,
       createdAt: now,
       updatedAt: now,
       deletedAt: null
@@ -637,6 +697,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
@@ -766,6 +828,127 @@ var DrizzleAgentStore = class {
       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)));
   }
+  /** 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)));
+    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 = [
+      (0, import_drizzle_orm2.isNull)(agentThread.activeStreamId),
+      (0, import_drizzle_orm2.eq)(agentThread.activeStreamId, runId),
+      ...options.replacing !== void 0 ? [
+        (0, import_drizzle_orm2.eq)(agentThread.activeStreamId, options.replacing)
+      ] : []
+    ];
+    const claimed = await this.db.update(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;
+  }
+  async releaseActiveStream(threadId, runId) {
+    const released = await this.db.update(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;
+  }
+  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));
+    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((0, import_drizzle_orm2.eq)(agentQueuedMessage.threadId, threadId)).orderBy((0, import_drizzle_orm2.asc)(agentQueuedMessage.position), (0, import_drizzle_orm2.asc)(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));
+    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;
+    }
+    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));
+    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((0, import_drizzle_orm2.eq)(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;
+  }
+  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;
+  }
+  async queuePause(threadId) {
+    const [thread] = await this.db.select({
+      queuePause: agentThread.queuePause
+    }).from(agentThread).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+    return thread?.queuePause ?? null;
+  }
+  async setQueuePause(threadId, pause) {
+    await this.db.update(agentThread).set({
+      queuePause: pause
+    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+  }
   async setActiveStream(threadId, runId) {
     await this.db.update(agentThread).set({
       activeStreamId: runId
@@ -1089,6 +1272,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
 var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
@@ -2358,6 +2567,7 @@ DrizzleAgentStoreModule = _ts_decorate2([
   agentMemory,
   agentMessage,
   agentModelPricing,
+  agentQueuedMessage,
   agentRun,
   agentSchema,
   agentThread,