@cursor/july 0.1.1

package/dist/channels/slack/socket-mode.js

@@ -0,0 +1,116 @@
+/**
+ * Slack Socket Mode via `@slack/socket-mode`.
+ *
+ * Thin wrapper: ACK envelopes immediately, then forward Events API
+ * payloads to the channel pack. Reconnect is handled by the SDK.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LogLevel, SocketModeClient } from "@slack/socket-mode";
+function createBridgeLogger(write) {
+    let level = LogLevel.INFO;
+    const rank = {
+        [LogLevel.ERROR]: 0,
+        [LogLevel.WARN]: 1,
+        [LogLevel.INFO]: 2,
+        [LogLevel.DEBUG]: 3,
+    };
+    const emit = (msgLevel, msgs) => {
+        if (rank[msgLevel] > rank[level]) {
+            return;
+        }
+        const text = msgs
+            .map((m) => (typeof m === "string" ? m : JSON.stringify(m)))
+            .join(" ");
+        write(`[agent-serve/slack] Socket Mode ${text}`);
+    };
+    return {
+        debug: (...msgs) => emit(LogLevel.DEBUG, msgs),
+        info: (...msgs) => emit(LogLevel.INFO, msgs),
+        warn: (...msgs) => emit(LogLevel.WARN, msgs),
+        error: (...msgs) => emit(LogLevel.ERROR, msgs),
+        setLevel(next) {
+            level = next;
+        },
+        getLevel: () => level,
+        setName() {
+            // Name is unused; agent-serve prefixes lines itself.
+        },
+    };
+}
+function invokeHandler(log, label, handler, payload) {
+    try {
+        const result = handler(payload);
+        if (result !== undefined &&
+            typeof result.then === "function") {
+            void Promise.resolve(result).catch((error) => {
+                log(`[agent-serve/slack] Socket Mode ${label} failed: ${errorMessage(error)}`);
+            });
+        }
+    }
+    catch (error) {
+        log(`[agent-serve/slack] Socket Mode ${label} failed: ${errorMessage(error)}`);
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Start a Socket Mode connection. Call `stop()` to tear down.
+ * Resolves once the first WebSocket session is connected.
+ */
+export function startSlackSocketMode(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const write = (_a = options.logger) !== null && _a !== void 0 ? _a : ((line) => console.log(line));
+        const client = new SocketModeClient({
+            appToken: options.appToken,
+            logger: createBridgeLogger(write),
+            logLevel: LogLevel.INFO,
+            autoReconnectEnabled: true,
+        });
+        client.on("connected", () => {
+            write("[agent-serve/slack] Socket Mode connected");
+        });
+        client.on("reconnecting", () => {
+            write("[agent-serve/slack] Socket Mode reconnecting");
+        });
+        client.on("disconnected", () => {
+            write("[agent-serve/slack] Socket Mode disconnected");
+        });
+        client.on("slack_event", (evt) => {
+            // ACK immediately (3s envelope budget); then dispatch off-path.
+            void Promise.resolve(evt.ack()).catch((error) => {
+                write(`[agent-serve/slack] Socket Mode ACK failed: ${errorMessage(error)}`);
+            });
+            if (evt.type === "events_api") {
+                if (evt.body !== undefined) {
+                    invokeHandler(write, "onEvent", options.onEvent, evt.body);
+                }
+                return;
+            }
+            if (evt.type === "interactive") {
+                if (evt.body !== undefined && options.onInteractive !== undefined) {
+                    invokeHandler(write, "onInteractive", options.onInteractive, evt.body);
+                }
+                return;
+            }
+        });
+        yield client.start();
+        return {
+            stop() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield client.disconnect();
+                    write("[agent-serve/slack] Socket Mode stopped");
+                });
+            },
+        };
+    });
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Chat streaming helpers for Slack AI / agent features.
+ */
+export type StreamTaskStatus = "pending" | "in_progress" | "complete" | "error";
+export interface StreamTaskChunk {
+    type: "task_update";
+    id: string;
+    title: string;
+    status: StreamTaskStatus;
+}
+/**
+ * Given previously sent cumulative text and the new cumulative text, return
+ * the suffix to append. Empty string when there is nothing new to send.
+ */
+export declare function computeStreamAppend(lastPostedText: string | null | undefined, cumulative: string): string;
+/** Build task_update chunks for tool calls. */
+export declare function buildTaskChunksForCalls(calls: Array<{
+    callId: string;
+    toolName: string;
+}>, status: StreamTaskStatus): StreamTaskChunk[];
+export declare function buildTaskChunkForResult(args: {
+    callId: string;
+    toolName: string;
+    isError: boolean;
+}): StreamTaskChunk;
+//# sourceMappingURL=stream.d.ts.map

