@sentry/junior 0.202.0 → 0.204.0

package/dist/runner-CZV2sC46.js

@@ -0,0 +1,392 @@
+import { p as authorizationId } from "./agent-CMyTD4DD.js";
+import { S as withLogContext, u as logException, y as setTags } from "./logging-BzAk1S_s.js";
+import { t as credentialContextForActor } from "./context-B45_WqVX.js";
+import { Ct as getConversationEventStore, Tt as getConversationStore } from "./agent-hooks-Bbcp9e33.js";
+import { $ as persistConversationMessages, P as commitAcceptedReply, Q as hydrateConversationMessages, R as loadProjection, W as recordAuthorizationCompleted, d as persistWithRetry, dt as recordDeliveredAssistantMessage, it as buildConversationContext, jt as stripRuntimeTurnContext, lt as markConversationMessage, pt as upsertConversationMessage, r as saveTurnCheckpoint, ut as normalizeConversationText } from "./checkpoint-CNrPyRJN.js";
+import { S as startActiveTurn, s as getAssistantReplyText, x as markTurnFailed } from "./pending-auth-CWmSdZVg.js";
+import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-D-O3A-Cp.js";
+import { t as ConversationTurnLifecycleService } from "./turn-lifecycle-DQV19VTW.js";
+import { n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CRc9jTJS.js";
+import { d as buildDeliveredTurnStatePatch, r as finalizeFailedTurnReplyWithEvent, t as completeAuthPauseTurn } from "./auth-pause-state-DosEalIG.js";
+import { randomUUID } from "node:crypto";
+import { createLocalSource, localDestinationSchema } from "@sentry/junior-plugin-api";
+//#region src/chat/local/runner.ts
+const SENTRY_EVENT_ID_PATTERN = /^[a-f0-9]{32}$/i;
+const LOCAL_FAILURE_EVENT_NAMES = {
+	agent_run_failed: "local.agent_run.failed",
+	delivery_failed: "local.reply.delivery.failed",
+	model_execution_failed: "local.model.execution.failed",
+	persistence_failed: "local.turn.persistence.failed"
+};
+function localDestination(conversationId) {
+	const parsed = localDestinationSchema.safeParse({
+		platform: "local",
+		conversationId
+	});
+	if (!parsed.success) throw new Error("Invalid local conversation id");
+	return parsed.data;
+}
+function localTurnId() {
+	return `local-turn-${randomUUID()}`;
+}
+function localRunId() {
+	return `local-run-${randomUUID()}`;
+}
+function captureLocalBoundaryFailure(args) {
+	setTags({
+		conversationId: args.conversationId,
+		...args.runId ? { runId: args.runId } : void 0
+	});
+	const eventId = args.capture(args.error, LOCAL_FAILURE_EVENT_NAMES[args.failureCode], { "app.ai.failure_code": args.failureCode });
+	return eventId && SENTRY_EVENT_ID_PATTERN.test(eventId) ? eventId : void 0;
+}
+/** Load durable local Pi history from the conversation-event projection. */
+async function loadLocalPiMessages(args) {
+	const projection = await loadProjection({ conversationId: args.conversationId });
+	if (projection.length === 0) return;
+	return stripRuntimeTurnContext(projection);
+}
+/** Run one local CLI message through Junior's shared agent-run boundary. */
+async function runLocalAgentTurn(input, deps) {
+	return withLogContext({
+		conversationId: input.conversationId,
+		destinationName: input.conversationId,
+		messageConversationId: input.conversationId,
+		platform: "local",
+		userId: "local-cli",
+		userName: "local"
+	}, () => runLocalAgentTurnInContext(input, deps));
+}
+async function runLocalAgentTurnInContext(input, deps) {
+	const text = input.message.trim();
+	if (!text) throw new Error("Local agent message must not be empty");
+	const destination = localDestination(input.conversationId);
+	const source = createLocalSource(destination.conversationId);
+	const lifecycle = new ConversationTurnLifecycleService(getConversationEventStore());
+	await getConversationStore().recordActivity({
+		conversationId: input.conversationId,
+		destination,
+		nowMs: Date.now(),
+		source: "local",
+		visibility: "private"
+	});
+	const persisted = await getPersistedThreadState(input.conversationId);
+	const conversation = coerceThreadConversationState(persisted);
+	await hydrateConversationMessages({
+		conversation,
+		conversationId: input.conversationId
+	});
+	let sandboxRef = getPersistedSandboxState(persisted);
+	const initialSandboxRef = sandboxRef;
+	const turnId = localTurnId();
+	const userMessageId = `${turnId}:user`;
+	const startedAtMs = Date.now();
+	upsertConversationMessage(conversation, {
+		id: userMessageId,
+		role: "user",
+		text: normalizeConversationText(text),
+		createdAtMs: startedAtMs,
+		author: {
+			fullName: "Local CLI",
+			userId: "local-cli",
+			userName: "local"
+		},
+		meta: {
+			explicitMention: true,
+			replied: false
+		}
+	});
+	await persistConversationMessages({
+		conversation,
+		conversationId: input.conversationId
+	});
+	await lifecycle.start({
+		conversationId: input.conversationId,
+		createdAtMs: Date.now(),
+		inputMessageIds: [userMessageId],
+		surface: "internal",
+		turnId
+	});
+	startActiveTurn({
+		conversation,
+		nextTurnId: turnId
+	});
+	let reply;
+	let completedState;
+	let failureCode = "persistence_failed";
+	let modelFailureEventId;
+	let modelFailureReason;
+	let modelFailureCaptureAttempted = false;
+	let currentRunId;
+	let completionSliceId = 1;
+	const localActor = {
+		fullName: "Local CLI",
+		platform: "local",
+		userId: "local-cli",
+		userName: "local"
+	};
+	let assistantMessageDelivered = false;
+	/** Print and record one completed assistant message in local conversation order. */
+	const deliverAssistantMessage = async (reply) => {
+		const message = typeof reply === "string" ? void 0 : reply;
+		const text = typeof reply === "string" ? reply : getAssistantReplyText(reply);
+		if (!text?.trim()) return;
+		failureCode = "delivery_failed";
+		await deps.deliverReply({ text });
+		assistantMessageDelivered = true;
+		const recordedMessageId = recordDeliveredAssistantMessage({
+			conversation,
+			sessionId: turnId,
+			text,
+			userMessageId
+		});
+		try {
+			await persistWithRetry(() => message ? commitAcceptedReply({
+				agentMessage: message,
+				conversation,
+				conversationMessageId: recordedMessageId,
+				conversationId: input.conversationId
+			}) : persistConversationMessages({
+				conversation,
+				conversationId: input.conversationId
+			}));
+		} catch (error) {
+			logException(/* @__PURE__ */ new Error("Accepted assistant message persistence failed"), "local.assistant.message_post_delivery_persist.failed", { "error.type": error instanceof Error ? error.name : typeof error });
+		}
+		failureCode = "agent_run_failed";
+	};
+	try {
+		await persistThreadStateById(input.conversationId, { conversation });
+		const piMessages = await loadLocalPiMessages({ conversationId: input.conversationId });
+		failureCode = "agent_run_failed";
+		const runAgent = async (messages) => {
+			currentRunId = localRunId();
+			setTags({ runId: currentRunId });
+			const authorization = deps.authorization ? {
+				createState: deps.authorization.createState,
+				deliver: deps.authorization.deliver
+			} : void 0;
+			return await deps.agentRunner.run({
+				conversationId: input.conversationId,
+				turnId,
+				runId: currentRunId,
+				instruction: {
+					text,
+					context: buildConversationContext(conversation, { excludeMessageId: userMessageId })
+				},
+				history: messages,
+				actor: localActor,
+				credentialContext: credentialContextForActor(localActor),
+				destination,
+				source,
+				surface: "internal",
+				authorization,
+				...deps.authorization ? void 0 : { disabledFeatures: ["interactive-auth"] },
+				environment: { sandboxEgressSignals: deps.sandboxEgressSignals },
+				state: {
+					pendingAuth: conversation.processing.pendingAuth,
+					sandboxRef
+				},
+				onEvent: async (event) => {
+					if (event.type === "status") {
+						await deps.onStatus?.(event.text);
+						return;
+					}
+					if (event.type === "tool_started") {
+						await deps.onToolInvocation?.({
+							params: event.params,
+							toolName: event.toolName
+						});
+						return;
+					}
+					if (event.type === "tool_finished") await deps.onToolResult?.(event.report);
+				},
+				delivery: deliverAssistantMessage,
+				durability: {
+					onSandboxRefChanged: async (nextSandboxRef) => {
+						sandboxRef = nextSandboxRef;
+						await persistThreadStateById(input.conversationId, {
+							conversation,
+							sandboxRef
+						});
+					},
+					recordPendingAuth: async (pendingAuth) => {
+						conversation.processing.pendingAuth = pendingAuth;
+						await persistThreadStateById(input.conversationId, {
+							conversation,
+							sandboxRef
+						});
+					}
+				}
+			});
+		};
+		let outcome = await runAgent(piMessages);
+		while (outcome.status === "awaiting_auth") {
+			const pendingAuth = conversation.processing.pendingAuth;
+			if (!pendingAuth || !deps.authorization) throw new Error("Local OAuth requires an active callback server and authorization delivery.");
+			completeAuthPauseTurn({
+				conversation,
+				sessionId: turnId
+			});
+			await persistThreadStateById(input.conversationId, {
+				conversation,
+				sandboxRef
+			});
+			await deps.authorization.wait();
+			await recordAuthorizationCompleted({
+				conversationId: input.conversationId,
+				kind: pendingAuth.kind,
+				provider: pendingAuth.provider,
+				actorId: pendingAuth.actorId,
+				authorizationId: authorizationId({
+					sessionId: turnId,
+					kind: pendingAuth.kind,
+					provider: pendingAuth.provider
+				})
+			});
+			completionSliceId += 1;
+			outcome = await runAgent(await loadLocalPiMessages({ conversationId: input.conversationId }));
+		}
+		if (outcome.status !== "completed") throw new Error(`Local agent run ended with ${outcome.status}`);
+		reply = outcome.result;
+		modelFailureCaptureAttempted = reply.diagnostics.outcome !== "success";
+		const finalized = finalizeFailedTurnReplyWithEvent({
+			reply,
+			logException
+		});
+		reply = finalized.reply;
+		modelFailureEventId = finalized.eventId;
+		modelFailureReason = finalized.failureReason;
+		if (reply.diagnostics.outcome !== "success") await deliverAssistantMessage(reply.text);
+		completedState = buildDeliveredTurnStatePatch({
+			conversation,
+			reply,
+			sessionId: turnId,
+			userMessageId
+		});
+	} catch (error) {
+		deps.authorization?.cancel();
+		const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureLocalBoundaryFailure({
+			capture: logException,
+			conversationId: input.conversationId,
+			error,
+			failureCode,
+			runId: currentRunId
+		});
+		try {
+			markTurnFailed({
+				conversation,
+				nowMs: Date.now(),
+				sessionId: turnId,
+				userMessageId,
+				markConversationMessage
+			});
+			await persistThreadStateById(input.conversationId, {
+				conversation,
+				sandboxRef: initialSandboxRef ?? null
+			});
+		} catch (persistenceError) {
+			const persistenceEventId = captureLocalBoundaryFailure({
+				capture: logException,
+				conversationId: input.conversationId,
+				error: persistenceError,
+				failureCode: "persistence_failed",
+				runId: currentRunId
+			});
+			await lifecycle.fail({
+				conversationId: input.conversationId,
+				createdAtMs: Date.now(),
+				...persistenceEventId ? { eventId: persistenceEventId } : void 0,
+				failureCode: "persistence_failed",
+				turnId
+			});
+			throw new AggregateError([error, persistenceError], "Local turn failure state could not be persisted");
+		}
+		await lifecycle.fail({
+			conversationId: input.conversationId,
+			createdAtMs: Date.now(),
+			...failureEventId ? { eventId: failureEventId } : void 0,
+			failureCode,
+			turnId
+		});
+		throw error;
+	}
+	deps.authorization?.cancel();
+	try {
+		await persistThreadStateById(input.conversationId, {
+			conversation: completedState.conversation,
+			sandboxRef: reply.sandboxRef ?? sandboxRef
+		});
+		if (reply.piMessages?.length) await saveTurnCheckpoint({
+			mode: "completed",
+			conversationId: input.conversationId,
+			turnId,
+			sliceId: completionSliceId,
+			messages: reply.piMessages,
+			durationMs: reply.diagnostics.durationMs,
+			usage: reply.diagnostics.usage,
+			destination,
+			source,
+			actor: localActor,
+			surface: "internal"
+		});
+	} catch (error) {
+		const persistenceEventId = captureLocalBoundaryFailure({
+			capture: logException,
+			conversationId: input.conversationId,
+			error,
+			failureCode: "persistence_failed",
+			runId: currentRunId
+		});
+		await lifecycle.fail({
+			conversationId: input.conversationId,
+			createdAtMs: Date.now(),
+			...persistenceEventId ? { eventId: persistenceEventId } : void 0,
+			failureCode: "persistence_failed",
+			turnId
+		});
+		throw error;
+	}
+	if (reply.diagnostics.outcome === "success") await lifecycle.complete({
+		conversationId: input.conversationId,
+		createdAtMs: Date.now(),
+		outcome: assistantMessageDelivered ? "success" : "no_reply",
+		turnId
+	});
+	else await lifecycle.fail({
+		conversationId: input.conversationId,
+		createdAtMs: Date.now(),
+		...modelFailureEventId ? { eventId: modelFailureEventId } : void 0,
+		failureCode: "model_execution_failed",
+		...modelFailureReason ? { failureReason: modelFailureReason } : void 0,
+		turnId
+	});
+	if (reply.diagnostics.outcome === "success") try {
+		await scheduleSessionCompletedPluginTasks({
+			conversationId: input.conversationId,
+			sessionId: turnId
+		}, { send: async (message) => {
+			try {
+				await processPluginTask(message);
+			} catch (error) {
+				logException(error, "local.plugin.session_completion_task.failed", {
+					conversationId: input.conversationId,
+					pluginName: message.plugin,
+					taskName: message.name,
+					turnId
+				});
+			}
+		} });
+	} catch (error) {
+		logException(error, "local.plugin.session_completion_task.failed", {
+			conversationId: input.conversationId,
+			turnId
+		});
+	}
+	return {
+		conversationId: input.conversationId,
+		outcome: reply.diagnostics.outcome
+	};
+}
+//#endregion
+export { runLocalAgentTurn };

package/dist/sandbox-egress-signals-bHZfmhbd.js

@@ -0,0 +1,46 @@
+import { Z as sandboxEgressSignalsResponseSchema } from "./agent-CMyTD4DD.js";
+//#region src/chat/local/sandbox-egress-signals.ts
+const SANDBOX_EGRESS_SIGNALS_PATH = "/api/internal/sandbox-egress/signals";
+const LOCAL_DEV_SERVER_TIMEOUT_MS = 1e3;
+function signalRequest(baseUrl, credentialToken) {
+	return {
+		headers: { "x-junior-sandbox-egress-token": credentialToken },
+		url: `${baseUrl}${SANDBOX_EGRESS_SIGNALS_PATH}`
+	};
+}
+async function requestLocalDevServer(request, init) {
+	try {
+		return await fetch(request.url, {
+			...init,
+			headers: request.headers,
+			signal: AbortSignal.timeout(LOCAL_DEV_SERVER_TIMEOUT_MS)
+		});
+	} catch {
+		return;
+	}
+}
+/** Create authenticated sandbox egress signal transport to the loopback dev server. */
+function createLocalSandboxEgressSignalTransport(baseUrl) {
+	return {
+		clear: async (credentialToken) => {
+			const response = await requestLocalDevServer(signalRequest(baseUrl, credentialToken), { method: "DELETE" });
+			if (!response) return;
+			if (!response.ok) throw new Error(`Could not clear dev-server sandbox egress signals: HTTP ${response.status}`);
+		},
+		consume: async (credentialToken) => {
+			const response = await requestLocalDevServer(signalRequest(baseUrl, credentialToken));
+			if (!response) return {};
+			if (!response.ok) throw new Error(`Could not consume dev-server sandbox egress signals: HTTP ${response.status}`);
+			const value = sandboxEgressSignalsResponseSchema.safeParse(await response.json());
+			if (!value.success) throw new Error("Dev-server sandbox egress signals were invalid");
+			const authRequired = value.data.auth_required;
+			const permissionDenied = value.data.permission_denied;
+			return {
+				...authRequired ? { authRequired } : void 0,
+				...permissionDenied ? { permissionDenied } : void 0
+			};
+		}
+	};
+}
+//#endregion
+export { createLocalSandboxEgressSignalTransport };