experimental-ash 0.25.2 → 0.27.0

package/dist/src/public/channels/slack/api.js

@@ -1,333 +1 @@
-/**
- * Native Slack Web API surface used by the channel.
- *
- * Exposes two handles to author code via `ctx`:
- *
- * - {@link SlackThread} — operations scoped to the bound thread.
- *   `ctx.thread.post(...)` reads as "post a reply to this thread".
- * - {@link SlackHandle} — Slack identity + raw API escape hatch.
- *   `ctx.slack.request(...)` reads as "raw Slack API call, possibly
- *   not the bound thread".
- *
- * Kept in a thin module so the channel core (`slackChannel.ts`), the
- * interaction handler (`interactions.ts`), and the default event
- * handlers (`defaults.ts`) can all share the same low-level helpers
- * without depending on each other.
- */
-import { isCardElement } from "#compiled/chat/index.js";
-import { createLogger } from "#internal/logging.js";
-import { encodeSlackApiBody } from "#public/channels/slack/api-encoding.js";
-import { cardToBlocks, cardToFallbackText } from "#public/channels/slack/blocks.js";
-import { gfmToSlackMrkdwn, rewriteBareMentions, slackMrkdwnToGfm, } from "#public/channels/slack/mrkdwn.js";
-const log = createLogger("slack.api");
-/**
- * Builds the Slack channel-local continuation token
- * (`<channelId>:<threadTs>`). Route `send()` namespaces this with the
- * channel name before handing it to the runtime
- * (`slack:<channelId>:<threadTs>`). `threadTs` may be empty for
- * threadless sessions; the channel auto-anchors on its first post.
- */
-export function slackContinuationToken(channelId, threadTs) {
-    return `${channelId}:${threadTs}`;
-}
-/**
- * Materializes a {@link SlackBotToken} to a concrete string. Falls
- * back to `process.env.SLACK_BOT_TOKEN` when no value was passed.
- */
-export async function resolveSlackBotToken(token) {
-    const source = token ?? process.env.SLACK_BOT_TOKEN;
-    if (!source)
-        throw new Error("SLACK_BOT_TOKEN is required.");
-    return typeof source === "function" ? await source() : source;
-}
-/**
- * Low-level POST to a Slack Web API method.
- *
- * Signs with the bot token and form-encodes the body — Slack documents
- * `application/x-www-form-urlencoded` as universal, JSON support is
- * partial (e.g. `conversations.replies` rejects JSON), so form is the
- * only safe default. Returns Slack's raw JSON response; callers inspect
- * `response.ok` themselves.
- */
-export async function callSlackApi(input) {
-    const token = await resolveSlackBotToken(input.botToken);
-    const encoded = encodeSlackApiBody(input.body);
-    const response = await fetch(`https://slack.com/api/${input.operation}`, {
-        method: "POST",
-        headers: {
-            authorization: `Bearer ${token}`,
-            "content-type": encoded.contentType,
-        },
-        body: encoded.body,
-    });
-    return response.json();
-}
-/**
- * Builds the `request(op, body)` Slack API caller installed on every
- * {@link SlackHandle}. Resolves the bot token at call time so rotated
- * credentials are picked up without rebuilding the binding.
- */
-function createSlackRequester(botToken) {
-    return (operation, body) => callSlackApi({ botToken, operation, body });
-}
-/**
- * Internal constructor for the `{ thread, slack }` pair.
- *
- * Auto-anchor: when the binding starts without a `threadTs`, the first
- * `chat.postMessage` adopts its own `ts` as the thread root; the live
- * `threadTs` is updated and `onThreadTsChanged` fires so the caller can persist
- * the anchor. Ephemerals and files-only posts do not anchor.
- */
-export function buildSlackBinding(input) {
-    const request = createSlackRequester(input.botToken);
-    const messages = [];
-    let currentThreadTs = input.threadTs;
-    function handleMessageTs(ts) {
-        if (currentThreadTs || ts === currentThreadTs)
-            return;
-        currentThreadTs = ts;
-        input.onThreadTsChanged?.(ts);
-    }
-    async function uploadFiles(files, options) {
-        if (files.length === 0) {
-            return { fileIds: [], raw: { ok: true } };
-        }
-        const channelId = options?.channelId ?? input.channelId;
-        const threadTs = options?.threadTs ?? currentThreadTs;
-        const token = await resolveSlackBotToken(input.botToken);
-        const fileIds = [];
-        for (const file of files) {
-            const bytes = await readFileBytes(file.data);
-            const getUrl = await callSlackApi({
-                botToken: input.botToken,
-                operation: "files.getUploadURLExternal",
-                body: {
-                    filename: file.filename,
-                    length: bytes.byteLength,
-                },
-            });
-            if (getUrl.ok !== true ||
-                typeof getUrl.upload_url !== "string" ||
-                typeof getUrl.file_id !== "string") {
-                throw new Error(`Slack files.getUploadURLExternal failed: ${getUrl.error ?? "unknown_error"}`);
-            }
-            const uploadResponse = await fetch(getUrl.upload_url, {
-                method: "POST",
-                headers: {
-                    authorization: `Bearer ${token}`,
-                    "content-type": "application/octet-stream",
-                },
-                body: bytes,
-            });
-            if (!uploadResponse.ok) {
-                throw new Error(`Slack upload POST returned HTTP ${uploadResponse.status} for ${file.filename}.`);
-            }
-            fileIds.push(getUrl.file_id);
-        }
-        const completeBody = {
-            files: files.map((file, i) => ({ id: fileIds[i], title: file.filename })),
-        };
-        if (channelId)
-            completeBody.channel_id = channelId;
-        if (threadTs)
-            completeBody.thread_ts = threadTs;
-        if (options?.initialComment)
-            completeBody.initial_comment = options.initialComment;
-        const complete = await callSlackApi({
-            botToken: input.botToken,
-            operation: "files.completeUploadExternal",
-            body: completeBody,
-        });
-        if (complete.ok !== true) {
-            throw new Error(`Slack files.completeUploadExternal failed: ${complete.error ?? "unknown_error"}`);
-        }
-        return { fileIds, raw: complete };
-    }
-    const thread = {
-        recentMessages: messages,
-        async post(rawMessage) {
-            const message = normalizePostInput(rawMessage);
-            const files = message.files ?? [];
-            const hasStructured = "blocks" in message || "card" in message;
-            // markdown / text + files: single Slack message with files attached
-            // via files.completeUploadExternal's initial_comment.
-            if (files.length > 0 && !hasStructured) {
-                const comment = "markdown" in message
-                    ? rewriteBareMentions(gfmToSlackMrkdwn(message.markdown))
-                    : "text" in message
-                        ? rewriteBareMentions(message.text)
-                        : undefined;
-                const result = await uploadFiles(files, { initialComment: comment });
-                const id = Array.isArray(result.raw.files) && result.raw.files.length > 0
-                    ? String(result.raw.files[0].id ?? "")
-                    : "";
-                return { id, raw: result.raw };
-            }
-            const body = buildPostMessageBody(message, input.channelId, currentThreadTs);
-            const response = await request("chat.postMessage", body);
-            if (response.ok !== true) {
-                throw new Error(`Slack chat.postMessage failed: ${response.error ?? "unknown_error"}`);
-            }
-            const id = typeof response.ts === "string" ? response.ts : "";
-            handleMessageTs(id);
-            // blocks / card + files: structured message lands first, then upload
-            // files as a follow-up post in the same thread.
-            if (files.length > 0 && hasStructured) {
-                try {
-                    await uploadFiles(files);
-                }
-                catch (error) {
-                    log.warn("file upload after structured post failed", { error });
-                }
-            }
-            return { id, raw: response };
-        },
-        async postEphemeral(userId, rawMessage) {
-            const message = normalizePostInput(rawMessage);
-            const body = buildPostMessageBody(message, input.channelId, currentThreadTs);
-            body.user = userId;
-            const response = await request("chat.postEphemeral", body);
-            if (response.ok !== true) {
-                throw new Error(`Slack chat.postEphemeral failed: ${response.error ?? "unknown_error"}`);
-            }
-            const id = typeof response.message_ts === "string" ? response.message_ts : "";
-            return { id, raw: response };
-        },
-        async startTyping(status) {
-            if (!input.channelId || !currentThreadTs)
-                return;
-            try {
-                const body = {
-                    channel_id: input.channelId,
-                    thread_ts: currentThreadTs,
-                    status: status ?? "",
-                };
-                if (status !== undefined && status.length > 0) {
-                    body.loading_messages = [status];
-                }
-                const response = await request("assistant.threads.setStatus", body);
-                if (response.ok !== true) {
-                    log.debug("assistant.threads.setStatus returned not-ok", {
-                        error: response.error,
-                    });
-                }
-            }
-            catch (error) {
-                log.debug("startTyping threw — swallowed", { error });
-            }
-        },
-        async refresh() {
-            messages.length = 0;
-            if (!input.channelId || !currentThreadTs)
-                return;
-            try {
-                const response = await request("conversations.replies", {
-                    channel: input.channelId,
-                    ts: currentThreadTs,
-                    limit: 50,
-                });
-                if (response.ok !== true || !Array.isArray(response.messages)) {
-                    log.debug("conversations.replies returned not-ok", { error: response.error });
-                    return;
-                }
-                for (const raw of response.messages) {
-                    messages.push(parseThreadMessage(raw, currentThreadTs));
-                }
-            }
-            catch (error) {
-                log.debug("refresh threw — swallowed", { error });
-            }
-        },
-        mentionUser(userId) {
-            return `<@${userId}>`;
-        },
-    };
-    const slack = {
-        channelId: input.channelId,
-        get threadTs() {
-            return currentThreadTs;
-        },
-        teamId: input.teamId,
-        request,
-        uploadFiles,
-    };
-    return { thread, slack };
-}
-/**
- * Coerces the ergonomic bare forms of `SlackThread.post` / `postEphemeral`
- * into the explicit {@link SlackPostInput} discriminated union the
- * implementation works with.
- *
- * - `string` → `{ markdown }` so call sites like `ctx.thread.post(event.message)`
- *   render through Slack's markdown converter.
- * - {@link CardElement} → `{ card }` so call sites like
- *   `ctx.thread.post(Card({...}))` go through the Block Kit converter.
- * - Anything else is assumed to already be a {@link SlackPostInput}.
- */
-function normalizePostInput(message) {
-    if (typeof message === "string")
-        return { markdown: message };
-    if (isCardElement(message))
-        return { card: message };
-    return message;
-}
-function buildPostMessageBody(message, channelId, threadTs) {
-    const base = {
-        channel: channelId,
-        unfurl_links: false,
-        unfurl_media: false,
-    };
-    if (threadTs)
-        base.thread_ts = threadTs;
-    if ("card" in message) {
-        base.blocks = cardToBlocks(message.card);
-        base.text = message.fallbackText ?? cardToFallbackText(message.card);
-        return base;
-    }
-    if ("blocks" in message) {
-        base.blocks = message.blocks;
-        if (message.text !== undefined)
-            base.text = message.text;
-        return base;
-    }
-    if ("markdown" in message) {
-        base.markdown_text = rewriteBareMentions(message.markdown);
-        return base;
-    }
-    base.text = rewriteBareMentions(message.text);
-    return base;
-}
-function parseThreadMessage(raw, threadRootTs) {
-    const text = typeof raw.text === "string" ? raw.text : "";
-    const ts = typeof raw.ts === "string" ? raw.ts : "";
-    const threadTs = typeof raw.thread_ts === "string" ? raw.thread_ts : threadRootTs;
-    const user = typeof raw.user === "string" ? raw.user : undefined;
-    const botId = typeof raw.bot_id === "string" ? raw.bot_id : undefined;
-    return {
-        text,
-        markdown: slackMrkdwnToGfm(text),
-        user,
-        botId,
-        ts,
-        threadTs,
-        isMe: botId !== undefined,
-        raw,
-    };
-}
-/**
- * Normalize a {@link FileUpload.data} value (`Buffer | Blob | ArrayBuffer`) to
- * a contiguous `Buffer` we can both POST and length-prefix without
- * holding two copies of the payload in memory.
- */
-async function readFileBytes(data) {
-    if (data instanceof ArrayBuffer)
-        return Buffer.from(data);
-    if (typeof Blob !== "undefined" && data instanceof Blob) {
-        return Buffer.from(await data.arrayBuffer());
-    }
-    if (ArrayBuffer.isView(data)) {
-        const view = data;
-        return Buffer.from(view.buffer, view.byteOffset, view.byteLength);
-    }
-    throw new Error("FileUpload.data must be a Buffer, ArrayBuffer, or Blob.");
-}
+import{createLogger}from"#internal/logging.js";import{isCardElement}from"#compiled/chat/index.js";import{encodeSlackApiBody}from"#public/channels/slack/api-encoding.js";import{cardToBlocks,cardToFallbackText}from"#public/channels/slack/blocks.js";import{gfmToSlackMrkdwn,rewriteBareMentions,slackMrkdwnToGfm}from"#public/channels/slack/mrkdwn.js";var log=createLogger(`slack.api`);function slackContinuationToken(e,t){return`${e}:${t}`}async function resolveSlackBotToken(e){let t=e??process.env.SLACK_BOT_TOKEN;if(!t)throw Error(`SLACK_BOT_TOKEN is required.`);return typeof t==`function`?await t():t}async function callSlackApi(e){let t=await resolveSlackBotToken(e.botToken),r=encodeSlackApiBody(e.body);return(await fetch(`https://slack.com/api/${e.operation}`,{method:`POST`,headers:{authorization:`Bearer ${t}`,"content-type":r.contentType},body:r.body})).json()}function createSlackRequester(e){return(t,n)=>callSlackApi({botToken:e,operation:t,body:n})}function buildSlackBinding(e){let t=createSlackRequester(e.botToken),n=[],r=e.threadTs;function handleMessageTs(t){r||t===r||(r=t,e.onThreadTsChanged?.(t))}async function uploadFiles(t,n){if(t.length===0)return{fileIds:[],raw:{ok:!0}};let i=n?.channelId??e.channelId,a=n?.threadTs??r,o=await resolveSlackBotToken(e.botToken),s=[];for(let n of t){let t=await readFileBytes(n.data),r=await callSlackApi({botToken:e.botToken,operation:`files.getUploadURLExternal`,body:{filename:n.filename,length:t.byteLength}});if(r.ok!==!0||typeof r.upload_url!=`string`||typeof r.file_id!=`string`)throw Error(`Slack files.getUploadURLExternal failed: ${r.error??`unknown_error`}`);let i=await fetch(r.upload_url,{method:`POST`,headers:{authorization:`Bearer ${o}`,"content-type":`application/octet-stream`},body:t});if(!i.ok)throw Error(`Slack upload POST returned HTTP ${i.status} for ${n.filename}.`);s.push(r.file_id)}let c={files:t.map((e,t)=>({id:s[t],title:e.filename}))};i&&(c.channel_id=i),a&&(c.thread_ts=a),n?.initialComment&&(c.initial_comment=n.initialComment);let l=await callSlackApi({botToken:e.botToken,operation:`files.completeUploadExternal`,body:c});if(l.ok!==!0)throw Error(`Slack files.completeUploadExternal failed: ${l.error??`unknown_error`}`);return{fileIds:s,raw:l}}return{thread:{recentMessages:n,async post(n){let i=normalizePostInput(n),s=i.files??[],l=`blocks`in i||`card`in i;if(s.length>0&&!l){let e=await uploadFiles(s,{initialComment:`markdown`in i?rewriteBareMentions(gfmToSlackMrkdwn(i.markdown)):`text`in i?rewriteBareMentions(i.text):void 0});return{id:Array.isArray(e.raw.files)&&e.raw.files.length>0?String(e.raw.files[0].id??``):``,raw:e.raw}}let u=await t(`chat.postMessage`,buildPostMessageBody(i,e.channelId,r));if(u.ok!==!0)throw Error(`Slack chat.postMessage failed: ${u.error??`unknown_error`}`);let d=typeof u.ts==`string`?u.ts:``;if(handleMessageTs(d),s.length>0&&l)try{await uploadFiles(s)}catch(e){log.warn(`file upload after structured post failed`,{error:e})}return{id:d,raw:u}},async postEphemeral(n,i){let a=buildPostMessageBody(normalizePostInput(i),e.channelId,r);a.user=n;let o=await t(`chat.postEphemeral`,a);if(o.ok!==!0)throw Error(`Slack chat.postEphemeral failed: ${o.error??`unknown_error`}`);return{id:typeof o.message_ts==`string`?o.message_ts:``,raw:o}},async startTyping(n){if(!(!e.channelId||!r))try{let i={channel_id:e.channelId,thread_ts:r,status:n??``};n!==void 0&&n.length>0&&(i.loading_messages=[n]);let a=await t(`assistant.threads.setStatus`,i);a.ok!==!0&&log.debug(`assistant.threads.setStatus returned not-ok`,{error:a.error})}catch(e){log.debug(`startTyping threw — swallowed`,{error:e})}},async refresh(){if(n.length=0,!(!e.channelId||!r))try{let i=await t(`conversations.replies`,{channel:e.channelId,ts:r,limit:50});if(i.ok!==!0||!Array.isArray(i.messages)){log.debug(`conversations.replies returned not-ok`,{error:i.error});return}for(let e of i.messages)n.push(parseThreadMessage(e,r))}catch(e){log.debug(`refresh threw — swallowed`,{error:e})}},mentionUser(e){return`<@${e}>`}},slack:{channelId:e.channelId,get threadTs(){return r},teamId:e.teamId,request:t,uploadFiles}}}function normalizePostInput(e){return typeof e==`string`?{markdown:e}:isCardElement(e)?{card:e}:e}function buildPostMessageBody(e,t,n){let a={channel:t,unfurl_links:!1,unfurl_media:!1};return n&&(a.thread_ts=n),`card`in e?(a.blocks=cardToBlocks(e.card),a.text=e.fallbackText??cardToFallbackText(e.card),a):`blocks`in e?(a.blocks=e.blocks,e.text!==void 0&&(a.text=e.text),a):`markdown`in e?(a.markdown_text=rewriteBareMentions(e.markdown),a):(a.text=rewriteBareMentions(e.text),a)}function parseThreadMessage(e,t){let n=typeof e.text==`string`?e.text:``,r=typeof e.ts==`string`?e.ts:``,i=typeof e.thread_ts==`string`?e.thread_ts:t,a=typeof e.user==`string`?e.user:void 0,o=typeof e.bot_id==`string`?e.bot_id:void 0;return{text:n,markdown:slackMrkdwnToGfm(n),user:a,botId:o,ts:r,threadTs:i,isMe:o!==void 0,raw:e}}async function readFileBytes(e){if(e instanceof ArrayBuffer)return Buffer.from(e);if(typeof Blob<`u`&&e instanceof Blob)return Buffer.from(await e.arrayBuffer());if(ArrayBuffer.isView(e)){let t=e;return Buffer.from(t.buffer,t.byteOffset,t.byteLength)}throw Error(`FileUpload.data must be a Buffer, ArrayBuffer, or Blob.`)}export{buildSlackBinding,callSlackApi,resolveSlackBotToken,slackContinuationToken};

