@sentry/junior 0.203.0 → 0.204.0

package/dist/task-runner-D-O3A-Cp.js

@@ -0,0 +1,639 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { _ as parseSlackMessageTs, r as credentialSubjectSchema } from "./context-B45_WqVX.js";
+import { Et as getDb, Tt as getConversationStore, Y as readActorIdentity, _t as createPluginLogger, gt as createPluginModel, ht as createPluginEmbedder, mt as createPluginState, u as getPlugins, ut as JUNIOR_THREAD_STATE_TTL_MS, vt as createPluginConversationEvents } from "./agent-hooks-Bbcp9e33.js";
+import { f as sameActorIdentity } from "./history-CqTuSAdI.js";
+import { Dt as isToolResultError, Ot as isToolResultMessage, Q as hydrateConversationMessages, bt as getPiMessageRole, jt as stripRuntimeTurnContext, kt as normalizeToolNameFromResult, s as getTurnRecord, wt as instructionTextForProjection } from "./checkpoint-CNrPyRJN.js";
+import { w as getStateAdapter } from "./profile-CrT5nXbw.js";
+import { u as recordTaskExecution } from "./execution-stats-DWfSihcH.js";
+import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CRc9jTJS.js";
+import { i as pluginTaskParamsSchema, o as sendVercelPluginTask, r as pluginTaskId } from "./task-queue-CJIR4RF7.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { destinationSchema, destinationVisibilitySchema, isSlackDestination, pluginRunContextSchema, replyAttributionSchema, sourceSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+//#region src/chat/agent-dispatch/store.ts
+const DISPATCH_PREFIX = "junior:agent_dispatch";
+const DISPATCH_LOCK_TTL_MS = 6e5;
+const DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS = 1e4;
+const nonEmptyExactStringSchema = z.string().min(1).refine((value) => value === value.trim() && value.toLowerCase() !== "unknown");
+const pendingDispatchMailboxAppendIndexSchema = z.array(nonEmptyExactStringSchema);
+const dispatchStatusSchema = z.enum([
+	"pending",
+	"running",
+	"awaiting_resume",
+	"completed",
+	"failed",
+	"blocked"
+]);
+const dispatchActorSchema = z.object({
+	platform: z.literal("system"),
+	name: nonEmptyExactStringSchema
+}).strict();
+const dispatchRecordSchema = z.object({
+	actor: dispatchActorSchema,
+	createdAtMs: z.number().finite(),
+	credentialSubject: credentialSubjectSchema.optional(),
+	destination: destinationSchema,
+	destinationVisibility: destinationVisibilitySchema,
+	errorMessage: z.string().optional(),
+	id: nonEmptyExactStringSchema,
+	idempotencyKey: z.string().min(1),
+	input: z.string().min(1),
+	metadata: z.record(z.string(), z.string()).optional(),
+	plugin: nonEmptyExactStringSchema,
+	replyAttribution: replyAttributionSchema.optional(),
+	resultMessageTs: z.string().optional(),
+	source: sourceSchema,
+	outcomes: z.array(taskOutcomeSchema).max(5).optional(),
+	status: dispatchStatusSchema,
+	updatedAtMs: z.number().finite()
+}).strict().superRefine((record, ctx) => {
+	if (!isSlackDestination(record.destination)) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Dispatch destination platform must be slack",
+			path: ["destination"]
+		});
+		return;
+	}
+	const subject = record.credentialSubject;
+	if (!subject) return;
+	if (subject.allowedWhen === "private-direct-conversation") {
+		if (!record.destination.channelId.startsWith("D")) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "Dispatch credentialSubject requires a private direct Slack destination",
+				path: ["credentialSubject"]
+			});
+			return;
+		}
+		if (subject.binding.type !== "slack-direct-conversation" || subject.binding.teamId !== record.destination.teamId || subject.binding.channelId !== record.destination.channelId) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Dispatch credentialSubject binding must match destination",
+			path: ["credentialSubject", "binding"]
+		});
+		return;
+	}
+	if (subject.binding.type !== subject.allowedWhen || subject.binding.plugin !== record.plugin || subject.binding.taskId !== subject.taskId) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Dispatch credentialSubject binding must match task",
+		path: ["credentialSubject", "binding"]
+	});
+});
+/** Return the durable key for one plugin-facing dispatch projection. */
+function getDispatchStorageKey(id) {
+	return `${DISPATCH_PREFIX}:record:${id}`;
+}
+function dispatchLockKey(id) {
+	return `${DISPATCH_PREFIX}:lock:${id}`;
+}
+function pendingDispatchMailboxAppendIndexKey() {
+	return `${DISPATCH_PREFIX}:incomplete`;
+}
+function pendingDispatchMailboxAppendIndexLockKey() {
+	return `${DISPATCH_PREFIX}:incomplete:lock`;
+}
+function normalizeMetadata(metadata) {
+	if (!metadata) return;
+	const entries = Object.entries(metadata).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string");
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function buildDispatchId(plugin, idempotencyKey) {
+	return `dispatch_${createHash("sha256").update(plugin).update("\0").update(idempotencyKey).digest("hex").slice(0, 32)}`;
+}
+/** Parse one durable dispatch projection record. */
+function parseDispatchRecord(value) {
+	const parsed = dispatchRecordSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+/** Return the isolated durable conversation id for one dispatch. */
+function getDispatchConversationId(dispatch) {
+	return `agent-dispatch:${dispatch.id}`;
+}
+/** Return the stable synthetic input message id for one dispatch turn. */
+function getDispatchInputMessageId(dispatchId) {
+	return `agent-dispatch:${dispatchId}`;
+}
+/** Return the stable turn id used by every run of one dispatch. */
+function getDispatchTurnId(dispatchId) {
+	return `dispatch:${dispatchId}`;
+}
+function toDispatchProjection(record) {
+	return {
+		id: record.id,
+		status: record.status,
+		...record.resultMessageTs ? { resultMessageTs: record.resultMessageTs } : void 0,
+		...record.errorMessage ? { errorMessage: record.errorMessage } : void 0
+	};
+}
+/** Gate recovery to dispatches that can still make progress. */
+function isTerminalDispatchStatus(status) {
+	return status === "completed" || status === "failed" || status === "blocked";
+}
+/** Serialize dispatch projection mutations. */
+async function withDispatchLock(dispatchId, task) {
+	const state = getStateAdapter();
+	await state.connect();
+	const lock = await state.acquireLock(dispatchLockKey(dispatchId), DISPATCH_LOCK_TTL_MS);
+	if (!lock) throw new Error(`Could not acquire dispatch lock for ${dispatchId}`);
+	try {
+		return await task(state);
+	} finally {
+		await state.releaseLock(lock);
+	}
+}
+async function putRecord(state, record) {
+	const parsed = dispatchRecordSchema.safeParse(record);
+	if (!parsed.success) throw new Error(`Dispatch record is invalid: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`);
+	const next = parsed.data;
+	await state.set(getDispatchStorageKey(next.id), next, JUNIOR_THREAD_STATE_TTL_MS);
+}
+async function updatePendingDispatchMailboxAppendIndex(state, update) {
+	const lock = await state.acquireLock(pendingDispatchMailboxAppendIndexLockKey(), DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS);
+	if (!lock) throw new Error("Could not acquire dispatch mailbox append index lock");
+	try {
+		const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
+		const ids = stored === void 0 || stored === null ? [] : pendingDispatchMailboxAppendIndexSchema.parse(stored);
+		const next = [...new Set(update([...new Set(ids)]))].slice(-1e4);
+		if (next.length === ids.length && next.every((id, index) => id === ids[index])) return;
+		await state.set(pendingDispatchMailboxAppendIndexKey(), next, JUNIOR_THREAD_STATE_TTL_MS);
+	} finally {
+		await state.releaseLock(lock);
+	}
+}
+/** Load dispatch state for conversation work and plugin projections. */
+async function getDispatchRecord(id) {
+	const state = getStateAdapter();
+	await state.connect();
+	return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+}
+/** Create a dispatch idempotently within its owner namespace. */
+async function createOrGetDispatch(args) {
+	const id = buildDispatchId(args.plugin, args.options.idempotencyKey);
+	return await withDispatchLock(id, async (state) => {
+		const existing = parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+		if (existing) return {
+			record: existing,
+			status: "already_exists"
+		};
+		const metadata = normalizeMetadata(args.options.metadata);
+		const record = {
+			actor: {
+				platform: "system",
+				name: args.plugin
+			},
+			createdAtMs: args.nowMs,
+			...args.options.credentialSubject ? { credentialSubject: args.options.credentialSubject } : void 0,
+			destination: args.options.destination,
+			destinationVisibility: args.options.destinationVisibility,
+			id,
+			idempotencyKey: args.options.idempotencyKey,
+			input: args.options.input,
+			...metadata ? { metadata } : void 0,
+			plugin: args.plugin,
+			...args.options.replyAttribution ? { replyAttribution: args.options.replyAttribution } : void 0,
+			...args.options.outcomes ? { outcomes: args.options.outcomes } : void 0,
+			status: "pending",
+			source: args.options.source,
+			updatedAtMs: args.nowMs
+		};
+		await updatePendingDispatchMailboxAppendIndex(state, (ids) => ids.includes(id) ? ids : [...ids, id]);
+		await putRecord(state, record);
+		return {
+			record,
+			status: "created"
+		};
+	});
+}
+async function transitionDispatch(id, transition) {
+	return await withDispatchLock(id, async (state) => {
+		const current = parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+		if (!current) return;
+		const transitioned = transition(current);
+		if (transitioned === current) return current;
+		const next = {
+			...transitioned,
+			updatedAtMs: Date.now()
+		};
+		await putRecord(state, next);
+		return next;
+	});
+}
+/** Mark a dispatch projection as actively running. */
+async function markDispatchRunning(id) {
+	return await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		status: "running",
+		errorMessage: void 0
+	});
+}
+/** Project a durable awaiting-resume turn state to the plugin API. */
+async function markDispatchAwaitingResume(id) {
+	return await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		status: "awaiting_resume"
+	});
+}
+async function recordEventTaskExecution(previous, next, status) {
+	if (!next || next.status !== status || previous?.status === status) return;
+	if (next.plugin !== "junior") return;
+	const eventTaskId = next.metadata?.eventTaskId;
+	if (!eventTaskId) return;
+	const conversationId = getDispatchConversationId(next);
+	const conversation = await getConversationStore().get({ conversationId });
+	await recordTaskExecution("event", eventTaskId, {
+		...conversation ? { conversationId } : void 0,
+		executionId: next.id,
+		nowMs: next.updatedAtMs,
+		status
+	});
+}
+/** Project a blocked turn to the plugin API. */
+async function markDispatchBlocked(id, errorMessage, resultMessageTs) {
+	const previous = await getDispatchRecord(id);
+	const next = await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		errorMessage,
+		...resultMessageTs ? { resultMessageTs } : void 0,
+		status: "blocked"
+	});
+	await recordEventTaskExecution(previous, next, "blocked");
+	return next;
+}
+/** Project a completed turn and its accepted Slack message to the plugin API. */
+async function markDispatchCompleted(id, resultMessageTs) {
+	const previous = await getDispatchRecord(id);
+	const next = await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		errorMessage: void 0,
+		...resultMessageTs ? { resultMessageTs } : void 0,
+		status: "completed"
+	});
+	await recordEventTaskExecution(previous, next, "completed");
+	return next;
+}
+/** Project a terminal conversation turn failure to the plugin API. */
+async function markDispatchFailed(id, errorMessage, resultMessageTs) {
+	const previous = await getDispatchRecord(id);
+	const next = await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		errorMessage,
+		...resultMessageTs ? { resultMessageTs } : void 0,
+		status: "failed"
+	});
+	await recordEventTaskExecution(previous, next, "failed");
+	return next;
+}
+/** Remove a dispatch after its durable mailbox append has succeeded. */
+async function confirmDispatchMailboxAppend(id) {
+	const state = getStateAdapter();
+	await state.connect();
+	await updatePendingDispatchMailboxAppendIndex(state, (ids) => ids.filter((candidate) => candidate !== id));
+}
+/** List dispatches whose durable mailbox append may not have completed. */
+async function listPendingDispatchMailboxAppends() {
+	const state = getStateAdapter();
+	await state.connect();
+	const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
+	return stored === void 0 || stored === null ? [] : [...new Set(pendingDispatchMailboxAppendIndexSchema.parse(stored))];
+}
+/** Load the dispatch under lock before its mailbox append becomes visible. */
+async function claimDispatchMailboxAppend(id) {
+	return await withDispatchLock(id, async (state) => {
+		return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+	});
+}
+/** Return a plugin-scoped dispatch projection without exposing raw runtime state. */
+async function getPluginDispatchProjection(args) {
+	const record = await getDispatchRecord(args.id);
+	if (!record || record.plugin !== args.plugin) return;
+	return toDispatchProjection(record);
+}
+//#endregion
+//#region src/chat/services/turn-session-routing.ts
+async function loadConversationChain(conversationId, conversationStore) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cursor = conversationId;
+	while (cursor && !seen.has(cursor)) {
+		seen.add(cursor);
+		const conversation = await conversationStore.get({ conversationId: cursor });
+		if (!conversation) break;
+		chain.push(conversation);
+		cursor = conversation.parentConversationId;
+	}
+	return chain;
+}
+/**
+* Normalize a stored Slack session source against the conversation destination.
+*
+* Does not create channel or thread values from the conversation id.
+*/
+function slackSourceForDestination(args) {
+	if (args.source?.kind !== "slack" || args.source.channelId !== args.destination.channelId) return;
+	const threadTs = args.source.threadTs?.trim();
+	return {
+		kind: "slack",
+		visibility: args.source.visibility ?? "public",
+		teamId: args.source.teamId?.trim() || args.destination.teamId,
+		channelId: args.source.channelId,
+		...threadTs ? { threadTs } : void 0
+	};
+}
+/**
+* Resolve the Conversation Location, Destination, and session Source.
+*
+* Reads parent Conversations when this Conversation has no Destination.
+*/
+async function resolveConversationRouting(args) {
+	const conversationStore = args.conversationStore ?? (await import("./agent-hooks-Bbcp9e33.js").then((n) => n.St)).getConversationStore();
+	const chain = await loadConversationChain(args.conversationId, conversationStore);
+	let destination;
+	let source;
+	let location;
+	for (const conversation of chain) {
+		destination ??= conversation.destination;
+		source ??= conversation.sessionSource;
+		location ??= conversation.location;
+		if (destination && source) break;
+	}
+	if (!destination) return;
+	if (destination.platform === "slack") {
+		const slackSource = slackSourceForDestination({
+			destination,
+			source
+		});
+		return {
+			destination,
+			...location ? { location } : void 0,
+			...slackSource ? { source: slackSource } : void 0
+		};
+	}
+	return {
+		destination,
+		...location ? { location } : void 0,
+		...source ? { source } : void 0
+	};
+}
+/** Require the Conversation Destination and Source from SQL. */
+async function resolveTurnSessionRouting(args) {
+	const routing = await resolveConversationRouting(args);
+	if (!routing?.destination || !routing.source) throw new Error(`Conversation ${args.conversationId} is missing durable routing metadata`);
+	return {
+		destination: routing.destination,
+		...routing.location ? { location: routing.location } : void 0,
+		source: routing.source
+	};
+}
+//#endregion
+//#region src/chat/plugins/task-runner.ts
+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 },
+		run: { async load() {
+			return await loadPluginRun(sessionParams);
+		} },
+		state: createPluginState(pluginName)
+	};
+}
+function findPluginTask(message) {
+	const plugin = 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().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) throw new Error(`Plugin task "${message.plugin}.${message.name}" is not registered`);
+		await resolved.task.run(taskPluginContext(resolved.plugin, message, options));
+	});
+}
+//#endregion
+export { markDispatchCompleted as _, claimDispatchMailboxAppend as a, getDispatchConversationId as c, getDispatchTurnId as d, getPluginDispatchProjection as f, markDispatchBlocked as g, markDispatchAwaitingResume as h, resolveTurnSessionRouting as i, getDispatchInputMessageId as l, listPendingDispatchMailboxAppends as m, scheduleSessionCompletedPluginTasks as n, confirmDispatchMailboxAppend as o, isTerminalDispatchStatus as p, task_runner_exports as r, createOrGetDispatch as s, processPluginTask as t, getDispatchRecord as u, markDispatchFailed as v, markDispatchRunning as y };