@fastagent-sh/fastagent 0.24.3 → 0.25.0

package/dist/channels/slack/history.js

@@ -0,0 +1,282 @@
+/**
+ * A Slack place's history, read when a turn runs (docs/design/place-history.md): a channel's top level from
+ * `conversations.history`, a thread from `conversations.replies`. What a place remembers between turns, and what a
+ * read leaves out, is the kit's (`createPlaceHistory`). A message's `ts` is its id and its position at once: the
+ * turn's ask is the read's exclusive `latest`, and the next read's cursor. Each read lists the newest page before the
+ * ask and stops at the cursor itself, as Feishu's does: Slack has no reliable "after this point" (`SlackRange`).
+ */
+import { capBufferedRefs } from "../kit/context-buffer.js";
+import { createPlaceHistory, } from "../kit/place-history.js";
+import { threadList } from "../kit/room-threads.js";
+import { CONTEXT_READ } from "../kit/transport.js";
+import { slackMessageText } from "./parse.js";
+import { log } from "../../log.js";
+import { SlackApiError } from "./slack-api.js";
+/** How many of a place's newest messages one read keeps; a place busier than this since its last answer says so. */
+const PAGE_SIZE = 50;
+/** What a place's first answered turn reads back, with no cursor yet. */
+const FIRST_READ = 20;
+/** Message subtypes that are someone saying something; every other subtype is the platform's (a join, a topic). */
+const SPOKEN_SUBTYPES = new Set(["file_share", "thread_broadcast", "bot_message", "me_message"]);
+/** How long a person's name is reused before it is looked up again. */
+const NAMES_TTL_MS = 10 * 60_000;
+/** How many of a channel's newest messages a thread list looks through. */
+const THREAD_SCAN = 100;
+/** A place: a channel's top level, or a thread in it. The turn record carries it as this key. */
+export function slackHistoryKey(teamId, place) {
+    const base = `${teamId}:${place.channelId}`;
+    return place.threadTs ? `${base}:root:${place.threadTs}` : base;
+}
+/** The inverse of {@link slackHistoryKey}. Slack ids and timestamps never contain a colon. */
+export function slackPlaceOf(key) {
+    const [teamId = "", channelId = "", , threadTs] = key.split(":");
+    return { teamId, channelId, ...(threadTs ? { threadTs } : {}) };
+}
+/**
+ * Order two Slack timestamps (`seconds.micros`). A double tells microseconds apart until 2^33 seconds (the year 2242),
+ * so plain numbers compare them exactly.
+ */
+const compareSlackTs = (a, b) => Number(a) - Number(b);
+/** Select the most recent background files of the folded messages, excluding the turn's own. */
+export function collectFoldedFiles(folded, primaryIds) {
+    const seen = new Set(primaryIds);
+    const files = [];
+    for (const message of folded) {
+        for (const file of message.files) {
+            if (seen.has(file.key))
+                continue;
+            seen.add(file.key);
+            files.push({ id: file.key, from: message.from.label, messageId: message.id });
+        }
+    }
+    const capped = capBufferedRefs(files);
+    return { files: capped.kept, skipped: capped.skipped };
+}
+const str = (value) => (typeof value === "string" ? value : undefined);
+const list = (value) => Array.isArray(value)
+    ? value.filter((item) => typeof item === "object" && item !== null)
+    : [];
+const textOf = (value) => str(value?.text);
+/** One run of `rich_text`, as the person wrote it. */
+function inline(element) {
+    switch (element.type) {
+        case "text":
+            return str(element.text);
+        case "link":
+            return str(element.text) ?? str(element.url);
+        case "user":
+            return `<@${str(element.user_id)}>`;
+        case "usergroup":
+            return `<!subteam^${str(element.usergroup_id)}>`;
+        case "channel":
+            return `<#${str(element.channel_id)}>`;
+        case "emoji":
+            return `:${str(element.name)}:`;
+        case "broadcast":
+            return `@${str(element.range)}`;
+        case "date":
+            return str(element.fallback) ?? "";
+        default:
+            return undefined;
+    }
+}
+function joined(items, read, separator) {
+    const parts = items.map(read);
+    return parts.every((part) => part !== undefined) ? parts.join(separator) : undefined;
+}
+/** A `rich_text` block: sections, lists, quotes and code, each a run of inline elements. */
+function richText(block) {
+    return joined(list(block.elements), (element) => {
+        const runs = (item) => joined(list(item.elements), inline, "");
+        switch (element.type) {
+            case "rich_text_section":
+            case "rich_text_preformatted":
+                return runs(element);
+            case "rich_text_quote": {
+                const run = runs(element);
+                return run === undefined ? undefined : `> ${run}`;
+            }
+            case "rich_text_list": {
+                // A list split by other blocks continues its numbering from `offset`.
+                const first = typeof element.offset === "number" ? element.offset + 1 : 1;
+                return joined(list(element.elements).map((item, index) => ({ item, index })), ({ item, index }) => {
+                    const run = runs(item);
+                    return run === undefined
+                        ? undefined
+                        : `${element.style === "ordered" ? `${first + index}.` : "-"} ${run}`;
+                }, "\n");
+            }
+            default:
+                return undefined;
+        }
+    }, 
+    // Each element is a block (a paragraph, a list, a quote, code): Slack does not always end one with a newline.
+    "\n");
+}
+const BLOCKS = {
+    header: (block) => textOf(block.text),
+    section: (block) => [textOf(block.text), ...list(block.fields).map(textOf)].filter(Boolean).join("\n"),
+    context: (block) => list(block.elements).map(textOf).filter(Boolean).join(" "),
+    markdown: (block) => str(block.text),
+    divider: () => "---",
+    image: (block) => `[image${str(block.alt_text) ? `: ${str(block.alt_text)}` : ""}]`,
+    rich_text: richText,
+    // A cell is `rich_text` or `raw_text`.
+    table: (block) => joined(Array.isArray(block.rows) ? block.rows : [], (row) => joined(list(row), (cell) => (cell.type === "raw_text" ? str(cell.text) : richText(cell)), " | "), "\n"),
+};
+/**
+ * What a message says. A Markdown post (every answer and `slack-send` post) is stored as blocks, and its `text` is a
+ * rendering that drops a table to ", with interactive elements" (measured), so the blocks are read when this knows them
+ * all, and `text` otherwise. Legacy attachments follow: an integration often says everything there.
+ */
+function spokenText(message) {
+    const blocks = list(message.blocks);
+    const read = joined(blocks, (block) => BLOCKS[String(block.type)]?.(block), "\n");
+    const body = blocks.length > 0 && read !== undefined ? read : (message.text ?? "");
+    const attached = (message.attachments ?? []).map((attachment) => {
+        const parts = [attachment.pretext, attachment.title, attachment.text].filter(Boolean);
+        return parts.length > 0 ? parts.join("\n") : (attachment.fallback ?? "");
+    });
+    return [body, ...attached].filter((part) => part.trim() !== "").join("\n");
+}
+export function createSlackPlaceHistory(deps) {
+    const { api } = deps;
+    /**
+     * The people already looked up, named or known to have no name to find (a failed lookup), and whether the app
+     * lacks `users:read`. All of it expires together, so a failure, a renamed person or a scope granted by a reinstall
+     * is picked up after the TTL, not on every turn and not only at the next start.
+     */
+    const fresh = () => ({
+        named: new Map(),
+        unnamed: new Set(),
+        scopeMissing: false,
+        at: Date.now(),
+    });
+    let names = fresh();
+    /** The missing scope is said once per process: after that, each retry would only repeat it. */
+    let scopeWarned = false;
+    /** Names for the people a fold shows; one not found is shown by user id. Never rejects: a name is a label. */
+    const peopleNames = async (messages) => {
+        if (Date.now() - names.at >= NAMES_TTL_MS)
+            names = fresh();
+        const { named, unnamed } = names;
+        const self = deps.self();
+        const wanted = new Set(messages.flatMap((message) => message.user !== undefined && message.bot_id === undefined && message.user !== self.userId
+            ? [message.user]
+            : []));
+        const unknown = [...wanted].filter((id) => !named.has(id) && !unnamed.has(id));
+        if (names.scopeMissing || unknown.length === 0)
+            return named;
+        const failures = [];
+        await Promise.all(unknown.map(async (id) => {
+            try {
+                const name = await api.userName(id, CONTEXT_READ);
+                if (name)
+                    named.set(id, name);
+                else
+                    unnamed.add(id);
+            }
+            catch (error) {
+                unnamed.add(id);
+                failures.push(error);
+            }
+        }));
+        const missingScope = failures.find((error) => error instanceof SlackApiError && error.slackError === "missing_scope");
+        if (missingScope) {
+            names.scopeMissing = true;
+            if (!scopeWarned) {
+                scopeWarned = true;
+                log.warn(`${deps.label} users:read is not granted, so people are shown by user id — add it under the Slack app's OAuth & Permissions → Bot Token Scopes (an app \`fastagent add slack\` created gets it with the next \`dev --tunnel\` or \`deploy --run\`), then Reinstall to Workspace; names appear within 10 minutes, or after a restart if the reinstall issued a new Bot Token`);
+            }
+        }
+        else if (failures.length > 0) {
+            log.warn(`${deps.label} could not look up ${failures.length} name(s) (shown by user id for 10 minutes): ${String(failures[0])}`);
+        }
+        return named;
+    };
+    /** Who said it: this app, another bot, or a person (by name where `users:read` gives one). */
+    const speaker = (message, people) => {
+        const self = deps.self();
+        const own = (message.user !== undefined && message.user === self.userId) ||
+            (message.bot_id !== undefined && message.bot_id === self.botId);
+        if (own)
+            return { kind: "self", label: "you" };
+        if (message.bot_id !== undefined) {
+            return { kind: "bot", label: `bot ${message.bot_profile?.name ?? message.username ?? message.bot_id}` };
+        }
+        const name = message.user === undefined ? undefined : people.get(message.user);
+        return { kind: "human", label: name ?? `user ${message.user ?? "unknown"}` };
+    };
+    const read = async (key, { cursor, drop }, until) => {
+        const place = slackPlaceOf(key);
+        const range = { ...(until ? { latest: until } : {}), limit: cursor ? PAGE_SIZE : FIRST_READ };
+        const page = place.threadTs === undefined
+            ? await api.channelHistory(place.channelId, range, CONTEXT_READ).then(({ messages, hasMore }) => ({
+                messages: messages.reverse(),
+                hasMore,
+            }))
+            : await api
+                .threadReplies(place.channelId, place.threadTs, range, CONTEXT_READ)
+                .then(({ messages, hasMore }) => ({
+                // The root comes first whatever the range: it is this place's discussion only on a first read.
+                messages: messages.filter((message) => message.ts !== place.threadTs || cursor === undefined),
+                hasMore,
+            }));
+        const after = (ts) => cursor === undefined || compareSlackTs(ts, cursor) > 0;
+        const listed = page.messages.filter((message) => message.ts !== undefined);
+        const fresh = listed.filter((message) => after(message.ts));
+        const earlier = page.hasMore && fresh.length === listed.length;
+        const spoken = fresh.filter((message) => message.hidden !== true &&
+            (message.subtype === undefined || SPOKEN_SUBTYPES.has(message.subtype)) &&
+            !drop(message.ts));
+        const people = await peopleNames(spoken);
+        const messages = spoken
+            .map((message) => {
+            const from = speaker(message, people);
+            const text = slackMessageText({ text: spokenText(message), files: message.files });
+            // No text, attachment or file to show: an empty line would only spend the fold's budget.
+            if (text.trim() === "")
+                return undefined;
+            return {
+                id: message.ts,
+                at: Number(message.ts) * 1000,
+                from,
+                text,
+                images: [],
+                // Whether a file is an image is `files.info`'s answer, read when the turn loads it.
+                files: (message.files ?? []).flatMap((file) => file.id ? [{ key: file.id, ...(file.name ? { name: file.name } : {}) }] : []),
+            };
+        })
+            .filter((message) => message !== undefined);
+        const newest = fresh.at(-1)?.ts;
+        return {
+            covered: fresh.map((message) => message.ts),
+            messages,
+            ...(newest ? { newest } : {}),
+            earlier,
+        };
+    };
+    /** Threads are roots with replies; `conversations.history` gives their count and last reply. */
+    const threads = async (room) => {
+        const { channelId } = slackPlaceOf(room);
+        const { messages } = await api.channelHistory(channelId, { limit: THREAD_SCAN }, CONTEXT_READ);
+        const roots = messages.filter((message) => message.ts !== undefined && (message.reply_count ?? 0) > 0);
+        const people = await peopleNames(roots);
+        const summaries = roots.map((message) => ({
+            id: message.ts,
+            time: { at: Number(message.latest_reply ?? message.ts) * 1000, is: "last active" },
+            replies: message.reply_count,
+            first: { label: speaker(message, people).label, text: spokenText(message) },
+        }));
+        return threadList(summaries, `this channel's newest ${THREAD_SCAN} messages`);
+    };
+    const history = createPlaceHistory({
+        label: deps.label,
+        path: deps.path,
+        isCursor: (value) => typeof value === "string",
+        compare: compareSlackTs,
+        isTurnInput: deps.isTurnInput,
+        read,
+    });
+    return { ...history, threads };
+}

