@sentry/junior 0.225.0 → 0.227.0

package/dist/web-authorization-r2lKYKJ2.js

@@ -0,0 +1,162 @@
+import { Ht as requestConversationWork, Mt as ensureConversationWake } from "./agent-runner-BGDSjciH.js";
+import { Xt as getConversationEventStore } from "./agent-hooks-bEwEJhlg.js";
+import { n as loadTurnCheckpoint, o as failTurnRecord, s as getTurnRecord } from "./checkpoint-oZYD3-Ar.js";
+import { w as getStateAdapter } from "./profile-upzC-wN1.js";
+import { a as getVercelConversationWorkQueue } from "./job-queue-AI0_QAgc.js";
+import { n as resolveTurnSessionRouting } from "./turn-session-routing-DyLGd_wU.js";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+//#region src/chat/task-execution/authorized-turn.ts
+/**
+* OAuth callbacks save readiness, not agent history. The conversation worker
+* consumes this event under its lease before it resumes the paused Turn.
+*/
+const authorizationSchema = z.object({
+	kind: z.enum(["mcp", "plugin"]),
+	provider: z.string().min(1),
+	actorId: z.string().min(1),
+	authorizationId: z.string().min(1),
+	authSessionId: z.string().optional(),
+	scope: z.string().optional(),
+	configuration: z.record(z.string(), z.unknown()).optional(),
+	toolChannelId: z.string().optional()
+});
+function authorizationKey$1(turn) {
+	return `turn:${turn.turnId}:authorization:${turn.version}`;
+}
+/** Save authorization for this parked boundary without changing model history. */
+async function recordTurnAuthorization(args) {
+	const turn = await getTurnRecord(args.conversationId, args.turnId);
+	if (!turn || turn.state !== "paused" || turn.resumeReason !== "auth") return;
+	await getConversationEventStore().append(args.conversationId, [{
+		idempotencyKey: authorizationKey$1(turn),
+		createdAtMs: Date.now(),
+		data: {
+			type: "structured_event",
+			namespace: "junior",
+			name: "turn_authorized",
+			version: 1,
+			turnId: turn.turnId,
+			content: authorizationSchema.parse(args)
+		}
+	}], { activity: "preserve" });
+	return {
+		conversationId: args.conversationId,
+		destination: args.destination,
+		turnId: turn.turnId,
+		expectedVersion: turn.version
+	};
+}
+/** Read authorization for the exact pause; a later auth pause needs its own callback. */
+async function getTurnAuthorization(turn) {
+	const event = await getConversationEventStore().loadByIdempotencyKey(turn.conversationId, authorizationKey$1(turn));
+	if (event?.data.type !== "structured_event") return void 0;
+	return authorizationSchema.parse(event.data.content);
+}
+//#endregion
+//#region src/chat/task-execution/turn-wake.ts
+/** Build the worker input for a paused turn. */
+async function getPausedTurnRequest(args) {
+	const turn = (await loadTurnCheckpoint({
+		conversationId: args.conversationId,
+		turnId: args.turnId
+	})).record;
+	if (!turn || turn.state !== "paused" || turn.resumeReason !== "timeout" && turn.resumeReason !== "yield" && turn.resumeReason !== "retry" && !(turn.resumeReason === "auth" && await getTurnAuthorization(turn)) || turn.resumeReason === "timeout" && turn.sliceId < 2) return;
+	let routing;
+	try {
+		routing = await resolveTurnSessionRouting({
+			conversationId: args.conversationId,
+			conversationStore: args.conversationStore
+		});
+	} catch (error) {
+		await failTurnRecord({
+			conversationId: args.conversationId,
+			expectedVersion: turn.version,
+			turnId: args.turnId,
+			errorMessage: error instanceof Error ? error.message : String(error)
+		});
+		return;
+	}
+	return {
+		conversationId: args.conversationId,
+		destination: routing.destination,
+		turnId: args.turnId,
+		expectedVersion: turn.version
+	};
+}
+/** Wake the conversation worker for a paused turn. */
+async function wakePausedTurn(request, options = {}) {
+	const nowMs = options.nowMs ?? Date.now();
+	await requestConversationWork({
+		conversationId: request.conversationId,
+		destination: request.destination,
+		nowMs,
+		state: options.state
+	});
+	const queue = options.queue ?? getVercelConversationWorkQueue();
+	await ensureConversationWake({
+		conversationId: request.conversationId,
+		idempotencyKey: [
+			"agent-continue",
+			request.conversationId,
+			request.turnId,
+			request.expectedVersion,
+			nowMs
+		].join(":"),
+		nowMs,
+		queue,
+		state: options.state
+	});
+}
+/** Create paused Turn operations for one app. */
+function createPausedTurns(options = {}) {
+	return {
+		get: (args) => getPausedTurnRequest({
+			...args,
+			conversationStore: options.conversationStore
+		}),
+		wake: (request) => wakePausedTurn(request, options)
+	};
+}
+/** Record completed authorization and wake the sole execution owner. */
+async function wakeAuthorizedTurn(args, queue) {
+	const request = await recordTurnAuthorization(args);
+	if (request) await wakePausedTurn(request, { queue });
+}
+//#endregion
+//#region src/chat/conversations/web-authorization.ts
+const WEB_AUTHORIZATION_PREFIX = "junior:web_authorization:v1";
+const WEB_AUTHORIZATION_TTL_MS = 864e5;
+function authorizationKey(conversationId, actorId) {
+	return `${WEB_AUTHORIZATION_PREFIX}:${conversationId}:${actorId}`;
+}
+/** Build authorization delivery for one web turn. */
+function createWebAuthorization(args) {
+	return {
+		createState: async () => randomUUID(),
+		deliver: async (request) => {
+			await getStateAdapter().set(authorizationKey(args.conversationId, args.actorId), JSON.stringify({
+				...request,
+				...args
+			}), WEB_AUTHORIZATION_TTL_MS);
+		}
+	};
+}
+/** Read the pending authorization request for one web actor. */
+async function getWebAuthorization(args) {
+	const value = await getStateAdapter().get(authorizationKey(args.conversationId, args.actorId));
+	if (typeof value !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		if (parsed.actorId !== args.actorId || parsed.conversationId !== args.conversationId || typeof parsed.authorizationUrl !== "string" || typeof parsed.label !== "string" || typeof parsed.completionText !== "string") return;
+		return parsed;
+	} catch {
+		return;
+	}
+}
+/** Remove a web authorization request after the parked turn continues. */
+async function deleteWebAuthorization(args) {
+	await getStateAdapter().delete(authorizationKey(args.conversationId, args.actorId));
+}
+//#endregion
+export { getPausedTurnRequest as a, getTurnAuthorization as c, createPausedTurns as i, deleteWebAuthorization as n, wakeAuthorizedTurn as o, getWebAuthorization as r, wakePausedTurn as s, createWebAuthorization as t };