@sentry/junior 0.258.0 → 0.259.0

package/dist/{pending-auth-D8J1uJUS.js → pending-auth-rG5U_QS1.js}

@@ -1,7 +1,6 @@
-import { v as isProviderRetryError } from "./client-DbyHuMFU.js";
-import { J as abandonTurnRecord, ln as estimateTextTokens } from "./tasks-CEXKTASS.js";
+import { y as isProviderRetryError } from "./client-BZdxgKyL.js";
+import { J as abandonTurnRecord, ln as estimateTextTokens } from "./tasks-DieKX3d4.js";
 import { r as isExperimentalFeatureEnabled } from "./experimental-BNK1l1jv.js";
-import { z } from "zod";
 // src/chat/state/turn-id.ts
 /** Build a stable turn identifier from a message ID. */
 function buildDeterministicTurnId(messageId) {
@@ -25,7 +24,7 @@ function buildDeterministicAssistantMessageId(turnId) {
 */
 function buildSubscribedReplyRouterPolicy(assistantName) {
 	return `You are judging whether the Slack assistant named ${assistantName} should reply to one latest message in a subscribed thread.
-Assess conversation floor ownership and whether the latest message continues work ${assistantName} was already doing. Derive should_reply and should_unsubscribe only after that assessment. Your primary objective is to re-engage when the thread is still talking to ${assistantName}, while staying quiet for human-to-human side conversation.
+Assess conversation floor ownership and whether the latest message continues work ${assistantName} was already doing. Choose the route only after that assessment. Your primary objective is to re-engage when the thread is still talking to ${assistantName}, while staying quiet for human-to-human side conversation.
 
 # Evidence Handling
 - Core-supplied routing signals and the assistant name are authoritative facts.
@@ -42,26 +41,38 @@ Assess conversation floor ownership and whether the latest message continues wor
 - If one or more humans spoke after ${assistantName}, the floor is human-to-human unless the latest message turns back to ${assistantName} or clearly continues work ${assistantName} was already handling.
 - Shared topic vocabulary alone does not give ${assistantName} the floor.
 - Explicit @mentions of another person usually mean the floor is not with ${assistantName}, unless the message also clearly asks ${assistantName} to act.
+- A message that starts by addressing another person by name is aimed at that person, not at ${assistantName}.
+- After one human addresses another human, later messages from either of them stay in that human exchange until one of them clearly turns back to ${assistantName}.
 
 # Reply Policy
-- should_reply=true when the latest message is explicitly aimed at ${assistantName}.
-- should_reply=true when the latest message is a natural follow-up to ${assistantName}'s prior question, answer, analysis, plan, or requested next step.
+- route=reply when the latest message is explicitly aimed at ${assistantName}.
+- route=reply when the latest message is a natural follow-up to ${assistantName}'s prior question, answer, analysis, plan, or requested next step.
 - Natural follow-ups include questions, corrections, added constraints, choices, requests to act, and topic-specific continuations, even without words like "you" or "${assistantName}".
-- Terse continuations such as "which one?", "why?", "what about auth?", "is that the right approach?", or "can you check on this?" can be should_reply=true when they continue ${assistantName}'s immediately preceding contribution.
-- Attachment-only messages can be should_reply=true when the thread context makes them a continuation of work ${assistantName} was doing.
-- should_reply=false for acknowledgments, reactions, status chatter, and team coordination that do not ask ${assistantName} to continue.
-- should_reply=false when the latest message is plainly human-to-human, even if it discusses the same project.
+- Terse continuations such as "which one?", "why?", "what about auth?", "is that the right approach?", or "can you check on this?" can be route=reply when they continue ${assistantName}'s immediately preceding contribution.
+- Attachment-only messages can be route=reply when the thread context makes them a continuation of work ${assistantName} was doing.
+- route=stay_quiet for acknowledgments, reactions, status chatter, and team coordination that do not ask ${assistantName} to continue.
+- route=stay_quiet when the latest message is plainly human-to-human, even if it discusses the same project.
 
 # Unsubscribe Policy
-- should_unsubscribe=true when the latest message clearly tells ${assistantName} to stop or leave the thread.
-- If should_unsubscribe=true, should_reply must be false.
+- route=unsubscribe when the latest message clearly tells ${assistantName} to stop or leave the thread.
 - Ordinary disagreement, correction, or "not yet" is not an unsubscribe.
 
 # Decision Policy
-- Prefer should_reply=true for clear continuations of ${assistantName}'s work.
-- Prefer should_reply=false for clear side conversation.
-- Use low confidence only for genuinely ambiguous floor ownership. Do not lower confidence merely because the assistant was addressed implicitly.
-- Keep the reason to one concise sentence under 160 characters grounded in floor ownership or continuity.`;
+- Prefer route=reply for clear continuations of ${assistantName}'s work.
+- Prefer route=stay_quiet for clear side conversation.
+- Spread probability across routes only for genuinely ambiguous floor ownership. Do not lower the reply probability merely because the assistant was addressed implicitly.`;
+}
+/** Build the decision question for one passive subscribed-thread message. */
+function buildSubscribedReplyRouterQuestions(assistantName) {
+	return { route: {
+		type: "choice",
+		instructions: buildSubscribedReplyRouterPolicy(assistantName),
+		criteria: {
+			reply: `The latest message is aimed at ${assistantName}. It addresses ${assistantName}, or it continues ${assistantName}'s latest answer, question, or plan and no human-to-human exchange started after it.`,
+			stay_quiet: `The latest message is aimed at another person or at the room. It addresses someone else by name or @mention, continues a human-to-human exchange, only shares topic words with earlier ${assistantName} messages, or is an acknowledgment or status chatter.`,
+			unsubscribe: `The latest message clearly tells ${assistantName} to stop or leave the thread.`
+		}
+	} };
 }
 // src/chat/services/subscribed-decision.ts
 /** Why the subscribed-thread router chose to reply or stay silent. */
