@sentry/junior 0.225.0 → 0.227.0

package/dist/{credential-sync-DCB2SwnQ.js → credential-sync-CUGbiiCM.js}

@@ -1,144 +1,24 @@
-import { C as resolvePluginOAuthAccount, D as lookupSlackUserProfile, V as getMcpProviderErrorAttributes, _ as putMcpStoredOAuthCredentials, at as parseOAuthStatePayload, b as getConversationPendingAuth, d as deleteMcpAuthSession, g as getMcpStoredOAuthCredentials, h as getMcpAuthSession, it as formatProviderLabel, mt as postSlackMessage, ot as resolveBaseUrl, u as finalizeMcpAuthorization, vt as createUserTokenStore } from "./agent-runner-Cad1RtWn.js";
-import { m as escapeXml } from "./client-ihmkx60d.js";
-import { d as logException, h as runBestEffort, p as logWarn } from "./logging-CcTvYQ8A.js";
-import { n as botConfig, o as getRuntimeMetadata } from "./config-DMg679BW.js";
-import { g as parseSlackUserId } from "./context-Bplcgypl.js";
-import { Jt as getSqlExecutor, U as getSlackClient, Wt as getConversationEventStore, ln as upsertIdentity, un as upsertLinkedIdentity } from "./agent-hooks-CRuRcOg9.js";
+import { Cn as createUserTokenStore, T as lookupSlackUserProfile, _ as putMcpStoredOAuthCredentials, d as deleteMcpAuthSession, dn as resolveBaseUrl, ft as getMcpProviderErrorAttributes, g as getMcpStoredOAuthCredentials, h as getMcpAuthSession, ln as formatProviderLabel, u as finalizeMcpAuthorization, un as parseOAuthStatePayload, x as resolvePluginOAuthAccount, yn as postSlackMessage } from "./agent-runner-BGDSjciH.js";
+import { m as escapeXml } from "./client-Pcxo3lGn.js";
+import { d as logException, h as runBestEffort, p as logWarn } from "./logging-BPBx6WF-.js";
+import { n as botConfig, o as getRuntimeMetadata } from "./config-CYvEow1F.js";
+import { g as parseSlackUserId } from "./context-0Et9iVSB.js";
+import { U as getSlackClient, en as getSqlExecutor, hn as upsertLinkedIdentity, mn as upsertIdentity } from "./agent-hooks-bEwEJhlg.js";
 import { i as homeDir } from "./package-discovery-7a9YqLhE.js";
-import { n as buildOAuthTokenRequest, r as parseOAuthTokenResponse, u as hasRequiredOAuthScope } from "./registry-C8I4IejN.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-pv4grNNb.js";
-import { t as discoverSkills } from "./skills-DUcDEgDI.js";
-import { B as recordAuthorizationCompleted, n as loadTurnCheckpoint, o as failTurnRecord, s as getTurnRecord, z as recordAuthenticationLinked } from "./checkpoint-6fkAdB3g.js";
-import { E as acquireActiveLock, w as getStateAdapter } from "./profile-CV97YuiL.js";
-import { Pt as requestConversationWork, wt as ensureConversationWake } from "./stats-DawHjcTw.js";
-import { t as getVercelConversationWorkQueue } from "./vercel-queue-DIkVcfK4.js";
-import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CAR6gdAm.js";
-import { n as resolveTurnSessionRouting } from "./turn-session-routing-Jkmmxpp-.js";
+import { n as buildOAuthTokenRequest, r as parseOAuthTokenResponse, u as hasRequiredOAuthScope } from "./registry-DM5aMhjm.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-Cw9V2jpn.js";
+import { t as discoverSkills } from "./skills-CAI5s___.js";
+import { B as recordAuthorizationCompleted, s as getTurnRecord, z as recordAuthenticationLinked } from "./checkpoint-oZYD3-Ar.js";
+import { E as acquireActiveLock, w as getStateAdapter } from "./profile-upzC-wN1.js";
+import { i as getConversationPendingAuth } from "./pending-auth-CHUjr_6d.js";
+import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-C_arVuaN.js";
+import { n as deleteWebAuthorization, o as wakeAuthorizedTurn, s as wakePausedTurn } from "./web-authorization-r2lKYKJ2.js";
 import { n as relayLocalOAuthCallback } from "./oauth-relay-CdCnu80W.js";