package/dist/channels/slack/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/stream.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,CAAC;AAEhF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACzC,UAAU,EAAE,MAAM,GACjB,MAAM,CAgBR;AAED,+CAA+C;AAC/C,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EAClD,MAAM,EAAE,gBAAgB,GACvB,eAAe,EAAE,CAOnB;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,eAAe,CAOlB"}

package/dist/channels/slack/stream.js

@@ -0,0 +1,39 @@
+/**
+ * Chat streaming helpers for Slack AI / agent features.
+ */
+/**
+ * Given previously sent cumulative text and the new cumulative text, return
+ * the suffix to append. Empty string when there is nothing new to send.
+ */
+export function computeStreamAppend(lastPostedText, cumulative) {
+    if (cumulative === "") {
+        return "";
+    }
+    if (lastPostedText === null ||
+        lastPostedText === undefined ||
+        lastPostedText === "") {
+        return cumulative;
+    }
+    if (cumulative.startsWith(lastPostedText)) {
+        return cumulative.slice(lastPostedText.length);
+    }
+    // Text rewound / rewritten — cannot unsend; skip append.
+    return "";
+}
+/** Build task_update chunks for tool calls. */
+export function buildTaskChunksForCalls(calls, status) {
+    return calls.map((call) => ({
+        type: "task_update",
+        id: call.callId,
+        title: call.toolName,
+        status,
+    }));
+}
+export function buildTaskChunkForResult(args) {
+    return {
+        type: "task_update",
+        id: args.callId,
+        title: args.toolName,
+        status: args.isError ? "error" : "complete",
+    };
+}

package/dist/channels/slack/tool-approval-events.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Slack surface for human-in-the-loop tool approvals.
+ *
+ * Or compose with {@link buildDefaultEvents} (or your own handlers). When
+ * composing by hand, also set `slackChannel({ interactivity: true })` (or
+ * `toolApprovals: true`) so Socket Mode routes Approve/Deny clicks —
+ * otherwise cards post but button presses are ACKed and ignored:
+ *
+ * ```ts
+ * events: {
+ *   ...buildDefaultEvents({ credentials }),
+ *   ...buildToolApprovalEvents({ credentials }),
+ * }
+ * ```
+ *
+ * Or opt in via `slackChannel({ toolApprovals: true })`.
+ * Park/resume itself is the framework HITL primitive (`needsApproval`);
+ * this pack only delivers Approve/Deny in Slack.
+ */
+import type { ChannelEventHandlers } from "../../types.js";
+import { type SlackLog } from "./log.js";
+import type { SlackChannelState, SlackCredentials } from "./types.js";
+export interface BuildToolApprovalEventsOptions {
+    credentials?: SlackCredentials;
+    /** Resolved per-call so channel onStart can rebind the server logger. */
+    getLog?: () => SlackLog;
+}
+/**
+ * Stream-event handlers that post Block Kit Approve/Deny cards and
+ * update them when approval is resolved (HTTP, playground, or Slack).
+ */
+export declare function buildToolApprovalEvents(options?: BuildToolApprovalEventsOptions): ChannelEventHandlers<SlackChannelState>;
+//# sourceMappingURL=tool-approval-events.d.ts.map

package/dist/channels/slack/tool-approval-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-approval-events.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/tool-approval-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAO3D,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEtE,MAAM,WAAW,8BAA8B;IAC7C,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,QAAQ,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,8BAAmC,GAC3C,oBAAoB,CAAC,iBAAiB,CAAC,CA6FzC"}

package/dist/channels/slack/tool-approval-events.js