@@ -77,14 +88,7 @@ const SubscribedReplyReason = {
 	ClassifierError: "classifier_error",
 	PassiveDisabled: "passive_disabled"
 };
-const replyDecisionSchema = z.object({
-	should_reply: z.boolean().describe("Whether Junior should respond to this thread message."),
-	should_unsubscribe: z.boolean().describe("Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."),
-	confidence: z.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-	reason: z.string().describe("Short reason for the decision; use an empty string if none.")
-}).strict();
 const ROUTER_CONFIDENCE_THRESHOLD = .7;
-const ROUTER_CLASSIFIER_MAX_TOKENS = 400;
 const MAX_MESSAGE_TRANSCRIPT_TOKENS = 1e4;
 const MAX_MESSAGE_ENTRY_TOKENS = 2e3;
 const RECENT_ASSISTANT_ENTRY_LIMIT = 40;
@@ -294,7 +298,7 @@ function getSubscribedReplyPreflightDecision(args) {
 		reasonDetail: leadingOtherPartyAddress
 	};
 }
-/** Decide whether to reply to a message in a subscribed thread using an LLM classifier. */
+/** Decide whether to reply to a message in a subscribed thread using a decision model. */
 async function decideSubscribedThreadReply(args) {
 	const text = args.input.text.trim();
 	const rawText = args.input.rawText.trim();
@@ -337,13 +341,10 @@ async function decideSubscribedThreadReply(args) {
 		reasonDetail: evidence.currentMessageIsTerseClarification ? "immediate terse clarification" : "immediate directed follow-up cue"
 	};
 	try {
-		const result = await args.completeObject({
+		const result = await args.completeDecision({
 			modelId: args.modelId,
-			schema: replyDecisionSchema,
-			maxTokens: ROUTER_CLASSIFIER_MAX_TOKENS,
-			temperature: 0,
-			system: buildSubscribedReplyRouterPolicy(args.botUserName),
-			prompt: buildRouterPrompt(rawText, evidence),
+			state: buildRouterPrompt(rawText, evidence),
+			questions: buildSubscribedReplyRouterQuestions(args.botUserName),
 			metadata: {
 				modelId: args.modelId,
 				threadId: args.input.context.threadId ?? "",
@@ -353,40 +354,9 @@ async function decideSubscribedThreadReply(args) {
 			},
 			promptName: "junior.passive_reply_route"
 		});
-		const parsed = replyDecisionSchema.parse(result.object);
-		const reason = parsed.reason?.trim() || "classifier";
-		if (parsed.should_unsubscribe) {
-			if (parsed.confidence < ROUTER_CONFIDENCE_THRESHOLD) return {
-				...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-				shouldReply: false,
-				reason: SubscribedReplyReason.LowConfidence,
-				reasonDetail: `${parsed.confidence.toFixed(2)}: ${reason}`
-			};
-			return {
-				...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-				shouldReply: false,
-				shouldUnsubscribe: true,
-				reason: SubscribedReplyReason.ThreadOptOut,
-				reasonDetail: reason
-			};
-		}
-		if (!parsed.should_reply) return {
-			...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-			shouldReply: false,
-			reason: SubscribedReplyReason.SideConversation,
-			reasonDetail: reason
-		};
-		if (parsed.confidence < ROUTER_CONFIDENCE_THRESHOLD) return {
-			...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-			shouldReply: false,
-			reason: SubscribedReplyReason.LowConfidence,
-			reasonDetail: `${parsed.confidence.toFixed(2)}: ${reason}`
-		};
 		return {
 			...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-			shouldReply: true,
-			reason: SubscribedReplyReason.Classifier,
-			reasonDetail: reason
+			...routeDecisionResult(result.answers.route)
 		};
 	} catch (error) {
 		if (isProviderRetryError(error)) throw error;
@@ -397,6 +367,36 @@ async function decideSubscribedThreadReply(args) {
 		};
 	}
 }
+function isSubscribedReplyRoute(value) {
+	return value === "reply" || value === "stay_quiet" || value === "unsubscribe";
+}
+function routeDecisionResult(answer) {
+	const route = answer.choice;
+	if (!isSubscribedReplyRoute(route)) throw new Error(`Decision model returned unknown route: ${route}`);
+	const probability = answer.probabilities?.[route] ?? 1;
+	const detail = `${route} p=${probability.toFixed(2)}`;
+	if (route === "stay_quiet") return {
+		shouldReply: false,
+		reason: SubscribedReplyReason.SideConversation,
+		reasonDetail: detail
+	};
+	if (probability < ROUTER_CONFIDENCE_THRESHOLD) return {
+		shouldReply: false,
+		reason: SubscribedReplyReason.LowConfidence,
+		reasonDetail: detail
+	};
+	if (route === "unsubscribe") return {
+		shouldReply: false,
+		shouldUnsubscribe: true,
+		reason: SubscribedReplyReason.ThreadOptOut,
+		reasonDetail: detail
+	};
+	return {
+		shouldReply: true,
+		reason: SubscribedReplyReason.Classifier,
+		reasonDetail: detail
+	};
+}
 // src/chat/services/pending-auth.ts
 const AUTH_LINK_REUSE_WINDOW_MS = 6e5;
 /** Decide whether the same agent-run session can reuse its fresh auth link. */

package/dist/{plugins-B11Mfkmv.d.ts → plugins-B_0Cr0MO.d.ts}

@@ -1,4 +1,4 @@
-import { PluginMcpConfig, PluginRegistration, PluginRuntimePostinstallCommand } from "@sentry/junior-plugin-api";
+import { PluginMcpConfig, PluginRegistration, PluginRuntimePostinstallCommand, PluginServiceAccountConfig } from "@sentry/junior-plugin-api";
 interface PluginOAuthConfig {
   clientIdEnv: string;
   clientSecretEnv: string;
@@ -68,6 +68,10 @@ interface PluginManifestConfig {
     wrappedTools?: string[] | null;
   } | null;
   oauth?: PluginOAuthConfigPatch | null;
+  accounts?: {
+    userOAuth?: boolean | null;
+    serviceAccount?: PluginServiceAccountConfig | null;
+  } | null;
   target?: {
     type?: string;
     configKey?: string;

package/dist/{profile-DpYjfKke.js → profile-qBM6B_-V.js}

@@ -1,11 +1,7 @@
-import { S as toOptionalTrimmed } from "./client-DbyHuMFU.js";
-import { b as setSpanStatus, y as setSpanAttributes } from "./logging-DsHONhVm.js";
-import { i as getChatConfig } from "./config-_WO_AjCB.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-BN4DVxco.js";
+import { C as toOptionalTrimmed } from "./client-BZdxgKyL.js";
+import { b as setSpanStatus, y as setSpanAttributes } from "./logging-BStXN56b.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-B8SuFPGb.js";
 import { createHash } from "node:crypto";
-import { createMemoryState } from "@chat-adapter/state-memory";
-import { createRedisState } from "@chat-adapter/state-redis";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {
 	const candidate = (input ?? "").trim();
@@ -48,271 +44,6 @@ function sleep(ms, signal) {
 		signal.addEventListener("abort", onAbort, { once: true });
 	});
 }
-// src/chat/state/locks.ts
-const ACTIVE_LOCK_TTL_MS = 9e4;
-const MUTATION_LOCK_TTL_MS = 1e4;
-/**
-* Acquire a lock for long-running work that the queued state adapter should
-* keep alive while the owning invocation is still making progress.
-*/
-async function acquireActiveLock(state, threadId) {
-	return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
-}
-/**
-* Run work under one lock, optionally waiting for the current owner.
-* `keepAlive` is for multi-store mutations that must retain ownership until all
-* side effects finish; callers should still fence each blind write.
-*/
-async function withLock(state, key, run, options = {}) {
-	const startedAtMs = Date.now();
-	let lock;
-	while (true) {
-		lock = await state.acquireLock(key, options.ttlMs ?? 9e4);
-		if (lock) break;
-		if (Date.now() - startedAtMs >= (options.waitMs ?? 0)) return { acquired: false };
-		await setTimeout$1(options.retryMs ?? 25, void 0, { ref: false });
-	}
-	const ttlMs = options.ttlMs ?? 9e4;
-	const heartbeat = options.keepAlive ? setInterval(() => {
-		state.extendLock(lock, ttlMs);
-	}, Math.max(1, Math.floor(ttlMs / 3))) : void 0;
-	heartbeat?.unref();
-	try {
-		return {
-			acquired: true,
-			value: await run(lock)
-		};
-	} finally {
-		if (heartbeat) clearInterval(heartbeat);
-		await state.releaseLock(lock);
-	}
-}
-/**
-* Prove lock ownership immediately before a blind write.
-*
-* Whole-record mutations must stop if their lock expired rather than overwrite
-* state committed by a newer owner.
-*/
-async function fenceLock(state, lock, ttlMs = MUTATION_LOCK_TTL_MS) {
-	if (!await state.extendLock(lock, ttlMs)) throw new Error(`Lock ownership was lost before write for ${lock.threadId}`);
-}
-// src/chat/state/adapter.ts
-const ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
-let stateAdapter;
-let redisStateAdapter;
-/** Lazily connect state operations, including queued-adapter lock heartbeats. */
-function createConnectingStateAdapter(base) {
-	const connected = async (operation) => {
-		await base.connect();
-		return await operation();
-	};
-	return {
-		appendToList: (key, value, options) => connected(() => base.appendToList(key, value, options)),
-		connect: () => base.connect(),
-		disconnect: () => base.disconnect(),
-		subscribe: (threadId) => connected(() => base.subscribe(threadId)),
-		unsubscribe: (threadId) => connected(() => base.unsubscribe(threadId)),
-		isSubscribed: (threadId) => connected(() => base.isSubscribed(threadId)),
-		acquireLock: (threadId, ttlMs) => connected(() => base.acquireLock(threadId, ttlMs)),
-		releaseLock: (lock) => connected(() => base.releaseLock(lock)),
-		extendLock: (lock, ttlMs) => connected(() => base.extendLock(lock, ttlMs)),
-		forceReleaseLock: (threadId) => connected(() => base.forceReleaseLock(threadId)),
-		enqueue: (threadId, entry, maxSize) => connected(() => base.enqueue(threadId, entry, maxSize)),
-		dequeue: (threadId) => connected(() => base.dequeue(threadId)),
-		queueDepth: (threadId) => connected(() => base.queueDepth(threadId)),
-		get: (key) => connected(() => base.get(key)),
-		getList: (key) => connected(() => base.getList(key)),
-		set: (key, value, ttlMs) => connected(() => base.set(key, value, ttlMs)),
-		setIfNotExists: (key, value, ttlMs) => connected(() => base.setIfNotExists(key, value, ttlMs)),
-		delete: (key) => connected(() => base.delete(key))
-	};
-}
-function createPrefixedStateAdapter(base, prefix) {
-	const prefixed = (value) => `${prefix}:${value}`;
-	const unprefixed = (value) => value.startsWith(`${prefix}:`) ? value.slice(prefix.length + 1) : value;
-	const prefixLock = (lock) => ({
-		...lock,
-		threadId: prefixed(lock.threadId)
-	});
-	const unprefixLock = (lock) => ({
-		...lock,
-		threadId: unprefixed(lock.threadId)
-	});
-	return {
-		appendToList: (key, value, options) => base.appendToList(prefixed(key), value, options),
-		connect: () => base.connect(),
-		disconnect: () => base.disconnect(),
-		subscribe: (threadId) => base.subscribe(prefixed(threadId)),
-		unsubscribe: (threadId) => base.unsubscribe(prefixed(threadId)),
-		isSubscribed: (threadId) => base.isSubscribed(prefixed(threadId)),
-		acquireLock: async (threadId, ttlMs) => {
-			const lock = await base.acquireLock(prefixed(threadId), ttlMs);
-			return lock ? unprefixLock(lock) : null;
-		},
-		releaseLock: (lock) => base.releaseLock(prefixLock(lock)),
-		extendLock: async (lock, ttlMs) => {
-			const prefixedLock = prefixLock(lock);
-			const extended = await base.extendLock(prefixedLock, ttlMs);
-			if (extended) lock.expiresAt = prefixedLock.expiresAt;
-			return extended;
-		},
-		forceReleaseLock: (threadId) => base.forceReleaseLock(prefixed(threadId)),
-		enqueue: (threadId, entry, maxSize) => base.enqueue(prefixed(threadId), entry, maxSize),
-		dequeue: (threadId) => base.dequeue(prefixed(threadId)),
-		queueDepth: (threadId) => base.queueDepth(prefixed(threadId)),
-		get: (key) => base.get(prefixed(key)),
-		getList: (key) => base.getList(prefixed(key)),
-		set: (key, value, ttlMs) => base.set(prefixed(key), value, ttlMs),
-		setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(prefixed(key), value, ttlMs),
-		delete: (key) => base.delete(prefixed(key))
-	};
-}
-function createQueuedStateAdapter(base, options) {
-	const heartbeats = /* @__PURE__ */ new Map();
-	const shouldHeartbeatLock = (ttlMs) => ttlMs === ACTIVE_LOCK_TTL_MS;
-	const heartbeatKey = (lock) => `${lock.threadId}:${lock.token}`;
-	const stopHeartbeatByKey = (key) => {
-		const heartbeat = heartbeats.get(key);
-		if (!heartbeat) return;
-		clearInterval(heartbeat.timer);
-		heartbeats.delete(key);
-	};
-	const stopHeartbeat = (lock) => {
-		stopHeartbeatByKey(heartbeatKey(lock));
-	};
-	const stopHeartbeatsForThread = (threadId) => {
-		for (const [key, heartbeat] of heartbeats) if (heartbeat.lock.threadId === threadId) stopHeartbeatByKey(key);
-	};
-	const stopAllHeartbeats = () => {
-		for (const key of heartbeats.keys()) stopHeartbeatByKey(key);
-	};
-	const runHeartbeat = async (key) => {
-		const heartbeat = heartbeats.get(key);
-		if (!heartbeat || heartbeat.inFlight) return;
-		heartbeat.inFlight = true;
-		try {
-			if (Date.now() - heartbeat.startedAtMs >= options.activeLockMaxAgeMs) {
-				stopHeartbeatByKey(key);
-				return;
-			}
-			if (!await base.extendLock(heartbeat.lock, heartbeat.ttlMs)) {
-				stopHeartbeatByKey(key);
-				return;
-			}
-			heartbeat.lock.expiresAt = Date.now() + heartbeat.ttlMs;
-		} catch {} finally {
-			const current = heartbeats.get(key);
-			if (current === heartbeat) current.inFlight = false;
-		}
-	};
-	const startOrUpdateHeartbeat = (lock, ttlMs) => {
-		const key = heartbeatKey(lock);
-		const existing = heartbeats.get(key);
-		if (existing) {
-			existing.ttlMs = ttlMs;
-			return;
-		}
-		const timer = setInterval(() => {
-			runHeartbeat(key);
-		}, ACTIVE_LOCK_HEARTBEAT_MS);
-		timer.unref?.();
-		heartbeats.set(key, {
-			inFlight: false,
-			lock,
-			startedAtMs: Date.now(),
-			timer,
-			ttlMs
-		});
-	};
-	const acquireLock = async (threadId, ttlMs) => {
-		const lock = await base.acquireLock(threadId, ttlMs);
-		if (lock && shouldHeartbeatLock(ttlMs)) startOrUpdateHeartbeat(lock, ttlMs);
-		return lock;
-	};
-	return {
-		appendToList: (key, value, options) => base.appendToList(key, value, options),
-		connect: () => base.connect(),
-		disconnect: async () => {
-			stopAllHeartbeats();
-			await base.disconnect();
-		},
-		subscribe: (threadId) => base.subscribe(threadId),
-		unsubscribe: (threadId) => base.unsubscribe(threadId),
-		isSubscribed: (threadId) => base.isSubscribed(threadId),
-		acquireLock,
-		releaseLock: async (lock) => {
-			stopHeartbeat(lock);
-			await base.releaseLock(lock);
-		},
-		extendLock: async (lock, ttlMs) => {
-			const extended = await base.extendLock(lock, ttlMs);
-			if (extended) {
-				lock.expiresAt = Date.now() + ttlMs;
-				if (shouldHeartbeatLock(ttlMs)) startOrUpdateHeartbeat(lock, ttlMs);
-				else stopHeartbeat(lock);
-			} else stopHeartbeat(lock);
-			return extended;
-		},
-		forceReleaseLock: async (threadId) => {
-			stopHeartbeatsForThread(threadId);
-			await base.forceReleaseLock(threadId);
-		},
-		enqueue: (threadId, entry, maxSize) => base.enqueue(threadId, entry, maxSize),
-		dequeue: (threadId) => base.dequeue(threadId),
-		queueDepth: (threadId) => base.queueDepth(threadId),
-		get: (key) => base.get(key),
-		getList: (key) => base.getList(key),
-		set: (key, value, ttlMs) => base.set(key, value, ttlMs),
-		setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
-		delete: (key) => base.delete(key)
-	};
-}
-function withOptionalPrefix(base, prefix) {
-	return prefix ? createPrefixedStateAdapter(base, prefix) : base;
-}
-function createStateAdapter() {
-	const config = getChatConfig();
-	const activeLockMaxAgeMs = config.bot.turnTimeoutMs + ACTIVE_LOCK_TTL_MS;
-	if (config.state.adapter === "memory") {
-		redisStateAdapter = void 0;
-		return createQueuedStateAdapter(createConnectingStateAdapter(withOptionalPrefix(createMemoryState(), config.state.keyPrefix)), { activeLockMaxAgeMs });
-	}
-	if (!config.state.redisUrl) throw new Error("REDIS_URL is required for durable Slack thread state");
-	const redisState = createRedisState({ url: config.state.redisUrl });
-	redisStateAdapter = redisState;
-	return createQueuedStateAdapter(createConnectingStateAdapter(withOptionalPrefix(redisState, config.state.keyPrefix)), { activeLockMaxAgeMs });
-}
-function getOptionalRedisStateAdapter() {
-	getStateAdapter();
-	return redisStateAdapter;
-}
-async function getConnectedStateContext() {
-	const adapter = getStateAdapter();
-	await adapter.connect();
-	return {
-		redisStateAdapter: getOptionalRedisStateAdapter(),
-		stateAdapter: adapter
-	};
-}
-/** Return the Redis adapter only when the caller is using the default state adapter. */
-async function getDefaultRedisStateAdapterFor(adapter) {
-	if (adapter !== stateAdapter) return;
-	const context = await getConnectedStateContext();
-	return context.stateAdapter === adapter ? context.redisStateAdapter : void 0;
-}
-function getStateAdapter() {
-	if (!stateAdapter) stateAdapter = createStateAdapter();
-	return stateAdapter;
-}
-async function disconnectStateAdapter() {
-	if (!stateAdapter) return;
-	try {
-		await stateAdapter.disconnect();
-	} finally {
-		stateAdapter = void 0;
-		redisStateAdapter = void 0;
-	}
-}
 // src/chat/sandbox/noninteractive-command.ts
 const NON_INTERACTIVE_ENV = {
 	CI: "1",
@@ -841,4 +572,4 @@ function isStale(profile, createdAtMs) {
 	const maxAgeMs = floatingMaxAgeMs();
 	return maxAgeMs === 0 || Date.now() - createdAtMs > maxAgeMs;
 }
-export { SANDBOX_DATA_ROOT as A, getDefaultRedisStateAdapterFor as C, fenceLock as D, acquireActiveLock as E, sandboxSkillFile as F, sandboxSkillPathResolution as I, SANDBOX_SKILLS_ROOT as M, SANDBOX_WORKSPACE_ROOT as N, withLock as O, sandboxSkillDir as P, disconnectStateAdapter as S, MUTATION_LOCK_TTL_MS as T, workspaceSnapshotNotReadyUserMessage as _, isAbortError as a, buildNonInteractiveShellScript as b, isSandboxCommandStreamInterruptedError as c, isSnapshottingError as d, throwSandboxOperationError as f, isWorkspaceSnapshotNotReadyError as g, getWorkspaceSnapshotNotReadyError as h, ensureDockerDaemon as i, SANDBOX_REPOS_ROOT as j, sleep as k, isSandboxMissingError as l, WorkspaceSnapshotNotReadyError as m, hash as n, isAlreadyExistsError as o, wrapSandboxSetupError as p, isStale as r, isSandboxApiTransientError as s, create as t, isSandboxUnavailableError as u, getVercelSandboxCredentials as v, getStateAdapter as w, runNonInteractiveCommand as x, buildCommandScript as y };
+export { SANDBOX_DATA_ROOT as C, sandboxSkillDir as D, SANDBOX_WORKSPACE_ROOT as E, sandboxSkillFile as O, sleep as S, SANDBOX_SKILLS_ROOT as T, workspaceSnapshotNotReadyUserMessage as _, isAbortError as a, buildNonInteractiveShellScript as b, isSandboxCommandStreamInterruptedError as c, isSnapshottingError as d, throwSandboxOperationError as f, isWorkspaceSnapshotNotReadyError as g, getWorkspaceSnapshotNotReadyError as h, ensureDockerDaemon as i, sandboxSkillPathResolution as k, isSandboxMissingError as l, WorkspaceSnapshotNotReadyError as m, hash as n, isAlreadyExistsError as o, wrapSandboxSetupError as p, isStale as r, isSandboxApiTransientError as s, create as t, isSandboxUnavailableError as u, getVercelSandboxCredentials as v, SANDBOX_REPOS_ROOT as w, runNonInteractiveCommand as x, buildCommandScript as y };

package/dist/{registry-Du566MtJ.js → registry-B_M_x_iS.js}

@@ -1,4 +1,4 @@
-import { m as logWarn, p as logInfo, y as setSpanAttributes } from "./logging-DsHONhVm.js";
+import { m as logWarn, p as logInfo, y as setSpanAttributes } from "./logging-BStXN56b.js";
 import { a as isUserActor, o as parseActorUserId } from "./actor-tlxzqaRe.js";
 import { n as normalizePluginPackageNames, o as pluginRoots, t as discoverInstalledPluginPackageContent } from "./package-discovery-DJBompdd.js";
 import path from "node:path";
@@ -49,6 +49,13 @@ function mcpOauthClientSource(oauthClient) {
 	setDefined$1(result, "authorize-params", oauthClient.authorizeParams);
 	return result;
 }
+/** Convert a camelCase `accounts` block to its plugin.yaml source keys. */
+function accountsSource(accounts) {
+	const result = {};
+	setDefined$1(result, "user-oauth", accounts.userOAuth);
+	setDefined$1(result, "service-account", accounts.serviceAccount);
+	return result;
+}
 function inlineMcpSource(mcp) {
 	if (mcp === void 0 || !isRecord(mcp)) return mcp;
 	const result = {};
@@ -99,6 +106,7 @@ function inlineManifestSource(manifest) {
 	setDefined$1(result, "runtime-postinstall", manifest.runtimePostinstall);
 	setDefined$1(result, "mcp", inlineMcpSource(manifest.mcp));
 	setDefined$1(result, "oauth", inlineOauthSource(manifest.oauth));
+	setDefined$1(result, "accounts", manifest.accounts && accountsSource(manifest.accounts));
 	setDefined$1(result, "target", inlineTargetSource(manifest.name, manifest.target));
 	return result;
 }
@@ -249,6 +257,10 @@ const mcpOauthClientSourceSchema = z.object({
 	scope: nonEmptyTrimmedString.optional(),
 	"authorize-params": stringMapSchema.optional()
 }).passthrough();
+const accountsSourceSchema = z.object({
+	"user-oauth": z.boolean().optional(),
+	"service-account": z.object({ tools: nonEmptyStringArraySchema("tools") }).strict().optional()
+}).strict();
 const mcpSourceSchema = z.object({
 	transport: nonEmptyTrimmedString.refine((value) => value === "http", { error: "must be \"http\"" }).optional(),
 	url: httpsUrlString,
@@ -277,6 +289,7 @@ const manifestSourceSchema = z.object({
 	"env-vars": z.record(z.string(), z.unknown(), { error: "must be an object" }).optional(),
 	mcp: z.record(z.string(), z.unknown(), { error: "must be an object" }).optional(),
 	oauth: z.record(z.string(), z.unknown(), { error: "must be an object" }).optional(),
+	accounts: z.record(z.string(), z.unknown(), { error: "must be an object" }).optional(),
 	target: z.record(z.string(), z.unknown(), { error: "must be an object" }).optional()
 }).passthrough();
 function setDefined(target, key, value) {
@@ -335,6 +348,7 @@ function manifestConfigPatch(config) {
 			result.oauth = oauth;
 		}
 	}
+	if (config.accounts !== void 0) result.accounts = config.accounts && accountsSource(config.accounts);
 	if (config.target !== void 0) {
 		if (!config.target) result.target = null;
 		else {
@@ -620,6 +634,28 @@ function normalizeMcp(data, envVars, name) {
 		...result.data["wrapped-tools"] ? { wrappedTools: result.data["wrapped-tools"] } : void 0
 	};
 }
+/**
+* Validate which accounts the plugin may use against the surfaces that
+* support them. Today only MCP OAuth stores a service account.
+*/
+function normalizeAccounts(data, mcp, name) {
+	const result = accountsSourceSchema.safeParse(data);
+	if (!result.success) throw new Error(issueMessage(result.error, `Plugin ${name} accounts`));
+	const userOAuth = result.data["user-oauth"];
+	const serviceAccount = result.data["service-account"];
+	if (userOAuth === false && !serviceAccount) throw new Error(`Plugin ${name} accounts.user-oauth false requires accounts.service-account`);
+	if (!serviceAccount) return;
+	if (!mcp || mcp.auth || mcp.oauthClient) throw new Error(`Plugin ${name} accounts.service-account requires mcp without auth or oauth-client`);
+	if (mcp.allowedTools) {
+		const loadedTools = /* @__PURE__ */ new Set([...mcp.allowedTools, ...mcp.wrappedTools ?? []]);
+		const unknownTools = serviceAccount.tools.filter((tool) => !loadedTools.has(tool));
+		if (unknownTools.length > 0) throw new Error(`Plugin ${name} accounts.service-account.tools must be listed in mcp.allowed-tools or mcp.wrapped-tools: ${unknownTools.join(", ")}`);
+	}
+	return {
+		...userOAuth === false ? { userOAuth } : void 0,
+		serviceAccount: { tools: serviceAccount.tools }
+	};
+}
 function parseManifestSource(parsedSource, dir, config, options) {
 	const source = applyManifestConfig(parsedSource, config);
 	const sourceResult = manifestSourceSchema.safeParse(source);
@@ -638,6 +674,7 @@ function parseManifestSource(parsedSource, dir, config, options) {
 		if (path === "env-vars") throw new Error(`Plugin ${String(parsedSource.name ?? "unknown")} env-vars must be an object`);
 		if (path === "mcp") throw new Error(`Plugin ${String(parsedSource.name ?? "unknown")} mcp must be an object`);
 		if (path === "oauth") throw new Error(`Plugin ${String(parsedSource.name ?? "unknown")} oauth must be an object`);
+		if (path === "accounts") throw new Error(`Plugin ${String(parsedSource.name ?? "unknown")} accounts must be an object`);
 		if (path === "target") throw new Error(`Plugin ${String(parsedSource.name ?? "unknown")} target must be an object`);
 		throw new Error(issue?.message ?? `Invalid plugin manifest in ${dir}`);
 	}
@@ -656,6 +693,7 @@ function parseManifestSource(parsedSource, dir, config, options) {
 	const runtimeDependencies = data["runtime-dependencies"] ? normalizeRuntimeDependencies(data["runtime-dependencies"], data.name) : void 0;
 	const runtimePostinstall = data["runtime-postinstall"] ? normalizeRuntimePostinstall(data["runtime-postinstall"], data.name) : void 0;
 	const mcp = data.mcp ? normalizeMcp(data.mcp, envVars, data.name) : void 0;
+	const accounts = data.accounts ? normalizeAccounts(data.accounts, mcp, data.name) : void 0;
 	const manifest = {
 		name: data.name,
 		displayName: data["display-name"],
@@ -668,7 +706,8 @@ function parseManifestSource(parsedSource, dir, config, options) {
 		...credentials ? { credentials } : void 0,
 		...runtimeDependencies ? { runtimeDependencies } : void 0,
 		...runtimePostinstall ? { runtimePostinstall } : void 0,
-		...mcp ? { mcp } : void 0
+		...mcp ? { mcp } : void 0,
+		...accounts ? { accounts } : void 0
 	};
 	if (data.oauth) {
 		if (!credentials && options?.allowHookManagedEgress !== true) throw new Error(`Plugin ${data.name} oauth requires credentials`);

package/dist/{resolve-ClCIgh8E.js → resolve-BzpuLh8c.js}

@@ -1,5 +1,6 @@
-import { T as withSpan, y as setSpanAttributes } from "./logging-DsHONhVm.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-DpYjfKke.js";
+import { T as withSpan, y as setSpanAttributes } from "./logging-BStXN56b.js";
+import { E as SANDBOX_WORKSPACE_ROOT, S as sleep, r as isStale, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, x as runNonInteractiveCommand } from "./profile-qBM6B_-V.js";
+import { r as getStateAdapter } from "./adapter-Bn0gFVSF.js";
 import { z } from "zod";
 import { FileSystem, Sandbox } from "@vercel/sandbox";
 // src/chat/sandbox/resources.ts

package/dist/{result-BBbKA61B.js → result-DEZH_AnZ.js}

@@ -1,12 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { $ as getAgentInvocation, X as createAgentInvocationFromLatest, ct as isTerminalAgentInvocation, et as getAgentInvocationIdForEvents, ft as markAgentInvocationParentMailboxAppended, it as getAgentInvocationResultMessageId, nt as getAgentInvocationIdForResult, st as getLatestAgentInvocationForConversation, tt as getAgentInvocationIdForMessage } from "./agent-runner-DGsFQw72.js";
+import { $ as getAgentInvocation, X as createAgentInvocationFromLatest, ct as isTerminalAgentInvocation, et as getAgentInvocationIdForEvents, ft as markAgentInvocationParentMailboxAppended, it as getAgentInvocationResultMessageId, nt as getAgentInvocationIdForResult, st as getLatestAgentInvocationForConversation, tt as getAgentInvocationIdForMessage } from "./agent-runner-CPSd7rKm.js";
 import { t as createActor } from "./actor-tlxzqaRe.js";
-import { f as credentialContextForActor } from "./registry-Du566MtJ.js";
-import { Q as listTurnSummaries, Z as getTurnRecord } from "./tasks-CEXKTASS.js";
-import { a as EVENT_WAIT_MS, c as timerWatchCredentialSubject, s as isEventMailboxMetadata } from "./session-stop-CIoFiwwe.js";
+import { f as credentialContextForActor } from "./registry-B_M_x_iS.js";
+import { Q as listTurnSummaries, Z as getTurnRecord } from "./tasks-DieKX3d4.js";
+import { a as EVENT_WAIT_MS, c as timerWatchCredentialSubject, s as isEventMailboxMetadata } from "./session-stop-CV65ZlU3.js";
 import { a as EVENT_SYSTEM_ACTOR, i as EVENT_MESSAGE_AUTHOR, o as isEventConversationMessage } from "./prompt-xgpyMtg7.js";
-import { r as appendAndEnqueueInboundMessage } from "./store-DJLwq4x8.js";
-import { r as enqueueAgentInvocation } from "./work-DRcsJ3hV.js";
+import { r as appendAndEnqueueInboundMessage } from "./store-B1GES4gC.js";
+import { r as enqueueAgentInvocation } from "./work-D3QKiV0O.js";
 import { z } from "zod";
 import { createEventSource, createLocalSource, createWebSource } from "@sentry/junior-plugin-api";
 // src/chat/task-execution/mailbox-input.ts