@sentry/junior 0.119.0 → 0.121.0

package/dist/{chunk-TGIQN7QW.js → chunk-VWBKDPMQ.js}

@@ -30,7 +30,7 @@ import {
   toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-4UIUDOOV.js";
+} from "./chunk-3DBMANUI.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
@@ -72,7 +72,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-BNJEPYTC.js";
+} from "./chunk-Z2XXPUZG.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -96,10 +96,10 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-GKFDU3ZI.js";
+} from "./chunk-ITMEXX5H.js";
 import {
   incrementStat
-} from "./chunk-JXRAOOXQ.js";
+} from "./chunk-XDRGYDED.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -121,7 +121,7 @@ import {
   normalizeSlackConversationId,
   resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-BLQZACHV.js";
+} from "./chunk-7HYV7KFM.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -130,7 +130,7 @@ import {
   getConversationStore,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-D3N4BPSL.js";
+} from "./chunk-254MFDOF.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -140,7 +140,7 @@ import {
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-VJTWKJWQ.js";
+} from "./chunk-UURFXX66.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -171,7 +171,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-VLTWQQKH.js";
+} from "./chunk-IDXLBKPS.js";
 import {
   canExposeConversationPayload,
   parseSlackThreadId,
@@ -188,10 +188,10 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-QZ7XRJDB.js";
+} from "./chunk-TRECK7RV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-JSTGI7TX.js";
+} from "./chunk-WUP7NWMP.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -199,7 +199,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-R53UT2OI.js";
+} from "./chunk-ET2SDCNV.js";
 import {
   credentialUserSubjectId
 } from "./chunk-W3U3YQYI.js";
@@ -223,7 +223,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-ZJ6IVZVO.js";
+} from "./chunk-JZ47AFSH.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
@@ -237,7 +237,7 @@ import {
   listReferenceFiles,
   soulPathCandidates,
   worldPathCandidates
-} from "./chunk-3V7OFJZC.js";
+} from "./chunk-H4HBKISO.js";
 
 // src/chat/configuration/defaults.ts
 var installDefaults = {};
@@ -1781,10 +1781,11 @@ var TOOL_POLICY_RULES = [
   "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
   "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
   "- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
+  "- After changing files, name the changed paths and summarize the completed result in the final answer.",
   "- If a sandbox-backed tool reports that sandbox execution is unavailable, treat that as a blocker for local file/shell inspection; do not pretend host files were inspected.",
   "- For user-provided URLs, use `webFetch`; for discovery, use `webSearch` then fetch/read promising sources; for current time/date context, use `systemTime`.",
   "- When a tool result includes a subscribable resource, use resource-event subscriptions for high-signal provider changes that serve the user's current intent; do not create scheduled polling tasks for events the subscription can deliver. Use the suggested events when they fit and write a concise intent summary.",
-  "- For code changes, debugging or root-cause analysis, broad refactors, and software architecture decisions, use `handoff` before substantive analysis when that tool is available.",
+  "- For code changes, debugging or root-cause analysis, broad refactors, and software architecture decisions, use `handoff` before substantive analysis only when it offers a profile that better matches the task. Do not switch merely because the task involves code.",
   "- Run `jr-rpc config get|set|unset|list` for provider defaults and `jr-rpc plugins list` for installed plugin introspection as standalone bash commands; do not chain them with `cd`, `&&`, pipes, or provider commands.",
   "- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
 ];
