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

package/dist/index.cjs

@@ -543,8 +543,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((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);
-    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
@@ -644,6 +644,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,
@@ -753,25 +782,63 @@ var DrizzleGovernanceQueries = class {
       runId: row.runId
     }));
   }
-  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({
+  /**
+  * 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: (0, import_drizzle_orm3.count)()
+    }).from(agentMessage).where((0, import_drizzle_orm3.inArray)(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: (0, import_drizzle_orm3.sum)(agentTokenUsage.inputTokens),
+      outputTokens: (0, import_drizzle_orm3.sum)(agentTokenUsage.outputTokens)
+    }).from(agentTokenUsage).where((0, import_drizzle_orm3.inArray)(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((0, import_drizzle_orm3.isNull)(agentThread.deletedAt)).orderBy((0, import_drizzle_orm3.desc)(agentThread.updatedAt), (0, import_drizzle_orm3.desc)(agentThread.id)).limit(limit);
+    return this.toThreadActivityRows(threads);
   }
   async runsInRange(range) {
     const { start, end } = (0, import_nestjs_agent_core.dayBoundsUtc)(range);
@@ -873,19 +940,7 @@ var DrizzleGovernanceQueries = class {
   }
   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
-    }));
+    return runs.map(toRecentRunRow);
   }
   /**
   * Tool calls sitting `pending_approval`, oldest first (an inbox drains from the back), joined
@@ -918,8 +973,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 } = (0, import_nestjs_agent_core.dayBoundsUtc)(range);
@@ -952,6 +1009,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)
       });
     }
@@ -1013,22 +1071,7 @@ var DrizzleGovernanceQueries = class {
       value: (0, import_drizzle_orm3.count)()
     }).from(agentThread).where(whereClause);
     const threads = await this.db.select().from(agentThread).where(whereClause).orderBy((0, import_drizzle_orm3.desc)(agentThread.updatedAt), (0, import_drizzle_orm3.desc)(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: (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);
-      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,
@@ -1051,24 +1094,146 @@ var DrizzleGovernanceQueries = class {
     }).from(agentRun).where(whereClause);
     const runs = await this.db.select().from(agentRun).where(whereClause).orderBy((0, import_drizzle_orm3.desc)(agentRun.startedAt), (0, import_drizzle_orm3.desc)(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 = (0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(agentToolCall.status, "pending_approval"), filters?.toolName !== void 0 ? (0, import_drizzle_orm3.eq)(agentToolCall.toolName, filters.toolName) : void 0, filters?.threadId !== void 0 ? (0, import_drizzle_orm3.eq)(agentThread.id, filters.threadId) : void 0, filters?.actorRef !== void 0 ? (0, import_drizzle_orm3.eq)(agentThread.actorRef, filters.actorRef) : void 0, filters?.agentName !== void 0 ? (0, import_drizzle_orm3.eq)(agentMessage.agentName, filters.agentName) : void 0, filters?.fromDay !== void 0 ? (0, import_drizzle_orm3.gte)(agentToolCall.createdAt, dayStartUtc(filters.fromDay)) : void 0, filters?.toDay !== void 0 ? (0, import_drizzle_orm3.lte)(agentToolCall.createdAt, dayEndUtc(filters.toDay)) : void 0);
+    const [totalRow] = await this.db.select({
+      value: (0, import_drizzle_orm3.count)()
+    }).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(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, (0, import_drizzle_orm3.eq)(agentToolCall.messageId, agentMessage.id)).innerJoin(agentThread, (0, import_drizzle_orm3.eq)(agentMessage.threadId, agentThread.id)).where(whereClause).orderBy((0, import_drizzle_orm3.asc)(agentToolCall.createdAt), (0, import_drizzle_orm3.asc)(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, (0, import_drizzle_orm3.eq)(agentRun.threadId, agentThread.id)).where((0, import_drizzle_orm3.eq)(agentRun.id, runId)).limit(1);
+    if (row === void 0) {
+      return null;
+    }
+    const toolCalls = await this.db.select().from(agentToolCall).where((0, import_drizzle_orm3.eq)(agentToolCall.runId, runId)).orderBy((0, import_drizzle_orm3.asc)(agentToolCall.createdAt), (0, import_drizzle_orm3.asc)(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((0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.eq)(agentTokenUsage.threadId, thread.id));
+    const usage = (0, import_nestjs_agent_core.rollupThreadUsage)(usageRows.map(toUsageInput), pricing);
+    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 messages = await this.db.select().from(agentMessage).where((0, import_drizzle_orm3.eq)(agentMessage.threadId, thread.id)).orderBy((0, import_drizzle_orm3.desc)(agentMessage.createdAt), (0, import_drizzle_orm3.desc)(agentMessage.id)).limit(query.messageLimit);
+    const toolCallCounts = await this.toolCallCountsByMessage(messages.map((message) => message.id));
+    const [runTotalRow] = await this.db.select({
+      value: (0, import_drizzle_orm3.count)()
+    }).from(agentRun).where((0, import_drizzle_orm3.eq)(agentRun.threadId, thread.id));
+    const runs = await this.db.select().from(agentRun).where((0, import_drizzle_orm3.eq)(agentRun.threadId, thread.id)).orderBy((0, import_drizzle_orm3.desc)(agentRun.startedAt), (0, import_drizzle_orm3.desc)(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 } = (0, import_nestjs_agent_core.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: (0, import_drizzle_orm3.count)()
+    }).from(agentToolCall).where((0, import_drizzle_orm3.inArray)(agentToolCall.messageId, messageIds)).groupBy(agentToolCall.messageId);
+    for (const row of rows) {
+      counts.set(row.messageId, row.value);
+    }
+    return counts;
+  }
 };
 
 // src/drizzle-pricing-store.ts