@cursor/bdk 0.2.2 → 0.2.4

package/src/channels/slack/api.ts

@@ -1,761 +0,0 @@
-/**
- * Slack Web API helpers used by the channel pack (`@slack/web-api`).
- */
-
-import { ErrorCode, type WebAPIPlatformError, WebClient } from "@slack/web-api";
-import { slackifyMarkdown } from "slackify-markdown";
-import { slackThreadKey } from "../../internal/slack-thread-key.js";
-import type { ArtifactsApi, HostContext } from "../../types.js";
-import { highlightCodeFences } from "./code-fences.js";
-import {
-  SLACK_DEFAULT_LOADING_MESSAGES,
-  SLACK_LOADING_MESSAGE_MAX_LEN,
-  SLACK_LOADING_MESSAGES_MAX,
-  SLACK_STATUS_MAX_LEN,
-  SLACK_TITLE_MAX_LEN,
-  SLACK_TYPING_MIN_INTERVAL_MS,
-  SLACK_UNSUPPORTED_ERRORS,
-} from "./constants.js";
-import { tryResolveAppToken, tryResolveBotToken } from "./credentials.js";
-import { defaultSlackLog, type SlackLog } from "./log.js";
-import type { StreamChunk } from "./stream.js";
-import type {
-  SlackApiTransport,
-  SlackBinding,
-  SlackBotToken,
-  SlackCredentials,
-  SlackSuggestedPrompt,
-  SoftSlackResult,
-} from "./types.js";
-
-/** Whether a bot token slot holds an API transport instead of a token. */
-export function isSlackApiTransport(token: SlackBotToken | undefined): token is SlackApiTransport {
-  return (
-    typeof token === "object" &&
-    token !== null &&
-    (token as SlackApiTransport).kind === "api-transport"
-  );
-}
-
-export async function resolveBotToken(credentials: SlackCredentials | undefined): Promise<string> {
-  const token = await tryResolveBotToken(credentials);
-  if (token === undefined) {
-    throw new Error(
-      "SLACK_BOT_TOKEN is required (set credentials.botToken, envPrefix, or the env var).",
-    );
-  }
-  return token;
-}
-
-/** Resolve the Socket Mode app-level token (`xapp-…`). */
-export async function resolveAppToken(credentials: SlackCredentials | undefined): Promise<string> {
-  const token = await tryResolveAppToken(credentials);
-  if (token === undefined) {
-    throw new Error(
-      "SLACK_APP_TOKEN is required for Socket Mode (set credentials.appToken, envPrefix, or the env var).",
-    );
-  }
-  return token;
-}
-
-/** Channel-local continuation key. IMs are the channel; threads keep ts. */
-export function slackContinuationKey(channelId: string, threadTs: string): string {
-  return slackThreadKey(channelId, threadTs);
-}
-
-function isPlatformError(error: unknown): error is WebAPIPlatformError {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    (error as { code: unknown }).code === ErrorCode.PlatformError &&
-    "data" in error
-  );
-}
-
-async function createWebClient(botToken: SlackBotToken | undefined): Promise<WebClient> {
-  return new WebClient(await resolveBotToken({ botToken }));
-}
-
-/**
- * Call a Slack Web API method. Platform errors (`ok: false`) are returned as
- * the response body (not thrown) so callers can soft-fail cleanly. When the
- * bot token slot holds a {@link SlackApiTransport} (e.g. the Cursor account
- * proxy), the call is executed by the transport instead of `@slack/web-api`.
- */
-export async function callSlackApi(args: {
-  botToken: SlackBotToken | undefined;
-  operation: string;
-  body: Record<string, unknown>;
-}): Promise<Record<string, unknown>> {
-  if (isSlackApiTransport(args.botToken)) {
-    return args.botToken.call(args.operation, args.body);
-  }
-  const client = await createWebClient(args.botToken);
-  try {
-    const result = await client.apiCall(args.operation, args.body);
-    return result as unknown as Record<string, unknown>;
-  } catch (error) {
-    if (isPlatformError(error)) {
-      return error.data as unknown as Record<string, unknown>;
-    }
-    throw error;
-  }
-}
-
-/**
- * Soft-fail wrapper: never throws for Slack API errors. Network/throw
- * errors become `{ ok: false, error }`. Unsupported feature errors set
- * `unsupported: true`.
- */
-export async function callSlackApiSoft(args: {
-  botToken: SlackBotToken | undefined;
-  operation: string;
-  body: Record<string, unknown>;
-}): Promise<SoftSlackResult> {
-  try {
-    const response = await callSlackApi(args);
-    if (response.ok === true) {
-      return { ok: true, ...response };
-    }
-    const error = typeof response.error === "string" ? response.error : "unknown_error";
-    return {
-      ok: false,
-      error,
-      ...(SLACK_UNSUPPORTED_ERRORS.has(error) ? { unsupported: true } : {}),
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-export function truncateTypingStatus(status: string, max?: number): string {
-  const limit = max ?? SLACK_STATUS_MAX_LEN;
-  const trimmed = status.trim().replace(/\s+/g, " ");
-  if (trimmed.length <= limit) {
-    return trimmed;
-  }
-  return `${trimmed.slice(0, limit - 1)}…`;
-}
-
-/**
- * Slack caps `loading_messages` at 5. When the cleaned list is longer,
- * send a wrapping time-based window of 5 so later strings still appear.
- */
-export function truncateLoadingMessages(messages: string[], nowMs: number = Date.now()): string[] {
-  const cleaned = messages
-    .map(message => truncateTypingStatus(message, SLACK_LOADING_MESSAGE_MAX_LEN))
-    .filter(message => message.length > 0);
-  if (cleaned.length <= SLACK_LOADING_MESSAGES_MAX) {
-    return cleaned;
-  }
-  const start = Math.floor(nowMs / SLACK_TYPING_MIN_INTERVAL_MS) % cleaned.length;
-  const window: string[] = [];
-  for (let i = 0; i < SLACK_LOADING_MESSAGES_MAX; i++) {
-    const message = cleaned[(start + i) % cleaned.length];
-    if (message === undefined) {
-      break;
-    }
-    window.push(message);
-  }
-  return window;
-}
-
-export function truncateTitle(title: string, max?: number): string {
-  const limit = max ?? SLACK_TITLE_MAX_LEN;
-  const trimmed = title.trim().replace(/\s+/g, " ");
-  if (trimmed.length <= limit) {
-    return trimmed;
-  }
-  return `${trimmed.slice(0, limit - 1)}…`;
-}
-
-// ---------------------------------------------------------------------------
-// Assistant / stream helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Show or clear the status chip under the thread.
- *
- * Status text goes through `assistant.threads.setStatus` alone. The agent
- * session is only written when clearing: Agent UX ignores an empty assistant
- * status, so `agents.sessions.setStatus` `active` is what actually drops the
- * chip. That same write must not accompany status text — Slack applies it
- * asynchronously and it blanks the chip when it lands after the text, which
- * reads as flicker between updates. A `processing` write would be worse:
- * Agent UX paints its own generic "is working…" over the assistant text
- * while the session is `processing`. An open `chat.startStream` also flips
- * the session to `processing` on Slack's side, so status text only shows on
- * non-streaming turns. The empty assistant call stays for older workspaces.
- */
-export async function setThreadStatus(args: {
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  threadTs: string;
-  status: string;
-  loadingMessages?: string[];
-}): Promise<SoftSlackResult> {
-  if (args.channelId === "" || args.threadTs === "") {
-    return { ok: false, error: "missing_channel_or_thread" };
-  }
-  const status = truncateTypingStatus(args.status);
-  const body: Record<string, unknown> = {
-    channel_id: args.channelId,
-    thread_ts: args.threadTs,
-    status,
-  };
-
-  if (status.length > 0) {
-    const loadingRaw =
-      args.loadingMessages !== undefined && args.loadingMessages.length > 0
-        ? args.loadingMessages
-        : [status, ...SLACK_DEFAULT_LOADING_MESSAGES.filter(m => m !== status)];
-    const loading_messages = truncateLoadingMessages(loadingRaw);
-    if (loading_messages.length > 0) {
-      body.loading_messages = loading_messages;
-    }
-    return callSlackApiSoft({
-      botToken: args.botToken,
-      operation: "assistant.threads.setStatus",
-      body,
-    });
-  }
-
-  const sessionResult = await callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "agents.sessions.setStatus",
-    body: {
-      channel_id: args.channelId,
-      thread_ts: args.threadTs,
-      status: "active",
-    },
-  });
-  const assistantResult = await callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "assistant.threads.setStatus",
-    body,
-  });
-
-  if (sessionResult.ok) {
-    return sessionResult;
-  }
-  if (sessionResult.unsupported === true || assistantResult.ok) {
-    return assistantResult;
-  }
-  return sessionResult;
-}
-
-export async function setThreadTitle(args: {
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  threadTs: string;
-  title: string;
-}): Promise<SoftSlackResult> {
-  return callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "assistant.threads.setTitle",
-    body: {
-      channel_id: args.channelId,
-      thread_ts: args.threadTs,
-      title: truncateTitle(args.title),
-    },
-  });
-}
-
-export async function setSuggestedPrompts(args: {
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  threadTs?: string;
-  prompts: SlackSuggestedPrompt[];
-  title?: string;
-}): Promise<SoftSlackResult> {
-  const body: Record<string, unknown> = {
-    channel_id: args.channelId,
-    prompts: args.prompts.map(p => ({
-      title: p.title,
-      message: p.message,
-    })),
-  };
-  if (args.threadTs !== undefined && args.threadTs !== "") {
-    body.thread_ts = args.threadTs;
-  }
-  if (args.title !== undefined && args.title !== "") {
-    body.title = args.title;
-  }
-  return callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "assistant.threads.setSuggestedPrompts",
-    body,
-  });
-}
-
-export async function startChatStream(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  thread_ts?: string;
-  markdown_text?: string;
-  chunks?: StreamChunk[];
-  recipient_user_id?: string;
-  recipient_team_id?: string;
-}): Promise<SoftSlackResult<{ ts: string; channel: string }>> {
-  const body: Record<string, unknown> = {
-    channel: args.channel,
-  };
-  // Empty markdown_text is rejected or opens a stream the assistant pane
-  // never attaches. Recipients are required outside DMs.
-  if (args.thread_ts !== undefined && args.thread_ts !== "") {
-    body.thread_ts = args.thread_ts;
-  }
-  if (args.markdown_text !== undefined && args.markdown_text !== "") {
-    body.markdown_text = args.markdown_text;
-  }
-  if (args.chunks !== undefined && args.chunks.length > 0) {
-    body.chunks = args.chunks;
-  }
-  if (args.recipient_user_id !== undefined && args.recipient_user_id !== "") {
-    body.recipient_user_id = args.recipient_user_id;
-  }
-  if (args.recipient_team_id !== undefined && args.recipient_team_id !== "") {
-    body.recipient_team_id = args.recipient_team_id;
-  }
-  const result = await callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "chat.startStream",
-    body,
-  });
-  if (!result.ok) {
-    return result;
-  }
-  const ts = typeof result.ts === "string" ? result.ts : "";
-  const channel = typeof result.channel === "string" ? result.channel : args.channel;
-  if (ts === "") {
-    return { ok: false, error: "missing_ts" };
-  }
-  return { ok: true, ts, channel };
-}
-
-export async function appendChatStream(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  ts: string;
-  markdown_text?: string;
-  chunks?: StreamChunk[];
-}): Promise<SoftSlackResult> {
-  const body: Record<string, unknown> = {
-    channel: args.channel,
-    ts: args.ts,
-  };
-  if (args.markdown_text !== undefined) {
-    body.markdown_text = args.markdown_text;
-  }
-  if (args.chunks !== undefined && args.chunks.length > 0) {
-    body.chunks = args.chunks;
-  }
-  return callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "chat.appendStream",
-    body,
-  });
-}
-
-export async function stopChatStream(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  ts: string;
-  markdown_text?: string;
-  chunks?: StreamChunk[];
-  blocks?: unknown[];
-}): Promise<SoftSlackResult> {
-  const body: Record<string, unknown> = {
-    channel: args.channel,
-    ts: args.ts,
-  };
-  if (args.markdown_text !== undefined) {
-    body.markdown_text = args.markdown_text;
-  }
-  if (args.chunks !== undefined && args.chunks.length > 0) {
-    body.chunks = args.chunks;
-  }
-  if (args.blocks !== undefined && args.blocks.length > 0) {
-    body.blocks = args.blocks;
-  }
-  return callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "chat.stopStream",
-    body,
-  });
-}
-
-const SLACK_MRKDWN_LITERAL_PATTERN = /<(?:[@#!][^>\r\n]+|(?:https?|ftp|mailto|tel):[^>\r\n]+)>/gi;
-const SLACK_MRKDWN_LINK_PATTERN = /<https?:\/\/[^|>]+\|/;
-
-/**
- * Convert CommonMark accepted by `markdown_text` to Slack's legacy mrkdwn
- * without letting the CommonMark parser reinterpret Slack-native syntax.
- */
-export function markdownToSlackMrkdwn(markdown: string): string {
-  const literals: string[] = [];
-  const placeholder = (index: number): string => `\ue000SLACK_LITERAL_${index}\ue001`;
-  const protectedMarkdown = markdown.replace(SLACK_MRKDWN_LITERAL_PATTERN, literal => {
-    const index = literals.push(literal) - 1;
-    return placeholder(index);
-  });
-
-  let converted = slackifyMarkdown(protectedMarkdown);
-  if (!markdown.endsWith("\n") && converted.endsWith("\n")) {
-    converted = converted.slice(0, -1);
-  }
-  for (const [index, literal] of literals.entries()) {
-    converted = converted.replaceAll(placeholder(index), literal);
-  }
-  return converted;
-}
-
-function requiresMrkdwnText(text: string): boolean {
-  return text.includes("<!subteam^") || SLACK_MRKDWN_LINK_PATTERN.test(text);
-}
-
-export async function postMessage(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  text: string;
-  threadTs?: string;
-  blocks?: unknown[];
-  /**
-   * Skip `markdown_text` and post with plain `text` only (Deploy Buddy /
-   * host-report pattern). Prefer this for large structured bodies — Slack
-   * `markdown_text` hard-caps at 12k while `text` allows ~40k.
-   */
-  plainText?: boolean;
-  /** Slack message metadata (`{ event_type, event_payload }`). */
-  metadata?: Record<string, unknown>;
-}): Promise<{ ts: string; channel: string }> {
-  // Slack treats markdown_text as mutually exclusive with text and blocks
-  // (error: markdown_text_conflict). Prefer markdown when we have no
-  // blocks; with Block Kit or plainText, use text as body/fallback.
-  const base: Record<string, unknown> = {
-    channel: args.channel,
-    unfurl_links: false,
-    unfurl_media: false,
-  };
-  if (args.threadTs !== undefined && args.threadTs !== "") {
-    base.thread_ts = args.threadTs;
-  }
-  if (args.metadata !== undefined) {
-    base.metadata = args.metadata;
-  }
-  const hasBlocks = args.blocks !== undefined && args.blocks.length > 0;
-  const convertToMrkdwn = args.plainText !== true && !hasBlocks && requiresMrkdwnText(args.text);
-  // User-group mentions (`<!subteam^…>`) and Slack mrkdwn links
-  // (`<https://…|label>`) only render correctly via mrkdwn `text`,
-  // not `markdown_text`.
-  const useText = args.plainText === true || hasBlocks || convertToMrkdwn;
-
-  let response: Record<string, unknown>;
-  if (useText) {
-    response = await callSlackApi({
-      botToken: args.botToken,
-      operation: "chat.postMessage",
-      body: {
-        ...base,
-        text: convertToMrkdwn ? markdownToSlackMrkdwn(args.text) : args.text,
-        ...(hasBlocks ? { blocks: args.blocks } : {}),
-      },
-    });
-  } else {
-    response = await callSlackApi({
-      botToken: args.botToken,
-      operation: "chat.postMessage",
-      body: {
-        ...base,
-        markdown_text: highlightCodeFences(args.text),
-      },
-    });
-    // Older workspaces / scopes may not accept markdown_text — retry with text.
-    // Also fall back when markdown_text hits its 12k limit (msg_too_long) while
-    // plain text still allows up to ~40k.
-    if (
-      response.ok !== true &&
-      (response.error === "markdown_text_conflict" ||
-        response.error === "invalid_arguments" ||
-        response.error === "invalid_blocks" ||
-        response.error === "msg_too_long" ||
-        SLACK_UNSUPPORTED_ERRORS.has(String(response.error ?? "")))
-    ) {
-      response = await callSlackApi({
-        botToken: args.botToken,
-        operation: "chat.postMessage",
-        body: {
-          ...base,
-          text: markdownToSlackMrkdwn(args.text),
-        },
-      });
-    }
-  }
-  if (response.ok !== true) {
-    throw new Error(`Slack chat.postMessage failed: ${String(response.error ?? "unknown_error")}`);
-  }
-  // Slack requires thread_ts as a string. A numeric ts (JSON number) silently
-  // drops threading server-side — never coerce via Number.
-  const ts = typeof response.ts === "string" ? response.ts : "";
-  if (ts === "") {
-    throw new Error(`Slack chat.postMessage ok but missing string ts (got ${typeof response.ts})`);
-  }
-  // When we asked to thread, confirm Slack honored it — but only when the
-  // response includes a thread_ts. Some proxy / customize-username payloads
-  // omit `message.thread_ts` even for successful threaded posts; treating
-  // that as failure retries (or deletes) replies and leaves empty threads.
-  const requestedThreadTs = args.threadTs;
-  if (requestedThreadTs !== undefined && requestedThreadTs !== "") {
-    const message = response.message;
-    if (typeof message === "object" && message !== null && !Array.isArray(message)) {
-      const applied =
-        typeof (message as { thread_ts?: unknown }).thread_ts === "string"
-          ? (message as { thread_ts: string }).thread_ts
-          : "";
-      if (applied !== "" && applied !== requestedThreadTs) {
-        throw new Error(
-          `Slack chat.postMessage ignored thread_ts (requested ${requestedThreadTs}, got ${applied})`,
-        );
-      }
-    }
-  }
-  // Slack returns the resolved channel ID (C…) even when the request used a name.
-  const channel =
-    typeof response.channel === "string" && response.channel !== ""
-      ? response.channel
-      : args.channel;
-  return { ts, channel };
-}
-
-/** Replace an existing message (e.g. strip Approve/Deny after a decision). */
-export async function updateMessage(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  ts: string;
-  text: string;
-  blocks?: unknown[];
-  /** Skip `markdown_text` and update with plain `text` only. */
-  plainText?: boolean;
-}): Promise<SoftSlackResult> {
-  const base: Record<string, unknown> = {
-    channel: args.channel,
-    ts: args.ts,
-  };
-  const useRawText = args.blocks !== undefined || args.plainText === true;
-  const convertToMrkdwn = !useRawText && requiresMrkdwnText(args.text);
-  if (useRawText || convertToMrkdwn) {
-    // Blocks / plainText / user-group mentions / mrkdwn links force the
-    // legacy text path (same as postMessage).
-    return callSlackApiSoft({
-      botToken: args.botToken,
-      operation: "chat.update",
-      body: {
-        ...base,
-        text: convertToMrkdwn ? markdownToSlackMrkdwn(args.text) : args.text,
-        ...(args.blocks !== undefined ? { blocks: args.blocks } : {}),
-      },
-    });
-  }
-  let result = await callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "chat.update",
-    body: {
-      ...base,
-      markdown_text: args.text,
-    },
-  });
-  // Older workspaces / scopes may not accept markdown_text — retry with text.
-  // Also fall back when markdown_text hits its 12k limit (msg_too_long).
-  if (
-    !result.ok &&
-    (result.error === "markdown_text_conflict" ||
-      result.error === "invalid_arguments" ||
-      result.error === "invalid_blocks" ||
-      result.error === "msg_too_long" ||
-      SLACK_UNSUPPORTED_ERRORS.has(String(result.error ?? "")))
-  ) {
-    result = await callSlackApiSoft({
-      botToken: args.botToken,
-      operation: "chat.update",
-      body: {
-        ...base,
-        text: markdownToSlackMrkdwn(args.text),
-      },
-    });
-  }
-  return result;
-}
-
-/**
- * Delete a message (`chat.delete`). Soft-fails — used best-effort to remove an
- * orphaned skeleton before falling back to a fresh post, so a failed delete
- * never blocks delivery of the reply.
- */
-export async function deleteMessage(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  ts: string;
-}): Promise<SoftSlackResult> {
-  if (args.channel === "" || args.ts === "") {
-    return { ok: false, error: "missing_channel_or_ts" };
-  }
-  return callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "chat.delete",
-    body: {
-      channel: args.channel,
-      ts: args.ts,
-    },
-  });
-}
-
-/** Add an emoji reaction (`reactions.add`). Soft-fails. */
-export async function addReaction(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  ts: string;
-  name: string;
-}): Promise<SoftSlackResult> {
-  if (args.channel === "" || args.ts === "" || args.name === "") {
-    return { ok: false, error: "missing_channel_ts_or_name" };
-  }
-  return callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "reactions.add",
-    body: {
-      channel: args.channel,
-      timestamp: args.ts,
-      name: args.name,
-    },
-  });
-}
-
-/** Remove an emoji reaction (`reactions.remove`). Soft-fails. */
-export async function removeReaction(args: {
-  botToken: SlackBotToken | undefined;
-  channel: string;
-  ts: string;
-  name: string;
-}): Promise<SoftSlackResult> {
-  if (args.channel === "" || args.ts === "" || args.name === "") {
-    return { ok: false, error: "missing_channel_ts_or_name" };
-  }
-  return callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "reactions.remove",
-    body: {
-      channel: args.channel,
-      timestamp: args.ts,
-      name: args.name,
-    },
-  });
-}
-
-export function buildSlackBinding(args: {
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  threadTs: string;
-  teamId?: string;
-  host: HostContext;
-  artifacts: ArtifactsApi;
-  onThreadTsChanged?: (threadTs: string) => void;
-  log?: SlackLog;
-}): SlackBinding {
-  let threadTs = args.threadTs;
-  const log = args.log ?? defaultSlackLog;
-
-  const thread = {
-    async post(text: string, options?: { blocks?: unknown[] }): Promise<{ ts: string }> {
-      const result = await postMessage({
-        botToken: args.botToken,
-        channel: args.channelId,
-        text,
-        threadTs,
-        ...(options?.blocks === undefined ? {} : { blocks: options.blocks }),
-      });
-      if (result.ts !== "" && threadTs === "") {
-        threadTs = result.ts;
-        args.onThreadTsChanged?.(result.ts);
-      }
-      log.info("postMessage ok", {
-        channel: args.channelId,
-        thread_ts: threadTs,
-        message_ts: result.ts,
-      });
-      return { ts: result.ts };
-    },
-    async startTyping(status: string, loadingMessages?: string[]): Promise<void> {
-      if (args.channelId === "" || threadTs === "") {
-        return;
-      }
-      const result = await setThreadStatus({
-        botToken: args.botToken,
-        channelId: args.channelId,
-        threadTs,
-        status,
-        ...(loadingMessages === undefined ? {} : { loadingMessages }),
-      });
-      if (!result.ok) {
-        log.warn("slack setStatus not-ok", {
-          error: result.error,
-          channel: args.channelId,
-          thread_ts: threadTs,
-        });
-      }
-    },
-    async setTitle(title: string): Promise<void> {
-      if (args.channelId === "" || threadTs === "") {
-        return;
-      }
-      const result = await setThreadTitle({
-        botToken: args.botToken,
-        channelId: args.channelId,
-        threadTs,
-        title,
-      });
-      if (!result.ok) {
-        log.warn("assistant.threads.setTitle not-ok", {
-          error: result.error,
-          channel: args.channelId,
-          thread_ts: threadTs,
-        });
-      }
-    },
-    async setSuggestedPrompts(prompts: SlackSuggestedPrompt[], title?: string): Promise<void> {
-      if (args.channelId === "" || threadTs === "" || prompts.length === 0) {
-        return;
-      }
-      const result = await setSuggestedPrompts({
-        botToken: args.botToken,
-        channelId: args.channelId,
-        threadTs,
-        prompts,
-        ...(title === undefined ? {} : { title }),
-      });
-      if (!result.ok) {
-        log.warn("assistant.threads.setSuggestedPrompts not-ok", {
-          error: result.error,
-          channel: args.channelId,
-          thread_ts: threadTs,
-        });
-      }
-    },
-  };
-
-  return {
-    thread,
-    slack: {
-      channelId: args.channelId,
-      get threadTs() {
-        return threadTs;
-      },
-      ...(args.teamId === undefined ? {} : { teamId: args.teamId }),
-    },
-    host: args.host,
-    artifacts: args.artifacts,
-  };
-}