@sentry/junior 0.66.3 → 0.67.1

package/dist/reporting.js

@@ -4,24 +4,25 @@ import {
   buildSentryTraceUrl,
   buildSystemPrompt,
   formatSlackConversationRedactedLabel,
+  getAgentPluginOperationalReports,
   getAgentTurnSessionRecord,
   listAgentTurnSessionSummaries,
   listAgentTurnSessionSummariesForConversation,
   resolveSlackConversationContextFromThreadId
-} from "./chunk-DG2I6GXC.js";
+} from "./chunk-5UIDU7XR.js";
 import {
   discoverSkills
-} from "./chunk-YL5G5YC4.js";
+} from "./chunk-V47RLIO2.js";
 import {
   canExposeConversationPayload,
   parseSlackThreadId,
   resolveConversationPrivacy
-} from "./chunk-SAYCFF7O.js";
+} from "./chunk-MT23VNOH.js";
 import {
   getPluginPackageContent,
   getPluginProviders,
   isRecord
-} from "./chunk-6QWWMZCK.js";
+} from "./chunk-OIIXZOOC.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   homeDir
@@ -34,6 +35,9 @@ import path from "path";
 var HUNG_TURN_PROGRESS_MS = 5 * 60 * 1e3;
 var SAFE_METADATA_KEY_LIMIT = 20;
 var PRIVATE_CONVERSATION_LABEL = "Private Conversation";
+var DASHBOARD_SESSION_FEED_LIMIT = 50;
+var DASHBOARD_CONVERSATION_STATS_LIMIT = 5e3;
+var RECENT_CONVERSATION_STATS_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
 function readDescriptionText() {
   try {
     const raw = readFileSync(
@@ -61,9 +65,9 @@ async function readPlugins() {
     name: plugin.manifest.name
   }));
 }
