@dudousxd/nestjs-agent-store-drizzle 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-import { MessageRole, ToolCallRequest, ToolResult, MessageUsage, ToolKind, ToolCallStatus, UsagePurpose, AgentStore, CreateThreadInput, ThreadSummary, ThreadDetail, AppendMessageInput, StoredMessage, RecordToolCallInput, UpdateToolCallInput, RecordUsageInput, AgentGovernanceQueries, AgentPricingStore, GovernanceRange, ModelSpendRow, ActorSpendRow, ThreadSpendRow, UsageTrendPoint, ToolCallActivityRow, ThreadActivityRow, RunMetrics, RunAgentBreakdownRow, RunErrorBreakdownRow, RunTrendPoint, RecentRunRow, PendingApprovalRow, ToolStatRow, GovernancePageQuery, ToolCallWhere, GovernancePage, ThreadWhere, RunWhere, ModelPriceInput, CurrentModelPrice } from '@dudousxd/nestjs-agent-core';
+import { MessageRole, ToolCallRequest, ToolResult, MessageUsage, ToolKind, ToolCallStatus, UsagePurpose, AgentStore, CreateThreadInput, ThreadSummary, ThreadDetail, AppendMessageInput, StoredMessage, RecordToolCallInput, UpdateToolCallInput, RecordUsageInput, AgentGovernanceQueries, AgentPricingStore, GovernanceRange, ModelSpendRow, ActorSpendRow, ThreadSpendRow, UsageTrendPoint, ToolCallActivityRow, ThreadActivityRow, RunMetrics, RunAgentBreakdownRow, RunErrorBreakdownRow, RunTrendPoint, RecentRunRow, PendingApprovalRow, ToolStatRow, GovernancePageQuery, ToolCallWhere, GovernancePage, ThreadWhere, RunWhere, ApprovalWhere, GovernanceRunDetail, GovernanceThreadDetailQuery, GovernanceThreadDetail, ModelPriceInput, CurrentModelPrice } from '@dudousxd/nestjs-agent-core';
 import { Type, DynamicModule } from '@nestjs/common';
 
 /**
@@ -2550,6 +2550,14 @@ declare class DrizzleGovernanceQueries implements AgentGovernanceQueries {
     spendByThread(range: GovernanceRange, limit: number): Promise<ThreadSpendRow[]>;
     usageTrend(range: GovernanceRange): Promise<UsageTrendPoint[]>;
     recentToolCalls(limit: number): Promise<ToolCallActivityRow[]>;
+    /**
+     * Message counts and token totals for a whole set of threads in TWO grouped queries, not two per
+     * thread — a 200-row page used to cost four hundred round trips. Mirrors the MikroORM adapter's
+     * `threadRollups`, which reaches the same numbers without a QueryBuilder.
+     */
+    private threadRollups;
+    /** Decorate an ordered thread list with its batched rollups, preserving the incoming order. */
+    private toThreadActivityRows;
     recentThreads(limit: number): Promise<ThreadActivityRow[]>;
     private runsInRange;
     runMetrics(range: GovernanceRange): Promise<RunMetrics>;
