@dudousxd/nestjs-agent-store-drizzle 0.1.0

package/dist/index.js

@@ -0,0 +1,749 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/schema.ts
+import { index, integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var agentThread = sqliteTable("agent_thread", {
+  id: text("id").primaryKey(),
+  actorRef: text("actor_ref").notNull(),
+  tenantRef: text("tenant_ref"),
+  title: text("title").notNull(),
+  persona: text("persona").notNull().default("default"),
+  transient: integer("transient", {
+    mode: "boolean"
+  }).notNull().default(false),
+  activeStreamId: text("active_stream_id"),
+  createdAt: integer("created_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  updatedAt: integer("updated_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  deletedAt: integer("deleted_at", {
+    mode: "timestamp_ms"
+  })
+}, (table) => [
+  index("agent_thread_actor_updated_idx").on(table.actorRef, table.updatedAt)
+]);
+var agentMessage = sqliteTable("agent_message", {
+  id: text("id").primaryKey(),
+  threadId: text("thread_id").notNull().references(() => agentThread.id, {
+    onDelete: "cascade"
+  }),
+  role: text("role").$type().notNull(),
+  content: text("content").notNull(),
+  toolCalls: text("tool_calls", {
+    mode: "json"
+  }).$type(),
+  toolResults: text("tool_results", {
+    mode: "json"
+  }).$type(),
+  followUps: text("follow_ups", {
+    mode: "json"
+  }).$type(),
+  usage: text("usage", {
+    mode: "json"
+  }).$type(),
+  persona: text("persona"),
+  createdAt: integer("created_at", {
+    mode: "timestamp_ms"
+  }).notNull()
+}, (table) => [
+  index("agent_message_thread_created_idx").on(table.threadId, table.createdAt)
+]);
+var agentToolCall = sqliteTable("agent_tool_call", {
+  id: text("id").primaryKey(),
+  messageId: text("message_id").notNull().references(() => agentMessage.id, {
+    onDelete: "cascade"
+  }),
+  toolName: text("tool_name").notNull(),
+  toolType: text("tool_type").$type().notNull(),
+  input: text("input", {
+    mode: "json"
+  }),
+  output: text("output", {
+    mode: "json"
+  }),
+  status: text("status").$type().notNull(),
+  executedByRef: text("executed_by_ref"),
+  executionMs: integer("execution_ms"),
+  error: text("error"),
+  createdAt: integer("created_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  executedAt: integer("executed_at", {
+    mode: "timestamp_ms"
+  })
+});
+var agentTokenUsage = sqliteTable("agent_token_usage", {
+  id: text("id").primaryKey(),
+  threadId: text("thread_id").notNull().references(() => agentThread.id, {
+    onDelete: "cascade"
+  }),
+  actorRef: text("actor_ref").notNull(),
+  messageId: text("message_id"),
+  modelId: text("model_id").notNull(),
+  purpose: text("purpose").$type().notNull(),
+  inputTokens: integer("input_tokens").notNull(),
+  outputTokens: integer("output_tokens").notNull(),
+  /** Subset of `inputTokens` written to the prompt cache this turn; null when not reported. */
+  cacheWriteTokens: integer("cache_write_tokens"),
+  /** Subset of `inputTokens` served from the prompt cache this turn; null when not reported. */
+  cacheReadTokens: integer("cache_read_tokens"),
+  /** Provider-reported actual USD cost for the turn; null when only tokens were reported. */
+  costUsd: real("cost_usd"),
+  createdAt: integer("created_at", {
+    mode: "timestamp_ms"
+  }).notNull()
+}, (table) => [
+  index("agent_token_usage_actor_created_idx").on(table.actorRef, table.createdAt)
+]);
+var agentModelPricing = sqliteTable("agent_model_pricing", {
+  id: text("id").primaryKey(),
+  modelId: text("model_id").notNull(),
+  inputPricePer1m: real("input_price_per_1m").notNull(),
+  outputPricePer1m: real("output_price_per_1m").notNull(),
+  /** Per-1M price for cache-write input tokens; null → price them at the input rate. */
+  cacheWritePricePer1m: real("cache_write_price_per_1m"),
+  /** Per-1M price for cache-read input tokens; null → price them at the input rate. */
+  cacheReadPricePer1m: real("cache_read_price_per_1m"),
+  effectiveFrom: integer("effective_from", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  isCurrent: integer("is_current", {
+    mode: "boolean"
+  }).notNull()
+});
+var agentSchema = {
+  agentThread,
+  agentMessage,
+  agentToolCall,
+  agentTokenUsage,
+  agentModelPricing
+};
+
+// src/ensure-schema.ts
+import { sql } from "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,
+    persona TEXT NOT NULL DEFAULT 'default',
+    transient INTEGER NOT NULL DEFAULT 0,
+    active_stream_id 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,
+    follow_ups TEXT,
+    usage TEXT,
+    persona 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_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
+  )`,
+  `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
+  )`
+];
+async function ensureAgentSchema(db) {
+  for (const statement of statements) {
+    await db.run(sql.raw(statement));
+  }
+}
+__name(ensureAgentSchema, "ensureAgentSchema");
+
+// src/drizzle-agent-store.ts
+import { and, asc, desc, eq, gte, inArray, isNull, lte } from "drizzle-orm";
+var DrizzleAgentStore = class {
+  static {
+    __name(this, "DrizzleAgentStore");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async createThread(input) {
+    const now = /* @__PURE__ */ new Date();
+    const thread = {
+      id: crypto.randomUUID(),
+      actorRef: input.actor.id,
+      tenantRef: input.actor.tenantRef ?? null,
+      title: input.title ?? "New chat",
+      persona: input.persona,
+      transient: input.transient ?? false,
+      activeStreamId: null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null
+    };
+    await this.db.insert(agentThread).values(thread);
+    return this.toSummary(thread);
+  }
+  async getThread(threadId) {
+    const [thread] = await this.db.select().from(agentThread).where(and(eq(agentThread.id, threadId), isNull(agentThread.deletedAt)));
+    if (thread === void 0) {
+      return null;
+    }
+    const messages = await this.db.select().from(agentMessage).where(eq(agentMessage.threadId, threadId)).orderBy(asc(agentMessage.createdAt), asc(agentMessage.id));
+    const last = messages[messages.length - 1];
+    return {
+      ...this.toSummary(thread, last?.content),
+      messages: messages.map((message) => this.toStoredMessage(message)),
+      ...thread.activeStreamId != null ? {
+        activeStreamId: thread.activeStreamId
+      } : {}
+    };
+  }
+  async listThreads(actorRef, limit = 50) {
+    const threads = await this.db.select().from(agentThread).where(and(eq(agentThread.actorRef, actorRef), eq(agentThread.transient, false), isNull(agentThread.deletedAt))).orderBy(desc(agentThread.updatedAt)).limit(limit);
+    const summaries = [];
+    for (const thread of threads) {
+      const [last] = await this.db.select().from(agentMessage).where(eq(agentMessage.threadId, thread.id)).orderBy(desc(agentMessage.createdAt), desc(agentMessage.id)).limit(1);
+      summaries.push(this.toSummary(thread, last?.content));
+    }
+    return summaries;
+  }
+  async softDeleteThread(threadId) {
+    await this.db.update(agentThread).set({
+      deletedAt: /* @__PURE__ */ new Date()
+    }).where(eq(agentThread.id, threadId));
+  }
+  async forkThread(threadId, fromMessageId) {
+    const [source] = await this.db.select().from(agentThread).where(eq(agentThread.id, threadId));
+    if (source === void 0) {
+      throw new Error(`thread ${threadId} not found`);
+    }
+    const messages = await this.db.select().from(agentMessage).where(eq(agentMessage.threadId, threadId)).orderBy(asc(agentMessage.createdAt), asc(agentMessage.id));
+    const cutoff = messages.findIndex((message) => message.id === fromMessageId);
+    const kept = cutoff >= 0 ? messages.slice(0, cutoff + 1) : messages;
+    const now = /* @__PURE__ */ new Date();
+    const fork = {
+      id: crypto.randomUUID(),
+      actorRef: source.actorRef,
+      tenantRef: source.tenantRef,
+      title: source.title,
+      persona: source.persona,
+      transient: false,
+      activeStreamId: null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null
+    };
+    await this.db.insert(agentThread).values(fork);
+    if (kept.length > 0) {
+      await this.db.insert(agentMessage).values(kept.map((message) => ({
+        id: crypto.randomUUID(),
+        threadId: fork.id,
+        role: message.role,
+        content: message.content,
+        toolCalls: message.toolCalls,
+        toolResults: message.toolResults,
+        followUps: message.followUps,
+        usage: message.usage,
+        persona: message.persona,
+        createdAt: message.createdAt
+      })));
+    }
+    return this.toSummary(fork);
+  }
+  async ownerOfThread(threadId) {
+    const [thread] = await this.db.select({
+      actorRef: agentThread.actorRef
+    }).from(agentThread).where(and(eq(agentThread.id, threadId), isNull(agentThread.deletedAt)));
+    return thread?.actorRef ?? null;
+  }
+  async ownerOfToolCall(toolCallId) {
+    const [row] = await this.db.select({
+      actorRef: agentThread.actorRef
+    }).from(agentToolCall).innerJoin(agentMessage, eq(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, eq(agentMessage.threadId, agentThread.id)).where(eq(agentToolCall.id, toolCallId));
+    return row?.actorRef ?? null;
+  }
+  async runForToolCall(toolCallId) {
+    const [row] = await this.db.select({
+      activeStreamId: agentThread.activeStreamId
+    }).from(agentToolCall).innerJoin(agentMessage, eq(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, eq(agentMessage.threadId, agentThread.id)).where(eq(agentToolCall.id, toolCallId));
+    return row?.activeStreamId ?? null;
+  }
+  async ownerOfActiveStream(runId) {
+    const [thread] = await this.db.select({
+      actorRef: agentThread.actorRef
+    }).from(agentThread).where(and(eq(agentThread.activeStreamId, runId), isNull(agentThread.deletedAt)));
+    return thread?.actorRef ?? null;
+  }
+  async setTitle(threadId, title) {
+    await this.db.update(agentThread).set({
+      title,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq(agentThread.id, threadId));
+  }
+  async setActiveStream(threadId, runId) {
+    await this.db.update(agentThread).set({
+      activeStreamId: runId
+    }).where(eq(agentThread.id, threadId));
+  }
+  async appendMessage(input) {
+    const [thread] = await this.db.select().from(agentThread).where(eq(agentThread.id, input.threadId));
+    if (thread === void 0) {
+      throw new Error(`thread ${input.threadId} not found`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const message = {
+      id: crypto.randomUUID(),
+      threadId: input.threadId,
+      role: input.role,
+      content: input.content,
+      toolCalls: input.toolCalls ?? null,
+      toolResults: input.toolResults ?? null,
+      followUps: input.followUps ?? null,
+      usage: input.usage ?? null,
+      persona: input.persona ?? null,
+      createdAt: now
+    };
+    await this.db.insert(agentMessage).values(message);
+    await this.db.update(agentThread).set({
+      updatedAt: now
+    }).where(eq(agentThread.id, input.threadId));
+    return this.toStoredMessage(message);
+  }
+  async truncateFrom(threadId, messageId) {
+    const messages = await this.db.select().from(agentMessage).where(eq(agentMessage.threadId, threadId)).orderBy(asc(agentMessage.createdAt), asc(agentMessage.id));
+    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(inArray(agentToolCall.messageId, doomedIds));
+    await this.db.delete(agentMessage).where(inArray(agentMessage.id, doomedIds));
+  }
+  async recordToolCall(input) {
+    await this.db.insert(agentToolCall).values({
+      id: input.toolCallId,
+      messageId: input.messageId,
+      toolName: input.toolName,
+      toolType: input.toolType,
+      input: input.input,
+      output: null,
+      status: input.status,
+      executedByRef: null,
+      executionMs: null,
+      error: null,
+      createdAt: /* @__PURE__ */ new Date(),
+      executedAt: null
+    });
+  }
+  async updateToolCall(input) {
+    const updates = {
+      status: input.status
+    };
+    if (input.output !== void 0) {
+      updates.output = input.output;
+    }
+    if (input.error !== void 0) {
+      updates.error = input.error;
+    }
+    if (input.executionMs !== void 0) {
+      updates.executionMs = input.executionMs;
+    }
+    if (input.executedByRef !== void 0) {
+      updates.executedByRef = input.executedByRef;
+    }
+    if (input.status === "executed" || input.status === "auto_executed") {
+      updates.executedAt = /* @__PURE__ */ new Date();
+    }
+    await this.db.update(agentToolCall).set(updates).where(eq(agentToolCall.id, input.toolCallId));
+  }
+  async recordUsage(input) {
+    await this.db.insert(agentTokenUsage).values({
+      id: crypto.randomUUID(),
+      threadId: input.threadId,
+      actorRef: input.actorRef,
+      messageId: input.messageId ?? null,
+      modelId: input.modelId,
+      purpose: input.purpose,
+      inputTokens: input.usage.inputTokens,
+      outputTokens: input.usage.outputTokens,
+      cacheWriteTokens: input.usage.cacheWriteTokens ?? null,
+      cacheReadTokens: input.usage.cacheReadTokens ?? null,
+      costUsd: input.costUsd ?? null,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  async quotaToday(actorRef, day) {
+    const start = /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+    const end = /* @__PURE__ */ new Date(`${day}T23:59:59.999Z`);
+    const rows = await this.db.select().from(agentTokenUsage).where(and(eq(agentTokenUsage.actorRef, actorRef), gte(agentTokenUsage.createdAt, start), lte(agentTokenUsage.createdAt, end)));
+    const usedTokens = rows.reduce((sum, row) => sum + row.inputTokens + row.outputTokens, 0);
+    return {
+      usedTokens
+    };
+  }
+  toSummary(thread, lastContent) {
+    return {
+      id: thread.id,
+      title: thread.title,
+      persona: thread.persona,
+      transient: thread.transient,
+      createdAt: thread.createdAt.toISOString(),
+      updatedAt: thread.updatedAt.toISOString(),
+      ...lastContent !== void 0 ? {
+        lastMessagePreview: lastContent.slice(0, 120)
+      } : {}
+    };
+  }
+  toStoredMessage(message) {
+    return {
+      id: message.id,
+      role: message.role,
+      content: message.content,
+      createdAt: message.createdAt.toISOString(),
+      ...message.toolCalls != null ? {
+        toolCalls: message.toolCalls
+      } : {},
+      ...message.toolResults != null ? {
+        toolResults: message.toolResults
+      } : {},
+      ...message.followUps != null ? {
+        followUps: message.followUps
+      } : {},
+      ...message.usage != null ? {
+        usage: message.usage
+      } : {}
+    };
+  }
+};
+
+// src/drizzle-governance-queries.ts
+import { and as and2, count, desc as desc2, eq as eq2, gte as gte2, isNull as isNull2, lte as lte2 } from "drizzle-orm";
+function estimateFromTokens(pricing, row) {
+  const price = pricing.get(row.modelId);
+  if (price === void 0) {
+    return 0;
+  }
+  const cacheWriteTokens = row.cacheWriteTokens ?? 0;
+  const cacheReadTokens = row.cacheReadTokens ?? 0;
+  const uncachedInputTokens = row.inputTokens - cacheWriteTokens - cacheReadTokens;
+  return uncachedInputTokens / 1e6 * price.inputPricePer1m + cacheWriteTokens / 1e6 * (price.cacheWritePricePer1m ?? price.inputPricePer1m) + cacheReadTokens / 1e6 * (price.cacheReadPricePer1m ?? price.inputPricePer1m) + row.outputTokens / 1e6 * price.outputPricePer1m;
+}
+__name(estimateFromTokens, "estimateFromTokens");
+function rowCost(pricing, row) {
+  return row.costUsd ?? estimateFromTokens(pricing, row);
+}
+__name(rowCost, "rowCost");
+function dayBounds(range) {
+  return {
+    start: /* @__PURE__ */ new Date(`${range.fromDay}T00:00:00.000Z`),
+    end: /* @__PURE__ */ new Date(`${range.toDay}T23:59:59.999Z`)
+  };
+}
+__name(dayBounds, "dayBounds");
+var DrizzleGovernanceQueries = class {
+  static {
+    __name(this, "DrizzleGovernanceQueries");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async loadPricing() {
+    const rows = await this.db.select().from(agentModelPricing).where(eq2(agentModelPricing.isCurrent, true));
+    const pricing = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      pricing.set(row.modelId, {
+        inputPricePer1m: row.inputPricePer1m,
+        outputPricePer1m: row.outputPricePer1m,
+        cacheWritePricePer1m: row.cacheWritePricePer1m,
+        cacheReadPricePer1m: row.cacheReadPricePer1m
+      });
+    }
+    return pricing;
+  }
+  async usageInRange(range) {
+    const { start, end } = dayBounds(range);
+    const rows = await this.db.select().from(agentTokenUsage).where(and2(gte2(agentTokenUsage.createdAt, start), lte2(agentTokenUsage.createdAt, end)));
+    return rows;
+  }
+  async spendByModel(range) {
+    const pricing = await this.loadPricing();
+    const rows = await this.usageInRange(range);
+    const byModel = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const bucket = byModel.get(row.modelId) ?? {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        costUsd: 0
+      };
+      bucket.requests += 1;
+      bucket.inputTokens += row.inputTokens;
+      bucket.outputTokens += row.outputTokens;
+      bucket.costUsd += rowCost(pricing, row);
+      byModel.set(row.modelId, bucket);
+    }
+    const result = [];
+    for (const [modelId, bucket] of byModel) {
+      result.push({
+        modelId,
+        requests: bucket.requests,
+        inputTokens: bucket.inputTokens,
+        outputTokens: bucket.outputTokens,
+        costUsd: bucket.costUsd
+      });
+    }
+    result.sort((left, right) => right.costUsd - left.costUsd || left.modelId.localeCompare(right.modelId));
+    return result;
+  }
+  async spendByActor(range) {
+    const pricing = await this.loadPricing();
+    const rows = await this.usageInRange(range);
+    const byActor = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const bucket = byActor.get(row.actorRef) ?? {
+        requests: 0,
+        totalTokens: 0,
+        costUsd: 0
+      };
+      bucket.requests += 1;
+      bucket.totalTokens += row.inputTokens + row.outputTokens;
+      bucket.costUsd += rowCost(pricing, row);
+      byActor.set(row.actorRef, bucket);
+    }
+    const result = [];
+    for (const [actorRef, bucket] of byActor) {
+      result.push({
+        actorRef,
+        requests: bucket.requests,
+        totalTokens: bucket.totalTokens,
+        costUsd: bucket.costUsd
+      });
+    }
+    result.sort((left, right) => right.costUsd - left.costUsd || left.actorRef.localeCompare(right.actorRef));
+    return result;
+  }
+  async usageTrend(range) {
+    const pricing = await this.loadPricing();
+    const rows = await this.usageInRange(range);
+    const byDay = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const day = row.createdAt.toISOString().slice(0, 10);
+      const bucket = byDay.get(day) ?? {
+        totalTokens: 0,
+        costUsd: 0
+      };
+      bucket.totalTokens += row.inputTokens + row.outputTokens;
+      bucket.costUsd += rowCost(pricing, row);
+      byDay.set(day, bucket);
+    }
+    const result = [];
+    for (const [day, bucket] of byDay) {
+      result.push({
+        day,
+        totalTokens: bucket.totalTokens,
+        costUsd: bucket.costUsd
+      });
+    }
+    result.sort((left, right) => left.day.localeCompare(right.day));
+    return result;
+  }
+  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
+    }).from(agentToolCall).innerJoin(agentMessage, eq2(agentToolCall.messageId, agentMessage.id)).orderBy(desc2(agentToolCall.createdAt), desc2(agentToolCall.id)).limit(limit);
+    return rows.map((row) => ({
+      toolCallId: row.toolCallId,
+      toolName: row.toolName,
+      toolType: row.toolType,
+      status: row.status,
+      threadId: row.threadId,
+      createdAt: row.createdAt.toISOString()
+    }));
+  }
+  async recentThreads(limit) {
+    const threads = await this.db.select().from(agentThread).where(isNull2(agentThread.deletedAt)).orderBy(desc2(agentThread.updatedAt), desc2(agentThread.id)).limit(limit);
+    const result = [];
+    for (const thread of threads) {
+      const [messageCountRow] = await this.db.select({
+        value: count()
+      }).from(agentMessage).where(eq2(agentMessage.threadId, thread.id));
+      const usageRows = await this.db.select().from(agentTokenUsage).where(eq2(agentTokenUsage.threadId, thread.id));
+      const totalTokens = usageRows.reduce((sum, row) => sum + row.inputTokens + row.outputTokens, 0);
+      result.push({
+        threadId: thread.id,
+        title: thread.title,
+        actorRef: thread.actorRef,
+        messageCount: messageCountRow?.value ?? 0,
+        totalTokens,
+        lastActivityAt: thread.updatedAt.toISOString()
+      });
+    }
+    return result;
+  }
+};
+
+// src/drizzle-pricing-store.ts
+import { and as and3, eq as eq3 } from "drizzle-orm";
+var DrizzlePricingStore = class {
+  static {
+    __name(this, "DrizzlePricingStore");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async upsertModelPrice(input) {
+    await this.db.update(agentModelPricing).set({
+      isCurrent: false
+    }).where(and3(eq3(agentModelPricing.modelId, input.modelId), eq3(agentModelPricing.isCurrent, true)));
+    await this.db.insert(agentModelPricing).values({
+      id: crypto.randomUUID(),
+      modelId: input.modelId,
+      inputPricePer1m: input.inputPricePer1m,
+      outputPricePer1m: input.outputPricePer1m,
+      cacheWritePricePer1m: input.cacheWritePricePer1m ?? null,
+      cacheReadPricePer1m: input.cacheReadPricePer1m ?? null,
+      effectiveFrom: /* @__PURE__ */ new Date(),
+      isCurrent: true
+    });
+  }
+  async listCurrentPrices() {
+    const rows = await this.db.select().from(agentModelPricing).where(eq3(agentModelPricing.isCurrent, true));
+    return rows.map((row) => ({
+      modelId: row.modelId,
+      inputPricePer1m: row.inputPricePer1m,
+      outputPricePer1m: row.outputPricePer1m,
+      effectiveFrom: row.effectiveFrom.toISOString(),
+      ...row.cacheWritePricePer1m != null ? {
+        cacheWritePricePer1m: row.cacheWritePricePer1m
+      } : {},
+      ...row.cacheReadPricePer1m != null ? {
+        cacheReadPricePer1m: row.cacheReadPricePer1m
+      } : {}
+    }));
+  }
+};
+
+// src/drizzle-agent-store.module.ts
+import { AGENT_GOVERNANCE_QUERIES, AGENT_PRICING_STORE, AGENT_STORE } from "@dudousxd/nestjs-agent-core";
+import { Module } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var DrizzleAgentStoreModule = class _DrizzleAgentStoreModule {
+  static {
+    __name(this, "DrizzleAgentStoreModule");
+  }
+  static forRoot(options) {
+    return {
+      module: _DrizzleAgentStoreModule,
+      global: true,
+      providers: [
+        {
+          provide: DrizzleAgentStore,
+          useFactory: /* @__PURE__ */ __name(() => new DrizzleAgentStore(options.db), "useFactory")
+        },
+        {
+          provide: AGENT_STORE,
+          useExisting: DrizzleAgentStore
+        },
+        {
+          provide: DrizzleGovernanceQueries,
+          useFactory: /* @__PURE__ */ __name(() => new DrizzleGovernanceQueries(options.db), "useFactory")
+        },
+        {
+          provide: AGENT_GOVERNANCE_QUERIES,
+          useExisting: DrizzleGovernanceQueries
+        },
+        {
+          provide: DrizzlePricingStore,
+          useFactory: /* @__PURE__ */ __name(() => new DrizzlePricingStore(options.db), "useFactory")
+        },
+        {
+          provide: AGENT_PRICING_STORE,
+          useExisting: DrizzlePricingStore
+        }
+      ],
+      exports: [
+        DrizzleAgentStore,
+        AGENT_STORE,
+        DrizzleGovernanceQueries,
+        AGENT_GOVERNANCE_QUERIES,
+        DrizzlePricingStore,
+        AGENT_PRICING_STORE
+      ]
+    };
+  }
+};
+DrizzleAgentStoreModule = _ts_decorate([
+  Module({})
+], DrizzleAgentStoreModule);
+export {
+  DrizzleAgentStore,
+  DrizzleAgentStoreModule,
+  DrizzleGovernanceQueries,
+  DrizzlePricingStore,
+  agentMessage,
+  agentModelPricing,
+  agentSchema,
+  agentThread,
+  agentTokenUsage,
+  agentToolCall,
+  ensureAgentSchema
+};
+//# sourceMappingURL=index.js.map