@sentry/junior 0.202.0 → 0.204.0

package/dist/db-BeyXKJOI.d.ts

@@ -0,0 +1,5 @@
+import "./store-C5qxF2ac.js";
+import { z } from "zod";
+import "drizzle-orm/pg-core";
+import "drizzle-orm/migrator";
+import "drizzle-orm/pg-core/session";

package/dist/destinations-BeBiJeEM.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { index, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+//#region src/db/schema/timestamps.ts
+const timestamptz = (name) => timestamp(name, { withTimezone: true });
+//#endregion
+//#region src/db/schema/destinations.ts
+const juniorDestinationKindSchema = z.enum([
+	"channel",
+	"dm",
+	"group",
+	"local_conversation",
+	"thread",
+	"web_session"
+]);
+const juniorDestinations = pgTable("junior_destinations", {
+	id: text("id").primaryKey(),
+	provider: text("provider").notNull(),
+	providerTenantId: text("provider_tenant_id").notNull().default(""),
+	providerDestinationId: text("provider_destination_id").notNull(),
+	kind: text("kind").$type().notNull(),
+	parentDestinationId: text("parent_destination_id"),
+	displayName: text("display_name"),
+	visibility: text("visibility").$type().notNull().default("unknown"),
+	metadata: jsonb("metadata_json"),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull()
+}, (table) => [uniqueIndex("junior_destinations_provider_destination_uidx").on(table.provider, table.providerTenantId, table.providerDestinationId), index("junior_destinations_provider_kind_idx").on(table.provider, table.kind)]);
+//#endregion
+export { juniorDestinations as n, timestamptz as r, juniorDestinationKindSchema as t };

package/dist/execution-stats-DWfSihcH.js

@@ -0,0 +1,373 @@
+import { f as logWarn } from "./logging-BzAk1S_s.js";
+import { Et as getDb } from "./agent-hooks-Bbcp9e33.js";
+import { C as juniorConversations, s as juniorTaskExecutions } from "./executor-DcMSlI5c.js";
+import { n as agentTurnCostUsd, r as agentTurnTotalTokens } from "./usage-D3EbSO7w.js";
+import { and, asc, count, desc, eq, gte, inArray, lte, max, or, sql } from "drizzle-orm";
+//#region src/api/conversations/aggregate.ts
+function usageTokenValue(source, field) {
+	return sql`CASE
+    WHEN ${source.usage}->>${field} IS NOT NULL
+      THEN (${source.usage}->>${field})::double precision
+    ELSE NULL
+  END`;
+}
+function tokenValue(source) {
+	return sql`
+    CASE
+      WHEN COALESCE(
+        ${source.usage}->>'inputTokens',
+        ${source.usage}->>'outputTokens',
+        ${source.usage}->>'cachedInputTokens',
+        ${source.usage}->>'cacheCreationTokens'
+      ) IS NOT NULL
+        THEN COALESCE((${source.usage}->>'inputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'outputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cachedInputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cacheCreationTokens')::double precision, 0)
+      WHEN ${source.usage}->>'totalTokens' IS NOT NULL
+        THEN (${source.usage}->>'totalTokens')::double precision
+      ELSE NULL
+    END
+  `;
+}
+function costValue(source) {
+	return conversationUsageCostExpr(source.usage);
+}
+/** Read one conversation row's usage cost as a SQL expression. */
+function conversationUsageCostExpr(usage) {
+	return sql`
+    CASE
+      WHEN ${usage}->'cost'->>'total' IS NOT NULL
+        THEN (${usage}->'cost'->>'total')::double precision
+      WHEN COALESCE(
+        ${usage}->'cost'->>'input',
+        ${usage}->'cost'->>'output',
+        ${usage}->'cost'->>'cacheRead',
+        ${usage}->'cost'->>'cacheWrite'
+      ) IS NOT NULL
+        THEN COALESCE((${usage}->'cost'->>'input')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'output')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'cacheRead')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'cacheWrite')::double precision, 0)
+      ELSE NULL
+    END
+  `;
+}
+/** Select complete conversation metrics inside the database instead of materializing source rows. */
+function conversationAggregateColumns(sources) {
+	const metrics = sources?.metrics ?? juniorConversations;
+	const roots = sources?.roots ?? juniorConversations;
+	const conversationCount = sources ? sql`COUNT(DISTINCT ${roots.conversationId})` : sql`COUNT(*)`;
+	return {
+		active: sql`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} NOT IN ('idle', 'failed')
+    )::integer`,
+		conversations: sql`${conversationCount}::integer`,
+		cachedInputTokens: sql`SUM(${usageTokenValue(metrics, "cachedInputTokens")})::double precision`,
+		costUsd: sql`SUM(${costValue(metrics)})::double precision`,
+		durationMs: sql`COALESCE(SUM(${metrics.durationMs}), 0)::double precision`,
+		failed: sql`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} = 'failed'
+    )::integer`,
+		inputTokens: sql`SUM(${usageTokenValue(metrics, "inputTokens")})::double precision`,
+		tokens: sql`SUM(${tokenValue(metrics)})::double precision`
+	};
+}
+/** Select the complete first/last activity range for a grouped conversation aggregate. */
+function conversationRangeColumns() {
+	return {
+		firstSeenAt: sql`MIN(${juniorConversations.createdAt})`.mapWith(juniorConversations.createdAt),
+		lastSeenAt: sql`MAX(${juniorConversations.lastActivityAt})`.mapWith(juniorConversations.lastActivityAt)
+	};
+}
+/** Count distinct UTC activity dates without loading conversation timestamps into the app. */
+function conversationActiveDaysColumn() {
+	return sql`COUNT(DISTINCT (${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC')::date)::integer`;
+}
+//#endregion
+//#region src/chat/tasks/execution-stats.ts
+const TASK_EXECUTION_TYPES = ["scheduled", "event"];
+const TASK_EXECUTION_STATUSES = [
+	"blocked",
+	"completed",
+	"failed"
+];
+function addUsd(current, next) {
+	return Math.round((current + next) * 0xe8d4a51000) / 0xe8d4a51000;
+}
+const EMPTY_RUN_WINDOWS = {
+	1: 0,
+	7: 0,
+	30: 0,
+	90: 0
+};
+/** Empty run windows for tasks with no execution history. */
+function emptyTaskRunWindows() {
+	return { ...EMPTY_RUN_WINDOWS };
+}
+function utcDate(nowMs) {
+	return new Date(nowMs).toISOString().slice(0, 10);
+}
+function emptyDay(date) {
+	return {
+		costUsd: 0,
+		date,
+		event: 0,
+		scheduled: 0
+	};
+}
+function emptyStatusDay(date) {
+	return {
+		blocked: 0,
+		completed: 0,
+		date,
+		failed: 0
+	};
+}
+/** Record one terminal task execution and its durable conversation when present. */
+async function recordTaskExecution(type, taskId, options) {
+	const namespace = options.namespace ?? "junior";
+	const nowMs = options.nowMs ?? Date.now();
+	const status = options.status ?? "completed";
+	try {
+		await getDb().insert(juniorTaskExecutions).values({
+			...options.conversationId ? { conversationId: options.conversationId } : void 0,
+			executedAtMs: nowMs,
+			executionId: options.executionId,
+			kind: type,
+			namespace,
+			status,
+			taskId
+		}).onConflictDoNothing({ target: [
+			juniorTaskExecutions.kind,
+			juniorTaskExecutions.namespace,
+			juniorTaskExecutions.executionId
+		] });
+	} catch (error) {
+		logWarn("task.execution.stat_failed", {
+			error,
+			"app.task.execution.id": options.executionId,
+			"app.task.execution.namespace": namespace,
+			"app.task.execution.status": status,
+			"app.task.execution.task_id": taskId,
+			"app.task.execution.type": type
+		});
+	}
+}
+/** Load usage analytics for all tasks of one type and namespace. */
+async function readTaskExecutionSummaries(type, namespace, options = {}) {
+	const nowMs = options.nowMs ?? Date.now();
+	const oneDayAgoMs = nowMs - 864e5;
+	const sevenDaysAgoMs = nowMs - 6048e5;
+	const thirtyDaysAgoMs = nowMs - 2592e6;
+	const ninetyDaysAgoMs = nowMs - 7776e6;
+	const db = getDb();
+	const latest = db.selectDistinctOn([juniorTaskExecutions.taskId], {
+		conversationId: juniorTaskExecutions.conversationId,
+		taskId: juniorTaskExecutions.taskId
+	}).from(juniorTaskExecutions).where(and(eq(juniorTaskExecutions.kind, type), eq(juniorTaskExecutions.namespace, namespace))).orderBy(juniorTaskExecutions.taskId, desc(juniorTaskExecutions.executedAtMs), desc(juniorTaskExecutions.executionId)).as("latest_task_execution");
+	const rows = await db.select({
+		lastConversationId: latest.conversationId,
+		lastExecutedAtMs: max(juniorTaskExecutions.executedAtMs),
+		runsLast1Day: sql`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${oneDayAgoMs})::int`,
+		runsLast7Days: sql`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${sevenDaysAgoMs})::int`,
+		runsLast30Days: sql`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${thirtyDaysAgoMs})::int`,
+		runsLast90Days: sql`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${ninetyDaysAgoMs})::int`,
+		taskId: juniorTaskExecutions.taskId,
+		totalRuns: sql`count(*)::int`
+	}).from(juniorTaskExecutions).innerJoin(latest, eq(latest.taskId, juniorTaskExecutions.taskId)).where(and(eq(juniorTaskExecutions.kind, type), eq(juniorTaskExecutions.namespace, namespace))).groupBy(juniorTaskExecutions.taskId, latest.conversationId);
+	return new Map(rows.map((row) => [row.taskId, {
+		...row.lastConversationId ? { lastConversationId: row.lastConversationId } : void 0,
+		...row.lastExecutedAtMs !== null ? { lastExecutedAtMs: row.lastExecutedAtMs } : void 0,
+		runs: {
+			1: row.runsLast1Day,
+			7: row.runsLast7Days,
+			30: row.runsLast30Days,
+			90: row.runsLast90Days
+		},
+		totalRuns: row.totalRuns
+	}]));
+}
+/** Load a fixed trailing window of completed executions stacked by task type. */
+async function readTaskExecutionDays(dayCount = 90, options = {}) {
+	const end = utcDate(options.nowMs ?? Date.now());
+	const endMs = Date.parse(`${end}T23:59:59.999Z`);
+	const startMs = Date.parse(`${end}T00:00:00.000Z`) - (dayCount - 1) * 864e5;
+	const executionDate = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+	const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
+	const rows = await getDb().select({
+		count: count(),
+		costUsd: sql`SUM(${conversationCost})::double precision`,
+		date: executionDate,
+		kind: juniorTaskExecutions.kind
+	}).from(juniorTaskExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorTaskExecutions.conversationId)).where(and(gte(juniorTaskExecutions.executedAtMs, startMs), lte(juniorTaskExecutions.executedAtMs, endMs), eq(juniorTaskExecutions.status, "completed"))).groupBy(executionDate, juniorTaskExecutions.kind).orderBy(asc(executionDate), asc(juniorTaskExecutions.kind));
+	const byDate = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < dayCount; offset += 1) {
+		const date = utcDate(startMs + offset * 864e5);
+		byDate.set(date, emptyDay(date));
+	}
+	for (const row of rows) {
+		const day = byDate.get(row.date);
+		if (!day) continue;
+		if (row.kind === "scheduled") day.scheduled = row.count;
+		else if (row.kind === "event") day.event = row.count;
+		if (row.costUsd !== null && row.costUsd > 0) day.costUsd = addUsd(day.costUsd, row.costUsd);
+	}
+	return [...byDate.values()];
+}
+/** Load a fixed trailing window of completed executions stacked by hour. */
+async function readTaskExecutionHours(hourCount = 168, options = {}) {
+	const nowMs = options.nowMs ?? Date.now();
+	const end = new Date(nowMs);
+	end.setUTCMinutes(0, 0, 0);
+	const endMs = end.getTime() + 3599999;
+	const startMs = end.getTime() - (hourCount - 1) * 36e5;
+	const executionHour = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+	const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
+	const rows = await getDb().select({
+		count: count(),
+		costUsd: sql`SUM(${conversationCost})::double precision`,
+		date: executionHour,
+		kind: juniorTaskExecutions.kind
+	}).from(juniorTaskExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorTaskExecutions.conversationId)).where(and(gte(juniorTaskExecutions.executedAtMs, startMs), lte(juniorTaskExecutions.executedAtMs, endMs), eq(juniorTaskExecutions.status, "completed"))).groupBy(executionHour, juniorTaskExecutions.kind).orderBy(asc(executionHour), asc(juniorTaskExecutions.kind));
+	const byHour = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < hourCount; offset += 1) {
+		const date = new Date(startMs + offset * 36e5).toISOString().slice(0, 13);
+		byHour.set(date, emptyDay(date));
+	}
+	for (const row of rows) {
+		const hour = byHour.get(row.date);
+		if (!hour) continue;
+		if (row.kind === "scheduled") hour.scheduled = row.count;
+		else if (row.kind === "event") hour.event = row.count;
+		if (row.costUsd !== null && row.costUsd > 0) hour.costUsd = addUsd(hour.costUsd, row.costUsd);
+	}
+	return [...byHour.values()];
+}
+/** Load the newest terminal task execution linked to one conversation, if any. */
+async function readTaskExecutionByConversationId(args) {
+	const namespace = args.namespace ?? "junior";
+	const row = (await getDb().select({
+		kind: juniorTaskExecutions.kind,
+		taskId: juniorTaskExecutions.taskId
+	}).from(juniorTaskExecutions).where(and(eq(juniorTaskExecutions.conversationId, args.conversationId), eq(juniorTaskExecutions.namespace, namespace), inArray(juniorTaskExecutions.kind, [...TASK_EXECUTION_TYPES]))).orderBy(desc(juniorTaskExecutions.executedAtMs), desc(juniorTaskExecutions.executionId)).limit(1))[0];
+	if (!row) return void 0;
+	if (row.kind !== "scheduled" && row.kind !== "event") return void 0;
+	return {
+		kind: row.kind,
+		taskId: row.taskId
+	};
+}
+/** Load newest-first executions for one task, with conversation titles when present. */
+async function readTaskExecutions(args) {
+	const namespace = args.namespace ?? "junior";
+	return (await getDb().select({
+		conversationId: juniorTaskExecutions.conversationId,
+		durationMs: juniorConversations.durationMs,
+		executedAtMs: juniorTaskExecutions.executedAtMs,
+		executionId: juniorTaskExecutions.executionId,
+		status: juniorTaskExecutions.status,
+		title: juniorConversations.title,
+		usage: juniorConversations.usage
+	}).from(juniorTaskExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorTaskExecutions.conversationId)).where(and(eq(juniorTaskExecutions.kind, args.kind), eq(juniorTaskExecutions.namespace, namespace), eq(juniorTaskExecutions.taskId, args.taskId))).orderBy(desc(juniorTaskExecutions.executedAtMs), desc(juniorTaskExecutions.executionId)).limit(args.limit)).map((row) => mapTaskExecutionRecord(row));
+}
+/** Load newest-first executions for the supplied viewer-visible tasks. */
+async function readTaskRuns(args) {
+	const tasks = args.tasks ?? [];
+	const conversationIds = [...new Set((args.conversationIds ?? []).filter((conversationId) => conversationId.trim().length > 0))];
+	if (tasks.length === 0 && conversationIds.length === 0) return [];
+	const namespace = args.namespace ?? "junior";
+	const selectors = [...tasks.map((task) => and(eq(juniorTaskExecutions.kind, task.kind), eq(juniorTaskExecutions.taskId, task.taskId))), ...conversationIds.length > 0 ? [inArray(juniorTaskExecutions.conversationId, conversationIds)] : []];
+	return (await getDb().select({
+		conversationId: juniorTaskExecutions.conversationId,
+		durationMs: juniorConversations.durationMs,
+		executedAtMs: juniorTaskExecutions.executedAtMs,
+		executionId: juniorTaskExecutions.executionId,
+		kind: juniorTaskExecutions.kind,
+		status: juniorTaskExecutions.status,
+		taskId: juniorTaskExecutions.taskId,
+		title: juniorConversations.title,
+		usage: juniorConversations.usage
+	}).from(juniorTaskExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorTaskExecutions.conversationId)).where(and(eq(juniorTaskExecutions.namespace, namespace), or(...selectors))).orderBy(desc(juniorTaskExecutions.executedAtMs), desc(juniorTaskExecutions.executionId)).limit(args.limit)).flatMap((row) => {
+		if (row.kind !== "scheduled" && row.kind !== "event") return [];
+		return [{
+			...mapTaskExecutionRecord(row),
+			kind: row.kind,
+			taskId: row.taskId
+		}];
+	});
+}
+function mapTaskExecutionRecord(row) {
+	const title = row.title?.trim();
+	const costUsd = agentTurnCostUsd(row.usage ?? void 0);
+	const totalTokens = agentTurnTotalTokens(row.usage ?? void 0);
+	const durationMs = typeof row.durationMs === "number" && Number.isFinite(row.durationMs) && row.durationMs > 0 ? row.durationMs : void 0;
+	return {
+		...row.conversationId ? { conversationId: row.conversationId } : void 0,
+		...costUsd !== void 0 ? { costUsd } : void 0,
+		...durationMs !== void 0 ? { durationMs } : void 0,
+		executedAt: new Date(row.executedAtMs).toISOString(),
+		executionId: row.executionId,
+		status: row.status,
+		...title ? { title } : void 0,
+		...totalTokens !== void 0 ? { totalTokens } : void 0
+	};
+}
+/** Load a fixed trailing window of terminal executions for one task by status. */
+async function readTaskExecutionStatusDays(args) {
+	const dayCount = args.dayCount ?? 90;
+	const namespace = args.namespace ?? "junior";
+	const end = utcDate(args.nowMs ?? Date.now());
+	const endMs = Date.parse(`${end}T23:59:59.999Z`);
+	const startMs = Date.parse(`${end}T00:00:00.000Z`) - (dayCount - 1) * 864e5;
+	const executionDate = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+	const rows = await getDb().select({
+		count: count(),
+		date: executionDate,
+		status: juniorTaskExecutions.status
+	}).from(juniorTaskExecutions).where(and(eq(juniorTaskExecutions.kind, args.kind), eq(juniorTaskExecutions.namespace, namespace), eq(juniorTaskExecutions.taskId, args.taskId), gte(juniorTaskExecutions.executedAtMs, startMs), lte(juniorTaskExecutions.executedAtMs, endMs), inArray(juniorTaskExecutions.status, [...TASK_EXECUTION_STATUSES]))).groupBy(executionDate, juniorTaskExecutions.status).orderBy(asc(executionDate), asc(juniorTaskExecutions.status));
+	const byDate = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < dayCount; offset += 1) {
+		const date = utcDate(startMs + offset * 864e5);
+		byDate.set(date, emptyStatusDay(date));
+	}
+	for (const row of rows) {
+		const day = byDate.get(row.date);
+		if (!day) continue;
+		if (row.status === "completed") day.completed = row.count;
+		else if (row.status === "failed") day.failed = row.count;
+		else if (row.status === "blocked") day.blocked = row.count;
+	}
+	return [...byDate.values()];
+}
+/** Load a fixed trailing window of terminal executions for one task by hour. */
+async function readTaskExecutionStatusHours(args) {
+	const hourCount = args.hourCount ?? 168;
+	const namespace = args.namespace ?? "junior";
+	const nowMs = args.nowMs ?? Date.now();
+	const end = new Date(nowMs);
+	end.setUTCMinutes(0, 0, 0);
+	const endMs = end.getTime() + 3599999;
+	const startMs = end.getTime() - (hourCount - 1) * 36e5;
+	const executionHour = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+	const rows = await getDb().select({
+		count: count(),
+		date: executionHour,
+		status: juniorTaskExecutions.status
+	}).from(juniorTaskExecutions).where(and(eq(juniorTaskExecutions.kind, args.kind), eq(juniorTaskExecutions.namespace, namespace), eq(juniorTaskExecutions.taskId, args.taskId), gte(juniorTaskExecutions.executedAtMs, startMs), lte(juniorTaskExecutions.executedAtMs, endMs), inArray(juniorTaskExecutions.status, [...TASK_EXECUTION_STATUSES]))).groupBy(executionHour, juniorTaskExecutions.status).orderBy(asc(executionHour), asc(juniorTaskExecutions.status));
+	const byHour = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < hourCount; offset += 1) {
+		const date = new Date(startMs + offset * 36e5).toISOString().slice(0, 13);
+		byHour.set(date, emptyStatusDay(date));
+	}
+	for (const row of rows) {
+		const hour = byHour.get(row.date);
+		if (!hour) continue;
+		if (row.status === "completed") hour.completed = row.count;
+		else if (row.status === "failed") hour.failed = row.count;
+		else if (row.status === "blocked") hour.blocked = row.count;
+	}
+	return [...byHour.values()];
+}
+//#endregion
+export { readTaskExecutionStatusDays as a, readTaskExecutions as c, conversationActiveDaysColumn as d, conversationAggregateColumns as f, readTaskExecutionHours as i, readTaskRuns as l, readTaskExecutionByConversationId as n, readTaskExecutionStatusHours as o, conversationRangeColumns as p, readTaskExecutionDays as r, readTaskExecutionSummaries as s, emptyTaskRunWindows as t, recordTaskExecution as u };