package/dist/channels/slack/invoke-turn.d.ts

@@ -1,9 +1,9 @@
-/** Resolve Slack file IDs at dequeue, then stream one engine-neutral Agent turn. */
-import type { Agent, AgentEvent } from "../../agent.ts";
+/** Resolve Slack file IDs at dequeue, then stream one harness-neutral Agent turn. */
+import type { Agent } from "../../agent-api.ts";
 import type * as Stream from "effect/Stream";
 import type { PortFailure } from "../../effect-port.ts";
-import { type BusyRetry } from "../kit/invoke-turn-kit.ts";
-import type { SlackBufferedFileRef } from "./context-buffer.ts";
+import { type TurnEvent } from "../kit/invoke-turn-kit.ts";
+import type { SlackBufferedFileRef } from "./history.ts";
 import { type SlackApi } from "./slack-api.ts";
 export interface SlackTurnTransport {
     api: SlackApi;
@@ -18,4 +18,11 @@ export interface SlackTurnAttachments {
         skipped: number;
     };
 }
-export declare function slackTurnStream(agent: Agent, session: string, text: string, transport: SlackTurnTransport, attachments: SlackTurnAttachments, busyRetry?: BusyRetry): Stream.Stream<AgentEvent, PortFailure>;
+/** One turn: resolve its files, then ask the agent. `key` is the turn's: the message it answers. */
+export declare function slackTurnStream(agent: Agent, turn: {
+    session: () => Promise<string>;
+    /** While it runs, the room its thread-reading tool reads (a channel turn's channel). */
+    enter?: (sessionId: string) => () => void;
+    key: string;
+    text: string;
+}, transport: SlackTurnTransport, attachments: SlackTurnAttachments): Stream.Stream<TurnEvent, PortFailure>;