-function statusFromCheckpoint(summary) {
+function statusFromCheckpoint(summary, nowMs = Date.now()) {
   const state = summary.state;
-  if (state === "running" && Date.now() - summary.lastProgressAtMs > HUNG_TURN_PROGRESS_MS) {
+  if (state === "running" && nowMs - summary.lastProgressAtMs > HUNG_TURN_PROGRESS_MS) {
     return "hung";
   }
   if (state === "running" || state === "awaiting_resume") {
@@ -75,7 +79,13 @@ function statusFromCheckpoint(summary) {
   return state;
 }
 function surfaceFromConversationId(conversationId) {
-  return parseSlackThreadId(conversationId) ? "slack" : "internal";
+  if (parseSlackThreadId(conversationId)) return "slack";
+  if (conversationId.startsWith("scheduler:")) return "scheduler";
+  if (conversationId.startsWith("api:")) return "api";
+  return "internal";
+}
+function surfaceFromSummary(summary) {
+  return summary.surface ?? surfaceFromConversationId(summary.conversationId);
 }
 function titleFromSummary(summary) {
   if (summary.state === "awaiting_resume" && summary.resumeReason) {
@@ -104,7 +114,7 @@ function turnUsageReport(usage) {
   };
   return Object.keys(report).length > 0 ? report : void 0;
 }
-function sessionReportFromSummary(summary) {
+function sessionReportFromSummary(summary, nowMs = Date.now()) {
   const slackThread = parseSlackThreadId(summary.conversationId);
   const privacy = resolveConversationPrivacy({
     conversationId: summary.conversationId
@@ -126,14 +136,14 @@ function sessionReportFromSummary(summary) {
     conversationId: summary.conversationId,
     ...conversationTitle ? { conversationTitle } : {},
     id: summary.sessionId,
-    status: statusFromCheckpoint(summary),
+    status: statusFromCheckpoint(summary, nowMs),
     startedAt: new Date(summary.startedAtMs).toISOString(),
     lastProgressAt: new Date(summary.lastProgressAtMs).toISOString(),
     lastSeenAt: new Date(summary.updatedAtMs).toISOString(),
     ...summary.state === "completed" ? { completedAt: new Date(summary.updatedAtMs).toISOString() } : {},
     cumulativeDurationMs: summary.cumulativeDurationMs,
     ...cumulativeUsage ? { cumulativeUsage } : {},
-    surface: surfaceFromConversationId(summary.conversationId),
+    surface: surfaceFromSummary(summary),
     title: titleFromSummary(summary),
     ...requesterIdentity ? { requesterIdentity } : {},
     ...slackThread ? { channel: slackThread.channelId } : {},
@@ -143,6 +153,245 @@ function sessionReportFromSummary(summary) {
     ...sentryTraceUrl ? { sentryTraceUrl } : {}
   };
 }
+function reportTime(value) {
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? time : void 0;
+}
+function usageTokenTotal(usage) {
+  if (!usage) return void 0;
+  const components = [
+    usage.inputTokens,
+    usage.outputTokens,
+    usage.cachedInputTokens,
+    usage.cacheCreationTokens
+  ].reduce((sum, value) => {
+    const count = typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+    return count === void 0 ? sum : (sum ?? 0) + count;
+  }, void 0);
+  if (components !== void 0) {
+    return components;
+  }
+  return typeof usage.totalTokens === "number" && Number.isFinite(usage.totalTokens) ? Math.max(0, Math.floor(usage.totalTokens)) : void 0;
+}
+function turnDurationSnapshot(turn) {
+  return typeof turn.cumulativeDurationMs === "number" && Number.isFinite(turn.cumulativeDurationMs) ? Math.max(0, Math.floor(turn.cumulativeDurationMs)) : void 0;
+}
+function turnContributions(turns) {
+  let previousDuration = 0;
+  let previousTokens = 0;
+  return turns.map((turn) => {
+    const duration = turnDurationSnapshot(turn);
+    const tokens = usageTokenTotal(turn.cumulativeUsage);
+    const contribution = {
+      durationMs: duration === void 0 ? 0 : Math.max(0, duration - previousDuration),
+      turn
+    };
+    if (tokens !== void 0) {
+      contribution.tokens = Math.max(0, tokens - previousTokens);
+    }
+    if (duration !== void 0) {
+      previousDuration = Math.max(previousDuration, duration);
+    }
+    if (tokens !== void 0) {
+      previousTokens = Math.max(previousTokens, tokens);
+    }
+    return contribution;
+  });
+}
+function contributionDurationTotal(contributions) {
+  return contributions.reduce(
+    (sum, contribution) => sum + contribution.durationMs,
+    0
+  );
+}
+function addTokenTotal(total, tokens) {
+  return tokens === void 0 ? total : (total ?? 0) + tokens;
+}
+function contributionTokenTotal(contributions) {
+  return contributions.reduce(
+    (sum, contribution) => addTokenTotal(sum, contribution.tokens),
+    void 0
+  );
+}
+function requesterLabel(requester) {
+  const email = requester?.email?.trim() || void 0;
+  const fullName = requester?.fullName?.trim() || void 0;
+  const slackUserName = requester?.slackUserName?.trim() || void 0;
+  return email ?? fullName ?? slackUserName ?? requester?.slackUserId;
+}
+function slackStatsLocationLabel(input) {
+  const channelId = input.channel;
+  if (!channelId) return void 0;
+  const name = input.channelName?.replace(/^#/, "");
+  if (channelId.startsWith("D")) {
+    return "Direct Message";
+  }
+  if (channelId.startsWith("C")) {
+    return name ? `#${name}` : "Public Channel";
+  }
+  if (channelId.startsWith("G")) {
+    if (name?.startsWith("mpdm-")) return "Group DM";
+    return "Private Channel";
+  }
+  return name || channelId;
+}
+function locationLabel(turn) {
+  return slackStatsLocationLabel(turn) ?? (turn.surface === "scheduler" ? "Scheduler" : turn.surface === "api" ? "API" : turn.surface === "internal" ? "Internal" : "Unknown");
+}
+function emptyStatsItem(label) {
+  return {
+    active: 0,
+    conversations: 0,
+    durationMs: 0,
+    failed: 0,
+    hung: 0,
+    label,
+    turns: 0
+  };
+}
+function addItemTokens(item, tokens) {
+  if (tokens !== void 0) {
+    item.tokens = (item.tokens ?? 0) + tokens;
+  }
+}
+function statusSignals(turns) {
+  return {
+    active: turns.some((turn) => turn.status === "active"),
+    failed: turns.some((turn) => turn.status === "failed"),
+    hung: turns.some((turn) => turn.status === "hung")
+  };
+}
+function statsItems(map) {
+  return [...map.values()].sort(
+    (left, right) => right.conversations - left.conversations || right.turns - left.turns || right.durationMs - left.durationMs || left.label.localeCompare(right.label)
+  );
+}
+function newestTurn(turns) {
+  return [...turns].sort(
+    (left, right) => (reportTime(right.lastSeenAt) ?? 0) - (reportTime(left.lastSeenAt) ?? 0) || right.id.localeCompare(left.id)
+  )[0];
+}
+function recentConversationGroups(args) {
+  const startMs = args.nowMs - RECENT_CONVERSATION_STATS_WINDOW_MS;
+  const groups = /* @__PURE__ */ new Map();
+  for (const session of args.sessions) {
+    groups.set(session.conversationId, [
+      ...groups.get(session.conversationId) ?? [],
+      session
+    ]);
+  }
+  return [...groups.values()].map(
+    (turns) => [...turns].sort(
+      (left, right) => (reportTime(left.startedAt) ?? 0) - (reportTime(right.startedAt) ?? 0) || left.id.localeCompare(right.id)
+    )
+  ).filter((turns) => {
+    const activityAt = reportTime(newestTurn(turns).lastSeenAt);
+    return activityAt !== void 0 && activityAt >= startMs && activityAt <= args.nowMs;
+  });
+}
+function conversationDurationMs(turns) {
+  if (!turns.some((turn) => turnDurationSnapshot(turn) !== void 0)) {
+    return 0;
+  }
+  return contributionDurationTotal(turnContributions(turns));
+}
+function buildConversationStatsReport(args) {
+  const conversations = recentConversationGroups(args);
+  const requesters = /* @__PURE__ */ new Map();
+  const locations = /* @__PURE__ */ new Map();
+  let durationMs = 0;
+  let tokens;
+  let active = 0;
+  let failed = 0;
+  let hung = 0;
+  for (const turns of conversations) {
+    const contributions = turnContributions(turns);
+    const conversationSignals = statusSignals(turns);
+    const conversationTokens = contributionTokenTotal(contributions);
+    durationMs += contributionDurationTotal(contributions);
+    tokens = addTokenTotal(tokens, conversationTokens);
+    active += conversationSignals.active ? 1 : 0;
+    failed += conversationSignals.failed ? 1 : 0;
+    hung += conversationSignals.hung ? 1 : 0;
+    const requesterTurns = /* @__PURE__ */ new Map();
+    for (const contribution of contributions) {
+      const requester = requesterLabel(contribution.turn.requesterIdentity) ?? "Unknown";
+      requesterTurns.set(requester, [
+        ...requesterTurns.get(requester) ?? [],
+        contribution
+      ]);
+    }
+    for (const [requester, requesterContributions] of requesterTurns) {
+      const item = requesters.get(requester) ?? emptyStatsItem(requester);
+      const signals = statusSignals(
+        requesterContributions.map((contribution) => contribution.turn)
+      );
+      item.conversations += 1;
+      item.turns += requesterContributions.length;
+      item.durationMs += contributionDurationTotal(requesterContributions);
+      item.active += signals.active ? 1 : 0;
+      item.failed += signals.failed ? 1 : 0;
+      item.hung += signals.hung ? 1 : 0;
+      addItemTokens(item, contributionTokenTotal(requesterContributions));
+      requesters.set(requester, item);
+    }
+    const location = locationLabel(newestTurn(turns));
+    const locationItem = locations.get(location) ?? emptyStatsItem(location);
+    locationItem.conversations += 1;
+    locationItem.turns += turns.length;
+    locationItem.durationMs += conversationDurationMs(turns);
+    locationItem.active += conversationSignals.active ? 1 : 0;
+    locationItem.failed += conversationSignals.failed ? 1 : 0;
+    locationItem.hung += conversationSignals.hung ? 1 : 0;
+    addItemTokens(locationItem, conversationTokens);
+    locations.set(location, locationItem);
+  }
+  return {
+    active,
+    conversations: conversations.length,
+    durationMs,
+    failed,
+    generatedAt: args.generatedAt,
+    hung,
+    locations: statsItems(locations),
+    requesters: statsItems(requesters),
+    sampleLimit: args.sampleLimit,
+    sampleSize: args.sampleSize,
+    source: "turn_session_records",
+    ...tokens !== void 0 ? { tokens } : {},
+    truncated: args.truncated,
+    turns: conversations.reduce((sum, turns) => sum + turns.length, 0),
+    windowEnd: new Date(args.nowMs).toISOString(),
+    windowStart: new Date(
+      args.nowMs - RECENT_CONVERSATION_STATS_WINDOW_MS
+    ).toISOString()
+  };
+}
+async function completeSampledConversationSummaries(args) {
+  if (!args.truncated) {
+    return args.summaries;
+  }
+  const conversationIds = [
+    ...new Set(args.summaries.map((summary) => summary.conversationId))
+  ];
+  const groups = await Promise.all(
+    conversationIds.map(
+      (conversationId) => listAgentTurnSessionSummariesForConversation(conversationId)
+    )
+  );
+  const summariesByTurn = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const summary of group) {
+      summariesByTurn.set(
+        `${summary.conversationId}:${summary.sessionId}`,
+        summary
+      );
+    }
+  }
+  return [...summariesByTurn.values()].sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  );
+}
 function canExposeConversationTranscript(summary) {
   return canExposeConversationPayload({
     conversationId: summary.conversationId
@@ -365,11 +614,50 @@ function traceIdFromTranscript(transcript) {
   return void 0;
 }
 async function readSessions() {
-  const summaries = await listAgentTurnSessionSummaries(50);
+  const nowMs = Date.now();
+  const summaries = await listAgentTurnSessionSummaries(
+    DASHBOARD_SESSION_FEED_LIMIT
+  );
   return {
     source: "turn_session_records",
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sessions: summaries.map(sessionReportFromSummary)
+    generatedAt: new Date(nowMs).toISOString(),
+    sessions: summaries.map(
+      (summary) => sessionReportFromSummary(summary, nowMs)
+    )
+  };
+}
+async function readConversationStats() {
+  const nowMs = Date.now();
+  const generatedAt = new Date(nowMs).toISOString();
+  const summaries = await listAgentTurnSessionSummaries(
+    DASHBOARD_CONVERSATION_STATS_LIMIT + 1
+  );
+  const truncated = summaries.length >= DASHBOARD_CONVERSATION_STATS_LIMIT;
+  const sampledSummaries = summaries.slice(
+    0,
+    DASHBOARD_CONVERSATION_STATS_LIMIT
+  );
+  const reportSummaries = await completeSampledConversationSummaries({
+    summaries: sampledSummaries,
+    truncated
+  });
+  return buildConversationStatsReport({
+    generatedAt,
+    nowMs,
+    sampleLimit: DASHBOARD_CONVERSATION_STATS_LIMIT,
+    sampleSize: sampledSummaries.length,
+    sessions: reportSummaries.map(
+      (summary) => sessionReportFromSummary(summary, nowMs)
+    ),
+    truncated
+  });
+}
+async function readPluginOperationalReports() {
+  const nowMs = Date.now();
+  return {
+    source: "trusted_plugins",
+    generatedAt: new Date(nowMs).toISOString(),
+    reports: await getAgentPluginOperationalReports(nowMs)
   };
 }
 async function readConversation(conversationId) {
@@ -436,6 +724,8 @@ function createJuniorReporting() {
     getPlugins: readPlugins,
     getSkills: readSkills,
     getSessions: readSessions,
+    getConversationStats: readConversationStats,
+    getPluginOperationalReports: readPluginOperationalReports,
     getConversation: readConversation
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.66.3",
+  "version": "0.67.1",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -65,7 +65,7 @@
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.66.3"
+    "@sentry/junior-plugin-api": "0.67.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -77,7 +77,7 @@
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
     "vitest": "^4.1.7",
-    "@sentry/junior-scheduler": "0.66.3"
+    "@sentry/junior-scheduler": "0.67.1"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",