@dudousxd/nestjs-agent-store-drizzle 0.1.0

package/dist/index.cjs

@@ -0,0 +1,784 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc3) => {
+  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: !(desc3 = __getOwnPropDesc(from, key)) || desc3.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DrizzleAgentStore: () => DrizzleAgentStore,
+  DrizzleAgentStoreModule: () => DrizzleAgentStoreModule,
+  DrizzleGovernanceQueries: () => DrizzleGovernanceQueries,
+  DrizzlePricingStore: () => DrizzlePricingStore,
+  agentMessage: () => agentMessage,
+  agentModelPricing: () => agentModelPricing,
+  agentSchema: () => agentSchema,
+  agentThread: () => agentThread,
+  agentTokenUsage: () => agentTokenUsage,
+  agentToolCall: () => agentToolCall,
+  ensureAgentSchema: () => ensureAgentSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema.ts
+var import_sqlite_core = require("drizzle-orm/sqlite-core");
+var agentThread = (0, import_sqlite_core.sqliteTable)("agent_thread", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  actorRef: (0, import_sqlite_core.text)("actor_ref").notNull(),
+  tenantRef: (0, import_sqlite_core.text)("tenant_ref"),
+  title: (0, import_sqlite_core.text)("title").notNull(),
+  persona: (0, import_sqlite_core.text)("persona").notNull().default("default"),
+  transient: (0, import_sqlite_core.integer)("transient", {
+    mode: "boolean"
+  }).notNull().default(false),
+  activeStreamId: (0, import_sqlite_core.text)("active_stream_id"),
+  createdAt: (0, import_sqlite_core.integer)("created_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  updatedAt: (0, import_sqlite_core.integer)("updated_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  deletedAt: (0, import_sqlite_core.integer)("deleted_at", {
+    mode: "timestamp_ms"
+  })
+}, (table) => [
+  (0, import_sqlite_core.index)("agent_thread_actor_updated_idx").on(table.actorRef, table.updatedAt)
+]);
+var agentMessage = (0, import_sqlite_core.sqliteTable)("agent_message", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  threadId: (0, import_sqlite_core.text)("thread_id").notNull().references(() => agentThread.id, {
+    onDelete: "cascade"
+  }),
+  role: (0, import_sqlite_core.text)("role").$type().notNull(),
+  content: (0, import_sqlite_core.text)("content").notNull(),
+  toolCalls: (0, import_sqlite_core.text)("tool_calls", {
+    mode: "json"
+  }).$type(),
+  toolResults: (0, import_sqlite_core.text)("tool_results", {
+    mode: "json"
+  }).$type(),
+  followUps: (0, import_sqlite_core.text)("follow_ups", {
+    mode: "json"
+  }).$type(),
+  usage: (0, import_sqlite_core.text)("usage", {
+    mode: "json"
+  }).$type(),
+  persona: (0, import_sqlite_core.text)("persona"),
+  createdAt: (0, import_sqlite_core.integer)("created_at", {
+    mode: "timestamp_ms"
+  }).notNull()
+}, (table) => [
+  (0, import_sqlite_core.index)("agent_message_thread_created_idx").on(table.threadId, table.createdAt)
+]);
+var agentToolCall = (0, import_sqlite_core.sqliteTable)("agent_tool_call", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  messageId: (0, import_sqlite_core.text)("message_id").notNull().references(() => agentMessage.id, {
+    onDelete: "cascade"
+  }),
+  toolName: (0, import_sqlite_core.text)("tool_name").notNull(),
+  toolType: (0, import_sqlite_core.text)("tool_type").$type().notNull(),
+  input: (0, import_sqlite_core.text)("input", {
+    mode: "json"
+  }),
+  output: (0, import_sqlite_core.text)("output", {
+    mode: "json"
+  }),
+  status: (0, import_sqlite_core.text)("status").$type().notNull(),
+  executedByRef: (0, import_sqlite_core.text)("executed_by_ref"),
+  executionMs: (0, import_sqlite_core.integer)("execution_ms"),
+  error: (0, import_sqlite_core.text)("error"),
+  createdAt: (0, import_sqlite_core.integer)("created_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  executedAt: (0, import_sqlite_core.integer)("executed_at", {
+    mode: "timestamp_ms"
+  })
+});
+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, {
+    onDelete: "cascade"
+  }),
+  actorRef: (0, import_sqlite_core.text)("actor_ref").notNull(),
+  messageId: (0, import_sqlite_core.text)("message_id"),
+  modelId: (0, import_sqlite_core.text)("model_id").notNull(),
+  purpose: (0, import_sqlite_core.text)("purpose").$type().notNull(),
+  inputTokens: (0, import_sqlite_core.integer)("input_tokens").notNull(),
+  outputTokens: (0, import_sqlite_core.integer)("output_tokens").notNull(),
+  /** Subset of `inputTokens` written to the prompt cache this turn; null when not reported. */
+  cacheWriteTokens: (0, import_sqlite_core.integer)("cache_write_tokens"),
+  /** Subset of `inputTokens` served from the prompt cache this turn; null when not reported. */
+  cacheReadTokens: (0, import_sqlite_core.integer)("cache_read_tokens"),
+  /** Provider-reported actual USD cost for the turn; null when only tokens were reported. */
+  costUsd: (0, import_sqlite_core.real)("cost_usd"),
+  createdAt: (0, import_sqlite_core.integer)("created_at", {
+    mode: "timestamp_ms"
+  }).notNull()
+}, (table) => [
+  (0, import_sqlite_core.index)("agent_token_usage_actor_created_idx").on(table.actorRef, table.createdAt)
+]);
+var agentModelPricing = (0, import_sqlite_core.sqliteTable)("agent_model_pricing", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  modelId: (0, import_sqlite_core.text)("model_id").notNull(),
+  inputPricePer1m: (0, import_sqlite_core.real)("input_price_per_1m").notNull(),
+  outputPricePer1m: (0, import_sqlite_core.real)("output_price_per_1m").notNull(),
+  /** Per-1M price for cache-write input tokens; null → price them at the input rate. */
+  cacheWritePricePer1m: (0, import_sqlite_core.real)("cache_write_price_per_1m"),
+  /** Per-1M price for cache-read input tokens; null → price them at the input rate. */
+  cacheReadPricePer1m: (0, import_sqlite_core.real)("cache_read_price_per_1m"),
+  effectiveFrom: (0, import_sqlite_core.integer)("effective_from", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  isCurrent: (0, import_sqlite_core.integer)("is_current", {
+    mode: "boolean"
+  }).notNull()
+});
+var agentSchema = {
+  agentThread,
+  agentMessage,
+  agentToolCall,
+  agentTokenUsage,
+  agentModelPricing
+};
+
+// src/ensure-schema.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,
+    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(import_drizzle_orm.sql.raw(statement));
+  }
+}
+__name(ensureAgentSchema, "ensureAgentSchema");
+
+// src/drizzle-agent-store.ts
+var import_drizzle_orm2 = require("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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(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 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((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 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);
+      summaries.push(this.toSummary(thread, last?.content));
+    }
+    return summaries;
+  }
+  async softDeleteThread(threadId) {
+    await this.db.update(agentThread).set({
+      deletedAt: /* @__PURE__ */ new Date()
+    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+  }
+  async forkThread(threadId, fromMessageId) {
+    const [source] = await this.db.select().from(agentThread).where((0, import_drizzle_orm2.eq)(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 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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(agentThread.id, threadId), (0, import_drizzle_orm2.isNull)(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));
+    return row?.actorRef ?? null;
+  }
+  async runForToolCall(toolCallId) {
+    const [row] = await this.db.select({
+      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));
+    return row?.activeStreamId ?? null;
+  }
+  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)));
+    return thread?.actorRef ?? null;
+  }
+  async setTitle(threadId, title) {
+    await this.db.update(agentThread).set({
+      title,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+  }
+  async setActiveStream(threadId, runId) {
+    await this.db.update(agentThread).set({
+      activeStreamId: runId
+    }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
+  }
+  async appendMessage(input) {
+    const [thread] = await this.db.select().from(agentThread).where((0, import_drizzle_orm2.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((0, import_drizzle_orm2.eq)(agentThread.id, input.threadId));
+    return this.toStoredMessage(message);
+  }
+  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 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));
+  }
+  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((0, import_drizzle_orm2.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((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 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
+var import_drizzle_orm3 = require("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((0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentTokenUsage.createdAt, start), (0, import_drizzle_orm3.lte)(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, (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);
+    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((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 result = [];
+    for (const thread of threads) {
+      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 usageRows = await this.db.select().from(agentTokenUsage).where((0, import_drizzle_orm3.eq)(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
+var import_drizzle_orm4 = require("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((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(agentModelPricing.modelId, input.modelId), (0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(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
+var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
+var import_common = require("@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: import_nestjs_agent_core.AGENT_STORE,
+          useExisting: DrizzleAgentStore
+        },
+        {
+          provide: DrizzleGovernanceQueries,
+          useFactory: /* @__PURE__ */ __name(() => new DrizzleGovernanceQueries(options.db), "useFactory")
+        },
+        {
+          provide: import_nestjs_agent_core.AGENT_GOVERNANCE_QUERIES,
+          useExisting: DrizzleGovernanceQueries
+        },
+        {
+          provide: DrizzlePricingStore,
+          useFactory: /* @__PURE__ */ __name(() => new DrizzlePricingStore(options.db), "useFactory")
+        },
+        {
+          provide: import_nestjs_agent_core.AGENT_PRICING_STORE,
+          useExisting: DrizzlePricingStore
+        }
+      ],
+      exports: [
+        DrizzleAgentStore,
+        import_nestjs_agent_core.AGENT_STORE,
+        DrizzleGovernanceQueries,
+        import_nestjs_agent_core.AGENT_GOVERNANCE_QUERIES,
+        DrizzlePricingStore,
+        import_nestjs_agent_core.AGENT_PRICING_STORE
+      ]
+    };
+  }
+};
+DrizzleAgentStoreModule = _ts_decorate([
+  (0, import_common.Module)({})
+], DrizzleAgentStoreModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DrizzleAgentStore,
+  DrizzleAgentStoreModule,
+  DrizzleGovernanceQueries,
+  DrizzlePricingStore,
+  agentMessage,
+  agentModelPricing,
+  agentSchema,
+  agentThread,
+  agentTokenUsage,
+  agentToolCall,
+  ensureAgentSchema
+});
+//# sourceMappingURL=index.cjs.map