@@ -2565,8 +2573,10 @@ declare class DrizzleGovernanceQueries implements AgentGovernanceQueries {
     pendingApprovals(limit: number): Promise<PendingApprovalRow[]>;
     /**
      * 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.
+     * `p50ExecutionMs`/`p95ExecutionMs` are computed over calls that recorded a non-null `executionMs`
+     * (regardless of their final status); both `null` when none did. Percentiles are taken in-process
+     * off the sorted sample rather than in SQL, matching the MikroORM adapter — MySQL has no
+     * `PERCENTILE_CONT` and one portable implementation beats three dialect-specific ones.
      */
     toolStats(range: GovernanceRange): Promise<ToolStatRow[]>;
     /**
@@ -2588,6 +2598,32 @@ declare class DrizzleGovernanceQueries implements AgentGovernanceQueries {
      * values outside the known literals can never match a row — short-circuits to an empty page.
      */
     runsPage(query: GovernancePageQuery<RunWhere>): Promise<GovernancePage<RecentRunRow>>;
+    /**
+     * Paged, filterable approvals inbox, oldest first — the same ordering as {@link pendingApprovals},
+     * now with the `total` that method structurally cannot report. The join to `agent_message` /
+     * `agent_thread` is unconditional (it already resolves title/actor/agentName), so the `threadId`/
+     * `actorRef`/`agentName` filters cost nothing extra.
+     *
+     * The order is TOTAL (`created_at asc, id asc`, and `id` is the primary key), so no row can land on
+     * two pages or on none for a given snapshot. Ascending order also means a newly requested approval
+     * appends past the last page instead of shifting the page an operator is currently reading.
+     */
+    approvalsPage(query: GovernancePageQuery<ApprovalWhere>): Promise<GovernancePage<PendingApprovalRow>>;
+    /**
+     * One run, its owning thread's headline and its tool calls — TWO queries regardless of how many
+     * tools the run called. `toolCalls` comes off `agent_tool_call.run_id`, so a run recorded before
+     * that column was written reports none.
+     */
+    runDetail(runId: string): Promise<GovernanceRunDetail | null>;
+    /**
+     * One thread with its lifetime usage rollup, its newest runs and its newest messages. A fixed six
+     * queries (thread, usage, message count, message page, that page's tool-call counts, runs+count) —
+     * the per-message tool-call counts are ONE grouped read over the returned message ids, not one per
+     * message. Soft-deleted threads are returned with `deleted: true`; an audit still needs them.
+     */
+    threadDetail(query: GovernanceThreadDetailQuery): Promise<GovernanceThreadDetail | null>;
+    /** Tool-call counts for a set of messages in ONE grouped query — the detail view's no-N+1 guarantee. */
+    private toolCallCountsByMessage;
 }
 
 /**

package/dist/index.js

@@ -508,8 +508,8 @@ var DrizzleAgentStore = class {
     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);
-    const costUsd = rows.reduce((sum, row) => sum + (row.costUsd ?? 0), 0);
+    const usedTokens = rows.reduce((sum2, row) => sum2 + row.inputTokens + row.outputTokens, 0);
+    const costUsd = rows.reduce((sum2, row) => sum2 + (row.costUsd ?? 0), 0);
     return {
       usedTokens,
       costUsd
@@ -553,8 +553,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, like, lte as lte2, sql as sql3 } from "drizzle-orm";
+import { bucketByActor, bucketByModel, bucketByThread, bucketUsageTrend, dayBoundsUtc, rollupThreadUsage, truncateDetailContent } from "@dudousxd/nestjs-agent-core";
+import { and as and2, asc as asc2, count, desc as desc2, eq as eq2, gte as gte2, inArray as inArray2, isNull as isNull2, like, lte as lte2, sql as sql3, sum } from "drizzle-orm";
 var UNCLASSIFIED_ERROR_CODE = "unknown";
 var DEFAULT_AGENT_BUCKET = "(default)";
 var TOOL_CALL_STATUSES = [
@@ -609,6 +609,35 @@ function emptyPage(query) {
   };
 }
 __name(emptyPage, "emptyPage");
+function toRecentRunRow(run) {
+  return {
+    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
+  };
+}
+__name(toRecentRunRow, "toRecentRunRow");
+function toRunToolCallRow(toolCall) {
+  return {
+    toolCallId: toolCall.id,
+    toolName: toolCall.toolName,
+    toolType: toolCall.toolType,
+    status: toolCall.status,
+    executionMs: toolCall.executionMs ?? null,
+    executedByRef: toolCall.executedByRef ?? null,
+    error: toolCall.error ?? null,
+    createdAt: toolCall.createdAt.toISOString()
+  };
+}
+__name(toRunToolCallRow, "toRunToolCallRow");
 function toUsageInput(row) {
   return {
     modelId: row.modelId,
@@ -718,25 +747,63 @@ var DrizzleGovernanceQueries = class {
       runId: row.runId
     }));
   }
-  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({
+  /**
+  * Message counts and token totals for a whole set of threads in TWO grouped queries, not two per
+  * thread — a 200-row page used to cost four hundred round trips. Mirrors the MikroORM adapter's
+  * `threadRollups`, which reaches the same numbers without a QueryBuilder.
+  */
+  async threadRollups(threadIds) {
+    const rollups = new Map(threadIds.map((threadId) => [
+      threadId,
+      {
+        messageCount: 0,
+        totalTokens: 0
+      }
+    ]));
+    if (threadIds.length === 0) {
+      return rollups;
+    }
+    const messageCounts = await this.db.select({
+      threadId: agentMessage.threadId,
+      value: count()
+    }).from(agentMessage).where(inArray2(agentMessage.threadId, threadIds)).groupBy(agentMessage.threadId);
+    for (const row of messageCounts) {
+      const bucket = rollups.get(row.threadId);
+      if (bucket !== void 0) {
+        bucket.messageCount = row.value;
+      }
+    }
+    const usageTotals = await this.db.select({
+      threadId: agentTokenUsage.threadId,
+      inputTokens: sum(agentTokenUsage.inputTokens),
+      outputTokens: sum(agentTokenUsage.outputTokens)
+    }).from(agentTokenUsage).where(inArray2(agentTokenUsage.threadId, threadIds)).groupBy(agentTokenUsage.threadId);
+    for (const row of usageTotals) {
+      const bucket = rollups.get(row.threadId);
+      if (bucket !== void 0) {
+        bucket.totalTokens = Number(row.inputTokens ?? 0) + Number(row.outputTokens ?? 0);
+      }
+    }
+    return rollups;
+  }
+  /** Decorate an ordered thread list with its batched rollups, preserving the incoming order. */
+  async toThreadActivityRows(threads) {
+    const rollups = await this.threadRollups(threads.map((thread) => thread.id));
+    return threads.map((thread) => {
+      const rollup = rollups.get(thread.id);
+      return {
         threadId: thread.id,
         title: thread.title,
         actorRef: thread.actorRef,
-        messageCount: messageCountRow?.value ?? 0,
-        totalTokens,
+        messageCount: rollup?.messageCount ?? 0,
+        totalTokens: rollup?.totalTokens ?? 0,
         lastActivityAt: thread.updatedAt.toISOString()
-      });
-    }
-    return result;
+      };
+    });
+  }
+  async recentThreads(limit) {
+    const threads = await this.db.select().from(agentThread).where(isNull2(agentThread.deletedAt)).orderBy(desc2(agentThread.updatedAt), desc2(agentThread.id)).limit(limit);
+    return this.toThreadActivityRows(threads);
   }
   async runsInRange(range) {
     const { start, end } = dayBoundsUtc(range);
@@ -838,19 +905,7 @@ var DrizzleGovernanceQueries = class {
   }
   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
-    }));
+    return runs.map(toRecentRunRow);
   }
   /**
   * Tool calls sitting `pending_approval`, oldest first (an inbox drains from the back), joined
@@ -883,8 +938,10 @@ var DrizzleGovernanceQueries = class {
   }
   /**
   * 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.
+  * `p50ExecutionMs`/`p95ExecutionMs` are computed over calls that recorded a non-null `executionMs`
+  * (regardless of their final status); both `null` when none did. Percentiles are taken in-process
+  * off the sorted sample rather than in SQL, matching the MikroORM adapter — MySQL has no
+  * `PERCENTILE_CONT` and one portable implementation beats three dialect-specific ones.
   */
   async toolStats(range) {
     const { start, end } = dayBoundsUtc(range);
@@ -917,6 +974,7 @@ var DrizzleGovernanceQueries = class {
         calls: bucket.calls,
         failed: bucket.failed,
         rejected: bucket.rejected,
+        p50ExecutionMs: percentileMs(bucket.executionMs, 0.5),
         p95ExecutionMs: percentileMs(bucket.executionMs, 0.95)
       });
     }
