@dudousxd/nestjs-agent-store-drizzle 0.3.4 → 0.5.0

package/dist/index.cjs

@@ -27,6 +27,7 @@ __export(index_exports, {
   DrizzlePricingStore: () => DrizzlePricingStore,
   agentMessage: () => agentMessage,
   agentModelPricing: () => agentModelPricing,
+  agentRun: () => agentRun,
   agentSchema: () => agentSchema,
   agentThread: () => agentThread,
   agentTokenUsage: () => agentTokenUsage,
@@ -147,12 +148,36 @@ var agentModelPricing = (0, import_sqlite_core.sqliteTable)("agent_model_pricing
     mode: "boolean"
   }).notNull()
 });
+var agentRun = (0, import_sqlite_core.sqliteTable)("agent_run", {
+  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(),
+  agentName: (0, import_sqlite_core.text)("agent_name"),
+  status: (0, import_sqlite_core.text)("status").$type().notNull(),
+  durationMs: (0, import_sqlite_core.integer)("duration_ms"),
+  errorCode: (0, import_sqlite_core.text)("error_code"),
+  errorMessage: (0, import_sqlite_core.text)("error_message"),
+  retries: (0, import_sqlite_core.integer)("retries").notNull().default(0),
+  startedAt: (0, import_sqlite_core.integer)("started_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  settledAt: (0, import_sqlite_core.integer)("settled_at", {
+    mode: "timestamp_ms"
+  }),
+  /** sha256 hex of the run's resolved (pre-RAG) system prompt; null for a pre-existing run. */
+  promptHash: (0, import_sqlite_core.text)("prompt_hash")
+}, (table) => [
+  (0, import_sqlite_core.index)("agent_run_started_idx").on(table.startedAt)
+]);
 var agentSchema = {
   agentThread,
   agentMessage,
   agentToolCall,
   agentTokenUsage,
-  agentModelPricing
+  agentModelPricing,
+  agentRun
 };
 
 // src/ensure-schema.ts
@@ -224,7 +249,23 @@ var statements = [
     cache_read_price_per_1m REAL,
     effective_from INTEGER NOT NULL,
     is_current INTEGER NOT NULL
-  )`
+  )`,
+  `CREATE TABLE IF NOT EXISTS agent_run (
+    id TEXT PRIMARY KEY NOT NULL,
+    thread_id TEXT NOT NULL REFERENCES agent_thread(id) ON DELETE CASCADE,
+    actor_ref TEXT NOT NULL,
+    agent_name TEXT,
+    status TEXT NOT NULL,
+    duration_ms INTEGER,
+    error_code TEXT,
+    error_message TEXT,
+    retries INTEGER NOT NULL DEFAULT 0,
+    started_at INTEGER NOT NULL,
+    settled_at INTEGER,
+    prompt_hash TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS agent_run_started_idx
+    ON agent_run (started_at)`
 ];
 async function ensureAgentSchema(db) {
   for (const statement of statements) {
@@ -366,6 +407,47 @@ var DrizzleAgentStore = class {
       activeStreamId: runId
     }).where((0, import_drizzle_orm2.eq)(agentThread.id, threadId));
   }
