@sentry/junior 0.265.0 → 0.267.0

package/dist/store-DvNZIsCr.js

@@ -0,0 +1,295 @@
+import { $t as appendExclusiveInboundMessage, Cn as requestConversationWork$1, En as stopConversationWork$1, Qt as ackMessages$1, Sn as requestAnotherSlice$1, Tn as steerWebPendingMessages$1, _n as markConversationWorkEnqueued$1, an as clearExpiredConversationLease$1, bn as releaseConversationWork$1, cn as deadLetterAttempt$1, dn as getConversationWorkState$1, en as appendInboundMessage, gn as listActiveConversationIds$1, in as clearConsumedConversationWake$1, ln as drainConversationMailbox$1, nn as cancelHumanFacingPendingMessages$1, on as completeConversationStop$1, rn as checkInConversationWork$1, sn as completeConversationWork$1, tn as beginConversationResume$1, un as getConversation$1, vn as recordAttemptFailure$1, wn as startConversationWork$1, xn as removeActiveConversation$1, yn as recordConversationRetry$1 } from "./tasks-0ilmuCux.js";
+import { f as getConversationStore } from "./viewer-DrN3oC2X.js";
+import "./job-queue-C0BZSa7r.js";
+// src/chat/task-execution/store.ts
+function metadataStore(options) {
+	return options.conversationStore ?? getConversationStore();
+}
+function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
+	return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
+}
+function hasRecentEnqueueMarker(conversation, nowMs) {
+	const lastEnqueuedAtMs = conversation.execution.lastEnqueuedAtMs;
+	return typeof lastEnqueuedAtMs === "number" && lastEnqueuedAtMs + 6e4 > nowMs;
+}
+function now() {
+	return Date.now();
+}
+async function recordExecutionMetadata(args) {
+	const conversation = await getConversation$1({
+		conversationId: args.conversationId,
+		state: args.state
+	});
+	if (!conversation) return;
+	await metadataStore(args).recordExecution({
+		channelName: conversation.channelName,
+		conversationId: conversation.conversationId,
+		createdAtMs: conversation.createdAtMs,
+		destination: conversation.destination,
+		execution: {
+			lastCheckpointAtMs: conversation.execution.lastCheckpointAtMs,
+			lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
+			runId: conversation.execution.runId,
+			status: conversation.execution.status,
+			updatedAtMs: conversation.execution.updatedAtMs
+		},
+		lastActivityAtMs: conversation.lastActivityAtMs,
+		metrics: null,
+		actor: conversation.actor,
+		source: conversation.source,
+		title: conversation.title,
+		updatedAtMs: conversation.updatedAtMs
+	});
+}
+/** Return a persisted conversation record, if one exists. */
+async function getConversation(args) {
+	return await getConversation$1(args);
+}
+/** Return a persisted conversation work record, if one exists. */
+async function getConversationWorkState(args) {
+	return await getConversationWorkState$1(args);
+}
+/** Count one failed conversation execution and persist its terminal retry state. */
+async function recordConversationRetry(args) {
+	const result = await recordConversationRetry$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Count mailbox messages that have not yet reached the conversation event log. */
+function countPendingConversationMessages(conversation) {
+	return conversation.execution.pendingMessages.length;
+}
+/** Return whether a conversation has pending or resumable execution work. */
+function hasRunnableConversationWork(conversation) {
+	return conversation.execution.status !== "idle" || countPendingConversationMessages(conversation) > 0;
+}
+/**
+* Ensure runnable conversation work has one accepted queue wake-up nudge.
+*
+* Ordinary wakes coalesce on a recent accepted marker. A caller can ignore the
+* marker without replacing an active lease. Replacement is only for consumed
+* or known-stale deliveries where another queue nudge must exist.
+*/
+async function ensureConversationWake(args) {
+	const nowMs = args.nowMs ?? now();
+	const conversation = await getConversation$1({
+		conversationId: args.conversationId,
+		state: args.state
+	});
+	if (!conversation || !hasRunnableConversationWork(conversation)) return { status: "no_work" };
+	if (args.replaceExistingWake !== true && conversation.execution.lease && conversation.execution.lease.expiresAtMs > nowMs) return { status: "lease_active" };
+	if (args.ignoreEnqueueMarker !== true && args.replaceExistingWake !== true && hasRecentEnqueueMarker(conversation, nowMs)) return { status: "already_enqueued" };
+	const queueResult = await args.queue.send({
+		schemaVersion: 2,
+		conversationId: args.conversationId
+	}, {
+		delayMs: args.delayMs,
+		idempotencyKey: args.idempotencyKey
+	});
+	await markConversationWorkEnqueued({
+		conversationId: args.conversationId,
+		conversationStore: args.conversationStore,
+		nowMs,
+		state: args.state
+	});
+	return {
+		status: "enqueued",
+		queueMessageId: queueResult?.messageId
+	};
+}
+async function enqueueAfterAppend(args) {
+	const nowMs = args.nowMs ?? now();
+	const appendResult = args.appendResult;
+	if (appendResult.status === "active") return appendResult;
+	let idempotencyKey = args.message.inboundMessageId;
+	if (appendResult.status === "duplicate") {
+		const conversation = await getConversation$1({
+			conversationId: args.message.conversationId,
+			state: args.state
+		});
+		if (!conversation) return appendResult;
+		if (hasRecentEnqueueMarker(conversation, nowMs)) {
+			await recordExecutionMetadata({
+				conversationId: args.message.conversationId,
+				conversationStore: args.conversationStore,
+				state: args.state
+			});
+			return appendResult;
+		}
+		if (!conversation.execution.pendingMessages.some((message) => message.inboundMessageId === args.message.inboundMessageId)) {
+			await recordExecutionMetadata({
+				conversationId: args.message.conversationId,
+				conversationStore: args.conversationStore,
+				state: args.state
+			});
+			return appendResult;
+		}
+		idempotencyKey = duplicateInboundNudgeIdempotencyKey(args.message, nowMs);
+	}
+	const wake = await ensureConversationWake({
+		conversationId: args.message.conversationId,
+		conversationStore: args.conversationStore,
+		delayMs: args.queueDelayMs,
+		idempotencyKey,
+		ignoreEnqueueMarker: args.message.source === "event" ? void 0 : true,
+		nowMs,
+		queue: args.queue,
+		replaceExistingWake: args.replaceExistingWake,
+		state: args.state
+	});
+	if (wake.status !== "enqueued") await recordExecutionMetadata({
+		conversationId: args.message.conversationId,
+		conversationStore: args.conversationStore,
+		state: args.state
+	});
+	return {
+		...appendResult,
+		...wake.status === "enqueued" ? { queueMessageId: wake.queueMessageId } : void 0
+	};
+}
+/** Persist inbound work and ensure a worker wake-up. */
+async function appendAndEnqueueInboundMessage(args) {
+	const nowMs = args.nowMs ?? now();
+	const result = await enqueueAfterAppend({
+		...args,
+		appendResult: await appendInboundMessage({
+			message: args.message,
+			nowMs,
+			state: args.state
+		}),
+		nowMs
+	});
+	if (result.status === "active") throw new Error("Non-exclusive mailbox enqueue returned active");
+	return result;
+}
+/** Persist exclusive inbound work and wake its worker when admitted. */
+async function appendAndEnqueueExclusiveInboundMessage(args) {
+	const nowMs = args.nowMs ?? now();
+	return await enqueueAfterAppend({
+		...args,
+		appendResult: await appendExclusiveInboundMessage({
+			message: args.message,
+			nowMs,
+			state: args.state
+		}),
+		nowMs
+	});
+}
+/** Persist a stop request for the current Conversation run. */
+async function stopConversationWork(args) {
+	const result = await stopConversationWork$1(args);
+	if (result.status === "requested") await recordExecutionMetadata(args);
+	return result;
+}
+/** Finish an observed stop request under the current worker lease. */
+async function completeConversationStop(args) {
+	const result = await completeConversationStop$1(args);
+	if (result.status === "cleared") await recordExecutionMetadata(args);
+	return result;
+}
+/** Clear an accepted wake marker after its delivery finds no runnable work. */
+async function clearConsumedConversationWake(args) {
+	const result = await clearConsumedConversationWake$1(args);
+	if (result) await recordExecutionMetadata(args);
+	return result;
+}
+/** Mark a conversation runnable when there is no new mailbox message. */
+async function requestConversationWork(args) {
+	const result = await requestConversationWork$1(args);
+	await recordExecutionMetadata({
+		conversationId: args.conversationId,
+		conversationStore: args.conversationStore,
+		state: args.state
+	});
+	return result;
+}
+/** Record that a wake-up nudge was accepted for the conversation. */
+async function markConversationWorkEnqueued(args) {
+	await markConversationWorkEnqueued$1(args);
+	await recordExecutionMetadata(args);
+}
+/** Try to acquire the durable execution lease for one conversation. */
+async function startConversationWork(args) {
+	const result = await startConversationWork$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Extend the durable execution lease when the worker checks in. */
+async function checkInConversationWork(args) {
+	const result = await checkInConversationWork$1(args);
+	if (result) await recordExecutionMetadata(args);
+	return result;
+}
+/** Drain pending mailbox entries after the caller accepts responsibility. */
+async function drainConversationMailbox(args) {
+	const result = await drainConversationMailbox$1(args);
+	if (result.changed) await recordExecutionMetadata(args);
+	return result.messages;
+}
+/** Acknowledge leased mailbox entries after the handler accepts responsibility. */
+async function ackMessages(args) {
+	const result = await ackMessages$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Cancel human-facing pending mailbox rows without requiring a worker lease. */
+async function cancelHumanFacingPendingMessages(args) {
+	const result = await cancelHumanFacingPendingMessages$1(args);
+	if (result.cancelledInboundMessageIds.length > 0) await recordExecutionMetadata(args);
+	return result;
+}
+/** Mark one author's queued web messages as interrupts. */
+async function steerWebPendingMessages(args) {
+	return await steerWebPendingMessages$1(args);
+}
+/** Mark the leased conversation as needing another queue-delivered slice. */
+async function requestAnotherSlice(args) {
+	const result = await requestAnotherSlice$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Begin a requested turn resume without releasing the current lease. */
+async function beginConversationResume(args) {
+	const result = await beginConversationResume$1(args);
+	if (result) await recordExecutionMetadata(args);
+	return result;
+}
+/** Release the durable execution lease without changing completion state. */
+async function releaseConversationWork(args) {
+	const result = await releaseConversationWork$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Finish a leased conversation and report whether runnable work remains. */
+async function completeConversationWork(args) {
+	const result = await completeConversationWork$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Record one failed delivery attempt and dead-letter messages at their limit. */
+async function recordAttemptFailure(args) {
+	const result = await recordAttemptFailure$1(args);
+	if (result.status === "recorded") await recordExecutionMetadata(args);
+	return result;
+}
+/** Record a terminal failure completion for a leased conversation. */
+async function deadLetterAttempt(args) {
+	const result = await deadLetterAttempt$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Recover an expired lease and persist the resulting retry state. */
+async function clearExpiredConversationLease(args) {
+	const result = await clearExpiredConversationLease$1(args);
+	await recordExecutionMetadata(args);
+	return result;
+}
+/** Remove one conversation from the active index after it is missing or idle. */
+async function removeActiveConversation(args) {
+	return await removeActiveConversation$1(args);
+}
+/** List active conversation ids by oldest execution update first. */
+async function listActiveConversationIds(args = {}) {
+	return await listActiveConversationIds$1(args);
+}
+export { requestAnotherSlice as C, stopConversationWork as D, steerWebPendingMessages as E, removeActiveConversation as S, startConversationWork as T, hasRunnableConversationWork as _, cancelHumanFacingPendingMessages as a, recordConversationRetry as b, clearExpiredConversationLease as c, countPendingConversationMessages as d, deadLetterAttempt as f, getConversationWorkState as g, getConversation as h, beginConversationResume as i, completeConversationStop as l, ensureConversationWake as m, appendAndEnqueueExclusiveInboundMessage as n, checkInConversationWork as o, drainConversationMailbox as p, appendAndEnqueueInboundMessage as r, clearConsumedConversationWake as s, ackMessages as t, completeConversationWork as u, listActiveConversationIds as v, requestConversationWork as w, releaseConversationWork as x, recordAttemptFailure as y };

package/dist/{task-queue-8XjDIORF.js → task-queue-B0DLgd2P.js}

@@ -1,5 +1,5 @@
-import { m as logWarn } from "./logging-D2QBriUo.js";
-import { c as QUEUE_SIGNATURE_MAX_AGE_MS, d as getQueueProvider, l as signQueueMessage, p as runWithTurnRequestDeadline, u as verifyQueueMessage } from "./job-queue-Cjo6Yg_b.js";
+import { h as logWarn } from "./logging-DuZ1A4ab.js";
+import { c as QUEUE_SIGNATURE_MAX_AGE_MS, d as getQueueProvider, l as signQueueMessage, p as runWithTurnRequestDeadline, u as verifyQueueMessage } from "./job-queue-C0BZSa7r.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 // src/chat/queue/callback.ts
@@ -44,10 +44,11 @@ function queueCallback(options) {
 	return {
 		/** Run a message that an in-process queue already trusts. */
 		consume,
+		consumer,
 		create: () => getQueueProvider().createCallback(consumer),
 		registerDev: () => {
 			if (process.env.NODE_ENV !== "development") return;
-			return getQueueProvider().registerDevConsumer(consumer);
+			return getQueueProvider().registerDevConsumer?.(consumer);
 		}
 	};
 }
@@ -109,7 +110,7 @@ function pluginTaskCallback() {
 		maxDeliveries: PLUGIN_TASK_MAX_DELIVERIES,
 		onRejected: logPluginTaskQueueMessageRejected,
 		run: async (message) => {
-			const { processPluginTask } = await import("./task-runner-6mLmG6g_.js").then((n) => n.r);
+			const { processPluginTask } = await import("./task-runner-B-PD_JOj.js").then((n) => n.r);
 			await processPluginTask(message);
 		},
 		topic: PLUGIN_TASK_QUEUE_TOPIC,
@@ -127,8 +128,12 @@ async function sendVercelPluginTask(message) {
 function createVercelPluginTaskCallback() {
 	return pluginTaskCallback().create();
 }
+/** Return the queue consumer for plugin tasks, for a pulling queue worker. */
+function pluginTaskQueueConsumer() {
+	return pluginTaskCallback().consumer;
+}
 /** Register the local-dev consumer for plugin tasks. */
 function registerVercelPluginTaskDevConsumer() {
 	return pluginTaskCallback().registerDev();
 }
-export { registerVercelPluginTaskDevConsumer as a, pluginTaskParamsSchema as i, createVercelPluginTaskCallback as n, sendVercelPluginTask as o, pluginTaskId as r, queueCallback as s, PLUGIN_TASK_QUEUE_TOPIC as t };
+export { pluginTaskQueueConsumer as a, queueCallback as c, pluginTaskParamsSchema as i, createVercelPluginTaskCallback as n, registerVercelPluginTaskDevConsumer as o, pluginTaskId as r, sendVercelPluginTask as s, PLUGIN_TASK_QUEUE_TOPIC as t };

package/dist/{task-runner-6mLmG6g_.js → task-runner-B-PD_JOj.js}

@@ -1,17 +1,17 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { $t as isToolResultMessage, Gt as getPiMessageRole, Nt as getTurnRecord, Qt as isToolResultError, X as hydrateConversationMessages, Yt as instructionTextForProjection, en as normalizeToolNameFromResult, i as readScheduledAutomation, l as blockEventAutomation, m as getEventAutomation, nn as stripRuntimeTurnContext, nt as fallbackShortTitle } from "./tasks-DGbrur6x.js";
-import { g as runBestEffort, m as logWarn } from "./logging-D2QBriUo.js";
-import { g as parseSlackMessageTs } from "./actor-tlxzqaRe.js";
-import { E as agentTurnTotalTokens, T as agentTurnCostUsd, d as getConversationStore, f as getDb, r as readActorIdentity } from "./viewer-B2wXNspU.js";
+import { Bn as instructionTextForProjection, Gn as normalizeToolNameFromResult, In as getPiMessageRole, Un as isToolResultError, Wn as isToolResultMessage, gt as fallbackShortTitle, i as readScheduledAutomation, l as blockEventAutomation, m as getEventAutomation, qn as stripRuntimeTurnContext, qt as getTurnRecord, ut as hydrateConversationMessages } from "./tasks-0ilmuCux.js";
+import { _ as runBestEffort, h as logWarn } from "./logging-DuZ1A4ab.js";
+import { p as parseSlackMessageTs } from "./actor-DZSokpwj.js";
+import { D as agentTurnTotalTokens, E as agentTurnCostUsd, f as getConversationStore, p as getDb, r as readActorIdentity } from "./viewer-DrN3oC2X.js";
 import { s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
-import { a as juniorAutomationRuns, o as juniorAutomationVersions, s as juniorAutomations } from "./executor-CAr7xQr2.js";
-import { m as sameActorIdentity } from "./history-AY8rs-FR.js";
-import { h as credentialSubjectSchema } from "./registry-COTeZ2cV.js";
-import { An as createPluginLogger, Bn as createPluginConversationEvents, Dn as createPluginState, On as createPluginEmbedder, _t as openSlackDirectMessage, fn as getDashboardTaskLink, g as coreTaskRegistrations, kn as createPluginModel, ln as JUNIOR_THREAD_STATE_TTL_MS, lt as escapeSlackMrkdwnText, nr as createPluginCache, p as getPlugins, ut as formatSlackLink, vt as postSlackMessage } from "./credentialed-C6pKlB1p.js";
-import { r as getStateAdapter } from "./adapter-cUkPH3Om.js";
-import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-D45lz-oC.js";
-import { t as resolveConversationRouting } from "./turn-session-routing-BKx6rfVd.js";
-import { i as pluginTaskParamsSchema, o as sendVercelPluginTask, r as pluginTaskId } from "./task-queue-8XjDIORF.js";
+import { a as juniorAutomationRuns, o as juniorAutomationVersions, s as juniorAutomations } from "./executor-VYrx_K4w.js";
+import { m as sameActorIdentity } from "./history-C84mlAwO.js";
+import { h as credentialSubjectSchema } from "./registry-FQutO926.js";
+import { $ as postSlackMessage, An as createPluginState, Mn as createPluginModel, Nn as createPluginLogger, U as escapeSlackMrkdwnText, Un as createPluginConversationEvents, W as formatSlackLink, Z as openSlackDirectMessage, ar as createPluginCache, dn as JUNIOR_THREAD_STATE_TTL_MS, g as coreTaskRegistrations, jn as createPluginEmbedder, mn as getDashboardTaskLink, p as getPlugins } from "./credentialed-CIGwoLU2.js";
+import { i as getStateAdapter } from "./adapter-BybMEezj.js";
+import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-DRmdJ2QN.js";
+import { t as resolveConversationRouting } from "./turn-session-routing-Dyut9l7Y.js";
+import { i as pluginTaskParamsSchema, r as pluginTaskId, s as sendVercelPluginTask } from "./task-queue-B0DLgd2P.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 import { and, asc, count, desc, eq, gte, inArray, isNotNull, lte, max, sql } from "drizzle-orm";
@@ -117,7 +117,7 @@ const EMPTY_RUN_WINDOWS = {
 	30: 0,
 	90: 0
 };
-/** Empty run windows for automations with no execution history. */
+/** Empty run or cost windows for automations with no execution history. */
 function emptyAutomationRunWindows() {
 	return { ...EMPTY_RUN_WINDOWS };
 }
@@ -199,7 +199,13 @@ async function readAutomationExecutionSummaries(automationIds, options = {}) {
 		conversationId: juniorAutomationRuns.conversationId,
 		automationId: juniorAutomationRuns.automationId
 	}).from(juniorAutomationRuns).where(selected).orderBy(juniorAutomationRuns.automationId, desc(juniorAutomationRuns.completedAtMs), desc(juniorAutomationRuns.id)).as("latest_task_execution");
+	const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
+	const costSince = (sinceMs) => sql`coalesce(sum(${conversationCost}) filter (where ${juniorAutomationRuns.completedAtMs} >= ${sinceMs}), 0)::double precision`;
 	const rows = await db.select({
+		costLast1Day: costSince(oneDayAgoMs),
+		costLast7Days: costSince(sevenDaysAgoMs),
+		costLast30Days: costSince(thirtyDaysAgoMs),
+		costLast90Days: costSince(ninetyDaysAgoMs),
 		lastRunStatus: latest.status,
 		lastConversationId: latest.conversationId,
 		lastExecutedAtMs: max(juniorAutomationRuns.completedAtMs),
@@ -209,8 +215,14 @@ async function readAutomationExecutionSummaries(automationIds, options = {}) {
 		runsLast90Days: sql`count(*) filter (where ${juniorAutomationRuns.completedAtMs} >= ${ninetyDaysAgoMs})::int`,
 		automationId: juniorAutomationRuns.automationId,
 		totalRuns: sql`count(*)::int`
-	}).from(juniorAutomationRuns).innerJoin(latest, eq(latest.automationId, juniorAutomationRuns.automationId)).where(selected).groupBy(juniorAutomationRuns.automationId, latest.conversationId, latest.status);
+	}).from(juniorAutomationRuns).innerJoin(latest, eq(latest.automationId, juniorAutomationRuns.automationId)).leftJoin(juniorConversations, executionConversation()).where(selected).groupBy(juniorAutomationRuns.automationId, latest.conversationId, latest.status);
 	return new Map(rows.map((row) => [row.automationId, {
+		costUsd: {
+			1: addUsd(0, row.costLast1Day),
+			7: addUsd(0, row.costLast7Days),
+			30: addUsd(0, row.costLast30Days),
+			90: addUsd(0, row.costLast90Days)
+		},
 		lastRunStatus: row.lastRunStatus,
 		...row.lastConversationId ? { lastConversationId: row.lastConversationId } : void 0,
 		...row.lastExecutedAtMs !== null ? { lastExecutedAtMs: row.lastExecutedAtMs } : void 0,