@sentry/junior 0.267.0 → 0.269.0

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

@@ -1,5 +1,5 @@
-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 { 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-B-PD_JOj.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-DRmdJ2QN.js → thread-state-CHy8LS0C.js}

@@ -1,8 +1,8 @@
-import { dt as persistConversationMessages, ur as createDurableLocationConfigurationService } from "./tasks-0ilmuCux.js";
-import { B as isRecord, H as toOptionalString, V as toOptionalNumber } from "./logging-DuZ1A4ab.js";
-import { p as getDb } from "./viewer-DrN3oC2X.js";
-import { dn as JUNIOR_THREAD_STATE_TTL_MS } from "./credentialed-CIGwoLU2.js";
-import { i as getStateAdapter } from "./adapter-BybMEezj.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 {
@@ -134,19 +134,9 @@ function getPersistedSandboxState(state) {
 		...workspaceId ? { workspaceId } : void 0
 	};
 }
-/** Persist a thread-state patch for a Chat thread handle. */
-async function persistThreadState(thread, patch) {
-	if (patch.conversation) await persistConversationMessages({
-		conversation: patch.conversation,
-		conversationId: toOptionalString(thread.id) ?? toOptionalString(thread.runId)
-	});
-	await persistThreadRuntimeState(thread, patch);
-}
 /** Persist only the Redis-backed runtime scratch in a thread-state patch. */
-async function persistThreadRuntimeState(thread, patch) {
-	const threadId = toOptionalString(thread.id) ?? toOptionalString(thread.runId);
-	if (!threadId) throw new Error("thread id is required to persist runtime scratch");
-	await mergePersistedState(threadStateKey(threadId), buildThreadStatePayload(patch));
+async function persistThreadRuntimeState(conversationId, patch) {
+	await mergePersistedState(threadStateKey(conversationId), buildThreadStatePayload(patch));
 }
 /** Load the persisted state payload for a thread without requiring a Chat singleton. */
 async function getPersistedThreadState(threadId) {
@@ -181,4 +171,4 @@ function getLocationConfigurationService(destination) {
 		loadLegacy: async () => await getLegacyChannelState(destination.channelId)
 	});
 }
-export { persistThreadState as a, persistThreadRuntimeState as i, getPersistedSandboxState as n, persistThreadStateById as o, getPersistedThreadState as r, coerceThreadConversationState as s, getLocationConfigurationService as t };
+export { persistThreadStateById as a, persistThreadRuntimeState as i, getPersistedSandboxState as n, coerceThreadConversationState as o, getPersistedThreadState as r, getLocationConfigurationService as t };

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

@@ -1,12 +1,13 @@
-import { $n as buildDeterministicTurnId, Rt as clearPendingAuth, ut as hydrateConversationMessages, wt as markConversationMessage } from "./tasks-0ilmuCux.js";
-import { _ as getProviderErrorAttributes, g as findProviderError, m as ProviderError, v as getProviderErrorUserMessage } from "./client-BjgbMawj.js";
-import { B as isRecord, t as buildTurnFailureResponse } from "./logging-DuZ1A4ab.js";
-import { p as parseSlackMessageTs } from "./actor-DZSokpwj.js";
-import { p as getDb, u as getConversationEventStore } from "./viewer-DrN3oC2X.js";
-import { er as listConversationAnnotations } from "./credentialed-CIGwoLU2.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-6EetVP-m.js";
-import { o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-DRmdJ2QN.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 { 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
@@ -66,12 +67,6 @@ async function loadPendingMessageCards(conversationId) {
 	if (selection.cards.size === 0) return [];
 	return resolveMessageCards([...selection.cards.values()].reverse(), await listConversationAnnotations(getDb(), conversationId));
 }
-// src/chat/interruption-marker.ts
-const INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
-/** Return the marker added when a visible reply ended mid-execution. */
-function getInterruptionMarker() {
-	return INTERRUPTED_MARKER;
-}
 // src/chat/runtime/delivered-turn-state.ts
 /** Build state after destination delivery or intentional no-reply completion. */
 function buildDeliveredTurnStatePatch(args) {
@@ -222,4 +217,4 @@ function finalizeFailedTurnReplyWithEvent(args) {
 		}
 	};
 }
-export { persistAuthPauseTurnState as a, getTurnUserSlackMessageTs as c, loadPendingMessageCards as d, completeAuthPauseTurn as i, buildDeliveredTurnStatePatch as l, getAgentTurnDiagnosticsAttributes as n, getTurnUserMessage as o, requireTurnFailureEventId as r, getTurnUserReplyAttachmentContext as s, finalizeFailedTurnReplyWithEvent as t, getInterruptionMarker as u };
+export { persistAuthPauseTurnState as a, getTurnUserSlackMessageTs as c, completeAuthPauseTurn as i, buildDeliveredTurnStatePatch as l, getAgentTurnDiagnosticsAttributes as n, getTurnUserMessage as o, requireTurnFailureEventId as r, getTurnUserReplyAttachmentContext as s, finalizeFailedTurnReplyWithEvent as t, loadPendingMessageCards as u };

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

@@ -1,4 +1,4 @@
-import { u as getConversationEventStore } from "./viewer-DrN3oC2X.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 {