@letta-ai/letta-code 0.30.24 → 0.30.26

package/dist/channels-slack.js

@@ -1,17 +1,291 @@
+// src/channels/slack/attachment-primitives.ts
+var MAX_SLACK_ATTACHMENTS = 8;
+var ALLOWED_SLACK_HOST_SUFFIXES = [
+  "slack.com",
+  "slack-edge.com",
+  "slack-files.com"
+];
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function normalizeSlackFileLike(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  return {
+    id: isNonEmptyString(record.id) ? record.id : undefined,
+    name: isNonEmptyString(record.name) ? record.name : undefined,
+    mimetype: isNonEmptyString(record.mimetype) ? record.mimetype : undefined,
+    size: typeof record.size === "number" ? record.size : undefined,
+    url_private: isNonEmptyString(record.url_private) ? record.url_private : undefined,
+    url_private_download: isNonEmptyString(record.url_private_download) ? record.url_private_download : undefined
+  };
+}
+function normalizeSlackAttachmentLike(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const files = Array.isArray(record.files) ? record.files.map((entry) => normalizeSlackFileLike(entry)).filter((entry) => Boolean(entry)) : undefined;
+  return {
+    image_url: isNonEmptyString(record.image_url) ? record.image_url : undefined,
+    files
+  };
+}
+function collectSlackFiles(rawEvent) {
+  const record = asRecord(rawEvent);
+  if (!record)
+    return [];
+  const deduped = new Map;
+  const push = (file) => {
+    if (!file)
+      return;
+    const key = file.id ?? file.url_private_download ?? file.url_private ?? `${file.name ?? "attachment"}:${file.mimetype ?? ""}`;
+    deduped.set(key, file);
+  };
+  if (Array.isArray(record.files)) {
+    for (const entry of record.files)
+      push(normalizeSlackFileLike(entry));
+  }
+  if (Array.isArray(record.attachments)) {
+    record.attachments.map((entry) => normalizeSlackAttachmentLike(entry)).filter((entry) => Boolean(entry)).forEach((attachment, index) => {
+      for (const file of attachment.files ?? [])
+        push(file);
+      if (attachment.image_url) {
+        push({
+          id: `attachment-image-${index}`,
+          name: `attachment-image-${index}.png`,
+          url_private: attachment.image_url
+        });
+      }
+    });
+  }
+  return Array.from(deduped.values()).slice(0, MAX_SLACK_ATTACHMENTS);
+}
+function nextCursor(page) {
+  const value = page.response_metadata?.next_cursor;
+  return isNonEmptyString(value) ? value.trim() : undefined;
+}
+async function resolveSlackMessageFiles(params) {
+  if (isNonEmptyString(params.threadTs)) {
+    let cursor;
+    do {
+      const page2 = await params.client.conversations.replies({
+        channel: params.channelId,
+        ts: params.threadTs,
+        limit: 200,
+        inclusive: true,
+        ...cursor ? { cursor } : {}
+      });
+      const message2 = (page2.messages ?? []).find((entry) => entry.ts === params.messageTs);
+      if (message2)
+        return collectSlackFiles(message2);
+      cursor = nextCursor(page2);
+    } while (cursor);
+    return null;
+  }
+  const page = await params.client.conversations.history({
+    channel: params.channelId,
+    oldest: params.messageTs,
+    latest: params.messageTs,
+    inclusive: true,
+    limit: 1
+  });
+  const message = (page.messages ?? []).find((entry) => entry.ts === params.messageTs);
+  return message ? collectSlackFiles(message) : null;
+}
+function isAllowedSlackHostname(hostname) {
+  const normalized = hostname.trim().toLowerCase();
+  return ALLOWED_SLACK_HOST_SUFFIXES.some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
+}
+function assertSlackFileUrl(rawUrl) {
+  const parsed = new URL(rawUrl);
+  if (parsed.protocol !== "https:") {
+    throw new Error(`Unsupported Slack file protocol: ${parsed.protocol}`);
+  }
+  if (!isAllowedSlackHostname(parsed.hostname)) {
+    throw new Error(`Refusing non-Slack attachment host: ${parsed.hostname}`);
+  }
+  return parsed;
+}
+function extensionForMimeType(mimeType) {
+  switch (mimeType?.toLowerCase()) {
+    case "image/png":
+      return ".png";
+    case "image/jpeg":
+      return ".jpg";
+    case "image/gif":
+      return ".gif";
+    case "image/webp":
+      return ".webp";
+    case "audio/aac":
+      return ".aac";
+    case "audio/m4a":
+    case "audio/mp4":
+    case "audio/x-m4a":
+      return ".m4a";
+    case "audio/mpeg":
+      return ".mp3";
+    case "audio/ogg":
+      return ".ogg";
+    case "audio/wav":
+    case "audio/x-wav":
+      return ".wav";
+    case "audio/webm":
+      return ".webm";
+    case "application/pdf":
+      return ".pdf";
+    case "text/plain":
+      return ".txt";
+    default:
+      return "";
+  }
+}
+function pathBaseName(pathname) {
+  const trimmed = pathname.replace(/\/+$/, "");
+  const separator = trimmed.lastIndexOf("/");
+  return trimmed.slice(separator + 1);
+}
+function extensionName(name) {
+  const base = pathBaseName(name);
+  if (base === "..")
+    return "";
+  const index = base.lastIndexOf(".");
+  return index > 0 ? base.slice(index) : "";
+}
+function resolveMimeType(name, fallback) {
+  if (fallback)
+    return fallback;
+  switch (extensionName(name).toLowerCase()) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".aac":
+      return "audio/aac";
+    case ".m4a":
+      return "audio/mp4";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".oga":
+    case ".ogg":
+    case ".opus":
+      return "audio/ogg";
+    case ".wav":
+      return "audio/wav";
+    case ".webm":
+      return "audio/webm";
+    case ".pdf":
+      return "application/pdf";
+    case ".txt":
+    case ".md":
+      return "text/plain";
+    default:
+      return;
+  }
+}
+function isGenericSlackMimeType(mimeType) {
+  const normalized = mimeType?.trim().toLowerCase();
+  return normalized === "application/octet-stream" || normalized === "binary/octet-stream";
+}
+function resolveSlackFileName(params) {
+  const hintedName = params.file.name ?? (params.url ? pathBaseName(new URL(params.url).pathname) : undefined) ?? `${params.file.id ?? "attachment"}${extensionForMimeType(params.file.mimetype)}`;
+  return extensionName(hintedName) || !params.mimeType ? hintedName : `${hintedName}${extensionForMimeType(params.mimeType)}`;
+}
+function resolveSlackFileMimeType(params) {
+  const preferredMimeType = params.responseMimeType && !isGenericSlackMimeType(params.responseMimeType) ? params.responseMimeType : params.file.mimetype && !isGenericSlackMimeType(params.file.mimetype) ? params.file.mimetype : undefined;
+  return resolveMimeType(params.fileName, preferredMimeType);
+}
+function resolveSlackFileMetadata(params) {
+  const hintedName = resolveSlackFileName({
+    file: params.file,
+    url: params.url
+  });
+  const mimeType = resolveSlackFileMimeType({
+    file: params.file,
+    fileName: hintedName,
+    responseMimeType: params.responseMimeType
+  });
+  return {
+    fileName: resolveSlackFileName({
+      file: params.file,
+      url: params.url,
+      mimeType
+    }),
+    mimeType
+  };
+}
+function parseContentLength(response) {
+  const header = response.headers.get("content-length");
+  if (!header)
+    return;
+  const value = Number(header);
+  return Number.isFinite(value) ? value : undefined;
+}
+async function fetchSlackFile(params) {
+  const rawUrl = params.file.url_private_download ?? params.file.url_private;
+  if (!rawUrl) {
+    throw new Error("Slack attachment does not include a private download URL.");
+  }
+  const parsed = assertSlackFileUrl(rawUrl);
+  const fetcher = params.fetcher ?? globalThis.fetch;
+  const authHeaders = { Authorization: `Bearer ${params.token}` };
+  const initial = await fetcher(parsed.href, {
+    headers: authHeaders,
+    redirect: "manual",
+    ...params.signal ? { signal: params.signal } : {}
+  });
+  let response = initial;
+  if (initial.status >= 300 && initial.status < 400) {
+    const location = initial.headers.get("location");
+    if (location) {
+      const resolved = new URL(location, parsed.href);
+      response = await fetcher(resolved.href, {
+        ...resolved.origin === parsed.origin ? { headers: authHeaders } : {},
+        redirect: "follow",
+        ...params.signal ? { signal: params.signal } : {}
+      });
+    }
+  }
+  if (!response.ok) {
+    throw new Error(`Slack attachment fetch failed with HTTP ${response.status}.`);
+  }
+  if (!response.body) {
+    throw new Error("Slack attachment response did not include a body.");
+  }
+  const responseMimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || undefined;
+  const metadata = resolveSlackFileMetadata({
+    file: params.file,
+    url: rawUrl,
+    responseMimeType
+  });
+  return {
+    body: response.body,
+    ...metadata,
+    contentLength: parseContentLength(response)
+  };
+}
 // src/channels/slack/bot-policy.ts
 function resolveSlackAllowBotsMode(value) {
   if (value === "mentions")
     return "mentions";
   return "off";
 }