@@ -978,22 +1036,7 @@ var DrizzleGovernanceQueries = class {
       value: count()
     }).from(agentThread).where(whereClause);
     const threads = await this.db.select().from(agentThread).where(whereClause).orderBy(desc2(agentThread.updatedAt), desc2(agentThread.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
-    const rows = [];
-    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);
-      rows.push({
-        threadId: thread.id,
-        title: thread.title,
-        actorRef: thread.actorRef,
-        messageCount: messageCountRow?.value ?? 0,
-        totalTokens,
-        lastActivityAt: thread.updatedAt.toISOString()
-      });
-    }
+    const rows = await this.toThreadActivityRows(threads);
     return {
       rows,
       total: totalRow?.value ?? 0,
@@ -1016,24 +1059,146 @@ var DrizzleGovernanceQueries = class {
     }).from(agentRun).where(whereClause);
     const runs = await this.db.select().from(agentRun).where(whereClause).orderBy(desc2(agentRun.startedAt), desc2(agentRun.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
     return {
-      rows: 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
+      rows: runs.map(toRecentRunRow),
+      total: totalRow?.value ?? 0,
+      page: query.page,
+      pageSize: query.pageSize
+    };
+  }
+  /**
+  * Paged, filterable approvals inbox, oldest first — the same ordering as {@link pendingApprovals},
+  * now with the `total` that method structurally cannot report. The join to `agent_message` /
+  * `agent_thread` is unconditional (it already resolves title/actor/agentName), so the `threadId`/
+  * `actorRef`/`agentName` filters cost nothing extra.
+  *
+  * The order is TOTAL (`created_at asc, id asc`, and `id` is the primary key), so no row can land on
+  * two pages or on none for a given snapshot. Ascending order also means a newly requested approval
+  * appends past the last page instead of shifting the page an operator is currently reading.
+  */
+  async approvalsPage(query) {
+    const filters = query.where;
+    const whereClause = and2(eq2(agentToolCall.status, "pending_approval"), filters?.toolName !== void 0 ? eq2(agentToolCall.toolName, filters.toolName) : void 0, filters?.threadId !== void 0 ? eq2(agentThread.id, filters.threadId) : void 0, filters?.actorRef !== void 0 ? eq2(agentThread.actorRef, filters.actorRef) : void 0, filters?.agentName !== void 0 ? eq2(agentMessage.agentName, filters.agentName) : void 0, filters?.fromDay !== void 0 ? gte2(agentToolCall.createdAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? lte2(agentToolCall.createdAt, dayEndUtc(filters.toDay)) : void 0);
+    const [totalRow] = await this.db.select({
+      value: count()
+    }).from(agentToolCall).innerJoin(agentMessage, eq2(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, eq2(agentMessage.threadId, agentThread.id)).where(whereClause);
+    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,
+      runId: agentToolCall.runId
+    }).from(agentToolCall).innerJoin(agentMessage, eq2(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, eq2(agentMessage.threadId, agentThread.id)).where(whereClause).orderBy(asc2(agentToolCall.createdAt), asc2(agentToolCall.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+    return {
+      rows: 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(),
+        runId: row.runId
       })),
       total: totalRow?.value ?? 0,
       page: query.page,
       pageSize: query.pageSize
     };
   }
+  /**
+  * One run, its owning thread's headline and its tool calls — TWO queries regardless of how many
+  * tools the run called. `toolCalls` comes off `agent_tool_call.run_id`, so a run recorded before
+  * that column was written reports none.
+  */
+  async runDetail(runId) {
+    const [row] = await this.db.select({
+      run: agentRun,
+      thread: agentThread
+    }).from(agentRun).innerJoin(agentThread, eq2(agentRun.threadId, agentThread.id)).where(eq2(agentRun.id, runId)).limit(1);
+    if (row === void 0) {
+      return null;
+    }
+    const toolCalls = await this.db.select().from(agentToolCall).where(eq2(agentToolCall.runId, runId)).orderBy(asc2(agentToolCall.createdAt), asc2(agentToolCall.id));
+    return {
+      run: toRecentRunRow(row.run),
+      thread: {
+        threadId: row.thread.id,
+        title: row.thread.title,
+        actorRef: row.thread.actorRef,
+        deleted: row.thread.deletedAt != null
+      },
+      toolCalls: toolCalls.map(toRunToolCallRow)
+    };
+  }
+  /**
+  * One thread with its lifetime usage rollup, its newest runs and its newest messages. A fixed six
+  * queries (thread, usage, message count, message page, that page's tool-call counts, runs+count) —
+  * the per-message tool-call counts are ONE grouped read over the returned message ids, not one per
+  * message. Soft-deleted threads are returned with `deleted: true`; an audit still needs them.
+  */
+  async threadDetail(query) {
+    const [thread] = await this.db.select().from(agentThread).where(eq2(agentThread.id, query.threadId)).limit(1);
+    if (thread === void 0) {
+      return null;
+    }
+    const pricing = await this.loadPricing();
+    const usageRows = await this.db.select().from(agentTokenUsage).where(eq2(agentTokenUsage.threadId, thread.id));
+    const usage = rollupThreadUsage(usageRows.map(toUsageInput), pricing);
+    const [messageCountRow] = await this.db.select({
+      value: count()
+    }).from(agentMessage).where(eq2(agentMessage.threadId, thread.id));
+    const messages = await this.db.select().from(agentMessage).where(eq2(agentMessage.threadId, thread.id)).orderBy(desc2(agentMessage.createdAt), desc2(agentMessage.id)).limit(query.messageLimit);
+    const toolCallCounts = await this.toolCallCountsByMessage(messages.map((message) => message.id));
+    const [runTotalRow] = await this.db.select({
+      value: count()
+    }).from(agentRun).where(eq2(agentRun.threadId, thread.id));
+    const runs = await this.db.select().from(agentRun).where(eq2(agentRun.threadId, thread.id)).orderBy(desc2(agentRun.startedAt), desc2(agentRun.id)).limit(query.runLimit);
+    return {
+      thread: {
+        threadId: thread.id,
+        title: thread.title,
+        actorRef: thread.actorRef,
+        messageCount: messageCountRow?.value ?? 0,
+        totalTokens: usage.totalTokens,
+        lastActivityAt: thread.updatedAt.toISOString()
+      },
+      deleted: thread.deletedAt != null,
+      usage,
+      runs: runs.map(toRecentRunRow),
+      runTotal: runTotalRow?.value ?? 0,
+      messages: messages.map((message) => {
+        const { content, truncated } = truncateDetailContent(message.content);
+        return {
+          messageId: message.id,
+          role: message.role,
+          content,
+          truncated,
+          agentName: message.agentName ?? null,
+          toolCallCount: toolCallCounts.get(message.id) ?? 0,
+          createdAt: message.createdAt.toISOString()
+        };
+      })
+    };
+  }
+  /** Tool-call counts for a set of messages in ONE grouped query — the detail view's no-N+1 guarantee. */
+  async toolCallCountsByMessage(messageIds) {
+    const counts = /* @__PURE__ */ new Map();
+    if (messageIds.length === 0) {
+      return counts;
+    }
+    const rows = await this.db.select({
+      messageId: agentToolCall.messageId,
+      value: count()
+    }).from(agentToolCall).where(inArray2(agentToolCall.messageId, messageIds)).groupBy(agentToolCall.messageId);
+    for (const row of rows) {
+      counts.set(row.messageId, row.value);
+    }
+    return counts;
+  }
 };
 
 // src/drizzle-pricing-store.ts