@sentry/junior 0.268.0 → 0.269.0

package/dist/{skills-CfAnfImD.js → skills-DmJJIuLF.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { h as logWarn } from "./logging-DLSpkSSr.js";
+import { h as logWarn } from "./logging-n7knse-O.js";
 import { s as skillRoots } from "./package-discovery-DJBompdd.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-BD9GSpc6.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BsoSmTM0.js";
 import path from "node:path";
 import { z } from "zod";
 import fs from "node:fs/promises";

package/dist/{spawn-cmq9p4Ly.js → spawn-ChCm46i-.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { Bt as actorFromRun, Vt as toolInvocationDestination } from "./agent-runner-CAYfFmU7.js";
-import { n as createAndEnqueueAgentInvocation } from "./work-3N-GHY9m.js";
+import { At as actorFromRun, jt as toolInvocationDestination } from "./agent-runner-CrDrPUtY.js";
+import { n as createAndEnqueueAgentInvocation } from "./work-BE_qTYGi.js";
 // src/chat/agent-invocations/spawn.ts
 var spawn_exports = /* @__PURE__ */ __exportAll({ bindSpawnAgent: () => bindSpawnAgent });
 /** Bind a Run's Actor and credentials to new Agent invocations. */

package/dist/{store-C5PN02QO.js → store-1DVhoKOL.js}

@@ -1,8 +1,8 @@
 import { l as TURN_REASONING_LEVELS, s as modelProfileSchema } from "./model-profile-Bg8EoCKD.js";
-import { h as getSqlExecutor, p as getConversationStore } from "./viewer-CpXTGlep.js";
+import { C as getSqlExecutor, x as getConversationStore } from "./viewer-DSbD6DF6.js";
 import { a as juniorAgentInvocations, i as juniorAgentBindings, n as AGENT_INVOCATION_PARENT_MAILBOX_STATUSES, t as AGENT_INVOCATION_MAILBOX_STATUSES } from "./agent-invocations-C1RNOCs8.js";
-import "./executor-4vhvsMZJ.js";
-import { p as credentialContextSchema } from "./registry-BgecKva0.js";
+import "./executor-CNS7ONt-.js";
+import { p as credentialContextSchema } from "./registry-By36_xsm.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 import { and, asc, count, countDistinct, desc, eq, inArray, lt, ne, or, sql } from "drizzle-orm";

package/dist/{store-zPEoJPBB.js → store-DCo2n5iJ.js}

@@ -1,6 +1,6 @@
-import { Cn as removeActiveConversation$1, Dn as steerWebPendingMessages$1, En as startConversationWork$1, On as stopConversationWork$1, Sn as releaseConversationWork$1, Tn as requestConversationWork$1, an as checkInConversationWork$1, bn as recordAttemptFailure$1, cn as completeConversationStop$1, dn as drainConversationMailbox$1, en as ackMessages$1, fn as getConversation$1, in as cancelHumanFacingPendingMessages$1, ln as completeConversationWork$1, nn as appendInboundMessage, on as clearConsumedConversationWake$1, pn as getConversationWorkState$1, rn as beginConversationResume$1, sn as clearExpiredConversationLease$1, tn as appendExclusiveInboundMessage, un as deadLetterAttempt$1, vn as listActiveConversationIds$1, wn as requestAnotherSlice$1, xn as recordConversationRetry$1, yn as markConversationWorkEnqueued$1 } from "./tasks-SB9z-VTU.js";
-import { p as getConversationStore } from "./viewer-CpXTGlep.js";
-import "./job-queue-In9QKz-I.js";
+import { $n as recordAttemptFailure$1, Bn as clearExpiredConversationLease$1, Fn as appendInboundMessage, Gn as getConversation$1, Hn as completeConversationWork$1, In as beginConversationResume$1, Kn as getConversationWorkState$1, Ln as cancelHumanFacingPendingMessages$1, Nn as ackMessages$1, Pn as appendExclusiveInboundMessage, Qn as markConversationWorkEnqueued$1, Rn as checkInConversationWork$1, Un as deadLetterAttempt$1, Vn as completeConversationStop$1, Wn as drainConversationMailbox$1, Zn as listActiveConversationIds$1, ar as startConversationWork$1, er as recordConversationRetry$1, ir as requestConversationWork$1, nr as removeActiveConversation$1, or as steerWebPendingMessages$1, rr as requestAnotherSlice$1, sr as stopConversationWork$1, tr as releaseConversationWork$1, zn as clearConsumedConversationWake$1 } from "./turn-session-routing-BqO0qXLk.js";
+import { x as getConversationStore } from "./viewer-DSbD6DF6.js";
+import "./job-queue-DI-k-Bbk.js";
 // src/chat/task-execution/store.ts
 function metadataStore(options) {
 	return options.conversationStore ?? getConversationStore();

package/dist/{task-queue-_mf28dSu.js → task-queue-HMC4QjFm.js}

@@ -1,5 +1,5 @@
-import { h as logWarn } from "./logging-DLSpkSSr.js";
-import { c as QUEUE_SIGNATURE_MAX_AGE_MS, d as getQueueProvider, l as signQueueMessage, p as runWithTurnRequestDeadline, u as verifyQueueMessage } from "./job-queue-In9QKz-I.js";
+import { h as logWarn } from "./logging-n7knse-O.js";
+import { c as QUEUE_SIGNATURE_MAX_AGE_MS, d as getQueueProvider, l as signQueueMessage, p as runWithTurnRequestDeadline, u as verifyQueueMessage } from "./job-queue-DI-k-Bbk.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 // src/chat/queue/callback.ts
@@ -110,7 +110,7 @@ function pluginTaskCallback() {
 		maxDeliveries: PLUGIN_TASK_MAX_DELIVERIES,
 		onRejected: logPluginTaskQueueMessageRejected,
 		run: async (message) => {
-			const { processPluginTask } = await import("./task-runner-DMI2prDO.js").then((n) => n.r);
+			const { processPluginTask } = await import("./task-runner-cA6yjn_E.js").then((n) => n.r);
 			await processPluginTask(message);
 		},
 		topic: PLUGIN_TASK_QUEUE_TOPIC,

package/dist/task-runner-cA6yjn_E.js

@@ -0,0 +1,269 @@
+import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
+import { Er as normalizeToolNameFromResult, Gt as hydrateConversationMessages, On as getTurnRecord, Or as stripRuntimeTurnContext, Tr as isToolResultMessage, _r as getPiMessageRole, t as resolveConversationRouting, u as getDispatchRecord, wr as isToolResultError, xr as instructionTextForProjection } from "./turn-session-routing-BqO0qXLk.js";
+import { m as parseSlackMessageTs } from "./actor-CP9K2Idu.js";
+import { S as getDb, i as readActorIdentity, x as getConversationStore } from "./viewer-DSbD6DF6.js";
+import { _ as sameActorIdentity } from "./media-85PDJxO_.js";
+import { ar as createPluginLogger, g as coreTaskRegistrations, hr as createPluginConversationEvents, ir as createPluginModel, jr as createPluginCache, nr as createPluginState, p as getPlugins, rr as createPluginEmbedder } from "./credentialed-BU-OW7HP.js";
+import { r as getStateAdapter } from "./adapter-2-CG25be.js";
+import { o as coerceThreadConversationState, r as getPersistedThreadState } from "./thread-state-CHy8LS0C.js";
+import { i as pluginTaskParamsSchema, r as pluginTaskId, s as sendVercelPluginTask } from "./task-queue-HMC4QjFm.js";
+import { pluginRunContextSchema } from "@sentry/junior-plugin-api";
+// src/chat/plugins/task-runner.ts
+/**
+* Plugin background-task orchestration.
+*
+* Core schedules tasks from completed sessions and exposes plugins only a
+* bounded run projection rather than live runtime internals or queue
+* payloads.
+*/
+var task_runner_exports = /* @__PURE__ */ __exportAll({
+	processPluginTask: () => processPluginTask,
+	scheduleSessionCompletedPluginTasks: () => scheduleSessionCompletedPluginTasks
+});
+const PLUGIN_TASK_LOCK_TTL_MS = 3e5;
+function isRecord(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function textPart(value) {
+	if (isRecord(value) && value.type === "text" && typeof value.text === "string") return value.text;
+}
+function messageText(message) {
+	const content = message.content;
+	if (typeof content === "string") return sanitizeText(content);
+	if (!Array.isArray(content)) return "";
+	return sanitizeText(content.map(textPart).filter(Boolean).join("\n"));
+}
+function toolResultText(message) {
+	const record = message;
+	return sanitizeText([
+		messageText(message),
+		record.output,
+		record.result,
+		record.stdout,
+		record.stderr,
+		record.toolResult
+	].filter((value) => typeof value === "string" && value.length > 0).join("\n"));
+}
+function sanitizeText(text) {
+	return text.replace(/<data_base64>[\s\S]*?<\/data_base64>/g, "<data_base64>[omitted]</data_base64>").replace(/data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=]+/gi, "[image data omitted]").replaceAll("\0", " ").trim();
+}
+/** Build the transcript provenance for a user message from its Pi provenance. */
+function messageProvenance(provenance) {
+	return {
+		authority: provenance.authority,
+		...provenance.actor ? { actor: provenance.actor } : void 0
+	};
+}
+function runTranscriptEntry(message, provenance, runActor) {
+	const role = getPiMessageRole(message);
+	if (role === "user" || role === "assistant") {
+		const text = role === "user" ? instructionTextForProjection(messageText(message)) : messageText(message);
+		if (!text) return;
+		if (role === "assistant") return {
+			type: "message",
+			role,
+			text
+		};
+		return {
+			type: "message",
+			role,
+			text,
+			provenance: messageProvenance(provenance),
+			isRunActor: sameActorIdentity(provenance.actor, runActor)
+		};
+	}
+	if (!isToolResultMessage(message)) return;
+	const toolName = normalizeToolNameFromResult(message);
+	if (!toolName) return;
+	const text = toolResultText(message);
+	return {
+		type: "toolResult",
+		toolName,
+		isError: isToolResultError(message),
+		...text ? { text } : void 0
+	};
+}
+/**
+* Slice the current turn's Pi messages with their aligned provenance and strip
+* runtime turn context, keeping each surviving message paired with the exact
+* provenance recorded for it. Stripping can drop or rewrite messages, so the
+* pairing is applied per message rather than by post-strip index.
+*/
+function turnMessagesWithProvenance(record) {
+	const startIndex = record.turnStartMessageIndex ?? 0;
+	const messages = record.piMessages.slice(startIndex);
+	const provenance = record.piMessageProvenance.slice(startIndex);
+	const paired = [];
+	for (const [index, message] of messages.entries()) for (const stripped of stripRuntimeTurnContext([message])) paired.push({
+		message: stripped,
+		provenance: provenance[index] ?? { authority: "context" }
+	});
+	return paired;
+}
+/** Recover the Slack context author identity from a persisted thread message. */
+function slackContextAuthor(location, message) {
+	const userId = message.author?.userId?.trim();
+	if (!userId) return;
+	return {
+		platform: "slack",
+		teamId: location.teamId,
+		userId,
+		...message.author?.userName ? { userName: message.author.userName } : void 0,
+		...message.author?.fullName ? { fullName: message.author.fullName } : void 0
+	};
+}
+function slackTimestampMs(value) {
+	const timestamp = parseSlackMessageTs(value);
+	if (!timestamp) return;
+	const timestampMs = Number(timestamp) * 1e3;
+	return Number.isFinite(timestampMs) ? timestampMs : void 0;
+}
+function conversationMessageTimestampMs(message) {
+	if (message.meta?.slackTs !== void 0) return slackTimestampMs(message.meta.slackTs);
+	return Number.isFinite(message.createdAtMs) ? message.createdAtMs : void 0;
+}
+function messageExistedAtRunCompletion(message, completedAtMs) {
+	const messageTimestampMs = conversationMessageTimestampMs(message);
+	return messageTimestampMs !== void 0 && messageTimestampMs <= completedAtMs;
+}
+/**
+* Project bounded public-thread context into the run transcript.
+*
+* Prior public Slack messages from the current Conversation are durable
+* evidence a completed run may have acted on, so passive consumers can cite
+* them. They are always context authority (never instruction), and private or
+* local Conversations add nothing here.
+*/
+async function loadConversationContextTranscriptEntries(record, location, visibility, runActor) {
+	if (location?.provider !== "slack" || visibility !== "public") return [];
+	const state = await getPersistedThreadState(record.conversationId);
+	const conversation = coerceThreadConversationState(state);
+	await hydrateConversationMessages({
+		conversation,
+		conversationId: record.conversationId
+	});
+	const entries = [];
+	for (const message of conversation.messages) {
+		if (message.role !== "user") continue;
+		if (!messageExistedAtRunCompletion(message, record.updatedAtMs)) continue;
+		const text = sanitizeText(message.text);
+		if (!text) continue;
+		const author = slackContextAuthor(location, message);
+		entries.push({
+			type: "message",
+			role: "user",
+			text,
+			provenance: {
+				authority: "context",
+				...author ? { actor: author } : void 0
+			},
+			isRunActor: sameActorIdentity(author, runActor)
+		});
+	}
+	return entries;
+}
+async function withPluginTaskLock(taskId, callback) {
+	const state = getStateAdapter();
+	await state.connect();
+	const lock = await state.acquireLock(`plugin:task:${taskId}`, PLUGIN_TASK_LOCK_TTL_MS);
+	if (!lock) throw new Error(`Could not acquire plugin task lock for ${taskId}`);
+	try {
+		return await callback();
+	} finally {
+		await state.releaseLock(lock);
+	}
+}
+/** Load the bounded completed-run projection exposed to plugin tasks. */
+async function loadPluginRun(params) {
+	const record = await getTurnRecord(params.conversationId, params.sessionId);
+	if (!record) throw new Error("Completed plugin task session record is unavailable");
+	if (record.state !== "completed") throw new Error("Completed plugin task session record is not completed");
+	const conversationStore = getConversationStore();
+	const routing = await resolveConversationRouting({
+		conversationId: params.conversationId,
+		conversationStore
+	});
+	if (!routing) throw new Error(`Conversation ${params.conversationId} is missing durable routing metadata`);
+	const source = record.source ?? routing.source;
+	if (!source) throw new Error("Completed plugin task session record is missing Source");
+	const conversation = await conversationStore.get({ conversationId: params.conversationId });
+	const runActor = record.actor ?? record.actors[0] ?? (record.dispatchId ? (await getDispatchRecord(record.dispatchId))?.actor : void 0);
+	const actorUser = runActor ? (await readActorIdentity(runActor))?.user : void 0;
+	const runEntries = turnMessagesWithProvenance(record).map(({ message, provenance }) => runTranscriptEntry(message, provenance, runActor)).filter((entry) => Boolean(entry));
+	const runMessageTexts = new Set(runEntries.filter((entry) => entry.type === "message").map((entry) => entry.text));
+	const contextEntries = (await loadConversationContextTranscriptEntries(record, conversation?.location, conversation?.visibility, runActor)).filter((entry) => entry.type !== "message" || !runMessageTexts.has(entry.text));
+	return pluginRunContextSchema.parse({
+		...actorUser ? { actorUserId: actorUser.id } : void 0,
+		completedAtMs: record.updatedAtMs,
+		conversationId: record.conversationId,
+		destination: routing.destination,
+		...routing.location ? { locationId: routing.location.id } : void 0,
+		actors: record.actors,
+		...runActor ? { actor: runActor } : void 0,
+		runId: record.turnId,
+		source,
+		transcript: [...contextEntries, ...runEntries]
+	});
+}
+/** Build the plugin-facing context for one claimed task attempt. */
+function taskPluginContext(plugin, message, options = {}) {
+	const pluginName = plugin.manifest.name;
+	const sessionParams = pluginTaskParamsSchema.parse(message.params);
+	return {
+		db: getDb(),
+		embedder: createPluginEmbedder(pluginName, { signal: options.signal }),
+		events: createPluginConversationEvents({
+			conversationId: sessionParams.conversationId,
+			operationId: pluginTaskId(message),
+			plugin,
+			turnId: sessionParams.sessionId
+		}),
+		id: pluginTaskId(message),
+		log: createPluginLogger(pluginName),
+		model: createPluginModel(pluginName, plugin.model, { signal: options.signal }),
+		name: message.name,
+		plugin: { name: pluginName },
+		cache: createPluginCache(pluginName),
+		run: { async load() {
+			return await loadPluginRun(sessionParams);
+		} },
+		state: createPluginState(pluginName)
+	};
+}
+function findPluginTask(message) {
+	const plugin = [...coreTaskRegistrations(), ...getPlugins()].find((candidate) => candidate.manifest.name === message.plugin);
+	if (!plugin?.tasks || !Object.hasOwn(plugin.tasks, message.name)) return;
+	return {
+		plugin,
+		task: plugin.tasks[message.name]
+	};
+}
+/** Schedule all plugin tasks interested in a completed agent-run session. */
+async function scheduleSessionCompletedPluginTasks(params, options = {}) {
+	const coreParams = pluginTaskParamsSchema.parse(params);
+	const taskRegistrations = [...getPlugins(), ...coreTaskRegistrations()].flatMap((plugin) => Object.keys(plugin.tasks ?? {}).map((name) => ({
+		name,
+		plugin
+	})));
+	if (taskRegistrations.length === 0) return;
+	const record = await getTurnRecord(coreParams.conversationId, coreParams.sessionId);
+	if (!record || record.state !== "completed") throw new Error("Completed plugin task session record is not ready");
+	const send = options.send ?? sendVercelPluginTask;
+	const messages = taskRegistrations.map(({ name, plugin }) => ({
+		name,
+		params: coreParams,
+		plugin: plugin.manifest.name
+	}));
+	await Promise.all(messages.map(async (message) => {
+		await send(message);
+	}));
+}
+/** Execute one parsed plugin task request. */
+async function processPluginTask(message, options = {}) {
+	await withPluginTaskLock(pluginTaskId(message), async () => {
+		const resolved = findPluginTask(message);
+		if (!resolved?.task) throw new Error(`Plugin task "${message.plugin}.${message.name}" is not registered`);
+		await resolved.task.run(taskPluginContext(resolved.plugin, message, options));
+	});
+}
+export { scheduleSessionCompletedPluginTasks as n, task_runner_exports as r, processPluginTask as t };

package/dist/{thread-state-BbbPh0Sn.js → thread-state-CHy8LS0C.js}

@@ -1,8 +1,8 @@
-import { fr as createDurableLocationConfigurationService, pt as persistConversationMessages } from "./tasks-SB9z-VTU.js";
-import { B as isRecord, H as toOptionalString, V as toOptionalNumber } from "./logging-DLSpkSSr.js";
-import { m as getDb } from "./viewer-CpXTGlep.js";
-import { pn as JUNIOR_THREAD_STATE_TTL_MS } from "./credentialed-lukuD-cc.js";
-import { i as getStateAdapter } from "./adapter-04AcD2SO.js";
+import { Gr as createDurableLocationConfigurationService, Kt as persistConversationMessages } from "./turn-session-routing-BqO0qXLk.js";
+import { B as isRecord, H as toOptionalString, V as toOptionalNumber } from "./logging-n7knse-O.js";
+import { S as getDb } from "./viewer-DSbD6DF6.js";
+import { In as JUNIOR_THREAD_STATE_TTL_MS } from "./credentialed-BU-OW7HP.js";
+import { r as getStateAdapter } from "./adapter-2-CG25be.js";
 // src/chat/state/conversation.ts
 function defaultConversationState() {
 	return {

package/dist/{turn-failure-response-BKKmnMB5.js → turn-failure-response-Dr7erLWs.js}

@@ -1,13 +1,13 @@
-import { Bt as clearPendingAuth, Et as markConversationMessage, ft as hydrateConversationMessages, tr as buildDeterministicTurnId } from "./tasks-SB9z-VTU.js";
-import { _ as getProviderErrorAttributes, g as findProviderError, m as ProviderError, v as getProviderErrorUserMessage } from "./client-C1yDYjoS.js";
-import { B as isRecord, t as buildTurnFailureResponse } from "./logging-DLSpkSSr.js";
+import { Gt as hydrateConversationMessages, Pr as buildDeterministicTurnId, an as markConversationMessage, yn as clearPendingAuth } from "./turn-session-routing-BqO0qXLk.js";
+import { _ as getProviderErrorAttributes, g as findProviderError, m as ProviderError, v as getProviderErrorUserMessage } from "./client-Cqf4TboL.js";
+import { B as isRecord, t as buildTurnFailureResponse } from "./logging-n7knse-O.js";
 import { m as parseSlackMessageTs } from "./actor-CP9K2Idu.js";
-import { d as getConversationEventStore, m as getDb } from "./viewer-CpXTGlep.js";
-import { rr as listConversationAnnotations } from "./credentialed-lukuD-cc.js";
-import { B as removedCardSchema, V as resolveMessageCards, z as readMessageCardRefs } from "./conversation-DSo310Ps.js";
-import { D as parseAgentInvocationResultMessageId, J as markTurnClosed, Y as markTurnCompleted, c as getAgentInvocation, m as getAgentInvocationTurnId } from "./store-C5PN02QO.js";
-import { t as getInterruptionMarker } from "./interruption-marker-CkncDT8d.js";
-import { a as persistThreadStateById, o as coerceThreadConversationState, r as getPersistedThreadState } from "./thread-state-BbbPh0Sn.js";
+import { S as getDb, y as getConversationEventStore } from "./viewer-DSbD6DF6.js";
+import { Er as listConversationAnnotations } from "./credentialed-BU-OW7HP.js";
+import { B as removedCardSchema, V as resolveMessageCards, z as readMessageCardRefs } from "./conversation-CTpD_PGk.js";
+import { D as parseAgentInvocationResultMessageId, J as markTurnClosed, Y as markTurnCompleted, c as getAgentInvocation, m as getAgentInvocationTurnId } from "./store-1DVhoKOL.js";
+import { t as getInterruptionMarker } from "./interruption-marker-g6Xup3Fk.js";
+import { a as persistThreadStateById, o as coerceThreadConversationState, r as getPersistedThreadState } from "./thread-state-CHy8LS0C.js";
 // src/chat/conversations/pending-cards.ts
 /**
 * Add the cards that tool results selected since the last visible assistant

package/dist/{turn-lifecycle-oP0kVeGz.js → turn-lifecycle-bf2fIYi_.js}

@@ -1,4 +1,4 @@
-import { d as getConversationEventStore } from "./viewer-CpXTGlep.js";
+import { y as getConversationEventStore } from "./viewer-DSbD6DF6.js";
 // src/chat/conversations/turn-lifecycle.ts
 /** Persist correlated turn lifecycle facts with retry-safe terminal exclusion. */
 var ConversationTurnLifecycleService = class {