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

package/dist/index.js

@@ -113,12 +113,36 @@ var agentModelPricing = sqliteTable("agent_model_pricing", {
     mode: "boolean"
   }).notNull()
 });
+var agentRun = sqliteTable("agent_run", {
+  id: text("id").primaryKey(),
+  threadId: text("thread_id").notNull().references(() => agentThread.id, {
+    onDelete: "cascade"
+  }),
+  actorRef: text("actor_ref").notNull(),
+  agentName: text("agent_name"),
+  status: text("status").$type().notNull(),
+  durationMs: integer("duration_ms"),
+  errorCode: text("error_code"),
+  errorMessage: text("error_message"),
+  retries: integer("retries").notNull().default(0),
+  startedAt: integer("started_at", {
+    mode: "timestamp_ms"
+  }).notNull(),
+  settledAt: integer("settled_at", {
+    mode: "timestamp_ms"
+  }),
+  /** sha256 hex of the run's resolved (pre-RAG) system prompt; null for a pre-existing run. */
+  promptHash: text("prompt_hash")
+}, (table) => [
+  index("agent_run_started_idx").on(table.startedAt)
+]);
 var agentSchema = {
   agentThread,
   agentMessage,
   agentToolCall,
   agentTokenUsage,
-  agentModelPricing
+  agentModelPricing,
+  agentRun
 };
 
 // src/ensure-schema.ts
@@ -190,7 +214,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) {
@@ -200,7 +240,7 @@ async function ensureAgentSchema(db) {
 __name(ensureAgentSchema, "ensureAgentSchema");
 
 // src/drizzle-agent-store.ts
-import { and, asc, desc, eq, gte, inArray, isNull, lte } from "drizzle-orm";
+import { and, asc, desc, eq, gte, inArray, isNull, lte, sql as sql2 } from "drizzle-orm";
 var DrizzleAgentStore = class {
   static {
     __name(this, "DrizzleAgentStore");
@@ -332,6 +372,47 @@ var DrizzleAgentStore = class {
       activeStreamId: runId
     }).where(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(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: sql2`${agentRun.retries} + 1`
+    }).where(eq(agentRun.id, runId));
+  }
   async appendMessage(input) {
     const [thread] = await this.db.select().from(agentThread).where(eq(agentThread.id, input.threadId));
     if (thread === void 0) {
@@ -470,6 +551,8 @@ var DrizzleAgentStore = class {
 // src/drizzle-governance-queries.ts
 import { bucketByActor, bucketByModel, bucketByThread, bucketUsageTrend, dayBoundsUtc } from "@dudousxd/nestjs-agent-core";
 import { and as and2, count, desc as desc2, eq as eq2, gte as gte2, inArray as inArray2, isNull as isNull2, lte as lte2 } from "drizzle-orm";
+var UNCLASSIFIED_ERROR_CODE = "unknown";
+var DEFAULT_AGENT_BUCKET = "(default)";
 function toUsageInput(row) {
   return {
     modelId: row.modelId,
@@ -484,6 +567,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");
@@ -589,6 +680,189 @@ var DrizzleGovernanceQueries = class {
     }
     return result;
   }
+  async runsInRange(range) {
+    const { start, end } = dayBoundsUtc(range);
+    return this.db.select().from(agentRun).where(and2(gte2(agentRun.startedAt, start), lte2(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 } = dayBoundsUtc(range);
+    const runs = await this.db.select().from(agentRun).where(and2(gte2(agentRun.startedAt, start), lte2(agentRun.startedAt, end), eq2(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(desc2(agentRun.startedAt), desc2(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, eq2(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, eq2(agentMessage.threadId, agentThread.id)).where(eq2(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 } = dayBoundsUtc(range);
+    const calls = await this.db.select().from(agentToolCall).where(and2(gte2(agentToolCall.createdAt, start), lte2(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
@@ -706,6 +980,7 @@ export {
   DrizzlePricingStore,
   agentMessage,
   agentModelPricing,
+  agentRun,
   agentSchema,
   agentThread,
   agentTokenUsage,