-import { n as deleteWebAuthorization } from "./web-authorization-B09B8A8R.js";
 import path from "node:path";
 import { z } from "zod";
 import { createHmac, createSecretKey, timingSafeEqual } from "node:crypto";
 import { pluginStoredTokensSchema } from "@sentry/junior-plugin-api";
 import fs from "node:fs";
-//#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(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(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(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/handlers/oauth-html.ts
 /** Build pre-escaped callback HTML with the shared response security policy. */
 function htmlCallbackResponse(title, message, status, options = {}) {
@@ -937,4 +817,4 @@ async function receiveLocalOAuthCredential(request) {
 	return new Response(null, { status: 204 });
 }
 //#endregion
-export { GET$1 as a, wakePausedTurn as c, publishAppHomeView as i, getTurnAuthorization as l, syncLocalOAuthCredential as n, createPausedTurns as o, GET as r, getPausedTurnRequest as s, receiveLocalOAuthCredential as t };
+export { GET$1 as a, publishAppHomeView as i, syncLocalOAuthCredential as n, GET as r, receiveLocalOAuthCredential as t };

package/dist/{executor-B9R4cHte.js → executor-BXMlFrV6.js}

@@ -1,5 +1,5 @@
 import { g as startSpanManual } from "./sentry-CgWZM_kV.js";
-import "./config-DMg679BW.js";
+import "./config-CYvEow1F.js";
 import { n as juniorDestinations, r as timestamptz } from "./destinations-BeBiJeEM.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { getTableColumns, sql } from "drizzle-orm";

package/dist/history-nukv1YN8.d.ts

@@ -0,0 +1,127 @@
+import { z } from "zod";
+import "@sentry/junior-plugin-api";
+//#region src/chat/attachments/input.d.ts
+/** Bound JSON image input below the hosting platform's request size limit. */
+declare const MAX_INPUT_IMAGE_BYTES: number;
+declare const MAX_INPUT_IMAGES = 3;
+/** Image bytes accepted with a web message, never stored in its mailbox row. */
+declare const inputImageSchema: z.ZodObject<{
+  filename: z.ZodString;
+  contentType: z.ZodEnum<{
+    "image/png": "image/png";
+    "image/jpeg": "image/jpeg";
+    "image/gif": "image/gif";
+    "image/webp": "image/webp";
+  }>;
+  data: z.ZodString;
+}, z.core.$strict>;
+type InputImage = z.output<typeof inputImageSchema>;
+/** Safe attachment facts shared by mailbox input and transcript messages. */
+declare const messageAttachmentSchema: z.ZodObject<{
+  id: z.ZodString;
+  filename: z.ZodString;
+  contentType: z.ZodString;
+  bytes: z.ZodNumber;
+}, z.core.$strict>;
+type MessageAttachment = z.output<typeof messageAttachmentSchema>;
+//#endregion
+//#region src/chat/conversations/cards.d.ts
+/** Built-in response types accepted by Message storage and delivery. */
+declare const messageCardSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"automation">;
+  id: z.ZodString;
+  title: z.ZodString;
+  url: z.ZodNullable<z.ZodString>;
+  instruction: z.ZodString;
+  trigger: z.ZodString;
+  warning: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"object">;
+  key: z.ZodString;
+  label: z.ZodString;
+  objectType: z.ZodEnum<{
+    code_change: "code_change";
+    task: "task";
+    automation: "automation";
+    item: "item";
+  }>;
+  title: z.ZodString;
+  url: z.ZodNullable<z.ZodURL>;
+  description: z.ZodOptional<z.ZodString>;
+  status: z.ZodOptional<z.ZodString>;
+  trigger: z.ZodOptional<z.ZodString>;
+  warning: z.ZodOptional<z.ZodString>;
+  displayType: z.ZodOptional<z.ZodString>;
+  sourceUpdatedAt: z.ZodOptional<z.ZodISODateTime>;
+  facts: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"code_change">;
+    author: z.ZodOptional<z.ZodString>;
+    sourceBranch: z.ZodOptional<z.ZodString>;
+    targetBranch: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    review: z.ZodOptional<z.ZodEnum<{
+      required: "required";
+      approved: "approved";
+      changes_requested: "changes_requested";
+    }>>;
+    checks: z.ZodOptional<z.ZodObject<{
+      passed: z.ZodNumber;
+      failed: z.ZodNumber;
+      pending: z.ZodNumber;
+    }, z.core.$strict>>;
+    mergeable: z.ZodOptional<z.ZodBoolean>;
+    changedFiles: z.ZodOptional<z.ZodNumber>;
+    additions: z.ZodOptional<z.ZodNumber>;
+    deletions: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"task">;
+    assignees: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    cycle: z.ZodOptional<z.ZodString>;
+    dueDate: z.ZodOptional<z.ZodISODate>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"deployment">;
+    project: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+    revision: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>], "type">>;
+  plugin: z.ZodString;
+}, z.core.$strict>], "kind">;
+type MessageCard = z.output<typeof messageCardSchema>;
+/** Render each built-in card with its own text format. */
+declare function messageCardText(card: MessageCard): string;
+//#endregion
+//#region src/chat/conversations/history.d.ts
+/** Where a failed turn stopped. */
+declare const conversationTurnFailureCodeSchema: z.ZodEnum<{
+  agent_run_failed: "agent_run_failed";
+  delivery_failed: "delivery_failed";
+  model_execution_failed: "model_execution_failed";
+  persistence_failed: "persistence_failed";
+}>;
+/**
+ * Why a failed turn stopped.
+ * Values are fixed labels only. Do not store raw exception text.
+ */
+declare const conversationTurnFailureReasonSchema: z.ZodEnum<{
+  unknown: "unknown";
+  capacity: "capacity";
+  auth: "auth";
+  permission: "permission";
+  rate_limit: "rate_limit";
+  timeout: "timeout";
+  network: "network";
+  server: "server";
+  invalid_request: "invalid_request";
+  invalid_response: "invalid_response";
+  quota: "quota";
+  content_policy: "content_policy";
+  empty_output: "empty_output";
+  tool_errors: "tool_errors";
+  suppressed_output: "suppressed_output";
+}>;
+//#endregion
+export { InputImage as a, MessageAttachment as c, messageCardText as i, conversationTurnFailureReasonSchema as n, MAX_INPUT_IMAGES as o, MessageCard as r, MAX_INPUT_IMAGE_BYTES as s, conversationTurnFailureCodeSchema as t };

