@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/mcp/workspace-mcp-config.ts

@@ -0,0 +1,188 @@
+/**
+ * User-owned MCP servers in `$VELLUM_WORKSPACE_DIR/mcp.json`.
+ *
+ * The file is an Agent Plugins 1.0.0 document (`$schema` + `mcpServers`).
+ * This module is the only reader and writer of that file. Presence of a
+ * server starts it. Headers are never persisted here.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+
+import type { McpConfig, McpServerConfig } from "../config/schemas/mcp.js";
+import { McpConfigSchema } from "../config/schemas/mcp.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceMcpConfigPath } from "../util/platform.js";
+import {
+  AGENT_PLUGINS_MCP_SCHEMA_URL,
+  projectSpecServerToTransport,
+  projectTransportToSpecServer,
+  SpecMcpDocumentSchema,
+  SpecMcpServerSchema,
+} from "./spec-schema.js";
+
+const log = getLogger("workspace-mcp-config");
+
+export type WorkspaceMcpFileState = "missing" | "ok" | "invalid";
+
+export interface WorkspaceMcpLoadResult {
+  readonly config: McpConfig;
+  readonly issues: readonly string[];
+  readonly fileState: WorkspaceMcpFileState;
+}
+
+/**
+ * Read `/workspace/mcp.json` and project it onto the in-memory MCP config.
+ *
+ * A missing file is an empty server map. An invalid file disables the
+ * workspace half only (plugin servers still load) and is reported so a
+ * write can refuse to overwrite it.
+ */
+export function readWorkspaceMcpFile(
+  path: string = getWorkspaceMcpConfigPath(),
+): WorkspaceMcpLoadResult {
+  if (!existsSync(path)) {
+    return {
+      config: McpConfigSchema.parse({}),
+      issues: [],
+      fileState: "missing",
+    };
+  }
+
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (err) {
+    const message = `mcp.json unreadable: ${err instanceof Error ? err.message : String(err)}`;
+    return {
+      config: McpConfigSchema.parse({}),
+      issues: [message],
+      fileState: "invalid",
+    };
+  }
+
+  let json: unknown;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    const message = `mcp.json invalid JSON: ${err instanceof Error ? err.message : String(err)}`;
+    return {
+      config: McpConfigSchema.parse({}),
+      issues: [message],
+      fileState: "invalid",
+    };
+  }
+
+  const document = SpecMcpDocumentSchema.safeParse(json);
+  if (!document.success) {
+    return {
+      config: McpConfigSchema.parse({}),
+      issues: ['mcp.json is missing a valid "mcpServers" object'],
+      fileState: "invalid",
+    };
+  }
+
+  const servers: Record<string, McpServerConfig> = {};
+  const issues: string[] = [];
+
+  for (const [serverKey, rawEntry] of Object.entries(document.data.mcpServers)) {
+    if (serverKey.trim().length === 0) {
+      issues.push("server key must be a non-empty string; skipping");
+      continue;
+    }
+
+    const entry = SpecMcpServerSchema.safeParse(rawEntry);
+    if (!entry.success) {
+      issues.push(
+        `invalid server entry "${serverKey}": ${entry.error.issues
+          .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+          .join("; ")}`,
+      );
+      continue;
+    }
+
+    if (entry.data.type === "stdio" && entry.data.cwd) {
+      issues.push(
+        `"${serverKey}": "cwd" is not supported by this host and was ignored; the server runs in the assistant's working directory`,
+      );
+    }
+
+    servers[serverKey] = {
+      transport: projectSpecServerToTransport(entry.data),
+    };
+  }
+
+  return {
+    config: { servers },
+    issues,
+    fileState: "ok",
+  };
+}
+
+/** Load the workspace MCP config, logging any declaration problems. */
+export function loadWorkspaceMcpConfig(): McpConfig {
+  const result = readWorkspaceMcpFile();
+  for (const issue of result.issues) {
+    log.warn(issue);
+  }
+  return result.config;
+}
+
+/**
+ * Refuse a write when `mcp.json` exists but is not a usable document, so a
+ * later add/remove cannot clobber a hand-edit the user still means to fix.
+ */
+export function assertWorkspaceMcpWritable(): void {
+  const result = readWorkspaceMcpFile();
+  if (result.fileState === "invalid") {
+    throw new Error(result.issues[0] ?? "mcp.json is not a valid document");
+  }
+}
+
+/** Persist the in-memory workspace MCP config as a spec-pure document. */
+export function saveWorkspaceMcpConfig(config: McpConfig): void {
+  assertWorkspaceMcpWritable();
+  const path = getWorkspaceMcpConfigPath();
+  const mcpServers: Record<string, unknown> = {};
+  for (const [id, server] of Object.entries(config.servers)) {
+    mcpServers[id] = projectTransportToSpecServer(server.transport);
+  }
+
+  const document = {
+    $schema: AGENT_PLUGINS_MCP_SCHEMA_URL,
+    mcpServers,
+  };
+
+  mkdirSync(dirname(path), { recursive: true });
+  const tmpPath = `${path}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(document, null, 2) + "\n");
+  renameSync(tmpPath, path);
+}
+
+/**
+ * Replace `config.mcp` on a settings/export payload with the projected
+ * workspace servers (transport only, headers stripped). Old clients that
+ * still read `mcp.servers` from `/v1/config` keep seeing the same shape.
+ */
+export function overlayWorkspaceMcpForConfigRead(config: unknown): void {
+  if (config === null || typeof config !== "object" || Array.isArray(config)) {
+    return;
+  }
+  const root = config as Record<string, unknown>;
+  const { servers } = loadWorkspaceMcpConfig();
+  const projected: Record<string, unknown> = {};
+  for (const [id, server] of Object.entries(servers)) {
+    const { headers: _headers, ...safeTransport } = server.transport as Record<
+      string,
+      unknown
+    >;
+    projected[id] = { transport: safeTransport };
+  }
+  root.mcp = { servers: projected };
+}

package/src/messaging/provider.ts

@@ -56,15 +56,22 @@ export interface MessagingProvider {
     query: string,
     options?: SearchOptions,
   ): Promise<SearchResult>;
-  sendMessage(
+
+  // ── Optional operations (platforms implement what they support) ───
+
+  /**
+   * Send through the provider's own API. A provider whose channel has a
+   * direct transport omits this: its sends go through the transport, which
+   * is the one send implementation per addressable channel, and the
+   * messaging tool routes there before it looks for this method.
+   */
+  sendMessage?(
     connection: OAuthConnection | undefined,
     conversationId: string,
     text: string,
     options?: SendOptions,
   ): Promise<SendResult>;
 
-  // ── Optional operations (platforms implement what they support) ───
-
   getThreadReplies?(
     connection: OAuthConnection | undefined,
     conversationId: string,

package/src/messaging/providers/__tests__/proactive-address.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+// The addressing capability resolves a named chat into exactly what each
+// transport's own operations read: the callback URL `channelForCallback`
+// resolves and the params `deliver` consumes. Resolution is local, so these
+// assertions make no platform call; the tests import the transports'
+// modules, which pull in their provider-API senders, so the senders'
+// credential lookups are stubbed to keep the import inert.
+import { mock } from "bun:test";
+
+const actualSecureKeys = await import("../../../security/secure-keys.js");
+mock.module("../../../security/secure-keys.js", () => ({
+  ...actualSecureKeys,
+  getSecureKeyAsync: async () => null,
+  getSecureKeyResultAsync: async () => ({ value: null }),
+}));
+
+const { channelForCallback } = await import("../callback-routing.js");
+const { discordTransport } = await import("../discord/transport.js");
+const { slackTransport } = await import("../slack/transport.js");
+const { telegramTransport } = await import("../telegram-bot/transport.js");
+const { whatsappTransport } = await import("../whatsapp/transport.js");
+
+describe("addressFor resolves to the channel's own routing state", () => {
+  test("slack: a chat, optionally under a thread", () => {
+    const room = slackTransport.addressFor!({ kind: "chat", chatId: "C123" });
+    expect(room).toEqual({
+      ctx: { callbackUrl: "/deliver/slack", params: {} },
+      chatId: "C123",
+    });
+    const thread = slackTransport.addressFor!({
+      kind: "chat",
+      chatId: "C123",
+      threadId: "1690000000.000001",
+    });
+    expect(thread).toEqual({
+      ctx: {
+        callbackUrl: "/deliver/slack?threadTs=1690000000.000001",
+        params: { threadTs: "1690000000.000001" },
+      },
+      chatId: "C123",
+      threadId: "1690000000.000001",
+    });
+    expect(channelForCallback(thread!.ctx.callbackUrl)).toBe("slack");
+  });
+
+  test("telegram: a chat with a topic; binds on send", () => {
+    expect(
+      telegramTransport.addressFor!({
+        kind: "chat",
+        chatId: "123",
+        threadId: "42",
+      }),
+    ).toEqual({
+      ctx: {
+        callbackUrl: "/deliver/telegram?threadId=42",
+        params: { threadId: "42" },
+      },
+      chatId: "123",
+      threadId: "42",
+    });
+    expect(telegramTransport.bindsChatOnProactiveSend).toBe(true);
+  });
+
+  test("discord: a chat with a thread, which is its own channel", () => {
+    const thread = discordTransport.addressFor!({
+      kind: "chat",
+      chatId: "C1",
+      threadId: "T1",
+    });
+    expect(thread).toEqual({
+      ctx: {
+        callbackUrl: "/deliver/discord?threadId=T1",
+        params: { threadId: "T1" },
+      },
+      chatId: "C1",
+      threadId: "T1",
+    });
+    expect(channelForCallback(thread!.ctx.callbackUrl)).toBe("discord");
+    expect(discordTransport.bindsChatOnProactiveSend).toBeUndefined();
+  });
+
+  test("whatsapp: the number is the chat; no threads; binds on send", () => {
+    expect(
+      whatsappTransport.addressFor!({
+        kind: "chat",
+        chatId: "12125550100",
+        threadId: "ignored",
+      }),
+    ).toEqual({
+      ctx: { callbackUrl: "/deliver/whatsapp", params: {} },
+      chatId: "12125550100",
+    });
+    expect(whatsappTransport.bindsChatOnProactiveSend).toBe(true);
+  });
+});

package/src/messaging/providers/callback-routing.ts

@@ -1,4 +1,5 @@
 import type { ChannelId } from "../../channels/types.js";
+import type { CallbackContext } from "./channel-transport.js";
 
 /**
  * Channels whose outbound replies the assistant delivers directly to the
@@ -22,6 +23,23 @@ export type DirectDeliveryChannel = (typeof DIRECT_DELIVERY_CHANNELS)[number];
 
 const CALLBACK_PREFIX = "/deliver/";
 
+/**
+ * The callback context a channel's operations read for a direct delivery
+ * that no inbound message brought a callback for: the channel's `/deliver`
+ * path with its per-channel params, spelled the way `channelForCallback`
+ * resolves it and the way the transports read it.
+ */
+export function directDeliveryContext(
+  channel: DirectDeliveryChannel,
+  params: Readonly<Record<string, string>> = {},
+): CallbackContext {
+  const query = new URLSearchParams(params).toString();
+  return {
+    callbackUrl: `${CALLBACK_PREFIX}${channel}${query ? `?${query}` : ""}`,
+    params,
+  };
+}
+
 /**
  * Resolve a gateway callback URL to the direct-delivery channel that owns it, or
  * `undefined` when no channel delivers it directly.

package/src/messaging/providers/channel-transport.ts

@@ -97,6 +97,35 @@ export interface ReactionTarget {
   readonly action: "add" | "remove";
 }
 
+/**
+ * Where a proactive send goes, in the caller's vocabulary rather than any
+ * channel's: a chat the caller already knows, optionally a thread within it.
+ * How a thread is spelled is each channel's own business.
+ *
+ * Tagged with its kind so a second way of naming a destination is additive
+ * rather than a reinterpretation of `chatId`. Reaching a person who has not
+ * been named as a chat is deliberately not a kind here: on Slack and Discord
+ * it costs a platform call whose result must be resolved at send time rather
+ * than stored, and nothing asks for it yet.
+ */
+export type ProactiveTarget = {
+  readonly kind: "chat";
+  readonly chatId: string;
+  readonly threadId?: string;
+};
+
+/**
+ * A proactive target resolved into what this channel's operations read: the
+ * callback context carrying the channel's routing state, the chat id
+ * `deliver` posts to, and the thread the post lands in, absent when it is
+ * not in one.
+ */
+export interface ProactiveAddress {
+  readonly ctx: CallbackContext;
+  readonly chatId: string;
+  readonly threadId?: string;
+}
+
 /**
  * Direct outbound delivery for one channel, wrapping the channel's provider-API
  * send functions behind a uniform surface. Transports are registered statically
@@ -111,6 +140,33 @@ export interface ChannelTransport {
   /** Canonical source channel id, e.g. `"slack"`. */
   readonly channel: ChannelId;
 
+  /**
+   * Resolve a target the caller names into this channel's own routing state,
+   * for a send that no inbound message brought a callback for.
+   *
+   * Implementing it is the whole of declaring that the channel can be
+   * addressed from a named chat. A transport that can only answer on the
+   * callback an inbound message carried omits it, and a caller reads the
+   * omission as "not addressable" rather than switching on the channel's
+   * name. Returning `undefined` for a target this channel cannot address is
+   * the same answer for that target alone.
+   *
+   * Resolution is local: it reads the target and the channel's own
+   * vocabulary, and makes no platform call. A destination that has to be
+   * resolved over the network belongs behind its own capability, so this one
+   * stays cheap enough to call on every send.
+   */
+  addressFor?(target: ProactiveTarget): ProactiveAddress | undefined;
+
+  /**
+   * Whether a proactive send to a chat must also bind that chat's inbound
+   * conversation, so the next message from the chat resolves to the same
+   * conversation the post lives in. Declared by a channel whose inbound
+   * conversations are keyed per chat and can be reset between sends; omitted
+   * by one whose inbound binding is made at ingress and keyed by thread.
+   */
+  readonly bindsChatOnProactiveSend?: boolean;
+
   /** Deliver a rendered reply (text / approval / attachments). */
   deliver(
     ctx: CallbackContext,

package/src/messaging/providers/discord/transport.ts

@@ -1,6 +1,7 @@
 import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type {
   CallbackContext,
   ChannelTransport,
@@ -51,6 +52,22 @@ async function sendTarget(
 export const discordTransport: ChannelTransport = {
   channel: "discord",
 
+  /**
+   * A chat is a channel id, with `threadId` naming the thread, which is its
+   * own channel. Reaching a person who has not been named as a chat would
+   * mean opening their DM first, a platform call this resolution does not
+   * make; the inbound `dm` param below is how an event-carried callback says
+   * its `chatId` is a recipient rather than a room.
+   */
+  addressFor(target) {
+    const threadId = target.threadId?.trim();
+    return {
+      ctx: directDeliveryContext("discord", threadId ? { threadId } : {}),
+      chatId: target.chatId,
+      ...(threadId ? { threadId } : {}),
+    };
+  },
+
   // Discord clears a typing indicator after ten seconds.
   activityRefreshMs: 8_000,
 

package/src/messaging/providers/slack/__tests__/adapter-token-routing.test.ts

@@ -162,10 +162,11 @@ describe("Slack adapter token routing", () => {
     globalThis.fetch = originalFetch;
   });
 
-  test("bot-token only: reads and writes both authenticate with the bot token (regression guard for pre-user-token behavior)", async () => {
+  test("bot-token only: reads authenticate with the bot token (regression guard for pre-user-token behavior)", async () => {
     // With only a bot token stored, reads must fall back to the bot token
     // so the adapter keeps working for installs that haven't re-consented
-    // the user scope. Writes stay on the bot token always.
+    // the user scope. Writes are not the adapter's: they go through the
+    // channel transport's senders, which always post as the bot.
     const resolved = await slackProvider.resolveConnection!();
     expect(resolved).toBeUndefined();
 
@@ -176,18 +177,12 @@ describe("Slack adapter token routing", () => {
     );
     expect(readCall).toBeDefined();
     expect(readCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
-
-    // Write path: sendMessage → /chat.postMessage must also use bot token.
-    await slackProvider.sendMessage(undefined, "C123", "hello");
-    const writeCall = captured.find((c) => c.url.includes("/chat.postMessage"));
-    expect(writeCall).toBeDefined();
-    expect(writeCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
   });
 
-  test("bot + user tokens: reads authenticate with the user token, writes with the bot token", async () => {
+  test("bot + user tokens: reads authenticate with the user token", async () => {
     // With both tokens stored, reads MUST flip to the user token so the
-    // adapter can see channels the user is in but the bot isn't. Writes
-    // MUST stay on the bot token so posts come from the bot identity.
+    // adapter can see channels the user is in but the bot isn't. Posts are
+    // the transport's and come from the bot identity there.
     getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
       if (key === credentialKey("slack_channel", "bot_token")) {
         return BOT_TOKEN;
@@ -217,12 +212,6 @@ describe("Slack adapter token routing", () => {
     expect(historyCall).toBeDefined();
     expect(historyCall!.authorization).toBe(`Bearer ${USER_TOKEN}`);
 
-    // Writes: sendMessage → bot token.
-    await slackProvider.sendMessage(undefined, "C123", "hello");
-    const sendCall = captured.find((c) => c.url.includes("/chat.postMessage"));
-    expect(sendCall).toBeDefined();
-    expect(sendCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
-
     // markRead → user token. conversations.mark sets the read cursor for
     // the authenticated identity, so it must use the same token whose unread
     // counts the adapter exposes.

package/src/messaging/providers/slack/adapter.ts

@@ -28,8 +28,6 @@ import type {
   Message,
   SearchOptions,
   SearchResult,
-  SendOptions,
-  SendResult,
 } from "../../provider-types.js";
 import { resolveSlackAuth } from "./auth.js";
 import * as slack from "./client.js";
@@ -144,24 +142,12 @@ function getReadAuth(connection?: OAuthConnection): OAuthConnection | string {
   return getSlackAuth(connection);
 }
 
-// SAFETY: content-creating writes (postMessage, updateMessage, deleteMessage,
-// reactions) MUST use the bot token. Using the user token would post as the
-// user, not as the bot. State-changing methods that target the authenticated
-// identity's own state (e.g. conversations.mark) should use the read auth so
-// the cursor matches the perspective the adapter exposes.
-/**
- * Resolve auth for content-creating write operations (postMessage and any
- * future reactions, joins, leaves, updates, or deletes).
- */
-function getWriteAuth(connection?: OAuthConnection): OAuthConnection | string {
-  if (connection) {
-    return connection;
-  }
-  if (_cachedSlackWriteAuth) {
-    return _cachedSlackWriteAuth;
-  }
-  return getSlackAuth(connection);
-}
+// SAFETY: content-creating writes (posts, updates, deletes, reactions) go
+// through the channel transport's senders, which authenticate with the bot
+// token so posts come from the bot identity. State-changing methods that
+// target the authenticated identity's own state (e.g. conversations.mark)
+// use the read auth so the cursor matches the perspective the adapter
+// exposes.
 
 /**
  * Resolve the bot token (raw string) and pass it to `fn`. Returns the
@@ -171,7 +157,7 @@ function getWriteAuth(connection?: OAuthConnection): OAuthConnection | string {
  * (`OAuthConnection.withToken`) for callers that need a raw token to hand
  * to a non-Slack-client API call — currently `downloadSlackFile` for inline
  * file/image fetches. Slack-client method calls should keep going through
- * `getReadAuth` / `getWriteAuth` and pass the union through.
+ * `getReadAuth` and pass the union through.
  */
 export async function withSlackBotToken<T>(
   account: string | undefined,
@@ -830,29 +816,6 @@ export const slackProvider: MessagingProvider = {
     };
   },
 
-  async sendMessage(
-    connection: OAuthConnection | undefined,
-    conversationId: string,
-    text: string,
-    options?: SendOptions,
-  ): Promise<SendResult> {
-    const auth = getWriteAuth(connection);
-    const resp = await slack.postMessage(
-      auth,
-      conversationId,
-      text,
-      options?.threadId,
-    );
-    // The thread reported is the one the post landed in, which is the one
-    // requested, since chat.postMessage threads exactly where it is told.
-    return {
-      id: resp.ts,
-      timestamp: parseFloat(resp.ts) * 1000,
-      conversationId: resp.channel,
-      ...(options?.threadId ? { threadId: options.threadId } : {}),
-    };
-  },
-
   async getThreadReplies(
     connection: OAuthConnection | undefined,
     conversationId: string,

package/src/messaging/providers/slack/transport.ts

@@ -3,6 +3,7 @@ import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { extractThreadTsFromCallbackUrl } from "../../../channels/slack-callback-url.js";
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type { ChannelTransport } from "../channel-transport.js";
 import { SLACK_STREAM_MARKDOWN_LIMIT } from "./api.js";
 import {
@@ -25,6 +26,21 @@ function mutedBlocks(text: string): KnownBlock[] {
 export const slackTransport: ChannelTransport = {
   channel: "slack",
 
+  /**
+   * A chat is a channel or DM id, with `threadTs` naming the thread to post
+   * under. Reaching a person who has not been named as a chat would mean
+   * opening the DM first (`conversations.open`), a platform call this
+   * resolution does not make.
+   */
+  addressFor(target) {
+    const threadTs = target.threadId?.trim();
+    return {
+      ctx: directDeliveryContext("slack", threadTs ? { threadTs } : {}),
+      chatId: target.chatId,
+      ...(threadTs ? { threadId: threadTs } : {}),
+    };
+  },
+
   describeReactionEmoji: describeSlackReactionEmoji,
 
   async react(target) {

package/src/messaging/providers/telegram-bot/adapter.ts

@@ -6,9 +6,6 @@
 
 import type { OAuthConnection } from "../../../oauth/connection.js";
 import { getConnectionByProvider } from "../../../oauth/oauth-store.js";
-import { getOrCreateConversation } from "../../../persistence/conversation-key-store.js";
-import { buildScopedConversationKey } from "../../../persistence/delivery-crud.js";
-import { upsertOutboundBinding } from "../../../persistence/external-conversation-store.js";
 import { credentialKey } from "../../../security/credential-key.js";
 import { getSecureKeyAsync } from "../../../security/secure-keys.js";
 import type { MessagingProvider } from "../../provider.js";
@@ -20,8 +17,6 @@ import type {
   Message,
   SearchOptions,
   SearchResult,
-  SendOptions,
-  SendResult,
 } from "../../provider-types.js";
 import * as telegram from "./client.js";
 
@@ -34,7 +29,7 @@ export const telegramBotMessagingProvider: MessagingProvider = {
   id: "telegram",
   displayName: "Telegram",
   credentialService: "telegram",
-  capabilities: new Set(["send"]),
+  capabilities: new Set(),
 
   async isConnected(): Promise<boolean> {
     const conn = getConnectionByProvider("telegram");
@@ -95,48 +90,6 @@ export const telegramBotMessagingProvider: MessagingProvider = {
     }
   },
 
-  async sendMessage(
-    _connection: OAuthConnection | undefined,
-    conversationId: string,
-    text: string,
-    _options?: SendOptions,
-  ): Promise<SendResult> {
-    const sent = await telegram.sendMessage(conversationId, text);
-    if (!sent.lastMessageId) {
-      throw new Error(
-        "Telegram accepted the message but returned no message id",
-      );
-    }
-
-    // Upsert external conversation binding so deleted/reset syncs are
-    // resurrected when an outbound message is sent. This ensures the
-    // conversation key mapping and binding exist for the next inbound.
-    try {
-      const sourceChannel = "telegram";
-      const conversationKey = buildScopedConversationKey(
-        sourceChannel,
-        conversationId,
-      );
-      const { conversationId: internalId } =
-        getOrCreateConversation(conversationKey);
-      upsertOutboundBinding({
-        conversationId: internalId,
-        sourceChannel,
-        externalChatId: conversationId,
-      });
-    } catch {
-      // Best-effort — don't fail the send if binding upsert fails
-    }
-
-    // The id is the one Telegram assigned, so a later reaction, edit, or
-    // delete carrying that id resolves to this send.
-    return {
-      id: sent.lastMessageId,
-      timestamp: Date.now(),
-      conversationId,
-    };
-  },
-
   async listConversations(
     _connection?: OAuthConnection,
     _options?: ListOptions,