experimental-ash 0.25.2 → 0.27.0

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

@@ -1,266 +1,3 @@
-/**
- * Card → Slack Block Kit converter.
- *
- * The chat SDK's Slack adapter used to walk the cross-platform
- * `CardElement` AST (the data shape produced by `Card({...})`,
- * `Actions([...])`, `Button({...})`, etc.) and emit Slack Block Kit
- * JSON for `chat.postMessage`. We replicate just that conversion here
- * so authors can keep using the ergonomic card builders without the
- * `@chat-adapter/slack` runtime.
- *
- * Supported shapes:
- *   Card                  → header + context + image header + children blocks
- *   TextElement           → `section`/`context` (style: plain | bold | muted)
- *   ImageElement          → `image` block
- *   DividerElement        → `divider`
- *   ActionsElement        → `actions` with buttons / link buttons /
- *                           static_select / radio_buttons
- *   SectionElement        → recurses into a sequence of blocks
- *   FieldsElement         → `section` with fields
- *   LinkElement           → `section` with a `<url|label>` mrkdwn
- *   TableElement          → `section` with a mrkdwn approximation
- *   ButtonElement         → `button` action element
- *   LinkButtonElement     → `button` action element with `url`
- *
- * Anything else falls back to the chat SDK's
- * `cardChildToFallbackText` (a string description) wrapped in a
- * section block so the message is never silently dropped.
- */
-import { cardChildToFallbackText, } from "#compiled/chat/index.js";
-import { truncatePlainText } from "#public/channels/slack/limits.js";
-/**
- * Converts a {@link CardElement} into a list of Slack Block Kit blocks
- * ready to ship to `chat.postMessage`'s `blocks` parameter.
- */
-export function cardToBlocks(card) {
-    const blocks = [];
-    const state = { usedNativeTable: false };
-    if (card.title) {
-        blocks.push({
-            type: "header",
-            text: { type: "plain_text", text: truncatePlainText(card.title) ?? card.title, emoji: true },
-        });
-    }
-    if (card.subtitle) {
-        blocks.push({
-            type: "context",
-            elements: [{ type: "mrkdwn", text: card.subtitle }],
-        });
-    }
-    if (card.imageUrl) {
-        blocks.push({ type: "image", image_url: card.imageUrl, alt_text: card.title ?? "" });
-    }
-    for (const child of card.children) {
-        appendChildBlocks(child, blocks, state);
-    }
-    return blocks;
-}
-/**
- * Best-effort fallback text for a card. Used as the `text` field on
- * `chat.postMessage` so notifications and accessibility readers still
- * see something meaningful.
- */
-export function cardToFallbackText(card) {
-    const lines = [];
-    if (card.title)
-        lines.push(card.title);
-    if (card.subtitle)
-        lines.push(card.subtitle);
-    for (const child of card.children) {
-        const text = cardChildToFallbackText(child);
-        if (text && text.length > 0)
-            lines.push(text);
-    }
-    return lines.join("\n").trim();
-}
-function appendChildBlocks(child, blocks, state) {
-    switch (child.type) {
-        case "text":
-            blocks.push(textToBlock(child));
-            return;
-        case "image":
-            blocks.push(imageToBlock(child));
-            return;
-        case "divider":
-            blocks.push(dividerToBlock(child));
-            return;
-        case "actions":
-            blocks.push(actionsToBlock(child));
-            return;
-        case "section":
-            for (const inner of child.children) {
-                appendChildBlocks(inner, blocks, state);
-            }
-            return;
-        case "fields":
-            blocks.push(fieldsToBlock(child));
-            return;
-        case "link":
-            blocks.push(linkToBlock(child));
-            return;
-        case "table":
-            blocks.push(...tableToBlocks(child, state));
-            return;
-        default: {
-            const fallback = cardChildToFallbackText(child);
-            if (fallback) {
-                blocks.push({ type: "section", text: { type: "mrkdwn", text: fallback } });
-            }
-        }
-    }
-}
-function textToBlock(text) {
-    if (text.style === "muted") {
-        return {
-            type: "context",
-            elements: [{ type: "mrkdwn", text: text.content }],
-        };
-    }
-    const body = text.style === "bold" ? `*${text.content}*` : text.content;
-    return { type: "section", text: { type: "mrkdwn", text: body } };
-}
-function imageToBlock(image) {
-    return { type: "image", image_url: image.url, alt_text: image.alt ?? "" };
-}
-function dividerToBlock(_divider) {
-    return { type: "divider" };
-}
-function actionsToBlock(actions) {
-    const elements = [];
-    for (const child of actions.children) {
-        const element = actionChildToElement(child);
-        if (element)
-            elements.push(element);
-    }
-    return { type: "actions", elements };
-}
-function actionChildToElement(child) {
-    switch (child.type) {
-        case "button":
-            return buttonToElement(child);
-        case "link-button":
-            return linkButtonToElement(child);
-        case "select":
-            return selectToElement(child);
-        case "radio_select":
-            return radioSelectToElement(child);
-        default:
-            return null;
-    }
-}
-function buttonToElement(button) {
-    const element = {
-        type: "button",
-        action_id: button.id,
-        text: { type: "plain_text", text: truncatePlainText(button.label) ?? button.label },
-    };
-    if (button.value !== undefined)
-        element.value = button.value;
-    if (button.style && button.style !== "default")
-        element.style = button.style;
-    if (button.disabled === true)
-        element.disabled = true;
-    if (button.callbackUrl)
-        element.url = button.callbackUrl;
-    return element;
-}
-function linkButtonToElement(button) {
-    const element = {
-        type: "button",
-        action_id: `link:${button.url}`,
-        text: { type: "plain_text", text: truncatePlainText(button.label) ?? button.label },
-        url: button.url,
-    };
-    if (button.style && button.style !== "default")
-        element.style = button.style;
-    return element;
-}
-function selectToElement(select) {
-    return {
-        type: "static_select",
-        action_id: select.id,
-        placeholder: {
-            type: "plain_text",
-            text: select.placeholder ?? select.label,
-        },
-        options: select.options.map((option) => ({
-            text: { type: "plain_text", text: option.label },
-            value: option.value,
-            ...(option.description
-                ? { description: { type: "plain_text", text: option.description } }
-                : {}),
-        })),
-    };
-}
-function radioSelectToElement(select) {
-    return {
-        type: "radio_buttons",
-        action_id: select.id,
-        options: select.options.map((option) => ({
-            text: { type: "plain_text", text: option.label },
-            value: option.value,
-            ...(option.description
-                ? { description: { type: "plain_text", text: option.description } }
-                : {}),
-        })),
-    };
-}
-function fieldsToBlock(fields) {
-    return {
-        type: "section",
-        fields: fields.children.map((field) => ({
-            type: "mrkdwn",
-            text: `*${field.label}*\n${field.value}`,
-        })),
-    };
-}
-function linkToBlock(link) {
-    return {
-        type: "section",
-        text: { type: "mrkdwn", text: `<${link.url}|${link.label}>` },
-    };
-}
-/**
- * Renders a {@link TableElement} as Slack's native table block when it
- * fits Slack's limits. Slack allows one table block per message, so
- * additional or oversized tables fall back to a fixed-width mrkdwn
- * approximation.
- */
-function tableToBlocks(table, state) {
-    const MAX_NATIVE_TABLE_ROWS = 100;
-    const MAX_NATIVE_TABLE_COLUMNS = 20;
-    if (!state.usedNativeTable &&
-        table.rows.length <= MAX_NATIVE_TABLE_ROWS &&
-        table.headers.length <= MAX_NATIVE_TABLE_COLUMNS) {
-        state.usedNativeTable = true;
-        return [
-            {
-                type: "table",
-                rows: [
-                    table.headers.map(tableCellToRawText),
-                    ...table.rows.map((row) => row.map(tableCellToRawText)),
-                ],
-            },
-        ];
-    }
-    return [tableToFallbackBlock(table)];
-}
-function tableCellToRawText(value) {
-    return { type: "raw_text", text: value || " " };
-}
-function tableToFallbackBlock(table) {
-    const widths = table.headers.map((header, columnIndex) => {
-        let width = header.length;
-        for (const row of table.rows) {
-            const cell = row[columnIndex] ?? "";
-            if (cell.length > width)
-                width = cell.length;
-        }
-        return width;
-    });
-    const headerLine = table.headers.map((header, i) => header.padEnd(widths[i] ?? 0)).join(" | ");
-    const separator = widths.map((width) => "-".repeat(width)).join("-|-");
-    const rowLines = table.rows.map((row) => table.headers.map((_, i) => (row[i] ?? "").padEnd(widths[i] ?? 0)).join(" | "));
-    const body = ["```", headerLine, separator, ...rowLines, "```"].join("\n");
-    return { type: "section", text: { type: "mrkdwn", text: body } };
-}
+import{cardChildToFallbackText}from"#compiled/chat/index.js";import{truncatePlainText}from"#public/channels/slack/limits.js";function cardToBlocks(e){let n=[],r={usedNativeTable:!1};e.title&&n.push({type:`header`,text:{type:`plain_text`,text:truncatePlainText(e.title)??e.title,emoji:!0}}),e.subtitle&&n.push({type:`context`,elements:[{type:`mrkdwn`,text:e.subtitle}]}),e.imageUrl&&n.push({type:`image`,image_url:e.imageUrl,alt_text:e.title??``});for(let t of e.children)appendChildBlocks(t,n,r);return n}function cardToFallbackText(t){let n=[];t.title&&n.push(t.title),t.subtitle&&n.push(t.subtitle);for(let r of t.children){let t=cardChildToFallbackText(r);t&&t.length>0&&n.push(t)}return n.join(`
+`).trim()}function appendChildBlocks(t,n,r){switch(t.type){case`text`:n.push(textToBlock(t));return;case`image`:n.push(imageToBlock(t));return;case`divider`:n.push(dividerToBlock(t));return;case`actions`:n.push(actionsToBlock(t));return;case`section`:for(let e of t.children)appendChildBlocks(e,n,r);return;case`fields`:n.push(fieldsToBlock(t));return;case`link`:n.push(linkToBlock(t));return;case`table`:n.push(...tableToBlocks(t,r));return;default:{let r=cardChildToFallbackText(t);r&&n.push({type:`section`,text:{type:`mrkdwn`,text:r}})}}}function textToBlock(e){return e.style===`muted`?{type:`context`,elements:[{type:`mrkdwn`,text:e.content}]}:{type:`section`,text:{type:`mrkdwn`,text:e.style===`bold`?`*${e.content}*`:e.content}}}function imageToBlock(e){return{type:`image`,image_url:e.url,alt_text:e.alt??``}}function dividerToBlock(e){return{type:`divider`}}function actionsToBlock(e){let t=[];for(let n of e.children){let e=actionChildToElement(n);e&&t.push(e)}return{type:`actions`,elements:t}}function actionChildToElement(e){switch(e.type){case`button`:return buttonToElement(e);case`link-button`:return linkButtonToElement(e);case`select`:return selectToElement(e);case`radio_select`:return radioSelectToElement(e);default:return null}}function buttonToElement(e){let n={type:`button`,action_id:e.id,text:{type:`plain_text`,text:truncatePlainText(e.label)??e.label}};return e.value!==void 0&&(n.value=e.value),e.style&&e.style!==`default`&&(n.style=e.style),e.disabled===!0&&(n.disabled=!0),e.callbackUrl&&(n.url=e.callbackUrl),n}function linkButtonToElement(e){let n={type:`button`,action_id:`link:${e.url}`,text:{type:`plain_text`,text:truncatePlainText(e.label)??e.label},url:e.url};return e.style&&e.style!==`default`&&(n.style=e.style),n}function selectToElement(e){return{type:`static_select`,action_id:e.id,placeholder:{type:`plain_text`,text:e.placeholder??e.label},options:e.options.map(e=>({text:{type:`plain_text`,text:e.label},value:e.value,...e.description?{description:{type:`plain_text`,text:e.description}}:{}}))}}function radioSelectToElement(e){return{type:`radio_buttons`,action_id:e.id,options:e.options.map(e=>({text:{type:`plain_text`,text:e.label},value:e.value,...e.description?{description:{type:`plain_text`,text:e.description}}:{}}))}}function fieldsToBlock(e){return{type:`section`,fields:e.children.map(e=>({type:`mrkdwn`,text:`*${e.label}*\n${e.value}`}))}}function linkToBlock(e){return{type:`section`,text:{type:`mrkdwn`,text:`<${e.url}|${e.label}>`}}}function tableToBlocks(e,t){return!t.usedNativeTable&&e.rows.length<=100&&e.headers.length<=20?(t.usedNativeTable=!0,[{type:`table`,rows:[e.headers.map(tableCellToRawText),...e.rows.map(e=>e.map(tableCellToRawText))]}]):[tableToFallbackBlock(e)]}function tableCellToRawText(e){return{type:`raw_text`,text:e||` `}}function tableToFallbackBlock(e){let t=e.headers.map((t,n)=>{let r=t.length;for(let t of e.rows){let e=t[n]??``;e.length>r&&(r=e.length)}return r});return{type:`section`,text:{type:`mrkdwn`,text:["```",e.headers.map((e,n)=>e.padEnd(t[n]??0)).join(` | `),t.map(e=>`-`.repeat(e)).join(`-|-`),...e.rows.map(n=>e.headers.map((e,r)=>(n[r]??``).padEnd(t[r]??0)).join(` | `)),"```"].join(`
+`)}}}export{cardToBlocks,cardToFallbackText};

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

