@sentry/junior 0.203.0 → 0.205.0

package/dist/work-B91LQKHr.js

@@ -0,0 +1,509 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { A as createAgentInvocationSchema, M as AgentInvocationLimitError, O as agentBindingSchema, f as PluginCredentialFailureError, j as AgentInvocationBusyError, k as agentInvocationSchema, tt as AuthorizationFlowDisabledError } from "./agent-D4nu8MQV.js";
+import { Ct as getConversationEventStore, Dt as getSqlExecutor, Tt as getConversationStore } from "./agent-hooks-DXHpTJ4m.js";
+import { f as juniorAgentBindings, p as juniorAgentInvocations } from "./executor-BlUhFL7_.js";
+import { B as openConversationProjection, o as failTurnRecord, r as saveTurnCheckpoint, s as getTurnRecord, xt as getTerminalAssistantMessages } from "./checkpoint-CrViJ8Ps.js";
+import { pt as appendAndEnqueueInboundMessage } from "./stats-3YZn-Swi.js";
+import { _ as isTurnInputCommitLostError, h as getConversationTurnBoundaryError, p as TurnInputCommitLostError, s as getAssistantReplyText } from "./pending-auth-CUbXq06G.js";
+import { t as ConversationTurnLifecycleService } from "./turn-lifecycle-CcnwrOcp.js";
+import { n as executeTurn, t as AgentRunError } from "./turn-execution-fI6PZ0iI.js";
+import { n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState } from "./thread-state-CqZ1m-es.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { and, asc, count, eq, inArray } from "drizzle-orm";
+//#region src/chat/agent-invocations/store.ts
+const CREATE_LOCK_PREFIX = "junior:agent_invocation:create";
+const TERMINAL_AGENT_INVOCATION_STATUSES = [
+	"blocked",
+	"completed",
+	"failed"
+];
+const NON_TERMINAL_AGENT_INVOCATION_STATUSES = [
+	"pending",
+	"running",
+	"awaiting_resume"
+];
+function stableId(prefix, ...parts) {
+	return `${prefix}:${createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 32)}`;
+}
+/** Return the stable identity for one retry-safe delegated task. */
+function getAgentInvocationId(parentConversationId, idempotencyKey) {
+	return stableId("agent-invocation", parentConversationId, idempotencyKey);
+}
+/** Return the stable child identity for one invocation without a named binding. */
+function getUnnamedAgentConversationId(invocationId) {
+	return stableId("agent", invocationId);
+}
+/** Return the stable child identity for one named binding. */
+function getNamedAgentConversationId(parentConversationId, name) {
+	return stableId("agent", parentConversationId, name);
+}
+/** Return the stable turn identity advanced by one agent invocation. */
+function getAgentInvocationTurnId(invocationId) {
+	return `agent-invocation:${invocationId}`;
+}
+/** Return the stable mailbox identity for one agent invocation. */
+function getAgentInvocationMessageId(invocationId) {
+	return `agent-invocation:${invocationId}:input`;
+}
+function bindingFromRow(row) {
+	return agentBindingSchema.parse({
+		childConversationId: row.childConversationId,
+		name: row.name,
+		parentConversationId: row.parentConversationId
+	});
+}
+function invocationFromRow(row) {
+	return agentInvocationSchema.parse({
+		actor: row.actor,
+		...row.agentName ? { agentName: row.agentName } : void 0,
+		childConversationId: row.childConversationId,
+		createdAtMs: row.createdAt.getTime(),
+		...row.credentialContext ? { credentialContext: row.credentialContext } : void 0,
+		destination: row.destination,
+		...row.errorMessage !== null ? { errorMessage: row.errorMessage } : void 0,
+		input: row.input,
+		invocationId: row.invocationId,
+		mailboxStatus: row.mailboxStatus,
+		parentConversationId: row.parentConversationId,
+		...row.reasoningLevel ? { reasoningLevel: row.reasoningLevel } : void 0,
+		...row.result !== null ? { result: row.result } : void 0,
+		source: row.source,
+		status: row.status,
+		...row.terminalAt ? { terminalAtMs: row.terminalAt.getTime() } : void 0,
+		updatedAtMs: row.updatedAt.getTime()
+	});
+}
+/** Require every durable creation input to match before replaying one key. */
+function sameCreateInput(invocation, input) {
+	return invocation.parentConversationId === input.parentConversationId && invocation.agentName === input.agentName && invocation.input === input.input && invocation.reasoningLevel === input.reasoningLevel && JSON.stringify(invocation.actor) === JSON.stringify(input.actor) && JSON.stringify(invocation.credentialContext) === JSON.stringify(input.credentialContext) && JSON.stringify(invocation.destination) === JSON.stringify(input.destination);
+}
+/** Read one named child binding in its parent-agent scope. */
+async function getAgentBinding(args) {
+	const rows = await getSqlExecutor().db().select().from(juniorAgentBindings).where(and(eq(juniorAgentBindings.parentConversationId, args.parentConversationId), eq(juniorAgentBindings.name, args.name)));
+	return rows[0] ? bindingFromRow(rows[0]) : void 0;
+}
+/** Read one durable agent invocation. */
+async function getAgentInvocation(invocationId) {
+	const rows = await getSqlExecutor().db().select().from(juniorAgentInvocations).where(eq(juniorAgentInvocations.invocationId, invocationId));
+	return rows[0] ? invocationFromRow(rows[0]) : void 0;
+}
+/** Resolve the single invocation that may resume for one child conversation. */
+async function getActiveAgentInvocationForConversation(childConversationId) {
+	const rows = await getSqlExecutor().db().select().from(juniorAgentInvocations).where(and(eq(juniorAgentInvocations.childConversationId, childConversationId), inArray(juniorAgentInvocations.status, ["running", "awaiting_resume"]))).orderBy(asc(juniorAgentInvocations.createdAt)).limit(2);
+	if (rows.length > 1) throw new Error(`Child conversation ${childConversationId} has multiple active agent invocations`);
+	return rows[0] ? invocationFromRow(rows[0]) : void 0;
+}
+async function getNonTerminalAgentInvocationForConversation(childConversationId) {
+	const rows = await getSqlExecutor().db().select().from(juniorAgentInvocations).where(and(eq(juniorAgentInvocations.childConversationId, childConversationId), inArray(juniorAgentInvocations.status, NON_TERMINAL_AGENT_INVOCATION_STATUSES))).orderBy(asc(juniorAgentInvocations.createdAt)).limit(1);
+	return rows[0] ? invocationFromRow(rows[0]) : void 0;
+}
+async function countNonTerminalAgentInvocationsForParent(parentConversationId) {
+	return (await getSqlExecutor().db().select({ value: count() }).from(juniorAgentInvocations).where(and(eq(juniorAgentInvocations.parentConversationId, parentConversationId), inArray(juniorAgentInvocations.status, NON_TERMINAL_AGENT_INVOCATION_STATUSES))))[0]?.value ?? 0;
+}
+/**
+* Create or replay one invocation, reusing named child conversations and
+* keeping unnamed child identities scoped to the invocation.
+*/
+async function createAgentInvocation(rawInput, nowMs = Date.now()) {
+	const input = createAgentInvocationSchema.parse(rawInput);
+	const invocationId = getAgentInvocationId(input.parentConversationId, input.idempotencyKey);
+	const childConversationId = input.agentName ? getNamedAgentConversationId(input.parentConversationId, input.agentName) : getUnnamedAgentConversationId(invocationId);
+	const lockName = `${CREATE_LOCK_PREFIX}:${input.parentConversationId}`;
+	return await getSqlExecutor().withLock(lockName, async () => {
+		const existing = await getAgentInvocation(invocationId);
+		if (existing) {
+			if (!sameCreateInput(existing, input)) throw new Error(`Agent invocation idempotency key was reused with different input for ${invocationId}`);
+			return existing;
+		}
+		if (await countNonTerminalAgentInvocationsForParent(input.parentConversationId) >= 8) throw new AgentInvocationLimitError(8);
+		await getConversationStore().createChild({
+			childConversationId,
+			parentConversationId: input.parentConversationId,
+			nowMs,
+			source: "internal"
+		});
+		if (input.agentName) {
+			await getSqlExecutor().db().insert(juniorAgentBindings).values({
+				childConversationId,
+				name: input.agentName,
+				parentConversationId: input.parentConversationId
+			}).onConflictDoNothing();
+			const binding = await getAgentBinding({
+				name: input.agentName,
+				parentConversationId: input.parentConversationId
+			});
+			if (!binding || binding.childConversationId !== childConversationId) throw new Error(`Named agent binding did not resolve to ${childConversationId}`);
+			if (await getNonTerminalAgentInvocationForConversation(childConversationId)) throw new AgentInvocationBusyError(input.agentName);
+		}
+		await getSqlExecutor().db().insert(juniorAgentInvocations).values({
+			invocationId,
+			parentConversationId: input.parentConversationId,
+			childConversationId,
+			agentName: input.agentName ?? null,
+			input: input.input,
+			actor: input.actor,
+			credentialContext: input.credentialContext ?? null,
+			source: { kind: "agent_invocation" },
+			destination: input.destination,
+			reasoningLevel: input.reasoningLevel ?? null,
+			status: "pending",
+			mailboxStatus: "pending",
+			createdAt: new Date(nowMs),
+			updatedAt: new Date(nowMs),
+			terminalAt: null
+		}).onConflictDoNothing();
+		const invocation = await getAgentInvocation(invocationId);
+		if (!invocation || !sameCreateInput(invocation, input)) throw new Error(`Agent invocation creation raced for ${invocationId}`);
+		return invocation;
+	});
+}
+/** List bounded invocation records whose mailbox append still needs repair. */
+async function listPendingAgentInvocationMailboxAppends(limit = 100) {
+	return (await getSqlExecutor().db().select().from(juniorAgentInvocations).where(eq(juniorAgentInvocations.mailboxStatus, "pending")).orderBy(asc(juniorAgentInvocations.createdAt)).limit(limit)).map(invocationFromRow);
+}
+/** Record that the invocation's idempotent mailbox append completed. */
+async function markAgentInvocationMailboxAppended(invocationId, nowMs = Date.now()) {
+	await getSqlExecutor().db().update(juniorAgentInvocations).set({
+		mailboxStatus: "appended",
+		updatedAt: new Date(nowMs)
+	}).where(eq(juniorAgentInvocations.invocationId, invocationId));
+}
+/** Mark one non-terminal invocation as actively executing. */
+async function markAgentInvocationRunning(invocationId, nowMs = Date.now()) {
+	await getSqlExecutor().db().update(juniorAgentInvocations).set({
+		status: "running",
+		updatedAt: new Date(nowMs)
+	}).where(and(eq(juniorAgentInvocations.invocationId, invocationId), inArray(juniorAgentInvocations.status, NON_TERMINAL_AGENT_INVOCATION_STATUSES)));
+	return await getAgentInvocation(invocationId);
+}
+/** Mark one invocation as waiting for another shared execution slice. */
+async function markAgentInvocationAwaitingResume(invocationId, nowMs = Date.now()) {
+	await getSqlExecutor().db().update(juniorAgentInvocations).set({
+		status: "awaiting_resume",
+		updatedAt: new Date(nowMs)
+	}).where(and(eq(juniorAgentInvocations.invocationId, invocationId), inArray(juniorAgentInvocations.status, NON_TERMINAL_AGENT_INVOCATION_STATUSES)));
+}
+/** Persist one terminal invocation result without overwriting an earlier result. */
+async function completeAgentInvocation(args) {
+	const nowMs = args.nowMs ?? Date.now();
+	await getSqlExecutor().db().update(juniorAgentInvocations).set({
+		status: args.status,
+		result: args.status === "completed" ? args.result : null,
+		errorMessage: args.status === "completed" ? null : args.errorMessage,
+		terminalAt: new Date(nowMs),
+		updatedAt: new Date(nowMs)
+	}).where(and(eq(juniorAgentInvocations.invocationId, args.invocationId), inArray(juniorAgentInvocations.status, NON_TERMINAL_AGENT_INVOCATION_STATUSES)));
+	return await getAgentInvocation(args.invocationId);
+}
+/** Return whether an agent invocation has finished. */
+function isTerminalAgentInvocation(invocation) {
+	return TERMINAL_AGENT_INVOCATION_STATUSES.includes(invocation.status);
+}
+//#endregion
+//#region src/chat/agent-invocations/work.ts
+var work_exports = /* @__PURE__ */ __exportAll({
+	buildAgentInvocationInboundMessage: () => buildAgentInvocationInboundMessage,
+	createAgentInvocationWorker: () => createAgentInvocationWorker,
+	createAndEnqueueAgentInvocation: () => createAndEnqueueAgentInvocation,
+	enqueueAgentInvocation: () => enqueueAgentInvocation,
+	resolveAgentInvocationId: () => resolveAgentInvocationId,
+	routeAgentInvocationWork: () => routeAgentInvocationWork
+});
+const agentInvocationMailboxMetadataSchema = z.object({
+	agentInvocationId: z.string().min(1),
+	kind: z.literal("agent_invocation")
+}).strict();
+/** Build destinationless mailbox work that references one durable invocation. */
+function buildAgentInvocationInboundMessage(invocation, nowMs = Date.now()) {
+	return {
+		conversationId: invocation.childConversationId,
+		createdAtMs: invocation.createdAtMs,
+		delivery: "defer",
+		inboundMessageId: getAgentInvocationMessageId(invocation.invocationId),
+		input: {
+			authorId: invocation.invocationId,
+			text: "[agent invocation]",
+			metadata: {
+				agentInvocationId: invocation.invocationId,
+				kind: "agent_invocation"
+			}
+		},
+		receivedAtMs: nowMs,
+		source: "internal"
+	};
+}
+/** Append one invocation to its child mailbox and send the normal queue wake. */
+async function enqueueAgentInvocation(invocation, options) {
+	if (invocation.mailboxStatus === "appended") return;
+	const nowMs = options.nowMs ?? Date.now();
+	await appendAndEnqueueInboundMessage({
+		message: buildAgentInvocationInboundMessage(invocation, nowMs),
+		conversationStore: options.conversationStore,
+		nowMs,
+		queue: options.queue,
+		state: options.state
+	});
+	await markAgentInvocationMailboxAppended(invocation.invocationId, nowMs);
+}
+/** Create or replay an invocation, then durably schedule its child work. */
+async function createAndEnqueueAgentInvocation(input, options) {
+	const invocation = await createAgentInvocation(input, options.nowMs);
+	await enqueueAgentInvocation(invocation, options);
+	return await getAgentInvocation(invocation.invocationId) ?? invocation;
+}
+/** Require one invocation metadata reference for one leased mailbox attempt. */
+function invocationIdFromMessages(messages) {
+	if (messages.length === 0) return;
+	const parsed = messages.map((message) => agentInvocationMailboxMetadataSchema.safeParse(message.input.metadata));
+	if (parsed.every((result) => !result.success)) return;
+	if (parsed.some((result) => !result.success)) throw new Error("Conversation mailbox mixes agent invocation and other input");
+	const invocationIds = new Set(parsed.map((result) => {
+		if (!result.success) throw new Error("Agent invocation mailbox metadata failed validation");
+		return result.data.agentInvocationId;
+	}));
+	if (invocationIds.size !== 1) throw new Error("Conversation mailbox contains multiple agent invocations in one attempt");
+	return invocationIds.values().next().value;
+}
+/** Resolve invocation execution from mailbox input or durable active state. */
+async function resolveAgentInvocationId(context) {
+	const mailboxInvocationId = invocationIdFromMessages(context.attempt.messages);
+	if (mailboxInvocationId) return mailboxInvocationId;
+	if (context.attempt.messages.length > 0) return;
+	return (await getActiveAgentInvocationForConversation(context.conversationId))?.invocationId;
+}
+/** Project the terminal invocation into the idempotent turn lifecycle. */
+async function persistTerminalLifecycle(invocation) {
+	const lifecycle = new ConversationTurnLifecycleService(getConversationEventStore());
+	const common = {
+		conversationId: invocation.childConversationId,
+		createdAtMs: "terminalAtMs" in invocation ? invocation.terminalAtMs : invocation.updatedAtMs,
+		turnId: getAgentInvocationTurnId(invocation.invocationId)
+	};
+	if (invocation.status === "completed") await lifecycle.complete({
+		...common,
+		outcome: invocation.result?.trim() ? "success" : "no_reply"
+	});
+	else if (invocation.status === "blocked" || invocation.status === "failed") await lifecycle.fail({
+		...common,
+		failureCode: "model_execution_failed"
+	});
+}
+/** Stop an invocation whose worker died, or project its terminal turn result. */
+async function projectTerminalTurn(invocation) {
+	let turn = await getTurnRecord(invocation.childConversationId, getAgentInvocationTurnId(invocation.invocationId));
+	if (!turn) return;
+	if (turn.state === "running") {
+		turn = await failTurnRecord({
+			conversationId: turn.conversationId,
+			expectedVersion: turn.version,
+			turnId: turn.turnId,
+			errorMessage: "Agent invocation lost its worker before it could pause"
+		});
+		if (!turn) return;
+	}
+	if (turn.state === "paused") return;
+	const result = getTerminalAssistantMessages(turn.piMessages).map(getAssistantReplyText).filter((text) => text !== void 0).join("\n\n");
+	const failed = turn.state !== "completed" || Boolean(turn.errorMessage);
+	return await completeAgentInvocation({
+		invocationId: invocation.invocationId,
+		...failed ? {
+			errorMessage: turn.errorMessage ?? "Agent invocation failed",
+			status: "failed"
+		} : {
+			result,
+			status: "completed"
+		}
+	});
+}
+/** Classify authorization failures that terminally block background work. */
+function blockingInvocationError(error) {
+	const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
+	return cause instanceof AuthorizationFlowDisabledError || cause instanceof PluginCredentialFailureError ? cause : void 0;
+}
+function isInvocationInputCommitLost(error) {
+	const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
+	return isTurnInputCommitLostError(cause);
+}
+/** Save one completed agent result on its child agent invocation. */
+async function saveAgentInvocationResult(args) {
+	const failed = args.result.diagnostics.outcome !== "success";
+	await persistThreadStateById(args.invocation.childConversationId, { sandboxRef: args.result.sandboxRef ?? args.sandboxRef });
+	if (args.result.piMessages?.length) await saveTurnCheckpoint({
+		mode: "completed",
+		conversationId: args.invocation.childConversationId,
+		turnId: args.turnId,
+		durationMs: args.result.diagnostics.durationMs,
+		usage: args.result.diagnostics.usage,
+		destination: args.invocation.destination,
+		...failed ? { errorMessage: args.result.diagnostics.errorMessage ?? "Agent invocation failed" } : void 0,
+		messages: args.result.piMessages,
+		actor: args.invocation.actor,
+		source: args.invocation.source,
+		surface: "internal"
+	});
+	const terminal = await completeAgentInvocation({
+		invocationId: args.invocation.invocationId,
+		...failed ? {
+			errorMessage: args.result.diagnostics.errorMessage ?? "Agent invocation failed",
+			status: "failed"
+		} : {
+			result: args.result.text,
+			status: "completed"
+		}
+	});
+	if (!terminal || !isTerminalAgentInvocation(terminal)) throw new Error(`Agent invocation did not finish for ${args.invocation.invocationId}`);
+	return terminal.status === "completed" ? {
+		finishedAtMs: terminal.terminalAtMs,
+		outcome: terminal.result.trim() ? "success" : "no_reply"
+	} : {
+		finishedAtMs: terminal.terminalAtMs,
+		failureCode: "model_execution_failed",
+		outcome: "failed"
+	};
+}
+/** Build the invocation consumer that advances work through the shared runner. */
+function createAgentInvocationWorker(agentRunner) {
+	return async (context, invocationId) => {
+		let invocation = await getAgentInvocation(invocationId);
+		if (!invocation) throw new Error(`Agent invocation is missing for ${invocationId}`);
+		let acknowledged = context.attempt.messages.length === 0;
+		const acknowledge = async () => {
+			if (acknowledged) return;
+			try {
+				await context.attempt.ack();
+			} catch {
+				throw new TurnInputCommitLostError(`Conversation work lease lost before invocation inbox ack for ${context.conversationId}`);
+			}
+			acknowledged = true;
+		};
+		const turnId = getAgentInvocationTurnId(invocation.invocationId);
+		const lifecycle = new ConversationTurnLifecycleService(getConversationEventStore());
+		let sandboxRef;
+		let history;
+		let location;
+		try {
+			if (invocation.childConversationId !== context.conversationId) throw new Error(`Agent invocation ${invocationId} belongs to ${invocation.childConversationId}, not ${context.conversationId}`);
+			if (context.destination) throw new Error(`Agent invocation conversation ${context.conversationId} must not own a provider destination`);
+			if (isTerminalAgentInvocation(invocation)) {
+				await persistTerminalLifecycle(invocation);
+				await acknowledge();
+				return { status: "completed" };
+			}
+			const projected = await projectTerminalTurn(invocation);
+			if (projected && isTerminalAgentInvocation(projected)) {
+				await persistTerminalLifecycle(projected);
+				await acknowledge();
+				return { status: "completed" };
+			}
+			invocation = await markAgentInvocationRunning(invocation.invocationId) ?? invocation;
+			await lifecycle.start({
+				conversationId: invocation.childConversationId,
+				createdAtMs: invocation.createdAtMs,
+				inputMessageIds: [getAgentInvocationMessageId(invocation.invocationId)],
+				surface: "internal",
+				turnId
+			});
+			const [persisted, projection] = await Promise.all([getPersistedThreadState(invocation.childConversationId), openConversationProjection({ conversationId: invocation.childConversationId })]);
+			sandboxRef = getPersistedSandboxState(persisted);
+			history = projection.messages;
+			location = (await getConversationStore().get({ conversationId: invocation.parentConversationId }))?.location;
+		} catch (error) {
+			if (isInvocationInputCommitLost(error)) return { status: "lost_lease" };
+			if (!context.attempt.isFinalAttempt) throw error;
+			const terminal = await completeAgentInvocation({
+				invocationId: invocation.invocationId,
+				errorMessage: error instanceof Error ? error.message : "Agent invocation failed",
+				status: "failed"
+			});
+			if (terminal) await persistTerminalLifecycle(terminal);
+			await acknowledge();
+			return { status: "completed" };
+		}
+		let outcome;
+		try {
+			outcome = await executeTurn(agentRunner, {
+				conversationId: invocation.childConversationId,
+				turnId,
+				runId: invocation.invocationId,
+				instruction: { text: invocation.input },
+				history,
+				actor: invocation.actor,
+				credentialContext: invocation.credentialContext,
+				destination: invocation.destination,
+				source: invocation.source,
+				...location ? { location } : void 0,
+				surface: "internal",
+				disabledFeatures: [
+					"handoff",
+					"interactive-auth",
+					"subagents"
+				],
+				reasoning: invocation.reasoningLevel,
+				state: { sandboxRef },
+				durability: {
+					onInputCommitted: acknowledge,
+					shouldYield: context.shouldYield,
+					onSandboxRefChanged: async (nextSandboxRef) => {
+						sandboxRef = nextSandboxRef;
+						await persistThreadStateById(invocation.childConversationId, { sandboxRef });
+					}
+				}
+			}, async (result) => await saveAgentInvocationResult({
+				invocation,
+				result,
+				sandboxRef,
+				turnId
+			}));
+		} catch (error) {
+			if (!(error instanceof AgentRunError)) throw error;
+			const runError = error.cause;
+			if (isInvocationInputCommitLost(runError)) return { status: "lost_lease" };
+			const blocking = blockingInvocationError(runError);
+			if (blocking) {
+				const terminal = await completeAgentInvocation({
+					invocationId: invocation.invocationId,
+					errorMessage: blocking.message,
+					status: "blocked"
+				});
+				if (terminal) await persistTerminalLifecycle(terminal);
+				await acknowledge();
+				return { status: "completed" };
+			}
+			if (!context.attempt.isFinalAttempt) throw runError;
+			const terminal = await completeAgentInvocation({
+				invocationId: invocation.invocationId,
+				errorMessage: runError instanceof Error ? runError.message : "Agent invocation failed",
+				status: "failed"
+			});
+			if (terminal) await persistTerminalLifecycle(terminal);
+			await acknowledge();
+			return { status: "completed" };
+		}
+		if (outcome.status === "suspended") {
+			await markAgentInvocationAwaitingResume(invocation.invocationId);
+			return { status: "yielded" };
+		}
+		if (outcome.status === "awaiting_auth") {
+			const terminal = await completeAgentInvocation({
+				invocationId: invocation.invocationId,
+				errorMessage: `Agent invocation requires ${outcome.providerDisplayName} authorization`,
+				status: "blocked"
+			});
+			if (terminal) await persistTerminalLifecycle(terminal);
+			await acknowledge();
+			return { status: "completed" };
+		}
+		await acknowledge();
+		return { status: "completed" };
+	};
+}
+/** Route invocation-backed work before falling through to existing consumers. */
+function routeAgentInvocationWork(options) {
+	return async (context) => {
+		const invocationId = await resolveAgentInvocationId(context);
+		return invocationId ? await options.invocationWorker(context, invocationId) : await options.fallbackWorker(context);
+	};
+}
+//#endregion
+export { work_exports as a, resolveAgentInvocationId as i, createAndEnqueueAgentInvocation as n, listPendingAgentInvocationMailboxAppends as o, enqueueAgentInvocation as r, createAgentInvocationWorker as t };