package/dist/src/public/channels/slack/attachments.js

@@ -1,156 +1 @@
-import { createLogger } from "#internal/logging.js";
-import { resolveSlackBotToken, } from "#public/channels/slack/api.js";
-import { evaluateFilePart, formatUploadPolicyViolation, isUploadsDisabled, } from "#public/channels/upload-policy.js";
-const log = createLogger("slack.attachments");
-/**
- * Emits one {@link FilePart} per supported attachment in the inbound
- * message, with `data` set to a `URL` object pointing at the Slack
- * file. Audio, video, URL-less, and policy-violating attachments are
- * dropped so a single bad upload never blocks the text portion.
- *
- * The `URL` object in `data` is resolved by the channel's `fetchFile`
- * function at staging time inside the workflow step.
- */
-export function collectSlackFileParts(attachments, policy) {
-    const parts = [];
-    for (const attachment of attachments ?? []) {
-        const part = toSlackFilePart(attachment, parts.length);
-        if (part === null)
-            continue;
-        const violation = evaluateFilePart(part, policy);
-        if (violation !== null) {
-            log.warn(`dropped attachment — ${formatUploadPolicyViolation(violation)}`, {
-                name: attachment.name,
-            });
-            continue;
-        }
-        parts.push(part);
-    }
-    return parts;
-}
-function toSlackFilePart(attachment, index) {
-    if (attachment.type === "audio" || attachment.type === "video") {
-        return null;
-    }
-    if (!attachment.url) {
-        log.warn("dropped attachment — no url available", {
-            name: attachment.name,
-        });
-        return null;
-    }
-    return {
-        type: "file",
-        mediaType: attachment.mimeType ?? "application/octet-stream",
-        filename: attachment.name ?? `attachment-${index}`,
-        data: new URL(attachment.url),
-    };
-}
-/**
- * Collects file parts for an inbound mention.
- *
- * Prefers attachments on the triggering mention (the common case: user
- * uploads a file and mentions the bot in the same message). When the
- * mention has none, refreshes the thread via {@link SlackThread.refresh}
- * and picks the latest non-bot message's attachments — covering the
- * case where a user dropped a file in the thread first, then mentioned
- * the bot in a follow-up. Any error during refresh is logged and treated
- * as "no attachments" so the text portion of the mention still gets
- * delivered.
- *
- * Skips the thread-history lookback when the policy disables uploads,
- * since the refresh can't surface anything we'd deliver.
- */
-export async function collectInboundFileParts(input) {
-    const fromMention = collectSlackFileParts(input.mention.attachments, input.policy);
-    if (fromMention.length > 0)
-        return fromMention;
-    if (isUploadsDisabled(input.policy))
-        return [];
-    try {
-        await input.thread.refresh();
-    }
-    catch (error) {
-        log.warn("slack thread refresh failed for attachment collection", { error });
-        return [];
-    }
-    const recent = input.thread.recentMessages;
-    for (let i = recent.length - 1; i >= 0; i -= 1) {
-        const candidate = recent[i];
-        if (!candidate || candidate.isMe)
-            continue;
-        const raw = candidate.raw;
-        const attachments = extractAttachmentsFromRaw(raw?.files);
-        const parts = collectSlackFileParts(attachments, input.policy);
-        if (parts.length > 0)
-            return parts;
-        return [];
-    }
-    return [];
-}
-function extractAttachmentsFromRaw(files) {
-    if (!Array.isArray(files))
-        return [];
-    return files.map((file) => {
-        const mimeType = typeof file.mimetype === "string" ? file.mimetype : undefined;
-        return {
-            id: typeof file.id === "string" ? file.id : "",
-            type: inferAttachmentType(mimeType),
-            url: typeof file.url_private === "string" ? file.url_private : undefined,
-            name: typeof file.name === "string" ? file.name : undefined,
-            mimeType,
-            size: typeof file.size === "number" ? file.size : undefined,
-        };
-    });
-}
-function inferAttachmentType(mimeType) {
-    if (mimeType === undefined)
-        return "file";
-    if (mimeType.startsWith("image/"))
-        return "image";
-    if (mimeType.startsWith("video/"))
-        return "video";
-    if (mimeType.startsWith("audio/"))
-        return "audio";
-    return "file";
-}
-/**
- * Combines text + file parts into the {@link UserContent} shape the
- * harness expects. Returns the raw text string when there are no
- * parts (the common path).
- */
-export function buildSlackTurnMessage(text, fileParts) {
-    if (fileParts.length === 0) {
-        return text;
-    }
-    const trimmed = text.trim();
-    if (trimmed.length === 0) {
-        return [...fileParts];
-    }
-    const textPart = { type: "text", text };
-    return [textPart, ...fileParts];
-}
-/**
- * Creates a `fetchFile` function for the Slack channel.
- *
- * Returns `null` for URLs that don't belong to Slack so they pass
- * through to the model provider unchanged. Fetches Slack file URLs
- * with the bot token.
- */
-export function createSlackFetchFile(input) {
-    return async (url) => {
-        if (!url.startsWith("https://files.slack.com/")) {
-            return null;
-        }
-        const token = await resolveSlackBotToken(input.botToken);
-        const response = await fetch(url, {
-            headers: { authorization: `Bearer ${token}` },
-        });
-        if (!response.ok) {
-            throw new Error(`Slack file fetch returned HTTP ${response.status} for ${url}.`);
-        }
-        return {
-            bytes: Buffer.from(await response.arrayBuffer()),
-            mediaType: response.headers.get("content-type") ?? undefined,
-        };
-    };
-}
+import{createLogger}from"#internal/logging.js";import{evaluateFilePart,formatUploadPolicyViolation,isUploadsDisabled}from"#public/channels/upload-policy.js";import{resolveSlackBotToken}from"#public/channels/slack/api.js";var log=createLogger(`slack.attachments`);function collectSlackFileParts(e,r){let i=[];for(let o of e??[]){let e=toSlackFilePart(o,i.length);if(e===null)continue;let s=evaluateFilePart(e,r);if(s!==null){log.warn(`dropped attachment — ${formatUploadPolicyViolation(s)}`,{name:o.name});continue}i.push(e)}return i}function toSlackFilePart(e,t){return e.type===`audio`||e.type===`video`?null:e.url?{type:`file`,mediaType:e.mimeType??`application/octet-stream`,filename:e.name??`attachment-${t}`,data:new URL(e.url)}:(log.warn(`dropped attachment — no url available`,{name:e.name}),null)}async function collectInboundFileParts(e){let t=collectSlackFileParts(e.mention.attachments,e.policy);if(t.length>0)return t;if(isUploadsDisabled(e.policy))return[];try{await e.thread.refresh()}catch(e){return log.warn(`slack thread refresh failed for attachment collection`,{error:e}),[]}let n=e.thread.recentMessages;for(let t=n.length-1;t>=0;--t){let r=n[t];if(!r||r.isMe)continue;let i=r.raw,a=collectSlackFileParts(extractAttachmentsFromRaw(i?.files),e.policy);return a.length>0?a:[]}return[]}function extractAttachmentsFromRaw(e){return Array.isArray(e)?e.map(e=>{let t=typeof e.mimetype==`string`?e.mimetype:void 0;return{id:typeof e.id==`string`?e.id:``,type:inferAttachmentType(t),url:typeof e.url_private==`string`?e.url_private:void 0,name:typeof e.name==`string`?e.name:void 0,mimeType:t,size:typeof e.size==`number`?e.size:void 0}}):[]}function inferAttachmentType(e){return e===void 0?`file`:e.startsWith(`image/`)?`image`:e.startsWith(`video/`)?`video`:e.startsWith(`audio/`)?`audio`:`file`}function buildSlackTurnMessage(e,t){return t.length===0?e:e.trim().length===0?[...t]:[{type:`text`,text:e},...t]}function createSlackFetchFile(e){return async t=>{if(!t.startsWith(`https://files.slack.com/`))return null;let n=await resolveSlackBotToken(e.botToken),r=await fetch(t,{headers:{authorization:`Bearer ${n}`}});if(!r.ok)throw Error(`Slack file fetch returned HTTP ${r.status} for ${t}.`);return{bytes:Buffer.from(await r.arrayBuffer()),mediaType:r.headers.get(`content-type`)??void 0}}}export{buildSlackTurnMessage,collectInboundFileParts,collectSlackFileParts,createSlackFetchFile};