@@ -0,0 +1,129 @@
+/**
+ * Slack surface for human-in-the-loop tool approvals.
+ *
+ * Or compose with {@link buildDefaultEvents} (or your own handlers). When
+ * composing by hand, also set `slackChannel({ interactivity: true })` (or
+ * `toolApprovals: true`) so Socket Mode routes Approve/Deny clicks —
+ * otherwise cards post but button presses are ACKed and ignored:
+ *
+ * ```ts
+ * events: {
+ *   ...buildDefaultEvents({ credentials }),
+ *   ...buildToolApprovalEvents({ credentials }),
+ * }
+ * ```
+ *
+ * Or opt in via `slackChannel({ toolApprovals: true })`.
+ * Park/resume itself is the framework HITL primitive (`needsApproval`);
+ * this pack only delivers Approve/Deny in Slack.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { postMessage, setThreadStatus, updateMessage } from "./api.js";
+import { buildApprovalBlocks, buildResolvedApprovalBlocks, } from "./approvals.js";
+import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import { defaultSlackLog } from "./log.js";
+/**
+ * Stream-event handlers that post Block Kit Approve/Deny cards and
+ * update them when approval is resolved (HTTP, playground, or Slack).
+ */
+export function buildToolApprovalEvents(options = {}) {
+    var _a;
+    var _b;
+    const botToken = (_a = options.credentials) === null || _a === void 0 ? void 0 : _a.botToken;
+    const getLog = (_b = options.getLog) !== null && _b !== void 0 ? _b : (() => defaultSlackLog);
+    return {
+        "action.approval_requested"(event, channel, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const log = getLog();
+                const state = channel.state;
+                if (state.channelId === null || state.threadTs === null) {
+                    return;
+                }
+                const blocks = buildApprovalBlocks({
+                    sessionId: ctx.session.id,
+                    callId: event.data.callId,
+                    toolName: event.data.toolName,
+                    args: event.data.args,
+                });
+                try {
+                    const posted = yield postMessage({
+                        botToken,
+                        channel: state.channelId,
+                        threadTs: state.threadTs,
+                        text: `Approval required for \`${event.data.toolName}\``,
+                        blocks,
+                    });
+                    channel.state.approvalMessageByCallId = Object.assign(Object.assign({}, ((_a = state.approvalMessageByCallId) !== null && _a !== void 0 ? _a : {})), { [event.data.callId]: posted.ts });
+                    yield setThreadStatus({
+                        botToken,
+                        channelId: state.channelId,
+                        threadTs: state.threadTs,
+                        status: "Awaiting approval…",
+                        loadingMessages: [
+                            "Awaiting approval…",
+                            ...SLACK_DEFAULT_LOADING_MESSAGES,
+                        ],
+                    });
+                    log.info("approval card posted", {
+                        call_id: event.data.callId,
+                        tool: event.data.toolName,
+                        message_ts: posted.ts,
+                    });
+                }
+                catch (error) {
+                    log.warn("approval card post failed", {
+                        call_id: event.data.callId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            });
+        },
+        "action.approval_resolved"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                var _b;
+                const log = getLog();
+                const state = channel.state;
+                const messageTs = (_a = state.approvalMessageByCallId) === null || _a === void 0 ? void 0 : _a[event.data.callId];
+                if (state.channelId !== null &&
+                    messageTs !== undefined &&
+                    messageTs !== "") {
+                    const blocks = buildResolvedApprovalBlocks(Object.assign({ toolName: event.data.toolName, decision: event.data.decision }, (event.data.by === undefined ? {} : { byUserId: event.data.by })));
+                    const verb = event.data.decision === "approve" ? "Approved" : "Denied";
+                    yield updateMessage({
+                        botToken,
+                        channel: state.channelId,
+                        ts: messageTs,
+                        text: `${verb} — ${event.data.toolName}`,
+                        blocks,
+                    });
+                    const next = Object.assign({}, ((_b = state.approvalMessageByCallId) !== null && _b !== void 0 ? _b : {}));
+                    delete next[event.data.callId];
+                    channel.state.approvalMessageByCallId = next;
+                }
+                if (state.channelId !== null && state.threadTs !== null) {
+                    yield setThreadStatus({
+                        botToken,
+                        channelId: state.channelId,
+                        threadTs: state.threadTs,
+                        status: "Working…",
+                        loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
+                    });
+                }
+                log.info("approval resolved in slack", {
+                    call_id: event.data.callId,
+                    decision: event.data.decision,
+                });
+            });
+        },
+    };
+}

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

