@sentry/junior 0.18.1 → 0.19.0

package/dist/app.js

@@ -2999,6 +2999,8 @@ function buildSystemPrompt(params) {
         "- If a loaded skill or `loadSkill` result declares `requires_capabilities`, run `jr-rpc issue-credential <capability> [--repo <owner/repo>]` as a bash command before authenticated bash/API work for that skill.",
         "- Use the minimum declared capability needed for the current operation.",
         "- If `jr-rpc issue-credential` returns `oauth_started`, relay its `message` to the user and stop. The runtime will resume after authorization.",
+        "- For disconnect + reconnect requests, run `jr-rpc delete-token <provider>` first, then `jr-rpc issue-credential` \u2014 the system handles the reconnect without auto-resuming the reconnect message.",
+        "- Use `jr-rpc oauth-start <provider>` only when the user explicitly asks to connect a provider and there is no task to resume after authorization.",
         "- GitHub capabilities need repository context, which can come from `--repo` or a configured `github.repo` default.",
         "- To persist or read conversation defaults (for example `github.repo`), run `jr-rpc config get|set|unset|list ...` as a bash command.",
         "- Capabilities are provider-qualified (for example `github.issues.write`).",
@@ -3539,6 +3541,52 @@ async function handleIssueCredentialCommand(args, deps) {
     });
   } catch (error) {
     if (error instanceof CredentialUnavailableError && getPluginOAuthConfig(error.provider) && deps.requesterId) {
+      const authAction = deps.providerAuthActions?.get(error.provider);
+      if (authAction?.kind === "oauth_started") {
+        const providerLabel = formatProviderLabel(error.provider);
+        return commandResult({
+          stdout: {
+            credential_unavailable: true,
+            oauth_started: true,
+            provider: error.provider,
+            private_delivery_sent: authAction.delivered,
+            message: authAction.delivered ? `I've already sent you a private authorization link to connect your ${providerLabel} account. Finish that flow, then return to Slack.` : `I still need to connect your ${providerLabel} account, but I wasn't able to send you a private authorization link. Please send me a direct message and try again.`
+          },
+          exitCode: 0
+        });
+      }
+      if (authAction?.kind === "token_deleted") {
+        const reconnectResult = await startOAuthFlow(error.provider, {
+          requesterId: deps.requesterId,
+          channelId: deps.channelId,
+          threadTs: deps.threadTs,
+          activeSkillName: deps.activeSkill?.name ?? void 0
+          // Intentionally no userMessage — reconnect flows must not auto-resume.
+        });
+        if (!reconnectResult.ok) {
+          return commandResult({
+            stderr: `${reconnectResult.error}
+`,
+            exitCode: 1
+          });
+        }
+        const delivered = !!reconnectResult.delivery;
+        deps.providerAuthActions?.set(error.provider, {
+          kind: "oauth_started",
+          delivered
+        });
+        const providerLabel = formatProviderLabel(error.provider);
+        return commandResult({
+          stdout: {
+            credential_unavailable: true,
+            oauth_started: true,
+            provider: error.provider,
+            private_delivery_sent: delivered,
+            message: delivered ? `I need to connect your ${providerLabel} account first. I've sent you a private authorization link.` : `I need to connect your ${providerLabel} account first, but I wasn't able to send you a private authorization link. Please send me a direct message and try your command again.`
+          },
+          exitCode: 0
+        });
+      }
       const oauthResult = await startOAuthFlow(error.provider, {
         requesterId: deps.requesterId,
         channelId: deps.channelId,
@@ -3808,6 +3856,10 @@ async function handleOAuthStartCommand(args, deps) {
     return commandResult({ stderr: `${result.error}
 `, exitCode: 1 });
   }
+  deps.providerAuthActions?.set(provider, {
+    kind: "oauth_started",
+    delivered: !!result.delivery
+  });
   if (!result.delivery) {
     return commandResult({
       stdout: {
@@ -3854,6 +3906,7 @@ async function handleDeleteTokenCommand(args, deps) {
     });
   }
   await unlinkProvider(deps.requesterId, provider, deps.userTokenStore);
+  deps.providerAuthActions?.set(provider, { kind: "token_deleted" });
   logInfo(
     "jr_rpc_delete_token",
     {},
@@ -6754,103 +6807,50 @@ function createToolState(hooks, context) {
     }
   };
 }
-function wrapToolExecution(toolName, toolDef, hooks) {
-  const maybeExecutable = toolDef;
-  if (!maybeExecutable.execute) {
-    return toolDef;
-  }
-  const originalExecute = maybeExecutable.execute.bind(toolDef);
-  maybeExecutable.execute = async (...args) => {
-    const input = args[0];
-    await hooks.onToolCallStart?.(toolName, input);
-    return originalExecute(...args);
-  };
-  return toolDef;
-}
 function createTools(availableSkills, hooks = {}, context) {
   const state = createToolState(hooks, context);
   const tools = {
-    loadSkill: wrapToolExecution(
-      "loadSkill",
-      createLoadSkillTool(context.sandbox, availableSkills, {
-        onSkillLoaded: hooks.onSkillLoaded
-      }),
-      hooks
-    ),
-    systemTime: wrapToolExecution("systemTime", createSystemTimeTool(), hooks),
-    bash: wrapToolExecution("bash", createBashTool(), hooks),
-    attachFile: wrapToolExecution(
-      "attachFile",
-      createAttachFileTool(context.sandbox, hooks),
-      hooks
-    ),
-    readFile: wrapToolExecution("readFile", createReadFileTool(), hooks),
-    writeFile: wrapToolExecution("writeFile", createWriteFileTool(), hooks),
-    webSearch: wrapToolExecution("webSearch", createWebSearchTool(), hooks),
-    webFetch: wrapToolExecution("webFetch", createWebFetchTool(hooks), hooks),
-    imageGenerate: wrapToolExecution(
-      "imageGenerate",
-      createImageGenerateTool(hooks, hooks.toolOverrides?.imageGenerate),
-      hooks
-    ),
-    slackCanvasUpdate: wrapToolExecution(
-      "slackCanvasUpdate",
-      createSlackCanvasUpdateTool(state, context),
-      hooks
-    ),
-    slackListCreate: wrapToolExecution(
-      "slackListCreate",
-      createSlackListCreateTool(state),
-      hooks
-    ),
-    slackListAddItems: wrapToolExecution(
-      "slackListAddItems",
-      createSlackListAddItemsTool(state),
-      hooks
-    ),
-    slackListGetItems: wrapToolExecution(
-      "slackListGetItems",
-      createSlackListGetItemsTool(state),
-      hooks
+    loadSkill: createLoadSkillTool(context.sandbox, availableSkills, {
+      onSkillLoaded: hooks.onSkillLoaded
+    }),
+    systemTime: createSystemTimeTool(),
+    bash: createBashTool(),
+    attachFile: createAttachFileTool(context.sandbox, hooks),
+    readFile: createReadFileTool(),
+    writeFile: createWriteFileTool(),
+    webSearch: createWebSearchTool(),
+    webFetch: createWebFetchTool(hooks),
+    imageGenerate: createImageGenerateTool(
+      hooks,
+      hooks.toolOverrides?.imageGenerate
     ),
-    slackListUpdateItem: wrapToolExecution(
-      "slackListUpdateItem",
-      createSlackListUpdateItemTool(state),
-      hooks
-    )
+    slackCanvasUpdate: createSlackCanvasUpdateTool(state, context),
+    slackListCreate: createSlackListCreateTool(state),
+    slackListAddItems: createSlackListAddItemsTool(state),
+    slackListGetItems: createSlackListGetItemsTool(state),
+    slackListUpdateItem: createSlackListUpdateItemTool(state)
   };
   if (context.mcpToolManager && context.getActiveSkills) {
-    tools.searchTools = wrapToolExecution(
-      "searchTools",
-      createSearchToolsTool(context.mcpToolManager, context.getActiveSkills),
-      hooks
+    tools.searchTools = createSearchToolsTool(
+      context.mcpToolManager,
+      context.getActiveSkills
     );
   }
   const { channelCapabilities } = context;
   if (channelCapabilities.canCreateCanvas) {
-    tools.slackCanvasCreate = wrapToolExecution(
-      "slackCanvasCreate",
-      createSlackCanvasCreateTool(context, state),
-      hooks
-    );
+    tools.slackCanvasCreate = createSlackCanvasCreateTool(context, state);
   }
   if (channelCapabilities.canPostToChannel) {
-    tools.slackChannelPostMessage = wrapToolExecution(
-      "slackChannelPostMessage",
-      createSlackChannelPostMessageTool(context, state),
-      hooks
-    );
-    tools.slackChannelListMessages = wrapToolExecution(
-      "slackChannelListMessages",
-      createSlackChannelListMessagesTool(context),
-      hooks
+    tools.slackChannelPostMessage = createSlackChannelPostMessageTool(
+      context,
+      state
     );
+    tools.slackChannelListMessages = createSlackChannelListMessagesTool(context);
   }
   if (channelCapabilities.canAddReactions) {
-    tools.slackMessageAddReaction = wrapToolExecution(
-      "slackMessageAddReaction",
-      createSlackMessageAddReactionTool(context, state),
-      hooks
+    tools.slackMessageAddReaction = createSlackMessageAddReactionTool(
+      context,
+      state
     );
   }
   return tools;
@@ -6973,6 +6973,267 @@ function extractHttpErrorDetails(error, options = {}) {
   };
 }
 
+// src/chat/runtime/status-format.ts
+var SLACK_STATUS_MAX_LENGTH = 50;
+function truncateWithEllipsis(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
+}
+function truncateStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
+}
+function compactStatusPath(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.length <= 80) {
+    return trimmed;
+  }
+  return `...${trimmed.slice(-77)}`;
+}
+function compactStatusText(value, maxLength = 80) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return truncateWithEllipsis(trimmed, maxLength);
+}
+function readShellToken(command, startIndex) {
+  let index = startIndex;
+  while (index < command.length && /\s/.test(command[index] ?? "")) {
+    index += 1;
+  }
+  if (index >= command.length) {
+    return void 0;
+  }
+  let token = "";
+  let quote;
+  while (index < command.length) {
+    const char = command[index];
+    if (!char) {
+      break;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        index += 1;
+        continue;
+      }
+      if (char === "\\" && quote === '"' && index + 1 < command.length) {
+        token += command[index + 1];
+        index += 2;
+        continue;
+      }
+      token += char;
+      index += 1;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      break;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      index += 1;
+      continue;
+    }
+    if (char === "\\" && index + 1 < command.length) {
+      token += command[index + 1];
+      index += 2;
+      continue;
+    }
+    token += char;
+    index += 1;
+  }
+  return { token, nextIndex: index };
+}
+function compactStatusCommand(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  let index = 0;
+  while (index < trimmed.length) {
+    const parsed = readShellToken(trimmed, index);
+    if (!parsed) {
+      return void 0;
+    }
+    index = parsed.nextIndex;
+    if (!parsed.token) {
+      continue;
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(parsed.token)) {
+      continue;
+    }
+    const normalized = parsed.token.replace(/[\\/]+$/g, "");
+    if (!normalized) {
+      return void 0;
+    }
+    const parts = normalized.split(/[\\/]/).filter((part) => part.length > 0);
+    const command = parts.length > 0 ? parts[parts.length - 1] : normalized;
+    return compactStatusText(command, 40);
+  }
+  return void 0;
+}
+function compactStatusFilename(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim().replace(/[\\/]+$/g, "");
+  if (!trimmed) {
+    return void 0;
+  }
+  const parts = trimmed.split(/[\\/]/).filter((part) => part.length > 0);
+  const filename = parts.length > 0 ? parts[parts.length - 1] : trimmed;
+  return compactStatusText(filename, 80);
+}
+function extractStatusUrlDomain(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    return parsed.hostname || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/chat/runtime/assistant-status.ts
+var STATUS_PATTERNS = {
+  thinking: {
+    defaultContext: "\u2026",
+    variants: ["Thinking", "Reasoning", "Considering", "Working through"]
+  },
+  searching: {
+    defaultContext: "sources",
+    variants: ["Searching", "Scanning", "Probing", "Trawling"]
+  },
+  reading: {
+    defaultContext: "task",
+    variants: ["Reading", "Inspecting", "Parsing", "Skimming"]
+  },
+  reviewing: {
+    defaultContext: "results",
+    variants: ["Reviewing", "Checking", "Inspecting", "Auditing"]
+  },
+  loading: {
+    defaultContext: "task",
+    variants: ["Loading", "Priming", "Booting", "Spinning up"]
+  },
+  updating: {
+    defaultContext: "state",
+    variants: ["Updating", "Patching", "Refreshing", "Adjusting"]
+  },
+  fetching: {
+    defaultContext: "sources",
+    variants: ["Fetching", "Pulling", "Retrieving", "Loading"]
+  },
+  creating: {
+    defaultContext: "draft",
+    variants: ["Creating", "Building", "Assembling", "Generating"]
+  },
+  listing: {
+    defaultContext: "items",
+    variants: ["Listing", "Gathering", "Collecting", "Enumerating"]
+  },
+  posting: {
+    defaultContext: "reply",
+    variants: ["Posting", "Sending", "Delivering", "Dispatching"]
+  },
+  adding: {
+    defaultContext: "details",
+    variants: ["Adding", "Applying", "Attaching", "Dropping in"]
+  },
+  running: {
+    defaultContext: "tasks",
+    variants: ["Running", "Executing", "Launching", "Processing"]
+  }
+};
+function makeAssistantStatus(kind, context) {
+  return { kind, ...context ? { context } : {} };
+}
+function normalizeAssistantStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+}
+function buildAssistantStatusPresentation(args) {
+  const random = args.random ?? Math.random;
+  const pattern = STATUS_PATTERNS[args.status.kind];
+  const context = normalizeAssistantStatusText(args.status.context ?? "") || pattern.defaultContext;
+  const index = Math.floor(random() * pattern.variants.length);
+  const verb = pattern.variants[index] ?? pattern.variants[0];
+  const visible = truncateStatusText(`${verb} ${context}`);
+  const hint = truncateStatusText(`${pattern.variants[0]} ${context}`);
+  return {
+    key: `${args.status.kind}:${context}`,
+    hint,
+    visible,
+    suggestions: Array.from(/* @__PURE__ */ new Set([visible, hint]))
+  };
+}
+function createSlackAdapterAssistantStatusTransport(args) {
+  return {
+    async setStatus(channelId, threadTs, status, suggestions) {
+      try {
+        await args.getSlackAdapter().setAssistantStatus(channelId, threadTs, status, suggestions);
+      } catch (error) {
+        logAssistantStatusFailure(status, error);
+      }
+    }
+  };
+}
+function createSlackWebApiAssistantStatusTransport(args) {
+  const getClient2 = args?.getSlackClient ?? getSlackClient;
+  return {
+    async setStatus(channelId, threadTs, status, suggestions) {
+      try {
+        await getClient2().assistant.threads.setStatus({
+          channel_id: channelId,
+          thread_ts: threadTs,
+          status,
+          ...suggestions ? { loading_messages: suggestions } : {}
+        });
+      } catch (error) {
+        logAssistantStatusFailure(status, error);
+      }
+    }
+  };
+}
+function logAssistantStatusFailure(status, error) {
+  logWarn(
+    "assistant_status_update_failed",
+    {},
+    {
+      "app.slack.status_text": status || "(clear)",
+      "error.message": error instanceof Error ? error.message : String(error)
+    },
+    "Failed to update assistant status"
+  );
+}
+
 // src/chat/sandbox/sandbox.ts
 var SANDBOX_TOOL_NAMES = /* @__PURE__ */ new Set(["bash", "readFile", "writeFile"]);
 var DEFAULT_MAX_OUTPUT_LENGTH = 3e4;
@@ -7465,7 +7726,7 @@ function createSandboxExecutor(options) {
   const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, onStatus) => {
     for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
       try {
-        await onStatus?.("Booting up...");
+        await onStatus?.(makeAssistantStatus("loading", "sandbox"));
         return await Sandbox.create({
           timeout: timeoutMs,
           source: {
@@ -7585,28 +7846,37 @@ function createSandboxExecutor(options) {
           let statusCount = 0;
           const sentStatuses = /* @__PURE__ */ new Set();
           const emitSandboxStatus = async (status) => {
-            if (!emitStatus || statusCount >= 4 || sentStatuses.has(status)) {
+            const statusKey = `${status.kind}:${status.context ?? ""}`;
+            if (!emitStatus || statusCount >= 4 || sentStatuses.has(statusKey)) {
               return;
             }
-            sentStatuses.add(status);
+            sentStatuses.add(statusKey);
             statusCount += 1;
             await emitStatus(status);
           };
           const reportSnapshotPhase = async (phase) => {
             if (phase === "resolve_start") {
-              await emitSandboxStatus("Checking sandbox snapshot cache...");
+              await emitSandboxStatus(
+                makeAssistantStatus("loading", "sandbox snapshot cache")
+              );
               return;
             }
             if (phase === "waiting_for_lock") {
-              await emitSandboxStatus("Waiting for sandbox snapshot build...");
+              await emitSandboxStatus(
+                makeAssistantStatus("loading", "sandbox snapshot build")
+              );
               return;
             }
             if (phase === "building_snapshot") {
-              await emitSandboxStatus("Building sandbox snapshot...");
+              await emitSandboxStatus(
+                makeAssistantStatus("creating", "sandbox snapshot")
+              );
               return;
             }
             if (phase === "cache_hit") {
-              await emitSandboxStatus("Using cached sandbox snapshot...");
+              await emitSandboxStatus(
+                makeAssistantStatus("loading", "sandbox snapshot")
+              );
             }
           };
           let createdSandbox;
@@ -7620,7 +7890,9 @@ function createSandboxExecutor(options) {
                 "app.sandbox.runtime": runtime
               },
               async () => {
-                await emitSandboxStatus("Preparing sandbox runtime...");
+                await emitSandboxStatus(
+                  makeAssistantStatus("loading", "sandbox runtime")
+                );
                 const snapshot = await resolveRuntimeDependencySnapshot({
                   runtime,
                   timeoutMs,
@@ -7639,7 +7911,9 @@ function createSandboxExecutor(options) {
                   } : {}
                 });
                 if (!snapshot.snapshotId) {
-                  await emitSandboxStatus("Booting up...");
+                  await emitSandboxStatus(
+                    makeAssistantStatus("loading", "sandbox")
+                  );
                   return await Sandbox.create({
                     timeout: timeoutMs,
                     runtime,
@@ -8069,219 +8343,74 @@ function shouldEmitDevAgentTrace() {
   return process.env.NODE_ENV === "development";
 }
 
-// src/chat/runtime/status-format.ts
-var SLACK_STATUS_MAX_LENGTH = 50;
-function truncateWithEllipsis(text, maxLength) {
-  if (text.length <= maxLength) {
-    return text;
+// src/chat/runtime/tool-status.ts
+function buildToolStatus(toolName, input) {
+  const obj = input && typeof input === "object" ? input : void 0;
+  const command = obj ? compactStatusCommand(obj.command) : void 0;
+  const path6 = obj ? compactStatusPath(obj.path) : void 0;
+  const filename = obj ? compactStatusFilename(obj.path) : void 0;
+  const query = obj ? compactStatusText(obj.query, 70) : void 0;
+  const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
+  const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
+  const provider = obj ? compactStatusText(obj.provider, 20) : void 0;
+  if (command && toolName === "bash") {
+    return makeAssistantStatus("running", command);
   }
-  return `${text.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
-}
-function truncateStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
-}
-function compactStatusPath(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  if (trimmed.length <= 80) {
-    return trimmed;
-  }
-  return `...${trimmed.slice(-77)}`;
-}
-function compactStatusText(value, maxLength = 80) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  return truncateWithEllipsis(trimmed, maxLength);
-}
-function readShellToken(command, startIndex) {
-  let index = startIndex;
-  while (index < command.length && /\s/.test(command[index] ?? "")) {
-    index += 1;
-  }
-  if (index >= command.length) {
-    return void 0;
-  }
-  let token = "";
-  let quote;
-  while (index < command.length) {
-    const char = command[index];
-    if (!char) {
-      break;
-    }
-    if (quote) {
-      if (char === quote) {
-        quote = void 0;
-        index += 1;
-        continue;
-      }
-      if (char === "\\" && quote === '"' && index + 1 < command.length) {
-        token += command[index + 1];
-        index += 2;
-        continue;
-      }
-      token += char;
-      index += 1;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      break;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      index += 1;
-      continue;
-    }
-    if (char === "\\" && index + 1 < command.length) {
-      token += command[index + 1];
-      index += 2;
-      continue;
-    }
-    token += char;
-    index += 1;
-  }
-  return { token, nextIndex: index };
-}
-function compactStatusCommand(value) {
-  if (typeof value !== "string") {
-    return void 0;
+  if (filename && toolName === "readFile") {
+    return makeAssistantStatus("reading", filename);
   }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
+  if (filename && toolName === "writeFile") {
+    return makeAssistantStatus("updating", filename);
   }
-  let index = 0;
-  while (index < trimmed.length) {
-    const parsed = readShellToken(trimmed, index);
-    if (!parsed) {
-      return void 0;
-    }
-    index = parsed.nextIndex;
-    if (!parsed.token) {
-      continue;
-    }
-    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(parsed.token)) {
-      continue;
-    }
-    const normalized = parsed.token.replace(/[\\/]+$/g, "");
-    if (!normalized) {
-      return void 0;
-    }
-    const parts = normalized.split(/[\\/]/).filter((part) => part.length > 0);
-    const command = parts.length > 0 ? parts[parts.length - 1] : normalized;
-    return compactStatusText(command, 40);
+  if (path6 && toolName === "writeFile") {
+    return makeAssistantStatus("updating", path6);
   }
-  return void 0;
-}
-function compactStatusFilename(value) {
-  if (typeof value !== "string") {
-    return void 0;
+  if (skillName && toolName === "loadSkill") {
+    return makeAssistantStatus("loading", skillName);
   }
-  const trimmed = value.trim().replace(/[\\/]+$/g, "");
-  if (!trimmed) {
-    return void 0;
+  if (query && toolName === "webSearch") {
+    return makeAssistantStatus("searching", `"${query}"`);
   }
-  const parts = trimmed.split(/[\\/]/).filter((part) => part.length > 0);
-  const filename = parts.length > 0 ? parts[parts.length - 1] : trimmed;
-  return compactStatusText(filename, 80);
-}
-function extractStatusUrlDomain(value) {
-  if (typeof value !== "string") {
-    return void 0;
+  if (query && provider && toolName === "searchTools") {
+    return makeAssistantStatus("searching", `${provider} "${query}"`);
   }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
+  if (query && toolName === "searchTools") {
+    return makeAssistantStatus("searching", `"${query}"`);
   }
-  try {
-    const parsed = new URL(trimmed);
-    return parsed.hostname || void 0;
-  } catch {
-    return void 0;
+  if (domain && toolName === "webFetch") {
+    return makeAssistantStatus("fetching", domain);
   }
-}
-
-// src/chat/runtime/tool-status.ts
-function formatToolStatus(toolName) {
   const known = {
-    loadSkill: "Loading skill instructions",
-    systemTime: "Reading current system time",
-    bash: "Working in the shell",
-    readFile: "Reading a file",
-    writeFile: "Updating a file",
-    webSearch: "Searching public sources",
-    webFetch: "Reading source pages",
-    slackChannelPostMessage: "Posting message to channel",
-    slackMessageAddReaction: "Adding emoji reaction",
-    slackChannelListMessages: "Listing channel messages",
-    slackCanvasCreate: "Creating detailed brief",
-    slackCanvasUpdate: "Updating detailed brief",
-    slackListCreate: "Creating tracking list",
-    slackListAddItems: "Updating tracking list",
-    slackListUpdateItem: "Updating tracking list",
-    imageGenerate: "Generating image",
-    searchTools: "Searching active tools"
+    loadSkill: makeAssistantStatus("loading", "skill instructions"),
+    systemTime: makeAssistantStatus("reading", "system time"),
+    bash: makeAssistantStatus("running", "shell"),
+    readFile: makeAssistantStatus("reading", "file"),
+    writeFile: makeAssistantStatus("updating", "file"),
+    webSearch: makeAssistantStatus("searching", "sources"),
+    webFetch: makeAssistantStatus("fetching", "pages"),
+    slackChannelPostMessage: makeAssistantStatus("posting", "channel"),
+    slackMessageAddReaction: makeAssistantStatus("adding", "reaction"),
+    slackChannelListMessages: makeAssistantStatus("listing", "messages"),
+    slackCanvasCreate: makeAssistantStatus("creating", "brief"),
+    slackCanvasUpdate: makeAssistantStatus("updating", "brief"),
+    slackListCreate: makeAssistantStatus("creating", "tracking list"),
+    slackListAddItems: makeAssistantStatus("updating", "tracking list"),
+    slackListUpdateItem: makeAssistantStatus("updating", "tracking list"),
+    imageGenerate: makeAssistantStatus("creating", "image"),
+    searchTools: makeAssistantStatus(
+      "searching",
+      provider ? `${provider} tools` : "tools"
+    )
   };
   if (known[toolName]) {
     return known[toolName];
   }
   const mcpMatch = /^mcp__([^_]+)__(.+)$/.exec(toolName);
   if (mcpMatch) {
-    return `Running ${mcpMatch[1]}/${mcpMatch[2]}`;
+    return makeAssistantStatus("running", `${mcpMatch[1]}/${mcpMatch[2]}`);
   }
   const readable = toolName.replaceAll("_", " ").trim();
-  return readable.length > 0 ? `Running ${readable}` : "Running tool";
-}
-function formatToolStatusWithInput(toolName, input) {
-  const obj = input && typeof input === "object" ? input : void 0;
-  const command = obj ? compactStatusCommand(obj.command) : void 0;
-  const path6 = obj ? compactStatusPath(obj.path) : void 0;
-  const filename = obj ? compactStatusFilename(obj.path) : void 0;
-  const query = obj ? compactStatusText(obj.query, 70) : void 0;
-  const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
-  const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
-  const provider = obj ? compactStatusText(obj.provider, 20) : void 0;
-  if (command && toolName === "bash") {
-    return `Running ${command}`;
-  }
-  if (filename && toolName === "readFile") {
-    return `Reading file ${filename}`;
-  }
-  if (filename && toolName === "writeFile") {
-    return `Updating file ${filename}`;
-  }
-  if (path6 && toolName === "writeFile") {
-    return `Updating file ${path6}`;
-  }
-  if (skillName && toolName === "loadSkill") {
-    return `Loading skill ${skillName}`;
-  }
-  if (query && toolName === "webSearch") {
-    return `Searching web for "${query}"`;
-  }
-  if (query && provider && toolName === "searchTools") {
-    return `Searching ${provider} tools for "${query}"`;
-  }
-  if (query && toolName === "searchTools") {
-    return `Searching tools for "${query}"`;
-  }
-  if (domain && toolName === "webFetch") {
-    return `Fetching page from ${domain}`;
-  }
-  return formatToolStatus(toolName);
+  return makeAssistantStatus("running", readable || "tool");
 }
 
 // src/chat/tools/execution/build-sandbox-input.ts
@@ -8432,7 +8561,7 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
         turnId: spanContext.turnId,
         agentId: spanContext.agentId
       };
-      await onStatus?.(`${formatToolStatusWithInput(toolName, params)}...`);
+      await onStatus?.(buildToolStatus(toolName, params));
       return withSpan(
         `execute_tool ${toolName}`,
         "gen_ai.execute_tool",
@@ -9098,6 +9227,7 @@ async function generateAssistantReply(messageText, context = {}) {
       requesterId: context.requester?.userId,
       resolveConfiguration: async (key) => configurationValues[key]
     });
+    const providerAuthActions = /* @__PURE__ */ new Map();
     const sandboxExecutor = createSandboxExecutor({
       sandboxId: context.sandbox?.sandboxId,
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
@@ -9113,6 +9243,7 @@ async function generateAssistantReply(messageText, context = {}) {
           threadTs: context.correlation?.threadTs,
           userMessage: userInput,
           userTokenStore: createUserTokenStore(),
+          providerAuthActions,
           onConfigurationValueChanged: (key, value) => {
             if (value === void 0) {
               delete configurationValues[key];
@@ -9201,11 +9332,6 @@ async function generateAssistantReply(messageText, context = {}) {
         onArtifactStatePatch: (patch) => {
           Object.assign(artifactStatePatch, patch);
         },
-        onToolCallStart: async (toolName, input) => {
-          await context.onStatus?.(
-            `${formatToolStatusWithInput(toolName, input)}...`
-          );
-        },
         toolOverrides: context.toolOverrides,
         onSkillLoaded: async (loadedSkill) => {
           const resolvedSkill = await skillSandbox.loadSkill(loadedSkill.name);
@@ -9559,6 +9685,152 @@ async function generateAssistantReply(messageText, context = {}) {
   }
 }
 
+// src/chat/runtime/progress-reporter.ts
+var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
+var STATUS_MIN_VISIBLE_MS = 1200;
+var STATUS_ROTATION_INTERVAL_MS = 3e4;
+function createProgressReporter(args) {
+  const now = args.now ?? (() => Date.now());
+  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
+  const random = args.random ?? Math.random;
+  let active = false;
+  let currentKey = "";
+  let currentStatus = makeAssistantStatus("thinking");
+  let currentVisibleStatus = "";
+  let lastStatusAt = 0;
+  let pendingStatus = null;
+  let pendingKey = "";
+  let pendingTimer = null;
+  let rotationTimer = null;
+  let inflightStatusUpdate = Promise.resolve();
+  const scheduleRotation = () => {
+    if (rotationTimer) {
+      clearTimer(rotationTimer);
+      rotationTimer = null;
+    }
+    if (!active || !currentVisibleStatus) {
+      return;
+    }
+    rotationTimer = setTimer(() => {
+      rotationTimer = null;
+      if (!active || !currentVisibleStatus) {
+        return;
+      }
+      void postRenderedStatus(currentStatus);
+    }, STATUS_ROTATION_INTERVAL_MS);
+  };
+  const postStatus = async (text, suggestions) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
+    }
+    if (!text && !currentVisibleStatus) {
+      return;
+    }
+    currentVisibleStatus = text;
+    lastStatusAt = now();
+    scheduleRotation();
+    const previous = inflightStatusUpdate;
+    const request = (async () => {
+      await previous;
+      await args.transport.setStatus(channelId, threadTs, text, suggestions);
+    })();
+    inflightStatusUpdate = request;
+    await request;
+  };
+  const postRenderedStatus = async (status) => {
+    const presentation = buildAssistantStatusPresentation({
+      status,
+      random
+    });
+    currentStatus = status;
+    currentKey = presentation.key;
+    await postStatus(presentation.visible, presentation.suggestions);
+  };
+  const clearPending = () => {
+    if (pendingTimer) {
+      clearTimer(pendingTimer);
+      pendingTimer = null;
+    }
+    pendingStatus = null;
+    pendingKey = "";
+  };
+  const flushPending = async () => {
+    if (!active || !pendingStatus) {
+      clearPending();
+      return;
+    }
+    const next = pendingStatus;
+    clearPending();
+    const nextPresentation = buildAssistantStatusPresentation({
+      status: next,
+      random
+    });
+    if (nextPresentation.key !== currentKey) {
+      await postRenderedStatus(next);
+    }
+  };
+  return {
+    async start() {
+      active = true;
+      clearPending();
+      currentStatus = makeAssistantStatus("thinking");
+      currentKey = "";
+      void postRenderedStatus(currentStatus);
+    },
+    async stop() {
+      active = false;
+      clearPending();
+      if (rotationTimer) {
+        clearTimer(rotationTimer);
+        rotationTimer = null;
+      }
+      currentKey = "";
+      await postStatus("");
+    },
+    async setStatus(status) {
+      if (!active) {
+        return;
+      }
+      const presentation = buildAssistantStatusPresentation({
+        status,
+        random
+      });
+      if (!presentation.visible) {
+        return;
+      }
+      if (presentation.key === currentKey || presentation.key === pendingKey) {
+        return;
+      }
+      const elapsed = now() - lastStatusAt;
+      const waitMs = Math.max(
+        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
+        STATUS_MIN_VISIBLE_MS - elapsed,
+        0
+      );
+      if (waitMs <= 0) {
+        clearPending();
+        void postRenderedStatus(status);
+        return;
+      }
+      pendingStatus = status;
+      pendingKey = presentation.key;
+      if (pendingTimer) {
+        return;
+      }
+      pendingTimer = setTimer(
+        () => {
+          pendingTimer = null;
+          void flushPending();
+        },
+        Math.max(1, waitMs)
+      );
+    }
+  };
+}
+
 // src/handlers/oauth-resume.ts
 function resolveReplyTimeoutMs(explicitTimeoutMs) {
   if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
@@ -9581,69 +9853,6 @@ async function postSlackMessage(channelId, threadTs, text) {
   } catch {
   }
 }
-async function setAssistantStatus(channelId, threadTs, status) {
-  try {
-    await getSlackClient().assistant.threads.setStatus({
-      channel_id: channelId,
-      thread_ts: threadTs,
-      status
-    });
-  } catch {
-  }
-}
-var STATUS_DEBOUNCE_MS = 1e3;
-function createDebouncedStatusPoster(channelId, threadTs) {
-  let lastPostAt = 0;
-  let currentStatus = "";
-  let pendingStatus = null;
-  let pendingTimer = null;
-  let stopped = false;
-  const flush = async () => {
-    if (stopped || !pendingStatus) return;
-    const status = pendingStatus;
-    pendingStatus = null;
-    pendingTimer = null;
-    lastPostAt = Date.now();
-    currentStatus = status;
-    await setAssistantStatus(channelId, threadTs, status);
-  };
-  const post = async (status) => {
-    if (stopped) return;
-    const truncated = truncateStatusText(status);
-    if (!truncated || truncated === currentStatus) return;
-    const now = Date.now();
-    const elapsed = now - lastPostAt;
-    if (elapsed >= STATUS_DEBOUNCE_MS) {
-      if (pendingTimer) {
-        clearTimeout(pendingTimer);
-        pendingTimer = null;
-      }
-      pendingStatus = null;
-      lastPostAt = now;
-      currentStatus = truncated;
-      await setAssistantStatus(channelId, threadTs, truncated);
-      return;
-    }
-    pendingStatus = truncated;
-    if (!pendingTimer) {
-      pendingTimer = setTimeout(
-        () => {
-          void flush();
-        },
-        Math.max(1, STATUS_DEBOUNCE_MS - elapsed)
-      );
-    }
-  };
-  post.stop = () => {
-    stopped = true;
-    if (pendingTimer) {
-      clearTimeout(pendingTimer);
-      pendingTimer = null;
-    }
-    pendingStatus = null;
-  };
-  return post;
-}
 function createReadOnlyConfigService(values) {
   const entries = Object.entries(values).map(([key, value]) => ({
     key,
@@ -9671,9 +9880,13 @@ function createReadOnlyConfigService(values) {
   };
 }
 async function resumeAuthorizedRequest(args) {
-  const postStatus = createDebouncedStatusPoster(args.channelId, args.threadTs);
+  const progress = createProgressReporter({
+    channelId: args.channelId,
+    threadTs: args.threadTs,
+    transport: createSlackWebApiAssistantStatusTransport()
+  });
   await postSlackMessage(args.channelId, args.threadTs, args.connectedText);
-  await setAssistantStatus(args.channelId, args.threadTs, "Thinking...");
+  await progress.start();
   try {
     const generateReply = args.generateReply ?? generateAssistantReply;
     const replyPromise = generateReply(args.messageText, {
@@ -9691,7 +9904,7 @@ async function resumeAuthorizedRequest(args) {
       artifactState: args.artifactState,
       configuration: args.configuration,
       channelConfiguration: args.configuration ? createReadOnlyConfigService(args.configuration) : void 0,
-      onStatus: postStatus
+      onStatus: (status) => progress.setStatus(status)
     });
     const replyTimeoutMs = resolveReplyTimeoutMs(args.replyTimeoutMs);
     const reply = typeof replyTimeoutMs === "number" ? await Promise.race([
@@ -9707,8 +9920,7 @@ async function resumeAuthorizedRequest(args) {
         )
       )
     ]) : await replyPromise;
-    postStatus.stop();
-    await setAssistantStatus(args.channelId, args.threadTs, "");
+    await progress.stop();
     if (args.onReply) {
       await args.onReply(reply);
     } else if (reply.text) {
@@ -9716,8 +9928,7 @@ async function resumeAuthorizedRequest(args) {
     }
     await args.onSuccess?.(reply);
   } catch (error) {
-    postStatus.stop();
-    await setAssistantStatus(args.channelId, args.threadTs, "");
+    await progress.stop();
     if (isRetryableTurnError(error, "mcp_auth_resume") && args.onAuthPause) {
       await args.onAuthPause(error);
       return;
@@ -11593,111 +11804,6 @@ function createJuniorRuntimeServices(overrides = {}) {
   };
 }
 
-// src/chat/runtime/progress-reporter.ts
-var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
-var STATUS_MIN_VISIBLE_MS = 1200;
-function createProgressReporter(args) {
-  const now = args.now ?? (() => Date.now());
-  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
-  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
-  let active = false;
-  let currentStatus = "";
-  let lastStatusAt = 0;
-  let pendingStatus = null;
-  let pendingTimer = null;
-  let inflightStatusUpdate = Promise.resolve();
-  const postStatus = async (text) => {
-    const channelId = args.channelId;
-    const threadTs = args.threadTs;
-    if (!channelId || !threadTs) {
-      return;
-    }
-    if (!text && !currentStatus) {
-      return;
-    }
-    currentStatus = text;
-    lastStatusAt = now();
-    const suggestions = text ? [text] : void 0;
-    const previous = inflightStatusUpdate;
-    const request = (async () => {
-      await previous;
-      try {
-        await args.setAssistantStatus(channelId, threadTs, text, suggestions);
-      } catch (error) {
-        logWarn(
-          "assistant_status_update_failed",
-          {},
-          {
-            "app.slack.status_text": text || "(clear)",
-            "error.message": error instanceof Error ? error.message : String(error)
-          },
-          "Failed to update assistant status"
-        );
-      }
-    })();
-    inflightStatusUpdate = request;
-    await request;
-  };
-  const clearPending = () => {
-    if (pendingTimer) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    pendingStatus = null;
-  };
-  const flushPending = async () => {
-    if (!active || !pendingStatus) {
-      clearPending();
-      return;
-    }
-    const next = pendingStatus;
-    clearPending();
-    if (next !== currentStatus) {
-      await postStatus(next);
-    }
-  };
-  return {
-    async start() {
-      active = true;
-      clearPending();
-      void postStatus("Thinking...");
-    },
-    async stop() {
-      active = false;
-      clearPending();
-      await postStatus("");
-    },
-    async setStatus(text) {
-      const truncated = truncateStatusText(text);
-      if (!active || !truncated || truncated === currentStatus || truncated === pendingStatus) {
-        return;
-      }
-      const elapsed = now() - lastStatusAt;
-      const waitMs = Math.max(
-        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
-        STATUS_MIN_VISIBLE_MS - elapsed,
-        0
-      );
-      if (waitMs <= 0) {
-        clearPending();
-        void postStatus(truncated);
-        return;
-      }
-      pendingStatus = truncated;
-      if (pendingTimer) {
-        return;
-      }
-      pendingTimer = setTimer(
-        () => {
-          pendingTimer = null;
-          void flushPending();
-        },
-        Math.max(1, waitMs)
-      );
-    }
-  };
-}
-
 // src/chat/runtime/streaming.ts
 function createTextStreamBridge() {
   const queue = [];
@@ -11738,36 +11844,6 @@ function createTextStreamBridge() {
     }
   };
 }
-function createNormalizingStream(inner, normalize) {
-  return {
-    async *[Symbol.asyncIterator]() {
-      let accumulated = "";
-      let emitted = 0;
-      for await (const chunk of inner) {
-        accumulated += chunk;
-        const lastNewline = accumulated.lastIndexOf("\n");
-        if (lastNewline === -1) {
-          const delta2 = accumulated.slice(emitted);
-          if (delta2) {
-            yield delta2;
-            emitted = accumulated.length;
-          }
-          continue;
-        }
-        const stable = accumulated.slice(0, lastNewline + 1);
-        const normalized = normalize(stable);
-        const delta = normalized.slice(emitted);
-        emitted = normalized.length;
-        if (delta) yield delta;
-      }
-      if (accumulated) {
-        const normalized = normalize(accumulated);
-        const delta = normalized.slice(emitted);
-        if (delta) yield delta;
-      }
-    }
-  };
-}
 
 // src/chat/runtime/reply-executor.ts
 function getExecutionFailureReason(reply) {
@@ -11881,7 +11957,9 @@ function createReplyToThread(deps) {
         const progress = createProgressReporter({
           channelId,
           threadTs,
-          setAssistantStatus: (channel, thread2, text, suggestions) => deps.getSlackAdapter().setAssistantStatus(channel, thread2, text, suggestions)
+          transport: createSlackAdapterAssistantStatusTransport({
+            getSlackAdapter: deps.getSlackAdapter
+          })
         });
         const textStream = createTextStreamBridge();
         let streamedReplyPromise;
@@ -11898,10 +11976,7 @@ function createReplyToThread(deps) {
           if (!streamedReplyPromise) {
             const streamingReply = (async () => {
               return await postThreadReply(
-                createNormalizingStream(
-                  textStream.iterable,
-                  ensureBlockSpacing
-                ),
+                textStream.iterable,
                 "streaming_initial_post"
               );
             })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "private": false,
   "publishConfig": {
     "access": "public"