@openparachute/agent 0.1.2 → 0.2.2

package/src/channels/chat-sdk-bridge.ts

@@ -1,652 +0,0 @@
-/**
- * Chat SDK bridge — wraps a Chat SDK adapter + Chat instance
- * to conform to the Paraclaw ChannelAdapter interface.
- *
- * Used by Discord, Slack, and other Chat SDK-supported platforms.
- */
-import http from 'http';
-
-import {
-  Chat,
-  Card,
-  CardText,
-  Actions,
-  Button,
-  type Adapter,
-  type ConcurrencyStrategy,
-  type Message as ChatMessage,
-} from 'chat';
-import { log } from '../log.js';
-import { SqliteStateAdapter } from '../state-sqlite.js';
-import { registerWebhookAdapter } from '../webhook-server.js';
-import { getAskQuestionRender } from '../db/sessions.js';
-import { encodePlatformId } from '../platform-id.js';
-import { normalizeOptions, type NormalizedOption } from './ask-question.js';
-import type { ChannelAdapter, ChannelSetup, InboundMessage } from './adapter.js';
-
-/** Adapter with optional gateway support (e.g., Discord). */
-interface GatewayAdapter extends Adapter {
-  startGatewayListener?(
-    options: { waitUntil?: (task: Promise<unknown>) => void },
-    durationMs?: number,
-    abortSignal?: AbortSignal,
-    webhookUrl?: string,
-  ): Promise<Response>;
-}
-
-/** Reply context extracted from a platform's raw message. */
-export interface ReplyContext {
-  text: string;
-  sender: string;
-}
-
-/** Extract reply context from a platform-specific raw message. Return null if no reply. */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ReplyContextExtractor = (raw: Record<string, any>) => ReplyContext | null;
-
-export interface ChatSdkBridgeConfig {
-  adapter: Adapter;
-  concurrency?: ConcurrencyStrategy;
-  /**
-   * Bot identity for v2 platform_id encoding. The bridge prefixes inbound
-   * platform_ids with `<botId>` so multiple bots on the same channel
-   * (e.g. two Telegram bots in the same install) route to distinct
-   * messaging_groups rows. Outbound deliveries strip the bot dim back out
-   * before handing to the SDK adapter, which only knows the v1 form.
-   *
-   * Rationale: see src/platform-id.ts module comment.
-   */
-  botId: string;
-  /** Bot token for authenticating forwarded Gateway events (required for interaction handling). */
-  botToken?: string;
-  /** Platform-specific reply context extraction. */
-  extractReplyContext?: ReplyContextExtractor;
-  /**
-   * Whether this platform uses threads as the primary conversation unit.
-   * See `ChannelAdapter.supportsThreads`. Declared by the calling channel
-   * skill, not inferred, because some platforms (Discord) can be used either
-   * way and the default depends on installation style.
-   */
-  supportsThreads: boolean;
-  /**
-   * Optional transform applied to outbound text/markdown before it reaches the
-   * adapter. Used by channels that need to sanitize for a platform-specific
-   * quirk (e.g. Telegram's legacy Markdown parse mode).
-   */
-  transformOutboundText?: (text: string) => string;
-  /**
-   * Maximum text length the underlying adapter accepts in a single message.
-   * When set, the bridge splits outbound text longer than this on paragraph
-   * → line → hard-char boundaries and posts multiple messages. Without this,
-   * adapters like Discord (2000) and Telegram (4096) silently truncate
-   * mid-response. The returned id is the first chunk's id so subsequent edits
-   * and reactions still target the head of the reply.
-   */
-  maxTextLength?: number;
-}
-
-/**
- * Split `text` into chunks no larger than `limit`, preferring paragraph
- * breaks, then line breaks, then a hard character cut as a last resort.
- * Preserves code fences only structurally — a fenced block that straddles a
- * chunk boundary will render as two independent blocks on the receiving
- * platform, which is the same behavior as manually re-opening a fence.
- */
-/**
- * Decode the actual option value from a button callback. Buttons are encoded
- * with an integer index (to keep under Telegram's 64-byte callback_data cap),
- * and the real value is looked up via `getAskQuestionRender(questionId)`.
- * Falls back to treating the tail as a literal value so old in-flight cards
- * (encoded before this shortening landed) still resolve.
- */
-function resolveSelectedOption(
-  render: { options: NormalizedOption[] } | undefined,
-  eventValue: string | undefined,
-  tail: string | undefined,
-): string {
-  const candidate = eventValue ?? tail ?? '';
-  if (render && /^\d+$/.test(candidate)) {
-    const idx = Number(candidate);
-    if (render.options[idx]) return render.options[idx].value;
-  }
-  return candidate;
-}
-
-export function splitForLimit(text: string, limit: number): string[] {
-  if (text.length <= limit) return [text];
-  const chunks: string[] = [];
-  let remaining = text;
-  while (remaining.length > limit) {
-    let cut = remaining.lastIndexOf('\n\n', limit);
-    if (cut <= 0) cut = remaining.lastIndexOf('\n', limit);
-    if (cut <= 0) cut = remaining.lastIndexOf(' ', limit);
-    if (cut <= 0) cut = limit;
-    chunks.push(remaining.slice(0, cut).trimEnd());
-    remaining = remaining.slice(cut).trimStart();
-  }
-  if (remaining.length > 0) chunks.push(remaining);
-  return chunks;
-}
-
-export function createChatSdkBridge(config: ChatSdkBridgeConfig): ChannelAdapter {
-  const { adapter, botId } = config;
-  const transformText = (t: string): string => (config.transformOutboundText ? config.transformOutboundText(t) : t);
-
-  /**
-   * Insert the bot id into a v1 platform_id from the SDK.
-   * `<channel>:<native>` → `<channel>:<botId>:<native>`.
-   * If the input does not start with `<channel>:` (defensive — shouldn't
-   * happen for Chat-SDK-namespaced ids), it is returned unchanged.
-   */
-  function withBot(sdkPlatformId: string): string {
-    const colon = sdkPlatformId.indexOf(':');
-    if (colon === -1) return sdkPlatformId;
-    const channel = sdkPlatformId.slice(0, colon);
-    const native = sdkPlatformId.slice(colon + 1);
-    return encodePlatformId(channel, botId, native);
-  }
-
-  /**
-   * Inverse of {@link withBot}: strip the bot id from a v2 platform_id so
-   * the SDK adapter sees the form it produced. Tolerates already-v1 input
-   * (legacy queue rows that haven't been backfilled) — passes through.
-   */
-  function withoutBot(v2PlatformId: string): string {
-    const colon = v2PlatformId.indexOf(':');
-    if (colon === -1) return v2PlatformId;
-    const rest = v2PlatformId.slice(colon + 1);
-    if (rest.startsWith(`${botId}:`)) {
-      return `${v2PlatformId.slice(0, colon + 1)}${rest.slice(botId.length + 1)}`;
-    }
-    return v2PlatformId;
-  }
-  let chat: Chat;
-  let state: SqliteStateAdapter;
-  let setupConfig: ChannelSetup;
-  let gatewayAbort: AbortController | null = null;
-
-  async function messageToInbound(
-    message: ChatMessage,
-    isMention: boolean,
-    isGroup?: boolean,
-  ): Promise<InboundMessage> {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const serialized = message.toJSON() as Record<string, any>;
-
-    // Download attachment data before serialization loses fetchData()
-    if (message.attachments && message.attachments.length > 0) {
-      const enriched = [];
-      for (const att of message.attachments) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const entry: Record<string, any> = {
-          type: att.type,
-          name: att.name,
-          mimeType: att.mimeType,
-          size: att.size,
-          width: (att as unknown as Record<string, unknown>).width,
-          height: (att as unknown as Record<string, unknown>).height,
-        };
-        if (att.fetchData) {
-          try {
-            const buffer = await att.fetchData();
-            entry.data = buffer.toString('base64');
-          } catch (err) {
-            log.warn('Failed to download attachment', { type: att.type, err });
-          }
-        }
-        enriched.push(entry);
-      }
-      serialized.attachments = enriched;
-    }
-
-    // Extract reply context via platform-specific hook
-    if (config.extractReplyContext && message.raw) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const replyTo = config.extractReplyContext(message.raw as Record<string, any>);
-      if (replyTo) serialized.replyTo = replyTo;
-    }
-
-    // Project chat-sdk's nested author into the flat sender fields the router
-    // expects (see src/router.ts extractAndUpsertUser). Native adapters already
-    // populate these directly; this brings chat-sdk adapters in line.
-    const author = serialized.author as { userId?: string; fullName?: string; userName?: string } | undefined;
-    if (author) {
-      const name = author.fullName ?? author.userName;
-      serialized.senderId = author.userId;
-      serialized.sender = name;
-      serialized.senderName = name;
-    }
-
-    // Drop raw to save DB space (can be very large)
-    serialized.raw = undefined;
-
-    return {
-      id: message.id,
-      kind: 'chat-sdk',
-      content: serialized,
-      timestamp: message.metadata.dateSent.toISOString(),
-      isMention,
-      isGroup,
-    };
-  }
-
-  const bridge: ChannelAdapter = {
-    name: adapter.name,
-    channelType: adapter.name,
-    supportsThreads: config.supportsThreads,
-
-    async setup(hostConfig: ChannelSetup) {
-      setupConfig = hostConfig;
-
-      state = new SqliteStateAdapter();
-
-      chat = new Chat({
-        adapters: { [adapter.name]: adapter },
-        userName: adapter.userName || 'Parachute Agent',
-        concurrency: config.concurrency ?? 'concurrent',
-        state,
-        logger: 'silent',
-      });
-
-      // Four SDK dispatch paths — bridge just forwards. All per-wiring
-      // engage / accumulate / drop / subscribe decisions live in the host
-      // router (src/router.ts routeInbound / evaluateEngage). The bridge
-      // only resolves channel ids and sets the platform-confirmed isMention
-      // flag that routeInbound evaluates; the router calls back into
-      // bridge.subscribe(...) when a mention-sticky wiring engages.
-
-      // Subscribed threads — every message in a thread we've previously
-      // engaged. Carry the SDK's `message.isMention` through so mention-mode
-      // wirings still fire on in-thread mentions.
-      chat.onSubscribedMessage(async (thread, message) => {
-        const channelId = withBot(adapter.channelIdFromThreadId(thread.id));
-        await setupConfig.onInbound(
-          channelId,
-          thread.id,
-          await messageToInbound(message, message.isMention === true, true),
-        );
-      });
-
-      // @mention in an unsubscribed thread — SDK-confirmed bot mention.
-      chat.onNewMention(async (thread, message) => {
-        const channelId = withBot(adapter.channelIdFromThreadId(thread.id));
-        await setupConfig.onInbound(channelId, thread.id, await messageToInbound(message, true, true));
-      });
-
-      // DMs — by definition addressed to the bot. Thread id flows through
-      // so sub-thread context reaches delivery (Slack users can open threads
-      // inside a DM). Router collapses DM sub-threads to one session via
-      // is_group=0 short-circuit.
-      chat.onDirectMessage(async (thread, message) => {
-        const channelId = withBot(adapter.channelIdFromThreadId(thread.id));
-        log.info('Inbound DM received', {
-          adapter: adapter.name,
-          channelId,
-          sender: (message.author as any)?.fullName ?? (message.author as any)?.userId ?? 'unknown',
-          threadId: thread.id,
-        });
-        await setupConfig.onInbound(channelId, thread.id, await messageToInbound(message, true, false));
-      });
-
-      // Plain messages in unsubscribed threads.
-      //
-      // Chat SDK dispatch (handling-events.mdx §"Handler dispatch order") is
-      // exclusive: subscribed → onSubscribedMessage; unsubscribed+mention →
-      // onNewMention; unsubscribed+pattern-match → onNewMessage. Registering
-      // with `/./` lets the router see every plain message on every
-      // unsubscribed thread the bot can see. The router short-circuits via
-      // getMessagingGroupWithAgentCount (~1 DB read) for unwired channels,
-      // so forwarding every one is cheap enough to not need a bridge-side
-      // flood gate.
-      chat.onNewMessage(/./, async (thread, message) => {
-        const channelId = withBot(adapter.channelIdFromThreadId(thread.id));
-        await setupConfig.onInbound(channelId, thread.id, await messageToInbound(message, false, true));
-      });
-
-      // Handle button clicks (ask_user_question)
-      chat.onAction(async (event) => {
-        if (!event.actionId.startsWith('ncq:')) return;
-        const parts = event.actionId.split(':');
-        if (parts.length < 3) return;
-        const questionId = parts[1];
-        const tail = parts.slice(2).join(':');
-        const userId = event.user?.userId || '';
-
-        // Resolve render metadata BEFORE dispatching onAction (which deletes the row).
-        const render = getAskQuestionRender(questionId);
-        // New format: button id/value is an integer index into options (kept
-        // short to fit Telegram's 64-byte callback_data cap). Old format:
-        // the full value is embedded in actionId/value directly.
-        const selectedOption = resolveSelectedOption(render, event.value, tail);
-        const title = render?.title ?? '❓ Question';
-        const matched = render?.options.find((o) => o.value === selectedOption);
-        const selectedLabel = matched?.selectedLabel ?? selectedOption ?? '(clicked)';
-
-        // Update the card to show the selected answer and remove buttons
-        try {
-          const tid = event.threadId;
-          await adapter.editMessage(tid, event.messageId, {
-            markdown: `${title}\n\n${selectedLabel}`,
-          });
-        } catch (err) {
-          log.warn('Failed to update card after action', { err });
-        }
-
-        setupConfig.onAction(questionId, selectedOption, userId);
-      });
-
-      await chat.initialize();
-
-      // Start Gateway listener for adapters that support it (e.g., Discord)
-      const gatewayAdapter = adapter as GatewayAdapter;
-      if (gatewayAdapter.startGatewayListener) {
-        gatewayAbort = new AbortController();
-
-        // Start local HTTP server to receive forwarded Gateway events (including interactions)
-        const webhookUrl = await startLocalWebhookServer(gatewayAdapter, setupConfig, config.botToken);
-
-        const startGateway = () => {
-          if (gatewayAbort?.signal.aborted) return;
-          // Capture the long-running listener promise via waitUntil
-          let listenerPromise: Promise<unknown> | undefined;
-          gatewayAdapter.startGatewayListener!(
-            {
-              waitUntil: (p: Promise<unknown>) => {
-                listenerPromise = p;
-              },
-            },
-            24 * 60 * 60 * 1000,
-            gatewayAbort!.signal,
-            webhookUrl,
-          ).then(() => {
-            // startGatewayListener resolves immediately with a Response;
-            // the actual work is in the listenerPromise passed to waitUntil
-            if (listenerPromise) {
-              listenerPromise
-                .then(() => {
-                  if (!gatewayAbort?.signal.aborted) {
-                    log.info('Gateway listener expired, restarting', { adapter: adapter.name });
-                    startGateway();
-                  }
-                })
-                .catch((err) => {
-                  if (!gatewayAbort?.signal.aborted) {
-                    log.error('Gateway listener error, restarting in 5s', { adapter: adapter.name, err });
-                    setTimeout(startGateway, 5000);
-                  }
-                });
-            }
-          });
-        };
-        startGateway();
-        log.info('Gateway listener started', { adapter: adapter.name });
-      } else {
-        // Non-gateway adapters (Slack, Teams, GitHub, etc.) — register on the shared webhook server
-        registerWebhookAdapter(chat, adapter.name);
-      }
-
-      log.info('Chat SDK bridge initialized', { adapter: adapter.name });
-    },
-
-    async deliver(platformId: string, threadId: string | null, message): Promise<string | undefined> {
-      // platformId arrives in v2 form (`<channel>:<botId>:<native>`); the SDK
-      // adapter only understands v1 (`<channel>:<native>`), so strip the bot
-      // dim before using it as the thread id. threadId, when present, is
-      // already an SDK-native thread id and goes through unchanged.
-      const tid = threadId ?? withoutBot(platformId);
-      const content = message.content as Record<string, unknown>;
-
-      if (content.operation === 'edit' && content.messageId) {
-        await adapter.editMessage(tid, content.messageId as string, {
-          markdown: transformText((content.text as string) || (content.markdown as string) || ''),
-        });
-        return;
-      }
-
-      if (content.operation === 'reaction' && content.messageId && content.emoji) {
-        await adapter.addReaction(tid, content.messageId as string, content.emoji as string);
-        return;
-      }
-
-      // Ask question card — render as Card with buttons
-      if (content.type === 'ask_question' && content.questionId && content.options) {
-        const questionId = content.questionId as string;
-        const title = content.title as string;
-        const question = content.question as string;
-        if (!title) {
-          log.error('ask_question missing required title — skipping delivery', { questionId });
-          return;
-        }
-        const options: NormalizedOption[] = normalizeOptions(content.options as never);
-        const card = Card({
-          title,
-          children: [
-            CardText(question),
-            Actions(
-              // Encode button id/value with the option index rather than the
-              // full value. Telegram caps callback_data at 64 bytes, and
-              // long values (e.g. ISO datetimes, URLs) push the JSON payload
-              // well past that. The onAction handlers resolve the index back
-              // to the real value via getAskQuestionRender(questionId).
-              options.map((opt, idx) =>
-                Button({ id: `ncq:${questionId}:${idx}`, label: opt.label, value: String(idx) }),
-              ),
-            ),
-          ],
-        });
-        const result = await adapter.postMessage(tid, {
-          card,
-          fallbackText: `${title}\n\n${question}\nOptions: ${options.map((o) => o.label).join(', ')}`,
-        });
-        return result?.id;
-      }
-
-      // Normal message
-      const rawText = (content.markdown as string) || (content.text as string);
-      const text = rawText ? transformText(rawText) : rawText;
-      if (text) {
-        // Attach files if present (FileUpload format: { data, filename })
-        const fileUploads = message.files?.map((f: { data: Buffer; filename: string }) => ({
-          data: f.data,
-          filename: f.filename,
-        }));
-        // Split if over the adapter's max length. Files ride on the first
-        // chunk so the head of the reply still carries them.
-        const chunks =
-          config.maxTextLength && text.length > config.maxTextLength
-            ? splitForLimit(text, config.maxTextLength)
-            : [text];
-        let firstId: string | undefined;
-        for (let i = 0; i < chunks.length; i++) {
-          const chunk = chunks[i];
-          const attachFiles = i === 0 && fileUploads && fileUploads.length > 0;
-          const result = await adapter.postMessage(
-            tid,
-            attachFiles ? { markdown: chunk, files: fileUploads } : { markdown: chunk },
-          );
-          if (i === 0) firstId = result?.id;
-        }
-        return firstId;
-      } else if (message.files && message.files.length > 0) {
-        // Files only, no text
-        const fileUploads = message.files.map((f: { data: Buffer; filename: string }) => ({
-          data: f.data,
-          filename: f.filename,
-        }));
-        const result = await adapter.postMessage(tid, { markdown: '', files: fileUploads });
-        return result?.id;
-      }
-    },
-
-    async setTyping(platformId: string, threadId: string | null) {
-      const tid = threadId ?? withoutBot(platformId);
-      await adapter.startTyping(tid);
-    },
-
-    async teardown() {
-      gatewayAbort?.abort();
-      await chat.shutdown();
-      log.info('Chat SDK bridge shut down', { adapter: adapter.name });
-    },
-
-    isConnected() {
-      return true;
-    },
-
-    async subscribe(_platformId: string, threadId: string) {
-      // Chat SDK's subscription state lives on the StateAdapter (not on the
-      // Chat instance itself). SqliteStateAdapter.subscribe is idempotent —
-      // a second call on an already-subscribed thread is a no-op. threadId
-      // is the SDK's thread id, which is what the router already has from
-      // the original inbound event.
-      await state.subscribe(threadId);
-    },
-  };
-
-  // Only expose openDM when the underlying Chat SDK adapter implements it.
-  // Delegate straight to adapter.openDM rather than going through chat.openDM:
-  // the latter dispatches via inferAdapterFromUserId, which only recognizes
-  // Discord snowflakes, Slack U-ids, Teams 29:-ids, and gChat users/-ids, and
-  // throws for everything else (Telegram numeric ids, iMessage, Matrix, …).
-  // Calling adapter.openDM directly also preserves the adapter's native
-  // platform_id encoding via channelIdFromThreadId (e.g. "telegram:<chatId>"),
-  // which matches what onInbound stores in messaging_groups — avoiding a
-  // duplicate-row / decode-error cascade at delivery time. See user-dm.ts for
-  // the direct-addressable fallback when the adapter has no openDM at all.
-  if (adapter.openDM) {
-    bridge.openDM = async (userHandle: string): Promise<string> => {
-      const threadId = await adapter.openDM!(userHandle);
-      return withBot(adapter.channelIdFromThreadId(threadId));
-    };
-  }
-
-  return bridge;
-}
-
-/**
- * Start a local HTTP server to receive forwarded Gateway events.
- * This is needed because the Gateway listener in webhook-forwarding mode
- * sends ALL raw events (including INTERACTION_CREATE for button clicks)
- * to the webhookUrl, which we handle here.
- */
-function startLocalWebhookServer(
-  adapter: GatewayAdapter,
-  setupConfig: ChannelSetup,
-  botToken?: string,
-): Promise<string> {
-  return new Promise((resolve) => {
-    const server = http.createServer((req, res) => {
-      const chunks: Buffer[] = [];
-      req.on('data', (chunk: Buffer) => chunks.push(chunk));
-      req.on('end', () => {
-        const body = Buffer.concat(chunks).toString();
-        handleForwardedEvent(body, adapter, setupConfig, botToken)
-          .then(() => {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end('{"ok":true}');
-          })
-          .catch((err) => {
-            log.error('Webhook server error', { err });
-            res.writeHead(500);
-            res.end('{"error":"internal"}');
-          });
-      });
-    });
-
-    server.listen(0, '127.0.0.1', () => {
-      const addr = server.address() as { port: number };
-      const url = `http://127.0.0.1:${addr.port}/webhook`;
-      log.info('Local webhook server started', { port: addr.port });
-      resolve(url);
-    });
-  });
-}
-
-async function handleForwardedEvent(
-  body: string,
-  adapter: GatewayAdapter,
-  setupConfig: ChannelSetup,
-  botToken?: string,
-): Promise<void> {
-  let event: { type: string; data: Record<string, unknown> };
-  try {
-    event = JSON.parse(body);
-  } catch {
-    return;
-  }
-
-  // Handle interaction events (button clicks) — not handled by adapter's handleForwardedGatewayEvent
-  if (event.type === 'GATEWAY_INTERACTION_CREATE' && event.data) {
-    const interaction = event.data;
-    // type 3 = MessageComponent (button/select)
-    if (interaction.type === 3) {
-      const customId = (interaction.data as Record<string, unknown>)?.custom_id as string;
-      // In guilds the clicker is at interaction.member.user; in DMs it's interaction.user directly.
-      const user =
-        ((interaction.member as Record<string, unknown>)?.user as Record<string, string> | undefined) ??
-        (interaction.user as Record<string, string> | undefined);
-      const interactionId = interaction.id as string;
-      const interactionToken = interaction.token as string;
-
-      // Parse the selected option from custom_id
-      let questionId: string | undefined;
-      let tail: string | undefined;
-      if (customId?.startsWith('ncq:')) {
-        const colonIdx = customId.indexOf(':', 4); // after "ncq:"
-        if (colonIdx !== -1) {
-          questionId = customId.slice(4, colonIdx);
-          tail = customId.slice(colonIdx + 1);
-        }
-      }
-
-      // Update the card to show the selected answer and remove buttons
-      const originalEmbeds =
-        ((interaction.message as Record<string, unknown>)?.embeds as Array<Record<string, unknown>>) || [];
-      const originalDescription = (originalEmbeds[0]?.description as string) || '';
-      const render = questionId ? getAskQuestionRender(questionId) : undefined;
-      // Discord custom_id mirrors the new index-based encoding (see Button
-      // construction). Decode back to the real option value for downstream.
-      const selectedOption = resolveSelectedOption(render, tail, tail);
-      const cardTitle = render?.title ?? ((originalEmbeds[0]?.title as string) || '❓ Question');
-      const matchedOpt = render?.options.find((o) => o.value === selectedOption);
-      const selectedLabel = matchedOpt?.selectedLabel ?? selectedOption ?? customId;
-      try {
-        await fetch(`https://discord.com/api/v10/interactions/${interactionId}/${interactionToken}/callback`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            type: 7, // UPDATE_MESSAGE — acknowledge + update in one call
-            data: {
-              embeds: [
-                {
-                  title: cardTitle,
-                  description: `${originalDescription}\n\n${selectedLabel}`,
-                },
-              ],
-              components: [], // remove buttons
-            },
-          }),
-        });
-      } catch (err) {
-        log.error('Failed to update interaction', { err });
-      }
-
-      // Dispatch to host
-      if (questionId && selectedOption) {
-        setupConfig.onAction(questionId, selectedOption, user?.id || '');
-      }
-      return;
-    }
-  }
-
-  // Forward other events to the adapter's webhook handler for normal processing
-  const fakeRequest = new Request('http://localhost/webhook', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-discord-gateway-token': botToken || '',
-    },
-    body,
-  });
-  await adapter.handleWebhook(fakeRequest, {});
-}