@dudousxd/nestjs-agent-telescope 0.1.0

package/dist/index.cjs

@@ -0,0 +1,641 @@
+"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, desc) => {
+  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: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentTelescopeWatcher: () => AgentTelescopeWatcher,
+  agentActorSpendTableProvider: () => agentActorSpendTableProvider,
+  agentDashboard: () => agentDashboard,
+  agentModelSpendTableProvider: () => agentModelSpendTableProvider,
+  agentRunsProvider: () => agentRunsProvider,
+  agentSpendByActorProvider: () => agentSpendByActorProvider,
+  agentSpendByModelProvider: () => agentSpendByModelProvider,
+  agentSpendTotalProvider: () => agentSpendTotalProvider,
+  agentTelescopeExtension: () => agentTelescopeExtension,
+  agentTokensProvider: () => agentTokensProvider,
+  agentTokensTotalProvider: () => agentTokensTotalProvider,
+  agentToolStatusProvider: () => agentToolStatusProvider,
+  agentToolsProvider: () => agentToolsProvider,
+  agentUsageTrendProvider: () => agentUsageTrendProvider,
+  resolveRange: () => resolveRange,
+  shiftUtcDay: () => shiftUtcDay,
+  toActorSpendRows: () => toActorSpendRows,
+  toActorSpendSegments: () => toActorSpendSegments,
+  toModelSpendRows: () => toModelSpendRows,
+  toModelSpendSegments: () => toModelSpendSegments,
+  toUsageTrendRows: () => toUsageTrendRows,
+  totalCostUsd: () => totalCostUsd,
+  totalTokens: () => totalTokens
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent-telescope.extension.ts
+var import_nestjs_telescope2 = require("@dudousxd/nestjs-telescope");
+
+// src/agent-dashboard.ts
+function agentDashboard() {
+  return {
+    id: "agent.overview",
+    label: "Agent",
+    panels: [],
+    sections: [
+      {
+        title: "Overview",
+        cols: 2,
+        panels: [
+          {
+            kind: "stat",
+            title: "Runs",
+            data: {
+              provider: "agent.runs"
+            }
+          },
+          {
+            kind: "stat",
+            title: "Tokens",
+            data: {
+              provider: "agent.tokens"
+            }
+          }
+        ]
+      },
+      {
+        title: "Spend",
+        cols: 2,
+        panels: [
+          {
+            kind: "stat",
+            title: "Total spend (USD)",
+            data: {
+              provider: "agent.spend.totalCost"
+            },
+            format: "number"
+          },
+          {
+            kind: "stat",
+            title: "Total tokens",
+            data: {
+              provider: "agent.spend.totalTokens"
+            },
+            format: "number"
+          },
+          {
+            kind: "breakdown",
+            title: "Spend by model",
+            data: {
+              provider: "agent.spend.byModel"
+            },
+            style: "donut"
+          },
+          {
+            kind: "timeseries",
+            title: "Daily spend & tokens",
+            data: {
+              provider: "agent.usage.trend"
+            },
+            series: [
+              "costUsd",
+              "totalTokens"
+            ],
+            style: "area"
+          }
+        ]
+      },
+      {
+        title: "Models",
+        panels: [
+          {
+            kind: "table",
+            title: "Usage & cost by model",
+            data: {
+              provider: "agent.spend.byModelTable"
+            },
+            columns: [
+              {
+                key: "modelId",
+                label: "Model"
+              },
+              {
+                key: "requests",
+                label: "Requests"
+              },
+              {
+                key: "inputTokens",
+                label: "Input tokens"
+              },
+              {
+                key: "outputTokens",
+                label: "Output tokens"
+              },
+              {
+                key: "costUsd",
+                label: "Cost (USD)"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        title: "Actors",
+        cols: 2,
+        panels: [
+          {
+            kind: "breakdown",
+            title: "Spend share by actor",
+            data: {
+              provider: "agent.spend.byActorShare"
+            },
+            style: "bar"
+          },
+          {
+            kind: "table",
+            title: "Spend by actor",
+            data: {
+              provider: "agent.spend.byActor"
+            },
+            columns: [
+              {
+                key: "actorRef",
+                label: "Actor"
+              },
+              {
+                key: "requests",
+                label: "Requests"
+              },
+              {
+                key: "totalTokens",
+                label: "Tokens"
+              },
+              {
+                key: "costUsd",
+                label: "Cost (USD)"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        title: "Tools",
+        cols: 2,
+        panels: [
+          {
+            kind: "breakdown",
+            title: "Tool-call status",
+            data: {
+              provider: "agent.toolStatus"
+            },
+            style: "donut"
+          },
+          {
+            kind: "table",
+            title: "Recent tool calls",
+            data: {
+              provider: "agent.tools"
+            },
+            columns: [
+              {
+                key: "toolName",
+                label: "Tool"
+              },
+              {
+                key: "toolType",
+                label: "Type"
+              },
+              {
+                key: "status",
+                label: "Status"
+              },
+              {
+                key: "runId",
+                label: "Run"
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+}
+__name(agentDashboard, "agentDashboard");
+
+// src/agent-data-providers.ts
+var import_nestjs_telescope = require("@dudousxd/nestjs-telescope");
+async function fetchEntries(ctx) {
+  const storage = ctx.moduleRef.get(import_nestjs_telescope.TELESCOPE_STORAGE, {
+    strict: false
+  });
+  const page = await storage.get({
+    type: "agent",
+    limit: 5e3
+  });
+  return page.data;
+}
+__name(fetchEntries, "fetchEntries");
+function ofEvent(entries, event) {
+  return entries.filter((entry) => entry.content?.event === event);
+}
+__name(ofEvent, "ofEvent");
+function agentRunsProvider() {
+  return {
+    name: "agent.runs",
+    async resolve(_query, ctx) {
+      const finished = ofEvent(await fetchEntries(ctx), "run.finished");
+      return {
+        value: finished.length
+      };
+    }
+  };
+}
+__name(agentRunsProvider, "agentRunsProvider");
+function agentTokensProvider() {
+  return {
+    name: "agent.tokens",
+    async resolve(_query, ctx) {
+      const finished = ofEvent(await fetchEntries(ctx), "run.finished");
+      const value = finished.reduce((sum, entry) => sum + (entry.content?.inputTokens ?? 0) + (entry.content?.outputTokens ?? 0), 0);
+      return {
+        value
+      };
+    }
+  };
+}
+__name(agentTokensProvider, "agentTokensProvider");
+function agentToolsProvider() {
+  return {
+    name: "agent.tools",
+    async resolve(_query, ctx) {
+      const calls = ofEvent(await fetchEntries(ctx), "tool-call").slice(-50).reverse().map((entry) => ({
+        toolName: entry.content?.toolName ?? "",
+        toolType: entry.content?.toolType ?? "",
+        status: entry.content?.status ?? "",
+        runId: entry.content?.runId ?? ""
+      }));
+      return {
+        rows: calls
+      };
+    }
+  };
+}
+__name(agentToolsProvider, "agentToolsProvider");
+function agentToolStatusProvider() {
+  return {
+    name: "agent.toolStatus",
+    async resolve(_query, ctx) {
+      const calls = ofEvent(await fetchEntries(ctx), "tool-call");
+      const counts = /* @__PURE__ */ new Map();
+      for (const call of calls) {
+        const status = call.content?.status ?? "unknown";
+        counts.set(status, (counts.get(status) ?? 0) + 1);
+      }
+      return {
+        segments: [
+          ...counts.entries()
+        ].map(([label, value]) => ({
+          label,
+          value
+        }))
+      };
+    }
+  };
+}
+__name(agentToolStatusProvider, "agentToolStatusProvider");
+
+// src/agent-governance-providers.ts
+var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
+var DEFAULT_TREND_WINDOW_DAYS = 30;
+var ISO_DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isRecord, "isRecord");
+function isGovernanceQueries(value) {
+  return isRecord(value) && typeof value.spendByModel === "function" && typeof value.spendByActor === "function" && typeof value.usageTrend === "function" && typeof value.recentToolCalls === "function" && typeof value.recentThreads === "function";
+}
+__name(isGovernanceQueries, "isGovernanceQueries");
+function resolveGovernanceQueries(ctx) {
+  let resolved;
+  try {
+    resolved = ctx.moduleRef.get(import_nestjs_agent_core.AGENT_GOVERNANCE_QUERIES, {
+      strict: false
+    });
+  } catch {
+    return null;
+  }
+  return isGovernanceQueries(resolved) ? resolved : null;
+}
+__name(resolveGovernanceQueries, "resolveGovernanceQueries");
+function isIsoDay(value) {
+  return typeof value === "string" && ISO_DAY_PATTERN.test(value);
+}
+__name(isIsoDay, "isIsoDay");
+function todayUtcDay() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+__name(todayUtcDay, "todayUtcDay");
+function shiftUtcDay(day, deltaDays) {
+  const shifted = /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+  shifted.setUTCDate(shifted.getUTCDate() + deltaDays);
+  return shifted.toISOString().slice(0, 10);
+}
+__name(shiftUtcDay, "shiftUtcDay");
+function resolveRange(query) {
+  const toDay = query && isIsoDay(query.toDay) ? query.toDay : todayUtcDay();
+  const fromDay = query && isIsoDay(query.fromDay) ? query.fromDay : shiftUtcDay(toDay, -(DEFAULT_TREND_WINDOW_DAYS - 1));
+  return {
+    fromDay,
+    toDay
+  };
+}
+__name(resolveRange, "resolveRange");
+function roundCents(value) {
+  return Math.round(value * 100) / 100;
+}
+__name(roundCents, "roundCents");
+function totalCostUsd(rows) {
+  return roundCents(rows.reduce((sum, row) => sum + row.costUsd, 0));
+}
+__name(totalCostUsd, "totalCostUsd");
+function totalTokens(rows) {
+  return rows.reduce((sum, row) => sum + row.inputTokens + row.outputTokens, 0);
+}
+__name(totalTokens, "totalTokens");
+function toModelSpendSegments(rows) {
+  return rows.filter((row) => row.costUsd > 0).map((row) => ({
+    label: row.modelId,
+    value: roundCents(row.costUsd)
+  }));
+}
+__name(toModelSpendSegments, "toModelSpendSegments");
+function toModelSpendRows(rows) {
+  return rows.map((row) => ({
+    modelId: row.modelId,
+    requests: row.requests,
+    inputTokens: row.inputTokens,
+    outputTokens: row.outputTokens,
+    costUsd: roundCents(row.costUsd)
+  }));
+}
+__name(toModelSpendRows, "toModelSpendRows");
+function toActorSpendRows(rows) {
+  return rows.map((row) => ({
+    actorRef: row.actorRef,
+    requests: row.requests,
+    totalTokens: row.totalTokens,
+    costUsd: roundCents(row.costUsd)
+  }));
+}
+__name(toActorSpendRows, "toActorSpendRows");
+function toActorSpendSegments(rows) {
+  return rows.filter((row) => row.costUsd > 0).map((row) => ({
+    label: row.actorRef,
+    value: roundCents(row.costUsd)
+  }));
+}
+__name(toActorSpendSegments, "toActorSpendSegments");
+function toUsageTrendRows(points) {
+  return points.map((point) => ({
+    label: point.day,
+    costUsd: roundCents(point.costUsd),
+    totalTokens: point.totalTokens
+  }));
+}
+__name(toUsageTrendRows, "toUsageTrendRows");
+function agentSpendTotalProvider() {
+  return {
+    name: "agent.spend.totalCost",
+    async resolve(query, ctx) {
+      const queries = resolveGovernanceQueries(ctx);
+      if (!queries) {
+        return {
+          value: 0
+        };
+      }
+      const byModel = await queries.spendByModel(resolveRange(query));
+      return {
+        value: totalCostUsd(byModel)
+      };
+    }
+  };
+}
+__name(agentSpendTotalProvider, "agentSpendTotalProvider");
+function agentTokensTotalProvider() {
+  return {
+    name: "agent.spend.totalTokens",
+    async resolve(query, ctx) {
+      const queries = resolveGovernanceQueries(ctx);
+      if (!queries) {
+        return {
+          value: 0
+        };
+      }
+      const byModel = await queries.spendByModel(resolveRange(query));
+      return {
+        value: totalTokens(byModel)
+      };
+    }
+  };
+}
+__name(agentTokensTotalProvider, "agentTokensTotalProvider");
+function agentSpendByModelProvider() {
+  return {
+    name: "agent.spend.byModel",
+    async resolve(query, ctx) {
+      const queries = resolveGovernanceQueries(ctx);
+      if (!queries) {
+        return {
+          segments: []
+        };
+      }
+      const byModel = await queries.spendByModel(resolveRange(query));
+      return {
+        segments: toModelSpendSegments(byModel)
+      };
+    }
+  };
+}
+__name(agentSpendByModelProvider, "agentSpendByModelProvider");
+function agentModelSpendTableProvider() {
+  return {
+    name: "agent.spend.byModelTable",
+    async resolve(query, ctx) {
+      const queries = resolveGovernanceQueries(ctx);
+      if (!queries) {
+        return {
+          rows: []
+        };
+      }
+      const byModel = await queries.spendByModel(resolveRange(query));
+      return {
+        rows: toModelSpendRows(byModel)
+      };
+    }
+  };
+}
+__name(agentModelSpendTableProvider, "agentModelSpendTableProvider");
+function agentUsageTrendProvider() {
+  return {
+    name: "agent.usage.trend",
+    async resolve(query, ctx) {
+      const queries = resolveGovernanceQueries(ctx);
+      if (!queries) {
+        return {
+          rows: []
+        };
+      }
+      const trend = await queries.usageTrend(resolveRange(query));
+      return {
+        rows: toUsageTrendRows(trend)
+      };
+    }
+  };
+}
+__name(agentUsageTrendProvider, "agentUsageTrendProvider");
+function agentActorSpendTableProvider() {
+  return {
+    name: "agent.spend.byActor",
+    async resolve(query, ctx) {
+      const queries = resolveGovernanceQueries(ctx);
+      if (!queries) {
+        return {
+          rows: []
+        };
+      }
+      const byActor = await queries.spendByActor(resolveRange(query));
+      return {
+        rows: toActorSpendRows(byActor)
+      };
+    }
+  };
+}
+__name(agentActorSpendTableProvider, "agentActorSpendTableProvider");
+function agentSpendByActorProvider() {
+  return {
+    name: "agent.spend.byActorShare",
+    async resolve(query, ctx) {
+      const queries = resolveGovernanceQueries(ctx);
+      if (!queries) {
+        return {
+          segments: []
+        };
+      }
+      const byActor = await queries.spendByActor(resolveRange(query));
+      return {
+        segments: toActorSpendSegments(byActor)
+      };
+    }
+  };
+}
+__name(agentSpendByActorProvider, "agentSpendByActorProvider");
+
+// src/agent-telescope.watcher.ts
+var import_node_diagnostics_channel = require("diagnostics_channel");
+var import_nestjs_diagnostics = require("@dudousxd/nestjs-diagnostics");
+var AGENT_EVENTS = [
+  "run.started",
+  "message",
+  "tool-call",
+  "quota.exceeded",
+  "run.finished"
+];
+var AgentTelescopeWatcher = class {
+  static {
+    __name(this, "AgentTelescopeWatcher");
+  }
+  type = "agent";
+  register(ctx) {
+    for (const event of AGENT_EVENTS) {
+      (0, import_node_diagnostics_channel.subscribe)((0, import_nestjs_diagnostics.channelName)("agent", event), (message) => {
+        const envelope = message;
+        ctx.record({
+          type: "agent",
+          content: {
+            event: envelope.event,
+            ...envelope.payload
+          },
+          tags: [
+            envelope.event
+          ]
+        });
+      });
+    }
+  }
+};
+
+// src/agent-telescope.extension.ts
+function agentTelescopeExtension() {
+  return (0, import_nestjs_telescope2.defineTelescopeExtension)({
+    name: "agent",
+    watchers: /* @__PURE__ */ __name(() => [
+      new AgentTelescopeWatcher()
+    ], "watchers"),
+    entryTypes: /* @__PURE__ */ __name(() => [
+      {
+        id: "agent",
+        label: "Agent",
+        dot: "bg-violet-400"
+      }
+    ], "entryTypes"),
+    dashboards: /* @__PURE__ */ __name(() => [
+      agentDashboard()
+    ], "dashboards"),
+    dataProviders: /* @__PURE__ */ __name(() => [
+      agentRunsProvider(),
+      agentTokensProvider(),
+      agentToolsProvider(),
+      agentToolStatusProvider(),
+      agentSpendTotalProvider(),
+      agentTokensTotalProvider(),
+      agentSpendByModelProvider(),
+      agentModelSpendTableProvider(),
+      agentUsageTrendProvider(),
+      agentActorSpendTableProvider(),
+      agentSpendByActorProvider()
+    ], "dataProviders")
+  });
+}
+__name(agentTelescopeExtension, "agentTelescopeExtension");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentTelescopeWatcher,
+  agentActorSpendTableProvider,
+  agentDashboard,
+  agentModelSpendTableProvider,
+  agentRunsProvider,
+  agentSpendByActorProvider,
+  agentSpendByModelProvider,
+  agentSpendTotalProvider,
+  agentTelescopeExtension,
+  agentTokensProvider,
+  agentTokensTotalProvider,
+  agentToolStatusProvider,
+  agentToolsProvider,
+  agentUsageTrendProvider,
+  resolveRange,
+  shiftUtcDay,
+  toActorSpendRows,
+  toActorSpendSegments,
+  toModelSpendRows,
+  toModelSpendSegments,
+  toUsageTrendRows,
+  totalCostUsd,
+  totalTokens
+});
+//# sourceMappingURL=index.cjs.map