-function isNonEmptyString(value) {
+function isNonEmptyString2(value) {
   return typeof value === "string" && value.length > 0;
 }
 function isSlackBotAuthoredInboundMessage(message) {
-  return isNonEmptyString(message.bot_id) || message.subtype === "bot_message";
+  return isNonEmptyString2(message.bot_id) || message.subtype === "bot_message";
 }
 function isOwnSlackBotInboundMessage(params) {
-  return isNonEmptyString(params.botUserId) && params.message.user === params.botUserId || isNonEmptyString(params.botId) && params.message.bot_id === params.botId;
+  return isNonEmptyString2(params.botUserId) && params.message.user === params.botUserId || isNonEmptyString2(params.botId) && params.message.bot_id === params.botId;
 }
 function shouldAcceptSlackInboundBotMessage(params) {
   if (isOwnSlackBotInboundMessage({
@@ -28,11 +302,11 @@ function shouldAcceptSlackInboundBotMessage(params) {
   return mode === "mentions" && params.wasMentioned;
 }
 // src/channels/slack/public-utils.ts
-function isNonEmptyString2(value) {
+function isNonEmptyString3(value) {
   return typeof value === "string" && value.length > 0;
 }
 function firstNonEmptyString(...values) {
-  return values.find(isNonEmptyString2);
+  return values.find(isNonEmptyString3);
 }
 function resolveSlackChatType(chatId) {
   return chatId.startsWith("D") ? "direct" : "channel";
@@ -189,13 +463,13 @@ function hasRecordValue(value) {
   return value !== null && typeof value === "object";
 }
 function hasSlackMention(text, userId) {
-  return isNonEmptyString2(text) && isNonEmptyString2(userId) && (text.includes(`<@${userId}>`) || text.includes(`<@${userId}|`));
+  return isNonEmptyString3(text) && isNonEmptyString3(userId) && (text.includes(`<@${userId}>`) || text.includes(`<@${userId}|`));
 }
 function isBotAuthoredMessage(message) {
-  return isNonEmptyString2(message.bot_id) || message.subtype === "bot_message";
+  return isNonEmptyString3(message.bot_id) || message.subtype === "bot_message";
 }
 function resolveMessageSubtypeIgnoreReason(message) {
-  const subtype = isNonEmptyString2(message.subtype) ? message.subtype : null;
+  const subtype = isNonEmptyString3(message.subtype) ? message.subtype : null;
   if (!subtype) {
     return null;
   }
@@ -215,14 +489,14 @@ function shouldSkipSlackMessageByLastSeen(params) {
 }
 function resolveSlackMessageIngressPolicy(params) {
   const { message } = params;
-  if (!isNonEmptyString2(message.channel)) {
+  if (!isNonEmptyString3(message.channel)) {
     return { shouldRoute: false, reason: "missing_channel" };
   }
   const senderId = firstNonEmptyString(message.user, message.bot_id);
   if (!senderId) {
     return { shouldRoute: false, reason: "missing_sender" };
   }
-  if (!isNonEmptyString2(message.ts)) {
+  if (!isNonEmptyString3(message.ts)) {
     return { shouldRoute: false, reason: "missing_timestamp" };
   }
   if (message.hidden === true) {
@@ -234,10 +508,10 @@ function resolveSlackMessageIngressPolicy(params) {
   }
   const chatType = resolveSlackChatType(message.channel);
   const threadId = chatType === "direct" ? firstNonEmptyString(message.thread_ts) ?? null : firstNonEmptyString(message.thread_ts, message.ts) ?? null;
-  if (chatType === "channel" && !isNonEmptyString2(message.thread_ts)) {
+  if (chatType === "channel" && !isNonEmptyString3(message.thread_ts)) {
     return { shouldRoute: false, reason: "top_level_channel_message" };
   }
-  const rawText = isNonEmptyString2(message.text) ? message.text : "";
+  const rawText = isNonEmptyString3(message.text) ? message.text : "";
   const wasMentioned = hasSlackMention(rawText, params.botUserId);
   if (chatType === "channel" && wasMentioned && params.appMentionEventWillHandleMentions === true) {
     return { shouldRoute: false, reason: "handled_by_app_mention" };
@@ -248,8 +522,8 @@ function resolveSlackMessageIngressPolicy(params) {
     shouldRoute: true,
     channelId: message.channel,
     senderId,
-    ...isNonEmptyString2(message.user) ? { senderUserId: message.user } : {},
-    ...isNonEmptyString2(message.bot_id) ? { senderBotId: message.bot_id } : {},
+    ...isNonEmptyString3(message.user) ? { senderUserId: message.user } : {},
+    ...isNonEmptyString3(message.bot_id) ? { senderBotId: message.bot_id } : {},
     messageId: message.ts,
     threadId,
     chatType,
@@ -263,23 +537,23 @@ function resolveSlackMessageIngressPolicy(params) {
 }
 function resolveSlackAppMentionIngressPolicy(params) {
   const { event } = params;
-  if (!isNonEmptyString2(event.channel)) {
+  if (!isNonEmptyString3(event.channel)) {
     return { shouldRoute: false, reason: "missing_channel" };
   }
   const senderId = firstNonEmptyString(event.user, event.bot_id);
   if (!senderId) {
     return { shouldRoute: false, reason: "missing_sender" };
   }
-  if (!isNonEmptyString2(event.ts)) {
+  if (!isNonEmptyString3(event.ts)) {
     return { shouldRoute: false, reason: "missing_timestamp" };
   }
-  const rawText = isNonEmptyString2(event.text) ? event.text : "";
+  const rawText = isNonEmptyString3(event.text) ? event.text : "";
   return {
     shouldRoute: true,
     channelId: event.channel,
     senderId,
-    ...isNonEmptyString2(event.user) ? { senderUserId: event.user } : {},
-    ...isNonEmptyString2(event.bot_id) ? { senderBotId: event.bot_id } : {},
+    ...isNonEmptyString3(event.user) ? { senderUserId: event.user } : {},
+    ...isNonEmptyString3(event.bot_id) ? { senderBotId: event.bot_id } : {},
     messageId: event.ts,
     threadId: firstNonEmptyString(event.thread_ts, event.ts) ?? event.ts,
     chatType: "channel",
@@ -296,16 +570,16 @@ function resolveSlackReactionIngressPolicy(params) {
   if (item?.type !== "message") {
     return { shouldRoute: false, reason: "invalid_reaction_item" };
   }
-  if (!isNonEmptyString2(item.channel)) {
+  if (!isNonEmptyString3(item.channel)) {
     return { shouldRoute: false, reason: "missing_channel" };
   }
-  if (!isNonEmptyString2(params.event.user)) {
+  if (!isNonEmptyString3(params.event.user)) {
     return { shouldRoute: false, reason: "missing_sender" };
   }
-  if (!isNonEmptyString2(item.ts)) {
+  if (!isNonEmptyString3(item.ts)) {
     return { shouldRoute: false, reason: "missing_timestamp" };
   }
-  if (!isNonEmptyString2(params.event.reaction)) {
+  if (!isNonEmptyString3(params.event.reaction)) {
     return { shouldRoute: false, reason: "missing_reaction" };
   }
   if (params.event.user === params.botUserId) {
@@ -322,7 +596,7 @@ function resolveSlackReactionIngressPolicy(params) {
     action: params.action,
     emoji: params.event.reaction,
     targetMessageId,
-    ...isNonEmptyString2(params.event.item_user) ? { targetSenderId: params.event.item_user } : {}
+    ...isNonEmptyString3(params.event.item_user) ? { targetSenderId: params.event.item_user } : {}
   };
   return {
     shouldRoute: true,
@@ -481,13 +755,13 @@ function getFallbackModelEntries(byHandle) {
 }
 
 // src/channels/slack/utils.ts
-function isNonEmptyString3(value) {
+function isNonEmptyString4(value) {
   return typeof value === "string" && value.length > 0;
 }
 function firstNonEmptyString2(...values) {
-  return values.find(isNonEmptyString3);
+  return values.find(isNonEmptyString4);
 }
-function asRecord(value) {
+function asRecord2(value) {
   return value && typeof value === "object" ? value : null;
 }
 var IGNORED_SLACK_MESSAGE_SUBTYPES2 = new Set([
@@ -522,12 +796,12 @@ var WRAPPER_SLACK_MESSAGE_SUBTYPES2 = new Set([
   "message_replied"
 ]);
 function getSlackActionRecord(action, body) {
-  const directAction = asRecord(action);
+  const directAction = asRecord2(action);
   if (directAction) {
     return directAction;
   }
-  const actions = asRecord(body)?.actions;
-  return Array.isArray(actions) ? asRecord(actions[0]) : null;
+  const actions = asRecord2(body)?.actions;
+  return Array.isArray(actions) ? asRecord2(actions[0]) : null;
 }
 
 // src/channels/slack/model-picker-blocks.ts
@@ -537,7 +811,7 @@ var SLACK_MODEL_OPTION_VALUE_LIMIT = 75;
 var SLACK_MODEL_SELECT_ACTION_ID = "letta_channel_model_select";
 function resolveSlackSelectedModel(action, body) {
   const actionRecord = getSlackActionRecord(action, body);
-  const selectedOption = asRecord(actionRecord?.selected_option);
+  const selectedOption = asRecord2(actionRecord?.selected_option);
   return firstNonEmptyString2(selectedOption?.value, actionRecord?.value) ?? null;
 }
 function escapeSlackMrkdwn(text) {
@@ -897,14 +1171,14 @@ function formatSlackToolNameForDisplay(toolName) {
   return toolName;
 }
 function resolveSlackConcreteActivity(event) {
-  if (event.kind === "command" && isNonEmptyString2(event.command)) {
+  if (event.kind === "command" && isNonEmptyString3(event.command)) {
     return sanitizeSlackStatusText(formatSlackToolNameForDisplay(event.command), SLACK_LOADING_MESSAGE_MAX);
   }
-  if (event.kind !== "tool" || !isNonEmptyString2(event.toolName) || event.toolName.toLowerCase() === "messagechannel") {
+  if (event.kind !== "tool" || !isNonEmptyString3(event.toolName) || event.toolName.toLowerCase() === "messagechannel") {
     return null;
   }
   for (const description of [event.toolTitle, event.toolDetails]) {
-    if (!isNonEmptyString2(description)) {
+    if (!isNonEmptyString3(description)) {
       continue;
     }
     const sanitized = sanitizeSlackStatusText(description, SLACK_LOADING_MESSAGE_MAX);
@@ -1056,22 +1330,22 @@ function createSlackStatusController(params) {
   const keepaliveByConversation = new Map;
   const clearedStaleReplyKeys = new Set;
   function getConversationKey(source) {
-    return source.channel === "slack" && isNonEmptyString2(source.agentId) && isNonEmptyString2(source.conversationId) ? `${source.agentId}:${source.conversationId}` : null;
+    return source.channel === "slack" && isNonEmptyString3(source.agentId) && isNonEmptyString3(source.conversationId) ? `${source.agentId}:${source.conversationId}` : null;
   }
   function getLifecycleReplyKey(source) {
-    if (source.channel !== "slack" || !isNonEmptyString2(source.chatId)) {
+    if (source.channel !== "slack" || !isNonEmptyString3(source.chatId)) {
       return null;
     }
     const replyToMessageId = resolveSlackProgressThreadTs(source);
-    return isNonEmptyString2(replyToMessageId) ? `${source.chatId}:${replyToMessageId}` : null;
+    return isNonEmptyString3(replyToMessageId) ? `${source.chatId}:${replyToMessageId}` : null;
   }
   function getLifecycleErrorReplyKey(source) {
-    if (source.channel !== "slack" || !isNonEmptyString2(source.chatId)) {
+    if (source.channel !== "slack" || !isNonEmptyString3(source.chatId)) {
       return null;
     }
     if (source.chatType === "direct" || resolveSlackChatType(source.chatId) === "direct") {
       const replyToMessageId = resolveSlackSourceThreadTs(source);
-      return isNonEmptyString2(replyToMessageId) ? `${source.chatId}:${replyToMessageId}` : `${source.chatId}:direct`;
+      return isNonEmptyString3(replyToMessageId) ? `${source.chatId}:${replyToMessageId}` : `${source.chatId}:direct`;
     }
     return getLifecycleReplyKey(source);
   }
@@ -1230,7 +1504,7 @@ ${loadingText}`;
         markAutoClearedByKey(key);
     },
     markAutoClearedForMessage(msg) {
-      if (isNonEmptyString2(msg.agentId) && isNonEmptyString2(msg.conversationId)) {
+      if (isNonEmptyString3(msg.agentId) && isNonEmptyString3(msg.conversationId)) {
         markAutoClearedByKey(`${msg.agentId}:${msg.conversationId}`);
         return;
       }
@@ -1269,6 +1543,8 @@ export {
   resolveSlackReactionIngressPolicy,
   resolveSlackOutboundThreadTs,
   resolveSlackMessageIngressPolicy,
+  resolveSlackMessageFiles,
+  resolveSlackFileMetadata,
   resolveSlackConcreteActivity,
   resolveSlackChatType,
   resolveSlackAppMentionIngressPolicy,
@@ -1277,13 +1553,15 @@ export {
   isProcessableSlackInboundMessage,
   isOwnSlackBotInboundMessage,
   formatSlackLifecycleErrorMessage,
+  fetchSlackFile,
   createSlackStatusController,
   createSlackMessageActionAdapter,
   createSlackChannelSender,
+  collectSlackFiles,
   buildSlackModelPickerBlocks,
   SLACK_MODEL_SELECT_ACTION_ID,
   SLACK_ASSISTANT_WORKING_STATUS,
   SLACK_ASSISTANT_STARTUP_STATUS
 };
 
-//# debugId=00F2BC6B76D5D4FA64756E2164756E21
+//# debugId=DB8AFA417A95EA8864756E2164756E21