package/dist/channels/slack/invoke-turn.js

@@ -1,4 +1,4 @@
-import { DEFAULT_BUSY_RETRY, attachedFilesManifest, attributedFileName, backgroundImagesManifest, loadBackground, missingAttachmentsNote, turnStream, } from "../kit/invoke-turn-kit.js";
+import { attachedFilesManifest, attributedFileName, backgroundImagesManifest, loadBackground, missingAttachmentsNote, turnStream, promptContent, } from "../kit/invoke-turn-kit.js";
 import { SlackApiError } from "./slack-api.js";
 const MARKDOWN_INSTRUCTION = "\n\n(Format your reply as standard Markdown. Slack renders it natively. Do not use HTML or Slack control-mention syntax such as <!here>, <!channel>, or <!everyone>.)";
 async function resolveFile(transport, fileId) {
@@ -44,15 +44,17 @@ async function resolveInputs(transport, attachments) {
         promptSuffix: `${missingNote}${imageManifest}${attachedFilesManifest(allFiles)}`,
     };
 }
-export function slackTurnStream(agent, session, text, transport, attachments, busyRetry = DEFAULT_BUSY_RETRY) {
+/** One turn: resolve its files, then ask the agent. `key` is the turn's: the message it answers. */
+export function slackTurnStream(agent, turn, transport, attachments) {
     return turnStream({
         agent,
         label: transport.label,
-        busyRetry,
+        session: turn.session,
+        ...(turn.enter === undefined ? {} : { enter: turn.enter }),
         resolve: () => resolveInputs(transport, attachments),
         turn: (resolved) => ({
-            scope: { session },
-            prompt: { text: `${text}${resolved.promptSuffix}${MARKDOWN_INSTRUCTION}`, images: resolved.images },
+            idempotencyKey: turn.key,
+            content: promptContent(`${turn.text}${resolved.promptSuffix}${MARKDOWN_INSTRUCTION}`, resolved.images),
         }),
         // Slack says which failures are transient; anything else (a deleted file, a missing scope) will
         // fail the same way on redelivery.

package/dist/channels/slack/manifest.d.ts

@@ -1,4 +1,3 @@
-export type SlackGroupBehavior = "context" | "mentions";
 export interface SlackAppManifest {
     display_information: {
         name: string;
@@ -39,11 +38,9 @@ export interface SlackAppManifest {
         token_rotation_enabled: boolean;
     };
 }
-export declare function slackBotScopes(groupBehavior: SlackGroupBehavior): string[];
-export declare function slackBotEvents(groupBehavior: SlackGroupBehavior): string[];
+export declare function slackBotScopes(): string[];
 export declare function buildSlackManifest(input: {
     name: string;
-    groupBehavior: SlackGroupBehavior;
     requestUrl?: string;
     redirectUrl?: string;
 }): SlackAppManifest;

package/dist/channels/slack/manifest.js

@@ -1,4 +1,6 @@
-const SLACK_BASE_BOT_SCOPES = [
+// One posture, as on Feishu: the agent hears the channels it is in (participant-model.md §2), so the history scopes
+// and their message events are part of every app. `users:read` names the people in the history a turn reads.
+const SLACK_BOT_SCOPES = [
     "app_mentions:read",
     "assistant:write",
     "chat:write",
@@ -6,15 +8,25 @@ const SLACK_BASE_BOT_SCOPES = [
     "files:write",
     "im:history",
     "reactions:write",
+    "channels:history",
+    "groups:history",
+    "mpim:history",
+    "users:read",
 ];
-const SLACK_CONTEXT_BOT_SCOPES = ["channels:history", "groups:history", "mpim:history"];
-const SLACK_BASE_BOT_EVENTS = ["app_context_changed", "app_home_opened", "app_mention", "message.im"];
-const SLACK_CONTEXT_BOT_EVENTS = ["message.channels", "message.groups", "message.mpim"];
-export function slackBotScopes(groupBehavior) {
-    return [...SLACK_BASE_BOT_SCOPES, ...(groupBehavior === "context" ? SLACK_CONTEXT_BOT_SCOPES : [])].sort();
+const SLACK_BOT_EVENTS = [
+    "app_context_changed",
+    "app_home_opened",
+    "app_mention",
+    "message.im",
+    "message.channels",
+    "message.groups",
+    "message.mpim",
+];
+export function slackBotScopes() {
+    return [...SLACK_BOT_SCOPES].sort();
 }
-export function slackBotEvents(groupBehavior) {
-    return [...SLACK_BASE_BOT_EVENTS, ...(groupBehavior === "context" ? SLACK_CONTEXT_BOT_EVENTS : [])].sort();
+function slackBotEvents() {
+    return [...SLACK_BOT_EVENTS].sort();
 }
 /** Slack's bot display name is more restrictive than the app name. */
 function slackBotDisplayName(name) {
@@ -49,7 +61,7 @@ export function buildSlackManifest(input) {
             bot_user: { display_name: slackBotDisplayName(name), always_online: false },
         },
         oauth_config: {
-            scopes: { bot: slackBotScopes(input.groupBehavior) },
+            scopes: { bot: slackBotScopes() },
             ...(input.redirectUrl ? { redirect_urls: [input.redirectUrl] } : {}),
         },
         settings: {
@@ -57,7 +69,7 @@ export function buildSlackManifest(input) {
                 ? {
                     event_subscriptions: {
                         request_url: input.requestUrl,
-                        bot_events: slackBotEvents(input.groupBehavior),
+                        bot_events: slackBotEvents(),
                     },
                 }
                 : {}),

package/dist/channels/slack/model.d.ts

@@ -58,7 +58,8 @@ export interface SlackEventEnvelope {
     }>;
 }
 export interface SlackRoute {
-    session?: string;
+    /** Which conversation it belongs to, the one its session is kept by (default: the thread). */
+    conversation?: string;
     channelId?: string;
     threadTs?: string | null;
     text?: string;

package/dist/channels/slack/onboard.d.ts

@@ -1,5 +1,4 @@
 import { createSlackApp, exchangeSlackOAuthCode, updateSlackAppManifest } from "./config-api.ts";
-import { type SlackGroupBehavior } from "./manifest.ts";
 import { type SlackOnboardingState } from "./onboarding-state.ts";
 export interface SlackOnboardIO {
     note(message: string): void;
@@ -33,7 +32,6 @@ export declare function onboardSlackApp(input: SlackOnboardInput, io: SlackOnboa
 }): Promise<SlackOnboardingState>;
 export declare function newSlackOnboardingState(input: {
     appName: string;
-    groupBehavior: SlackGroupBehavior;
     configToken: string;
     configRefreshToken: string;
     /** When the pair was captured; pass it through rather than re-deriving the same expiry twice. */

package/dist/channels/slack/onboard.js

@@ -22,7 +22,6 @@ export async function onboardSlackApp(input, io, deps = {}) {
     });
     const manifest = buildSlackManifest({
         name: state.appName,
-        groupBehavior: state.groupBehavior,
         requestUrl: input.requestUrl,
         redirectUrl: input.redirectUrl,
     });
@@ -91,7 +90,7 @@ export async function onboardSlackApp(input, io, deps = {}) {
     const oauthState = randomBytes(24).toString("hex");
     const authorize = new URL("https://slack.com/oauth/v2/authorize");
     authorize.searchParams.set("client_id", state.clientId);
-    authorize.searchParams.set("scope", slackBotScopes(state.groupBehavior).join(","));
+    authorize.searchParams.set("scope", slackBotScopes().join(","));
     authorize.searchParams.set("redirect_uri", input.redirectUrl);
     authorize.searchParams.set("state", oauthState);
     // The redirect lands on the tunnel hostname, which THIS machine may not resolve yet (#421).
@@ -112,7 +111,7 @@ export async function onboardSlackApp(input, io, deps = {}) {
     });
     if (oauth.appId !== state.appId)
         throw new Error("Slack OAuth installed a different app than the manifest app");
-    if (slackBotScopes(state.groupBehavior).some((scope) => !oauth.scopes.includes(scope))) {
+    if (slackBotScopes().some((scope) => !oauth.scopes.includes(scope))) {
         throw new Error("Slack OAuth completed without all required bot scopes; re-run fastagent add slack to reinstall");
     }
     await io.writeRuntimeSecrets({ botToken: oauth.botToken });
@@ -130,7 +129,6 @@ export function newSlackOnboardingState(input) {
     return {
         version: 1,
         appName: input.appName,
-        groupBehavior: input.groupBehavior,
         configToken: input.configToken,
         configRefreshToken: input.configRefreshToken,
         configTokenExpiresAt: input.configTokenExpiresAt ?? configTokenExpiry(input.now),

package/dist/channels/slack/onboarding-state.d.ts

@@ -1,10 +1,8 @@
-import type { SlackGroupBehavior } from "./manifest.ts";
 /** When a token pair captured `now` stops being usable — the ONE place that answers it. */
 export declare function configTokenExpiry(now?: number): number;
 export interface SlackOnboardingState {
     version: 1;
     appName: string;
-    groupBehavior: SlackGroupBehavior;
     appId?: string;
     /** Set before apps.manifest.create; without an appId it blocks blind duplicate-creation retries. */
     createAttemptedAt?: string;

package/dist/channels/slack/onboarding-state.js

@@ -18,7 +18,6 @@ function validState(value) {
         state !== null &&
         state.version === 1 &&
         typeof state.appName === "string" &&
-        (state.groupBehavior === "context" || state.groupBehavior === "mentions") &&
         typeof state.configToken === "string" &&
         typeof state.configRefreshToken === "string" &&
         typeof state.configTokenExpiresAt === "number");

package/dist/channels/slack/parse.d.ts

@@ -2,7 +2,6 @@ import type { SlackEventEnvelope, SlackMessageEvent, SlackRoute } from "./model.
 export type { SlackEventEnvelope, SlackFile, SlackMessageEvent, SlackRoute } from "./model.ts";
 /** Does this text address ANYONE — a user, a broadcast, or a user group? */
 export declare function hasSlackMention(text: string): boolean;
-export declare function hasSlackUserMention(text: string): boolean;
 /** Does this text mention this specific user (either form)? */
 export declare function mentionsSlackUser(text: string, userId: string): boolean;
 /** Strip every mention, e.g. before matching a bare command word or building a title. */
@@ -20,10 +19,6 @@ export declare function slackTeamId(envelope: SlackEventEnvelope): string | unde
 export declare function slackFileIds(event: SlackMessageEvent): string[];
 /** Text plus a structural marker for file-only or captioned file shares. */
 export declare function slackMessageText(event: SlackMessageEvent): string;
-export declare function slackSenderLabel(event: SlackMessageEvent): string;
-/** Main-channel discussion and each concrete thread are independent context buckets. */
-export declare function slackPlaceKey(teamId: string, event: Pick<SlackMessageEvent, "channel" | "thread_ts">): string;
-export declare function slackBufferText(text: string): string;
 export declare function slackEnvelope(envelope: SlackEventEnvelope): string;
 /** Default explicit-summon policy: DMs and app_mention events only. */
 export declare function defaultSlackRoute(envelope: SlackEventEnvelope): SlackRoute | null;

package/dist/channels/slack/parse.js

@@ -1,5 +1,4 @@
-import { BUFFER_LINE_MAX_CHARS } from "../kit/context-buffer.js";
-import { codePointPrefix, truncateCodePointPrefix } from "../kit/text.js";
+import { codePointPrefix } from "../kit/text.js";
 const HUMAN_MESSAGE_SUBTYPES = new Set(["file_share", "thread_broadcast"]);
 /** Both forms Slack writes a mention in: `<@U123>` and the labelled `<@U123|name>`. */
 const mentionSource = (idPattern) => String.raw `<@${idPattern}(?:\|[^>]*)?>`;
@@ -10,9 +9,6 @@ const ANY_MENTION = String.raw `(?:${USER_MENTION}|<!(?:here|channel|everyone)(?
 export function hasSlackMention(text) {
     return new RegExp(ANY_MENTION, "i").test(text);
 }
-export function hasSlackUserMention(text) {
-    return new RegExp(USER_MENTION, "i").test(text);
-}
 /** Escape a platform-supplied id before it becomes part of a pattern. */
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 /** Does this text mention this specific user (either form)? */
@@ -58,17 +54,6 @@ export function slackMessageText(event) {
     const marker = `[${files} attached file${files === 1 ? "" : "s"}]`;
     return text ? `${text}\n${marker}` : marker;
 }
-export function slackSenderLabel(event) {
-    return `user ${event.user ?? "unknown"}`;
-}
-/** Main-channel discussion and each concrete thread are independent context buckets. */
-export function slackPlaceKey(teamId, event) {
-    const base = `${teamId}:${event.channel ?? "unknown-channel"}`;
-    return event.thread_ts ? `${base}:root:${event.thread_ts}` : base;
-}
-export function slackBufferText(text) {
-    return truncateCodePointPrefix(text.replace(/\s+/g, " ").trim(), BUFFER_LINE_MAX_CHARS);
-}
 export function slackEnvelope(envelope) {
     const event = envelope.event;
     if (!event?.channel)

package/dist/channels/slack/preview.d.ts

@@ -1,5 +1,4 @@
-/** Slack reply rendering: native Agent streams first, rate-safe edited-message compatibility second. */
-import type { AgentEvent } from "../../agent.ts";
+import type { TurnEvent } from "../kit/invoke-turn-kit.ts";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import { PortFailure } from "../../effect-port.ts";
@@ -23,7 +22,7 @@ export declare function sanitizeSlackMarkdown(markdown: string): string;
 export declare function deliverSlackAnswer(api: SlackApi, target: SlackTarget, markdown: string, previewTs?: string): Promise<void>;
 /** Settle a queue/drop/defer notice. These are authored plain strings, so the basic text API is enough. */
 export declare function settleSlackPreview(api: SlackApi, target: SlackTarget, previewTs: string | undefined, text: string): Promise<void>;
-export declare function slackReply(events: Stream.Stream<AgentEvent, PortFailure>, api: SlackApi, target: SlackTarget, formatError: (failure: SlackFailure) => string | undefined, options?: {
+export declare function slackReply(events: Stream.Stream<TurnEvent, PortFailure>, api: SlackApi, target: SlackTarget, formatError: (failure: SlackFailure) => string | undefined, options?: {
     rendering?: SlackRendering;
     initialPreviewTs?: string;
     threadTitle?: string;