+  /** Persist the start of a run (turn). Replay-safe: called under a durable localStep. */
+  async recordRunStart(run) {
+    const runRow = {
+      id: run.runId,
+      threadId: run.threadId,
+      actorRef: run.actorRef,
+      agentName: run.agentName ?? null,
+      status: "running",
+      durationMs: null,
+      errorCode: null,
+      errorMessage: null,
+      retries: 0,
+      startedAt: /* @__PURE__ */ new Date(),
+      settledAt: null,
+      promptHash: run.promptHash ?? null
+    };
+    await this.db.insert(agentRun).values(runRow);
+  }
+  /** Settle a run's outcome. A no-op when the run is unknown (mirrors `setTitle`/`updateThread`). */
+  async recordRunEnd(end) {
+    const updates = {
+      status: end.status,
+      settledAt: /* @__PURE__ */ new Date()
+    };
+    if (end.durationMs !== void 0) {
+      updates.durationMs = end.durationMs;
+    }
+    if (end.errorCode !== void 0) {
+      updates.errorCode = end.errorCode;
+    }
+    if (end.errorMessage !== void 0) {
+      updates.errorMessage = end.errorMessage;
+    }
+    await this.db.update(agentRun).set(updates).where((0, import_drizzle_orm2.eq)(agentRun.id, end.runId));
+  }
+  /** Bump the run's llm-step retry counter. Atomic `retries = retries + 1`, no read-modify-write. */
+  async bumpRunRetries(runId) {
+    await this.db.update(agentRun).set({
+      retries: import_drizzle_orm2.sql`${agentRun.retries} + 1`
+    }).where((0, import_drizzle_orm2.eq)(agentRun.id, runId));
+  }
   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) {
@@ -504,6 +586,8 @@ var DrizzleAgentStore = class {
 // src/drizzle-governance-queries.ts
 var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
 var import_drizzle_orm3 = require("drizzle-orm");
+var UNCLASSIFIED_ERROR_CODE = "unknown";
+var DEFAULT_AGENT_BUCKET = "(default)";
 function toUsageInput(row) {
   return {
     modelId: row.modelId,
@@ -518,6 +602,14 @@ function toUsageInput(row) {
   };
 }
 __name(toUsageInput, "toUsageInput");
+function percentileMs(sortedDurationsMs, p) {
+  if (sortedDurationsMs.length === 0) {
+    return null;
+  }
+  const offset = Math.min(sortedDurationsMs.length - 1, Math.floor(p * sortedDurationsMs.length));
+  return sortedDurationsMs[offset] ?? null;
+}
+__name(percentileMs, "percentileMs");
 var DrizzleGovernanceQueries = class {
   static {
     __name(this, "DrizzleGovernanceQueries");
@@ -623,6 +715,189 @@ var DrizzleGovernanceQueries = class {
     }
     return result;
   }
+  async runsInRange(range) {
+    const { start, end } = (0, import_nestjs_agent_core.dayBoundsUtc)(range);
+    return this.db.select().from(agentRun).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentRun.startedAt, start), (0, import_drizzle_orm3.lte)(agentRun.startedAt, end)));
+  }
+  async runMetrics(range) {
+    const runs = await this.runsInRange(range);
+    let completed = 0;
+    let failed = 0;
+    let retries = 0;
+    const settledDurationsMs = [];
+    for (const run of runs) {
+      if (run.status === "completed") {
+        completed += 1;
+      } else if (run.status === "failed") {
+        failed += 1;
+      }
+      retries += run.retries;
+      if ((run.status === "completed" || run.status === "failed") && run.durationMs != null) {
+        settledDurationsMs.push(run.durationMs);
+      }
+    }
+    settledDurationsMs.sort((left, right) => left - right);
+    return {
+      runs: runs.length,
+      completed,
+      failed,
+      successRate: runs.length === 0 ? 0 : completed / runs.length,
+      retries,
+      durationP50Ms: percentileMs(settledDurationsMs, 0.5),
+      durationP95Ms: percentileMs(settledDurationsMs, 0.95)
+    };
+  }
+  async runsByAgent(range) {
+    const runs = await this.runsInRange(range);
+    const byAgent = /* @__PURE__ */ new Map();
+    for (const run of runs) {
+      const agentName = run.agentName ?? DEFAULT_AGENT_BUCKET;
+      const bucket = byAgent.get(agentName) ?? {
+        runs: 0,
+        failed: 0,
+        retries: 0
+      };
+      bucket.runs += 1;
+      bucket.failed += run.status === "failed" ? 1 : 0;
+      bucket.retries += run.retries;
+      byAgent.set(agentName, bucket);
+    }
+    const result = [];
+    for (const [agentName, bucket] of byAgent) {
+      result.push({
+        agentName,
+        ...bucket
+      });
+    }
+    result.sort((left, right) => right.runs - left.runs || left.agentName.localeCompare(right.agentName));
+    return result;
+  }
+  async runErrors(range) {
+    const { start, end } = (0, import_nestjs_agent_core.dayBoundsUtc)(range);
+    const runs = await this.db.select().from(agentRun).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentRun.startedAt, start), (0, import_drizzle_orm3.lte)(agentRun.startedAt, end), (0, import_drizzle_orm3.eq)(agentRun.status, "failed")));
+    const byError = /* @__PURE__ */ new Map();
+    for (const run of runs) {
+      const errorCode = run.errorCode ?? UNCLASSIFIED_ERROR_CODE;
+      byError.set(errorCode, (byError.get(errorCode) ?? 0) + 1);
+    }
+    const result = [];
+    for (const [errorCode, errorCount] of byError) {
+      result.push({
+        errorCode,
+        count: errorCount
+      });
+    }
+    result.sort((left, right) => right.count - left.count || left.errorCode.localeCompare(right.errorCode));
+    return result;
+  }
+  async runTrend(range) {
+    const runs = await this.runsInRange(range);
+    const byDay = /* @__PURE__ */ new Map();
+    for (const run of runs) {
+      const day = run.startedAt.toISOString().slice(0, 10);
+      const bucket = byDay.get(day) ?? {
+        runs: 0,
+        failed: 0
+      };
+      bucket.runs += 1;
+      bucket.failed += run.status === "failed" ? 1 : 0;
+      byDay.set(day, bucket);
+    }
+    const result = [];
+    for (const [day, bucket] of byDay) {
+      result.push({
+        day,
+        ...bucket
+      });
+    }
+    result.sort((left, right) => left.day.localeCompare(right.day));
+    return result;
+  }
+  async recentRuns(limit) {
+    const runs = await this.db.select().from(agentRun).orderBy((0, import_drizzle_orm3.desc)(agentRun.startedAt), (0, import_drizzle_orm3.desc)(agentRun.id)).limit(limit);
+    return runs.map((run) => ({
+      runId: run.id,
+      threadId: run.threadId,
+      actorRef: run.actorRef,
+      agentName: run.agentName ?? null,
+      status: run.status,
+      durationMs: run.durationMs ?? null,
+      errorCode: run.errorCode ?? null,
+      errorMessage: run.errorMessage ?? null,
+      retries: run.retries,
+      startedAt: run.startedAt.toISOString(),
+      promptHash: run.promptHash ?? null
+    }));
+  }
+  /**
+  * Tool calls sitting `pending_approval`, oldest first (an inbox drains from the back), joined
+  * through their message to the owning thread for title/actorRef and to the message itself for
+  * `agentName` (null when the message carries none).
+  */
+  async pendingApprovals(limit) {
+    const rows = await this.db.select({
+      toolCallId: agentToolCall.id,
+      toolName: agentToolCall.toolName,
+      input: agentToolCall.input,
+      threadId: agentThread.id,
+      threadTitle: agentThread.title,
+      actorRef: agentThread.actorRef,
+      agentName: agentMessage.agentName,
+      requestedAt: agentToolCall.createdAt
+    }).from(agentToolCall).innerJoin(agentMessage, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, (0, import_drizzle_orm3.eq)(agentMessage.threadId, agentThread.id)).where((0, import_drizzle_orm3.eq)(agentToolCall.status, "pending_approval")).orderBy(agentToolCall.createdAt, agentToolCall.id).limit(limit);
+    return rows.map((row) => ({
+      toolCallId: row.toolCallId,
+      toolName: row.toolName,
+      input: row.input,
+      threadId: row.threadId,
+      threadTitle: row.threadTitle,
+      actorRef: row.actorRef,
+      agentName: row.agentName ?? null,
+      requestedAt: row.requestedAt.toISOString()
+    }));
+  }
+  /**
+  * Per-tool call/failure/rejection/latency rollup over the range, highest call count first.
+  * `p95ExecutionMs` is computed over calls that recorded a non-null `executionMs` (regardless of
+  * their final status); `null` when none did.
+  */
+  async toolStats(range) {
+    const { start, end } = (0, import_nestjs_agent_core.dayBoundsUtc)(range);
+    const calls = await this.db.select().from(agentToolCall).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.gte)(agentToolCall.createdAt, start), (0, import_drizzle_orm3.lte)(agentToolCall.createdAt, end)));
+    const byTool = /* @__PURE__ */ new Map();
+    for (const call of calls) {
+      const key = `${call.toolName} ${call.toolType}`;
+      const bucket = byTool.get(key) ?? {
+        toolName: call.toolName,
+        toolType: call.toolType,
+        calls: 0,
+        failed: 0,
+        rejected: 0,
+        executionMs: []
+      };
+      bucket.calls += 1;
+      bucket.failed += call.status === "failed" ? 1 : 0;
+      bucket.rejected += call.status === "rejected" ? 1 : 0;
+      if (call.executionMs != null) {
+        bucket.executionMs.push(call.executionMs);
+      }
+      byTool.set(key, bucket);
+    }
+    const result = [];
+    for (const bucket of byTool.values()) {
+      bucket.executionMs.sort((left, right) => left - right);
+      result.push({
+        toolName: bucket.toolName,
+        toolType: bucket.toolType,
+        calls: bucket.calls,
+        failed: bucket.failed,
+        rejected: bucket.rejected,
+        p95ExecutionMs: percentileMs(bucket.executionMs, 0.95)
+      });
+    }
+    result.sort((left, right) => right.calls - left.calls || left.toolName.localeCompare(right.toolName));
+    return result;
+  }
 };
 
 // src/drizzle-pricing-store.ts
@@ -741,6 +1016,7 @@ DrizzleAgentStoreModule = _ts_decorate([
   DrizzlePricingStore,
   agentMessage,
   agentModelPricing,
+  agentRun,
   agentSchema,
   agentThread,
   agentTokenUsage,