@@ -1,70 +1 @@
-/**
- * Slack rendering for `connection.authorization_*` events.
- *
- * The framework emits these when a tool call needs the user to complete
- * an OAuth-style authorization flow (e.g. signing in to Linear). The
- * channel's default handler posts:
- *
- * 1. An ephemeral "Sign in with X" link button to the triggering user
- *    (when their id is known), surfacing the challenge URL.
- * 2. A public "Connect with X to continue" status message visible to
- *    everyone in the thread.
- *
- * When the matching `connection.authorization_completed` event arrives
- * the public status message is edited in place to surface the outcome
- * (`authorized` / `declined` / `failed` / `timed-out`).
- */
-/**
- * Title-cases a connection name (`linear` → `Linear`) for display. Empty
- * strings pass through unchanged so the renderer never emits an empty
- * label inside a sentence.
- */
-export function formatConnectionDisplayName(connectionName) {
-    if (connectionName.length === 0)
-        return connectionName;
-    return connectionName.charAt(0).toUpperCase() + connectionName.slice(1);
-}
-/**
- * Public status text posted when an authorization challenge fires. When
- * the channel cannot identify a triggering user (rare — schedule-initiated
- * sessions or events that lack actor metadata) the text drops the
- * "Connect with" call-to-action since there's no one to act on it.
- */
-export function buildAuthRequiredPublicText(input) {
-    if (!input.hasUser) {
-        return `Authorization required for ${input.displayName} (no triggering user)`;
-    }
-    return `Connect with ${input.displayName} to continue`;
-}
-/**
- * Final-state markdown for the previously-posted status message. Edited
- * in place by `connection.authorization_completed` so the user sees
- * resolution without scrolling.
- */
-export function buildAuthCompletedText(input) {
-    if (input.outcome === "authorized") {
-        return `:white_check_mark: ${input.displayName} connected`;
-    }
-    const tail = input.reason !== undefined ? ` (${input.reason})` : "";
-    return `:x: ${input.displayName} authorization ${input.outcome}${tail}`;
-}
-/**
- * Block Kit blocks for the ephemeral "Sign in with X" link button.
- * Slack ephemerals accept the same block list shape as regular messages
- * so the helper returns blocks directly.
- */
-export function buildAuthEphemeralBlocks(input) {
-    return [
-        {
-            type: "actions",
-            elements: [
-                {
-                    type: "button",
-                    text: { type: "plain_text", text: `Sign in with ${input.displayName}` },
-                    url: input.url,
-                    style: "primary",
-                },
-            ],
-        },
-    ];
-}
+function formatConnectionDisplayName(e){return e.length===0?e:e.charAt(0).toUpperCase()+e.slice(1)}function buildAuthRequiredPublicText(e){return e.hasUser?`Connect with ${e.displayName} to continue`:`Authorization required for ${e.displayName} (no triggering user)`}function buildAuthCompletedText(e){if(e.outcome===`authorized`)return`:white_check_mark: ${e.displayName} connected`;let t=e.reason===void 0?``:` (${e.reason})`;return`:x: ${e.displayName} authorization ${e.outcome}${t}`}function buildAuthEphemeralBlocks(e){return[{type:`actions`,elements:[{type:`button`,text:{type:`plain_text`,text:`Sign in with ${e.displayName}`},url:e.url,style:`primary`}]}]}export{buildAuthCompletedText,buildAuthEphemeralBlocks,buildAuthRequiredPublicText,formatConnectionDisplayName};

