@sentry/junior 0.116.1 → 0.118.0

package/dist/{chunk-ZYHLNTC2.js → chunk-GT2ZUALJ.js}

@@ -1,23 +1,21 @@
 import {
-  SANDBOX_WORKSPACE_ROOT,
-  getStateAdapter
-} from "./chunk-7CSVG54J.js";
+  getDb
+} from "./chunk-KC5EE27Y.js";
 import {
-  createPluginAnnotations,
-  isConversationChannel,
-  isConversationScopedChannel,
-  isDmChannel,
-  normalizeSlackConversationId
-} from "./chunk-FAEALXEH.js";
+  juniorConversationAnnotations
+} from "./chunk-GCGJGSQL.js";
 import {
-  getDb
-} from "./chunk-BFYVIOTS.js";
+  SANDBOX_WORKSPACE_ROOT,
+  getStateAdapter,
+  sleep
+} from "./chunk-3N3FMCKN.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
+  getSlackBotToken,
   standardModelId
-} from "./chunk-CY7NXM32.js";
+} from "./chunk-PWRFTDTY.js";
 import {
   isActorUserId,
   parseActorUserId
@@ -25,8 +23,11 @@ import {
 import {
   logException,
   logInfo,
-  logWarn
-} from "./chunk-F3SWGSPG.js";
+  logWarn,
+  setSpanAttributes,
+  setSpanStatus,
+  withSpan
+} from "./chunk-MLZFK4KP.js";
 import {
   parseSlackChannelReferenceId,
   parseSlackMessageTs,
@@ -35,10 +36,72 @@ import {
 
 // src/chat/plugins/agent-hooks.ts
 import {
+  promptContextSchema,
   promptMessageSchema,
   resourceEventSchema
 } from "@sentry/junior-plugin-api";
 
+// src/chat/plugins/annotations.ts
+import { and, desc, eq } from "drizzle-orm";
+import {
+  conversationAnnotationInputSchema
+} from "@sentry/junior-plugin-api";
+function createPluginAnnotations(args) {
+  return {
+    async upsert(input) {
+      const annotation = conversationAnnotationInputSchema.parse(input);
+      const now = /* @__PURE__ */ new Date();
+      await args.db.insert(juniorConversationAnnotations).values({
+        annotation,
+        conversationId: args.conversationId,
+        createdAt: now,
+        key: annotation.key,
+        kind: annotation.kind,
+        plugin: args.plugin,
+        updatedAt: now
+      }).onConflictDoUpdate({
+        target: [
+          juniorConversationAnnotations.conversationId,
+          juniorConversationAnnotations.plugin,
+          juniorConversationAnnotations.kind,
+          juniorConversationAnnotations.key
+        ],
+        set: { annotation, updatedAt: now }
+      });
+    },
+    async remove(kind, key) {
+      await args.db.delete(juniorConversationAnnotations).where(
+        and(
+          eq(
+            juniorConversationAnnotations.conversationId,
+            args.conversationId
+          ),
+          eq(juniorConversationAnnotations.plugin, args.plugin),
+          eq(juniorConversationAnnotations.kind, kind),
+          eq(juniorConversationAnnotations.key, key)
+        )
+      );
+    },
+    async list() {
+      return (await listConversationAnnotations(args.db, args.conversationId)).filter((a) => a.plugin === args.plugin);
+    }
+  };
+}
+async function listConversationAnnotations(db, conversationId) {
+  const rows = await db.select().from(juniorConversationAnnotations).where(eq(juniorConversationAnnotations.conversationId, conversationId)).orderBy(desc(juniorConversationAnnotations.updatedAt));
+  return rows.flatMap((row) => {
+    const parsed = conversationAnnotationInputSchema.safeParse(row.annotation);
+    return parsed.success ? [
+      {
+        ...parsed.data,
+        plugin: row.plugin,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString()
+      }
+    ] : [];
+  });
+}
+
 // src/chat/plugins/logging.ts
 function createPluginLogger(plugin) {
   return {
@@ -260,6 +323,428 @@ function getSlackToolContext(context) {
 
 // src/chat/credentials/subject.ts
 import { createHmac, timingSafeEqual } from "crypto";
+
+// src/chat/slack/client.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { WebClient } from "@slack/web-api";
+
+// src/chat/slack/workspace-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var workspaceTeamIdStorage = new AsyncLocalStorage();
+function runWithWorkspaceTeamId(teamId, fn) {
+  if (!teamId) return fn();
+  return workspaceTeamIdStorage.run(teamId, fn);
+}
+function getWorkspaceTeamId() {
+  return workspaceTeamIdStorage.getStore();
+}
+
+// src/chat/slack/client.ts
+var SlackActionError = class extends Error {
+  code;
+  apiError;
+  needed;
+  provided;
+  statusCode;
+  requestId;
+  errorData;
+  retryAfterSeconds;
+  detail;
+  detailLine;
+  detailRule;
+  constructor(message, code, options = {}) {
+    super(message);
+    this.name = "SlackActionError";
+    this.code = code;
+    this.apiError = options.apiError;
+    this.needed = options.needed;
+    this.provided = options.provided;
+    this.statusCode = options.statusCode;
+    this.requestId = options.requestId;
+    this.errorData = options.errorData;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+    this.detail = options.detail;
+    this.detailLine = options.detailLine;
+    this.detailRule = options.detailRule;
+  }
+};
+function serializeSlackErrorData(data) {
+  if (!data || typeof data !== "object") {
+    return void 0;
+  }
+  const filtered = Object.fromEntries(
+    Object.entries(data).filter(
+      ([key]) => key !== "error"
+    )
+  );
+  if (Object.keys(filtered).length === 0) {
+    return void 0;
+  }
+  try {
+    const serialized = JSON.stringify(filtered);
+    return serialized.length <= 600 ? serialized : `${serialized.slice(0, 597)}...`;
+  } catch {
+    return void 0;
+  }
+}
+function getHeaderString(headers, name) {
+  if (!headers || typeof headers !== "object") {
+    return void 0;
+  }
+  const key = name.toLowerCase();
+  const entries = headers;
+  for (const [entryKey, value] of Object.entries(entries)) {
+    if (entryKey.toLowerCase() !== key) continue;
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      const first = value.find((entry) => typeof entry === "string");
+      return typeof first === "string" ? first : void 0;
+    }
+  }
+  return void 0;
+}
+function parseSlackCanvasDetail(detail) {
+  if (typeof detail !== "string") {
+    return {};
+  }
+  const trimmed = detail.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const parsed = {
+    detail: trimmed
+  };
+  const lineMatch = trimmed.match(/line\s+(\d+):/i);
+  if (lineMatch) {
+    const line = Number.parseInt(lineMatch[1] ?? "", 10);
+    if (Number.isFinite(line)) {
+      parsed.detailLine = line;
+    }
+  }
+  if (/unsupported heading depth/i.test(trimmed)) {
+    parsed.detailRule = "unsupported_heading_depth";
+  }
+  return parsed;
+}
+var installationTokenStorage = new AsyncLocalStorage2();
+var clientsByToken = /* @__PURE__ */ new Map();
+function runWithSlackInstallationToken(token, fn) {
+  const trimmed = token.trim();
+  if (!trimmed) {
+    throw new SlackActionError(
+      "Slack installation token binding requires a non-empty token",
+      "missing_token"
+    );
+  }
+  return installationTokenStorage.run({ token: trimmed }, fn);
+}
+function resolveSlackToken() {
+  const ambientToken = installationTokenStorage.getStore()?.token;
+  if (ambientToken) {
+    return ambientToken;
+  }
+  const envToken = getSlackBotToken();
+  if (envToken) {
+    return envToken;
+  }
+  const teamId = getWorkspaceTeamId();
+  if (teamId) {
+    throw new SlackActionError(
+      `Slack call is scoped to workspace ${teamId} but no installation token is bound and no default bot token is configured`,
+      "missing_token"
+    );
+  }
+  throw new SlackActionError(
+    "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack Web API actions in this service",
+    "missing_token"
+  );
+}
+function normalizeSlackConversationId(channelId) {
+  return parseSlackChannelReferenceId(channelId);
+}
+function getClient() {
+  const token = resolveSlackToken();
+  let cached = clientsByToken.get(token);
+  if (!cached) {
+    cached = new WebClient(token, {
+      retryConfig: { retries: 0 },
+      rejectRateLimitedCalls: true
+    });
+    clientsByToken.set(token, cached);
+  }
+  return cached;
+}
+function mapSlackError(error) {
+  if (error instanceof SlackActionError) {
+    return error;
+  }
+  const candidate = error;
+  const apiError = candidate.data?.error;
+  const message = candidate.message ?? "Slack action failed";
+  const baseOptions = {
+    apiError,
+    statusCode: candidate.statusCode,
+    requestId: getHeaderString(candidate.headers, "x-slack-req-id"),
+    errorData: serializeSlackErrorData(candidate.data),
+    ...parseSlackCanvasDetail(candidate.data?.detail)
+  };
+  if (apiError === "missing_scope") {
+    return new SlackActionError(message, "missing_scope", {
+      ...baseOptions,
+      needed: candidate.data?.needed,
+      provided: candidate.data?.provided
+    });
+  }
+  if (apiError === "not_in_channel") {
+    return new SlackActionError(message, "not_in_channel", baseOptions);
+  }
+  if (apiError === "restricted_action_read_only_channel") {
+    return new SlackActionError(message, "read_only_channel", baseOptions);
+  }
+  if (apiError === "already_reacted") {
+    return new SlackActionError(message, "already_reacted", baseOptions);
+  }
+  if (apiError === "no_reaction") {
+    return new SlackActionError(message, "no_reaction", baseOptions);
+  }
+  if (apiError === "invalid_arguments") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "invalid_cursor") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "invalid_name") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
+    return new SlackActionError(message, "not_found", baseOptions);
+  }
+  if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
+    return new SlackActionError(message, "feature_unavailable", baseOptions);
+  }
+  if (apiError === "canvas_creation_failed") {
+    return new SlackActionError(message, "canvas_creation_failed", baseOptions);
+  }
+  if (apiError === "canvas_editing_failed") {
+    return new SlackActionError(message, "canvas_editing_failed", baseOptions);
+  }
+  if (candidate.code === "slack_webapi_rate_limited_error" || candidate.statusCode === 429) {
+    return new SlackActionError(message, "rate_limited", {
+      ...baseOptions,
+      retryAfterSeconds: candidate.retryAfter
+    });
+  }
+  return new SlackActionError(message, "internal_error", baseOptions);
+}
+var MAX_RETRY_DELAY_MS = 1e4;
+var MAX_TOTAL_RETRY_DELAY_MS = 2e4;
+var CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "EAI_AGAIN"
+]);
+var TIMEOUT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ETIMEDOUT",
+  "ECONNABORTED",
+  "ESOCKETTIMEDOUT"
+]);
+function findNetworkErrorCode(error, depth = 0) {
+  if (!error || typeof error !== "object" || depth > 4) {
+    return void 0;
+  }
+  const candidate = error;
+  if (typeof candidate.code === "string" && (CONNECTION_ERROR_CODES.has(candidate.code) || TIMEOUT_ERROR_CODES.has(candidate.code))) {
+    return candidate.code;
+  }
+  return findNetworkErrorCode(candidate.original, depth + 1) ?? findNetworkErrorCode(candidate.cause, depth + 1);
+}
+function hasSocketHangUpMessage(error) {
+  return error instanceof Error && error.message.toLowerCase().includes("socket hang up");
+}
+function classifySlackRetry(raw, mapped) {
+  if (mapped.code === "rate_limited") {
+    return "rate_limited";
+  }
+  if (mapped.statusCode !== void 0 && mapped.statusCode >= 500) {
+    return "server_error";
+  }
+  const networkCode = findNetworkErrorCode(raw);
+  if (networkCode && CONNECTION_ERROR_CODES.has(networkCode)) {
+    return "connection";
+  }
+  if (networkCode && TIMEOUT_ERROR_CODES.has(networkCode)) {
+    return "timeout";
+  }
+  if (hasSocketHangUpMessage(raw)) {
+    return "connection";
+  }
+  return "none";
+}
+async function withSlackRetries(task, maxAttempts = 3, context = {}) {
+  let attempt = 0;
+  let totalDelayMs = 0;
+  const action = context.action ?? "unknown";
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    const attemptNumber = attempt;
+    try {
+      return await withSpan(
+        `POST slack.com/api/${action}`,
+        "http.client",
+        {},
+        async () => {
+          try {
+            return await task();
+          } catch (error) {
+            const mapped = mapSlackError(error);
+            const errorAttrs = {
+              "error.type": mapped.code
+            };
+            if (mapped.apiError) {
+              errorAttrs["app.slack.api_error_code"] = mapped.apiError;
+            }
+            if (mapped.code === "rate_limited") {
+              errorAttrs["http.response.status_code"] = 429;
+              if (mapped.retryAfterSeconds) {
+                errorAttrs["app.slack.retry_after_ms"] = mapped.retryAfterSeconds * 1e3;
+              }
+            } else if (mapped.statusCode != null) {
+              errorAttrs["http.response.status_code"] = mapped.statusCode;
+            }
+            setSpanAttributes(errorAttrs);
+            setSpanStatus("error");
+            throw error;
+          }
+        },
+        {
+          "http.request.method": "POST",
+          "server.address": "slack.com",
+          "url.scheme": "https",
+          "url.path": `/api/${action}`,
+          "app.slack.method": action,
+          "app.retry.max_attempts": maxAttempts,
+          ...attemptNumber > 1 ? { "http.resend_count": attemptNumber - 1 } : {},
+          ...context.attributes ?? {},
+          ...context.spanAttributes ?? {}
+        }
+      );
+    } catch (error) {
+      const mapped = mapSlackError(error);
+      const retryClass = classifySlackRetry(error, mapped);
+      const isRetryable = retryClass === "rate_limited" || retryClass === "connection" || retryClass === "server_error" || retryClass === "timeout" && context.idempotent === true;
+      const remainingDelayBudgetMs = MAX_TOTAL_RETRY_DELAY_MS - totalDelayMs;
+      const baseLogAttributes = {
+        "app.slack.action": action,
+        "app.slack.error_code": mapped.code,
+        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
+        ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
+        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : {},
+        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : {},
+        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : {},
+        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : {},
+        ...context.attributes ?? {}
+      };
+      if (!isRetryable || attempt >= maxAttempts || remainingDelayBudgetMs <= 0) {
+        logWarn(
+          "slack_action_failed",
+          {},
+          {
+            ...baseLogAttributes,
+            ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : {}
+          },
+          "Slack action failed"
+        );
+        throw mapped;
+      }
+      logWarn(
+        "slack_action_retrying",
+        {},
+        {
+          ...baseLogAttributes,
+          "app.slack.retry_attempt": attempt,
+          "app.slack.retry_class": retryClass
+        },
+        "Retrying Slack action after transient failure"
+      );
+      const retryAfterMs = retryClass === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
+      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
+      const delayMs = Math.min(
+        retryAfterMs ?? backoffMs,
+        MAX_RETRY_DELAY_MS,
+        remainingDelayBudgetMs
+      );
+      totalDelayMs += delayMs;
+      await sleep(delayMs);
+    }
+  }
+  throw new SlackActionError(
+    "Slack action exhausted retries",
+    "internal_error"
+  );
+}
+function getSlackClient() {
+  return getClient();
+}
+function isDmChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  return Boolean(normalized && normalized.startsWith("D"));
+}
+function isConversationScopedChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return false;
+  return normalized.startsWith("C") || normalized.startsWith("G") || normalized.startsWith("D");
+}
+function isConversationChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return false;
+  return normalized.startsWith("C") || normalized.startsWith("G");
+}
+async function getFilePermalink(fileId) {
+  const client = getClient();
+  const response = await withSlackRetries(
+    () => client.files.info({
+      file: fileId
+    }),
+    3,
+    {
+      action: "files.info",
+      idempotent: true,
+      spanAttributes: { "app.slack.file_id": fileId }
+    }
+  );
+  return response.file?.permalink;
+}
+async function downloadPrivateSlackFile(url) {
+  const token = resolveSlackToken();
+  return withSpan(
+    "GET files.slack.com",
+    "http.client",
+    {},
+    async () => {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+      setSpanAttributes({ "http.response.status_code": response.status });
+      if (!response.ok) {
+        setSpanAttributes({ "error.type": String(response.status) });
+        setSpanStatus("error");
+        throw new Error(`Slack file download failed: ${response.status}`);
+      }
+      return Buffer.from(await response.arrayBuffer());
+    },
+    {
+      "http.request.method": "GET",
+      "server.address": "files.slack.com",
+      "url.scheme": "https",
+      "app.slack.method": "files.download"
+    }
+  );
+}
+
+// src/chat/credentials/subject.ts
 var CREDENTIAL_SUBJECT_HMAC_CONTEXT = "junior.credential_subject.v1";
 var CREDENTIAL_SUBJECT_SIGNATURE_VERSION = "v1";
 function getCredentialSubjectSecret() {
@@ -426,8 +911,9 @@ var PLUGIN_ROUTE_METHODS = /* @__PURE__ */ new Set([
   "ALL"
 ]);
 var PLUGIN_PROMPT_CONTRIBUTION_TOTAL_MAX_CHARS = 16e3;
+var PLUGIN_PROMPT_CONTEXT_MAX_BYTES = 8e3;
+var PLUGIN_PROMPT_CONTEXT_TOTAL_MAX_BYTES = 16e3;
 var systemPromptMessageArraySchema = z.array(promptMessageSchema);
-var userPromptMessageArraySchema = z.array(promptMessageSchema);
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -492,6 +978,53 @@ function toPromptContributionContext(args) {
     text: args.message.text
   };
 }
