@sentry/junior 0.114.0 → 0.115.0

package/dist/{chunk-WV4UJBAS.js → chunk-43RYMWJ2.js}

@@ -1,3 +1,31 @@
+import {
+  authorizationId
+} from "./chunk-DIB4GX3G.js";
+import {
+  RetryableDeliveryError,
+  actorFromRouting,
+  addReactionToMessage,
+  assertRunRoutingConsistency,
+  createMcpOAuthClientProvider,
+  createUserTokenStore,
+  deleteMcpAuthSession,
+  deliverOAuthAuthorization,
+  formatProviderLabel,
+  getMcpAuthSession,
+  getSlackMessagePermalink,
+  hasEgressCredentialHooks,
+  issuePluginCredential,
+  issueProviderCredentialLease,
+  onPluginEgressResponse,
+  patchMcpAuthSession,
+  resolveBaseUrl,
+  selectPluginGrant,
+  slackOutputPolicy,
+  startOAuthFlow,
+  surfaceFromRouting,
+  toolInvocationDestination,
+  uploadFilesToConversation
+} from "./chunk-LYA2AB5G.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
@@ -10,7 +38,6 @@ import {
   extractAssistantText,
   getAgentContextCompactionTriggerTokens,
   getAgentContextInputLimitTokens,
-  getInterruptionMarker,
   getPiMessageRole,
   getTerminalAssistantMessages,
   hasRuntimeTurnContext,
@@ -38,7 +65,13 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-6QWPVTMO.js";
+} from "./chunk-CEYOL62C.js";
+import {
+  parseSandboxEgressAuthRequiredSignal,
+  parseSandboxEgressPermissionDeniedSignal,
+  sandboxEgressCredentialContextSchema,
+  sandboxEgressCredentialLeaseSchema
+} from "./chunk-HDSDCEPK.js";
 import {
   buildNonInteractiveShellScript,
   createSandboxSession,
@@ -55,7 +88,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-XLFBQJUO.js";
+} from "./chunk-PVZHG2XZ.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -65,43 +98,37 @@ import {
 } from "./chunk-UIE3R5XU.js";
 import {
   createPluginHookRunner,
-  createPluginLogger,
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
-  getPlugins,
   getSlackToolContext,
   resolveChannelCapabilities
-} from "./chunk-VNNBSKCO.js";
+} from "./chunk-RAVKCKXA.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
-  acquireActiveLock,
   getStateAdapter,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-YU6PO42Q.js";
+} from "./chunk-67CVNDJ7.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
   getFilePermalink,
   getSlackClient,
   isConversationScopedChannel,
-  isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-RD7EJI7H.js";
+} from "./chunk-CWEZEPD4.js";
 import {
   contextProvenance,
   getConversationEventStore,
   getConversationSearchStore,
   getConversationStore,
-  getDb,
   instructionActors,
-  instructionProvenanceFor,
-  parseDestination
-} from "./chunk-FIGAF6KL.js";
+  instructionProvenanceFor
+} from "./chunk-HWCQRGLL.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -134,7 +161,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-ZGXH3REA.js";
+} from "./chunk-SYJT7AKB.js";
 import {
   parseSlackThreadId,
   resolveConversationPrivacy,
@@ -144,26 +171,27 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-6Y5L4BOM.js";
+} from "./chunk-FXOYURO4.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-TLGM5X2M.js";
+} from "./chunk-2QG4MZQ7.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-OSKEC4XU.js";
+} from "./chunk-6FKLPVF3.js";
 import {
   CredentialUnavailableError,
-  credentialContextSchema,
-  credentialUserSubjectId,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-K2W4CK7K.js";
+} from "./chunk-EW5MLKT5.js";
+import {
+  credentialUserSubjectId
+} from "./chunk-W3U3YQYI.js";
 import {
   isUserActor
-} from "./chunk-C4MZ3GP5.js";
+} from "./chunk-HZF5P5UN.js";
 import {
   extractGenAiUsageAttributes,
   extractGenAiUsageSummary,
@@ -181,13 +209,12 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-4FUEG3QY.js";
+} from "./chunk-NVUQSFWX.js";
 import {
-  isRecord,
   parseSlackChannelId,
   parseSlackMessageTs,
   parseSlackUserId
-} from "./chunk-42WRQLJ6.js";
+} from "./chunk-F3B2YJ76.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -920,12 +947,12 @@ function sortJsonValue(value) {
     Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, sortJsonValue(item)])
   );
 }
