@sentry/junior 0.133.0 → 0.135.0

package/dist/{chunk-ECUILEUX.js → chunk-NGX2V4WY.js}

@@ -1,10 +1,11 @@
 import {
   JUNIOR_NATIVE_EVENT_NAMESPACE,
+  ToolInputError,
   addAgentTurnUsage,
   agentTurnUsageSchema,
   authenticationLinkedEvent,
   authenticationUnlinkedEvent
-} from "./chunk-HX236W2U.js";
+} from "./chunk-CDQ4YIZM.js";
 import {
   agentHistoryItemSchema,
   bindProviderConversation,
@@ -17,17 +18,18 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-LNYNTR27.js";
+} from "./chunk-VZEKCQLD.js";
 import {
+  SANDBOX_WORKSPACE_ROOT,
   getStateAdapter,
   sleep
-} from "./chunk-TLN54TOQ.js";
+} from "./chunk-TYEDZVRM.js";
 import {
   botConfig,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-LDRO4OQ4.js";
+} from "./chunk-RMI6OX52.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -42,19 +44,35 @@ import {
   setSpanAttributes,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-EJRJWBKG.js";
+} from "./chunk-QQCEMMVN.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
 
 // src/chat/pi/transcript.ts
 var RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
+var AGENTS_INSTRUCTIONS_START = "# AGENTS.md instructions";
 function userMessageContent(message) {
   const record = message;
   return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
 }
 function isRuntimeTurnContextPart(part) {
-  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(RUNTIME_TURN_CONTEXT_START);
+  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && (part.text.startsWith(RUNTIME_TURN_CONTEXT_START) || part.text.startsWith(AGENTS_INSTRUCTIONS_START));
+}
+function hasCurrentInstruction(message) {
+  return userMessageContent(message)?.some(
+    (part) => part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.includes("<current-instruction")
+  ) ?? false;
+}
+function messageTimestamp(message) {
+  return message.timestamp;
+}
+function isStandaloneRuntimeContextMessage(messages, index) {
+  const message = messages[index];
+  const next = messages[index + 1];
+  return Boolean(
+    message && next && userMessageContent(message) && userMessageContent(next) && messageTimestamp(message) === messageTimestamp(next) && !hasCurrentInstruction(message) && hasCurrentInstruction(next)
+  );
 }
 var EMBEDDED_THREAD_CONTEXT_TAGS = [
   "recent-thread-messages",
@@ -123,11 +141,14 @@ function trimTrailingAssistantMessages(messages) {
 }
 function hasRuntimeTurnContext(messages) {
   return messages.some(
-    (message) => userMessageContent(message)?.some(isRuntimeTurnContextPart)
+    (message, index) => isStandaloneRuntimeContextMessage(messages, index) || userMessageContent(message)?.some(isRuntimeTurnContextPart)
   );
 }
 function retainRuntimeTurnContext(messages) {
-  return messages.flatMap((message) => {
+  return messages.flatMap((message, index) => {
+    if (isStandaloneRuntimeContextMessage(messages, index)) {
+      return [message];
+    }
     const runtimeContent = userMessageContent(message)?.filter(isRuntimeTurnContextPart) ?? [];
     return runtimeContent.length > 0 ? [{ ...message, content: runtimeContent }] : [];
   });
@@ -147,7 +168,10 @@ function getUserMessageInstructionText(message) {
   return instructionTextForProjection(text).trim();
 }
 function stripRuntimeTurnContext(messages) {
-  return messages.flatMap((message) => {
+  return messages.flatMap((message, index) => {
+    if (isStandaloneRuntimeContextMessage(messages, index)) {
+      return [];
+    }
     const content = userMessageContent(message);
     if (!content) return [message];
     const nextContent = content.filter(
@@ -978,7 +1002,7 @@ async function loadConnectedMcpProviders(args) {
   );
   return connectedMcpProvidersFromEvents(events);
 }
-function messageTimestamp(message) {
+function messageTimestamp2(message) {
   const timestamp = message.timestamp;
   return typeof timestamp === "number" ? timestamp : Date.now();
 }
@@ -1006,7 +1030,7 @@ async function commitAcceptedReply(args) {
             {
               idempotencyKey: `message:${args.conversationMessageId}:agent`,
               data: historyItemFromPiMessage(agentMessage, contextProvenance),
-              createdAtMs: messageTimestamp(agentMessage)
+              createdAtMs: messageTimestamp2(agentMessage)
             }
           ]
         );
@@ -1070,7 +1094,7 @@ async function commitMessagesLocked(args, executor) {
           message,
           nextLocalProvenance[matchingPrefix + index]
         ),
-        createdAtMs: messageTimestamp(message)
+        createdAtMs: messageTimestamp2(message)
       })),
       ...turnContextEvents
     ]);
@@ -1399,6 +1423,354 @@ import {
 } from "@sentry/junior-plugin-api";
 import { z as z2 } from "zod";
 
+// src/chat/repository-instructions.ts
+import { createHash as createHash2 } from "crypto";
+import path2 from "path";
+
+// src/chat/tools/sandbox/file-utils.ts
+import path from "path";
+var MAX_TEXT_CHARS = 6e4;
+var RIPGREP_EXCLUDED_GLOBS = [
+  "!**/.git/**",
+  "!**/node_modules/**"
+];
+var DEFAULT_SEARCH_COMMAND_TIMEOUT_MS = 3e4;
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function positiveInteger2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  const integer = Math.floor(value);
+  return integer > 0 ? integer : void 0;
+}
+function normalizeToLf(value) {
+  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function truncateText(value, maxChars = MAX_TEXT_CHARS) {
+  if (value.length <= maxChars) {
+    return { content: value, truncated: false };
+  }
+  const removed = value.length - maxChars;
+  return {
+    content: `${value.slice(0, maxChars)}
+
+[output truncated: ${removed} characters removed]`,
+    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;
+  throw new ToolInputError(`Path not found: ${textPath}`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function globToRegExp(pattern) {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    const next = pattern[index + 1];
+    if (char === "*" && next === "*") {
+      if (pattern[index + 2] === "/") {
+        source += "(?:.*/)?";
+        index += 2;
+        continue;
+      }
+      source += ".*";
+      index += 1;
+      continue;
+    }
+    if (char === "*") {
+      source += "[^/]*";
+      continue;
+    }
+    if (char === "?") {
+      source += "[^/]";
+      continue;
+    }
+    source += escapeRegExp(char);
+  }
+  return new RegExp(`^${source}$`);
+}
+function matchesGlob(relativePath, pattern) {
+  const matcher = globToRegExp(pattern);
+  if (matcher.test(relativePath)) {
+    return true;
+  }
+  if (pattern.startsWith("**/") && matchesGlob(relativePath, pattern.slice(3))) {
+    return true;
+  }
+  return !pattern.includes("/") && matcher.test(path.posix.basename(relativePath));
+}
+function resolveWorkspacePath(input, fallback = ".") {
+  const requested = (input ?? "").trim() || fallback;
+  const absolute = requested.startsWith("/") ? requested : path.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
+  const normalized = path.posix.normalize(absolute);
+  if (normalized !== SANDBOX_WORKSPACE_ROOT && !normalized.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) {
+    throw new ToolInputError(
+      `Path must stay within ${SANDBOX_WORKSPACE_ROOT}: ${requested}`
+    );
+  }
+  return normalized;
+}
+function getRipgrepSearchLocation(root, rootIsDirectory) {
+  if (rootIsDirectory) {
+    return { cwd: root, target: "." };
+  }
+  return {
+    cwd: path.posix.dirname(root),
+    target: path.posix.basename(root)
+  };
+}
+async function collectFiles(params) {
+  const files = [];
+  let limitReached = false;
+  let missingPath;
+  const visit = async (dirPath) => {
+    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 = path.posix.join(dirPath, entry);
+      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);
+        }
+        if (limitReached) return;
+        continue;
+      }
+      const relativePath = path.posix.relative(params.root, fullPath);
+      if (!params.pattern || matchesGlob(relativePath, params.pattern)) {
+        files.push(fullPath);
+        if (params.limit && files.length >= params.limit) {
+          limitReached = true;
+          return;
+        }
+      }
+    }
+  };
+  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 = path.posix.basename(params.root);
+    return {
+      files: !params.pattern || matchesGlob(relativePath, params.pattern) ? [params.root] : [],
+      limitReached: false,
+      missingRoot: false
+    };
+  }
+  await visit(params.root);
+  return {
+    files,
+    limitReached,
+    missingPath,
+    missingRoot: missingPath === params.root
+  };
+}
+
+// src/chat/repository-instructions.ts
+var AGENTS_FILENAME = "AGENTS.md";
+var MAX_REPOSITORY_INSTRUCTIONS_BYTES = 32 * 1024;
+var AGENTS_REPLACEMENT_NOTICE = "These AGENTS.md instructions replace all previously provided AGENTS.md instructions.";
+var AGENTS_REMOVAL_NOTICE = "The previously provided AGENTS.md instructions no longer apply.";
+async function pathExists(fs, target) {
+  try {
+    await fs.stat(target);
+    return true;
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function directoryExists(fs, target) {
+  try {
+    return (await fs.stat(target)).isDirectory();
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function findGitRoot(fs, cwd) {
+  let current = cwd;
+  for (; ; ) {
+    if (await pathExists(fs, path2.posix.join(current, ".git"))) {
+      return current;
+    }
+    if (current === SANDBOX_WORKSPACE_ROOT) {
+      return void 0;
+    }
+    const parent = path2.posix.dirname(current);
+    if (parent === current || parent !== SANDBOX_WORKSPACE_ROOT && !parent.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+async function findSingleRepositoryDirectory(fs) {
+  const entries = await fs.readdir(SANDBOX_WORKSPACE_ROOT);
+  const repositories = [];
+  for (const entry of entries) {
+    const candidate = path2.posix.join(SANDBOX_WORKSPACE_ROOT, entry);
+    if (await directoryExists(fs, candidate) && await pathExists(fs, path2.posix.join(candidate, ".git"))) {
+      repositories.push(candidate);
+      if (repositories.length > 1) {
+        return void 0;
+      }
+    }
+  }
+  return repositories[0];
+}
+async function readInstructionFile(fs, filePath) {
+  try {
+    const content = await fs.readFile(filePath, { encoding: "utf8" });
+    return content.trim() ? content : void 0;
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function resolveRepositoryInstructions(args) {
+  const gitRoot = await findGitRoot(args.fs, args.cwd);
+  if (!gitRoot) {
+    return void 0;
+  }
+  const directories = [];
+  let current = args.cwd;
+  for (; ; ) {
+    directories.push(current);
+    if (current === gitRoot) {
+      break;
+    }
+    current = path2.posix.dirname(current);
+  }
+  directories.reverse();
+  const sources = [];
+  let remaining = MAX_REPOSITORY_INSTRUCTIONS_BYTES;
+  for (const directory of directories) {
+    if (remaining <= 0) {
+      break;
+    }
+    const filePath = path2.posix.join(directory, AGENTS_FILENAME);
+    const content = await readInstructionFile(args.fs, filePath);
+    if (!content) {
+      continue;
+    }
+    const bytes = Buffer.from(content, "utf8");
+    const bounded = bytes.length <= remaining ? content : bytes.subarray(0, remaining).toString("utf8");
+    sources.push({ content: bounded, path: filePath });
+    remaining -= Buffer.byteLength(bounded, "utf8");
+  }
+  if (sources.length === 0) {
+    return void 0;
+  }
+  const text = sources.map((source) => source.content).join("\n\n");
+  const fingerprint = createHash2("sha256").update(JSON.stringify({ directory: args.cwd, sources })).digest("hex");
+  return { directory: args.cwd, fingerprint, sources, text };
+}
+function renderAgentsInstructions(args) {
+  const directory = args.directory ? ` for ${args.directory}` : "";
+  return `# AGENTS.md instructions${directory}
+
+<INSTRUCTIONS>
+${args.text}
+</INSTRUCTIONS>`;
+}
+function buildAgentsInstructionsMessage(args) {
+  return {
+    role: "user",
+    content: [{ type: "text", text: renderAgentsInstructions(args) }],
+    timestamp: args.timestamp ?? Date.now()
+  };
+}
+function findVisibleAgentsInstructions(messages) {
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+    const message = messages[messageIndex];
+    if (message.role !== "user" || !Array.isArray(message.content)) {
+      continue;
+    }
+    for (let partIndex = message.content.length - 1; partIndex >= 0; partIndex -= 1) {
+      const part = message.content[partIndex];
+      if (part.type !== "text" || typeof part.text !== "string" || !part.text.startsWith("# AGENTS.md instructions")) {
+        continue;
+      }
+      const match = part.text.match(
+        /^# AGENTS\.md instructions(?: for ([^\n]+))?\n\n<INSTRUCTIONS>\n([\s\S]*)\n<\/INSTRUCTIONS>$/
+      );
+      if (!match) {
+        continue;
+      }
+      let text = match[2];
+      if (text === AGENTS_REMOVAL_NOTICE) {
+        return { active: false };
+      }
+      if (text.startsWith(`${AGENTS_REPLACEMENT_NOTICE}
+
+`)) {
+        text = text.slice(AGENTS_REPLACEMENT_NOTICE.length + 2);
+      }
+      return {
+        active: true,
+        ...match[1] ? { directory: match[1] } : {},
+        text
+      };
+    }
+  }
+  return void 0;
+}
+function isAgentsInstructionsMessage(message) {
+  return Boolean(findVisibleAgentsInstructions([message]));
+}
+
 // src/chat/state/turn-session-keys.ts
 var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
 function agentTurnSessionKey(conversationId, sessionId) {
@@ -1530,7 +1902,7 @@ async function recordConversationActivityMetadata(args) {
   });
 }
 function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessageIndex, restoreVolatileContext = true) {
-  const piMessages = restoreVolatileContext && (stored.state === "running" || stored.state === "awaiting_resume") ? restoreRuntimeContext(piProjection.messages, stored.runtimeContext) : piProjection.messages;
+  const restoredProjection = restoreVolatileContext && (stored.state === "running" || stored.state === "awaiting_resume") ? restoreRuntimeContext(piProjection, stored.runtimeContext) : piProjection;
   return {
     version: stored.version,
     ...stored.channelName ? { channelName: stored.channelName } : {},
@@ -1541,8 +1913,8 @@ function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessag
     startedAtMs: stored.startedAtMs,
     lastProgressAtMs: stored.lastProgressAtMs,
     updatedAtMs: stored.updatedAtMs,
-    piMessages,
-    piMessageProvenance: piProjection.provenance,
+    piMessages: restoredProjection.messages,
+    piMessageProvenance: restoredProjection.provenance,
     actors: stored.actors ?? instructionActors(piProjection.provenance),
     cumulativeDurationMs: stored.cumulativeDurationMs,
     ...stored.destination ? { destination: stored.destination } : {},
@@ -1563,30 +1935,41 @@ function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessag
     ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
   };
 }
-function restoreRuntimeContext(messages, runtimeContext) {
-  if (!runtimeContext || runtimeContext.length === 0) return messages;
-  const restored = [...messages];
+function restoreRuntimeContext(projection, runtimeContext) {
+  if (!runtimeContext || runtimeContext.length === 0) return projection;
+  const restoredMessages = [...projection.messages];
+  const restoredProvenance = [...projection.provenance];
   const unmatchedRuntimeContext = [];
   for (const runtimeMessage of runtimeContext) {
     const runtime = runtimeMessage;
-    const targetIndex = restored.findIndex((message) => {
+    const targetIndex = restoredMessages.findIndex((message) => {
       const candidate = message;
       return candidate.role === "user" && candidate.timestamp === runtime.timestamp;
     });
     if (targetIndex < 0) {
-      unmatchedRuntimeContext.push(runtimeMessage);
+      if (isAgentsInstructionsMessage(runtimeMessage)) {
+        const followingIndex = restoredMessages.findIndex((message) => {
+          const timestamp = message.timestamp;
+          return typeof runtime.timestamp === "number" && typeof timestamp === "number" && timestamp > runtime.timestamp;
+        });
+        const insertionIndex = followingIndex < 0 ? restoredMessages.length : followingIndex;
+        restoredMessages.splice(insertionIndex, 0, runtimeMessage);
+        restoredProvenance.splice(insertionIndex, 0, contextProvenance);
+      } else {
+        unmatchedRuntimeContext.push(runtimeMessage);
+      }
       continue;
     }
-    const target = restored[targetIndex];
-    restored[targetIndex] = {
-      ...restored[targetIndex],
-      content: [
-        ...Array.isArray(runtime.content) ? runtime.content : [],
-        ...Array.isArray(target.content) ? target.content : []
-      ]
-    };
+    restoredMessages.splice(targetIndex, 0, runtimeMessage);
+    restoredProvenance.splice(targetIndex, 0, contextProvenance);
   }
-  return [...unmatchedRuntimeContext, ...restored];
+  return {
+    messages: [...unmatchedRuntimeContext, ...restoredMessages],
+    provenance: [
+      ...unmatchedRuntimeContext.map(() => contextProvenance),
+      ...restoredProvenance
+    ]
+  };
 }
 async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
   const stateAdapter = getStateAdapter();
@@ -2944,6 +3327,24 @@ export {
   recordTurnRoute,
   recordToolExecutionStarted,
   recordGuardianActionReviewed,
+  MAX_TEXT_CHARS,
+  RIPGREP_EXCLUDED_GLOBS,
+  DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
+  positiveInteger2 as positiveInteger,
+  normalizeToLf,
+  truncateText,
+  isMissingPathError,
+  missingPathSearchResult,
+  resolveWorkspacePath,
+  getRipgrepSearchLocation,
+  collectFiles,
+  AGENTS_REPLACEMENT_NOTICE,
+  AGENTS_REMOVAL_NOTICE,
+  findSingleRepositoryDirectory,
+  resolveRepositoryInstructions,
+  renderAgentsInstructions,
+  buildAgentsInstructionsMessage,
+  findVisibleAgentsInstructions,
   buildDeterministicTurnId,
   buildDeterministicAssistantMessageId,
   ConversationTurnBoundaryError,

package/dist/{chunk-TBVS7GBE.js → chunk-OSCF2BDE.js}

@@ -2,18 +2,18 @@ import {
   SANDBOX_WORKSPACE_ROOT,
   getStateAdapter,
   sleep
-} from "./chunk-TLN54TOQ.js";
+} from "./chunk-TYEDZVRM.js";
 import {
   toOptionalTrimmed
-} from "./chunk-LDRO4OQ4.js";
+} from "./chunk-RMI6OX52.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-JLN4XSPR.js";
+} from "./chunk-UXYZPEWP.js";
 import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-EJRJWBKG.js";
+} from "./chunk-QQCEMMVN.js";
 
 // src/chat/sandbox/resources.ts
 var configuredResources;
@@ -216,7 +216,7 @@ function buildEnvExports(options) {
   }
   return lines;
 }
-function toCommandScript(input) {
+function buildCommandScript(input) {
   return [shellQuote(input.cmd), ...(input.args ?? []).map(shellQuote)].join(
     " "
   );
@@ -229,7 +229,7 @@ function buildNonInteractiveCommand(input) {
     cmd: "bash",
     args: [
       input.login ? "-lc" : "-c",
-      buildNonInteractiveShellScript(toCommandScript(input), {
+      buildNonInteractiveShellScript(buildCommandScript(input), {
         env: input.env,
         pathPrefix: input.pathPrefix
       })
@@ -1065,6 +1065,9 @@ function isMissingError(error) {
 }
 
 export {
+  buildCommandScript,
+  buildNonInteractiveShellScript,
+  runNonInteractiveCommand,
   isAlreadyExistsError,
   isSandboxUnavailableError,
   isSandboxMissingError,
@@ -1073,8 +1076,6 @@ export {
   wrapSandboxSetupError,
   throwSandboxOperationError,
   getVercelSandboxCredentials,
-  buildNonInteractiveShellScript,
-  runNonInteractiveCommand,
   getSandboxResourceConfig,
   setSandboxResourceConfig,
   getSandboxResources,

package/dist/{chunk-HTGXUNEC.js → chunk-P2D7IW57.js}

@@ -6,25 +6,25 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-WHEMUEXT.js";
+} from "./chunk-ZBQIA5NI.js";
 import {
   getDb,
   parseDestination
-} from "./chunk-LNYNTR27.js";
+} from "./chunk-VZEKCQLD.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   sleep
-} from "./chunk-TLN54TOQ.js";
+} from "./chunk-TYEDZVRM.js";
 import {
   normalizeSlackEmojiName
-} from "./chunk-LDRO4OQ4.js";
+} from "./chunk-RMI6OX52.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-JLN4XSPR.js";
+} from "./chunk-UXYZPEWP.js";
 import {
   fetchWithBoundedOAuthErrorBodies
-} from "./chunk-HJ4KDO4N.js";
+} from "./chunk-6UNZ5DHG.js";
 import {
   parseSlackMessageTs,
   parseSlackUserId
@@ -33,7 +33,7 @@ import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-EJRJWBKG.js";
+} from "./chunk-QQCEMMVN.js";
 
 // src/chat/capabilities/router.ts
 var ProviderCredentialRouter = class {

package/dist/{chunk-EJRJWBKG.js → chunk-QQCEMMVN.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-FX6BLEDP.js";
+} from "./chunk-HDGTBCQR.js";
 
 // src/chat/logging.ts
 import path from "path";