+function normalizePromptContext(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0 || Buffer.byteLength(serialized, "utf8") > PLUGIN_PROMPT_CONTEXT_MAX_BYTES) {
+    throw new TypeError("Plugin prompt context exceeded its serialized budget");
+  }
+  const parsed = JSON.parse(serialized);
+  if (!isRecord(parsed)) {
+    throw new TypeError("Plugin prompt context must be a JSON object");
+  }
+  return parsed;
+}
+function toUserPromptContributionContext(args) {
+  const message = promptMessageSchema.safeParse(args.value);
+  if (message.success) {
+    return toPromptContributionContext({
+      hookName: "userPrompt",
+      index: args.index,
+      message: message.data,
+      pluginName: args.pluginName
+    });
+  }
+  if (!isRecord(args.value) || typeof args.value.renderPrompt !== "function") {
+    return void 0;
+  }
+  const context = promptContextSchema.safeParse(args.value.context);
+  if (!context.success) {
+    return void 0;
+  }
+  const text = promptMessageSchema.safeParse({
+    text: args.value.renderPrompt()
+  });
+  if (!text.success) {
+    return void 0;
+  }
+  return {
+    id: `userPrompt:${args.index}`,
+    pluginName: args.pluginName,
+    text: text.data.text,
+    context: {
+      content: normalizePromptContext(context.data.content),
+      kind: context.data.kind,
+      loadedAtMs: Date.now(),
+      pluginName: args.pluginName,
+      version: context.data.version
+    }
+  };
+}
 function logInvalidPromptContributions(args) {
   logWarn(
     "plugin_prompt_contribution_result_invalid",
@@ -606,6 +1139,7 @@ async function getPluginSystemPromptContributions(source) {
 async function getPluginUserPromptContributions(args) {
   const contributions = [];
   let totalChars = 0;
+  let totalContextBytes = 0;
   for (const plugin of getPlugins()) {
     const pluginName = plugin.manifest.name;
     const hook = plugin.hooks?.userPrompt;
@@ -619,27 +1153,38 @@ async function getPluginUserPromptContributions(args) {
       if (rawResult === void 0) {
         continue;
       }
-      const result = userPromptMessageArraySchema.safeParse(rawResult);
-      if (!result.success) {
+      if (!Array.isArray(rawResult)) {
         logInvalidPromptContributions({
           hookName: "userPrompt",
           pluginName
         });
         continue;
       }
-      const acceptedContributions = result.data.map(
-        (message, index) => toPromptContributionContext({
+      const acceptedContributions = rawResult.map(
+        (value, index) => toUserPromptContributionContext({ index, pluginName, value })
+      );
+      if (acceptedContributions.some((contribution) => !contribution)) {
+        logInvalidPromptContributions({
           hookName: "userPrompt",
-          index,
-          message,
           pluginName
-        })
+        });
+        continue;
+      }
+      const validContributions = acceptedContributions.filter(
+        (contribution) => contribution !== void 0
       );
-      const pluginContributionChars = acceptedContributions.reduce(
+      const pluginContributionChars = validContributions.reduce(
         (sum, contribution) => sum + contribution.text.length,
         0
       );
-      if (totalChars + pluginContributionChars > PLUGIN_PROMPT_CONTRIBUTION_TOTAL_MAX_CHARS) {
+      const pluginContextBytes = validContributions.reduce(
+        (sum, contribution) => sum + (contribution.context ? Buffer.byteLength(
+          JSON.stringify(contribution.context.content),
+          "utf8"
+        ) : 0),
+        0
+      );
+      if (totalChars + pluginContributionChars > PLUGIN_PROMPT_CONTRIBUTION_TOTAL_MAX_CHARS || totalContextBytes + pluginContextBytes > PLUGIN_PROMPT_CONTEXT_TOTAL_MAX_BYTES) {
         logWarn(
           "plugin_user_prompt_contribution_budget_exceeded",
           {},
@@ -651,7 +1196,8 @@ async function getPluginUserPromptContributions(args) {
         continue;
       }
       totalChars += pluginContributionChars;
-      contributions.push(...acceptedContributions);
+      totalContextBytes += pluginContextBytes;
+      contributions.push(...validContributions);
     } catch (error) {
       logWarn(
         "plugin_user_prompt_hook_failed",
@@ -1299,6 +1845,7 @@ function createPluginHookRunner(input = {}) {
 }
 
 export {
+  listConversationAnnotations,
   createPluginLogger,
   createPluginModel,
   createPluginEmbedder,
@@ -1306,6 +1853,18 @@ export {
   setDashboardConversationLinkOptions,
   getDashboardConversationLink,
   getSlackToolContext,
+  runWithWorkspaceTeamId,
+  getWorkspaceTeamId,
+  SlackActionError,
+  getHeaderString,
+  runWithSlackInstallationToken,
+  normalizeSlackConversationId,
+  withSlackRetries,
+  getSlackClient,
+  isDmChannel,
+  isConversationScopedChannel,
+  getFilePermalink,
+  downloadPrivateSlackFile,
   bindSlackDirectCredentialSubject,
   verifySlackDirectCredentialSubject,
   bindScheduledTaskCredentialSubject,

package/dist/{chunk-KNCELO2M.js → chunk-HN6LFYG3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-PE44LDDQ.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-FAEALXEH.js";
+} from "./chunk-GT2ZUALJ.js";
 import {
   parseSlackThreadId
 } from "./chunk-FXOYURO4.js";