@dudousxd/nestjs-agent-store-drizzle 0.30.0 → 0.32.0

package/dist/index.js

@@ -249,6 +249,12 @@ var agentRun = sqliteTable("agent_run", {
   agentName: text("agent_name"),
   status: text("status").$type().notNull(),
   durationMs: integer("duration_ms"),
+  /** Turn start to the first `text` frame; null for a run that streamed none or did not complete. */
+  ttftMs: integer("ttft_ms"),
+  /** The run's known spend (the sum of its model calls with a known cost); null when none had one. */
+  costUsd: real("cost_usd"),
+  /** The model the run's last model call resolved to. */
+  modelId: text("model_id"),
   errorCode: text("error_code"),
   errorMessage: text("error_message"),
   retries: integer("retries").notNull().default(0),
@@ -381,6 +387,94 @@ var agentActionProposal = sqliteTable("agent_action_proposal", {
   uniqueIndex("agent_action_proposal_outcome_idx").on(table.outcomeIdKey),
   index("agent_action_proposal_scope_idx").on(table.scopeKey, table.createdAt, table.id)
 ]);
+var agentPoppyConversation = sqliteTable("agent_poppy_conversation", {
+  id: text("id").primaryKey(),
+  clientId: text("client_id").notNull(),
+  userId: text("user_id").notNull(),
+  accountRef: text("account_ref"),
+  agentName: text("agent_name").notNull(),
+  threadId: text("thread_id"),
+  parentId: text("parent_id"),
+  openDirectId: text("open_direct_id"),
+  status: text("status").notNull(),
+  responder: text("responder").notNull(),
+  context: text("context"),
+  activeRunId: text("active_run_id"),
+  turnSeq: integer("turn_seq").notNull(),
+  grantInfo: text("grant_info"),
+  readerHolder: text("reader_holder"),
+  readerUntil: integer("reader_until"),
+  prunedSeq: integer("pruned_seq").notNull(),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+});
+var agentPoppyEvent = sqliteTable("agent_poppy_event", {
+  conversationId: text("conversation_id").notNull(),
+  seq: integer("seq").notNull(),
+  id: text("id").notNull(),
+  type: text("type").notNull(),
+  event: text("event").notNull(),
+  eventKey: text("event_key"),
+  createdAt: integer("created_at").notNull()
+}, (table) => [
+  primaryKey({
+    columns: [
+      table.conversationId,
+      table.seq
+    ]
+  }),
+  uniqueIndex("agent_poppy_event_key_idx").on(table.conversationId, table.eventKey),
+  index("agent_poppy_event_id_idx").on(table.conversationId, table.id)
+]);
+var agentPoppyMessage = sqliteTable("agent_poppy_message", {
+  owner: text("owner").notNull(),
+  messageId: text("message_id").notNull(),
+  fingerprint: text("fingerprint").notNull(),
+  conversationId: text("conversation_id").notNull(),
+  response: text("response").notNull(),
+  createdAt: integer("created_at").notNull()
+}, (table) => [
+  primaryKey({
+    columns: [
+      table.owner,
+      table.messageId
+    ]
+  })
+]);
+var agentPoppyConnection = sqliteTable("agent_poppy_connection", {
+  owner: text("owner").notNull(),
+  issuer: text("issuer").notNull(),
+  domain: text("domain").notNull(),
+  organization: text("organization").notNull(),
+  scope: text("scope").notNull(),
+  status: text("status").notNull(),
+  state: text("state").notNull(),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull()
+}, (table) => [
+  primaryKey({
+    columns: [
+      table.owner,
+      table.issuer
+    ]
+  })
+]);
+var agentPoppyConnect = sqliteTable("agent_poppy_connect", {
+  id: text("id").primaryKey(),
+  owner: text("owner").notNull(),
+  domain: text("domain").notNull(),
+  issuer: text("issuer").notNull(),
+  organization: text("organization").notNull(),
+  scope: text("scope").notNull(),
+  actor: text("actor"),
+  threadId: text("thread_id"),
+  runId: text("run_id"),
+  toolCallId: text("tool_call_id"),
+  flow: text("flow"),
+  status: text("status").notNull(),
+  expiresAt: integer("expires_at").notNull(),
+  createdAt: integer("created_at").notNull()
+});
 var agentSchema = {
   agentActionProposal,
   agentThread,
@@ -395,7 +489,12 @@ var agentSchema = {
   ragIngestionLog,
   agentConfirmToken,
   agentChannelState,
-  agentStreamFrame
+  agentStreamFrame,
+  agentPoppyConversation,
+  agentPoppyEvent,
+  agentPoppyMessage,
+  agentPoppyConnection,
+  agentPoppyConnect
 };
 
 // src/ensure-schema.ts
@@ -588,6 +687,12 @@ var agentRun2 = mysqlTable("agent_run", {
   agentName: key("agent_name"),
   status: key("status").$type().notNull(),
   durationMs: int("duration_ms"),
+  /** Turn start to the first `text` frame; null for a run that streamed none or did not complete. */
+  ttftMs: int("ttft_ms"),
+  /** The run's known spend (the sum of its model calls with a known cost); null when none had one. */
+  costUsd: double("cost_usd"),
+  /** The model the run's last model call resolved to. */
+  modelId: key("model_id"),
   errorCode: key("error_code"),
   errorMessage: longtext("error_message"),
   retries: int("retries").notNull().default(0),
@@ -717,6 +822,124 @@ var agentActionProposal2 = mysqlTable("agent_action_proposal", {
   uniqueIndex2("agent_action_proposal_outcome_idx").on(table.outcomeIdKey),
   index2("agent_action_proposal_scope_idx").on(table.scopeKey, table.createdAt, table.id)
 ]);
+var agentPoppyConversation2 = mysqlTable("agent_poppy_conversation", {
+  id: key("id").primaryKey(),
+  clientId: varchar("client_id", {
+    length: 2048
+  }).notNull(),
+  userId: key("user_id").notNull(),
+  accountRef: key("account_ref"),
+  agentName: key("agent_name").notNull(),
+  threadId: key("thread_id"),
+  parentId: key("parent_id"),
+  openDirectId: key("open_direct_id"),
+  status: key("status").notNull(),
+  responder: key("responder").notNull(),
+  context: longtext("context"),
+  activeRunId: key("active_run_id"),
+  turnSeq: bigint("turn_seq", {
+    mode: "number"
+  }).notNull(),
+  grantInfo: longtext("grant_info"),
+  readerHolder: key("reader_holder"),
+  readerUntil: bigint("reader_until", {
+    mode: "number"
+  }),
+  prunedSeq: bigint("pruned_seq", {
+    mode: "number"
+  }).notNull(),
+  createdAt: bigint("created_at", {
+    mode: "number"
+  }).notNull(),
+  updatedAt: bigint("updated_at", {
+    mode: "number"
+  }).notNull()
+});
+var agentPoppyEvent2 = mysqlTable("agent_poppy_event", {
+  conversationId: key("conversation_id").notNull(),
+  seq: bigint("seq", {
+    mode: "number"
+  }).notNull(),
+  id: key("id").notNull(),
+  type: key("type").notNull(),
+  event: longtext("event").notNull(),
+  eventKey: key("event_key"),
+  createdAt: bigint("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  primaryKey2({
+    columns: [
+      table.conversationId,
+      table.seq
+    ]
+  }),
+  uniqueIndex2("agent_poppy_event_key_idx").on(table.conversationId, table.eventKey),
+  index2("agent_poppy_event_id_idx").on(table.conversationId, table.id)
+]);
+var agentPoppyMessage2 = mysqlTable("agent_poppy_message", {
+  owner: key("owner").notNull(),
+  messageId: key("message_id").notNull(),
+  fingerprint: key("fingerprint").notNull(),
+  conversationId: key("conversation_id").notNull(),
+  response: longtext("response").notNull(),
+  createdAt: bigint("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  primaryKey2({
+    columns: [
+      table.owner,
+      table.messageId
+    ]
+  })
+]);
+var agentPoppyConnection2 = mysqlTable("agent_poppy_connection", {
+  owner: key("owner").notNull(),
+  issuer: varchar("issuer", {
+    length: 512
+  }).notNull(),
+  domain: key("domain").notNull(),
+  organization: key("organization").notNull(),
+  scope: longtext("scope").notNull(),
+  status: key("status").notNull(),
+  state: longtext("state").notNull(),
+  createdAt: bigint("created_at", {
+    mode: "number"
+  }).notNull(),
+  updatedAt: bigint("updated_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  primaryKey2({
+    columns: [
+      table.owner,
+      table.issuer
+    ]
+  })
+]);
+var agentPoppyConnect2 = mysqlTable("agent_poppy_connect", {
+  id: key("id").primaryKey(),
+  owner: key("owner").notNull(),
+  domain: key("domain").notNull(),
+  issuer: varchar("issuer", {
+    length: 512
+  }).notNull(),
+  organization: key("organization").notNull(),
+  scope: longtext("scope").notNull(),
+  actor: longtext("actor"),
+  threadId: key("thread_id"),
+  runId: key("run_id"),
+  toolCallId: key("tool_call_id"),
+  flow: longtext("flow"),
+  status: key("status").notNull(),
+  expiresAt: bigint("expires_at", {
+    mode: "number"
+  }).notNull(),
+  createdAt: bigint("created_at", {
+    mode: "number"
+  }).notNull()
+});
 var mysqlAgentSchema = {
   agentActionProposal: agentActionProposal2,
   agentThread: agentThread2,
@@ -731,7 +954,12 @@ var mysqlAgentSchema = {
   ragIngestionLog: ragIngestionLog2,
   agentConfirmToken: agentConfirmToken2,
   agentChannelState: agentChannelState2,
-  agentStreamFrame: agentStreamFrame2
+  agentStreamFrame: agentStreamFrame2,
+  agentPoppyConversation: agentPoppyConversation2,
+  agentPoppyEvent: agentPoppyEvent2,
+  agentPoppyMessage: agentPoppyMessage2,
+  agentPoppyConnection: agentPoppyConnection2,
+  agentPoppyConnect: agentPoppyConnect2
 };
 
 // src/schema-pg.ts
@@ -911,6 +1139,12 @@ var agentRun3 = pgTable("agent_run", {
   agentName: text2("agent_name"),
   status: text2("status").$type().notNull(),
   durationMs: integer2("duration_ms"),
+  /** Turn start to the first `text` frame; null for a run that streamed none or did not complete. */
+  ttftMs: integer2("ttft_ms"),
+  /** The run's known spend (the sum of its model calls with a known cost); null when none had one. */
+  costUsd: doublePrecision("cost_usd"),
+  /** The model the run's last model call resolved to. */
+  modelId: text2("model_id"),
   errorCode: text2("error_code"),
   errorMessage: text2("error_message"),
   retries: integer2("retries").notNull().default(0),
@@ -1038,6 +1272,118 @@ var agentActionProposal3 = pgTable("agent_action_proposal", {
   uniqueIndex3("agent_action_proposal_outcome_idx").on(table.outcomeIdKey),
   index3("agent_action_proposal_scope_idx").on(table.scopeKey, table.createdAt, table.id)
 ]);
+var agentPoppyConversation3 = pgTable("agent_poppy_conversation", {
+  id: text2("id").primaryKey(),
+  clientId: text2("client_id").notNull(),
+  userId: text2("user_id").notNull(),
+  accountRef: text2("account_ref"),
+  agentName: text2("agent_name").notNull(),
+  threadId: text2("thread_id"),
+  parentId: text2("parent_id"),
+  openDirectId: text2("open_direct_id"),
+  status: text2("status").notNull(),
+  responder: text2("responder").notNull(),
+  context: text2("context"),
+  activeRunId: text2("active_run_id"),
+  turnSeq: bigint2("turn_seq", {
+    mode: "number"
+  }).notNull(),
+  grantInfo: text2("grant_info"),
+  readerHolder: text2("reader_holder"),
+  readerUntil: bigint2("reader_until", {
+    mode: "number"
+  }),
+  prunedSeq: bigint2("pruned_seq", {
+    mode: "number"
+  }).notNull(),
+  createdAt: bigint2("created_at", {
+    mode: "number"
+  }).notNull(),
+  updatedAt: bigint2("updated_at", {
+    mode: "number"
+  }).notNull()
+});
+var agentPoppyEvent3 = pgTable("agent_poppy_event", {
+  conversationId: text2("conversation_id").notNull(),
+  seq: bigint2("seq", {
+    mode: "number"
+  }).notNull(),
+  id: text2("id").notNull(),
+  type: text2("type").notNull(),
+  event: text2("event").notNull(),
+  eventKey: text2("event_key"),
+  createdAt: bigint2("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  primaryKey3({
+    columns: [
+      table.conversationId,
+      table.seq
+    ]
+  }),
+  uniqueIndex3("agent_poppy_event_key_idx").on(table.conversationId, table.eventKey),
+  index3("agent_poppy_event_id_idx").on(table.conversationId, table.id)
+]);
+var agentPoppyMessage3 = pgTable("agent_poppy_message", {
+  owner: text2("owner").notNull(),
+  messageId: text2("message_id").notNull(),
+  fingerprint: text2("fingerprint").notNull(),
+  conversationId: text2("conversation_id").notNull(),
+  response: text2("response").notNull(),
+  createdAt: bigint2("created_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  primaryKey3({
+    columns: [
+      table.owner,
+      table.messageId
+    ]
+  })
+]);
+var agentPoppyConnection3 = pgTable("agent_poppy_connection", {
+  owner: text2("owner").notNull(),
+  issuer: text2("issuer").notNull(),
+  domain: text2("domain").notNull(),
+  organization: text2("organization").notNull(),
+  scope: text2("scope").notNull(),
+  status: text2("status").notNull(),
+  state: text2("state").notNull(),
+  createdAt: bigint2("created_at", {
+    mode: "number"
+  }).notNull(),
+  updatedAt: bigint2("updated_at", {
+    mode: "number"
+  }).notNull()
+}, (table) => [
+  primaryKey3({
+    columns: [
+      table.owner,
+      table.issuer
+    ]
+  })
+]);
+var agentPoppyConnect3 = pgTable("agent_poppy_connect", {
+  id: text2("id").primaryKey(),
+  owner: text2("owner").notNull(),
+  domain: text2("domain").notNull(),
+  issuer: text2("issuer").notNull(),
+  organization: text2("organization").notNull(),
+  scope: text2("scope").notNull(),
+  actor: text2("actor"),
+  threadId: text2("thread_id"),
+  runId: text2("run_id"),
+  toolCallId: text2("tool_call_id"),
+  flow: text2("flow"),
+  status: text2("status").notNull(),
+  expiresAt: bigint2("expires_at", {
+    mode: "number"
+  }).notNull(),
+  createdAt: bigint2("created_at", {
+    mode: "number"
+  }).notNull()
+});
 var pgAgentSchema = {
   agentActionProposal: agentActionProposal3,
   agentThread: agentThread3,
@@ -1052,7 +1398,12 @@ var pgAgentSchema = {
   ragIngestionLog: ragIngestionLog3,
   agentConfirmToken: agentConfirmToken3,
   agentChannelState: agentChannelState3,
-  agentStreamFrame: agentStreamFrame3
+  agentStreamFrame: agentStreamFrame3,
+  agentPoppyConversation: agentPoppyConversation3,
+  agentPoppyEvent: agentPoppyEvent3,
+  agentPoppyMessage: agentPoppyMessage3,
+  agentPoppyConnection: agentPoppyConnection3,
+  agentPoppyConnect: agentPoppyConnect3
 };
 
 // src/dialect.ts
@@ -2409,6 +2760,9 @@ var DrizzleAgentStore = class {
       agentName: run.agentName ?? null,
       status: "running",
       durationMs: null,
+      ttftMs: null,
+      costUsd: null,
+      modelId: null,
       errorCode: null,
       errorMessage: null,
       retries: 0,
@@ -2428,6 +2782,15 @@ var DrizzleAgentStore = class {
     if (end.durationMs !== void 0) {
       updates.durationMs = end.durationMs;
     }
+    if (end.ttftMs !== void 0) {
+      updates.ttftMs = end.ttftMs;
+    }
+    if (end.costUsd !== void 0) {
+      updates.costUsd = end.costUsd;
+    }
+    if (end.modelId !== void 0) {
+      updates.modelId = end.modelId;
+    }
     if (end.errorCode !== void 0) {
       updates.errorCode = end.errorCode;
     }
@@ -2913,6 +3276,11 @@ function toRecentRunRow(run) {
     agentName: run.agentName ?? null,
     status: run.status,
     durationMs: run.durationMs ?? null,
+    ttftMs: run.ttftMs ?? null,
+    // MySQL's DOUBLE and Postgres' double precision come back as numbers; a driver that hands a
+    // decimal back as a string is normalized here so the SPI row is always a number.
+    costUsd: run.costUsd == null ? null : Number(run.costUsd),
+    modelId: run.modelId ?? null,
     errorCode: run.errorCode ?? null,
     errorMessage: run.errorMessage ?? null,
     retries: run.retries,
@@ -3116,6 +3484,7 @@ var DrizzleGovernanceQueries = class {
     let failed = 0;
     let retries = 0;
     const settledDurationsMs = [];
+    const ttftsMs = [];
     for (const run of runs) {
       if (run.status === "completed") {
         completed += 1;
@@ -3126,8 +3495,12 @@ var DrizzleGovernanceQueries = class {
       if ((run.status === "completed" || run.status === "failed") && run.durationMs != null) {
         settledDurationsMs.push(run.durationMs);
       }
+      if (run.status === "completed" && run.parentRunId == null && run.ttftMs != null) {
+        ttftsMs.push(run.ttftMs);
+      }
     }
     settledDurationsMs.sort((left, right) => left - right);
+    ttftsMs.sort((left, right) => left - right);
     return {
       runs: runs.length,
       completed,
@@ -3135,7 +3508,9 @@ var DrizzleGovernanceQueries = class {
       successRate: runs.length === 0 ? 0 : completed / runs.length,
       retries,
       durationP50Ms: percentileMs(settledDurationsMs, 0.5),
-      durationP95Ms: percentileMs(settledDurationsMs, 0.95)
+      durationP95Ms: percentileMs(settledDurationsMs, 0.95),
+      ttftP50Ms: percentileMs(ttftsMs, 0.5),
+      ttftP95Ms: percentileMs(ttftsMs, 0.95)
     };
   }
   async runsByAgent(range) {
@@ -3883,14 +4258,392 @@ var DrizzleChannelStore = class {
   }
 };
 
+// src/drizzle-poppy-store.ts
+import { newEventId } from "@dudousxd/nestjs-agent-core";
+import { and as and8, desc as desc3, eq as eq9, gt as gt4, isNull as isNull4, lt as lt3, lte as lte5, or as or3 } from "drizzle-orm";
+var MAX_APPEND_ATTEMPTS = 50;
+var sleep = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
+var nullable = /* @__PURE__ */ __name((value) => value == null ? null : String(value), "nullable");
+function toInt(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") return Number.parseInt(value, 10) || 0;
+  return 0;
+}
+__name(toInt, "toInt");
+var PATCH_COLUMNS = {
+  accountRef: "accountRef",
+  threadId: "threadId",
+  openDirectId: "openDirectId",
+  status: "status",
+  responder: "responder",
+  context: "context",
+  activeRunId: "activeRunId",
+  turnSeq: "turnSeq",
+  grant: "grantInfo",
+  prunedSeq: "prunedSeq"
+};
+var DrizzlePoppyStore = class {
+  static {
+    __name(this, "DrizzlePoppyStore");
+  }
+  db;
+  dialect;
+  t;
+  constructor(db) {
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
+  }
+  async createConversation(record) {
+    await this.db.insert(this.t.agentPoppyConversation).values({
+      id: record.id,
+      clientId: record.clientId,
+      userId: record.userId,
+      accountRef: record.accountRef,
+      agentName: record.agentName,
+      threadId: record.threadId,
+      parentId: record.parentId,
+      openDirectId: record.openDirectId,
+      status: record.status,
+      responder: record.responder,
+      context: JSON.stringify(record.context),
+      activeRunId: record.activeRunId,
+      turnSeq: record.turnSeq,
+      grantInfo: record.grant === null ? null : JSON.stringify(record.grant),
+      readerHolder: null,
+      readerUntil: null,
+      prunedSeq: record.prunedSeq,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt
+    });
+  }
+  async getConversation(id) {
+    const table = this.t.agentPoppyConversation;
+    const [row] = await this.db.select().from(table).where(eq9(table.id, id)).limit(1);
+    if (!row) return null;
+    return {
+      id: row.id,
+      clientId: row.clientId,
+      userId: row.userId,
+      accountRef: nullable(row.accountRef),
+      agentName: row.agentName,
+      threadId: nullable(row.threadId),
+      parentId: nullable(row.parentId),
+      openDirectId: nullable(row.openDirectId),
+      status: row.status,
+      responder: row.responder,
+      context: row.context == null ? {} : JSON.parse(row.context),
+      activeRunId: nullable(row.activeRunId),
+      turnSeq: toInt(row.turnSeq),
+      grant: row.grantInfo == null ? null : JSON.parse(row.grantInfo),
+      prunedSeq: toInt(row.prunedSeq),
+      createdAt: toInt(row.createdAt),
+      updatedAt: toInt(row.updatedAt)
+    };
+  }
+  async updateConversation(id, patch) {
+    const table = this.t.agentPoppyConversation;
+    const set = {
+      updatedAt: Date.now()
+    };
+    for (const [key2, column] of Object.entries(PATCH_COLUMNS)) {
+      const value = patch[key2];
+      if (value === void 0) continue;
+      set[column] = key2 === "context" || key2 === "grant" && value !== null ? JSON.stringify(value) : value;
+    }
+    await this.db.update(table).set(set).where(eq9(table.id, id));
+  }
+  async appendEvent(conversationId, body, options = {}) {
+    const table = this.t.agentPoppyEvent;
+    for (let attempt = 1; ; attempt++) {
+      if (options.key !== void 0) {
+        const [existing] = await this.db.select({
+          seq: table.seq,
+          event: table.event
+        }).from(table).where(and8(eq9(table.conversationId, conversationId), eq9(table.eventKey, options.key))).limit(1);
+        if (existing) {
+          return {
+            event: {
+              seq: toInt(existing.seq),
+              event: JSON.parse(existing.event)
+            },
+            created: false
+          };
+        }
+      }
+      const seq = await this.lastSeq(conversationId) + 1;
+      const now = Date.now();
+      const stored = {
+        seq,
+        event: {
+          id: newEventId(seq),
+          created_at: new Date(now).toISOString(),
+          ...body
+        }
+      };
+      let inserted = false;
+      try {
+        inserted = await this.insertIgnore(table, {
+          conversationId,
+          seq,
+          id: stored.event.id,
+          type: body.type,
+          event: JSON.stringify(stored.event),
+          eventKey: options.key ?? null,
+          createdAt: now
+        });
+      } catch (error) {
+        if (!isUniqueViolation(error)) throw error;
+      }
+      if (inserted) return {
+        event: stored,
+        created: true
+      };
+      if (attempt >= MAX_APPEND_ATTEMPTS) {
+        throw new Error(`poppy: could not append to ${conversationId} after ${attempt} attempts`);
+      }
+      await sleep(Math.random() * Math.min(attempt, 10) * 2);
+    }
+  }
+  /** The last position taken: the last event's, or — every event pruned — the pruned floor. */
+  async lastSeq(conversationId) {
+    const table = this.t.agentPoppyEvent;
+    const [last] = await this.db.select({
+      seq: table.seq
+    }).from(table).where(eq9(table.conversationId, conversationId)).orderBy(desc3(table.seq)).limit(1);
+    if (last) return toInt(last.seq);
+    const conversations = this.t.agentPoppyConversation;
+    const [conversation] = await this.db.select({
+      prunedSeq: conversations.prunedSeq
+    }).from(conversations).where(eq9(conversations.id, conversationId)).limit(1);
+    return toInt(conversation?.prunedSeq);
+  }
+  async listEvents(conversationId, afterSeq, limit) {
+    const table = this.t.agentPoppyEvent;
+    const rows = await this.db.select({
+      seq: table.seq,
+      event: table.event
+    }).from(table).where(and8(eq9(table.conversationId, conversationId), gt4(table.seq, afterSeq))).orderBy(table.seq).limit(limit);
+    return rows.map((row) => ({
+      seq: toInt(row.seq),
+      event: JSON.parse(row.event)
+    }));
+  }
+  async findEventSeq(conversationId, eventId) {
+    const table = this.t.agentPoppyEvent;
+    const [row] = await this.db.select({
+      seq: table.seq
+    }).from(table).where(and8(eq9(table.conversationId, conversationId), eq9(table.id, eventId))).limit(1);
+    return row ? toInt(row.seq) : null;
+  }
+  async pruneEvents(conversationId, before) {
+    const table = this.t.agentPoppyEvent;
+    const [last] = await this.db.select({
+      seq: table.seq
+    }).from(table).where(eq9(table.conversationId, conversationId)).orderBy(desc3(table.seq)).limit(1);
+    if (!last) return;
+    const [dropped] = await this.db.select({
+      seq: table.seq
+    }).from(table).where(and8(eq9(table.conversationId, conversationId), lt3(table.createdAt, before), lt3(table.seq, toInt(last.seq)))).orderBy(desc3(table.seq)).limit(1);
+    if (!dropped) return;
+    const upTo = toInt(dropped.seq);
+    const conversations = this.t.agentPoppyConversation;
+    await this.db.update(conversations).set({
+      prunedSeq: upTo
+    }).where(and8(eq9(conversations.id, conversationId), lt3(conversations.prunedSeq, upTo)));
+    await this.db.delete(table).where(and8(eq9(table.conversationId, conversationId), lte5(table.seq, upTo)));
+  }
+  async claimMessage(owner, messageId, receipt) {
+    const table = this.t.agentPoppyMessage;
+    for (let attempt = 1; ; attempt++) {
+      const inserted = await this.insertIgnore(table, {
+        owner,
+        messageId,
+        fingerprint: receipt.fingerprint,
+        conversationId: receipt.conversationId,
+        response: JSON.stringify(receipt.response),
+        createdAt: Date.now()
+      });
+      if (inserted) return {
+        status: "claimed"
+      };
+      const [row] = await this.db.select().from(table).where(and8(eq9(table.owner, owner), eq9(table.messageId, messageId))).limit(1);
+      if (row) {
+        return {
+          status: "existing",
+          fingerprint: row.fingerprint,
+          conversationId: row.conversationId,
+          response: JSON.parse(row.response)
+        };
+      }
+      if (attempt >= 5) throw new Error(`poppy: could not claim message ${messageId}`);
+    }
+  }
+  async releaseMessage(owner, messageId) {
+    const table = this.t.agentPoppyMessage;
+    await this.db.delete(table).where(and8(eq9(table.owner, owner), eq9(table.messageId, messageId)));
+  }
+  async leaseReader(conversationId, holder, ttlMs) {
+    const table = this.t.agentPoppyConversation;
+    const now = Date.now();
+    const taken = await affectedRows(this.dialect, this.db.update(table).set({
+      readerHolder: holder,
+      readerUntil: now + ttlMs
+    }).where(and8(eq9(table.id, conversationId), or3(isNull4(table.readerHolder), eq9(table.readerHolder, holder), lte5(table.readerUntil, now)))), table.id);
+    if (taken === 1) return true;
+    if (this.dialect !== "mysql") return false;
+    const [row] = await this.db.select({
+      holder: table.readerHolder
+    }).from(table).where(eq9(table.id, conversationId)).limit(1);
+    return row?.holder === holder;
+  }
+  async releaseReader(conversationId, holder) {
+    const table = this.t.agentPoppyConversation;
+    await this.db.update(table).set({
+      readerHolder: null,
+      readerUntil: null
+    }).where(and8(eq9(table.id, conversationId), eq9(table.readerHolder, holder)));
+  }
+  /** Insert `row`, skipping it on any duplicate key. `true` when it went in. */
+  async insertIgnore(table, row) {
+    if (this.dialect === "mysql") {
+      const insert = this.db.insert(table);
+      return mysqlAffectedRows(await insert.ignore().values(row)) === 1;
+    }
+    const statement = this.db.insert(table).values(row).onConflictDoNothing();
+    return await affectedRows(this.dialect, statement, table.createdAt) === 1;
+  }
+};
+
+// src/drizzle-poppy-connection-store.ts
+import { and as and9, asc as asc5, eq as eq10 } from "drizzle-orm";
+var nullable2 = /* @__PURE__ */ __name((value) => value == null ? null : String(value), "nullable");
+var toInt2 = /* @__PURE__ */ __name((value) => typeof value === "number" ? value : Number(value ?? 0), "toInt");
+var DrizzlePoppyConnectionStore = class {
+  static {
+    __name(this, "DrizzlePoppyConnectionStore");
+  }
+  db;
+  dialect;
+  t;
+  constructor(db) {
+    this.dialect = agentDialectOf(db);
+    this.t = agentTablesFor(this.dialect);
+    this.db = asBuilder(db);
+  }
+  async listConnections(owner) {
+    const table = this.t.agentPoppyConnection;
+    const rows = await this.db.select().from(table).where(eq10(table.owner, owner)).orderBy(asc5(table.domain), asc5(table.issuer));
+    return rows.map(toConnection);
+  }
+  async getConnection(owner, issuer) {
+    const table = this.t.agentPoppyConnection;
+    const [row] = await this.db.select().from(table).where(and9(eq10(table.owner, owner), eq10(table.issuer, issuer))).limit(1);
+    return row ? toConnection(row) : null;
+  }
+  async saveConnection(record) {
+    const table = this.t.agentPoppyConnection;
+    const columns = {
+      domain: record.domain,
+      organization: record.organization,
+      scope: record.scope,
+      status: record.status,
+      state: record.state,
+      updatedAt: record.updatedAt
+    };
+    await upsert(this.dialect, this.db.insert(table).values({
+      owner: record.owner,
+      issuer: record.issuer,
+      createdAt: record.createdAt,
+      ...columns
+    }), [
+      table.owner,
+      table.issuer
+    ], columns);
+  }
+  async deleteConnection(owner, issuer) {
+    const table = this.t.agentPoppyConnection;
+    await this.db.delete(table).where(and9(eq10(table.owner, owner), eq10(table.issuer, issuer)));
+  }
+  async createPending(record) {
+    const table = this.t.agentPoppyConnect;
+    const row = {
+      id: record.id,
+      owner: record.owner,
+      domain: record.domain,
+      issuer: record.issuer,
+      organization: record.organization,
+      scope: record.scope,
+      actor: record.actor === null ? null : JSON.stringify(record.actor),
+      threadId: record.threadId,
+      runId: record.runId,
+      toolCallId: record.toolCallId,
+      flow: record.flow,
+      status: record.status,
+      expiresAt: record.expiresAt,
+      createdAt: record.createdAt
+    };
+    if (this.dialect === "mysql") {
+      const insert = this.db.insert(table);
+      await insert.ignore().values(row);
+      return;
+    }
+    await this.db.insert(table).values(row).onConflictDoNothing();
+  }
+  async getPending(id) {
+    const table = this.t.agentPoppyConnect;
+    const [row] = await this.db.select().from(table).where(eq10(table.id, id)).limit(1);
+    if (!row) return null;
+    return {
+      id: row.id,
+      owner: row.owner,
+      domain: row.domain,
+      issuer: row.issuer,
+      organization: row.organization,
+      scope: row.scope ?? "",
+      actor: row.actor == null ? null : JSON.parse(row.actor),
+      threadId: nullable2(row.threadId),
+      runId: nullable2(row.runId),
+      toolCallId: nullable2(row.toolCallId),
+      flow: nullable2(row.flow),
+      status: row.status,
+      expiresAt: toInt2(row.expiresAt),
+      createdAt: toInt2(row.createdAt)
+    };
+  }
+  async updatePending(id, patch) {
+    const set = {};
+    if (patch.flow !== void 0) set.flow = patch.flow;
+    if (patch.status !== void 0) set.status = patch.status;
+    if (Object.keys(set).length === 0) return;
+    const table = this.t.agentPoppyConnect;
+    await this.db.update(table).set(set).where(eq10(table.id, id));
+  }
+};
+function toConnection(row) {
+  return {
+    owner: row.owner,
+    issuer: row.issuer,
+    domain: row.domain,
+    organization: row.organization,
+    scope: row.scope ?? "",
+    status: row.status,
+    state: row.state,
+    createdAt: toInt2(row.createdAt),
+    updatedAt: toInt2(row.updatedAt)
+  };
+}
+__name(toConnection, "toConnection");
+
 // src/drizzle-rag-ingestion-log.ts
 import { subscribe, unsubscribe } from "diagnostics_channel";
 import { Injectable, Logger } from "@nestjs/common";
-import { and as and8, asc as asc5, count as count2, desc as desc3, eq as eq9, gt as gt4, lt as lt3, or as or3 } from "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;
+import { and as and10, asc as asc6, count as count2, desc as desc4, eq as eq11, gt as gt5, lt as lt4, or as or4 } from "drizzle-orm";
+function _ts_decorate(decorators, target, key2, desc5) {
+  var c = arguments.length, r = c < 3 ? target : desc5 === null ? desc5 = Object.getOwnPropertyDescriptor(target, key2) : desc5, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
-    r = Reflect.decorate(decorators, target, key2, desc4);
+    r = Reflect.decorate(decorators, target, key2, desc5);
   } else {
     for (var i = decorators.length - 1; i >= 0; i--) {
       if (d = decorators[i]) {
@@ -3934,8 +4687,8 @@ function num(value) {
 }
 __name(num, "num");
 var RAG_INGESTION_LOG_PAGE_ORDER = [
-  desc3(ragIngestionLog.updatedAt),
-  asc5(ragIngestionLog.documentId)
+  desc4(ragIngestionLog.updatedAt),
+  asc6(ragIngestionLog.documentId)
 ];
 var DEFAULT_PAGE_SIZE = 200;
 var DEFAULT_BATCH_SIZE = 200;
@@ -4085,17 +4838,17 @@ 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(this.t.ragIngestionLog).where(eq9(this.t.ragIngestionLog.documentId, documentId));
+    const [row] = await this.db.select().from(this.t.ragIngestionLog).where(eq11(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 affectedRows(this.dialect, this.db.delete(this.t.ragIngestionLog).where(eq9(this.t.ragIngestionLog.documentId, documentId)), this.t.ragIngestionLog.documentId);
+    const removed = await affectedRows(this.dialect, this.db.delete(this.t.ragIngestionLog).where(eq11(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 affectedRows(this.dialect, this.db.delete(this.t.ragIngestionLog).where(eq9(this.t.ragIngestionLog.collection, collection)), this.t.ragIngestionLog.documentId);
+    const removed = await affectedRows(this.dialect, this.db.delete(this.t.ragIngestionLog).where(eq11(this.t.ragIngestionLog.collection, collection)), this.t.ragIngestionLog.documentId);
     return removed;
   }
   /**
@@ -4125,7 +4878,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
     }
   }
   where(query) {
-    return and8(query.collection !== void 0 ? eq9(this.t.ragIngestionLog.collection, query.collection) : void 0, query.status !== void 0 ? eq9(this.t.ragIngestionLog.status, query.status) : void 0);
+    return and10(query.collection !== void 0 ? eq11(this.t.ragIngestionLog.collection, query.collection) : void 0, query.status !== void 0 ? eq11(this.t.ragIngestionLog.status, query.status) : void 0);
   }
   /**
   * The coordinates filter AND'd with "strictly after `cursor` in
@@ -4140,7 +4893,7 @@ var DrizzleRagIngestionLog = class _DrizzleRagIngestionLog {
     if (cursor === void 0) {
       return base;
     }
-    return and8(base, or3(lt3(this.t.ragIngestionLog.updatedAt, cursor.updatedAt), and8(eq9(this.t.ragIngestionLog.updatedAt, cursor.updatedAt), gt4(this.t.ragIngestionLog.documentId, cursor.documentId))));
+    return and10(base, or4(lt4(this.t.ragIngestionLog.updatedAt, cursor.updatedAt), and10(eq11(this.t.ragIngestionLog.updatedAt, cursor.updatedAt), gt5(this.t.ragIngestionLog.documentId, cursor.documentId))));
   }
   /**
   * Upsert one outcome. Keyed by document id so the row always reflects the *current* state — a
@@ -4213,12 +4966,12 @@ DrizzleRagIngestionLog = _ts_decorate([
 ], DrizzleRagIngestionLog);
 
 // src/drizzle-agent-store.module.ts
-import { AGENT_CHANNEL_STORE, AGENT_CONFIRM_TOKEN_STORE, AGENT_GOVERNANCE_QUERIES, AGENT_PRICING_STORE, AGENT_STORE } from "@dudousxd/nestjs-agent-core";
+import { AGENT_CHANNEL_STORE, AGENT_CONFIRM_TOKEN_STORE, AGENT_GOVERNANCE_QUERIES, AGENT_POPPY_CONNECTION_STORE, AGENT_POPPY_STORE, AGENT_PRICING_STORE, AGENT_STORE } from "@dudousxd/nestjs-agent-core";
 import { Module } from "@nestjs/common";
-function _ts_decorate2(decorators, target, key2, desc4) {
-  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key2) : desc4, d;
+function _ts_decorate2(decorators, target, key2, desc5) {
+  var c = arguments.length, r = c < 3 ? target : desc5 === null ? desc5 = Object.getOwnPropertyDescriptor(target, key2) : desc5, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
-    r = Reflect.decorate(decorators, target, key2, desc4);
+    r = Reflect.decorate(decorators, target, key2, desc5);
   } else {
     for (var i = decorators.length - 1; i >= 0; i--) {
       if (d = decorators[i]) {
@@ -4301,6 +5054,23 @@ var DrizzleAgentStoreModule = class _DrizzleAgentStoreModule {
         {
           provide: AGENT_CHANNEL_STORE,
           useExisting: DrizzleChannelStore
+        },
+        // Personal Agent Protocol (Poppy) conversations and connections, shared by every replica.
+        {
+          provide: DrizzlePoppyStore,
+          useFactory: /* @__PURE__ */ __name(() => new DrizzlePoppyStore(options.db), "useFactory")
+        },
+        {
+          provide: AGENT_POPPY_STORE,
+          useExisting: DrizzlePoppyStore
+        },
+        {
+          provide: DrizzlePoppyConnectionStore,
+          useFactory: /* @__PURE__ */ __name(() => new DrizzlePoppyConnectionStore(options.db), "useFactory")
+        },
+        {
+          provide: AGENT_POPPY_CONNECTION_STORE,
+          useExisting: DrizzlePoppyConnectionStore
         }
       ],
       exports: [
@@ -4317,7 +5087,11 @@ var DrizzleAgentStoreModule = class _DrizzleAgentStoreModule {
         DrizzleConfirmTokenStore,
         AGENT_CONFIRM_TOKEN_STORE,
         DrizzleChannelStore,
-        AGENT_CHANNEL_STORE
+        AGENT_CHANNEL_STORE,
+        DrizzlePoppyStore,
+        AGENT_POPPY_STORE,
+        DrizzlePoppyConnectionStore,
+        AGENT_POPPY_CONNECTION_STORE
       ]
     };
   }
@@ -4333,6 +5107,8 @@ export {
   DrizzleConfirmTokenStore,
   DrizzleGovernanceQueries,
   DrizzleMemoryProvider,
+  DrizzlePoppyConnectionStore,
+  DrizzlePoppyStore,
   DrizzlePricingStore,
   DrizzleRagIngestionLog,
   DrizzleStreamFrameTable,
@@ -4346,6 +5122,11 @@ export {
   agentMemory,
   agentMessage,
   agentModelPricing,
+  agentPoppyConnect,
+  agentPoppyConnection,
+  agentPoppyConversation,
+  agentPoppyEvent,
+  agentPoppyMessage,
   agentQueuedMessage,
   agentRun,
   agentSchema,