@@ -0,0 +1,326 @@
+/**
+ * Types for the Slack platform channel pack.
+ */
+import type { AgentCloudOptions, AuthContext, ChannelEventHandlers, HostContext } from "../../types.js";
+/**
+ * Pluggable Slack Web API caller. Instead of holding a raw `xoxb-…` token,
+ * calls are executed by `call` — e.g. proxied through the Cursor backend
+ * with the signed-in account's Slack connection (`cursorAccount: true`).
+ * Implementations return the Slack response body (including `ok: false`
+ * platform errors) and only throw on programmer error.
+ */
+export interface SlackApiTransport {
+    kind: "api-transport";
+    /** Human-readable transport label for logs (e.g. `cursor-account`). */
+    label: string;
+    call(method: string, args: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+/** Bot token as a string, a (possibly async) resolver, or an API transport. */
+export type SlackBotToken = string | (() => string | Promise<string>) | SlackApiTransport;
+export interface SlackCredentials {
+    /**
+     * Bot user OAuth token (`xoxb-…`), or a {@link SlackApiTransport} that
+     * executes Web API calls without a local token. When omitted, falls back
+     * to `SLACK_BOT_TOKEN` (or `{envPrefix}_SLACK_BOT_TOKEN` via
+     * {@link SlackChannelOptions.envPrefix}).
+     */
+    botToken?: SlackBotToken;
+    /**
+     * App-level token (`xapp-…`) for Socket Mode. Requires scope
+     * `connections:write`. Same fallback rules as `botToken`.
+     */
+    appToken?: string | (() => string | Promise<string>);
+}
+/** Per-session Slack adapter state. */
+export interface SlackChannelState {
+    channelId: string | null;
+    threadTs: string | null;
+    teamId: string | null;
+    triggeringUserId: string | null;
+    pendingToolCallMessage: string | null;
+    lastReasoningTypingAtMs: number | null;
+    lastReasoningTypingStatus: string | null;
+    /** Active chat stream message ts (`chat.startStream`). */
+    streamTs: string | null;
+    /** Channel id used when the stream was started. */
+    streamChannelId?: string | null;
+    /** Last cumulative text sent via appendStream (for incremental append). */
+    lastPostedText?: string | null;
+    /**
+     * When true, stream APIs failed for this session — use postMessage
+     * for the rest of the turn.
+     */
+    streamingUnavailable?: boolean;
+    /**
+     * Message ts of approval cards keyed by tool call id (for
+     * replacing Approve/Deny buttons after a decision).
+     */
+    approvalMessageByCallId?: Record<string, string>;
+}
+export interface SlackAuthor {
+    userId: string;
+    userName?: string;
+    isBot: boolean;
+}
+export interface SlackMessage {
+    text: string;
+    /** Text roughly suitable for the model (mention markers cleaned). */
+    markdown: string;
+    ts: string;
+    threadTs: string;
+    channelId: string;
+    teamId?: string;
+    author?: SlackAuthor;
+}
+export interface SlackDispatchDecision {
+    auth: AuthContext | null;
+    /** Extra context blocks injected alongside the default Slack context. */
+    context?: string[];
+    /**
+     * Override the user prompt sent to the model. When omitted, uses the Slack
+     * message markdown (plus context blocks). Host-prepared reviews can pass
+     * a short "read pr.txt" prompt here.
+     */
+    message?: string;
+    /**
+     * Absolute directory used as the local harness `cwd` for this session
+     * (new sessions only).
+     */
+    workspaceDir?: string;
+    /**
+     * Relative path → contents written into the session workspace before the
+     * first turn (new sessions only). Prefer this for host-prepared files like
+     * `pr.txt` so default skill materialization stays on the session cwd.
+     */
+    workspaceFiles?: Record<string, string>;
+    /** Session display title (new sessions only). */
+    title?: string;
+    /**
+     * Per-session cloud options (new sessions only). Use this to attach a PR to
+     * a cloud agent from an inbound Slack mention.
+     */
+    cloud?: AgentCloudOptions;
+    /**
+     * Seed the Cursor SDK agent id for a new session (ignored when the thread
+     * already has one). Lets a handler reattach a Slack thread to an existing
+     * cloud conversation (e.g. per-PR `bc-…` affinity).
+     */
+    sdkAgentId?: string;
+}
+export interface SlackSuggestedPrompt {
+    title: string;
+    message: string;
+}
+export interface SlackThreadHandle {
+    post(text: string, options?: {
+        blocks?: unknown[];
+    }): Promise<{
+        ts: string;
+    }>;
+    startTyping(status: string, loadingMessages?: string[]): Promise<void>;
+    setTitle(title: string): Promise<void>;
+    setSuggestedPrompts(prompts: SlackSuggestedPrompt[], title?: string): Promise<void>;
+}
+export interface SlackBinding {
+    thread: SlackThreadHandle;
+    slack: {
+        channelId: string;
+        threadTs: string;
+        teamId?: string;
+    };
+    /** Shared host services (MCP / GitHub / Slack). */
+    host: HostContext;
+}
+export type SlackMessageHandler = (ctx: SlackBinding, message: SlackMessage) => SlackDispatchDecision | null | undefined | Promise<SlackDispatchDecision | null | undefined>;
+/**
+ * Opt-in channel watch: dispatch on posts in explicitly allowlisted
+ * channels without requiring an @mention. There is deliberately no
+ * "every channel the bot is in" wildcard — watching a channel is a
+ * per-channel decision.
+ */
+export interface SlackChannelPostsOptions {
+    /**
+     * Channels to watch: ids (`C…` / `G…`) or `#names`. Must be non-empty
+     * (empty is a definition error). `#names` are resolved to ids via
+     * `conversations.list` when the channel starts; the bot must be a member
+     * of each watched channel to receive its messages. Socket Mode only —
+     * `cursorAccount: true` rejects `engagement.channelPosts`.
+     */
+    allow: string[];
+    /**
+     * Which posts dispatch. `"top-level"` (default) fires only on new
+     * channel posts — never on replies inside other people's threads, so the
+     * agent can take fresh intake but cannot barge into conversations.
+     * `"all"` also dispatches thread replies (Socket Mode only).
+     */
+    posts?: "top-level" | "all";
+    /**
+     * Delay dispatch by this many milliseconds so rapid edits settle first.
+     * Edits during the window update the dispatched text; deleting the post
+     * cancels the dispatch. Defaults to `0` (immediate). Socket Mode only —
+     * the Cursor relay does not deliver edits/deletes.
+     */
+    debounceMs?: number;
+}
+/**
+ * How the agent engages over Slack. Omitted entirely = mentions + DMs,
+ * which is also the default for each flag — summoned, never proactive.
+ */
+export interface SlackEngagementOptions {
+    /** Dispatch on `app_mention`. Defaults to `true`. */
+    mentions?: boolean;
+    /** Dispatch on direct messages (`message.im`). Defaults to `true`. */
+    directMessages?: boolean;
+    /**
+     * Opt-in channel watch (see {@link SlackChannelPostsOptions}). Requires
+     * the Slack app to subscribe to `message.channels` / `message.groups`
+     * (`slack init --channel-posts`, or add the events to an existing app).
+     */
+    channelPosts?: SlackChannelPostsOptions;
+}
+export interface SlackChannelOptions {
+    credentials?: SlackCredentials;
+    /**
+     * Per-agent env prefix for tokens. `envPrefix: "MY_AGENT"` reads
+     * `MY_AGENT_SLACK_BOT_TOKEN` + `MY_AGENT_SLACK_APP_TOKEN`. Prefer this over
+     * shared `SLACK_*` vars when serving multiple agents in one process.
+     * Ignored when `credentials` is set explicitly.
+     */
+    envPrefix?: string;
+    /**
+     * Use the signed-in Cursor account's Slack connection instead of a
+     * dedicated Slack app: no bot/app tokens, no extra install. Inbound
+     * traffic (`@Cursor <agent name> …` mentions, replies in threads the
+     * agent owns, and DMs) is relayed from the Cursor backend
+     * (`/v0/slack-events`), and outbound Web API calls are proxied through it
+     * — the agent posts as the Cursor Slack app with this agent's name and
+     * icon.
+     *
+     * Both paths stay first-class: omit this (default) for the classic
+     * Socket-Mode channel with your own Slack app and tokens. Requires a
+     * signed-in host (`agent-serve login` / `CURSOR_API_KEY`) and a Slack
+     * account linked to the Cursor account. Mutually exclusive with
+     * `credentials` / `envPrefix`. `engagement.mentions: false` and
+     * `engagement.directMessages: false` are rejected (the relay always
+     * carries that traffic). Channel watching (`engagement.channelPosts`) and
+     * tool approvals / interactivity (`toolApprovals` / `interactivity`) are
+     * Socket Mode only — not supported on cursorAccount; agents must be
+     * explicitly addressed, and Approve/Deny buttons need a dedicated Slack
+     * app.
+     */
+    cursorAccount?: boolean;
+    /**
+     * Display name registered with the Cursor backend when
+     * {@link cursorAccount} is on: `@Cursor <agentName> …` routes here, and
+     * replies post under this username. Defaults to a name derived from the
+     * agent's mount slug (or project name).
+     */
+    agentName?: string;
+    /** Avatar for posts when {@link cursorAccount} is on. */
+    agentIcon?: {
+        url?: string;
+        emoji?: string;
+    };
+    /**
+     * Optional log sink. When omitted, uses `console.log` until the server
+     * mounts the channel and rebinds to {@link ServeOptions.logger}.
+     */
+    logger?: (line: string) => void;
+    /**
+     * Engagement surface. Defaults to mentions + DMs only; channel watch is
+     * opt-in via {@link SlackEngagementOptions.channelPosts}.
+     */
+    engagement?: SlackEngagementOptions;
+    onAppMention?: SlackMessageHandler;
+    onDirectMessage?: SlackMessageHandler;
+    /**
+     * Handler for watched channel posts (same contract as `onAppMention`:
+     * return `null` to skip, or a {@link SlackDispatchDecision} to dispatch).
+     * Only consulted when `engagement.channelPosts` is configured.
+     */
+    onChannelPost?: SlackMessageHandler;
+    /**
+     * Override / extend the default stream-event handlers (typing, replies).
+     * Handlers you provide replace the matching default handlers.
+     */
+    events?: ChannelEventHandlers<SlackChannelState>;
+    /**
+     * When true (default), reply on final `message.completed` and show typing
+     * via `assistant.threads.setStatus` (and streaming when enabled).
+     */
+    deliverDefaults?: boolean;
+    /**
+     * Stream assistant text while the turn runs via `chat.startStream` /
+     * `appendStream` / `stopStream` (defaults to `true` for Socket Mode).
+     * Ignored when {@link cursorAccount} is on — that path never edits posts
+     * (`setStatus` + one final `chat.postMessage` only).
+     */
+    streaming?: boolean;
+    /**
+     * Show task-style thinking steps for tool calls (stream chunks or status).
+     * Defaults to `true`.
+     */
+    thinkingSteps?: boolean;
+    /**
+     * Opt in to Slack delivery for human-in-the-loop tool approvals.
+     *
+     * Framework park/resume is enabled by `needsApproval` on server tools.
+     * Set this to `true` to also post Block Kit Approve/Deny cards and route
+     * the Socket Mode `interactive` clicks to `resolveApproval`. Socket Mode
+     * only — rejected on `cursorAccount: true` (the Cursor Slack connection
+     * does not relay Block Kit clicks).
+     *
+     * Defaults to `false`. For custom composition, spread
+     * `buildToolApprovalEvents({ credentials })` into `events`.
+     */
+    toolApprovals?: boolean;
+    /**
+     * Route interactive payloads to approval resolution without opting into
+     * the full {@link buildToolApprovalEvents} handler pack. Use when
+     * composing `buildToolApprovalEvents` into `events` manually. Socket Mode
+     * only — rejected on `cursorAccount: true`.
+     */
+    interactivity?: boolean;
+    /**
+     * Suggested prompts shown when an assistant thread starts (and optionally
+     * after a turn completes).
+     */
+    suggestedPrompts?: SlackSuggestedPrompt[];
+    suggestedPromptsTitle?: string;
+}
+export interface SlackManifestOptions {
+    /** Display name for the Slack app. */
+    name: string;
+    /** Bot display name (handle without @). Defaults from `name`. */
+    botDisplayName?: string;
+    /** Env profile. Affects display name suffix. */
+    env: "dev" | "prod";
+    /** Optional short description shown in the Slack app. */
+    description?: string;
+    /** Include `assistant_view` + `assistant:write` for typing status. */
+    assistant?: boolean;
+    /**
+     * Enable Slack interactivity (needed for Approve/Deny cards).
+     * Defaults to `false` — enable when using `toolApprovals: true`.
+     */
+    interactivity?: boolean;
+    /**
+     * Subscribe to `message.channels` + `message.groups` for the opt-in
+     * channel watch (`engagement.channelPosts`). Defaults to `false`.
+     */
+    channelPosts?: boolean;
+    /** Seed suggested prompts into the manifest `assistant_view`. */
+    suggestedPrompts?: Array<{
+        title: string;
+        message: string;
+    }>;
+}
+/** Soft-fail result for optional Slack API features. */
+export type SoftSlackResult<T extends Record<string, unknown> = Record<string, unknown>> = ({
+    ok: true;
+} & T) | {
+    ok: false;
+    error: string;
+    unsupported?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map