@sentry/junior 0.46.0 → 0.47.0

package/dist/app.js

@@ -4466,6 +4466,29 @@ function truncateText(value, maxChars = MAX_TEXT_CHARS) {
     truncated: true
   };
 }
+function isMissingPathError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const candidate = error;
+  if (candidate.code === "ENOENT") {
+    return true;
+  }
+  return typeof candidate.message === "string" && candidate.message.startsWith("File not found:");
+}
+function missingPathSearchResult(params) {
+  const textPath = params.displayPath ?? params.missingPath ?? params.path;
+  return {
+    content: [{ type: "text", text: `Path not found: ${textPath}` }],
+    details: {
+      ok: false,
+      error: "not_found",
+      path: params.path,
+      ...params.missingPath ? { missing_path: params.missingPath } : {},
+      truncated: false
+    }
+  };
+}
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -4520,13 +4543,35 @@ function resolveWorkspacePath(input, fallback = ".") {
 async function collectFiles(params) {
   const files = [];
   let limitReached = false;
+  let missingPath;
   const visit = async (dirPath) => {
-    const entries = (await params.fs.readdir(dirPath)).sort(
-      (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
-    );
+    if (missingPath) {
+      return;
+    }
+    let entries;
+    try {
+      entries = (await params.fs.readdir(dirPath)).sort(
+        (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
+      );
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        missingPath = dirPath;
+        return;
+      }
+      throw error;
+    }
     for (const entry of entries) {
       const fullPath = path4.posix.join(dirPath, entry);
-      const stat2 = await params.fs.stat(fullPath);
+      let stat2;
+      try {
+        stat2 = await params.fs.stat(fullPath);
+      } catch (error) {
+        if (isMissingPathError(error)) {
+          missingPath = fullPath;
+          return;
+        }
+        throw error;
+      }
       if (stat2.isDirectory()) {
         if (!SKIPPED_DIRECTORIES.has(entry)) {
           await visit(fullPath);
@@ -4544,20 +4589,38 @@ async function collectFiles(params) {
       }
     }
   };
-  const stat = await params.fs.stat(params.root);
+  let stat;
+  try {
+    stat = await params.fs.stat(params.root);
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return {
+        files,
+        limitReached: false,
+        missingPath: params.root,
+        missingRoot: true
+      };
+    }
+    throw error;
+  }
   if (!stat.isDirectory()) {
     const relativePath = path4.posix.basename(params.root);
     return {
       files: !params.pattern || matchesGlob(relativePath, params.pattern) ? [params.root] : [],
-      limitReached: false
+      limitReached: false,
+      missingRoot: false
     };
   }
   await visit(params.root);
-  return { files, limitReached };
+  return {
+    files,
+    limitReached,
+    missingPath,
+    missingRoot: missingPath === params.root
+  };
 }
 
-// src/chat/tools/sandbox/edit-file.ts
-import { Type as Type2 } from "@sinclair/typebox";
+// src/chat/tools/sandbox/text-edits.ts
 function detectLineEnding(value) {
   return value.includes("\r\n") ? "\r\n" : "\n";
 }
@@ -4589,6 +4652,44 @@ function firstChangedLine(oldContent, newContent) {
   }
   return void 0;
 }
+function prepareTextReplacementArguments(input) {
+  if (!input || typeof input !== "object") {
+    return input;
+  }
+  const raw = { ...input };
+  if (typeof raw.edits === "string") {
+    try {
+      raw.edits = JSON.parse(raw.edits);
+    } catch {
+      return raw;
+    }
+  }
+  const edits = Array.isArray(raw.edits) ? [...raw.edits] : [];
+  const oldText = raw.oldText ?? raw.old_text;
+  const newText = raw.newText ?? raw.new_text;
+  if (typeof oldText === "string" && typeof newText === "string") {
+    edits.push({ oldText, newText });
+  }
+  if (edits.length > 0) {
+    raw.edits = edits.map((edit) => {
+      if (!edit || typeof edit !== "object") {
+        return edit;
+      }
+      const record = edit;
+      const { old_text, new_text, ...rest } = record;
+      return {
+        ...rest,
+        oldText: record.oldText ?? old_text,
+        newText: record.newText ?? new_text
+      };
+    });
+  }
+  delete raw.oldText;
+  delete raw.old_text;
+  delete raw.newText;
+  delete raw.new_text;
+  return raw;
+}
 function buildCompactDiff(oldContent, newContent) {
   const oldLines = oldContent.split("\n");
   const newLines = newContent.split("\n");
@@ -4630,19 +4731,19 @@ function buildCompactDiff(oldContent, newContent) {
     firstChangedLine: firstChangedLine(oldContent, newContent)
   };
 }
-function validateAndApplyEdits(content, edits, filePath) {
+function validateAndApplyTextEdits(content, edits, targetName) {
   if (!Array.isArray(edits) || edits.length === 0) {
-    throw new Error("editFile requires at least one edit.");
+    throw new Error(`${targetName} requires at least one edit.`);
   }
   const normalizedEdits = edits.map((edit, index) => {
     if (typeof edit.oldText !== "string" || edit.oldText.length === 0) {
       throw new Error(
-        `edits[${index}].oldText must not be empty in ${filePath}.`
+        `edits[${index}].oldText must not be empty in ${targetName}.`
       );
     }
     if (typeof edit.newText !== "string") {
       throw new Error(
-        `edits[${index}].newText must be a string in ${filePath}.`
+        `edits[${index}].newText must be a string in ${targetName}.`
       );
     }
     return {
@@ -4656,13 +4757,13 @@ function validateAndApplyEdits(content, edits, filePath) {
     const matchIndex = content.indexOf(edit.oldText);
     if (matchIndex === -1) {
       throw new Error(
-        `Could not find edits[${index}] in ${filePath}. oldText must match exactly including whitespace and newlines.`
+        `Could not find edits[${index}] in ${targetName}. oldText must match exactly including whitespace and newlines.`
       );
     }
     const occurrences = countOccurrences(content, edit.oldText);
     if (occurrences > 1) {
       throw new Error(
-        `Found ${occurrences} occurrences of edits[${index}] in ${filePath}. Each oldText must be unique.`
+        `Found ${occurrences} occurrences of edits[${index}] in ${targetName}. Each oldText must be unique.`
       );
     }
     matchedEdits.push({
@@ -4678,7 +4779,7 @@ function validateAndApplyEdits(content, edits, filePath) {
     const current = matchedEdits[index];
     if (previous.matchIndex + previous.matchLength > current.matchIndex) {
       throw new Error(
-        `edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${filePath}. Merge overlapping replacements into one edit.`
+        `edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${targetName}. Merge overlapping replacements into one edit.`
       );
     }
   }
@@ -4688,47 +4789,15 @@ function validateAndApplyEdits(content, edits, filePath) {
     newContent = newContent.slice(0, edit.matchIndex) + edit.newText + newContent.slice(edit.matchIndex + edit.matchLength);
   }
   if (newContent === content) {
-    throw new Error(`No changes made to ${filePath}.`);
+    throw new Error(`No changes made to ${targetName}.`);
   }
   return { baseContent: content, newContent };
 }
+
+// src/chat/tools/sandbox/edit-file.ts
+import { Type as Type2 } from "@sinclair/typebox";
 function prepareEditFileArguments(input) {
-  if (!input || typeof input !== "object") {
-    return input;
-  }
-  const raw = { ...input };
-  if (typeof raw.edits === "string") {
-    try {
-      raw.edits = JSON.parse(raw.edits);
-    } catch {
-      return raw;
-    }
-  }
-  const edits = Array.isArray(raw.edits) ? [...raw.edits] : [];
-  const oldText = raw.oldText ?? raw.old_text;
-  const newText = raw.newText ?? raw.new_text;
-  if (typeof oldText === "string" && typeof newText === "string") {
-    edits.push({ oldText, newText });
-  }
-  if (edits.length > 0) {
-    raw.edits = edits.map((edit) => {
-      if (!edit || typeof edit !== "object") {
-        return edit;
-      }
-      const record = edit;
-      const { old_text, new_text, ...rest } = record;
-      return {
-        ...rest,
-        oldText: record.oldText ?? old_text,
-        newText: record.newText ?? new_text
-      };
-    });
-  }
-  delete raw.oldText;
-  delete raw.old_text;
-  delete raw.newText;
-  delete raw.new_text;
-  return raw;
+  return prepareTextReplacementArguments(input);
 }
 async function editFile(params) {
   const filePath = resolveWorkspacePath(params.path);
@@ -4736,7 +4805,7 @@ async function editFile(params) {
   const { bom, text } = stripBom(rawContent);
   const lineEnding = detectLineEnding(text);
   const normalizedContent = normalizeToLf(text);
-  const { baseContent, newContent } = validateAndApplyEdits(
+  const { baseContent, newContent } = validateAndApplyTextEdits(
     normalizedContent,
     params.edits,
     params.path
@@ -4817,12 +4886,18 @@ async function findFiles(params) {
   }
   const root = resolveWorkspacePath(params.path);
   const limit = positiveInteger(params.limit) ?? DEFAULT_FIND_LIMIT;
-  const { files, limitReached } = await collectFiles({
+  const { files, limitReached, missingPath, missingRoot } = await collectFiles({
     fs: params.fs,
     root,
     pattern: params.pattern,
     limit
   });
+  if (missingPath) {
+    return missingPathSearchResult({
+      path: params.path ?? ".",
+      ...missingRoot ? { displayPath: params.path ?? "." } : { missingPath }
+    });
+  }
   const relativePaths = files.map(
     (filePath) => path5.posix.relative(root, filePath)
   );
@@ -4919,11 +4994,17 @@ async function grepFiles(params) {
   const limit = positiveInteger(params.limit) ?? DEFAULT_GREP_LIMIT;
   const context = positiveInteger(params.context) ?? 0;
   const regex = params.literal ? void 0 : new RegExp(params.pattern, params.ignoreCase ? "i" : "");
-  const { files } = await collectFiles({
+  const { files, missingPath, missingRoot } = await collectFiles({
     fs: params.fs,
     root,
     pattern: params.glob
   });
+  if (missingPath) {
+    return missingPathSearchResult({
+      path: params.path ?? ".",
+      ...missingRoot ? { displayPath: params.path ?? "." } : { missingPath }
+    });
+  }
   const output = [];
   let matchCount = 0;
   let matchLimitReached = false;
@@ -4933,8 +5014,14 @@ async function grepFiles(params) {
     let content;
     try {
       content = await params.fs.readFile(filePath, { encoding: "utf8" });
-    } catch {
-      continue;
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        return missingPathSearchResult({
+          path: params.path ?? ".",
+          missingPath: filePath
+        });
+      }
+      throw error;
     }
     if (content.includes("\0")) {
       continue;
@@ -5214,13 +5301,29 @@ var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
   const dirPath = resolveWorkspacePath(params.path);
   const limit = positiveInteger(params.limit) ?? DEFAULT_LIST_LIMIT;
-  const stat = await params.fs.stat(dirPath);
+  let stat;
+  try {
+    stat = await params.fs.stat(dirPath);
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return missingPathSearchResult({ path: params.path ?? "." });
+    }
+    throw error;
+  }
   if (!stat.isDirectory()) {
     throw new Error(`Not a directory: ${params.path ?? "."}`);
   }
-  const entries = (await params.fs.readdir(dirPath)).sort(
-    (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
-  );
+  let entries;
+  try {
+    entries = (await params.fs.readdir(dirPath)).sort(
+      (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
+    );
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return missingPathSearchResult({ path: params.path ?? "." });
+    }
+    throw error;
+  }
   const output = [];
   let entryLimitReached = false;
   for (const entry of entries) {
@@ -5232,8 +5335,14 @@ async function listDir(params) {
     try {
       const entryStat = await params.fs.stat(entryPath);
       output.push(`${entry}${entryStat.isDirectory() ? "/" : ""}`);
-    } catch {
-      continue;
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        return missingPathSearchResult({
+          path: params.path ?? ".",
+          missingPath: entryPath
+        });
+      }
+      throw error;
     }
   }
   const bounded = truncateText(
@@ -5824,6 +5933,14 @@ function sliceFileContent(params) {
     } : {}
   };
 }
+function missingFileResult(path11) {
+  return {
+    content: "",
+    error: "not_found",
+    path: path11,
+    success: false
+  };
+}
 function createReadFileTool() {
   return tool({
     description: "Read a bounded line range from a file in the sandbox workspace. Use when you need exact file contents to verify facts or make edits safely. Prefer grep/findFiles/listDir for broad discovery.",
@@ -6180,6 +6297,37 @@ function createSlackMessageAddReactionTool(context, state) {
 // src/chat/tools/slack/canvas-tools.ts
 import { Type as Type16 } from "@sinclair/typebox";
 
+// src/chat/slack/canvas-references.ts
+var SLACK_FILE_ID_PATTERN = /^F[A-Z0-9]{4,}$/i;
+var SLACK_CANVAS_PATH_PATTERN = /^\/(?:docs|canvas|files)\/(?:T[A-Z0-9]+\/)?(?:U[A-Z0-9]+\/)?(F[A-Z0-9]{4,})(?:\/|$)/i;
+function isSlackHost(hostname) {
+  return hostname === "slack.com" || hostname.endsWith(".slack.com");
+}
+function normalizeReferenceInput(input) {
+  let value = input.trim();
+  if (value.startsWith("<") && value.endsWith(">")) {
+    value = value.slice(1, -1);
+  }
+  return value.split("|", 1)[0]?.trim() ?? "";
+}
+function extractCanvasId(input) {
+  const trimmed = normalizeReferenceInput(input);
+  if (!trimmed) return void 0;
+  if (SLACK_FILE_ID_PATTERN.test(trimmed)) {
+    return trimmed.toUpperCase();
+  }
+  try {
+    const url = new URL(trimmed);
+    if (!isSlackHost(url.hostname)) {
+      return void 0;
+    }
+    const urlMatch = url.pathname.match(SLACK_CANVAS_PATH_PATTERN);
+    return urlMatch?.[1]?.toUpperCase();
+  } catch {
+    return void 0;
+  }
+}
+
 // src/chat/tools/slack/canvases.ts
 function normalizeCanvasMarkdown(markdown) {
   let normalizedHeadingCount = 0;
@@ -6271,27 +6419,7 @@ async function grantChannelCanvasAccess(canvasId, channelId) {
     );
   }
 }
-async function lookupCanvasSection(canvasId, containsText) {
-  const client2 = getSlackClient();
-  const response = await withSlackRetries(
-    () => client2.canvases.sections.lookup({
-      canvas_id: canvasId,
-      criteria: {
-        contains_text: containsText
-      }
-    }),
-    3,
-    {
-      action: "canvases.sections.lookup",
-      attributes: {
-        "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1),
-        "app.slack.canvas.contains_text_length": containsText.length
-      }
-    }
-  );
-  return response.sections?.[0]?.id;
-}
-async function updateCanvas(input) {
+async function writeCanvasMarkdown(input) {
   const client2 = getSlackClient();
   const normalizedContent = normalizeCanvasMarkdown(input.markdown);
   await withSlackRetries(
@@ -6299,8 +6427,7 @@ async function updateCanvas(input) {
       canvas_id: input.canvasId,
       changes: [
         {
-          operation: input.operation,
-          section_id: input.sectionId,
+          operation: "replace",
           document_content: {
             type: "markdown",
             markdown: normalizedContent.markdown
@@ -6313,27 +6440,19 @@ async function updateCanvas(input) {
       action: "canvases.edit",
       attributes: {
         "app.slack.canvas.canvas_id_prefix": input.canvasId.slice(0, 1),
-        "app.slack.canvas.operation": input.operation,
+        "app.slack.canvas.operation": "replace",
         "app.slack.canvas.markdown_length": normalizedContent.markdown.length,
         "app.slack.canvas.markdown_normalized": normalizedContent.normalizedHeadingCount > 0,
         "app.slack.canvas.normalized_heading_count": normalizedContent.normalizedHeadingCount
       }
     }
   );
+  return normalizedContent;
 }
-var CANVAS_ID_PATTERN = /^F[A-Z0-9]+$/i;
-var CANVAS_URL_FILE_ID_PATTERN = /\/(?:docs|canvas|files)\/(?:T[A-Z0-9]+\/)?(?:U[A-Z0-9]+\/)?(F[A-Z0-9]+)/i;
-function extractCanvasId(input) {
-  const trimmed = input.trim();
-  if (!trimmed) return void 0;
-  if (CANVAS_ID_PATTERN.test(trimmed)) {
-    return trimmed.toUpperCase();
-  }
-  const urlMatch = trimmed.match(CANVAS_URL_FILE_ID_PATTERN);
-  if (urlMatch?.[1]) {
-    return urlMatch[1].toUpperCase();
-  }
-  return void 0;
+function isCanvasFile(file) {
+  const filetype = file.filetype?.toLowerCase() ?? "";
+  const mimetype = file.mimetype?.toLowerCase() ?? "";
+  return filetype === "quip" || filetype === "canvas" || mimetype.includes("quip") || mimetype.includes("canvas");
 }
 async function readCanvas(canvasIdOrUrl) {
   const canvasId = extractCanvasId(canvasIdOrUrl);
@@ -6359,6 +6478,9 @@ async function readCanvas(canvasIdOrUrl) {
   if (!file) {
     throw new Error("Slack returned no file metadata for canvas.");
   }
+  if (!isCanvasFile(file)) {
+    throw new Error("Slack file metadata did not describe a Canvas document.");
+  }
   const downloadUrl = file.url_private_download ?? file.url_private;
   if (!downloadUrl) {
     throw new Error(
@@ -6378,7 +6500,6 @@ async function readCanvas(canvasIdOrUrl) {
 }
 
 // src/chat/tools/slack/canvas-tools.ts
-var MAX_CANVAS_READ_CHARS = 4e4;
 var MAX_RECENT_CANVASES = 5;
 function mergeRecentCanvases(existing, created) {
   const nextEntry = {
@@ -6391,6 +6512,46 @@ function mergeRecentCanvases(existing, created) {
   const deduped = prior.filter((entry) => entry.id !== created.id);
   return [nextEntry, ...deduped].slice(0, MAX_RECENT_CANVASES);
 }
+function prepareCanvasEditArguments(input) {
+  return prepareTextReplacementArguments(input);
+}
+function storedCanvasUrl(state, canvasId) {
+  const lastCanvasUrl = state.artifactState.lastCanvasUrl;
+  if (lastCanvasUrl && extractCanvasId(lastCanvasUrl) === canvasId) {
+    return lastCanvasUrl;
+  }
+  for (const canvas of state.artifactState.recentCanvases ?? []) {
+    if (extractCanvasId(canvas.id) === canvasId) {
+      return canvas.url;
+    }
+    if (canvas.url && extractCanvasId(canvas.url) === canvasId) {
+      return canvas.url;
+    }
+  }
+  return void 0;
+}
+function resolveCanvasTarget(canvas) {
+  const canvasId = extractCanvasId(canvas);
+  if (!canvasId) {
+    return {
+      ok: false,
+      error: "Could not parse a Slack canvas/file ID from input. Provide an F-prefixed ID or a Slack canvas/docs URL."
+    };
+  }
+  return { ok: true, canvasId };
+}
+var editReplacementSchema2 = Type16.Object(
+  {
+    oldText: Type16.String({
+      minLength: 1,
+      description: "Exact Canvas markdown to replace. It must be unique in the current Canvas body and must not overlap another edit."
+    }),
+    newText: Type16.String({
+      description: "Replacement Canvas markdown for this edit."
+    })
+  },
+  { additionalProperties: false }
+);
 function createSlackCanvasCreateTool(context, state) {
   return tool({
     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.",
@@ -6439,7 +6600,6 @@ function createSlackCanvasCreateTool(context, state) {
         markdown,
         channelId: targetChannelId
       });
-      state.setTurnCreatedCanvasId(created.canvasId);
       await state.patchArtifactState({
         lastCanvasId: created.canvasId,
         lastCanvasUrl: created.permalink,
@@ -6463,67 +6623,111 @@ function createSlackCanvasCreateTool(context, state) {
     }
   });
 }
-function createSlackCanvasUpdateTool(state, _context) {
+function createSlackCanvasReadTool() {
   return tool({
-    description: "Update the active Slack canvas tracked in artifact context. Use when continuing or correcting a document already tracked in this thread. Do not use to create a brand-new long-form artifact.",
-    inputSchema: Type16.Object({
-      markdown: Type16.String({
-        minLength: 1,
-        description: "Markdown content to insert or use as replacement text."
-      }),
-      operation: Type16.Optional(
-        Type16.Union(
-          [
-            Type16.Literal("insert_at_end"),
-            Type16.Literal("insert_at_start"),
-            Type16.Literal("replace")
-          ],
-          { description: "Canvas update mode." }
-        )
-      ),
-      section_id: Type16.Optional(
-        Type16.String({
-          minLength: 1,
-          description: "Optional section ID required for targeted replace operations."
-        })
-      ),
-      section_contains_text: Type16.Optional(
-        Type16.String({
+    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: Type16.Object(
+      {
+        canvas: Type16.String({
           minLength: 1,
-          description: "Optional helper text used to find the target section when section_id is not provided."
-        })
-      )
-    }),
-    execute: async ({
-      markdown,
-      operation,
-      section_id,
-      section_contains_text
-    }) => {
-      const targetCanvasId = state.getTurnCreatedCanvasId() ?? state.getCurrentCanvasId();
-      const resolvedOperation = operation ?? "insert_at_end";
-      if (!targetCanvasId) {
+          description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
+        }),
+        offset: Type16.Optional(
+          Type16.Integer({
+            minimum: 1,
+            description: "1-indexed line number to start reading from."
+          })
+        ),
+        limit: Type16.Optional(
+          Type16.Integer({
+            minimum: 1,
+            description: "Maximum number of lines to read. Defaults to 1000."
+          })
+        )
+      },
+      { additionalProperties: false }
+    ),
+    execute: async ({ canvas, offset, limit }) => {
+      const target = resolveCanvasTarget(canvas);
+      if (!target.ok) {
+        return target;
+      }
+      try {
+        const result = await readCanvas(target.canvasId);
+        const range = sliceFileContent({
+          content: normalizeToLf(result.content),
+          limit,
+          offset,
+          path: result.canvasId
+        });
+        return {
+          ok: true,
+          canvas_id: result.canvasId,
+          title: result.title,
+          permalink: result.permalink,
+          mimetype: result.mimetype,
+          filetype: result.filetype,
+          original_byte_length: result.byteLength,
+          content: range.content,
+          start_line: range.start_line,
+          end_line: range.end_line,
+          total_lines: range.total_lines,
+          truncated: range.truncated,
+          continuation: range.continuation
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "canvas read failed";
         logWarn(
-          "slack_canvas_update_missing_target",
+          "slack_canvas_read_failed",
           {},
           {
-            "gen_ai.tool.name": "slackCanvasUpdate",
-            "app.artifacts.last_canvas_id": state.artifactState.lastCanvasId ?? "none",
-            "app.artifacts.turn_created_canvas_id": state.getTurnCreatedCanvasId() ?? "none"
+            "gen_ai.tool.name": "slackCanvasRead",
+            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
           },
-          "Canvas update rejected because no explicit target canvas was provided"
+          message
         );
         return {
           ok: false,
-          error: "No active canvas found in artifact context"
+          canvas_id: target.canvasId,
+          error: message
         };
       }
-      const operationKey = createOperationKey("slackCanvasUpdate", {
-        canvas_id: targetCanvasId,
-        markdown,
-        operation: resolvedOperation,
-        section_id: section_id ?? null,
-        section_contains_text: section_contains_text ?? null
+    }
+  });
+}
+function createSlackCanvasEditTool(state) {
+  return tool({
+    description: "Edit one Slack canvas with exact markdown replacements. Use for precise changes to existing Canvas content. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff.",
+    promptSnippet: "existing-canvas exact edits; returns diff",
+    promptGuidelines: [
+      "prefer over slackCanvasWrite for targeted changes",
+      "oldText exact, unique, non-overlapping",
+      "multiple same-canvas changes: one edits[] call"
+    ],
+    prepareArguments: prepareCanvasEditArguments,
+    executionMode: "sequential",
+    inputSchema: Type16.Object(
+      {
+        canvas: Type16.String({
+          minLength: 1,
+          description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."
+        }),
+        edits: Type16.Array(editReplacementSchema2, {
+          minItems: 1,
+          description: "Exact replacements matched against the current Canvas body, not incrementally."
+        })
+      },
+      { additionalProperties: false }
+    ),
+    execute: async ({ canvas, edits }) => {
+      const target = resolveCanvasTarget(canvas);
+      if (!target.ok) {
+        return target;
+      }
+      const operationKey = createOperationKey("slackCanvasEdit", {
+        canvas_id: target.canvasId,
+        edits
       });
       const cached = state.getOperationResult(operationKey);
       if (cached) {
@@ -6532,72 +6736,124 @@ function createSlackCanvasUpdateTool(state, _context) {
           deduplicated: true
         };
       }
-      const sectionId = section_id ?? (section_contains_text ? await lookupCanvasSection(targetCanvasId, section_contains_text) : void 0);
-      await updateCanvas({
-        canvasId: targetCanvasId,
-        markdown,
-        operation: resolvedOperation,
-        sectionId
-      });
-      await state.patchArtifactState({ lastCanvasId: targetCanvasId });
-      const response = {
-        ok: true,
-        canvas_id: targetCanvasId,
-        operation: resolvedOperation,
-        section_id: sectionId
-      };
-      state.setOperationResult(operationKey, response);
-      return response;
+      try {
+        const current = await readCanvas(target.canvasId);
+        const normalizedContent = normalizeToLf(current.content);
+        const { baseContent, newContent } = validateAndApplyTextEdits(
+          normalizedContent,
+          edits,
+          target.canvasId
+        );
+        const written = await writeCanvasMarkdown({
+          canvasId: target.canvasId,
+          markdown: newContent
+        });
+        await state.patchArtifactState({
+          lastCanvasId: target.canvasId,
+          lastCanvasUrl: current.permalink ?? state.artifactState.lastCanvasUrl
+        });
+        const diff = buildCompactDiff(
+          normalizeCanvasMarkdown(baseContent).markdown,
+          written.markdown
+        );
+        const response = {
+          ok: true,
+          canvas_id: target.canvasId,
+          title: current.title,
+          permalink: current.permalink,
+          diff: diff.diff,
+          first_changed_line: diff.firstChangedLine,
+          replacements: edits.length,
+          normalized_heading_count: written.normalizedHeadingCount,
+          summary: `Edited canvas ${target.canvasId}`
+        };
+        state.setOperationResult(operationKey, response);
+        return response;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "canvas edit failed";
+        logWarn(
+          "slack_canvas_edit_failed",
+          {},
+          {
+            "gen_ai.tool.name": "slackCanvasEdit",
+            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
+          },
+          message
+        );
+        return {
+          ok: false,
+          canvas_id: target.canvasId,
+          error: message
+        };
+      }
     }
   });
 }
-function createSlackCanvasReadTool() {
+function createSlackCanvasWriteTool(state) {
   return tool({
-    description: "Read a Slack canvas the bot has access to (including canvases the bot created) by canvas ID or Slack canvas/docs URL. Use when the user shares a Slack canvas link (https://*.slack.com/docs/... or /canvas/...) or references a canvas ID and you need its contents. Do not use for generic web pages \u2014 use webFetch for those.",
-    annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type16.Object({
-      canvas: Type16.String({
-        minLength: 1,
-        description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
-      })
-    }),
-    execute: async ({ canvas }) => {
-      const canvasId = extractCanvasId(canvas);
-      if (!canvasId) {
+    description: "Write UTF-8 markdown content to a Slack canvas. Use for deliberate full-Canvas replacement after validation. Do not use for targeted edits.",
+    promptSnippet: "deliberate full-canvas replacement",
+    promptGuidelines: ["targeted existing-canvas changes: slackCanvasEdit"],
+    executionMode: "sequential",
+    inputSchema: Type16.Object(
+      {
+        canvas: Type16.String({
+          minLength: 1,
+          description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."
+        }),
+        content: Type16.String({
+          description: "UTF-8 markdown content to write."
+        })
+      },
+      { additionalProperties: false }
+    ),
+    execute: async ({ canvas, content }) => {
+      const target = resolveCanvasTarget(canvas);
+      if (!target.ok) {
+        return target;
+      }
+      const operationKey = createOperationKey("slackCanvasWrite", {
+        canvas_id: target.canvasId,
+        content
+      });
+      const cached = state.getOperationResult(operationKey);
+      if (cached) {
         return {
-          ok: false,
-          error: "Could not parse a Slack canvas/file ID from input. Provide an F-prefixed ID or a Slack canvas/docs URL."
+          ...cached,
+          deduplicated: true
         };
       }
       try {
-        const result = await readCanvas(canvas);
-        const truncated = result.content.length > MAX_CANVAS_READ_CHARS;
-        const content = truncated ? result.content.slice(0, MAX_CANVAS_READ_CHARS) : result.content;
-        return {
+        const written = await writeCanvasMarkdown({
+          canvasId: target.canvasId,
+          markdown: content
+        });
+        await state.patchArtifactState({
+          lastCanvasId: target.canvasId,
+          lastCanvasUrl: storedCanvasUrl(state, target.canvasId)
+        });
+        const response = {
           ok: true,
-          canvas_id: result.canvasId,
-          title: result.title,
-          permalink: result.permalink,
-          mimetype: result.mimetype,
-          filetype: result.filetype,
-          original_byte_length: result.byteLength,
-          truncated,
-          content
+          canvas_id: target.canvasId,
+          normalized_heading_count: written.normalizedHeadingCount,
+          summary: `Wrote canvas ${target.canvasId}`
         };
+        state.setOperationResult(operationKey, response);
+        return response;
       } catch (error) {
-        const message = error instanceof Error ? error.message : "canvas read failed";
+        const message = error instanceof Error ? error.message : "canvas write failed";
         logWarn(
-          "slack_canvas_read_failed",
+          "slack_canvas_write_failed",
           {},
           {
-            "gen_ai.tool.name": "slackCanvasRead",
-            "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1)
+            "gen_ai.tool.name": "slackCanvasWrite",
+            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
           },
           message
         );
         return {
           ok: false,
-          canvas_id: canvasId,
+          canvas_id: target.canvasId,
           error: message
         };
       }
@@ -8529,7 +8785,6 @@ function createWriteFileTool() {
 // src/chat/tools/index.ts
 function createToolState(hooks, context) {
   const operationResultCache = /* @__PURE__ */ new Map();
-  let turnCreatedCanvasId;
   const artifactState = {
     ...context.artifactState ?? {},
     listColumnMap: {
@@ -8549,11 +8804,6 @@ function createToolState(hooks, context) {
   return {
     artifactState,
     patchArtifactState,
-    getCurrentCanvasId: () => artifactState.lastCanvasId,
-    getTurnCreatedCanvasId: () => turnCreatedCanvasId,
-    setTurnCreatedCanvasId: (canvasId) => {
-      turnCreatedCanvasId = canvasId;
-    },
     getCurrentListId: () => artifactState.lastListId,
     getOperationResult: (operationKey) => operationResultCache.get(operationKey),
     setOperationResult: (operationKey, result) => {
@@ -8584,7 +8834,8 @@ function createTools(availableSkills, hooks = {}, context) {
       hooks.toolOverrides?.imageGenerate
     ),
     slackCanvasRead: createSlackCanvasReadTool(),
-    slackCanvasUpdate: createSlackCanvasUpdateTool(state, context),
+    slackCanvasEdit: createSlackCanvasEditTool(state),
+    slackCanvasWrite: createSlackCanvasWriteTool(state),
     slackThreadRead: createSlackThreadReadTool(context),
     slackUserLookup: createSlackUserLookupTool(),
     slackListCreate: createSlackListCreateTool(state),
@@ -10304,7 +10555,16 @@ function createSandboxExecutor(options) {
         "app.sandbox.path.length": filePath.length
       },
       async () => {
-        const response = await executeReadFile({ path: filePath });
+        let response;
+        try {
+          response = await executeReadFile({ path: filePath });
+        } catch (error) {
+          if (isMissingPathError(error)) {
+            setSpanStatus("ok");
+            return missingFileResult(filePath);
+          }
+          throw error;
+        }
         const content = String(response.content ?? "");
         setSpanAttributes({
           "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
@@ -16363,24 +16623,14 @@ function createSlackTurnRuntime(deps) {
         const threadId = deps.getThreadId(thread, message);
         const channelId = deps.getChannelId(thread, message);
         const runId = deps.getRunId(thread, message);
-        const context = logContext({
+        const turnContext = logContext({
           threadId,
           requesterId: message.author.userId,
           requesterUserName: message.author.userName,
           channelId,
           runId
         });
-        processingReaction = await startSlackProcessingReaction({
-          thread,
-          message,
-          logException: deps.logException,
-          logContext: context
-        });
-        const toolInvocationHook = createToolInvocationHook(
-          processingReaction,
-          hooks
-        );
-        await deps.withSpan("chat.turn", "chat.turn", context, async () => {
+        await deps.withSpan("chat.turn", "chat.turn", turnContext, async () => {
           const legacyAttachmentText = renderSlackLegacyAttachmentText(
             message.raw
           );
@@ -16395,7 +16645,7 @@ function createSlackTurnRuntime(deps) {
             strippedUserText,
             message.raw
           );
-          const context2 = {
+          const threadContext = {
             threadId,
             requesterId: message.author.userId,
             channelId,
@@ -16413,7 +16663,7 @@ function createSlackTurnRuntime(deps) {
               thread,
               message,
               decision: { shouldReply: false, reason },
-              context: context2,
+              context: threadContext,
               userText
             });
             return;
@@ -16423,7 +16673,7 @@ function createSlackTurnRuntime(deps) {
             message,
             userText,
             explicitMention: Boolean(message.isMention),
-            context: context2
+            context: threadContext
           });
           await deps.persistPreparedState({
             thread,
@@ -16435,7 +16685,7 @@ function createSlackTurnRuntime(deps) {
             conversationContext: deps.getPreparedConversationContext(preparedState),
             hasAttachments: message.attachments.length > 0 || legacyAttachmentText !== "",
             isExplicitMention: Boolean(message.isMention),
-            context: context2
+            context: threadContext
           });
           if (await maybeHandleThreadOptOutDecision({
             thread,
@@ -16446,7 +16696,7 @@ function createSlackTurnRuntime(deps) {
               thread,
               message,
               decision,
-              context: context2,
+              context: threadContext,
               preparedState,
               userText
             });
@@ -16457,12 +16707,22 @@ function createSlackTurnRuntime(deps) {
               thread,
               message,
               decision,
-              context: context2,
+              context: threadContext,
               preparedState,
               userText
             });
             return;
           }
+          processingReaction = await startSlackProcessingReaction({
+            thread,
+            message,
+            logException: deps.logException,
+            logContext: turnContext
+          });
+          const toolInvocationHook = createToolInvocationHook(
+            processingReaction,
+            hooks
+          );
           await deps.replyToThread(thread, message, {
             explicitMention: Boolean(message.isMention),
             preparedState,

package/package.json

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