@@ -1805,7 +1806,8 @@ var EXECUTION_CONTRACT_RULES = [
   "- Complete the full task, but report only the result and evidence the user needs; do not narrate every step, check, or detail.",
   "- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
   "- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
-  "- For non-trivial or long-running work, call `reportProgress` early when available, then only when the major phase changes. Routine tool calls should stay silent."
+  "- Use `reportProgress` only for work with multiple substantive phases or a materially long wait. Skip short lookups and routine commands; after an initial update, call it again only when the major phase changes.",
+  "- When a tool outcome is unknown and may include side effects, inspect authoritative state before retrying. If state already reflects the intended result, do not repeat the mutation."
 ];
 var CONVERSATION_RULES = [
   "- In thread follow-ups, answer from prior thread context; do not repeat resolved clarifying questions.",
@@ -3259,6 +3261,20 @@ var SNAPSHOT_BOOT_RETRY_DELAY_MS = 1e3;
 var SANDBOX_NAME_PREFIX = "junior-";
 var MAX_KEEPALIVE_INTERVAL_MS = 3e4;
 var MIN_KEEPALIVE_INTERVAL_MS = 1e3;
+function sandboxFetchOptions(signal) {
+  if (!signal) {
+    return {};
+  }
+  return {
+    fetch: (input, init) => {
+      const requestSignal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+      return globalThis.fetch(input, {
+        ...init,
+        signal: requestSignal ? AbortSignal.any([requestSignal, signal]) : signal
+      });
+    }
+  };
+}
 function truncateOutput(output, maxLength) {
   if (output.length <= maxLength) {
     return { value: output, truncated: false };
@@ -3398,9 +3414,10 @@ function createSandboxRuntime(options) {
       }
     );
   };
-  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, initialSandboxName) => {
+  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, initialSandboxName, signal) => {
     const resources = getSandboxResources();
     for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
+      signal?.throwIfAborted();
       const sandboxName = attempt === 0 ? initialSandboxName : createSandboxName();
       const networkPolicy = preflightNetworkPolicy(sandboxName);
       try {
@@ -3413,14 +3430,15 @@ function createSandboxRuntime(options) {
               snapshotId
             },
             ...resources ? { resources } : {},
-            ...sandboxCredentials ?? {}
+            ...sandboxCredentials ?? {},
+            ...sandboxFetchOptions(signal)
           })
         );
       } catch (error) {
         if (!isSnapshottingError(error) || attempt === SNAPSHOT_BOOT_RETRY_COUNT - 1) {
           throw error;
         }
-        await sleep(SNAPSHOT_BOOT_RETRY_DELAY_MS);
+        await sleep(SNAPSHOT_BOOT_RETRY_DELAY_MS, signal);
       }
     }
     throw new Error(`Failed to boot sandbox from snapshot ${snapshotId}`);
@@ -3440,7 +3458,8 @@ function createSandboxRuntime(options) {
     });
   };
   const createSandboxFromResolvedSnapshot = async (params) => {
-    const { runtime, snapshot, sandboxCredentials, sandboxName } = params;
+    const { runtime, snapshot, sandboxCredentials, sandboxName, signal } = params;
+    signal?.throwIfAborted();
     if (!snapshot.snapshotId) {
       const networkPolicy = preflightNetworkPolicy(sandboxName);
       const resources = getSandboxResources();
@@ -3450,7 +3469,8 @@ function createSandboxRuntime(options) {
           runtime,
           ...networkPolicy ? { name: sandboxName, persistent: false, networkPolicy } : {},
           ...resources ? { resources } : {},
-          ...sandboxCredentials ?? {}
+          ...sandboxCredentials ?? {},
+          ...sandboxFetchOptions(signal)
         })
       );
     }
@@ -3458,7 +3478,8 @@ function createSandboxRuntime(options) {
       return await createSandboxFromSnapshot(
         snapshot.snapshotId,
         sandboxCredentials,
-        sandboxName
+        sandboxName,
+        signal
       );
     } catch (error) {
       if (!isMissingError(error)) {
@@ -3471,19 +3492,22 @@ function createSandboxRuntime(options) {
         runtime,
         timeoutMs,
         forceRebuild: true,
-        staleSnapshotId: snapshot.snapshotId
+        staleSnapshotId: snapshot.snapshotId,
+        signal
       });
       if (!rebuiltSnapshot.snapshotId) {
         throw error;
       }
+      signal?.throwIfAborted();
       return await createSandboxFromSnapshot(
         rebuiltSnapshot.snapshotId,
         sandboxCredentials,
-        sandboxName
+        sandboxName,
+        signal
       );
     }
   };