package/dist/images-8siTAUNW.js

@@ -0,0 +1,82 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { j as storeAttachment, k as readLiveAttachment } from "./agent-runner-BGDSjciH.js";
+import { en as getSqlExecutor } from "./agent-hooks-bEwEJhlg.js";
+import "./conversation-BnhOMfEB.js";
+//#region src/chat/attachments/images.ts
+var images_exports = /* @__PURE__ */ __exportAll({
+	decodeInputImages: () => decodeInputImages,
+	loadInputImages: () => loadInputImages,
+	storeInputImages: () => storeInputImages
+});
+function matchesImageType(data, contentType) {
+	switch (contentType) {
+		case "image/png": return data.subarray(0, 8).equals(Buffer.from([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		]));
+		case "image/jpeg": return data[0] === 255 && data[1] === 216 && data[2] === 255;
+		case "image/gif": return ["GIF87a", "GIF89a"].includes(data.toString("ascii", 0, 6));
+		case "image/webp": return data.toString("ascii", 0, 4) === "RIFF" && data.toString("ascii", 8, 12) === "WEBP";
+	}
+}
+/** Check declared image types against file signatures before storing uploads. */
+function decodeInputImages(images) {
+	const files = images.map((image) => {
+		const data = Buffer.from(image.data, "base64");
+		if (!matchesImageType(data, image.contentType) || data.toString("base64") !== image.data) throw new Error("Use PNG, JPEG, GIF, or WebP image files.");
+		return {
+			data,
+			bytes: data.byteLength,
+			filename: image.filename,
+			mimeType: image.contentType,
+			path: image.filename
+		};
+	});
+	if (files.reduce((sum, file) => sum + file.bytes, 0) > 3145728) throw new Error("Images must total 3 MB or less.");
+	return files;
+}
+/** Store image bytes before accepting a message into the mailbox. */
+async function storeInputImages(args) {
+	return await Promise.all(args.files.map(async (file) => {
+		return {
+			id: (await storeAttachment({
+				conversationId: args.conversationId,
+				db: getSqlExecutor(),
+				file,
+				storage: args.storage
+			})).id,
+			filename: file.filename,
+			contentType: file.mimeType,
+			bytes: file.bytes
+		};
+	}));
+}
+/** Load stored images for model input. */
+async function loadInputImages(args) {
+	return await Promise.all(args.attachments.map(async (ref) => {
+		const attachment = await readLiveAttachment({
+			attachmentId: ref.id,
+			conversationId: args.conversationId,
+			db: getSqlExecutor()
+		});
+		if (!attachment || attachment.storageProvider !== args.storage.provider) throw new Error("Input image is no longer available.");
+		const body = await args.storage.get(attachment.storageKey);
+		if (!body) throw new Error("Input image contents are unavailable.");
+		const data = Buffer.from(await new Response(body).arrayBuffer());
+		if (data.byteLength !== attachment.bytes) throw new Error("Input image size does not match stored metadata.");
+		return {
+			attachmentId: ref.id,
+			filename: attachment.filename,
+			mediaType: attachment.contentType,
+			data
+		};
+	}));
+}
+//#endregion
+export { images_exports as n, storeInputImages as r, decodeInputImages as t };