-function isRecord2(value) {
+function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function injectContinuationToolName(details, toolName) {
   const parsed = juniorToolResultSchema.parse(details);
-  if (!isRecord2(parsed.continuation)) {
+  if (!isRecord(parsed.continuation)) {
     return parsed;
   }
   return juniorToolResultWithBoundContinuationSchema.parse({
@@ -1299,69 +1326,6 @@ var AuthorizationFlowDisabledError = class extends Error {
   }
 };
 
-// src/chat/agent/request.ts
-var RetryableDeliveryError = class extends Error {
-  constructor(cause) {
-    super("Assistant delivery was transient or ambiguous", { cause });
-    this.name = "RetryableDeliveryError";
-  }
-};
-function actorFromRouting(routing) {
-  if (routing.dispatch?.actor) {
-    return routing.dispatch.actor;
-  }
-  if (routing.actor) {
-    return routing.actor;
-  }
-  if (routing.credentialContext && !("type" in routing.credentialContext.actor)) {
-    return routing.credentialContext.actor;
-  }
-  return void 0;
-}
-function assertRunRoutingConsistency(request) {
-  const { destination, source } = request.routing;
-  if (source.platform !== destination.platform) {
-    throw new TypeError("Run source and destination platforms do not match");
-  }
-  if (source.platform === "slack" && destination.platform === "slack") {
-    if (source.teamId !== destination.teamId) {
-      throw new TypeError("Slack source and destination teams do not match");
-    }
-  } else if (source.platform === "local" && destination.platform === "local" && (source.conversationId !== request.conversationId || destination.conversationId !== request.conversationId)) {
-    throw new TypeError(
-      "Local source, destination, and run conversation IDs do not match"
-    );
-  }
-  const actor = request.routing.dispatch?.actor ?? request.routing.actor;
-  if (!actor || actor.platform === "system") {
-    return;
-  }
-  if (actor.platform !== destination.platform) {
-    throw new TypeError(
-      `Actor platform "${actor.platform}" does not match destination platform "${destination.platform}"`
-    );
-  }
-  if (actor.platform === "slack" && destination.platform === "slack" && actor.teamId !== destination.teamId) {
-    throw new TypeError("Slack actor team does not match destination team");
-  }
-}
-function toolInvocationDestination(routing) {
-  if (routing.destination.platform !== "slack" || !routing.toolChannelId) {
-    return routing.destination;
-  }
-  return {
-    platform: "slack",
-    teamId: routing.destination.teamId,
-    channelId: routing.toolChannelId
-  };
-}
-function surfaceFromRouting(routing) {
-  if (routing.surface) {
-    return routing.surface;
-  }
-  return routing.source.platform === "slack" ? "slack" : "internal";
-}
-
 // src/chat/agent/session.ts
 async function restoreSessionRecord(args) {
   const sessionRecordState = await loadTurnSessionRecord({
@@ -1387,7 +1351,7 @@ function parseMcpProviderFromToolName(toolName) {
 
 // src/chat/pi/derived-state.ts
 var MCP_BRIDGE_TOOLS = /* @__PURE__ */ new Set(["callMcpTool", "searchMcpTools"]);
-function isRecord3(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function providerFromToolName(value) {
@@ -1409,7 +1373,7 @@ function addBridgeToolProvider(toolName, value, providers) {
   if (bridgeTool === "searchMcpTools") {
     for (const argsKey of ["input", "args", "arguments", "params"]) {
       const args = value[argsKey];
-      if (isRecord3(args)) {
+      if (isRecord2(args)) {
         addString(providers, args.provider);
       }
     }
@@ -1418,7 +1382,7 @@ function addBridgeToolProvider(toolName, value, providers) {
   if (bridgeTool === "callMcpTool") {
     for (const argsKey of ["input", "args", "arguments", "params"]) {
       const args = value[argsKey];
-      if (isRecord3(args)) {
+      if (isRecord2(args)) {
         addString(providers, providerFromToolName(args.tool_name));
       }
     }
@@ -1431,18 +1395,18 @@ function addMcpResultProvider(message, providers) {
     return;
   }
   if (toolName === "loadSkill") {
-    if (isRecord3(message.details)) {
+    if (isRecord2(message.details)) {
       addString(providers, message.details.mcp_provider);
     }
     addString(providers, message.mcp_provider);
     return;
   }
   if (toolName === "searchMcpTools") {
-    if (isRecord3(message.details)) {
+    if (isRecord2(message.details)) {
       addString(providers, message.details.provider);
       if (Array.isArray(message.details.tools)) {
         for (const tool of message.details.tools) {
-          if (isRecord3(tool)) {
+          if (isRecord2(tool)) {
             addString(providers, providerFromToolName(tool.tool_name));
           }
         }
@@ -1454,11 +1418,11 @@ function addMcpResultProvider(message, providers) {
   if (toolName === "callMcpTool") {
     for (const argsKey of ["input", "args", "arguments", "params"]) {
       const args = message[argsKey];
-      if (isRecord3(args)) {
+      if (isRecord2(args)) {
         addString(providers, providerFromToolName(args.tool_name));
       }
     }
-    if (isRecord3(message.details)) {
+    if (isRecord2(message.details)) {
       addString(providers, message.details.provider);
       addString(providers, providerFromToolName(message.details.tool_name));
     }
@@ -1466,7 +1430,7 @@ function addMcpResultProvider(message, providers) {
   }
 }
 function scanMcpProviders(message, providers) {
-  if (!isRecord3(message)) {
+  if (!isRecord2(message)) {
     return;
   }
   if (message.role === "toolResult") {
@@ -1478,15 +1442,15 @@ function scanMcpProviders(message, providers) {
     return;
   }
   for (const part of content) {
-    if (!isRecord3(part)) {
+    if (!isRecord2(part)) {
       continue;
     }
     addBridgeToolProvider(getToolName(part), part, providers);
   }
 }
 function scanLoadedSkills(message, skills) {
-  if (isRecord3(message) && message.role === "toolResult" && message.toolName === "loadSkill" && message.isError !== true) {
-    if (isRecord3(message.details)) {
+  if (isRecord2(message) && message.role === "toolResult" && message.toolName === "loadSkill" && message.isError !== true) {
+    if (isRecord2(message.details)) {
       addString(skills, message.details.skill_name);
     }
     addString(skills, message.skill_name);
@@ -1573,424 +1537,6 @@ import { isDeepStrictEqual } from "util";
 // src/chat/prompt.ts
 import fs2 from "fs";
 import path2 from "path";
-
-// src/chat/slack/status-format.ts
-var SLACK_STATUS_MAX_LENGTH = 50;
-function truncateStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) {
-    return trimmed;
-  }
-  return `${trimmed.slice(0, SLACK_STATUS_MAX_LENGTH - 3).trimEnd()}...`;
-}
-
-// src/chat/slack/mrkdwn.ts
-function escapeSlackMrkdwnText(text) {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-function escapeSlackLinkUrl(url) {
-  return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
-}
-function formatSlackLink(url, label) {
-  return `<${escapeSlackLinkUrl(url)}|${escapeSlackMrkdwnText(label)}>`;
-}
-function readInlineCodeSpan(line, start) {
-  if (line[start] !== "`") {
-    return void 0;
-  }
-  let n = 1;
-  while (line[start + n] === "`") {
-    n++;
-  }
-  const marker = "`".repeat(n);
-  let search = start + n;
-  while (search < line.length) {
-    const close = line.indexOf(marker, search);
-    if (close === -1) {
-      return void 0;
-    }
-    const after = close + n;
-    if (line[after] !== "`") {
-      return { text: line.slice(start, after), end: after };
-    }
-    search = after + 1;
-  }
-  return void 0;
-}
-function readExistingSlackAngleToken(line, start) {
-  if (line[start] !== "<") {
-    return void 0;
-  }
-  const close = line.indexOf(">", start + 1);
-  if (close === -1) {
-    return void 0;
-  }
-  const body = line.slice(start + 1, close);
-  if (/^(?:https?:\/\/|@|#|!)/.test(body)) {
-    return { text: line.slice(start, close + 1), end: close + 1 };
-  }
-  return void 0;
-}
-function readMarkdownLink(line, start) {
-  if (line[start] !== "[") {
-    return void 0;
-  }
-  const labelEnd = line.indexOf("](", start + 1);
-  if (labelEnd === -1) {
-    return void 0;
-  }
-  const destStart = labelEnd + 2;
-  if (!line.startsWith("http://", destStart) && !line.startsWith("https://", destStart)) {
-    return void 0;
-  }
-  const closeParens = line.indexOf(")", destStart);
-  if (closeParens === -1) {
-    return void 0;
-  }
-  return { text: line.slice(start, closeParens + 1), end: closeParens + 1 };
-}
-function hasUnmatchedClosingParen(text) {
-  let balance = 0;
-  for (const ch of text) {
-    if (ch === "(") balance++;
-    else if (ch === ")") balance--;
-  }
-  return balance < 0;
-}
-function readBareUrl(line, start) {
-  let end = start;
-  while (end < line.length) {
-    const ch = line[end];
-    if (/\s/.test(ch) || ch === "<" || ch === ">" || ch === '"' || ch === "`" || ch === "|" || ch === "*") {
-      break;
-    }
-    end++;
-  }
-  if (end === start) {
-    return void 0;
-  }
-  let raw = line.slice(start, end);
-  let suffix = "";
-  const peel = () => {
-    suffix = raw.slice(-1) + suffix;
-    raw = raw.slice(0, -1);
-  };
-  const shouldPeel = () => raw.endsWith("_") || /[.,!?;:]$/.test(raw) || raw.endsWith(")") && hasUnmatchedClosingParen(raw);
-  while (raw.length > 0 && shouldPeel()) {
-    peel();
-  }
-  if (!/^https?:\/\/.+/.test(raw)) {
-    return void 0;
-  }
-  return { url: raw, suffix, end };
-}
-function wrapBareUrlsOnLine(line) {
-  let result = "";
-  let i = 0;
-  while (i < line.length) {
-    const codeSpan = readInlineCodeSpan(line, i);
-    if (codeSpan) {
-      result += codeSpan.text;
-      i = codeSpan.end;
-      continue;
-    }
-    const angleToken = readExistingSlackAngleToken(line, i);
-    if (angleToken) {
-      result += angleToken.text;
-      i = angleToken.end;
-      continue;
-    }
-    const mdLink = readMarkdownLink(line, i);
-    if (mdLink) {
-      result += mdLink.text;
-      i = mdLink.end;
-      continue;
-    }
-    if (line.startsWith("https://", i) || line.startsWith("http://", i)) {
-      const parsed = readBareUrl(line, i);
-      if (parsed) {
-        result += `<${parsed.url}>${parsed.suffix}`;
-        i = parsed.end;
-        continue;
-      }
-    }
-    result += line[i];
-    i++;
-  }
-  return result;
-}
-function wrapBareUrls(text) {
-  const lines = text.split("\n");
-  const out = [];
-  let inCodeBlock = false;
-  for (const line of lines) {
-    if (line.trimStart().startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      out.push(line);
-      continue;
-    }
-    out.push(inCodeBlock ? line : wrapBareUrlsOnLine(line));
-  }
-  return out.join("\n");
-}
-function ensureBlockSpacing(text) {
-  const codeBlockPattern = /^```/;
-  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-  const lines = text.split("\n");
-  const result = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isCodeFence = codeBlockPattern.test(line.trimStart());
-    if (isCodeFence) {
-      if (!inCodeBlock) {
-        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev2 !== void 0 && prev2.trim() !== "") {
-          result.push("");
-        }
-      }
-      inCodeBlock = !inCodeBlock;
-      result.push(line);
-      continue;
-    }
-    if (inCodeBlock) {
-      result.push(line);
-      continue;
-    }
-    const prev = result.length > 0 ? result[result.length - 1] : void 0;
-    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
-      result.push("");
-    }
-    result.push(line);
-  }
-  return result.join("\n");
-}
-function normalizeSlackReplyMarkdown(text) {
-  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
-  normalized = wrapBareUrls(normalized);
-  normalized = ensureBlockSpacing(normalized);
-  return normalized.replace(/\n{3,}/g, "\n\n").trim();
-}
-function normalizeSlackStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
-}
-
-// src/chat/slack/output.ts
-var MAX_INLINE_CHARS = 2200;
-var MAX_INLINE_LINES = 45;
-var CONTINUED_MARKER = "\n\n[Continued below]";
-function countSlackLines(text) {
-  if (!text) {
-    return 0;
-  }
-  return text.split("\n").length;
-}
-function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return text.length <= maxChars && countSlackLines(text) <= maxLines;
-}
-function findSplitIndex(text, maxChars) {
-  if (text.length <= maxChars) {
-    return text.length;
-  }
-  const bounded = text.slice(0, maxChars);
-  const newlineIndex = bounded.lastIndexOf("\n");
-  if (newlineIndex > 0) {
-    return newlineIndex;
-  }
-  const spaceIndex = bounded.lastIndexOf(" ");
-  if (spaceIndex > 0) {
-    return spaceIndex;
-  }
-  return maxChars;
-}
-function splitByLineBudget(text, maxLines) {
-  if (maxLines <= 0) {
-    return "";
-  }
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) {
-    return text;
-  }
-  return lines.slice(0, maxLines).join("\n");
-}
-function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return {
-    maxChars: Math.max(1, maxChars - suffix.length),
-    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
-  };
-}
-function forceSplitBudget(text, budget) {
-  const lineCount = countSlackLines(text);
-  return {
-    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
-    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
-  };
-}
-function getFenceContinuation(text) {
-  let open;
-  for (const line of text.split("\n")) {
-    const trimmed = line.trimStart();
-    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
-    if (!openerMatch) {
-      continue;
-    }
-    if (!open) {
-      open = {
-        fence: openerMatch[1],
-        openerLine: trimmed
-      };
-      continue;
-    }
-    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
-      open = void 0;
-    }
-  }
-  if (!open) {
-    return null;
-  }
-  return {
-    closeSuffix: text.endsWith("\n") ? open.fence : `
-${open.fence}`,
-    reopenPrefix: `${open.openerLine}
-`
-  };
-}
-function appendSlackSuffix(text, marker) {
-  const carryover = getFenceContinuation(text);
-  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
-}
-function stripTrailingContinuationMarker(text) {
-  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
-}
-function takeSlackContinuationChunk(text, budget) {
-  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, budget)
-    ));
-  }
-  let carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
-  }
-  const carryoverBudget = reserveInlineBudgetForSuffix(
-    `${carryover.closeSuffix}${CONTINUED_MARKER}`
-  );
-  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, carryoverBudget)
-    ));
-  }
-  carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
-  }
-  return {
-    prefix,
-    rest: `${carryover.reopenPrefix}${rest}`
-  };
-}
-function takeSlackContinuationPrefix(text, options) {
-  const budget = {
-    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
-    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
-  };
-  const { prefix, rest } = (() => {
-    if (options?.forceSplit) {
-      return takeSlackContinuationChunk(text, budget);
-    }
-    const initial = takeSlackInlinePrefix(text, budget);
-    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
-  })();
-  return {
-    prefix,
-    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
-    rest
-  };
-}
-function takeSlackInlinePrefix(text, options) {
-  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
-  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
-  const normalized = text.replace(/\r\n?/g, "\n");
-  if (!normalized) {
-    return { prefix: "", rest: "" };
-  }
-  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
-    return { prefix: normalized, rest: "" };
-  }
-  const lineBounded = splitByLineBudget(normalized, maxLines);
-  const cutIndex = findSplitIndex(lineBounded, maxChars);
-  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
-  if (prefix) {
-    return {
-      prefix,
-      rest: normalized.slice(prefix.length).trimStart()
-    };
-  }
-  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
-  return {
-    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
-    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
-  };
-}
-function splitSlackReplyText(text, options) {
-  const normalized = normalizeSlackReplyMarkdown(text);
-  if (!normalized) {
-    return [];
-  }
-  const chunks = [];
-  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-  let remaining = normalized;
-  while (remaining) {
-    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
-    if (fitsFinalChunk) {
-      chunks.push(
-        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
-      );
-      break;
-    }
-    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
-      ...continuationBudget,
-      forceSplit: true
-    });
-    chunks.push(renderedPrefix);
-    remaining = rest;
-  }
-  if (chunks.length === 2) {
-    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
-  }
-  return chunks;
-}
-function getSlackContinuationBudget() {
-  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-}
-function buildSlackOutputMessage(text) {
-  const normalized = normalizeSlackReplyMarkdown(text);
-  if (!normalized) {
-    throw new Error(
-      `Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`
-    );
-  }
-  return {
-    markdown: normalized
-  };
-}
-var slackOutputPolicy = {
-  maxInlineChars: MAX_INLINE_CHARS,
-  maxInlineLines: MAX_INLINE_LINES
-};
-
-// src/chat/prompt.ts
 var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
 function getLoggedMarkdownFiles() {
   const globalState = globalThis;
@@ -2824,160 +2370,6 @@ async function assemblePrompt(args) {
   };
 }
 
-// src/chat/capabilities/catalog.ts
-var cachedCatalog;
-function getCapabilityCatalog() {
-  const signature = pluginCatalogRuntime.getSignature();
-  if (cachedCatalog?.signature === signature) return cachedCatalog;
-  const providers = pluginCatalogRuntime.getCapabilityProviders();
-  const capabilityToProvider = /* @__PURE__ */ new Map();
-  for (const provider of providers) {
-    for (const capability of provider.capabilities) {
-      if (capabilityToProvider.has(capability)) {
-        throw new Error(
-          `Duplicate capability registration for "${capability}"`
-        );
-      }
-      capabilityToProvider.set(capability, provider);
-    }
-  }
-  cachedCatalog = { signature, providers, capabilityToProvider };
-  return cachedCatalog;
-}
-var catalogLogged = false;
-function logCapabilityCatalogLoadedOnce() {
-  if (catalogLogged) return;
-  catalogLogged = true;
-  const { providers } = getCapabilityCatalog();
-  const capabilityNames = providers.flatMap((p) => p.capabilities).sort();
-  const configKeys = [
-    ...new Set(providers.flatMap((p) => p.configKeys))
-  ].sort();
-  logInfo(
-    "capability_catalog_loaded",
-    {},
-    {
-      "app.capability.providers": providers.map((p) => p.provider),
-      "app.capability.count": capabilityNames.length,
-      "app.capability.names": capabilityNames,
-      "app.config.key_count": configKeys.length,
-      "app.config.keys": configKeys
-    },
-    "Loaded capability provider catalog"
-  );
-}
-
-// src/chat/capabilities/router.ts
-var ProviderCredentialRouter = class {
-  brokersByProvider;
-  constructor(input) {
-    this.brokersByProvider = input.brokersByProvider;
-  }
-  async issue(input) {
-    const broker = this.brokersByProvider[input.provider];
-    if (!broker) {
-      throw new Error(
-        `No credential broker registered for provider: ${input.provider}`
-      );
-    }
-    return await broker.issue({
-      context: input.context,
-      reason: input.reason
-    });
-  }
-};
-
-// src/chat/credentials/user-token-store.ts
-import {
-  pluginStoredTokensSchema
-} from "@sentry/junior-plugin-api";
-var storedTokensSchema = pluginStoredTokensSchema;
-
-// src/chat/credentials/state-adapter-token-store.ts
-var KEY_PREFIX = "oauth-token";
-var BUFFER_MS = 24 * 60 * 60 * 1e3;
-var LONG_LIVED_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
-var REFRESH_LOCK_WAIT_MS = 3e4;
-var REFRESH_LOCK_RETRY_MS = 100;
-function tokenKey(userId, provider) {
-  return `${KEY_PREFIX}:${userId}:${provider}`;
-}
-function refreshLockKey(userId, provider) {
-  return `${tokenKey(userId, provider)}:refresh`;
-}
-var StateAdapterTokenStore = class {
-  state;
-  constructor(stateAdapter) {
-    this.state = stateAdapter;
-  }
-  async get(userId, provider) {
-    const stored = await this.state.get(tokenKey(userId, provider));
-    return stored === null || stored === void 0 ? void 0 : storedTokensSchema.parse(stored);
-  }
-  async set(userId, provider, tokens) {
-    const parsed = storedTokensSchema.parse(tokens);
-    const expiresAt = parsed.refreshTokenExpiresAt ?? parsed.expiresAt;
-    const ttlMs2 = expiresAt ? Math.max(expiresAt - Date.now() + BUFFER_MS, BUFFER_MS) : LONG_LIVED_TTL_MS;
-    await this.state.set(tokenKey(userId, provider), parsed, ttlMs2);
-  }
-  async delete(userId, provider) {
-    await this.state.delete(tokenKey(userId, provider));
-  }
-  /** Wait for the per-slot refresh gate so rotated refresh tokens are used once. */
-  async withRefresh(userId, provider, callback) {
-    const lockKey = refreshLockKey(userId, provider);
-    const deadline = Date.now() + REFRESH_LOCK_WAIT_MS;
-    while (true) {
-      const lock = await acquireActiveLock(this.state, lockKey);
-      if (lock) {
-        try {
-          return await callback();
-        } finally {
-          await this.state.releaseLock(lock);
-        }
-      }
-      if (Date.now() >= deadline) {
-        throw new Error(`Could not acquire OAuth token refresh lock`);
-      }
-      await sleep(REFRESH_LOCK_RETRY_MS);
-    }
-  }
-};
-
-// src/chat/capabilities/factory.ts
-var sandboxEgressRouters = /* @__PURE__ */ new WeakMap();
-function createUserTokenStore() {
-  return new StateAdapterTokenStore(getStateAdapter());
-}
-function createProviderCredentialRouter(userTokenStore) {
-  logCapabilityCatalogLoadedOnce();
-  const brokersByProvider = {};
-  for (const plugin of pluginCatalogRuntime.getProviders()) {
-    const { name } = plugin.manifest;
-    if (!plugin.manifest.credentials && !plugin.manifest.apiHeaders) {
-      continue;
-    }
-    brokersByProvider[name] = pluginCatalogRuntime.createBroker(name, {
-      userTokenStore
-    });
-  }
-  return new ProviderCredentialRouter({ brokersByProvider });
-}
-function getSandboxEgressRouter() {
-  const stateAdapter = getStateAdapter();
-  let router = sandboxEgressRouters.get(stateAdapter);
-  if (!router) {
-    router = createProviderCredentialRouter(
-      new StateAdapterTokenStore(stateAdapter)
-    );
-    sandboxEgressRouters.set(stateAdapter, router);
-  }
-  return router;
-}
-async function issueProviderCredentialLease(input) {
-  return await getSandboxEgressRouter().issue(input);
-}
-
 // src/chat/capabilities/jr-rpc-command.ts
 import { Bash, defineCommand } from "just-bash";
 function commandResult(input) {
@@ -3248,631 +2640,96 @@ function createJrRpcCommand(deps) {
       "jr-rpc config get <key>",
       "jr-rpc config set <key> <value> [--json]",
       "jr-rpc config unset <key>",
-      "jr-rpc config list [--prefix <value>]",
-      "jr-rpc plugins list"
-    ].join("\n");
-    const verb = (args[0] ?? "").trim();
-    if (verb === "config") {
-      return handleConfigCommand(args.slice(1), deps);
-    }
-    if (verb === "plugins") {
-      return handlePluginsCommand(args.slice(1));
-    }
-    return commandResult({
-      stderr: `Unsupported jr-rpc command. Use:
-${usage}
-`,
-      exitCode: 2
-    });
-  });
-}
-async function maybeExecuteJrRpcCustomCommand(command, deps) {
-  const normalized = command.trim();
-  if (!/^jr-rpc(?:\s|$)/.test(normalized)) {
-    return { handled: false };
-  }
-  const shell = new Bash({
-    customCommands: [createJrRpcCommand(deps)]
-  });
-  const execResult = await shell.exec(normalized);
-  return {
-    handled: true,
-    result: {
-      ok: execResult.exitCode === 0,
-      command: normalized,
-      cwd: "/",
-      exit_code: execResult.exitCode,
-      signal: null,
-      timed_out: false,
-      stdout: execResult.stdout,
-      stderr: execResult.stderr,
-      stdout_truncated: false,
-      stderr_truncated: false
-    }
-  };
-}
-
-// src/chat/sandbox/command-result.ts
-function formatSandboxCommandResult(params) {
-  return makeStructuredToolResult({
-    ok: params.ok,
-    status: params.ok ? "success" : "error",
-    target: params.command,
-    data: {
-      command: params.command,
-      cwd: params.cwd,
-      exit_code: params.exit_code,
-      signal: params.signal,
-      timed_out: params.timed_out,
-      aborted: Boolean(params.aborted),
-      stdout: params.stdout,
-      stderr: params.stderr,
-      stdout_truncated: params.stdout_truncated,
-      stderr_truncated: params.stderr_truncated
-    },
-    truncated: params.stdout_truncated || params.stderr_truncated,
-    ...!params.ok ? {
-      error: {
-        kind: params.aborted ? "outcome_unknown" : params.timed_out ? "timeout" : "nonzero_exit",
-        message: params.aborted ? "Command was interrupted before its outcome was confirmed. It may have produced side effects; reconcile external state before retrying or reporting failure." : params.stderr.trim() || `Command exited with code ${params.exit_code}`,
-        retryable: params.timed_out
-      }
-    } : {},
-    command: params.command,
-    cwd: params.cwd,
-    exit_code: params.exit_code,
-    signal: params.signal,
-    timed_out: params.timed_out,
-    aborted: Boolean(params.aborted),
-    stdout: params.stdout,
-    stderr: params.stderr,
-    stdout_truncated: params.stdout_truncated,
-    stderr_truncated: params.stderr_truncated,
-    ...params.auth_required ? { auth_required: params.auth_required } : {},
-    ...params.permission_denied ? { permission_denied: params.permission_denied } : {}
-  });
-}
-
-// src/chat/sandbox/sandbox.ts
-import fs4 from "fs/promises";
-
-// src/chat/oauth-flow.ts
-import { randomBytes } from "crypto";
-import {
-  sourceSchema
-} from "@sentry/junior-plugin-api";
-
-// src/chat/slack/outbound.ts
-var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
-function requireSlackConversationId(channelId, action) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) {
-    throw new Error(`${action} requires a valid channel ID`);
-  }
-  return normalized;
-}
-function requireSlackThreadTimestamp(threadTs, action) {
-  const normalized = threadTs.trim();
-  if (!normalized) {
-    throw new Error(`${action} requires a thread timestamp`);
-  }
-  return normalized;
-}
-function requireSlackMessageTimestamp(timestamp, action) {
-  const normalized = parseSlackMessageTs(timestamp);
-  if (!normalized) {
-    throw new Error(`${action} requires a target message timestamp`);
-  }
-  return normalized;
-}
-function requireSlackMessageText(text, action) {
-  if (text.trim().length === 0) {
-    throw new Error(`${action} requires non-empty text`);
-  }
-  if (text.length > MAX_SLACK_MESSAGE_TEXT_CHARS) {
-    throw new Error(
-      `${action} text exceeds Slack's 40000 character truncation limit`
-    );
-  }
-  return text;
-}
-async function getSlackMessagePermalink(args) {
-  try {
-    const response = await withSlackRetries(
-      () => getSlackClient().chat.getPermalink({
-        channel: args.channelId,
-        message_ts: args.messageTs
-      }),
-      3,
-      {
-        action: "chat.getPermalink",
-        idempotent: true,
-        spanAttributes: {
-          "app.slack.channel_id": args.channelId,
-          "app.slack.message_ts": args.messageTs
-        }
-      }
-    );
-    return response.permalink;
-  } catch {
-    return void 0;
-  }
-}
-async function postSlackMessage(input) {
-  const channelId = requireSlackConversationId(
-    input.channelId,
-    "Slack message posting"
-  );
-  const text = requireSlackMessageText(input.text, "Slack message posting");
-  const threadTs = input.threadTs ? requireSlackThreadTimestamp(
-    input.threadTs,
-    "Slack thread message posting"
-  ) : void 0;
-  const response = await withSlackRetries(
-    () => getSlackClient().chat.postMessage({
-      channel: channelId,
-      text,
-      ...input.blocks?.length ? {
-        blocks: input.blocks
-      } : {},
-      ...threadTs ? { thread_ts: threadTs } : {}
-    }),
-    3,
-    {
-      action: "chat.postMessage",
-      spanAttributes: {
-        "app.slack.channel_id": channelId,
-        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
-      }
-    }
-  );
-  const messageTs = parseSlackMessageTs(response.ts);
-  if (!messageTs) {
-    throw new Error("Slack message posted without ts");
-  }
-  return {
-    ts: messageTs,
-    ...input.includePermalink ? {
-      permalink: await getSlackMessagePermalink({
-        channelId,
-        messageTs
-      })
-    } : {}
-  };
-}
-async function postSlackEphemeralMessage(input) {
-  const channelId = requireSlackConversationId(
-    input.channelId,
-    "Slack ephemeral message posting"
-  );
-  const userId = parseSlackUserId(input.userId);
-  if (!userId) {
-    throw new Error("Slack ephemeral message posting requires a user ID");
-  }
-  const text = requireSlackMessageText(
-    input.text,
-    "Slack ephemeral message posting"
-  );
-  const threadTs = input.threadTs ? requireSlackThreadTimestamp(
-    input.threadTs,
-    "Slack ephemeral thread message posting"
-  ) : void 0;
-  const response = await withSlackRetries(
-    () => getSlackClient().chat.postEphemeral({
-      channel: channelId,
-      user: userId,
-      text,
-      ...threadTs ? { thread_ts: threadTs } : {}
-    }),
-    3,
-    {
-      action: "chat.postEphemeral",
-      spanAttributes: {
-        "app.slack.channel_id": channelId,
-        "app.slack.user_id": userId,
-        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
-      }
-    }
-  );
-  return {
-    messageTs: response.message_ts
-  };
-}
-async function uploadFilesToConversation(input) {
-  const channelId = requireSlackConversationId(
-    input.channelId,
-    "Slack file upload"
-  );
-  const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack file upload") : void 0;
-  if (input.files.length === 0) {
-    throw new Error("Slack file upload requires at least one file");
-  }
-  const fileUploads = input.files.map((file) => {
-    const filename = file.filename.trim();
-    if (!filename) {
-      throw new Error(
-        "Slack file upload requires every file to have a filename"
-      );
-    }
-    return {
-      file: file.data,
-      filename
-    };
-  });
-  const response = await withSlackRetries(
-    () => getSlackClient().filesUploadV2({
-      channel_id: channelId,
-      ...threadTs ? { thread_ts: threadTs } : {},
-      file_uploads: fileUploads
-    }),
-    3,
-    {
-      action: "filesUploadV2",
-      spanAttributes: {
-        "app.slack.channel_id": channelId,
-        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
-      }
-    }
-  );
-  return {
-    files: (response.files ?? []).flatMap(
-      (completion) => (completion.files ?? []).map((file) => file.id ? { id: file.id } : {})
-    )
-  };
-}
-async function addReactionToMessage(input) {
-  const channelId = requireSlackConversationId(
-    input.channelId,
-    "Slack reaction"
-  );
-  const timestamp = requireSlackMessageTimestamp(
-    input.timestamp,
-    "Slack reaction"
-  );
-  const emoji = normalizeSlackEmojiName(input.emoji);
-  if (!emoji) {
-    throw new Error("Slack reaction requires a valid emoji alias name");
-  }
-  try {
-    await withSlackRetries(
-      () => getSlackClient().reactions.add({
-        channel: channelId,
-        timestamp,
-        name: emoji
-      }),
-      3,
-      {
-        action: "reactions.add",
-        idempotent: true,
-        spanAttributes: {
-          "app.slack.channel_id": channelId,
-          "app.slack.message_ts": timestamp,
-          "app.slack.reaction": emoji
-        }
-      }
-    );
-  } catch (error) {
-    if (error instanceof SlackActionError && error.code === "already_reacted") {
-      return { ok: true };
-    }
-    throw error;
-  }
-  return { ok: true };
-}
-async function removeReactionFromMessage(input) {
-  const channelId = requireSlackConversationId(
-    input.channelId,
-    "Slack reaction removal"
-  );
-  const timestamp = requireSlackMessageTimestamp(
-    input.timestamp,
-    "Slack reaction removal"
-  );
-  const emoji = normalizeSlackEmojiName(input.emoji);
-  if (!emoji) {
-    throw new Error("Slack reaction removal requires a valid emoji alias name");
-  }
-  try {
-    await withSlackRetries(
-      () => getSlackClient().reactions.remove({
-        channel: channelId,
-        timestamp,
-        name: emoji
-      }),
-      3,
-      {
-        action: "reactions.remove",
-        idempotent: true,
-        spanAttributes: {
-          "app.slack.channel_id": channelId,
-          "app.slack.message_ts": timestamp,
-          "app.slack.reaction": emoji
-        }
-      }
-    );
-  } catch (error) {
-    if (error instanceof SlackActionError && error.code === "no_reaction") {
-      return { ok: true };
-    }
-    throw error;
-  }
-  return { ok: true };
-}
-
-// src/chat/oauth-authorization-message.ts
-function formatOAuthAuthorizationMessage(args) {
-  return `${formatSlackLink(args.authorizationUrl, args.label)}. ${args.completionText}`;
-}
-
-// src/chat/oauth-flow.ts
-var OAUTH_STATE_TTL_MS = 10 * 60 * 1e3;
-function optionalString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function parseOAuthStatePayload(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  if (typeof value.userId !== "string" || typeof value.provider !== "string") {
-    return void 0;
-  }
-  const destination = parseDestination(value.destination);
-  if (value.destination !== void 0 && !destination) {
-    return void 0;
-  }
-  const source = value.source === void 0 ? void 0 : sourceSchema.safeParse(value.source);
-  if (value.source !== void 0 && (!source || !source.success)) {
-    return void 0;
-  }
-  return {
-    userId: value.userId,
-    provider: value.provider,
-    ...optionalString(value.channelId) ? { channelId: optionalString(value.channelId) } : {},
-    ...destination ? { destination } : {},
-    ...source?.success ? { source: source.data } : {},
-    ...optionalString(value.threadTs) ? { threadTs: optionalString(value.threadTs) } : {},
-    ...optionalString(value.resumeConversationId) ? { resumeConversationId: optionalString(value.resumeConversationId) } : {},
-    ...optionalString(value.resumeSessionId) ? { resumeSessionId: optionalString(value.resumeSessionId) } : {},
-    ...optionalString(value.scope) ? { scope: optionalString(value.scope) } : {}
-  };
-}
-function formatProviderLabel(provider) {
-  const displayName = pluginCatalogRuntime.getDisplayName(provider);
-  if (!displayName) {
-    throw new Error(`Unknown plugin provider display name: "${provider}"`);
-  }
-  return displayName;
-}
-function resolveBaseUrl() {
-  const explicit = process.env.JUNIOR_BASE_URL?.trim();
-  if (explicit) return explicit;
-  const vercelProd = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim();
-  if (vercelProd) return `https://${vercelProd}`;
-  const vercelUrl = process.env.VERCEL_URL?.trim();
-  if (vercelUrl) return `https://${vercelUrl}`;
-  return void 0;
-}
-async function deliverPrivateMessage(input) {
-  let client;
-  try {
-    client = getSlackClient();
-  } catch {
-    logWarn(
-      "oauth_private_delivery_skip",
-      {},
-      { "app.reason": "missing_bot_token" },
-      "Skipped private message delivery \u2014 no SLACK_BOT_TOKEN"
-    );
-    return false;
-  }
-  if (input.channelId) {
-    try {
-      if (isDmChannel(input.channelId)) {
-        await postSlackMessage({
-          channelId: input.channelId,
-          text: input.text,
-          threadTs: input.threadTs
-        });
-      } else {
-        await postSlackEphemeralMessage({
-          channelId: input.channelId,
-          userId: input.userId,
-          text: input.text,
-          threadTs: input.threadTs
-        });
-      }
-      return "in_context";
-    } catch (error) {
-      logWarn(
-        "oauth_private_delivery_failed",
-        {},
-        {
-          "app.slack.error": error instanceof Error ? error.message : String(error),
-          "app.slack.channel": input.channelId
-        },
-        "Private message delivery failed, falling back to DM"
-      );
-    }
-  }
-  try {
-    const dmChannelId = (await withSlackRetries(
-      () => client.conversations.open({ users: input.userId }),
-      3,
-      {
-        action: "conversations.open",
-        spanAttributes: { "app.slack.user_id": input.userId }
-      }
-    )).channel?.id;
-    if (!dmChannelId) {
-      logWarn(
-        "oauth_dm_fallback_failed",
-        {},
-        { "app.reason": "no_dm_channel_id" },
-        "conversations.open returned no channel ID"
-      );
-      return false;
-    }
-    await postSlackMessage({ channelId: dmChannelId, text: input.text });
-    return "fallback_dm";
-  } catch (error) {
-    logWarn(
-      "oauth_dm_fallback_failed",
-      {},
-      {
-        "app.slack.error": error instanceof Error ? error.message : String(error)
-      },
-      "DM fallback delivery failed"
-    );
-    return false;
-  }
-}
-async function startOAuthFlow(provider, input) {
-  const providerConfig = pluginCatalogRuntime.getOAuthConfig(provider);
-  if (!providerConfig) {
-    return {
-      ok: false,
-      error: `Provider "${provider}" does not support OAuth authorization`
-    };
-  }
-  const clientId = process.env[providerConfig.clientIdEnv]?.trim();
-  if (!clientId) {
-    return {
-      ok: false,
-      error: `Missing ${providerConfig.clientIdEnv} environment variable`
-    };
-  }
-  const baseUrl = resolveBaseUrl();
-  if (!baseUrl) {
-    return {
-      ok: false,
-      error: "Cannot determine base URL (set JUNIOR_BASE_URL or deploy to Vercel)"
-    };
-  }
-  const state = randomBytes(32).toString("hex");
-  const requestedScope = input.scope ?? providerConfig.scope;
-  await getStateAdapter().set(
-    `oauth-state:${state}`,
-    {
-      userId: input.actorId,
-      provider,
-      ...input.channelId ? { channelId: input.channelId } : {},
-      ...input.destination ? { destination: input.destination } : {},
-      ...input.source ? { source: input.source } : {},
-      ...input.threadTs ? { threadTs: input.threadTs } : {},
-      ...input.resumeConversationId ? { resumeConversationId: input.resumeConversationId } : {},
-      ...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {},
-      ...requestedScope ? { scope: requestedScope } : {}
-    },
-    OAUTH_STATE_TTL_MS
-  );
-  const authorizeParams = new URLSearchParams({
-    client_id: clientId,
-    state,
-    redirect_uri: `${baseUrl}${providerConfig.callbackPath}`,
-    response_type: "code"
+      "jr-rpc config list [--prefix <value>]",
+      "jr-rpc plugins list"
+    ].join("\n");
+    const verb = (args[0] ?? "").trim();
+    if (verb === "config") {
+      return handleConfigCommand(args.slice(1), deps);
+    }
+    if (verb === "plugins") {
+      return handlePluginsCommand(args.slice(1));
+    }
+    return commandResult({
+      stderr: `Unsupported jr-rpc command. Use:
+${usage}
+`,
+      exitCode: 2
+    });
   });
-  if (requestedScope) {
-    authorizeParams.set("scope", requestedScope);
-  }
-  for (const [key, value] of Object.entries(
-    providerConfig.authorizeParams ?? {}
-  )) {
-    authorizeParams.set(key, value);
+}
+async function maybeExecuteJrRpcCustomCommand(command, deps) {
+  const normalized = command.trim();
+  if (!/^jr-rpc(?:\s|$)/.test(normalized)) {
+    return { handled: false };
   }
-  logInfo(
-    "jr_rpc_oauth_start",
-    {},
-    {
-      "app.credential.provider": provider,
-      ...input.activeSkillName ? { "app.skill.name": input.activeSkillName } : {}
-    },
-    "Initiated OAuth authorization code flow"
-  );
-  const authorizationUrl = `${providerConfig.authorizeEndpoint}?${authorizeParams.toString()}`;
+  const shell = new Bash({
+    customCommands: [createJrRpcCommand(deps)]
+  });
+  const execResult = await shell.exec(normalized);
   return {
-    ok: true,
-    delivery: await deliverPrivateMessage({
-      channelId: input.channelId,
-      threadTs: input.threadTs,
-      userId: input.actorId,
-      text: formatOAuthAuthorizationMessage({
-        authorizationUrl,
-        label: `Click here to link your ${formatProviderLabel(provider)} account`,
-        completionText: "Once you've authorized, you'll see a confirmation in Slack."
-      })
-    })
+    handled: true,
+    result: {
+      ok: execResult.exitCode === 0,
+      command: normalized,
+      cwd: "/",
+      exit_code: execResult.exitCode,
+      signal: null,
+      timed_out: false,
+      stdout: execResult.stdout,
+      stderr: execResult.stderr,
+      stdout_truncated: false,
+      stderr_truncated: false
+    }
   };
 }
 
-// src/chat/sandbox/egress/session.ts
-import { createHmac, randomUUID, timingSafeEqual } from "crypto";
-
-// src/chat/sandbox/egress/schemas.ts
-import { z as z3 } from "zod";
-import {
-  pluginAuthorizationSchema,
-  pluginCredentialHeaderTransformSchema,
-  pluginGrantSchema,
-  pluginProviderAccountSchema
-} from "@sentry/junior-plugin-api";
-var finiteNumberSchema = z3.number().refine(Number.isFinite);
-var httpStatusSchema = z3.number().int().min(100).max(599);
-var providerNameSchema = z3.string().regex(/^[a-z][a-z0-9-]*$/);
-var credentialSignalKindSchema = z3.enum(["auth_required", "unavailable"]);
-var sandboxEgressGrantSchema = pluginGrantSchema;
-var sandboxEgressCredentialContextSchema = z3.object({
-  credentials: credentialContextSchema,
-  egressId: z3.string().min(1),
-  expiresAtMs: finiteNumberSchema,
-  contextId: z3.string().min(1)
-}).strict();
-var sandboxEgressCredentialLeaseSchema = z3.object({
-  account: pluginProviderAccountSchema.optional(),
-  authorization: pluginAuthorizationSchema.optional(),
-  grant: sandboxEgressGrantSchema,
-  provider: providerNameSchema,
-  expiresAt: z3.string().min(1),
-  headerTransforms: z3.array(pluginCredentialHeaderTransformSchema).min(1)
-}).strict();
-var sandboxEgressAuthRequiredSignalSchema = z3.object({
-  authorization: pluginAuthorizationSchema.optional(),
-  grant: sandboxEgressGrantSchema,
-  kind: credentialSignalKindSchema.default("auth_required"),
-  provider: providerNameSchema,
-  message: z3.string().optional(),
-  createdAtMs: finiteNumberSchema
-}).strict().superRefine((signal, ctx) => {
-  if (signal.authorization && signal.authorization.provider !== signal.provider) {
-    ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
-      message: "Auth signal authorization provider must match provider",
-      path: ["authorization", "provider"]
-    });
-  }
-});
-var sandboxEgressPermissionDeniedSignalSchema = z3.object({
-  account: pluginProviderAccountSchema.optional(),
-  acceptedPermissions: z3.string().optional(),
-  grant: sandboxEgressGrantSchema,
-  message: z3.string().min(1),
-  provider: providerNameSchema,
-  source: z3.literal("upstream"),
-  sso: z3.string().optional(),
-  status: httpStatusSchema,
-  upstreamHost: z3.string().min(1),
-  upstreamPath: z3.string().min(1),
-  createdAtMs: finiteNumberSchema
-}).strict();
-function parseSandboxEgressAuthRequiredSignal(value) {
-  const result = sandboxEgressAuthRequiredSignalSchema.safeParse(value);
-  return result.success ? result.data : void 0;
-}
-function parseSandboxEgressPermissionDeniedSignal(value) {
-  const result = sandboxEgressPermissionDeniedSignalSchema.safeParse(value);
-  return result.success ? result.data : void 0;
+// src/chat/sandbox/command-result.ts
+function formatSandboxCommandResult(params) {
+  return makeStructuredToolResult({
+    ok: params.ok,
+    status: params.ok ? "success" : "error",
+    target: params.command,
+    data: {
+      command: params.command,
+      cwd: params.cwd,
+      exit_code: params.exit_code,
+      signal: params.signal,
+      timed_out: params.timed_out,
+      aborted: Boolean(params.aborted),
+      stdout: params.stdout,
+      stderr: params.stderr,
+      stdout_truncated: params.stdout_truncated,
+      stderr_truncated: params.stderr_truncated
+    },
+    truncated: params.stdout_truncated || params.stderr_truncated,
+    ...!params.ok ? {
+      error: {
+        kind: params.aborted ? "outcome_unknown" : params.timed_out ? "timeout" : "nonzero_exit",
+        message: params.aborted ? "Command was interrupted before its outcome was confirmed. It may have produced side effects; reconcile external state before retrying or reporting failure." : params.stderr.trim() || `Command exited with code ${params.exit_code}`,
+        retryable: params.timed_out
+      }
+    } : {},
+    command: params.command,
+    cwd: params.cwd,
+    exit_code: params.exit_code,
+    signal: params.signal,
+    timed_out: params.timed_out,
+    aborted: Boolean(params.aborted),
+    stdout: params.stdout,
+    stderr: params.stderr,
+    stdout_truncated: params.stdout_truncated,
+    stderr_truncated: params.stderr_truncated,
+    ...params.auth_required ? { auth_required: params.auth_required } : {},
+    ...params.permission_denied ? { permission_denied: params.permission_denied } : {}
+  });
 }
 
+// src/chat/sandbox/sandbox.ts
+import fs4 from "fs/promises";
+
 // src/chat/sandbox/egress/session.ts
+import { createHmac, randomUUID, timingSafeEqual } from "crypto";
 var SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
 var SANDBOX_EGRESS_TOKEN_VERSION = "v1";
 var SANDBOX_EGRESS_HMAC_CONTEXT = "junior.sandbox_egress.v1";
@@ -5321,10 +4178,10 @@ function validateAndApplyTextEdits(content, edits, targetName) {
 }
 
 // src/chat/tools/sandbox/edit-file.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/chat/tool-support/zod-tool.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 function isContentOnlyToolResult(value) {
   return value !== null && typeof value === "object" && Array.isArray(value.content) && !("details" in value);
 }
@@ -5348,7 +4205,7 @@ function zodTool(definition) {
   const { inputSchema, outputSchema, prepareArguments, execute, ...toolDef } = definition;
   let modelInputSchema;
   try {
-    modelInputSchema = z4.toJSONSchema(inputSchema);
+    modelInputSchema = z3.toJSONSchema(inputSchema);
   } catch (error) {
     throw new TypeError(
       "zodTool() inputSchema must be representable as JSON Schema.",
@@ -5358,7 +4215,7 @@ function zodTool(definition) {
   let modelOutputSchema;
   if (outputSchema) {
     try {
-      modelOutputSchema = z4.toJSONSchema(outputSchema);
+      modelOutputSchema = z3.toJSONSchema(outputSchema);
     } catch (error) {
       throw new TypeError(
         "zodTool() outputSchema must be representable as JSON Schema.",
@@ -5494,20 +4351,20 @@ async function editFile(params) {
     truncated: diff.truncated
   });
 }
-var editReplacementSchema = z5.object({
-  oldText: z5.string().min(1).describe(
+var editReplacementSchema = z4.object({
+  oldText: z4.string().min(1).describe(
     "Exact text to replace. It must be unique in the original file and must not overlap another edit."
   ),
-  newText: z5.string().describe("Replacement text for this edit.")
+  newText: z4.string().describe("Replacement text for this edit.")
 });
 function createEditFileTool() {
   return zodTool({
     description: "Edit one sandbox workspace file with exact text replacements. Use for precise changes to existing files; prefer this over writeFile for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same file: use one edits[] call.",
     prepareArguments: prepareEditFileArguments,
     executionMode: "sequential",
-    inputSchema: z5.object({
-      path: z5.string().min(1).describe("Path to edit in the sandbox workspace."),
-      edits: z5.array(editReplacementSchema).min(1).describe(
+    inputSchema: z4.object({
+      path: z4.string().min(1).describe("Path to edit in the sandbox workspace."),
+      edits: z4.array(editReplacementSchema).min(1).describe(
         "Exact replacements matched against the original file, not incrementally."
       )
     }),
@@ -5522,7 +4379,7 @@ function createEditFileTool() {
 
 // src/chat/tools/sandbox/find-files.ts
 import path5 from "path";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var DEFAULT_FIND_LIMIT = 1e3;
 async function findFiles(params) {
   if (!params.pattern.trim()) {
@@ -5582,14 +4439,14 @@ function createFindFilesTool() {
   return zodTool({
     description: "Find sandbox workspace files by glob pattern. Returns bounded paths relative to the search root and skips dependency/cache directories.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z6.object({
-      pattern: z6.string().min(1).describe(
+    inputSchema: z5.object({
+      pattern: z5.string().min(1).describe(
         "Glob pattern to match, for example '*.ts', '**/*.json', or 'src/**/*.test.ts'."
       ),
-      path: z6.string().min(1).describe(
+      path: z5.string().min(1).describe(
         "Directory or file path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z6.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 1000.").optional()
+      limit: z5.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 1000.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -5602,12 +4459,12 @@ function createFindFilesTool() {
 
 // src/chat/tools/sandbox/grep.ts
 import path6 from "path";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var DEFAULT_GREP_LIMIT = 100;
 var MAX_GREP_LINE_CHARS = 500;
-var booleanInput = (description) => z7.preprocess(
+var booleanInput = (description) => z6.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z7.boolean()
+  z6.boolean()
 ).describe(description);
 function truncateGrepLine(value) {
   if (value.length <= MAX_GREP_LINE_CHARS) {
@@ -5756,20 +4613,20 @@ function createGrepTool() {
   return zodTool({
     description: "Search sandbox workspace file contents. Returns bounded matching lines with file paths and line numbers. Respects path/glob filters and includes truncation notices.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z7.object({
-      pattern: z7.string().min(1).describe("Regex pattern or literal text to search for."),
-      path: z7.string().min(1).describe(
+    inputSchema: z6.object({
+      pattern: z6.string().min(1).describe("Regex pattern or literal text to search for."),
+      path: z6.string().min(1).describe(
         "Directory or file path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      glob: z7.string().min(1).describe("Optional glob filter such as '*.ts' or '**/*.test.ts'.").optional(),
+      glob: z6.string().min(1).describe("Optional glob filter such as '*.ts' or '**/*.test.ts'.").optional(),
       ignoreCase: booleanInput(
         "Whether matching should ignore case."
       ).optional(),
       literal: booleanInput(
         "Treat pattern as literal text instead of regex."
       ).optional(),
-      context: z7.coerce.number().int().min(0).describe("Number of surrounding context lines to include.").optional(),
-      limit: z7.coerce.number().int().min(1).describe("Maximum matches to return. Defaults to 100.").optional()
+      context: z6.coerce.number().int().min(0).describe("Number of surrounding context lines to include.").optional(),
+      limit: z6.coerce.number().int().min(1).describe("Maximum matches to return. Defaults to 100.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -5780,7 +4637,7 @@ function createGrepTool() {
 
 // src/chat/tools/sandbox/list-dir.ts
 import path7 from "path";
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
   const dirPath = resolveWorkspacePath(params.path);
@@ -5861,11 +4718,11 @@ function createListDirTool() {
   return zodTool({
     description: "List a sandbox workspace directory. Returns sorted entries with '/' suffixes for directories and bounded truncation notices.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z8.object({
-      path: z8.string().min(1).describe(
+    inputSchema: z7.object({
+      path: z7.string().min(1).describe(
         "Directory path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z8.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
+      limit: z7.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -5877,7 +4734,7 @@ function createListDirTool() {
 }
 
 // src/chat/tools/sandbox/read-file.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // src/chat/tool-support/text-range-result.ts
 var DEFAULT_READ_LIMIT = 1e3;
@@ -5952,10 +4809,10 @@ function createReadFileTool() {
   return zodTool({
     description: "Read a bounded line range from a file in the sandbox workspace. Use when you need exact file contents to verify facts or make edits safely. Prefer grep/findFiles/listDir for broad discovery.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z9.object({
-      path: z9.string().min(1).describe("Path to the file in the sandbox workspace."),
-      offset: z9.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z9.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+    inputSchema: z8.object({
+      path: z8.string().min(1).describe("Path to the file in the sandbox workspace."),
+      offset: z8.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z8.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -6020,6 +4877,30 @@ function createSandbox(options) {
     });
     return token;
   };
+  const clearEgressSignals = async (egressId) => {
+    if (!options.egressSignals) {
+      await clearSandboxEgressSignals(egressId);
+      return;
+    }
+    await options.egressSignals.clear(
+      sandboxEgressCredentialTokenFor(egressId)
+    );
+  };
+  const consumeEgressSignals = async (egressId) => {
+    if (options.egressSignals) {
+      return await options.egressSignals.consume(
+        sandboxEgressCredentialTokenFor(egressId)
+      );
+    }
+    const [authRequired, permissionDenied] = await Promise.all([
+      consumeSandboxEgressAuthRequiredSignal(egressId),
+      consumeSandboxEgressPermissionDeniedSignal(egressId)
+    ]);
+    return {
+      ...authRequired ? { authRequired } : {},
+      ...permissionDenied ? { permissionDenied } : {}
+    };
+  };
   const runtime = createSandboxRuntime({
     sandboxRef: options.sandboxRef,
     skills: options.skills,
@@ -6063,7 +4944,7 @@ function createSandbox(options) {
       "app.sandbox.command_length": command.length
     });
     const { bash: executeBash, sessionId: activeSessionId } = await runtime.tools();
-    await clearSandboxEgressSignals(activeSessionId);
+    await clearEgressSignals(activeSessionId);
     const result = await withSandboxToolSpan(
       "bash",
       "process.exec",
@@ -6101,8 +4982,7 @@ function createSandbox(options) {
         }
       }
     );
-    const authRequired = await consumeSandboxEgressAuthRequiredSignal(activeSessionId);
-    const permissionDenied = await consumeSandboxEgressPermissionDeniedSignal(activeSessionId);
+    const { authRequired, permissionDenied } = await consumeEgressSignals(activeSessionId);
     return formatSandboxCommandResult({
       ok: result.exitCode === 0,
       command,
@@ -6421,25 +5301,25 @@ function createSandbox(options) {
 
 // src/chat/tools/sandbox/file-uploads.ts
 import path8 from "path";
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var MAX_SANDBOX_FILE_UPLOAD_BYTES = 10 * 1024 * 1024;
 var SANDBOX_ARTIFACTS_DIR = "/tmp/junior/artifacts";
-var sandboxFileReferenceSchema = z10.object({
-  path: z10.string().min(1).describe(
+var sandboxFileReferenceSchema = z9.object({
+  path: z9.string().min(1).describe(
     "Exact source path of an existing sandbox file. Preserve paths returned by other tools unchanged; do not move or rewrite them before sending."
   ),
-  filename: z10.string().min(1).nullable().optional().describe(
+  filename: z9.string().min(1).nullable().optional().describe(
     "Optional filename override shown to the recipient. Null is treated as omitted."
   ),
-  mimeType: z10.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted."),
-  bytes: z10.number().int().nonnegative().nullable().optional().describe(
+  mimeType: z9.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted."),
+  bytes: z9.number().int().nonnegative().nullable().optional().describe(
     "Optional known file size returned by a producing tool. Null is treated as omitted; sending tools validate the file contents directly."
   )
 });
 var generatedArtifactFileRefSchema = sandboxFileReferenceSchema.extend({
-  filename: z10.string().min(1),
-  mimeType: z10.string().min(1).optional(),
-  bytes: z10.number().int().nonnegative()
+  filename: z9.string().min(1),
+  mimeType: z9.string().min(1).optional(),
+  bytes: z9.number().int().nonnegative()
 }).strict();
 var MIME_BY_EXTENSION = {
   ".png": "image/png",
@@ -6603,6 +5483,7 @@ function createAgentSandbox(options) {
     referenceFiles: listReferenceFiles(),
     traceContext: options.traceContext,
     tracePropagation: options.tracePropagation,
+    egressSignals: options.egressSignals,
     credentialEgress: options.credentialEgress,
     prepare: options.prepareSandbox,
     onSandboxRefChanged: async (sandboxRef) => {
@@ -7342,13 +6223,13 @@ function serializeMcpPayload(payload, privacy, options = {}) {
 }
 
 // src/chat/tools/sandbox/bash.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 function createBashTool2() {
   return zodTool({
     description: "Run a bash command inside the isolated sandbox workspace. Use this for repository inspection/execution tasks that need shell access. Do not use for network-sensitive or destructive actions unless explicitly required.",
-    inputSchema: z11.object({
-      command: z11.string().min(1).describe("Bash command to run inside the sandbox."),
-      timeoutMs: z11.coerce.number().int().min(1e3).describe(
+    inputSchema: z10.object({
+      command: z10.string().min(1).describe("Bash command to run inside the sandbox."),
+      timeoutMs: z10.coerce.number().int().min(1e3).describe(
         "Optional command timeout in milliseconds. Use for commands that may hang."
       ).optional()
     }),
@@ -7362,14 +6243,14 @@ function createBashTool2() {
 }
 
 // src/chat/tools/web/image-generate.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 var imageGenerateOutputSchema = juniorToolResultSchema.extend({
-  model: z12.string(),
-  prompt: z12.string(),
-  enrichedPrompt: z12.string(),
-  image_count: z12.number().int().nonnegative(),
-  images: z12.array(generatedArtifactFileRefSchema),
-  delivery: z12.string()
+  model: z11.string(),
+  prompt: z11.string(),
+  enrichedPrompt: z11.string(),
+  image_count: z11.number().int().nonnegative(),
+  images: z11.array(generatedArtifactFileRefSchema),
+  delivery: z11.string()
 }).strict();
 var ENRICHMENT_SYSTEM_PROMPT = `You are an image prompt enrichment agent. Your job is to rewrite image generation requests to reflect a specific visual identity and mood.
 
@@ -7430,8 +6311,8 @@ function parseImageGenerationError(status, body, model) {
 function createImageGenerateTool(hooks, options, deps = {}) {
   return zodTool({
     description: "Generate images from a prompt. Use when the user wants to visually show or represent something \u2014 feelings, concepts, art, humor, or any visual idea. Also use for explicit image creation requests.",
-    inputSchema: z12.object({
-      prompt: z12.string().min(1).max(4e3).describe("Image generation prompt.")
+    inputSchema: z11.object({
+      prompt: z11.string().min(1).max(4e3).describe("Image generation prompt.")
     }),
     outputSchema: imageGenerateOutputSchema,
     execute: async ({ prompt }) => {
@@ -7517,7 +6398,7 @@ function createImageGenerateTool(hooks, options, deps = {}) {
 }
 
 // src/chat/tools/skill/call-mcp-tool.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 function resolveMcpArguments(input) {
   const extraKeys = Object.keys(input).filter(
     (key) => key !== "tool_name" && key !== "arguments"
@@ -7553,9 +6434,9 @@ function missingToolMessage(toolName, provider) {
 function createCallMcpToolTool(mcpToolManager) {
   return zodTool({
     description: "Call an active MCP tool by exact tool_name. Use searchMcpTools to discover tool names and schemas; copy required provider fields into arguments. Do not call with only tool_name unless the discovered tool has no arguments. Authorization is handled by the runtime when required.",
-    inputSchema: z13.object({
-      tool_name: z13.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
-      arguments: z13.record(z13.string(), z13.unknown()).describe(
+    inputSchema: z12.object({
+      tool_name: z12.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
+      arguments: z12.record(z12.string(), z12.unknown()).describe(
         'Arguments matching the disclosed MCP tool schema, for example { "query": "..." } when searchMcpTools shows query is required.'
       ).optional()
     }).passthrough(),
@@ -7596,7 +6477,7 @@ function createCallMcpToolTool(mcpToolManager) {
 }
 
 // src/chat/tools/skill/load-skill.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 function toLoadedSkill(result, availableSkills) {
   if (result.ok !== true || typeof result.skill_name !== "string" || typeof result.description !== "string" || typeof result.skill_dir !== "string" || typeof result.instructions !== "string") {
     return null;
@@ -7645,8 +6526,8 @@ async function loadSkillFromHost(availableSkills, skillName) {
 function createLoadSkillTool(availableSkills, options) {
   return zodTool({
     description: "Load a skill by name for this turn. The result includes working_directory; resolve skill paths there and run skill-owned bash commands from there or with absolute paths. When the result includes mcp_provider, use searchMcpTools before callMcpTool. Use when a request clearly matches a known skill.",
-    inputSchema: z14.object({
-      skill_name: z14.string().min(1).describe("Skill name to load, without the leading slash.")
+    inputSchema: z13.object({
+      skill_name: z13.string().min(1).describe("Skill name to load, without the leading slash.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ skill_name }) => {
@@ -7664,7 +6545,7 @@ function createLoadSkillTool(availableSkills, options) {
 }
 
 // src/chat/tools/skill/search-mcp-tools.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 
 // src/chat/tool-support/schema-summary.ts
 function getSchemaProperties(schema) {
@@ -7794,37 +6675,37 @@ function toActiveMcpCatalogSummaries(toolDefs) {
 // src/chat/tools/skill/search-mcp-tools.ts
 var DEFAULT_MAX_RESULTS = 5;
 var MAX_RESULTS = 20;
-var providerSummarySchema = z15.object({
-  provider: z15.string(),
-  description: z15.string(),
-  active: z15.boolean()
+var providerSummarySchema = z14.object({
+  provider: z14.string(),
+  description: z14.string(),
+  active: z14.boolean()
 }).strict();
-var mcpCallExampleSchema = z15.object({
-  tool_name: z15.string(),
-  arguments: z15.record(z15.string(), z15.string())
+var mcpCallExampleSchema = z14.object({
+  tool_name: z14.string(),
+  arguments: z14.record(z14.string(), z14.string())
 }).strict();
-var exposedToolSummarySchema = z15.object({
-  tool_name: z15.string(),
-  mcp_tool_name: z15.string(),
-  provider: z15.string(),
-  title: z15.string().optional(),
-  description: z15.string(),
-  signature: z15.string(),
+var exposedToolSummarySchema = z14.object({
+  tool_name: z14.string(),
+  mcp_tool_name: z14.string(),
+  provider: z14.string(),
+  title: z14.string().optional(),
+  description: z14.string(),
+  signature: z14.string(),
   call: mcpCallExampleSchema,
-  input_schema: z15.record(z15.string(), z15.unknown()),
-  input_schema_summary: z15.string(),
-  output_schema: z15.record(z15.string(), z15.unknown()).optional(),
-  annotations: z15.record(z15.string(), z15.unknown()).optional()
+  input_schema: z14.record(z14.string(), z14.unknown()),
+  input_schema_summary: z14.string(),
+  output_schema: z14.record(z14.string(), z14.unknown()).optional(),
+  annotations: z14.record(z14.string(), z14.unknown()).optional()
 }).strict();
 var searchMcpToolsOutputSchema = juniorToolResultSchema.extend({
-  query: z15.string().nullable(),
-  provider: z15.string().nullable(),
-  total_active_tools: z15.number().int().nonnegative(),
-  returned_tools: z15.number().int().nonnegative(),
-  execution_tool: z15.literal("callMcpTool"),
+  query: z14.string().nullable(),
+  provider: z14.string().nullable(),
+  total_active_tools: z14.number().int().nonnegative(),
+  returned_tools: z14.number().int().nonnegative(),
+  execution_tool: z14.literal("callMcpTool"),
   execution_example: mcpCallExampleSchema,
-  available_providers: z15.array(providerSummarySchema),
-  tools: z15.array(exposedToolSummarySchema)
+  available_providers: z14.array(providerSummarySchema),
+  tools: z14.array(exposedToolSummarySchema)
 }).strict();
 function normalize(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -7944,14 +6825,14 @@ function searchProviderCatalog(providers, query) {
 function createSearchMcpToolsTool(mcpToolManager) {
   return zodTool({
     description: "List or search MCP providers and active MCP tools. When provider is supplied and not yet active, Junior connects to it on demand and returns tool descriptors including schemas. Without provider, returns active tools plus matching configured providers without connecting. Use when choosing a provider tool or when callMcpTool arguments are unclear.",
-    inputSchema: z15.object({
-      query: z15.string().min(1).describe(
+    inputSchema: z14.object({
+      query: z14.string().min(1).describe(
         "Optional search terms describing the MCP tool or arguments needed."
       ).optional(),
-      provider: z15.string().min(1).describe(
+      provider: z14.string().min(1).describe(
         "Optional provider name to list or search within. If configured but not yet connected, Junior activates it on demand."
       ).optional(),
-      max_results: z15.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
+      max_results: z14.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchMcpToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -8006,12 +6887,12 @@ function createSearchMcpToolsTool(mcpToolManager) {
 }
 
 // src/chat/tools/runtime/report-progress.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 function createReportProgressTool() {
   return zodTool({
     description: "Update the user-visible assistant loading message with a short progress phase. For every non-trivial turn, call this early with the initial major work phase, then call it again only when the major phase meaningfully changes. Messages must be written in sentence case with a present-participle verb (e.g. 'Searching docs', 'Reviewing results', 'Running checks'). Skip trivial direct answers, generic filler, and minor substeps.",
-    inputSchema: z16.object({
-      message: z16.string().min(1).describe("Short user-facing progress message.")
+    inputSchema: z15.object({
+      message: z15.string().min(1).describe("Short user-facing progress message.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => ({
@@ -8022,34 +6903,34 @@ function createReportProgressTool() {
 }
 
 // src/chat/tools/resource-events.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 
 // src/chat/resource-events/store.ts
 import { createHash } from "crypto";
 import { destinationSchema } from "@sentry/junior-plugin-api";
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription";
 var INDEX_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
 var SUBSCRIPTION_LOCK_RETRY_MS = 25;
 var SUBSCRIPTION_LOCK_HEARTBEAT_MS = 3e3;
-var subscriptionStatusSchema = z17.enum(["active", "cancelled", "completed"]);
-var subscriptionIdIndexSchema = z17.array(z17.string().min(1));
-var subscriptionSchema = z17.object({
-  conversationId: z17.string().min(1),
-  createdAtMs: z17.number().finite(),
+var subscriptionStatusSchema = z16.enum(["active", "cancelled", "completed"]);
+var subscriptionIdIndexSchema = z16.array(z16.string().min(1));
+var subscriptionSchema = z16.object({
+  conversationId: z16.string().min(1),
+  createdAtMs: z16.number().finite(),
   destination: destinationSchema,
-  events: z17.array(z17.string().min(1)).min(1),
-  expiresAtMs: z17.number().finite(),
-  id: z17.string().min(1),
-  intent: z17.string().min(1),
-  label: z17.string().min(1),
-  provider: z17.string().min(1),
-  resourceRef: z17.string().min(1),
-  resourceType: z17.string().min(1),
+  events: z16.array(z16.string().min(1)).min(1),
+  expiresAtMs: z16.number().finite(),
+  id: z16.string().min(1),
+  intent: z16.string().min(1),
+  label: z16.string().min(1),
+  provider: z16.string().min(1),
+  resourceRef: z16.string().min(1),
+  resourceType: z16.string().min(1),
   status: subscriptionStatusSchema,
-  updatedAtMs: z17.number().finite()
+  updatedAtMs: z16.number().finite()
 }).strict();
 function digest(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 32);
@@ -8405,18 +7286,18 @@ var RESOURCE_WATCH_TOOL_SOURCE = {
   id: "resource-watches",
   description: "Inspect or stop resource watches for the current conversation."
 };
-var subscribeInputSchema = z18.object({
-  resourceRef: z18.string().describe("Opaque resource ref copied from a subscribable tool result."),
-  provider: z18.string().describe("Provider that owns the resource ref."),
-  resourceType: z18.string().describe("Provider-defined resource type from the subscribable hint."),
-  label: z18.string().describe("Human-readable resource label from the subscribable hint."),
-  events: z18.array(z18.string()).min(1).describe(
+var subscribeInputSchema = z17.object({
+  resourceRef: z17.string().describe("Opaque resource ref copied from a subscribable tool result."),
+  provider: z17.string().describe("Provider that owns the resource ref."),
+  resourceType: z17.string().describe("Provider-defined resource type from the subscribable hint."),
+  label: z17.string().describe("Human-readable resource label from the subscribable hint."),
+  events: z17.array(z17.string()).min(1).describe(
     "High-signal event names to deliver to this conversation when they occur."
   ),
-  intent: z18.string().describe(
+  intent: z17.string().describe(
     "Concise reason this conversation wants these events, used when an event arrives."
   ),
-  ttlMs: z18.coerce.number().describe(
+  ttlMs: z17.coerce.number().describe(
     "How long to keep the subscription active. Defaults to 14 days and is capped at 30 days."
   ).optional()
 });
@@ -8509,7 +7390,7 @@ function createListResourceEventSubscriptionsTool(context) {
     description: "List active resource event subscriptions for the current conversation.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z18.object({}),
+    inputSchema: z17.object({}),
     outputSchema: juniorToolResultSchema,
     async execute() {
       const conversationId = requireConversationContext(context);
@@ -8542,7 +7423,7 @@ function createStopWatchingResourcesTool(context) {
     description: "Stop every resource watch for the current conversation. Infer the user's intent from context instead of requiring a special command, and call this tool before confirming that watching stopped.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z18.object({}),
+    inputSchema: z17.object({}),
     outputSchema: juniorToolResultSchema,
     async execute() {
       const conversationId = requireConversationContext(context);
@@ -8649,11 +7530,11 @@ async function listThreadReplies(input) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 function slackTimestampParam(description) {
-  return z19.preprocess(
+  return z18.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z19.string().min(1)
+    z18.string().min(1)
   ).describe(description);
 }
 function optionalSlackTimestampParam(description) {
@@ -8684,10 +7565,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z20 } from "zod";
-var booleanInput2 = (description) => z20.preprocess(
+import { z as z19 } from "zod";
+var booleanInput2 = (description) => z19.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z20.boolean()
+  z19.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -8714,9 +7595,9 @@ function createSlackChannelListMessagesTool(context) {
   return zodTool({
     description: "List channel messages from Slack history in the active channel context. Use when the user asks for recent or historical channel context outside this thread. Do not use for live monitoring or when current thread context already answers the question.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z20.object({
-      limit: z20.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z20.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+    inputSchema: z19.object({
+      limit: z19.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z19.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: optionalSlackTimestampParam(
         "Optional oldest message timestamp (Slack ts) for range filtering."
       ),
@@ -8726,7 +7607,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z20.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z19.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({
@@ -8800,20 +7681,20 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-search.ts
-import { z as z21 } from "zod";
+import { z as z20 } from "zod";
 var DEFAULT_LIMIT = 5;
 var conversationSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z21.string(),
-  count: z21.number().int().nonnegative(),
-  threads: z21.array(
-    z21.object({
-      conversation_id: z21.string().min(1),
-      thread_ts: z21.string().min(1),
-      message_id: z21.string().min(1),
-      message_role: z21.enum(["assistant", "user"]),
-      message_timestamp: z21.string().datetime(),
-      excerpt: z21.string(),
-      permalink: z21.string().url().optional()
+  query: z20.string(),
+  count: z20.number().int().nonnegative(),
+  threads: z20.array(
+    z20.object({
+      conversation_id: z20.string().min(1),
+      thread_ts: z20.string().min(1),
+      message_id: z20.string().min(1),
+      message_role: z20.enum(["assistant", "user"]),
+      message_timestamp: z20.string().datetime(),
+      excerpt: z20.string(),
+      permalink: z20.string().url().optional()
     }).strict()
   )
 });
@@ -8826,9 +7707,9 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
       description: "Search retained public Junior conversation threads in the current Slack workspace."
     },
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z21.object({
-      query: z21.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
-      limit: z21.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
+    inputSchema: z20.object({
+      query: z20.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
+      limit: z20.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
     }),
     outputSchema: conversationSearchOutputSchema,
     execute: async ({ query, limit }) => {
@@ -8875,27 +7756,27 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 var DEFAULT_LIMIT2 = 10;
-var optionalTimestampSchema = z22.preprocess(
+var optionalTimestampSchema = z21.preprocess(
   (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z22.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
+  z21.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
 );
-var searchMessageSchema = z22.object({
-  author_name: z22.string().optional(),
-  author_user_id: z22.string().optional(),
-  channel_id: z22.string().min(1),
-  channel_name: z22.string().optional(),
-  message_ts: z22.string().min(1),
-  content: z22.string(),
-  is_author_bot: z22.boolean().optional(),
-  permalink: z22.string().url()
+var searchMessageSchema = z21.object({
+  author_name: z21.string().optional(),
+  author_user_id: z21.string().optional(),
+  channel_id: z21.string().min(1),
+  channel_name: z21.string().optional(),
+  message_ts: z21.string().min(1),
+  content: z21.string(),
+  is_author_bot: z21.boolean().optional(),
+  permalink: z21.string().url()
 });
 var publicSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z22.string(),
-  count: z22.number().int().nonnegative(),
-  messages: z22.array(searchMessageSchema),
-  next_cursor: z22.string().optional()
+  query: z21.string(),
+  count: z21.number().int().nonnegative(),
+  messages: z21.array(searchMessageSchema),
+  next_cursor: z21.string().optional()
 });
 function normalizeMessage(value) {
   const parsed = searchMessageSchema.safeParse(value);
@@ -8917,8 +7798,8 @@ function createSlackPublicSearchTool(actionToken) {
   return zodTool({
     description: "Search public Slack channel messages across the current workspace. Use when the user asks about company activity, announcements, public mentions, or context outside the active channel. Search only when requested or clearly needed, prefer focused keywords and time bounds, and cite returned permalinks. This never searches private channels or DMs.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z22.object({
-      query: z22.string().trim().min(1).max(500).describe(
+    inputSchema: z21.object({
+      query: z21.string().trim().min(1).max(500).describe(
         "A focused Slack search query, including Slack search filters when useful."
       ),
       after: optionalTimestampSchema.describe(
@@ -8927,10 +7808,10 @@ function createSlackPublicSearchTool(actionToken) {
       before: optionalTimestampSchema.describe(
         "Optional Unix timestamp upper bound."
       ),
-      cursor: z22.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z22.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z22.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z22.enum(["asc", "desc"]).describe("Sort direction.").optional()
+      cursor: z21.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z21.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z21.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z21.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -8996,7 +7877,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z23 } from "zod";
+import { z as z22 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -9020,8 +7901,8 @@ function createOperationKey(toolName, input) {
 function createSlackMessageAddReactionTool(context, state) {
   return zodTool({
     description: "Add an emoji reaction to the current inbound Slack message. Use when the user asks for a reaction on the current message without another target. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
-    inputSchema: z23.object({
-      emoji: z23.string().min(1).max(64).describe(
+    inputSchema: z22.object({
+      emoji: z22.string().min(1).max(64).describe(
         "Slack emoji alias name to react with (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`). Optional surrounding colons are allowed."
       )
     }),
@@ -9072,18 +7953,18 @@ function createSlackMessageAddReactionTool(context, state) {
 
 // src/chat/slack/tools/send-files.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z24 } from "zod";
-var sendFilesDataSchema = z24.object({
-  channel_id: z24.string().min(1),
-  deduplicated: z24.boolean().optional(),
-  file_count: z24.number().int().nonnegative(),
-  file_ids: z24.array(z24.string().min(1)).optional(),
-  thread_ts: z24.string().min(1)
+import { z as z23 } from "zod";
+var sendFilesDataSchema = z23.object({
+  channel_id: z23.string().min(1),
+  deduplicated: z23.boolean().optional(),
+  file_count: z23.number().int().nonnegative(),
+  file_ids: z23.array(z23.string().min(1)).optional(),
+  thread_ts: z23.string().min(1)
 });
 var sendFilesResultSchema = juniorToolResultSchema.extend({
-  ok: z24.literal(true),
-  status: z24.literal("success"),
-  target: z24.string().min(1),
+  ok: z23.literal(true),
+  status: z23.literal("success"),
+  target: z23.string().min(1),
   data: sendFilesDataSchema
 });
 function normalizeFiles(files) {
@@ -9108,8 +7989,8 @@ function fileOperationInput(files) {
 function createSendFilesTool(context, state, materializeFile) {
   return zodTool({
     description: "Send one or more sandbox files into the active Slack conversation. Use when the user asks to attach, send, or share files here, in this conversation, or in this thread. Do not use for ordinary assistant text, top-level channel posts, other named channels, inline @mentions, or pinging mentioned users.",
-    inputSchema: z24.object({
-      files: z24.array(sandboxFileReferenceSchema).min(1).describe(
+    inputSchema: z23.object({
+      files: z23.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -9413,13 +8294,13 @@ function storedCanvasUrl(state, canvasId) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, reply with one or two short sentences plus the canvas link; do not recap the canvas contents. Do not use for short answers that fit cleanly in one normal thread reply.",
-    inputSchema: z25.object({
-      title: z25.string().min(1).max(160).describe("Canvas title."),
-      markdown: z25.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z24.object({
+      title: z24.string().min(1).max(160).describe("Canvas title."),
+      markdown: z24.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ title, markdown }) => {
@@ -9482,35 +8363,35 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z26.object({
-  oldText: z26.string().min(1).describe(
+var editReplacementSchema2 = z25.object({
+  oldText: z25.string().min(1).describe(
     "Exact Canvas markdown to replace. It must be unique in the current Canvas body and must not overlap another edit."
   ),
-  newText: z26.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z25.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z26.string().optional(),
-  title: z26.string().optional(),
-  permalink: z26.string().optional(),
-  diff: z26.string().optional(),
-  first_changed_line: z26.number().int().positive().optional(),
-  replacements: z26.number().int().nonnegative().optional(),
-  normalized_heading_count: z26.number().int().nonnegative().optional(),
-  summary: z26.string().optional(),
-  deduplicated: z26.boolean().optional()
+  canvas_id: z25.string().optional(),
+  title: z25.string().optional(),
+  permalink: z25.string().optional(),
+  diff: z25.string().optional(),
+  first_changed_line: z25.number().int().positive().optional(),
+  replacements: z25.number().int().nonnegative().optional(),
+  normalized_heading_count: z25.number().int().nonnegative().optional(),
+  summary: z25.string().optional(),
+  deduplicated: z25.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
     description: "Edit one Slack canvas with exact markdown replacements. Use for precise changes to existing Canvas content; prefer this over slackCanvasWrite for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same canvas: use one edits[] call.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: z26.object({
-      canvas: z26.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      edits: z26.array(editReplacementSchema2).min(1).describe(
+    inputSchema: z25.object({
+      canvas: z25.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      edits: z25.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -9588,29 +8469,29 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z27 } from "zod";
+import { z as z26 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z27.string().optional(),
-  title: z27.string().optional(),
-  permalink: z27.string().optional(),
-  mimetype: z27.string().optional(),
-  filetype: z27.string().optional(),
-  original_byte_length: z27.number().int().nonnegative().optional(),
-  content: z27.string().optional(),
-  start_line: z27.number().int().positive().optional(),
-  end_line: z27.number().int().nonnegative().optional(),
-  total_lines: z27.number().int().nonnegative().optional()
+  canvas_id: z26.string().optional(),
+  title: z26.string().optional(),
+  permalink: z26.string().optional(),
+  mimetype: z26.string().optional(),
+  filetype: z26.string().optional(),
+  original_byte_length: z26.number().int().nonnegative().optional(),
+  content: z26.string().optional(),
+  start_line: z26.number().int().positive().optional(),
+  end_line: z26.number().int().nonnegative().optional(),
+  total_lines: z26.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
     description: "Read a bounded line range from a Slack canvas as markdown. Use when you need exact Canvas contents to verify facts or make edits safely. Do not use for generic web pages \u2014 use webFetch for those.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z27.object({
-      canvas: z27.string().min(1).describe(
+    inputSchema: z26.object({
+      canvas: z26.string().min(1).describe(
         "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
       ),
-      offset: z27.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z27.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z26.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z26.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -9667,14 +8548,14 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     description: "Write UTF-8 markdown content to a Slack canvas. Use for deliberate full-Canvas replacement after validation; use slackCanvasEdit for targeted changes to existing canvas content.",
     executionMode: "sequential",
-    inputSchema: z28.object({
-      canvas: z28.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      content: z28.string().describe("UTF-8 markdown content to write.")
+    inputSchema: z27.object({
+      canvas: z27.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      content: z27.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ canvas, content }) => {
@@ -9910,12 +8791,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z29 } from "zod";
+import { z as z28 } from "zod";
 function slackChannelIdParam(description) {
-  return z29.string().min(1).describe(description);
+  return z28.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z29.string().min(1).describe(description);
+  return z28.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -9939,16 +8820,16 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     description: "Add tasks to the active Slack list tracked in artifact context. Use when the user wants actionable items recorded in the current thread list. Do not use when no list exists and list creation was not requested.",
-    inputSchema: z30.object({
-      items: z30.array(z30.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    inputSchema: z29.object({
+      items: z29.array(z29.string().min(1)).min(1).max(25).describe("List item titles to create."),
       assignee_user_id: slackUserIdParam(
         "Optional Slack user ID assigned to all created items."
       ).optional(),
-      due_date: z30.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z29.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ items, assignee_user_id, due_date }) => {
@@ -10002,12 +8883,12 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z31 } from "zod";
+import { z as z30 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     description: "Create a Slack todo list for action tracking. Use when the user needs structured tasks with ownership/completion tracking. Do not use for one-off notes without task management needs.",
-    inputSchema: z31.object({
-      name: z31.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z30.object({
+      name: z30.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ name }) => {
@@ -10039,13 +8920,13 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z32 } from "zod";
+import { z as z31 } from "zod";
 function createSlackListGetItemsTool(state) {
   return zodTool({
     description: "Read items from the active Slack list tracked in artifact context. Use when the user asks for task status, open items, or list contents. Do not use when list state is already known from the immediately prior result.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z32.object({
-      limit: z32.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z31.object({
+      limit: z31.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ limit }) => {
@@ -10070,21 +8951,21 @@ function createSlackListGetItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z33 } from "zod";
-var booleanInput3 = (description) => z33.preprocess(
+import { z as z32 } from "zod";
+var booleanInput3 = (description) => z32.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z33.boolean()
+  z32.boolean()
 ).describe(description);
-var updateListItemInputSchema = z33.union([
-  z33.object({
-    item_id: z33.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z32.union([
+  z32.object({
+    item_id: z32.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update."),
-    title: z33.string().min(1).describe("Optional new item title.").optional()
+    title: z32.string().min(1).describe("Optional new item title.").optional()
   }),
-  z33.object({
-    item_id: z33.string().min(1).describe("ID of the Slack list item to update."),
+  z32.object({
+    item_id: z32.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z33.string().min(1).describe("Optional new item title.")
+    title: z32.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -10160,7 +9041,7 @@ async function checkSlackChannelReadAccess(args) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z34 } from "zod";
+import { z as z33 } from "zod";
 
 // src/chat/slack/tools/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -10333,8 +9214,8 @@ function createSlackThreadReadTool(context, deps = {}) {
   return zodTool({
     description: "Read a Slack thread from a shared Slack message archive URL or explicit channel + timestamp. Use when the user shares a Slack message link (https://*.slack.com/archives/...) and you need the referenced message and its thread context. Only the current conversation and public channels Junior has seen in this workspace are readable.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z34.object({
-      url: z34.string().min(1).describe(
+    inputSchema: z33.object({
+      url: z33.string().min(1).describe(
         "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
       ).optional(),
       channel_id: slackChannelIdParam(
@@ -10343,8 +9224,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       ts: slackTimestampParam(
         "Slack message timestamp (e.g. 1700000000.123456). May be the thread root or any message in the thread."
       ).optional(),
-      limit: z34.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z34.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z33.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z33.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, channel_id, ts, limit, max_pages }) => {
@@ -10600,29 +9481,29 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z35 } from "zod";
-var booleanInput4 = (description) => z35.preprocess(
+import { z as z34 } from "zod";
+var booleanInput4 = (description) => z34.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z35.boolean()
+  z34.boolean()
 ).describe(description);
 function createSlackUserLookupTool() {
   return zodTool({
     description: "Look up Slack user profiles by user ID, email, or name search. Use when you need to identify a user, resolve cross-platform identity, or look up profile details like title or status. Returns profile fields including custom fields. For user ID lookup, pass a Slack user ID (e.g. U039RR91S). For search, pass a name query.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z35.object({
+    inputSchema: z34.object({
       user_id: slackUserIdParam(
         "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
       ).optional(),
-      email: z35.string().min(3).describe(
+      email: z34.string().min(3).describe(
         "Email address to look up. Mutually exclusive with user_id and query."
       ).optional(),
-      query: z35.string().min(2).describe(
+      query: z34.string().min(2).describe(
         "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
       ).optional(),
-      limit: z35.coerce.number().int().min(1).max(20).describe(
+      limit: z34.coerce.number().int().min(1).max(20).describe(
         "Maximum number of results to return for name search. Defaults to 10."
       ).optional(),
-      max_pages: z35.coerce.number().int().min(1).max(5).describe(
+      max_pages: z34.coerce.number().int().min(1).max(5).describe(
         "Maximum number of Slack API pages to scan for name search. Defaults to 3."
       ).optional(),
       include_bots: booleanInput4(
@@ -10726,18 +9607,18 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z36 } from "zod";
+import { z as z35 } from "zod";
 var systemTimeOutputSchema = juniorToolResultSchema.extend({
-  unix_ms: z36.number(),
-  iso_utc: z36.string(),
-  iso_local: z36.string(),
-  timezone_offset_minutes: z36.number()
+  unix_ms: z35.number(),
+  iso_utc: z35.string(),
+  iso_local: z35.string(),
+  timezone_offset_minutes: z35.number()
 });
 function createSystemTimeTool() {
   return zodTool({
     description: "Return current system time in UTC and local ISO formats. Use when the user asks for current time/date context. Do not use as a substitute for historical or timezone-conversion research.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z36.object({}),
+    inputSchema: z35.object({}),
     outputSchema: systemTimeOutputSchema,
     privateTraceResult: (result) => ({
       ok: result.ok,
@@ -10766,10 +9647,10 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z37 } from "zod";
+import { z as z36 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z37.enum(handoff.profiles);
+  const profileSchema = z36.enum(handoff.profiles);
   const handoffResultSchema = juniorToolResultSchema.extend({
     model_profile: profileSchema
   });
@@ -10777,7 +9658,7 @@ function createHandoffTool(handoff) {
   return zodTool({
     description: `Switch to another execution profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
     executionMode: "sequential",
-    inputSchema: z37.object({
+    inputSchema: z36.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -10800,7 +9681,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z38 } from "zod";
+import { z as z37 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -11250,9 +10131,9 @@ function createWebFetchTool(hooks, options = {}) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z38.object({
-      url: z38.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z38.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z37.object({
+      url: z37.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z37.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, max_chars }) => {
@@ -11313,7 +10194,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z39 } from "zod";
+import { z as z38 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -11362,9 +10243,9 @@ function createWebSearchTool(modelId, override) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z39.object({
-      query: z39.string().min(1).max(500).describe("Search query."),
-      max_results: z39.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z38.object({
+      query: z38.string().min(1).max(500).describe("Search query."),
+      max_results: z38.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ query, max_results }) => {
@@ -11433,14 +10314,14 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z40 } from "zod";
+import { z as z39 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or deliberate full-file replacement after validation; use editFile instead for targeted changes to existing files. Do not use for exploratory analysis-only turns.",
     executionMode: "sequential",
-    inputSchema: z40.object({
-      path: z40.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z40.string().describe("UTF-8 file content to write.")
+    inputSchema: z39.object({
+      path: z39.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z39.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -11799,11 +10680,11 @@ function replaceGeneratedTextContent(content, text) {
     ...withoutFirstGeneratedTextContent(content)
   ];
 }
-function isRecord4(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function hasContinuation(value) {
-  return isRecord4(value) && isRecord4(value.continuation);
+  return isRecord3(value) && isRecord3(value.continuation);
 }
 function stringField(record, key) {
   const value = record[key];
@@ -11818,7 +10699,7 @@ function stringListField(record, key) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function accountText(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord3(value)) {
     return void 0;
   }
   const label = stringField(value, "label") || stringField(value, "id");
@@ -11829,7 +10710,7 @@ function accountText(value) {
   return id && id !== label ? `${label} (${id})` : label;
 }
 function upstreamPermissionDeniedText(value) {
-  if (!isRecord4(value) || !isRecord4(value.permission_denied)) {
+  if (!isRecord3(value) || !isRecord3(value.permission_denied)) {
     return void 0;
   }
   const signal = value.permission_denied;
@@ -11844,7 +10725,7 @@ function upstreamPermissionDeniedText(value) {
   if (!provider || !message || !upstreamHost || !upstreamPath || !status) {
     return void 0;
   }
-  const grant = isRecord4(signal.grant) ? signal.grant : {};
+  const grant = isRecord3(signal.grant) ? signal.grant : {};
   const grantName = stringField(grant, "name");
   const grantAccess = stringField(grant, "access");
   const grantReason = stringField(grant, "reason");
@@ -11967,9 +10848,6 @@ function pluginAuthRequiredSignal(details) {
     ...parsedSignal.authorization ? { authorization: parsedSignal.authorization } : {}
   };
 }
-function authorizationId(args) {
-  return `${args.sessionId}:${args.kind}:${args.provider}`;
-}
 function createPluginAuthOrchestration(input) {
   let pendingPause;
   const startAuthorizationPause = async (provider, options) => {
@@ -12006,7 +10884,8 @@ function createPluginAuthOrchestration(input) {
         threadTs: input.threadTs,
         ...options?.scope ? { scope: options.scope } : {},
         resumeConversationId: input.conversationId,
-        resumeSessionId: input.sessionId
+        resumeSessionId: input.sessionId,
+        authorization: input.authorization
       });
       if (!oauthResult.ok) {
         throw new Error(oauthResult.error);
@@ -12184,17 +11063,17 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z41 } from "zod";
+import { z as z40 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
     description: "Execute any catalog tool by exact tool_name from searchTools or a tool-result execution hint. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z41.object({
-      tool_name: z41.string().min(1).describe(
+    inputSchema: z40.object({
+      tool_name: z40.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z41.record(z41.string(), z41.unknown()).describe(
+      arguments: z40.record(z40.string(), z40.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -12234,42 +11113,42 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z42 } from "zod";
+import { z as z41 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
-var searchToolsSourceSchema = z42.object({
-  id: z42.string(),
-  description: z42.string()
+var searchToolsSourceSchema = z41.object({
+  id: z41.string(),
+  description: z41.string()
 }).strict();
-var toolCallExampleSchema = z42.object({
-  tool_name: z42.string(),
-  arguments: z42.record(z42.string(), z42.string())
+var toolCallExampleSchema = z41.object({
+  tool_name: z41.string(),
+  arguments: z41.record(z41.string(), z41.string())
 }).strict();
-var searchToolsToolSchema = z42.object({
-  tool_name: z42.string(),
-  description: z42.string(),
-  exposure: z42.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z42.string().optional(),
-  signature: z42.string(),
+var searchToolsToolSchema = z41.object({
+  tool_name: z41.string(),
+  description: z41.string(),
+  exposure: z41.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z41.string().optional(),
+  signature: z41.string(),
   call: toolCallExampleSchema,
-  input_schema: z42.unknown(),
-  input_schema_summary: z42.string(),
-  call_notes: z42.array(z42.string()),
-  annotations: z42.record(z42.string(), z42.unknown())
+  input_schema: z41.unknown(),
+  input_schema_summary: z41.string(),
+  call_notes: z41.array(z41.string()),
+  annotations: z41.record(z41.string(), z41.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolResultSchema.extend({
-  query: z42.string().nullable(),
-  source: z42.string().nullable(),
-  sources: z42.array(searchToolsSourceSchema),
-  total_catalog_tools: z42.number().int().nonnegative(),
-  total_eligible_tools: z42.number().int().nonnegative(),
-  total_matches: z42.number().int().nonnegative(),
-  returned_tools: z42.number().int().nonnegative(),
-  execution_tool: z42.literal("executeTool"),
+  query: z41.string().nullable(),
+  source: z41.string().nullable(),
+  sources: z41.array(searchToolsSourceSchema),
+  total_catalog_tools: z41.number().int().nonnegative(),
+  total_eligible_tools: z41.number().int().nonnegative(),
+  total_matches: z41.number().int().nonnegative(),
+  returned_tools: z41.number().int().nonnegative(),
+  execution_tool: z41.literal("executeTool"),
   execution_example: toolCallExampleSchema,
-  tools: z42.array(searchToolsToolSchema)
+  tools: z41.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -12461,14 +11340,14 @@ function createSearchToolsTool(catalogTools) {
   return zodTool({
     description: renderSearchToolsDescription(knownSources),
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z42.object({
-      query: z42.string().nullable().describe(
+    inputSchema: z41.object({
+      query: z41.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z42.string().nullable().describe(
+      source: z41.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z42.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z41.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -12754,542 +11633,12 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxTools,
   }));
 }
 
-// src/chat/mcp/oauth.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// src/chat/mcp/auth-store.ts
-import {
-  sourceSchema as sourceSchema2
-} from "@sentry/junior-plugin-api";
-var MCP_AUTH_SESSION_PREFIX = "junior:mcp_oauth_attempt:v2";
-var MCP_AUTH_CREDENTIALS_PREFIX = "junior:mcp_auth_credentials";
-var MCP_AUTH_SESSION_INDEX_PREFIX = "junior:mcp_oauth_attempt_index:v2";
-var MCP_SERVER_SESSION_PREFIX = "junior:mcp_server_session";
-var MCP_AUTH_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
-var MCP_AUTH_CREDENTIALS_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var MCP_SERVER_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
-function sessionKey(authSessionId) {
-  return `${MCP_AUTH_SESSION_PREFIX}:${authSessionId}`;
-}
-function credentialsKey(userId, provider) {
-  return `${MCP_AUTH_CREDENTIALS_PREFIX}:${userId}:${provider}`;
-}
-function sessionIndexKey(userId, provider) {
-  return `${MCP_AUTH_SESSION_INDEX_PREFIX}:${userId}:${provider}`;
-}
-function serverSessionKey(userId, provider) {
-  return `${MCP_SERVER_SESSION_PREFIX}:${userId}:${provider}`;
-}
-function parseSessionIndex(value) {
-  if (typeof value !== "string") {
-    return [];
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!Array.isArray(parsed)) {
-      return [];
-    }
-    return [
-      ...new Set(parsed.filter((id) => typeof id === "string"))
-    ];
-  } catch {
-    return [];
-  }
-}
-function parseMcpAuthSession(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(parsed)) {
-      return void 0;
-    }
-    if (parsed.schemaVersion !== 2 || typeof parsed.authSessionId !== "string" || typeof parsed.provider !== "string" || typeof parsed.userId !== "string" || typeof parsed.conversationId !== "string" || typeof parsed.sessionId !== "string" || typeof parsed.userMessage !== "string" || typeof parsed.createdAtMs !== "number" || typeof parsed.updatedAtMs !== "number") {
-      return void 0;
-    }
-    const destination = parsed.destination === void 0 ? void 0 : parseDestination(parsed.destination);
-    if (parsed.destination !== void 0 && !destination) {
-      return void 0;
-    }
-    const source = parsed.source === void 0 ? void 0 : sourceSchema2.safeParse(parsed.source);
-    if (parsed.source !== void 0 && (!source || !source.success)) {
-      return void 0;
-    }
-    return {
-      schemaVersion: 2,
-      authSessionId: parsed.authSessionId,
-      provider: parsed.provider,
-      userId: parsed.userId,
-      conversationId: parsed.conversationId,
-      ...destination ? { destination } : {},
-      ...source?.success ? { source: source.data } : {},
-      sessionId: parsed.sessionId,
-      userMessage: parsed.userMessage,
-      createdAtMs: parsed.createdAtMs,
-      updatedAtMs: parsed.updatedAtMs,
-      ...typeof parsed.channelId === "string" ? { channelId: parsed.channelId } : {},
-      ...typeof parsed.threadTs === "string" ? { threadTs: parsed.threadTs } : {},
-      ...typeof parsed.toolChannelId === "string" ? { toolChannelId: parsed.toolChannelId } : {},
-      ...isRecord(parsed.configuration) ? { configuration: parsed.configuration } : {},
-      ...isRecord(parsed.artifactState) ? { artifactState: parsed.artifactState } : {},
-      ...typeof parsed.authorizationUrl === "string" ? { authorizationUrl: parsed.authorizationUrl } : {},
-      ...typeof parsed.codeVerifier === "string" ? { codeVerifier: parsed.codeVerifier } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-function parseServerSession(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(parsed) || typeof parsed.sessionId !== "string" || typeof parsed.updatedAtMs !== "number") {
-      return void 0;
-    }
-    return {
-      sessionId: parsed.sessionId,
-      updatedAtMs: parsed.updatedAtMs
-    };
-  } catch {
-    return void 0;
-  }
-}
-function parseStoredCredentials(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(parsed)) {
-      return void 0;
-    }
-    return {
-      ...isRecord(parsed.clientInformation) ? {
-        clientInformation: parsed.clientInformation
-      } : {},
-      ...isRecord(parsed.discoveryState) ? {
-        discoveryState: parsed.discoveryState
-      } : {},
-      ...isRecord(parsed.tokens) ? { tokens: parsed.tokens } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-async function getConnectedStateAdapter() {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  return stateAdapter;
-}
-async function getMcpAuthSession(authSessionId) {
-  const stateAdapter = await getConnectedStateAdapter();
-  return parseMcpAuthSession(await stateAdapter.get(sessionKey(authSessionId)));
-}
-async function putMcpAuthSession(session, ttlMs2 = MCP_AUTH_SESSION_TTL_MS) {
-  const stateAdapter = await getConnectedStateAdapter();
-  await stateAdapter.set(
-    sessionKey(session.authSessionId),
-    JSON.stringify(session),
-    ttlMs2
-  );
-  const nextIndex = parseSessionIndex(
-    await stateAdapter.get(sessionIndexKey(session.userId, session.provider))
-  );
-  if (!nextIndex.includes(session.authSessionId)) {
-    nextIndex.push(session.authSessionId);
-  }
-  await stateAdapter.set(
-    sessionIndexKey(session.userId, session.provider),
-    JSON.stringify(nextIndex),
-    ttlMs2
-  );
-}
-async function patchMcpAuthSession(authSessionId, patch) {
-  const current = await getMcpAuthSession(authSessionId);
-  if (!current) {
-    throw new Error(`Unknown MCP auth session: ${authSessionId}`);
-  }
-  const next = {
-    ...current,
-    ...patch,
-    schemaVersion: 2,
-    authSessionId: current.authSessionId,
-    provider: current.provider,
-    userId: current.userId,
-    conversationId: current.conversationId,
-    ...current.destination ? { destination: current.destination } : {},
-    sessionId: current.sessionId,
-    userMessage: current.userMessage,
-    createdAtMs: current.createdAtMs,
-    updatedAtMs: Date.now()
-  };
-  await putMcpAuthSession(next);
-  return next;
-}
-async function deleteMcpAuthSession(authSessionId) {
-  const stateAdapter = await getConnectedStateAdapter();
-  const current = parseMcpAuthSession(
-    await stateAdapter.get(sessionKey(authSessionId))
-  );
-  await stateAdapter.delete(sessionKey(authSessionId));
-  if (!current) {
-    return;
-  }
-  const nextIndex = parseSessionIndex(
-    await stateAdapter.get(sessionIndexKey(current.userId, current.provider))
-  ).filter((id) => id !== authSessionId);
-  if (nextIndex.length > 0) {
-    await stateAdapter.set(
-      sessionIndexKey(current.userId, current.provider),
-      JSON.stringify(nextIndex),
-      MCP_AUTH_SESSION_TTL_MS
-    );
-    return;
-  }
-  await stateAdapter.delete(sessionIndexKey(current.userId, current.provider));
-}
-async function deleteMcpAuthSessionsForUserProvider(userId, provider) {
-  const stateAdapter = await getConnectedStateAdapter();
-  const indexKey = sessionIndexKey(userId, provider);
-  const authSessionIds = parseSessionIndex(await stateAdapter.get(indexKey));
-  for (const authSessionId of authSessionIds) {
-    await stateAdapter.delete(sessionKey(authSessionId));
-  }
-  await stateAdapter.delete(indexKey);
-}
-async function getMcpStoredOAuthCredentials(userId, provider) {
-  const stateAdapter = await getConnectedStateAdapter();
-  return parseStoredCredentials(
-    await stateAdapter.get(credentialsKey(userId, provider))
-  );
-}
-async function putMcpStoredOAuthCredentials(userId, provider, value, ttlMs2 = MCP_AUTH_CREDENTIALS_TTL_MS) {
-  const stateAdapter = await getConnectedStateAdapter();
-  await stateAdapter.set(
-    credentialsKey(userId, provider),
-    JSON.stringify(value),
-    ttlMs2
-  );
-}
-async function deleteMcpStoredOAuthCredentials(userId, provider) {
-  const stateAdapter = await getConnectedStateAdapter();
-  await stateAdapter.delete(credentialsKey(userId, provider));
-}
-async function getMcpServerSessionId(userId, provider) {
-  const stateAdapter = await getConnectedStateAdapter();
-  return parseServerSession(
-    await stateAdapter.get(serverSessionKey(userId, provider))
-  )?.sessionId;
-}
-async function putMcpServerSessionId(userId, provider, sessionId, ttlMs2 = MCP_SERVER_SESSION_TTL_MS) {
-  const stateAdapter = await getConnectedStateAdapter();
-  await stateAdapter.set(
-    serverSessionKey(userId, provider),
-    JSON.stringify({
-      sessionId,
-      updatedAtMs: Date.now()
-    }),
-    ttlMs2
-  );
-}
-async function deleteMcpServerSessionId(userId, provider) {
-  const stateAdapter = await getConnectedStateAdapter();
-  await stateAdapter.delete(serverSessionKey(userId, provider));
-}
-
-// src/chat/mcp/oauth-provider.ts
-function createClientMetadata(callbackUrl) {
-  return {
-    client_name: "Junior MCP Client",
-    redirect_uris: [callbackUrl],
-    grant_types: ["authorization_code", "refresh_token"],
-    response_types: ["code"],
-    token_endpoint_auth_method: "none"
-  };
-}
-function clientAllowsRedirectUri(clientInformation, callbackUrl) {
-  const redirectUris = clientInformation.redirect_uris;
-  if (!Array.isArray(redirectUris)) {
-    return true;
-  }
-  return redirectUris.includes(callbackUrl);
-}
-var StateBackedMcpOAuthClientProvider = class {
-  constructor(authSessionId, callbackUrl, sessionContext, runCredentialMutation) {
-    this.authSessionId = authSessionId;
-    this.callbackUrl = callbackUrl;
-    this.sessionContext = sessionContext;
-    this.runCredentialMutation = runCredentialMutation;
-    this.clientMetadata = createClientMetadata(callbackUrl);
-  }
-  authSessionId;
-  callbackUrl;
-  sessionContext;
-  runCredentialMutation;
-  clientMetadata;
-  get redirectUrl() {
-    return this.callbackUrl;
-  }
-  async state() {
-    return this.authSessionId;
-  }
-  async clientInformation() {
-    const session = await this.getCredentialContext();
-    const credentials = await getMcpStoredOAuthCredentials(
-      session.userId,
-      session.provider
-    );
-    const clientInformation = credentials?.clientInformation;
-    if (!clientInformation) {
-      return void 0;
-    }
-    if (clientAllowsRedirectUri(clientInformation, this.callbackUrl)) {
-      return clientInformation;
-    }
-    return void 0;
-  }
-  async saveClientInformation(clientInformation) {
-    await this.mutateCredentials(async () => {
-      const session = await this.getCredentialContext();
-      const credentials = await getMcpStoredOAuthCredentials(
-        session.userId,
-        session.provider
-      ) ?? {};
-      await putMcpStoredOAuthCredentials(session.userId, session.provider, {
-        ...credentials,
-        clientInformation
-      });
-    });
-  }
-  async tokens() {
-    const session = await this.getCredentialContext();
-    const credentials = await getMcpStoredOAuthCredentials(
-      session.userId,
-      session.provider
-    );
-    return credentials?.tokens;
-  }
-  async saveTokens(tokens) {
-    await this.mutateCredentials(async () => {
-      const session = await this.getCredentialContext();
-      const credentials = await getMcpStoredOAuthCredentials(
-        session.userId,
-        session.provider
-      ) ?? {};
-      await putMcpStoredOAuthCredentials(session.userId, session.provider, {
-        ...credentials,
-        tokens
-      });
-    });
-  }
-  async redirectToAuthorization(authorizationUrl) {
-    const existing = await getMcpAuthSession(this.authSessionId);
-    if (existing?.authorizationUrl && existing.authorizationUrl !== authorizationUrl.toString()) {
-      throw new Error("MCP OAuth authorization attempt is already initialized");
-    }
-    await this.ensureSession({
-      authorizationUrl: authorizationUrl.toString()
-    });
-  }
-  async saveCodeVerifier(codeVerifier) {
-    const existing = await getMcpAuthSession(this.authSessionId);
-    if (existing?.codeVerifier && existing.codeVerifier !== codeVerifier) {
-      throw new Error("MCP OAuth authorization attempt is already initialized");
-    }
-    await this.ensureSession({ codeVerifier });
-  }
-  async codeVerifier() {
-    const session = await this.requireSession();
-    if (!session.codeVerifier) {
-      throw new Error("Missing MCP OAuth code verifier");
-    }
-    return session.codeVerifier;
-  }
-  async saveDiscoveryState(state) {
-    await this.mutateCredentials(async () => {
-      const session = await this.getCredentialContext();
-      const credentials = await getMcpStoredOAuthCredentials(
-        session.userId,
-        session.provider
-      ) ?? {};
-      await putMcpStoredOAuthCredentials(session.userId, session.provider, {
-        ...credentials,
-        discoveryState: state
-      });
-    });
-  }
-  async discoveryState() {
-    const session = await this.getCredentialContext();
-    const credentials = await getMcpStoredOAuthCredentials(
-      session.userId,
-      session.provider
-    );
-    return credentials?.discoveryState;
-  }
-  async invalidateCredentials(scope) {
-    await this.mutateCredentials(async () => {
-      const session = await this.getCredentialContext();
-      const credentials = await getMcpStoredOAuthCredentials(
-        session.userId,
-        session.provider
-      ) ?? {};
-      await putMcpStoredOAuthCredentials(session.userId, session.provider, {
-        ...scope === "tokens" || scope === "all" ? {} : credentials.tokens ? { tokens: credentials.tokens } : {},
-        ...scope === "client" || scope === "all" ? {} : credentials.clientInformation ? { clientInformation: credentials.clientInformation } : {},
-        ...scope === "discovery" || scope === "all" ? {} : credentials.discoveryState ? { discoveryState: credentials.discoveryState } : {}
-      });
-    });
-  }
-  async getMcpServerSessionId() {
-    const session = await this.getCredentialContext();
-    return await getMcpServerSessionId(session.userId, session.provider);
-  }
-  async saveMcpServerSessionId(sessionId) {
-    await this.mutateCredentials(async () => {
-      const session = await this.getCredentialContext();
-      if (!sessionId) {
-        await deleteMcpServerSessionId(session.userId, session.provider);
-        return;
-      }
-      await putMcpServerSessionId(session.userId, session.provider, sessionId);
-    });
-  }
-  /** Route shared credential writes through callback-owned freshness control. */
-  async mutateCredentials(mutation) {
-    return this.runCredentialMutation ? await this.runCredentialMutation(mutation) : await mutation();
-  }
-  async getCredentialContext() {
-    return this.sessionContext ?? await this.requireSession();
-  }
-  async ensureSession(patch) {
-    const existing = await getMcpAuthSession(this.authSessionId);
-    if (existing) {
-      return await patchMcpAuthSession(this.authSessionId, patch);
-    }
-    if (!this.sessionContext) {
-      throw new Error(`Unknown MCP auth session: ${this.authSessionId}`);
-    }
-    const now = Date.now();
-    const nextSession = {
-      schemaVersion: 2,
-      authSessionId: this.authSessionId,
-      ...this.sessionContext,
-      ...patch,
-      createdAtMs: now,
-      updatedAtMs: now
-    };
-    await putMcpAuthSession(nextSession);
-    return nextSession;
-  }
-  async requireSession() {
-    const session = await getMcpAuthSession(this.authSessionId);
-    if (!session) {
-      throw new Error(`Unknown MCP auth session: ${this.authSessionId}`);
-    }
-    return session;
-  }
-};
-
-// src/chat/mcp/oauth.ts
-function getMcpOAuthCallbackPath(provider) {
-  return `/api/oauth/callback/mcp/${provider}`;
-}
-function requirePluginWithMcp(provider) {
-  const plugin = pluginCatalogRuntime.getDefinition(provider);
-  if (!plugin?.manifest.mcp) {
-    throw new Error(`Plugin "${provider}" does not support MCP`);
-  }
-  return plugin;
-}
-async function createMcpOAuthClientProvider(input) {
-  requirePluginWithMcp(input.provider);
-  const baseUrl = resolveBaseUrl();
-  if (!baseUrl) {
-    throw new Error(
-      "Cannot determine base URL (set JUNIOR_BASE_URL or deploy to Vercel)"
-    );
-  }
-  const authSessionId = randomUUID3();
-  return new StateBackedMcpOAuthClientProvider(
-    authSessionId,
-    `${baseUrl}${getMcpOAuthCallbackPath(input.provider)}`,
-    {
-      provider: input.provider,
-      userId: input.userId,
-      conversationId: input.conversationId,
-      ...input.destination ? { destination: input.destination } : {},
-      ...input.source ? { source: input.source } : {},
-      sessionId: input.sessionId,
-      userMessage: input.userMessage,
-      ...input.channelId ? { channelId: input.channelId } : {},
-      ...input.threadTs ? { threadTs: input.threadTs } : {},
-      ...input.toolChannelId ? { toolChannelId: input.toolChannelId } : {},
-      ...input.configuration ? { configuration: input.configuration } : {},
-      ...input.artifactState ? { artifactState: input.artifactState } : {}
-    }
-  );
-}
-async function finalizeMcpAuthorization(provider, authSessionId, authorizationCode, runCredentialMutation) {
-  const plugin = requirePluginWithMcp(provider);
-  const mcp = plugin.manifest.mcp;
-  if (!mcp) {
-    throw new Error(`Plugin "${provider}" does not support MCP`);
-  }
-  const session = await getMcpAuthSession(authSessionId);
-  if (!session) {
-    throw new Error(`Unknown MCP auth session: ${authSessionId}`);
-  }
-  if (session.provider !== provider) {
-    throw new Error(
-      `MCP auth session provider mismatch: expected "${provider}", got "${session.provider}"`
-    );
-  }
-  const baseUrl = resolveBaseUrl();
-  if (!baseUrl) {
-    throw new Error(
-      "Cannot determine base URL (set JUNIOR_BASE_URL or deploy to Vercel)"
-    );
-  }
-  const callbackUrl = `${baseUrl}${getMcpOAuthCallbackPath(provider)}`;
-  const authProvider = new StateBackedMcpOAuthClientProvider(
-    authSessionId,
-    callbackUrl,
-    void 0,
-    runCredentialMutation
-  );
-  const requestInit = {};
-  if (mcp.headers && Object.keys(mcp.headers).length > 0) {
-    requestInit.headers = new Headers(mcp.headers);
-  }
-  const transport = new StreamableHTTPClientTransport2(new URL(mcp.url), {
-    ...Object.keys(requestInit).length > 0 ? { requestInit } : {},
-    authProvider
-  });
-  try {
-    await transport.finishAuth(authorizationCode);
-  } finally {
-    await transport.close();
-  }
-  const nextSession = await getMcpAuthSession(authSessionId);
-  if (!nextSession) {
-    throw new Error(`Unknown MCP auth session: ${authSessionId}`);
-  }
-  return nextSession;
-}
-
 // src/chat/services/mcp-auth-orchestration.ts
 var McpAuthorizationPauseError = class extends AuthorizationPauseError {
   constructor(provider, providerDisplayName, disposition, requestText) {
     super("mcp", provider, providerDisplayName, disposition, requestText);
   }
 };
-function authorizationId2(args) {
-  return `${args.sessionId}:${args.kind}:${args.provider}`;
-}
 function createMcpAuthOrchestration(input) {
   let pendingPause;
   const authSessionIdsByProvider = /* @__PURE__ */ new Map();
@@ -13314,7 +11663,8 @@ function createMcpAuthOrchestration(input) {
       ...input.threadTs ? { threadTs: input.threadTs } : {},
       ...input.toolChannelId ? { toolChannelId: input.toolChannelId } : {},
       configuration: input.getConfiguration(),
-      artifactState: input.getArtifactState()
+      artifactState: input.getArtifactState(),
+      createAuthorizationState: input.authorization?.createState
     });
     authSessionIdsByProvider.set(plugin.manifest.name, provider.authSessionId);
     return provider;
@@ -13374,15 +11724,16 @@ function createMcpAuthOrchestration(input) {
         );
       }
       await recordPendingAuth(nextPendingAuth);
-      const delivery = await deliverPrivateMessage({
+      const authorizationRequest = {
+        authorizationUrl: authSession.authorizationUrl,
+        label: `Click here to link your ${providerLabel} MCP access`,
+        completionText: "Once you've authorized, Junior will continue automatically."
+      };
+      const delivery = await deliverOAuthAuthorization(authorizationRequest, {
+        authorization: input.authorization,
         channelId: authSession.channelId,
         threadTs: authSession.threadTs,
-        userId: authSession.userId,
-        text: formatOAuthAuthorizationMessage({
-          authorizationUrl: authSession.authorizationUrl,
-          label: `Click here to link your ${providerLabel} MCP access`,
-          completionText: "Once you've authorized, this thread will continue automatically."
-        })
+        userId: authSession.userId
       });
       if (!delivery) {
         await deleteMcpAuthSession(authSessionId);
@@ -13405,7 +11756,7 @@ function createMcpAuthOrchestration(input) {
       kind: "mcp",
       provider,
       actorId,
-      authorizationId: authorizationId2({
+      authorizationId: authorizationId({
         kind: "mcp",
         provider,
         sessionId
@@ -13429,197 +11780,7 @@ function createMcpAuthOrchestration(input) {
 }
 
 // src/chat/egress/plugin.ts
-import { randomUUID as randomUUID4 } from "crypto";
-
-// src/chat/plugins/credential-hooks.ts
-import {
-  pluginAuthorizationSchema as pluginAuthorizationSchema2,
-  pluginCredentialResultSchema,
-  pluginGrantSchema as pluginGrantSchema2,
-  pluginProviderAccountSchema as pluginProviderAccountSchema2
-} from "@sentry/junior-plugin-api";
-function parseSchema(schema, value, message) {
-  const result = schema.safeParse(value);
-  if (!result.success) {
-    throw new Error(message);
-  }
-  return result.data;
-}
-function parseAuthorization(value, pluginName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const authorization = parseSchema(
-    pluginAuthorizationSchema2,
-    value,
-    `Plugin "${pluginName}" grant authorization is invalid`
-  );
-  if (authorization.provider !== pluginName) {
-    throw new Error(
-      `Plugin "${pluginName}" grant authorization provider must match the issuing plugin`
-    );
-  }
-  return authorization;
-}
-function parseGrant(value, pluginName) {
-  return parseSchema(
-    pluginGrantSchema2,
-    value,
-    `Plugin "${pluginName}" grantForEgress returned an invalid grant`
-  );
-}
-function pluginFor(provider) {
-  return getPlugins().find((candidate) => candidate.manifest.name === provider);
-}
-function basePluginContext(plugin) {
-  const pluginName = plugin.manifest.name;
-  return {
-    plugin: { name: pluginName },
-    log: createPluginLogger(pluginName),
-    db: getDb()
-  };
-}
-function parseCredentialResult(value, pluginName) {
-  const result = parseSchema(
-    pluginCredentialResultSchema,
-    value,
-    `Plugin "${pluginName}" issueCredential result is invalid`
-  );
-  if (result.type === "lease") {
-    parseAuthorization(result.lease.authorization, pluginName);
-    return result;
-  }
-  if (result.type === "unavailable") {
-    return result;
-  }
-  parseAuthorization(result.authorization, pluginName);
-  return result;
-}
-async function selectPluginGrant(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.grantForEgress;
-  if (!plugin || !hook) {
-    return void 0;
-  }
-  const result = await hook({
-    ...basePluginContext(plugin),
-    request: {
-      ...input.bodyText !== void 0 ? { bodyText: input.bodyText } : {},
-      method: input.method,
-      ...input.operation ? { operation: input.operation } : {},
-      url: input.upstreamUrl.toString()
-    }
-  });
-  return result === void 0 ? void 0 : parseGrant(result, plugin.manifest.name);
-}
-async function onPluginEgressResponse(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.onEgressResponse;
-  if (!plugin || !hook) {
-    return {};
-  }
-  let permissionDenied;
-  await hook({
-    ...basePluginContext(plugin),
-    grant: input.grant,
-    permissionDenied(message) {
-      const trimmed = message.trim();
-      if (!trimmed) {
-        throw new Error(
-          `Plugin "${plugin.manifest.name}" onEgressResponse permissionDenied message is empty`
-        );
-      }
-      permissionDenied = { message: trimmed };
-    },
-    request: {
-      method: input.method,
-      ...input.operation ? { operation: input.operation } : {},
-      url: input.upstreamUrl.toString()
-    },
-    response: input.response
-  });
-  return permissionDenied ? { permissionDenied } : {};
-}
-function hasEgressCredentialHooks(provider) {
-  const hooks = pluginFor(provider)?.hooks;
-  return Boolean(hooks?.grantForEgress || hooks?.issueCredential);
-}
-async function resolvePluginOAuthAccount(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.resolveOAuthAccount;
-  if (!plugin || !hook) {
-    return void 0;
-  }
-  const account = await hook({
-    ...basePluginContext(plugin),
-    tokens: input.tokens
-  });
-  return account === void 0 ? void 0 : parseSchema(
-    pluginProviderAccountSchema2,
-    account,
-    `Plugin "${plugin.manifest.name}" resolveOAuthAccount returned an invalid account`
-  );
-}
-async function issuePluginCredential(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.issueCredential;
-  if (!plugin || !hook) {
-    throw new Error(`Plugin "${input.provider}" has no issueCredential hook`);
-  }
-  const currentUserId = "type" in input.actor ? input.actor.userId : void 0;
-  const credentialSubjectUserId = input.credentialSubject?.userId;
-  const result = await hook({
-    ...basePluginContext(plugin),
-    actor: input.actor,
-    grant: input.grant,
-    ...input.credentialSubject ? { credentialSubject: input.credentialSubject } : {},
-    tokens: {
-      ...currentUserId ? {
-        currentUser: {
-          userId: currentUserId,
-          get: async () => await input.userTokenStore.get(
-            currentUserId,
-            plugin.manifest.name
-          ),
-          set: async (tokens) => {
-            await input.userTokenStore.set(
-              currentUserId,
-              plugin.manifest.name,
-              tokens
-            );
-          },
-          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
-            currentUserId,
-            plugin.manifest.name,
-            callback
-          )
-        }
-      } : {},
-      ...credentialSubjectUserId ? {
-        credentialSubject: {
-          userId: credentialSubjectUserId,
-          get: async () => await input.userTokenStore.get(
-            credentialSubjectUserId,
-            plugin.manifest.name
-          ),
-          set: async (tokens) => {
-            await input.userTokenStore.set(
-              credentialSubjectUserId,
-              plugin.manifest.name,
-              tokens
-            );
-          },
-          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
-            credentialSubjectUserId,
-            plugin.manifest.name,
-            callback
-          )
-        }
-      } : {}
-    }
-  });
-  return parseCredentialResult(result, plugin.manifest.name);
-}
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/chat/sandbox/egress/credentials.ts
 var HTTP_READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
@@ -14392,8 +12553,8 @@ async function executeCredentialedEgressRequest(input) {
 function credentialContextForPluginEgress(credentialContext) {
   return {
     credentials: credentialContext,
-    contextId: randomUUID4(),
-    egressId: `plugin-egress:${randomUUID4()}`,
+    contextId: randomUUID3(),
+    egressId: `plugin-egress:${randomUUID3()}`,
     expiresAtMs: Date.now() + 30 * 60 * 1e3
   };
 }
@@ -14464,6 +12625,7 @@ async function wireAgentTools(args) {
     skills: args.availableSkills,
     traceContext: args.spanContext,
     tracePropagation: args.policy.sandboxTracePropagation,
+    egressSignals: args.policy.sandboxEgressSignals,
     credentialEgress: args.routing.credentialContext,
     actor: args.currentActor,
     channelConfiguration: args.policy.channelConfiguration,
@@ -14494,7 +12656,8 @@ async function wireAgentTools(args) {
       args.artifactStatePatch
     ),
     recordPendingAuth: args.durability.recordPendingAuth,
-    authorizationFlowMode: args.policy.authorizationFlowMode
+    authorizationFlowMode: args.policy.authorizationFlowMode,
+    authorization: args.authorization
   });
   const pluginAuth = createPluginAuthOrchestration({
     abortAgent: args.abortAgent,
@@ -14509,7 +12672,8 @@ async function wireAgentTools(args) {
     pendingAuth: args.state.pendingAuth,
     recordPendingAuth: args.durability.recordPendingAuth,
     authorizationFlowMode: args.policy.authorizationFlowMode,
-    userTokenStore
+    userTokenStore,
+    authorization: args.authorization
   });
   const mcpToolManager = new McpToolManager(
     pluginCatalogRuntime.getMcpProviders(),
@@ -15178,6 +13342,7 @@ ${summary}`)
         retainedMessageCount: replacement.length - 1,
         summaryChars: summary.length
       },
+      summary,
       replacementHistory: replacement.map((message, index) => {
         const sourceEventSeq = index < retained.length ? sourceProjection.seqs[retained[index].sourceIndex] : void 0;
         return {
@@ -15211,8 +13376,9 @@ async function compactContextForHandoff(args, deps) {
   if (!runtimeMessage) {
     throw new Error("Handoff requires the current runtime turn context");
   }
+  const generatedSummary = await summarizeContext(args, deps);
   const summary = `${MODEL_HANDOFF_SUMMARY_PREFIX}
-${await summarizeContext(args, deps)}`;
+${generatedSummary}`;
   const message = {
     ...runtimeMessage,
     content: [
@@ -15231,6 +13397,7 @@ ${await summarizeContext(args, deps)}`;
       modelId: args.target.modelId,
       ...args.target.reasoningLevel ? { reasoningLevel: args.target.reasoningLevel } : {},
       ...args.triggeringToolCallId ? { triggeringToolCallId: args.triggeringToolCallId } : {},
+      summary: generatedSummary,
       replacementHistory: replacementMessages.map((replacementMessage) => ({
         message: replacementMessage,
         provenance: contextProvenance
@@ -15330,6 +13497,7 @@ ${summary}`;
         retainedMessageCount: pendingMessages.length,
         summaryChars: summary.length
       },
+      summary,
       replacementHistory: replacementMessages.map((message, index) => ({
         message,
         provenance: index === 0 ? contextProvenance : pendingMessages[index - 1]?.provenance ?? contextProvenance
@@ -15432,6 +13600,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
   const state = request.state ?? {};
   const observers = request.observers ?? {};
   const delivery = request.delivery;
+  const authorization = request.authorization;
   const durability = request.durability ?? {};
   signal?.throwIfAborted();
   assertRunRoutingConsistency(request);
@@ -15783,6 +13952,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       connectedMcpProviders,
       conversationPrivacy,
       durability,
+      authorization,
       generatedFiles,
       invokedSkill,
       observers,
@@ -16443,24 +14613,12 @@ export {
   getConfigDefaults,
   shouldEmitDevAgentTrace,
   AuthorizationFlowDisabledError,
-  RetryableDeliveryError,
-  truncateStatusText,
-  escapeSlackMrkdwnText,
-  formatSlackLink,
-  normalizeSlackStatusText,
-  splitSlackReplyText,
-  buildSlackOutputMessage,
   buildSteeringPiMessage,
-  createUserTokenStore,
-  postSlackMessage,
-  addReactionToMessage,
-  removeReactionFromMessage,
-  parseOAuthStatePayload,
-  formatProviderLabel,
-  resolveBaseUrl,
-  startOAuthFlow,
   SANDBOX_EGRESS_PROXY_PATH,
   parseSandboxEgressCredentialToken,
+  clearSandboxEgressSignals,
+  consumeSandboxEgressAuthRequiredSignal,
+  consumeSandboxEgressPermissionDeniedSignal,
   normalizeSandboxEgressTracePropagationDomains,
   shouldPropagateSandboxEgressTrace,
   resolveSandboxEgressProviderForHost,
@@ -16472,14 +14630,6 @@ export {
   appendSlackLegacyAttachmentText,
   latestReportedProgress,
   PluginCredentialFailureError,
-  getMcpAuthSession,
-  deleteMcpAuthSession,
-  deleteMcpAuthSessionsForUserProvider,
-  getMcpStoredOAuthCredentials,
-  deleteMcpStoredOAuthCredentials,
-  deleteMcpServerSessionId,
-  finalizeMcpAuthorization,
-  resolvePluginOAuthAccount,
   executeCredentialedEgressRequest,
   createContextCompactor,
   executeAgentRun,