-  const createFreshSandbox = async () => {
+  const createFreshSandbox = async (signal) => {
     const runtime = SANDBOX_RUNTIME;
     const sandboxCredentials = getVercelSandboxCredentials();
     const sandboxName = createSandboxName();
@@ -3500,14 +3524,17 @@ function createSandboxRuntime(options) {
         async () => {
           const snapshot = await resolve({
             runtime,
-            timeoutMs
+            timeoutMs,
+            signal
           });
+          signal?.throwIfAborted();
           setSnapshotAttributes(snapshot);
           return await createSandboxFromResolvedSnapshot({
             runtime,
             snapshot,
             sandboxCredentials,
-            sandboxName
+            sandboxName,
+            signal
           });
         }
       );
@@ -3552,7 +3579,7 @@ function createSandboxRuntime(options) {
   const tryReuseCachedSandbox = async () => {
     return activeSandbox?.session ?? null;
   };
-  const tryRestoreHintedSandbox = async () => {
+  const tryRestoreHintedSandbox = async (signal) => {
     const ref = sandboxRef;
     if (!ref) {
       return null;
@@ -3571,7 +3598,8 @@ function createSandboxRuntime(options) {
           await Sandbox.get({
             name: ref.id,
             resume: true,
-            ...sandboxCredentials ?? {}
+            ...sandboxCredentials ?? {},
+            ...sandboxFetchOptions(signal)
           })
         )
       );
@@ -3599,7 +3627,7 @@ function createSandboxRuntime(options) {
       return failSetup(error);
     }
   };
-  const acquireSandbox = async () => {
+  const acquireSandbox = async (signal) => {
     return await withSandboxSpan(
       "sandbox.acquire",
       "sandbox.acquire",
@@ -3615,25 +3643,63 @@ function createSandboxRuntime(options) {
         if (cachedSandbox) {
           return cachedSandbox;
         }
-        const hintedSandbox = await tryRestoreHintedSandbox();
+        signal?.throwIfAborted();
+        const hintedSandbox = await tryRestoreHintedSandbox(signal);
         if (hintedSandbox) {
           return hintedSandbox;
         }
-        return await createFreshSandbox();
+        return await createFreshSandbox(signal);
       }
     );
   };
-  const getOrAcquireSandbox = async () => {
-    if (acquiringSandbox) {
-      return await acquiringSandbox;
-    }
-    const nextSandbox = acquireSandbox();
-    acquiringSandbox = nextSandbox;
-    try {
-      return await nextSandbox;
-    } finally {
-      if (acquiringSandbox === nextSandbox) {
-        acquiringSandbox = void 0;
+  const getOrAcquireSandbox = async (signal) => {
+    for (; ; ) {
+      signal?.throwIfAborted();
+      let acquisition = acquiringSandbox;
+      if (!acquisition) {
+        const controller = new AbortController();
+        const startedAcquisition = {
+          controller,
+          promise: acquireSandbox(signal ? controller.signal : void 0),
+          settled: false,
+          waiters: 0
+        };
+        const markSettled = () => {
+          startedAcquisition.settled = true;
+          if (acquiringSandbox === startedAcquisition) {
+            acquiringSandbox = void 0;
+          }
+        };
+        void startedAcquisition.promise.then(markSettled, markSettled);
+        acquiringSandbox = startedAcquisition;
+        acquisition = startedAcquisition;
+      }
+      acquisition.waiters += 1;
+      let removeAbortListener;
+      try {
+        if (!signal) {
+          return await acquisition.promise;
+        }
+        const aborted = new Promise((_resolve, reject) => {
+          const onAbort = () => reject(signal.reason);
+          signal.addEventListener("abort", onAbort, { once: true });
+          removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+        });
+        return await Promise.race([acquisition.promise, aborted]);
+      } catch (error) {
+        signal?.throwIfAborted();
+        if (!acquisition.controller.signal.aborted) {
+          throw error;
+        }
+        if (acquiringSandbox === acquisition) {
+          acquiringSandbox = void 0;
+        }
+      } finally {
+        removeAbortListener?.();
+        acquisition.waiters -= 1;
+        if (acquisition.waiters === 0 && !acquisition.settled) {
+          acquisition.controller.abort(signal?.reason);
+        }
       }
     }
   };
@@ -3782,9 +3848,11 @@ function createSandboxRuntime(options) {
       runCommand: async (input) => await sandboxInstance.runCommand(input)
     };
   };
-  const ensureReadySandbox = async () => {
-    const activeSandbox2 = await getOrAcquireSandbox();
+  const ensureReadySandbox = async (signal) => {
+    const activeSandbox2 = await getOrAcquireSandbox(signal);
+    signal?.throwIfAborted();
     await probeSession(activeSandbox2);
+    signal?.throwIfAborted();
     await extendKeepAlive(activeSandbox2);
     startKeepAlive(activeSandbox2);
     return activeSandbox2;
@@ -3793,11 +3861,11 @@ function createSandboxRuntime(options) {
     sandboxRef() {
       return sandboxRef ? { ...sandboxRef } : void 0;
     },
-    async acquire() {
-      return await getOrAcquireSandbox();
+    async acquire(signal) {
+      return await getOrAcquireSandbox(signal);
     },
-    async tools() {
-      return createToolExecutors(await ensureReadySandbox());
+    async tools(signal) {
+      return createToolExecutors(await ensureReadySandbox(signal));
     },
     async refreshNetworkPolicy(traceHeaders) {
       const active = activeSandbox;
@@ -5319,14 +5387,14 @@ function createSandbox(options) {
       setToolCallSpanAttributes,
       fileSystem() {
         signal?.throwIfAborted();
-        return fileSystemPromise ??= runtime.tools().then(({ fs: fs5 }) => {
+        return fileSystemPromise ??= runtime.tools(signal).then(({ fs: fs5 }) => {
           signal?.throwIfAborted();
           return bindSandboxFileSystem(fs5, signal);
         });
       },
       commandRunner() {
         signal?.throwIfAborted();
-        return commandRunnerPromise ??= runtime.tools().then(({ runCommand }) => {
+        return commandRunnerPromise ??= runtime.tools(signal).then(({ runCommand }) => {
           signal?.throwIfAborted();
           return async (input) => await runCommand({
             ...input,
@@ -5382,7 +5450,7 @@ function createSandbox(options) {
     logSandboxBootRequest("tool.bash", {
       "app.sandbox.command_length": command.length
     });
-    const { bash: executeBash, sessionId: activeSessionId } = await runtime.tools();
+    const { bash: executeBash, sessionId: activeSessionId } = await runtime.tools(context.signal);
     await clearEgressSignals(activeSessionId);
     const result = await withSandboxToolSpan(
       "bash",
@@ -6490,6 +6558,7 @@ var McpToolManager = class {
     try {
       const client = await this.getClient(plugin);
       const tools = this.filterListedTools(plugin, await client.listTools());
+      this.assertWrappedToolsAvailable(plugin, tools);
       this.toolsByProvider.set(
         provider,
         tools.map((tool) => this.toManagedTool(plugin, client, tool))
@@ -6540,8 +6609,26 @@ var McpToolManager = class {
         `Plugin ${plugin.manifest.name} MCP discovery missing allowlisted tools: ${missingTools.join(", ")}`
       );
     }
-    const allowedToolSet = new Set(allowedTools);
-    return tools.filter((tool) => allowedToolSet.has(tool.name));
+    const loadedToolSet = /* @__PURE__ */ new Set([
+      ...allowedTools,
+      ...plugin.manifest.mcp?.wrappedTools ?? []
+    ]);
+    return tools.filter((tool) => loadedToolSet.has(tool.name));
+  }
+  assertWrappedToolsAvailable(plugin, tools) {
+    const wrappedTools = plugin.manifest.mcp?.wrappedTools ?? [];
+    if (wrappedTools.length === 0) {
+      return;
+    }
+    const availableToolNames = new Set(tools.map((tool) => tool.name));
+    const missingTools = wrappedTools.filter(
+      (toolName) => !availableToolNames.has(toolName)
+    );
+    if (missingTools.length > 0) {
+      throw new Error(
+        `Plugin ${plugin.manifest.name} MCP discovery missing wrapped tools: ${missingTools.join(", ")}`
+      );
+    }
   }
   async getClient(plugin) {
     const existing = this.clientsByProvider.get(plugin.manifest.name);
@@ -6627,8 +6714,13 @@ var McpToolManager = class {
                   "gen_ai.tool.call.result": resultAttribute
                 });
               }
+              const providerContent = boundMcpContent(
+                toAgentToolContent(result)
+              );
               return {
-                content: toModelVisibleMcpContent(result)
+                content: toModelVisibleMcpContent(result),
+                providerContent,
+                ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
               };
             } catch (error) {
               if (error instanceof McpAuthorizationRequiredError && await this.handleAuthorizationRequired(
@@ -6639,7 +6731,9 @@ var McpToolManager = class {
                   { type: "text", text: "Authorization pending." }
                 ];
                 return {
-                  content: parkedContent
+                  authorizationPending: true,
+                  content: parkedContent,
+                  providerContent: parkedContent
                 };
               }
               const errorAttributes = {
@@ -6692,10 +6786,59 @@ var McpToolManager = class {
       if (options.provider && provider !== options.provider) {
         continue;
       }
-      resolved.push(...this.toolsByProvider.get(provider) ?? []);
+      const wrappedTools = new Set(
+        this.pluginsByProvider.get(provider)?.manifest.mcp?.wrappedTools ?? []
+      );
+      resolved.push(
+        ...(this.toolsByProvider.get(provider) ?? []).filter(
+          (tool) => !wrappedTools.has(tool.rawName)
+        )
+      );
     }
     return resolved;
   }
+  /** Call one active provider tool declared for plugin-owned wrapping. */
+  async callWrappedTool(provider, rawName, args, options) {
+    if (!this.activeProviders.has(provider)) {
+      throw new McpToolError(`MCP provider is not active: ${provider}`);
+    }
+    const wrappedTools = new Set(
+      this.pluginsByProvider.get(provider)?.manifest.mcp?.wrappedTools ?? []
+    );
+    if (!wrappedTools.has(rawName)) {
+      throw new McpToolError(
+        `Plugin ${provider} cannot call unwrapped MCP tool ${rawName}`
+      );
+    }
+    const tool = (this.toolsByProvider.get(provider) ?? []).find(
+      (candidate) => candidate.rawName === rawName
+    );
+    if (!tool) {
+      throw new McpToolError(
+        `MCP provider ${provider} does not expose tool ${rawName}`
+      );
+    }
+    let result;
+    try {
+      result = await tool.execute(args, {
+        conversationPrivacy: "private",
+        ...options?.toolCallId ? { toolCallId: options.toolCallId } : {}
+      });
+    } catch (error) {
+      if (error instanceof McpToolError) {
+        return { status: "error", message: error.message };
+      }
+      throw error;
+    }
+    if (result.authorizationPending) {
+      return { status: "authorization_pending" };
+    }
+    return {
+      status: "success",
+      content: result.providerContent ?? result.content,
+      ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
+    };
+  }
   toToolDescriptor(tool) {
     return {
       name: tool.name,
@@ -7451,7 +7594,7 @@ function createViewImageTool(sandbox, supportsImageInput, deps = {}) {
 import { z as z16 } 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.",
+    description: "Update the user-visible assistant loading message with a short progress phase. Use this only for work with multiple substantive phases or a materially long wait. Skip short lookups, routine commands, generic filler, and minor substeps. After an initial update, 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').",
     inputSchema: z16.object({
       message: z16.string().min(1).describe("Short user-facing progress message.")
     }),
@@ -10591,7 +10734,7 @@ var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
   const profileSchema = z38.enum(handoff.profiles);
   const handoffResultSchema = juniorToolResultSchema.extend({
-    model_profile: profileSchema
+    model_profile: modelProfileSchema
   });
   const profileNames = handoff.profiles.map((profile) => `\`${profile}\``).join(", ");
   return zodTool({
@@ -14976,15 +15119,21 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       activeModelProfile = args.profile;
       activeModelId = target.modelId;
     };
-    const requestHandoff = {
-      profiles: handoffProfiles,
-      execute: async (profile, options) => await scheduleHandoff({
-        profile,
-        signal: options.signal,
-        sourceMessages: [...agent.state.messages],
-        triggeringToolCallId: options.toolCallId
-      })
+    const handoffControlFor = (activeProfile) => {
+      const profiles = handoffProfiles.filter(
+        (profile) => profile !== activeProfile
+      );
+      return profiles.length > 0 ? {
+        profiles,
+        execute: async (profile, options) => await scheduleHandoff({
+          profile,
+          signal: options.signal,
+          sourceMessages: [...agent.state.messages],
+          triggeringToolCallId: options.toolCallId
+        })
+      } : void 0;
     };
+    const requestHandoff = handoffControlFor(activeModelProfile);
     setTags({
       ...runLogContext,
       modelId: activeModelId
@@ -15028,7 +15177,30 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     mcpToolManager = wiring.mcpToolManager;
     closeTools = wiring.close;
     const getPendingAuthPause = wiring.getPendingAuthPause;
-    const toolsAfterHandoff = wiring.agentTools;
+    const toolsWithoutHandoff = wiring.agentTools.filter(
+      (tool) => tool.name !== HANDOFF_TOOL_NAME
+    );
+    const handoffAgentTool = wiring.agentTools.find(
+      (tool) => tool.name === HANDOFF_TOOL_NAME
+    );
+    const toolsForActiveProfile = () => {
+      const handoff = handoffControlFor(activeModelProfile);
+      if (!handoff) {
+        return toolsWithoutHandoff;
+      }
+      if (!handoffAgentTool) {
+        throw new Error("Handoff control is missing its Pi tool");
+      }
+      const definition = createHandoffTool(handoff);
+      return wiring.agentTools.map(
+        (tool) => tool.name === HANDOFF_TOOL_NAME ? {
+          ...handoffAgentTool,
+          description: definition.description,
+          parameters: definition.inputSchema,
+          prepareArguments: definition.prepareArguments
+        } : tool
+      );
+    };
     const {
       baseInstructions,
       inputMessages,
@@ -15066,7 +15238,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       agent.state.messages = replacement;
       agent.state.model = model;
       agent.state.thinkingLevel = thinkingLevel;
-      agent.state.tools = toolsAfterHandoff;
+      const tools = toolsForActiveProfile();
+      agent.state.tools = tools;
       runResume.setBeforeMessageCount(replacement.length);
       runResume.setTurnStartMessageIndex(0);
       runResume.adoptCommittedBoundary(replacement);
@@ -15079,7 +15252,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         context: {
           systemPrompt: baseInstructions,
           messages: replacement,
-          tools: toolsAfterHandoff
+          tools
         },
         model,
         thinkingLevel

package/dist/{chunk-JSTGI7TX.js → chunk-WUP7NWMP.js}

@@ -1,6 +1,6 @@
 import {
   createPluginCatalogRuntime
-} from "./chunk-R53UT2OI.js";
+} from "./chunk-ET2SDCNV.js";
 
 // src/chat/plugins/catalog-runtime.ts
 var pluginCatalogRuntime = createPluginCatalogRuntime();

package/dist/{chunk-JXRAOOXQ.js → chunk-XDRGYDED.js}

@@ -1,6 +1,6 @@
 import {
   getDb
-} from "./chunk-D3N4BPSL.js";
+} from "./chunk-254MFDOF.js";
 import {
   juniorStats
 } from "./chunk-GCGJGSQL.js";

package/dist/{chunk-BNJEPYTC.js → chunk-Z2XXPUZG.js}

@@ -13,17 +13,17 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-D3N4BPSL.js";
+} from "./chunk-254MFDOF.js";
 import {
   getStateAdapter,
   sleep
-} from "./chunk-VJTWKJWQ.js";
+} from "./chunk-UURFXX66.js";
 import {
   botConfig,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-VLTWQQKH.js";
+} from "./chunk-IDXLBKPS.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -32,7 +32,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-ZJ6IVZVO.js";
+} from "./chunk-JZ47AFSH.js";
 import {
   isRecord,
   toOptionalNumber,