package/dist/src/public/channels/slack/constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default route that `slackChannel({})` mounts on. The scaffold's slack
+ * setup (`vercel connect attach --trigger-path ...`) must point at this
+ * exact path or Connect-forwarded Slack events 404 against the Ash
+ * framework router.
+ */
+export declare const SLACK_CHANNEL_DEFAULT_ROUTE = "/ash/v1/slack";

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

@@ -0,0 +1 @@
+var SLACK_CHANNEL_DEFAULT_ROUTE=`/ash/v1/slack`;export{SLACK_CHANNEL_DEFAULT_ROUTE};

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

@@ -1,211 +1,4 @@
-import { createLogger, extractErrorId, formatErrorHint } from "#internal/logging.js";
-import { buildAuthCompletedText, buildAuthEphemeralBlocks, buildAuthRequiredPublicText, formatConnectionDisplayName, } from "#public/channels/slack/connections.js";
-import { renderInputRequestBlocks } from "#public/channels/slack/hitl.js";
-import { truncateMessageText, truncateTypingStatus } from "#public/channels/slack/limits.js";
-const log = createLogger("slack.defaults");
-/**
- * Workspace-scoped projection of the Slack actor that produced
- * `message`. Used by {@link defaultOnAppMention} to derive a
- * {@link SessionAuthContext} when the customer hasn't supplied their
- * own `onAppMention`.
- */
-export function defaultSlackAuth(message, ctx) {
-    const author = message.author;
-    if (!author)
-        return null;
-    const teamId = message.teamId;
-    const isBot = author.isBot;
-    const userId = author.userId;
-    const principalId = teamId
-        ? isBot
-            ? `slack:${teamId}:bot:${userId}`
-            : `slack:${teamId}:${userId}`
-        : isBot
-            ? `slack:bot:${userId}`
-            : `slack:${userId}`;
-    const attributes = {
-        author_type: isBot ? "bot" : "user",
-        channel_id: ctx.slack.channelId,
-        thread_ts: ctx.slack.threadTs,
-        user_id: userId,
-    };
-    if (author.userName)
-        attributes.user_name = author.userName;
-    if (author.fullName)
-        attributes.full_name = author.fullName;
-    if (teamId !== undefined)
-        attributes.team_id = teamId;
-    return {
-        attributes,
-        authenticator: "slack-webhook",
-        issuer: teamId !== undefined ? `slack:${teamId}` : "slack",
-        principalId,
-        principalType: isBot ? "service" : "user",
-    };
-}
-/**
- * Default `onAppMention` — derives auth from the Slack actor and posts
- * a `"Thinking…"` typing indicator before the workflow runtime starts.
- */
-export async function defaultOnAppMention(ctx, message) {
-    await ctx.thread.startTyping("Thinking...");
-    return { auth: defaultSlackAuth(message, ctx) };
-}
-/**
- * Default `onDirectMessage` — derives auth from the Slack actor and
- * posts a `"Thinking…"` typing indicator before the workflow runtime
- * starts. Matches the default mention behavior; replace the option to
- * customize gating, auth derivation, or pre-dispatch side effects.
- */
-export async function defaultOnDirectMessage(ctx, message) {
-    await ctx.thread.startTyping("Thinking...");
-    return { auth: defaultSlackAuth(message, ctx) };
-}
-/**
- * Reads the first non-empty line of a model-emitted message. The
- * default `actions.requested` handler uses this to surface the
- * model's own pre-tool-call narration as the typing indicator.
- */
-function firstNonEmptyLine(text) {
-    for (const line of text.split(/\r?\n/u)) {
-        const trimmed = line.trim();
-        if (trimmed.length > 0)
-            return trimmed;
-    }
-    return undefined;
-}
-/**
- * Default `input.requested` handler — renders each pending HITL
- * request as Slack `block_actions`. Buttons by default; radio for
- * ≤6-option select requests; static_select for >6-option select
- * requests. Override by declaring `events["input.requested"]`.
- */
-export function defaultInputRequestedHandler() {
-    return async (data, ctx) => {
-        if (data.requests.length === 0)
-            return;
-        const promptText = truncateMessageText(data.requests.map((r) => r.prompt).join("\n"));
-        await ctx.thread.post({
-            blocks: data.requests.flatMap(renderInputRequestBlocks),
-            text: promptText,
-        });
-    };
-}
-/**
- * Built-in Slack event handlers — typing indicators, error replies,
- * and the connection-authorization status flow. Each is overridable
- * per-event by passing the same key under `slackChannel({ events })`.
- */
-export const defaultEvents = {
-    async "turn.started"(_event, ctx) {
-        ctx.state.pendingToolCallMessage = null;
-        await ctx.thread.startTyping("Working...");
-    },
-    async "actions.requested"(event, ctx) {
-        const buffered = ctx.state.pendingToolCallMessage;
-        ctx.state.pendingToolCallMessage = null;
-        if (buffered) {
-            await ctx.thread.startTyping(truncateTypingStatus(buffered));
-            return;
-        }
-        const labels = event.actions.map((a) => (a.kind === "tool-call" ? a.toolName : a.kind));
-        await ctx.thread.startTyping(truncateTypingStatus(`Running ${labels.join(", ")}...`));
-    },
-    async "message.completed"(event, ctx) {
-        if (event.finishReason === "tool-calls") {
-            ctx.state.pendingToolCallMessage = event.message
-                ? (firstNonEmptyLine(event.message) ?? null)
-                : null;
-            return;
-        }
-        ctx.state.pendingToolCallMessage = null;
-        if (event.message)
-            await ctx.thread.post(event.message);
-    },
-    async "turn.failed"(event, ctx) {
-        const hint = formatErrorHint(event);
-        const errorId = extractErrorId(event.details);
-        await ctx.thread.post([
-            `I hit an error while handling your request${hint}.`,
-            "",
-            "Please try again, rephrase, or reach out if it keeps failing.",
-            ...(errorId ? ["", `_Error id: \`${errorId}\`_`] : []),
-        ].join("\n"));
-    },
-    async "session.failed"(event, ctx) {
-        const hint = formatErrorHint(event);
-        const errorId = extractErrorId(event.details);
-        await ctx.thread.post([
-            `This session couldn't recover from an error${hint}.`,
-            "",
-            "Start a new thread to continue — I can't pick this one back up.",
-            ...(errorId ? ["", `_Error id: \`${errorId}\`_`] : []),
-        ].join("\n"));
-    },
-    async "connection.authorization_required"(event, ctx) {
-        const displayName = formatConnectionDisplayName(event.connectionName);
-        const triggeringUserId = ctx.state.triggeringUserId ?? null;
-        const challengeUrl = event.authorization?.url;
-        if (triggeringUserId && challengeUrl) {
-            try {
-                await ctx.thread.postEphemeral(triggeringUserId, {
-                    blocks: buildAuthEphemeralBlocks({ displayName, url: challengeUrl }),
-                    text: `Sign in with ${displayName}: ${challengeUrl}`,
-                });
-            }
-            catch (error) {
-                log.error("Slack auth ephemeral delivery failed", {
-                    connectionName: event.connectionName,
-                    error,
-                });
-            }
-        }
-        const publicText = buildAuthRequiredPublicText({
-            displayName,
-            hasUser: triggeringUserId !== null,
-        });
-        try {
-            const sent = await ctx.thread.post(publicText);
-            if (sent.id) {
-                ctx.state.pendingAuthMessageTs = {
-                    ...ctx.state.pendingAuthMessageTs,
-                    [event.connectionName]: sent.id,
-                };
-            }
-        }
-        catch (error) {
-            log.error("Slack auth public message delivery failed", {
-                connectionName: event.connectionName,
-                error,
-            });
-        }
-    },
-    async "connection.authorization_completed"(event, ctx) {
-        const pending = ctx.state.pendingAuthMessageTs ?? {};
-        const ts = pending[event.connectionName];
-        if (ts === undefined)
-            return;
-        const displayName = formatConnectionDisplayName(event.connectionName);
-        const text = buildAuthCompletedText({
-            displayName,
-            outcome: event.outcome,
-            reason: event.reason,
-        });
-        try {
-            await ctx.slack.request("chat.update", {
-                channel: ctx.slack.channelId,
-                ts,
-                text,
-            });
-        }
-        catch (error) {
-            log.error("Slack auth status edit failed", {
-                connectionName: event.connectionName,
-                error,
-            });
-        }
-        const next = { ...pending };
-        delete next[event.connectionName];
-        ctx.state.pendingAuthMessageTs = next;
-    },
-};
+import{createLogger,extractErrorId,formatErrorHint}from"#internal/logging.js";import{truncateMessageText,truncateTypingStatus}from"#public/channels/slack/limits.js";import{buildAuthCompletedText,buildAuthEphemeralBlocks,buildAuthRequiredPublicText,formatConnectionDisplayName}from"#public/channels/slack/connections.js";import{renderInputRequestBlocks}from"#public/channels/slack/hitl.js";var log=createLogger(`slack.defaults`);function defaultSlackAuth(e,t){let n=e.author;if(!n)return null;let r=e.teamId,i=n.isBot,a=n.userId,o=r?i?`slack:${r}:bot:${a}`:`slack:${r}:${a}`:i?`slack:bot:${a}`:`slack:${a}`,s={author_type:i?`bot`:`user`,channel_id:t.slack.channelId,thread_ts:t.slack.threadTs,user_id:a};return n.userName&&(s.user_name=n.userName),n.fullName&&(s.full_name=n.fullName),r!==void 0&&(s.team_id=r),{attributes:s,authenticator:`slack-webhook`,issuer:r===void 0?`slack`:`slack:${r}`,principalId:o,principalType:i?`service`:`user`}}async function defaultOnAppMention(e,t){return await e.thread.startTyping(`Thinking...`),{auth:defaultSlackAuth(t,e)}}async function defaultOnDirectMessage(e,t){return await e.thread.startTyping(`Thinking...`),{auth:defaultSlackAuth(t,e)}}function firstNonEmptyLine(e){for(let t of e.split(/\r?\n/u)){let e=t.trim();if(e.length>0)return e}}function defaultInputRequestedHandler(){return async(e,t)=>{if(e.requests.length===0)return;let n=truncateMessageText(e.requests.map(e=>e.prompt).join(`
+`));await t.thread.post({blocks:e.requests.flatMap(renderInputRequestBlocks),text:n})}}var defaultEvents={async"turn.started"(e,t){t.state.pendingToolCallMessage=null,await t.thread.startTyping(`Working...`)},async"actions.requested"(e,t){let n=t.state.pendingToolCallMessage;if(t.state.pendingToolCallMessage=null,n){await t.thread.startTyping(truncateTypingStatus(n));return}let r=e.actions.map(e=>e.kind===`tool-call`?e.toolName:e.kind);await t.thread.startTyping(truncateTypingStatus(`Running ${r.join(`, `)}...`))},async"message.completed"(e,t){if(e.finishReason===`tool-calls`){t.state.pendingToolCallMessage=e.message?firstNonEmptyLine(e.message)??null:null;return}t.state.pendingToolCallMessage=null,e.message&&await t.thread.post(e.message)},async"turn.failed"(e,r){let i=formatErrorHint(e),a=extractErrorId(e.details);await r.thread.post([`I hit an error while handling your request${i}.`,``,`Please try again, rephrase, or reach out if it keeps failing.`,...a?[``,`_Error id: \`${a}\`_`]:[]].join(`
+`))},async"session.failed"(e,r){let i=formatErrorHint(e),a=extractErrorId(e.details);await r.thread.post([`This session couldn't recover from an error${i}.`,``,`Start a new thread to continue — I can't pick this one back up.`,...a?[``,`_Error id: \`${a}\`_`]:[]].join(`
+`))},async"connection.authorization_required"(e,t){let n=formatConnectionDisplayName(e.connectionName),r=t.state.triggeringUserId??null,i=e.authorization?.url;if(r&&i)try{await t.thread.postEphemeral(r,{blocks:buildAuthEphemeralBlocks({displayName:n,url:i}),text:`Sign in with ${n}: ${i}`})}catch(t){log.error(`Slack auth ephemeral delivery failed`,{connectionName:e.connectionName,error:t})}let a=buildAuthRequiredPublicText({displayName:n,hasUser:r!==null});try{let n=await t.thread.post(a);n.id&&(t.state.pendingAuthMessageTs={...t.state.pendingAuthMessageTs,[e.connectionName]:n.id})}catch(t){log.error(`Slack auth public message delivery failed`,{connectionName:e.connectionName,error:t})}},async"connection.authorization_completed"(e,t){let n=t.state.pendingAuthMessageTs??{},r=n[e.connectionName];if(r===void 0)return;let i=buildAuthCompletedText({displayName:formatConnectionDisplayName(e.connectionName),outcome:e.outcome,reason:e.reason});try{await t.slack.request(`chat.update`,{channel:t.slack.channelId,ts:r,text:i})}catch(t){log.error(`Slack auth status edit failed`,{connectionName:e.connectionName,error:t})}let o={...n};delete o[e.connectionName],t.state.pendingAuthMessageTs=o}};export{defaultEvents,defaultInputRequestedHandler,defaultOnAppMention,defaultOnDirectMessage,defaultSlackAuth};