@sentry/junior 0.257.0 → 0.259.0

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

@@ -1,8 +1,7 @@
-import { v as isProviderRetryError } from "./client-D8HnkOQX.js";
-import { J as abandonTurnRecord, ln as estimateTextTokens } from "./tasks-D_WIJtvO.js";
-import { r as isExperimentalFeatureEnabled } from "./experimental-CQIvMUO7.js";
-import { z } from "zod";
-//#region src/chat/state/turn-id.ts
+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";
+// 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, "_")}`;
@@ -11,8 +10,7 @@ function buildDeterministicTurnId(messageId) {
 function buildDeterministicAssistantMessageId(turnId) {
 	return `${turnId}:assistant:1`;
 }
-//#endregion
-//#region src/chat/services/subscribed-reply-router-policy.ts
+// src/chat/services/subscribed-reply-router-policy.ts
 /**
 * Passive subscribed-thread reply router policy.
 *
@@ -26,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.
@@ -43,37 +41,54 @@ 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.`;
 }
-//#endregion
-//#region src/chat/services/subscribed-decision.ts
-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();
+/** 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. */
+const SubscribedReplyReason = {
+	ThreadOptOut: "thread_opt_out",
+	ExplicitMention: "explicit_mention",
+	DirectedFollowUp: "directed_follow_up",
+	DirectedToOtherParty: "directed_to_other_party",
+	EmptyMessage: "empty_message",
+	Classifier: "llm_classifier",
+	SideConversation: "side_conversation",
+	LowConfidence: "low_confidence",
+	ClassifierError: "classifier_error",
+	PassiveDisabled: "passive_disabled"
+};
 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;
@@ -131,13 +146,13 @@ function getThreadStopDecision(args) {
 	if (hasBangStop(rawText, text)) return {
 		shouldReply: false,
 		shouldUnsubscribe: true,
-		reason: "thread_opt_out",
+		reason: SubscribedReplyReason.ThreadOptOut,
 		reasonDetail: "!stop"
 	};
 	if (isBareStop(rawText, text)) return {
 		shouldReply: false,
 		shouldUnsubscribe: true,
-		reason: "thread_opt_out",
+		reason: SubscribedReplyReason.ThreadOptOut,
 		reasonDetail: "stop"
 	};
 }
@@ -167,7 +182,7 @@ function parseTranscriptMessages(conversationContext) {
 	const lines = conversationContext.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
 	for (const line of lines) {
 		const match = line.match(TRANSCRIPT_MESSAGE_LINE_RE);
-		if (!match) continue;
+		if (!match?.[1]) continue;
 		const role = match[1].toLowerCase();
 		if (role !== "assistant" && role !== "user") continue;
 		messages.push({
@@ -279,11 +294,11 @@ function getSubscribedReplyPreflightDecision(args) {
 	if (!leadingOtherPartyAddress) return;
 	return {
 		shouldReply: false,
-		reason: "directed_to_other_party",
+		reason: SubscribedReplyReason.DirectedToOtherParty,
 		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();
@@ -303,36 +318,33 @@ async function decideSubscribedThreadReply(args) {
 	if (preflightDecision) return preflightDecision;
 	if (!text && !args.input.hasAttachments) return {
 		shouldReply: false,
-		reason: "empty_message"
+		reason: SubscribedReplyReason.EmptyMessage
 	};
 	if (args.input.isExplicitMention) return {
 		shouldReply: true,
-		reason: "explicit_mention"
+		reason: SubscribedReplyReason.ExplicitMention
 	};
 	if (!isExperimentalFeatureEnabled("passive-routing")) return {
 		shouldReply: false,
-		reason: "passive_disabled",
+		reason: SubscribedReplyReason.PassiveDisabled,
 		reasonDetail: "passive-routing"
 	};
 	if (!args.input.hasAttachments && isAcknowledgmentOnly(text)) return {
 		shouldReply: false,
-		reason: "side_conversation",
+		reason: SubscribedReplyReason.SideConversation,
 		reasonDetail: "acknowledgment"
 	};
 	const evidence = buildRouterEvidence(args.input);
 	if (evidence.assistantWasLastSpeaker && evidence.humanMessagesSinceLastAssistant === 0 && !evidence.currentMessageHasAttachments && (evidence.currentMessageHasDirectedFollowUpCue || evidence.currentMessageIsTerseClarification)) return {
 		shouldReply: true,
-		reason: "directed_follow_up",
+		reason: SubscribedReplyReason.DirectedFollowUp,
 		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 ?? "",
@@ -342,52 +354,50 @@ 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: "low_confidence",
-				reasonDetail: `${parsed.confidence.toFixed(2)}: ${reason}`
-			};
-			return {
-				...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-				shouldReply: false,
-				shouldUnsubscribe: true,
-				reason: "thread_opt_out",
-				reasonDetail: reason
-			};
-		}
-		if (!parsed.should_reply) return {
-			...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-			shouldReply: false,
-			reason: "side_conversation",
-			reasonDetail: reason
-		};
-		if (parsed.confidence < ROUTER_CONFIDENCE_THRESHOLD) return {
-			...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-			shouldReply: false,
-			reason: "low_confidence",
-			reasonDetail: `${parsed.confidence.toFixed(2)}: ${reason}`
-		};
 		return {
 			...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
-			shouldReply: true,
-			reason: "llm_classifier",
-			reasonDetail: reason
+			...routeDecisionResult(result.answers.route)
 		};
 	} catch (error) {
 		if (isProviderRetryError(error)) throw error;
 		args.logClassifierFailure(error, args.input);
 		return {
 			shouldReply: false,
-			reason: "classifier_error"
+			reason: SubscribedReplyReason.ClassifierError
 		};
 	}
 }
-//#endregion
-//#region src/chat/services/pending-auth.ts
+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. */
 function canReusePendingAuthLink(args) {
@@ -425,9 +435,8 @@ function wasPendingAuthStopped(conversation, pendingAuth) {
 		const message = conversation.messages[index];
 		if (message?.role !== "user") continue;
 		if (buildDeterministicTurnId(message.id) === pendingAuth.sessionId) return false;
-		if (message.meta?.skippedReason?.startsWith(`thread_opt_out:`)) return true;
+		if (message.meta?.skippedReason?.startsWith(`${SubscribedReplyReason.ThreadOptOut}:`)) return true;
 	}
 	return false;
 }
-//#endregion
-export { wasPendingAuthStopped as a, getThreadStopDecision as c, getConversationPendingAuth as i, buildDeterministicAssistantMessageId as l, canReusePendingAuthLink as n, decideSubscribedThreadReply as o, clearPendingAuth as r, getSubscribedReplyPreflightDecision as s, abandonReplacedPendingAuth as t, buildDeterministicTurnId as u };
+export { wasPendingAuthStopped as a, getSubscribedReplyPreflightDecision as c, buildDeterministicTurnId as d, getConversationPendingAuth as i, getThreadStopDecision as l, canReusePendingAuthLink as n, SubscribedReplyReason as o, clearPendingAuth as r, decideSubscribedThreadReply as s, abandonReplacedPendingAuth as t, buildDeterministicAssistantMessageId as u };

package/dist/{plugin-module-CVvEUSMH.js → plugin-module-Cf5gVPWP.js}

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { statSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-//#region src/plugin-module.ts
+// src/plugin-module.ts
 const PLUGIN_MODULE_EXTENSIONS = [
 	"",
 	".ts",
@@ -77,5 +77,4 @@ async function loadAppPluginSet(cwd, importModule) {
 	}
 	return await loadPluginSetFromModule(pluginModule, importModule);
 }
-//#endregion
 export { loadPluginSetFromModule as n, resolvePluginModule as r, loadAppPluginSet as t };

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

@@ -1,5 +1,4 @@
-import { PluginMcpConfig, PluginRegistration, PluginRuntimePostinstallCommand } from "@sentry/junior-plugin-api";
-//#region src/chat/plugins/types.d.ts
+import { PluginMcpConfig, PluginRegistration, PluginRuntimePostinstallCommand, PluginServiceAccountConfig } from "@sentry/junior-plugin-api";
 interface PluginOAuthConfig {
   clientIdEnv: string;
   clientSecretEnv: string;
@@ -69,14 +68,16 @@ interface PluginManifestConfig {
     wrappedTools?: string[] | null;
   } | null;
   oauth?: PluginOAuthConfigPatch | null;
+  accounts?: {
+    userOAuth?: boolean | null;
+    serviceAccount?: PluginServiceAccountConfig | null;
+  } | null;
   target?: {
     type?: string;
     configKey?: string;
     commandFlags?: string[] | null;
   } | null;
 }
-//#endregion
-//#region src/plugins.d.ts
 type JuniorPluginInput = PluginRegistration | string;
 interface JuniorPluginSetOptions {
   /** Install-level manifest overrides applied before validation. */
@@ -93,5 +94,4 @@ interface JuniorPluginSet {
 }
 /** Define package-name plugins and JS plugin definitions for one app. */
 declare function defineJuniorPlugins(inputs: JuniorPluginInput[], options?: JuniorPluginSetOptions): JuniorPluginSet;
-//#endregion
 export { defineJuniorPlugins as i, JuniorPluginSet as n, JuniorPluginSetOptions as r, JuniorPluginInput as t };

package/dist/{plugins-egKWjgue.js → plugins-DOm9Y6qI.js}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-//#region src/plugins.ts
+import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
+// src/plugins.ts
 var plugins_exports = /* @__PURE__ */ __exportAll({
 	defineJuniorPlugins: () => defineJuniorPlugins,
 	pluginCatalogConfigFromEnv: () => pluginCatalogConfigFromEnv,
@@ -95,5 +95,4 @@ function pluginRuntimeRegistrationsFromPluginSet(pluginSet) {
 function pluginCliRegistrationsFromPluginSet(pluginSet) {
 	return pluginSet?.registrations.filter((plugin) => plugin.cli) ?? [];
 }
-//#endregion
 export { pluginRuntimeRegistrationsFromPluginSet as a, pluginCliRegistrationsFromPluginSet as i, pluginCatalogConfigFromEnv as n, plugins_exports as o, pluginCatalogConfigFromPluginSet as r, defineJuniorPlugins as t };

package/dist/{private-trace-result-BLvBjy_e.js → private-trace-result-CE7_lEdq.js}

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-//#region src/chat/tool-support/private-trace-result.ts
+// src/chat/tool-support/private-trace-result.ts
 const PRIVATE_TRACE_RESULT_ATTRIBUTE = "gen_ai.tool.call.result.exposure";
 const privateTraceResultToken = randomUUID();
 /** Mark one tool result as an adapter-approved private trace projection. */
@@ -12,5 +12,4 @@ function consumePrivateTraceResultMarker(attributes) {
 	delete attributes[PRIVATE_TRACE_RESULT_ATTRIBUTE];
 	return projected;
 }
-//#endregion
 export { privateTraceResultAttributes as n, consumePrivateTraceResultMarker as t };