package/dist/instrumentation.js

@@ -1,6 +1,6 @@
-import { N as getDeploymentServiceVersion, P as getDeploymentTelemetryAttributes } from "./logging-CcTvYQ8A.js";
+import { N as getDeploymentServiceVersion, P as getDeploymentTelemetryAttributes } from "./logging-BPBx6WF-.js";
 import { _ as vercelAIIntegration, a as getClient, b as withStreamedSpan, c as init, o as getGlobalScope } from "./sentry-CgWZM_kV.js";
-import { n as getCurrentConversationPrivacy } from "./conversation-privacy-ZYy05Y3q.js";
+import { n as getCurrentConversationPrivacy } from "./conversation-privacy-hQmyZbOC.js";
 import { t as consumePrivateTraceResultMarker } from "./private-trace-result-BLvBjy_e.js";
 //#region src/chat/sentry-payload-filter.ts
 const PAYLOAD_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([

package/dist/{vercel-queue-DIkVcfK4.js → job-queue-AI0_QAgc.js}

@@ -1,5 +1,7 @@
+import { a as getChatConfig } from "./config-CYvEow1F.js";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
-import { createHmac, timingSafeEqual } from "node:crypto";
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
 import { QueueClient } from "@vercel/queue";
 /** Validate the v2 conversation work hint sent through Vercel Queue. */
 const conversationQueueMessageSchema = z.object({
@@ -21,6 +23,24 @@ function isConversationQueueMessageRejectedError(error) {
 	return error instanceof ConversationQueueMessageRejectedError;
 }
 //#endregion
+//#region src/chat/runtime/request-deadline.ts
+const requestDeadlineStorage = new AsyncLocalStorage();
+function createTurnRequestDeadline(startedAtMs) {
+	return {
+		startedAtMs,
+		deadlineAtMs: startedAtMs + Math.max(1, getChatConfig().functionMaxDurationSeconds * 1e3 - 2e4)
+	};
+}
+/** Return the host request deadline inherited by the current async turn. */
+function getTurnRequestDeadline() {
+	return requestDeadlineStorage.getStore();
+}
+/** Run work with one host request deadline shared by nested queued turns. */
+function runWithTurnRequestDeadline(callback, startedAtMs = Date.now()) {
+	if (requestDeadlineStorage.getStore()) return callback();
+	return requestDeadlineStorage.run(createTurnRequestDeadline(startedAtMs), callback);
+}
+//#endregion
 //#region src/chat/vercel-queue-client.ts
 function defaultQueueClientOptions() {
 	if (process.env.VERCEL_DEPLOYMENT_ID?.trim()) return {};
@@ -164,4 +184,43 @@ function getVercelConversationWorkQueue() {
 	return defaultQueue;
 }
 //#endregion
-export { signQueueMessage as a, ConversationQueueMessageRejectedError as c, QUEUE_SIGNATURE_MAX_AGE_MS as i, conversationQueueMessageSchema as l, resolveConversationWorkQueueTopic as n, verifyQueueMessage as o, verifyConversationQueueMessage as r, createVercelQueueClient as s, getVercelConversationWorkQueue as t, isConversationQueueMessageRejectedError as u };
+//#region src/chat/sandbox/snapshot/job-queue.ts
+/** Send Workspace snapshot build messages. */
+const SIGNATURE_CONTEXT = "junior.workspace_snapshot_queue.v1";
+const SIGNATURE_VERSION = "v1";
+const WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC = "junior_workspace_snapshots";
+const workspaceSnapshotJobSign = {
+	context: SIGNATURE_CONTEXT,
+	schema: z.object({
+		workspaceId: z.string().uuid(),
+		profileHash: z.string().min(1)
+	}).strict(),
+	signatureVersion: SIGNATURE_VERSION,
+	parts: (message) => [message.workspaceId, message.profileHash]
+};
+function jobId(message) {
+	return `workspace-snapshot_${createHash("sha256").update(message.workspaceId).update("\0").update(message.profileHash).digest("hex").slice(0, 32)}`;
+}
+/** Sign a Workspace snapshot job for tests and local checks. */
+function signWorkspaceSnapshotJobMessage(message, nowMs = Date.now()) {
+	return signQueueMessage(workspaceSnapshotJobSign, message, nowMs);
+}
+/** Check that a recent queue message came from Junior. */
+function verifyWorkspaceSnapshotJobMessage(value, nowMs = Date.now()) {
+	return verifyQueueMessage(workspaceSnapshotJobSign, value, nowMs);
+}
+async function send(message, idempotencyKey) {
+	const options = { retentionSeconds: QUEUE_SIGNATURE_MAX_AGE_MS / 1e3 };
+	if (idempotencyKey) options.idempotencyKey = idempotencyKey;
+	await createVercelQueueClient().send(WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC, signWorkspaceSnapshotJobMessage(message), options);
+}
+/** Send a job unless the same Workspace build already has one. */
+async function sendWorkspaceSnapshotJob(message) {
+	await send(message, jobId(message));
+}
+/** Send the next job for a Workspace build that is still running. */
+async function sendNextWorkspaceSnapshotJob(message) {
+	await send(message);
+}
+//#endregion
+export { getVercelConversationWorkQueue as a, QUEUE_SIGNATURE_MAX_AGE_MS as c, createVercelQueueClient as d, getTurnRequestDeadline as f, isConversationQueueMessageRejectedError as g, conversationQueueMessageSchema as h, verifyWorkspaceSnapshotJobMessage as i, signQueueMessage as l, ConversationQueueMessageRejectedError as m, sendNextWorkspaceSnapshotJob as n, resolveConversationWorkQueueTopic as o, runWithTurnRequestDeadline as p, sendWorkspaceSnapshotJob as r, verifyConversationQueueMessage as s, WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC as t, verifyQueueMessage as u };

package/dist/{logging-CcTvYQ8A.js → logging-BPBx6WF-.js}

@@ -1,5 +1,5 @@
 import { d as setTag, f as setUser, h as startSpan, i as getActiveSpan, l as logger, n as captureMessage, p as spanToJSON, s as getTraceData, t as captureException, y as withScope } from "./sentry-CgWZM_kV.js";
-import { t as JUNIOR_VERSION } from "./version-DYcuOFQb.js";
+import { t as JUNIOR_VERSION } from "./version-lhQSfLjx.js";
 import path from "node:path";
 import { styleText } from "node:util";
 import { ConfigError, configureSync, getConfig, getLogger } from "@logtape/logtape";

package/dist/nitro.d.ts

@@ -1,4 +1,4 @@
-import { n as JuniorDashboardOptions } from "./app-BbSD6EtD.js";
+import { n as JuniorDashboardOptions } from "./app-CjRIKZb5.js";
 import { n as JuniorPluginSet } from "./plugins-BT2l4We3.js";
 //#region src/nitro.d.ts
 export type JuniorNitroDashboardOptions = JuniorDashboardOptions;

package/dist/nitro.js

@@ -1,9 +1,8 @@
-import { A as JUNIOR_RETENTION_ROUTE, D as JUNIOR_HEARTBEAT_ROUTE, E as JUNIOR_HEARTBEAT_CRON_SCHEDULE, O as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, T as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, j as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, k as JUNIOR_RETENTION_CRON_SCHEDULE } from "./logging-CcTvYQ8A.js";
+import { A as JUNIOR_RETENTION_ROUTE, D as JUNIOR_HEARTBEAT_ROUTE, E as JUNIOR_HEARTBEAT_CRON_SCHEDULE, O as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, T as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, j as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, k as JUNIOR_RETENTION_CRON_SCHEDULE } from "./logging-BPBx6WF-.js";
 import { d as resolvePackageDir, t as discoverInstalledPluginPackageContent, u as isValidPackageName } from "./package-discovery-7a9YqLhE.js";
-import { n as resolveConversationWorkQueueTopic } from "./vercel-queue-DIkVcfK4.js";
-import { t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-D2SiTrnt.js";
+import { o as resolveConversationWorkQueueTopic, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-AI0_QAgc.js";
 import { a as pluginRuntimeRegistrationsFromPluginSet, r as pluginCatalogConfigFromPluginSet } from "./plugins-egKWjgue.js";
-import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-D3PLY59C.js";
+import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-iuDAqfZg.js";
 import { n as loadPluginSetFromModule, r as resolvePluginModule } from "./plugin-module-BKGOXca2.js";
 import path from "node:path";
 import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";

package/dist/{oauth-authorization-BS4vPJmu.js → oauth-authorization-Cq1GaLIP.js}

@@ -1,4 +1,4 @@
-import { h as extractAssistantText } from "./checkpoint-6fkAdB3g.js";
+import { h as extractAssistantText } from "./checkpoint-oZYD3-Ar.js";
 //#region src/chat/runtime/turn.ts
 /** Classified Slack turn failure carrying the owning Sentry capture outward. */
 var ConversationTurnBoundaryError = class extends Error {

package/dist/{oauth-callback-server-DnlQsGBJ.js → oauth-callback-server-CnF03VYh.js}

@@ -1,5 +1,5 @@
-import { vt as createUserTokenStore } from "./agent-runner-Cad1RtWn.js";
-import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-DCB2SwnQ.js";
+import { Cn as createUserTokenStore } from "./agent-runner-BGDSjciH.js";
+import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-CUGbiiCM.js";
 import { createServer } from "node:http";
 //#region src/chat/local/oauth-callback-server.ts
 const LOCAL_OAUTH_TIMEOUT_MS = 6e5;

package/dist/pending-auth-CHUjr_6d.js

@@ -0,0 +1,59 @@
+import { i as abandonTurnRecord } from "./checkpoint-oZYD3-Ar.js";
+//#region src/chat/state/turn-id.ts
+/** Build a stable turn identifier from a message ID. */
+function buildDeterministicTurnId(messageId) {
+	return `turn_${messageId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+/** Build the stable visible assistant-message identity for one logical turn. */
+function buildDeterministicAssistantMessageId(turnId) {
+	return `${turnId}:assistant:1`;
+}
+//#endregion
+//#region src/chat/services/pending-auth.ts
+const AUTH_LINK_REUSE_WINDOW_MS = 6e5;
+const NON_REQUEST_SKIPPED_REASON_PREFIXES = ["directed_to_other_party:", "side_conversation:"];
+function isSkippedNonRequest(reason) {
+	return NON_REQUEST_SKIPPED_REASON_PREFIXES.some((prefix) => reason?.startsWith(prefix));
+}
+/** Decide whether the same agent-run session can reuse its fresh auth link. */
+function canReusePendingAuthLink(args) {
+	const { pendingAuth } = args;
+	if (!pendingAuth) return false;
+	return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.actorId === args.actorId && pendingAuth.scope === args.scope && pendingAuth.sessionId === args.sessionId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
+}
+function getConversationPendingAuth(args) {
+	const pendingAuth = args.conversation.processing.pendingAuth;
+	if (!pendingAuth) return;
+	if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.actorId !== args.actorId || pendingAuth.scope !== args.scope) return;
+	return pendingAuth;
+}
+function clearPendingAuth(conversation, sessionId) {
+	if (!conversation.processing.pendingAuth) return;
+	if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) return;
+	conversation.processing.pendingAuth = void 0;
+}
+/** Mark the prior blocked turn abandoned after a new auth attempt replaces it. */
+async function abandonReplacedPendingAuth(args) {
+	if (args.previousPendingAuth && args.previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) await abandonTurnRecord({
+		conversationId: args.conversationId,
+		turnId: args.previousPendingAuth.sessionId,
+		errorMessage: "Abandoned by a newer auth-blocked request in the same conversation."
+	});
+}
+/**
+* Decide whether an auth callback still belongs to the latest real human
+* request, ignoring bot-authored and passive bystander rows while treating
+* failed human turns and opt-outs as newer freshness blockers.
+*/
+function isPendingAuthLatestRequest(conversation, pendingAuth) {
+	for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+		const message = conversation.messages[index];
+		if (message?.role !== "user") continue;
+		if (message.author?.isBot) continue;
+		if (isSkippedNonRequest(message.meta?.skippedReason)) continue;
+		return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+	}
+	return false;
+}
+//#endregion
+export { isPendingAuthLatestRequest as a, getConversationPendingAuth as i, canReusePendingAuthLink as n, buildDeterministicAssistantMessageId as o, clearPendingAuth as r, buildDeterministicTurnId as s, abandonReplacedPendingAuth as t };

package/dist/{profile-CV97YuiL.js → profile-upzC-wN1.js}

@@ -1,7 +1,7 @@
-import { w as toOptionalTrimmed } from "./client-ihmkx60d.js";
-import { v as setSpanAttributes, y as setSpanStatus } from "./logging-CcTvYQ8A.js";
-import { a as getChatConfig } from "./config-DMg679BW.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-pv4grNNb.js";
+import { w as toOptionalTrimmed } from "./client-Pcxo3lGn.js";
+import { v as setSpanAttributes, y as setSpanStatus } from "./logging-BPBx6WF-.js";
+import { a as getChatConfig } from "./config-CYvEow1F.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-Cw9V2jpn.js";
 import { createHash } from "node:crypto";
 import { createMemoryState } from "@chat-adapter/state-memory";
 import { createRedisState } from "@chat-adapter/state-redis";

package/dist/{prompt-CL8zxsmm.js → prompt-CZIQcPHy.js}

@@ -1,4 +1,4 @@
-import { I as briefOutcomeStatusSchema, L as conversationBriefSchema, R as parseBriefInput } from "./conversation-Bygi39Xj.js";
+import { H as conversationBriefSchema, U as parseBriefInput, V as briefOutcomeStatusSchema } from "./conversation-BnhOMfEB.js";
 import { z } from "zod";
 //#region src/chat/briefs/generate.ts
 const MAX_INPUT_CHARS = 6e4;

package/dist/{registry-C8I4IejN.js → registry-DM5aMhjm.js}

@@ -1,5 +1,5 @@
-import { f as logInfo, p as logWarn, v as setSpanAttributes } from "./logging-CcTvYQ8A.js";
-import { i as credentialUserSubjectId } from "./context-Bplcgypl.js";
+import { f as logInfo, p as logWarn, v as setSpanAttributes } from "./logging-BPBx6WF-.js";
+import { i as credentialUserSubjectId } from "./context-0Et9iVSB.js";
 import { n as normalizePluginPackageNames, o as pluginRoots, t as discoverInstalledPluginPackageContent } from "./package-discovery-7a9YqLhE.js";
 import path from "node:path";
 import { z } from "zod";

package/dist/{resolve-DXVAzYa3.js → resolve-sF6Lg7Ay.js}

@@ -1,5 +1,5 @@
-import { v as setSpanAttributes, w as withSpan } from "./logging-CcTvYQ8A.js";
-import { N as SANDBOX_WORKSPACE_ROOT, k as sleep, r as isStale, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand } from "./profile-CV97YuiL.js";
+import { v as setSpanAttributes, w as withSpan } from "./logging-BPBx6WF-.js";
+import { N as SANDBOX_WORKSPACE_ROOT, k as sleep, r as isStale, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand } from "./profile-upzC-wN1.js";
 import { z } from "zod";
 import { FileSystem, Sandbox } from "@vercel/sandbox";
 //#region src/chat/sandbox/resources.ts

package/dist/{runner-Die1RJ_z.js → runner-Bu2wYpK8.js}

@@ -1,13 +1,13 @@
-import { C as withLogContext, b as setTags, d as logException } from "./logging-CcTvYQ8A.js";
-import { t as credentialContextForActor } from "./context-Bplcgypl.js";
-import { Kt as getConversationStore, Wt as getConversationEventStore } from "./agent-hooks-CRuRcOg9.js";
-import { M as messageCardText } from "./conversation-Bygi39Xj.js";
-import { A as commitAcceptedReply, B as recordAuthorizationCompleted, J as hydrateConversationMessages, P as loadProjection, Y as persistConversationMessages, at as markConversationMessage, et as buildConversationContext, lt as upsertConversationMessage, ot as normalizeConversationText, r as saveTurnCheckpoint, st as recordDeliveredAssistantMessage, u as persistWithRetry } from "./checkpoint-6fkAdB3g.js";
-import { _ as markTurnFailed, r as getAssistantReplyText, t as authorizationId, v as startActiveTurn } from "./oauth-authorization-BS4vPJmu.js";
-import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-BMl2aM2v.js";
-import { t as ConversationTurnLifecycleService } from "./turn-lifecycle-DPDHKi2U.js";
-import { n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CAR6gdAm.js";
-import { d as loadPendingMessageCards, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, t as finalizeFailedTurnReplyWithEvent } from "./turn-failure-response-CZyoUMkD.js";
+import { C as withLogContext, b as setTags, d as logException } from "./logging-BPBx6WF-.js";
+import { t as credentialContextForActor } from "./context-0Et9iVSB.js";
+import { Qt as getConversationStore, Xt as getConversationEventStore } from "./agent-hooks-bEwEJhlg.js";
+import { M as messageCardText } from "./conversation-BnhOMfEB.js";
+import { A as commitAcceptedReply, B as recordAuthorizationCompleted, J as hydrateConversationMessages, P as loadProjection, Y as persistConversationMessages, ct as markConversationMessage, ft as upsertConversationMessage, lt as normalizeConversationText, r as saveTurnCheckpoint, rt as buildConversationContext, u as persistWithRetry, ut as recordDeliveredAssistantMessage } from "./checkpoint-oZYD3-Ar.js";
+import { _ as markTurnFailed, r as getAssistantReplyText, t as authorizationId, v as startActiveTurn } from "./oauth-authorization-Cq1GaLIP.js";
+import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-S3QtH38c.js";
+import { t as ConversationTurnLifecycleService } from "./turn-lifecycle-CdiIejXH.js";
+import { n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-C_arVuaN.js";
+import { d as loadPendingMessageCards, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, t as finalizeFailedTurnReplyWithEvent } from "./turn-failure-response-DarwGYgC.js";
 import { randomUUID } from "node:crypto";
 import { createLocalSource, localDestinationSchema } from "@sentry/junior-plugin-api";
 //#region src/chat/local/runner.ts