@sentry/junior 0.104.1 → 0.105.0

package/dist/{chunk-TMWUGGSA.js → chunk-NJJFU6CP.js}

@@ -616,9 +616,6 @@ function isNoReplyMarker(text) {
 function containsNoReplyMarker(text) {
   return text.includes(NO_REPLY_MARKER);
 }
-function stripNoReplyMarker(text) {
-  return text.replaceAll(NO_REPLY_MARKER, "").trim();
-}
 
 // src/chat/services/turn-result.ts
 function isExecutionDeferralResponse(text) {
@@ -731,7 +728,8 @@ function buildTurnResult(input) {
   ).trim();
   const exactNoReplyMarker = isNoReplyMarker(rawPrimaryText);
   const mixedNoReplyMarker = !exactNoReplyMarker && containsNoReplyMarker(rawPrimaryText);
-  const primaryText = exactNoReplyMarker ? "" : mixedNoReplyMarker ? stripNoReplyMarker(rawPrimaryText) : rawPrimaryText;
+  const noReplyRequested = exactNoReplyMarker || mixedNoReplyMarker;
+  const primaryText = noReplyRequested ? "" : rawPrimaryText;
   const toolErrorCount = toolResults.filter((result) => result.isError).length;
   const successfulToolResults = toolResults.filter(
     (result) => !isToolResultError(result)
@@ -741,7 +739,7 @@ function buildTurnResult(input) {
   );
   const canvasCreated = successfulToolNames.has("slackCanvasCreate");
   const reactionPerformed = successfulToolNames.has("addReaction");
-  const silentCompletionSuccess = exactNoReplyMarker;
+  const silentCompletionSuccess = noReplyRequested;
   const baseDeliveryPlan = {
     mode: "thread",
     postThreadText: true
@@ -6814,8 +6812,129 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
   });
 }
 
-// src/chat/slack/tools/message-add-reaction.ts
+// src/chat/slack/tools/public-search.ts
 import { z as z20 } from "zod";
+var DEFAULT_LIMIT2 = 10;
+var optionalTimestampSchema = z20.preprocess(
+  (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
+  z20.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
+);
+var searchMessageSchema = z20.object({
+  author_name: z20.string().optional(),
+  author_user_id: z20.string().optional(),
+  channel_id: z20.string().min(1),
+  channel_name: z20.string().optional(),
+  message_ts: z20.string().min(1),
+  content: z20.string(),
+  is_author_bot: z20.boolean().optional(),
+  permalink: z20.string().url()
+});
+var publicSearchOutputSchema = juniorToolResultSchema.extend({
+  query: z20.string(),
+  count: z20.number().int().nonnegative(),
+  messages: z20.array(searchMessageSchema),
+  next_cursor: z20.string().optional()
+});
+function normalizeMessage(value) {
+  const parsed = searchMessageSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function explicitSearchError(error) {
+  if (error.code === "missing_scope") {
+    return "Public Slack search is unavailable because this installation is missing the `search:read.public` scope.";
+  }
+  if (error.code === "feature_unavailable") {
+    return "Public Slack search is not available for this Slack workspace or app installation.";
+  }
+  if (error.apiError === "invalid_action_token") {
+    return "Public Slack search could not use the current Slack interaction token. Ask again in a new message or mention.";
+  }
+  return void 0;
+}
+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: z20.object({
+      query: z20.string().trim().min(1).max(500).describe(
+        "A focused Slack search query, including Slack search filters when useful."
+      ),
+      after: optionalTimestampSchema.describe(
+        "Optional Unix timestamp lower bound."
+      ),
+      before: optionalTimestampSchema.describe(
+        "Optional Unix timestamp upper bound."
+      ),
+      cursor: z20.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z20.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z20.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z20.enum(["asc", "desc"]).describe("Sort direction.").optional()
+    }),
+    outputSchema: publicSearchOutputSchema,
+    execute: async ({
+      query,
+      after,
+      before,
+      cursor,
+      limit,
+      sort,
+      sort_dir
+    }) => {
+      try {
+        const normalizedAfter = optionalTimestampSchema.parse(after);
+        const normalizedBefore = optionalTimestampSchema.parse(before);
+        const response = await withSlackRetries(
+          () => getSlackClient().apiCall("assistant.search.context", {
+            action_token: actionToken,
+            query,
+            channel_types: ["public_channel"],
+            content_types: ["messages"],
+            include_bots: true,
+            limit: limit ?? DEFAULT_LIMIT2,
+            ...normalizedAfter !== void 0 ? { after: normalizedAfter } : {},
+            ...normalizedBefore !== void 0 ? { before: normalizedBefore } : {},
+            ...cursor ? { cursor } : {},
+            ...sort ? { sort } : {},
+            ...sort_dir ? { sort_dir } : {}
+          }),
+          3,
+          {
+            action: "assistant.search.context",
+            idempotent: true
+          }
+        );
+        const messages = (response.results?.messages ?? []).map(normalizeMessage).filter((message) => Boolean(message));
+        const nextCursor = response.results?.next_cursor;
+        return {
+          ok: true,
+          status: "success",
+          query,
+          count: messages.length,
+          messages,
+          ...typeof nextCursor === "string" && nextCursor ? { next_cursor: nextCursor } : {}
+        };
+      } catch (error) {
+        if (error instanceof SlackActionError) {
+          const message = explicitSearchError(error);
+          if (message) {
+            return {
+              ok: false,
+              status: "error",
+              error: message,
+              query,
+              count: 0,
+              messages: []
+            };
+          }
+        }
+        throw error;
+      }
+    }
+  });
+}
+
+// src/chat/slack/tools/message-add-reaction.ts
+import { z as z21 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -6839,8 +6958,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: z20.object({
-      emoji: z20.string().min(1).max(64).describe(
+    inputSchema: z21.object({
+      emoji: z21.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."
       )
     }),
@@ -6891,15 +7010,15 @@ function createSlackMessageAddReactionTool(context, state) {
 
 // src/chat/slack/tools/send-message.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z21 } from "zod";
-var fileInputSchema = z21.object({
-  path: z21.string().min(1).describe(
+import { z as z22 } from "zod";
+var fileInputSchema = z22.object({
+  path: z22.string().min(1).describe(
     "Sandbox file path to include in the message. Absolute paths and workspace-relative paths are supported."
   ),
-  filename: z21.string().min(1).nullable().optional().describe(
+  filename: z22.string().min(1).nullable().optional().describe(
     "Optional filename override shown in Slack. Null is treated as omitted."
   ),
-  mimeType: z21.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted.")
+  mimeType: z22.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted.")
 });
 function hasText(text) {
   return typeof text === "string" && text.trim().length > 0;
@@ -6926,9 +7045,9 @@ function fileOperationInput(files) {
 function createSendMessageTool(context, state, materializeFile) {
   return zodTool({
     description: "Send a Slack message with optional 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. The message can contain text, files, or both; file-only messages are allowed. Do not use for top-level channel posts, other named channels, inline @mentions, or pinging mentioned users.",
-    inputSchema: z21.object({
-      text: z21.string().max(4e4).nullable().optional().describe("Slack mrkdwn text to send. Null is treated as omitted."),
-      files: z21.array(fileInputSchema).min(1).nullable().optional().describe(
+    inputSchema: z22.object({
+      text: z22.string().max(4e4).nullable().optional().describe("Slack mrkdwn text to send. Null is treated as omitted."),
+      files: z22.array(fileInputSchema).min(1).nullable().optional().describe(
         "Sandbox files to include in the message. Null is treated as omitted."
       )
     }),
@@ -7256,13 +7375,13 @@ function storedCanvasUrl(state, canvasId) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z22 } from "zod";
+import { z as z23 } 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: z22.object({
-      title: z22.string().min(1).max(160).describe("Canvas title."),
-      markdown: z22.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z23.object({
+      title: z23.string().min(1).max(160).describe("Canvas title."),
+      markdown: z23.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ title, markdown }) => {
@@ -7325,35 +7444,35 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z23.object({
-  oldText: z23.string().min(1).describe(
+var editReplacementSchema2 = z24.object({
+  oldText: z24.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: z23.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z24.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z23.string().optional(),
-  title: z23.string().optional(),
-  permalink: z23.string().optional(),
-  diff: z23.string().optional(),
-  first_changed_line: z23.number().int().positive().optional(),
-  replacements: z23.number().int().nonnegative().optional(),
-  normalized_heading_count: z23.number().int().nonnegative().optional(),
-  summary: z23.string().optional(),
-  deduplicated: z23.boolean().optional()
+  canvas_id: z24.string().optional(),
+  title: z24.string().optional(),
+  permalink: z24.string().optional(),
+  diff: z24.string().optional(),
+  first_changed_line: z24.number().int().positive().optional(),
+  replacements: z24.number().int().nonnegative().optional(),
+  normalized_heading_count: z24.number().int().nonnegative().optional(),
+  summary: z24.string().optional(),
+  deduplicated: z24.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: z23.object({
-      canvas: z23.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      edits: z23.array(editReplacementSchema2).min(1).describe(
+    inputSchema: z24.object({
+      canvas: z24.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      edits: z24.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -7431,29 +7550,29 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z24.string().optional(),
-  title: z24.string().optional(),
-  permalink: z24.string().optional(),
-  mimetype: z24.string().optional(),
-  filetype: z24.string().optional(),
-  original_byte_length: z24.number().int().nonnegative().optional(),
-  content: z24.string().optional(),
-  start_line: z24.number().int().positive().optional(),
-  end_line: z24.number().int().nonnegative().optional(),
-  total_lines: z24.number().int().nonnegative().optional()
+  canvas_id: z25.string().optional(),
+  title: z25.string().optional(),
+  permalink: z25.string().optional(),
+  mimetype: z25.string().optional(),
+  filetype: z25.string().optional(),
+  original_byte_length: z25.number().int().nonnegative().optional(),
+  content: z25.string().optional(),
+  start_line: z25.number().int().positive().optional(),
+  end_line: z25.number().int().nonnegative().optional(),
+  total_lines: z25.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: z24.object({
-      canvas: z24.string().min(1).describe(
+    inputSchema: z25.object({
+      canvas: z25.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: z24.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z24.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z25.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z25.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -7510,14 +7629,14 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z25 } from "zod";
+import { z as z26 } 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: z25.object({
-      canvas: z25.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      content: z25.string().describe("UTF-8 markdown content to write.")
+    inputSchema: z26.object({
+      canvas: z26.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      content: z26.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ canvas, content }) => {
@@ -7753,12 +7872,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 function slackChannelIdParam(description) {
-  return z26.string().min(1).describe(description);
+  return z27.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z26.string().min(1).describe(description);
+  return z27.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -7782,16 +7901,16 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z27 } from "zod";
+import { z as z28 } 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: z27.object({
-      items: z27.array(z27.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    inputSchema: z28.object({
+      items: z28.array(z28.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: z27.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z28.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 }) => {
@@ -7845,12 +7964,12 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z28 } from "zod";
+import { z as z29 } 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: z28.object({
-      name: z28.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z29.object({
+      name: z29.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ name }) => {
@@ -7882,13 +8001,13 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z29 } from "zod";
+import { z as z30 } 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: z29.object({
-      limit: z29.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z30.object({
+      limit: z30.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ limit }) => {
@@ -7913,21 +8032,21 @@ function createSlackListGetItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z30 } from "zod";
-var booleanInput3 = (description) => z30.preprocess(
+import { z as z31 } from "zod";
+var booleanInput3 = (description) => z31.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z30.boolean()
+  z31.boolean()
 ).describe(description);
-var updateListItemInputSchema = z30.union([
-  z30.object({
-    item_id: z30.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z31.union([
+  z31.object({
+    item_id: z31.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update."),
-    title: z30.string().min(1).describe("Optional new item title.").optional()
+    title: z31.string().min(1).describe("Optional new item title.").optional()
   }),
-  z30.object({
-    item_id: z30.string().min(1).describe("ID of the Slack list item to update."),
+  z31.object({
+    item_id: z31.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z30.string().min(1).describe("Optional new item title.")
+    title: z31.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -8003,7 +8122,7 @@ async function checkSlackChannelReadAccess(args) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // src/chat/slack/tools/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -8176,8 +8295,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: z31.object({
-      url: z31.string().min(1).describe(
+    inputSchema: z32.object({
+      url: z32.string().min(1).describe(
         "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
       ).optional(),
       channel_id: slackChannelIdParam(
@@ -8186,8 +8305,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: z31.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z31.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z32.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z32.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 }) => {
@@ -8443,29 +8562,29 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z32 } from "zod";
-var booleanInput4 = (description) => z32.preprocess(
+import { z as z33 } from "zod";
+var booleanInput4 = (description) => z33.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z32.boolean()
+  z33.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: z32.object({
+    inputSchema: z33.object({
       user_id: slackUserIdParam(
         "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
       ).optional(),
-      email: z32.string().min(3).describe(
+      email: z33.string().min(3).describe(
         "Email address to look up. Mutually exclusive with user_id and query."
       ).optional(),
-      query: z32.string().min(2).describe(
+      query: z33.string().min(2).describe(
         "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
       ).optional(),
-      limit: z32.coerce.number().int().min(1).max(20).describe(
+      limit: z33.coerce.number().int().min(1).max(20).describe(
         "Maximum number of results to return for name search. Defaults to 10."
       ).optional(),
-      max_pages: z32.coerce.number().int().min(1).max(5).describe(
+      max_pages: z33.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(
@@ -8569,18 +8688,18 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var systemTimeOutputSchema = juniorToolResultSchema.extend({
-  unix_ms: z33.number(),
-  iso_utc: z33.string(),
-  iso_local: z33.string(),
-  timezone_offset_minutes: z33.number()
+  unix_ms: z34.number(),
+  iso_utc: z34.string(),
+  iso_local: z34.string(),
+  timezone_offset_minutes: z34.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: z33.object({}),
+    inputSchema: z34.object({}),
     outputSchema: systemTimeOutputSchema,
     privateTraceResult: (result) => ({
       ok: result.ok,
@@ -8609,10 +8728,10 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z34.enum(handoff.profiles);
+  const profileSchema = z35.enum(handoff.profiles);
   const defaultProfile = handoff.profiles[0];
   const handoffResultSchema = juniorToolResultSchema.extend({
     model_profile: profileSchema
@@ -8621,7 +8740,7 @@ function createHandoffTool(handoff) {
   return zodTool({
     description: `Permanently switch this conversation to a more capable model profile, replace prior context with a continuation summary, and continue the same task with the same workspace and all other normal tools. Available profiles: ${profileNames}. Omit profile to use \`${defaultProfile}\`. Call it as the only tool in the assistant message when the system tool policy requires a model upgrade.`,
     executionMode: "sequential",
-    inputSchema: z34.object({
+    inputSchema: z35.object({
       profile: profileSchema.nullish().describe(
         "Named model profile to use for the rest of the conversation; omit or pass null for the default"
       )
@@ -8640,7 +8759,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -9087,9 +9206,9 @@ function createWebFetchTool(hooks, options = {}) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z35.object({
-      url: z35.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z35.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z36.object({
+      url: z36.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z36.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 }) => {
@@ -9156,7 +9275,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 import { getModel } from "@earendil-works/pi-ai/compat";
@@ -9207,9 +9326,9 @@ function createWebSearchTool(override) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z36.object({
-      query: z36.string().min(1).max(500).describe("Search query."),
-      max_results: z36.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z37.object({
+      query: z37.string().min(1).max(500).describe("Search query."),
+      max_results: z37.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ query, max_results }) => {
@@ -9279,14 +9398,14 @@ function createWebSearchTool(override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z37 } from "zod";
+import { z as z38 } 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: z37.object({
-      path: z37.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z37.string().describe("UTF-8 file content to write.")
+    inputSchema: z38.object({
+      path: z38.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z38.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -9389,6 +9508,11 @@ function createTools(availableSkills, hooks = {}, context) {
         context.conversationId
       );
     }
+    if (context.source.platform === "slack" && context.slackActionToken) {
+      tools.slackPublicSearch = createSlackPublicSearchTool(
+        context.slackActionToken
+      );
+    }
     tools.slackUserLookup = createSlackUserLookupTool();
     tools.slackListCreate = createSlackListCreateTool(state);
     tools.slackListAddItems = createSlackListAddItemsTool(state);
@@ -10001,59 +10125,59 @@ async function startOAuthFlow(provider, input) {
 }
 
 // src/chat/sandbox/egress/schemas.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 import {
   pluginAuthorizationSchema,
   pluginCredentialHeaderTransformSchema,
   pluginGrantSchema,
   pluginProviderAccountSchema
 } from "@sentry/junior-plugin-api";
-var finiteNumberSchema = z38.number().refine(Number.isFinite);
-var httpStatusSchema = z38.number().int().min(100).max(599);
-var providerNameSchema = z38.string().regex(/^[a-z][a-z0-9-]*$/);
-var credentialSignalKindSchema = z38.enum(["auth_required", "unavailable"]);
+var finiteNumberSchema = z39.number().refine(Number.isFinite);
+var httpStatusSchema = z39.number().int().min(100).max(599);
+var providerNameSchema = z39.string().regex(/^[a-z][a-z0-9-]*$/);
+var credentialSignalKindSchema = z39.enum(["auth_required", "unavailable"]);
 var sandboxEgressGrantSchema = pluginGrantSchema;
-var sandboxEgressCredentialContextSchema = z38.object({
+var sandboxEgressCredentialContextSchema = z39.object({
   credentials: credentialContextSchema,
-  egressId: z38.string().min(1),
+  egressId: z39.string().min(1),
   expiresAtMs: finiteNumberSchema,
-  contextId: z38.string().min(1)
+  contextId: z39.string().min(1)
 }).strict();
-var sandboxEgressCredentialLeaseSchema = z38.object({
+var sandboxEgressCredentialLeaseSchema = z39.object({
   account: pluginProviderAccountSchema.optional(),
   authorization: pluginAuthorizationSchema.optional(),
   grant: sandboxEgressGrantSchema,
   provider: providerNameSchema,
-  expiresAt: z38.string().min(1),
-  headerTransforms: z38.array(pluginCredentialHeaderTransformSchema).min(1)
+  expiresAt: z39.string().min(1),
+  headerTransforms: z39.array(pluginCredentialHeaderTransformSchema).min(1)
 }).strict();
-var sandboxEgressAuthRequiredSignalSchema = z38.object({
+var sandboxEgressAuthRequiredSignalSchema = z39.object({
   authorization: pluginAuthorizationSchema.optional(),
   grant: sandboxEgressGrantSchema,
   kind: credentialSignalKindSchema.default("auth_required"),
   provider: providerNameSchema,
-  message: z38.string().optional(),
+  message: z39.string().optional(),
   createdAtMs: finiteNumberSchema
 }).strict().superRefine((signal, ctx) => {
   if (signal.authorization && signal.authorization.provider !== signal.provider) {
     ctx.addIssue({
-      code: z38.ZodIssueCode.custom,
+      code: z39.ZodIssueCode.custom,
       message: "Auth signal authorization provider must match provider",
       path: ["authorization", "provider"]
     });
   }
 });
-var sandboxEgressPermissionDeniedSignalSchema = z38.object({
+var sandboxEgressPermissionDeniedSignalSchema = z39.object({
   account: pluginProviderAccountSchema.optional(),
-  acceptedPermissions: z38.string().optional(),
+  acceptedPermissions: z39.string().optional(),
   grant: sandboxEgressGrantSchema,
-  message: z38.string().min(1),
+  message: z39.string().min(1),
   provider: providerNameSchema,
-  source: z38.literal("upstream"),
-  sso: z38.string().optional(),
+  source: z39.literal("upstream"),
+  sso: z39.string().optional(),
   status: httpStatusSchema,
-  upstreamHost: z38.string().min(1),
-  upstreamPath: z38.string().min(1),
+  upstreamHost: z39.string().min(1),
+  upstreamPath: z39.string().min(1),
   createdAtMs: finiteNumberSchema
 }).strict();
 function parseSandboxEgressAuthRequiredSignal(value) {
@@ -10314,15 +10438,15 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z39 } 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. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z39.object({
-      tool_name: z39.string().min(1).describe("Exact catalog tool_name returned by searchTools."),
-      arguments: z39.record(z39.string(), z39.unknown()).describe(
+    inputSchema: z40.object({
+      tool_name: z40.string().min(1).describe("Exact catalog tool_name returned by searchTools."),
+      arguments: z40.record(z40.string(), z40.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -10362,42 +10486,42 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z40 } 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 = z40.object({
-  id: z40.string(),
-  description: z40.string()
+var searchToolsSourceSchema = z41.object({
+  id: z41.string(),
+  description: z41.string()
 }).strict();
-var toolCallExampleSchema = z40.object({
-  tool_name: z40.string(),
-  arguments: z40.record(z40.string(), z40.string())
+var toolCallExampleSchema = z41.object({
+  tool_name: z41.string(),
+  arguments: z41.record(z41.string(), z41.string())
 }).strict();
-var searchToolsToolSchema = z40.object({
-  tool_name: z40.string(),
-  description: z40.string(),
-  exposure: z40.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z40.string().optional(),
-  signature: z40.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: z40.unknown(),
-  input_schema_summary: z40.string(),
-  call_notes: z40.array(z40.string()),
-  annotations: z40.record(z40.string(), z40.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: z40.string().nullable(),
-  source: z40.string().nullable(),
-  sources: z40.array(searchToolsSourceSchema),
-  total_catalog_tools: z40.number().int().nonnegative(),
-  total_eligible_tools: z40.number().int().nonnegative(),
-  total_matches: z40.number().int().nonnegative(),
-  returned_tools: z40.number().int().nonnegative(),
-  execution_tool: z40.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: z40.array(searchToolsToolSchema)
+  tools: z41.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -10589,14 +10713,14 @@ function createSearchToolsTool(catalogTools) {
   return zodTool({
     description: renderSearchToolsDescription(knownSources),
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z40.object({
-      query: z40.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: z40.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: z40.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) => ({
@@ -14642,7 +14766,8 @@ async function wireAgentTools(args) {
       ...commonToolRuntimeContext,
       destination: toolDestination,
       actor: args.currentActor?.platform === "slack" ? args.currentActor : void 0,
-      source: runSource
+      source: runSource,
+      slackActionToken: args.routing.slackActionToken
     };
   } else {
     if (toolDestination.platform !== "local") {
@@ -15340,9 +15465,9 @@ async function executeAgentRun(request) {
   const conversationPrivacy = resolveConversationPrivacy({
     channelId: request.routing.correlation?.channelId,
     conversationId: request.routing.correlation?.conversationId ?? request.routing.correlation?.threadId ?? request.routing.correlation?.runId,
-    // Source-confirmed visibility from the live event's channel_type; without
-    // it the turn fails closed to private telemetry capture.
-    visibility: request.routing.slackConversation?.visibility
+    // Destination visibility is provider-neutral. Slack event context remains
+    // a compatibility fallback for callers that have not projected it yet.
+    visibility: request.routing.destinationVisibility ?? request.routing.slackConversation?.visibility
   });
   return runWithConversationPrivacy(
     conversationPrivacy ?? "private",