mercury-agent 0.4.5

package/resources/templates/mercury.example.yaml

@@ -0,0 +1,75 @@
+# Copy to mercury.yaml in your project root (optional).
+# Precedence: MERCURY_* env vars override this file when the env key is set.
+# Secrets (API keys, tokens, MERCURY_API_SECRET, etc.) belong in .env only — not here.
+
+# server:
+#   port: 8787
+#   bot_username: mercury
+
+# model:
+#   chain:
+#     - provider: anthropic
+#       model: claude-sonnet-4-20250514
+#   # Legacy single primary + optional fallback (when chain is omitted):
+#   # provider: anthropic
+#   # model: claude-sonnet-4-20250514
+#   # fallback_provider: openai
+#   # fallback: gpt-4o-mini
+#   # max_retries_per_leg: 2
+#   # chain_budget_ms: 120000
+#   # capabilities: { tools: false }
+
+# Top-level alias for model.chain (optional; model.chain wins if both are set):
+# model_chain:
+#   - provider: google
+#     model: gemini-2.5-flash
+
+# ingress:
+#   discord: false
+#   slack: false
+#   teams: false
+#   whatsapp: false
+#   telegram: false
+
+# runtime:
+#   data_dir: .mercury
+#   # auth_path: ...
+#   # whatsapp_auth_dir: .mercury/whatsapp-auth
+#   max_concurrency: 2
+#   log_level: info
+#   log_format: text
+#   rate_limit_per_user: 10
+#   rate_limit_window_ms: 60000
+
+# trigger:
+#   patterns: "@Mercury,Mercury"
+#   match: mention
+
+# conditional_context:
+#   enabled: true
+#   classifier: heuristic
+#   # classifier_provider: groq
+#   # classifier_model: llama-3.3-70b-versatile
+
+# compaction:
+#   keep_recent_tokens: 20000
+#   # After each full-session run, auto-compact if the pi session has more than this many entries (10–10000). Omit to disable.
+#   # auto_compact_threshold: 50
+
+# agent:
+#   image: ghcr.io/michaelliv/mercury-agent:latest
+#   container_timeout_ms: 300000
+#   container_bwrap_docker_compat: false
+
+# discord:
+#   gateway_duration_ms: 600000
+
+# telegram:
+#   format_enabled: true
+
+# media:
+#   enabled: true
+#   max_size_mb: 10
+
+# permissions:
+#   admins: ""

package/src/adapters/discord-native.ts

@@ -0,0 +1,534 @@
+/**
+ * Native Discord adapter using discord.js for persistent WebSocket connection.
+ *
+ * Similar to the WhatsApp/Baileys adapter pattern — maintains a persistent
+ * connection instead of the serverless gateway approach.
+ */
+
+import {
+  type Adapter,
+  type AdapterPostableMessage,
+  type ChatInstance,
+  type EmojiValue,
+  type FetchOptions,
+  type FetchResult,
+  type FormattedContent,
+  Message,
+  parseMarkdown,
+  type RawMessage,
+  stringifyMarkdown,
+  type ThreadInfo,
+  type WebhookOptions,
+} from "chat";
+import {
+  Client,
+  type Message as DiscordMessage,
+  Events,
+  GatewayIntentBits,
+  type OmitPartialGroupDMChannel,
+  Partials,
+} from "discord.js";
+import { logger } from "../logger.js";
+
+/** Discord's maximum message length */
+export const DISCORD_MAX_LENGTH = 2000;
+
+/**
+ * Split a message into chunks that fit within Discord's character limit.
+ * Tries to break at natural boundaries (paragraphs, lines, spaces) when possible.
+ */
+export function chunkMessage(text: string, maxLength: number): string[] {
+  if (text.length <= maxLength) return [text];
+
+  const chunks: string[] = [];
+  let remaining = text;
+
+  while (remaining.length > maxLength) {
+    // Try to break at paragraph boundary
+    let breakPoint = remaining.lastIndexOf("\n\n", maxLength);
+
+    // Fall back to line break
+    if (breakPoint < maxLength / 2) {
+      breakPoint = remaining.lastIndexOf("\n", maxLength);
+    }
+
+    // Fall back to space
+    if (breakPoint < maxLength / 2) {
+      breakPoint = remaining.lastIndexOf(" ", maxLength);
+    }
+
+    // Hard break if no good boundary found
+    if (breakPoint <= 0) {
+      breakPoint = maxLength;
+    }
+
+    chunks.push(remaining.slice(0, breakPoint).trim());
+    remaining = remaining.slice(breakPoint).trim();
+  }
+
+  if (remaining) {
+    chunks.push(remaining);
+  }
+
+  return chunks;
+}
+
+type DiscordThreadId = {
+  guildId: string;
+  channelId: string;
+  threadId?: string;
+};
+
+export interface DiscordNativeAdapterOptions {
+  /** Bot token */
+  botToken: string;
+  /** Bot username for trigger matching */
+  userName?: string;
+}
+
+export class DiscordNativeAdapter
+  implements Adapter<DiscordThreadId, DiscordMessage>
+{
+  readonly name = "discord";
+  readonly userName: string;
+
+  private chat?: ChatInstance;
+  private client: Client;
+  private readonly botToken: string;
+
+  constructor(options: DiscordNativeAdapterOptions) {
+    this.userName = options.userName ?? "mercury";
+    this.botToken = options.botToken;
+
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.GuildMessageReactions,
+      ],
+      partials: [Partials.Channel, Partials.Message],
+    });
+  }
+
+  get botUserId(): string | undefined {
+    return this.client.user?.id;
+  }
+
+  get discordClient(): Client {
+    return this.client;
+  }
+
+  async initialize(chat: ChatInstance): Promise<void> {
+    this.chat = chat;
+    logger.info("Discord native adapter initializing");
+
+    this.client.on(Events.ClientReady, () => {
+      logger.info("Discord native adapter connected", {
+        username: this.client.user?.username,
+        id: this.client.user?.id,
+      });
+    });
+
+    this.client.on(Events.MessageCreate, (message) => {
+      void this.handleIncomingMessage(message);
+    });
+
+    this.client.on(Events.Error, (error) => {
+      logger.error("Discord client error", { error: error.message });
+    });
+
+    await this.client.login(this.botToken);
+  }
+
+  async handleWebhook(
+    _request: Request,
+    _options?: WebhookOptions,
+  ): Promise<Response> {
+    // No webhook needed — we use persistent WebSocket
+    return new Response("Discord native adapter uses WebSocket, no webhook.", {
+      status: 202,
+    });
+  }
+
+  channelIdFromThreadId(threadId: string): string {
+    const parts = threadId.split(":");
+    return `discord:${parts[1]}:${parts[2]}`;
+  }
+
+  encodeThreadId(platformData: DiscordThreadId): string {
+    const parts = ["discord", platformData.guildId, platformData.channelId];
+    if (platformData.threadId) {
+      parts.push(platformData.threadId);
+    }
+    return parts.join(":");
+  }
+
+  decodeThreadId(threadId: string): DiscordThreadId {
+    const parts = threadId.split(":");
+    if (parts.length < 3 || parts[0] !== "discord") {
+      throw new Error(`Invalid Discord thread ID: ${threadId}`);
+    }
+    return {
+      guildId: parts[1],
+      channelId: parts[2],
+      threadId: parts[3],
+    };
+  }
+
+  async postMessage(
+    threadId: string,
+    message: AdapterPostableMessage,
+  ): Promise<RawMessage<DiscordMessage>> {
+    const { channelId, threadId: discordThreadId } =
+      this.decodeThreadId(threadId);
+
+    const targetId = discordThreadId || channelId;
+    const channel = await this.client.channels.fetch(targetId);
+
+    if (!channel || !("send" in channel)) {
+      throw new Error(`Cannot send to channel: ${targetId}`);
+    }
+
+    const text = this.postableToText(message);
+    const chunks = chunkMessage(text, DISCORD_MAX_LENGTH);
+
+    let lastSent: DiscordMessage | undefined;
+    for (const chunk of chunks) {
+      lastSent = await channel.send(chunk);
+    }
+
+    // lastSent is guaranteed to be defined since chunks always has at least one element
+    const sent = lastSent as DiscordMessage;
+    return {
+      id: sent.id,
+      threadId,
+      raw: sent,
+    };
+  }
+
+  async editMessage(
+    threadId: string,
+    messageId: string,
+    message: AdapterPostableMessage,
+  ): Promise<RawMessage<DiscordMessage>> {
+    const { channelId, threadId: discordThreadId } =
+      this.decodeThreadId(threadId);
+
+    const targetId = discordThreadId || channelId;
+    const channel = await this.client.channels.fetch(targetId);
+
+    if (!channel || !("messages" in channel)) {
+      throw new Error(`Cannot edit in channel: ${targetId}`);
+    }
+
+    const msg = await channel.messages.fetch(messageId);
+    const text = this.postableToText(message);
+    const edited = await msg.edit(text);
+
+    return {
+      id: edited.id,
+      threadId,
+      raw: edited,
+    };
+  }
+
+  async deleteMessage(threadId: string, messageId: string): Promise<void> {
+    const { channelId, threadId: discordThreadId } =
+      this.decodeThreadId(threadId);
+
+    const targetId = discordThreadId || channelId;
+    const channel = await this.client.channels.fetch(targetId);
+
+    if (!channel || !("messages" in channel)) {
+      throw new Error(`Cannot delete in channel: ${targetId}`);
+    }
+
+    const msg = await channel.messages.fetch(messageId);
+    await msg.delete();
+  }
+
+  async addReaction(
+    threadId: string,
+    messageId: string,
+    emoji: EmojiValue | string,
+  ): Promise<void> {
+    const { channelId, threadId: discordThreadId } =
+      this.decodeThreadId(threadId);
+
+    const targetId = discordThreadId || channelId;
+    const channel = await this.client.channels.fetch(targetId);
+
+    if (!channel || !("messages" in channel)) {
+      throw new Error(`Cannot react in channel: ${targetId}`);
+    }
+
+    const msg = await channel.messages.fetch(messageId);
+    const emojiStr = typeof emoji === "string" ? emoji : emoji.toString();
+    await msg.react(emojiStr);
+  }
+
+  async removeReaction(
+    threadId: string,
+    messageId: string,
+    emoji: EmojiValue | string,
+  ): Promise<void> {
+    const { channelId, threadId: discordThreadId } =
+      this.decodeThreadId(threadId);
+
+    const targetId = discordThreadId || channelId;
+    const channel = await this.client.channels.fetch(targetId);
+
+    if (!channel || !("messages" in channel)) {
+      throw new Error(`Cannot remove reaction in channel: ${targetId}`);
+    }
+
+    const msg = await channel.messages.fetch(messageId);
+    const emojiStr = typeof emoji === "string" ? emoji : emoji.toString();
+    const reaction = msg.reactions.cache.find(
+      (r) => r.emoji.name === emojiStr || r.emoji.toString() === emojiStr,
+    );
+    if (reaction) {
+      await reaction.users.remove(this.client.user?.id);
+    }
+  }
+
+  async fetchMessages(
+    threadId: string,
+    options?: FetchOptions,
+  ): Promise<FetchResult<DiscordMessage>> {
+    const { channelId, threadId: discordThreadId } =
+      this.decodeThreadId(threadId);
+
+    const targetId = discordThreadId || channelId;
+    const channel = await this.client.channels.fetch(targetId);
+
+    if (!channel || !("messages" in channel)) {
+      return { messages: [] };
+    }
+
+    const fetchOptions: { limit?: number; before?: string } = {};
+    if (options?.limit) fetchOptions.limit = options.limit;
+    if (options?.cursor) fetchOptions.before = options.cursor;
+
+    const messages = await channel.messages.fetch(fetchOptions);
+    const parsed = messages.map((msg) => this.parseMessage(msg));
+
+    return { messages: Array.from(parsed.values()) };
+  }
+
+  async fetchThread(threadId: string): Promise<ThreadInfo> {
+    const {
+      guildId,
+      channelId,
+      threadId: discordThreadId,
+    } = this.decodeThreadId(threadId);
+
+    const isDM = guildId === "@me";
+
+    return {
+      id: threadId,
+      channelId: `discord:${guildId}:${channelId}`,
+      isDM,
+      metadata: { guildId, channelId, threadId: discordThreadId },
+    };
+  }
+
+  parseMessage(raw: DiscordMessage): Message<DiscordMessage> {
+    const guildId = raw.guildId || "@me";
+    const channelId = raw.channelId;
+    const threadId = raw.thread?.id;
+
+    const fullThreadId = this.encodeThreadId({ guildId, channelId, threadId });
+
+    // Check if bot is mentioned
+    const isMention =
+      raw.mentions.users.has(this.client.user?.id || "") ||
+      raw.mentions.everyone ||
+      raw.content.includes(`<@${this.client.user?.id}>`);
+
+    return new Message({
+      id: raw.id,
+      threadId: fullThreadId,
+      text: raw.content,
+      formatted: parseMarkdown(raw.content),
+      raw,
+      isMention,
+      author: {
+        userId: raw.author.id,
+        userName: raw.author.username,
+        fullName: raw.author.displayName || raw.author.username,
+        isBot: raw.author.bot,
+        isMe: raw.author.id === this.client.user?.id,
+      },
+      metadata: {
+        dateSent: raw.createdAt,
+        edited: raw.editedAt !== null,
+      },
+      attachments: raw.attachments.map((a) => ({
+        type: this.getAttachmentType(a.contentType),
+        url: a.url,
+        name: a.name,
+        size: a.size,
+        mimeType: a.contentType || undefined,
+      })),
+    });
+  }
+
+  renderFormatted(content: FormattedContent): string {
+    return stringifyMarkdown(content);
+  }
+
+  async startTyping(threadId: string): Promise<void> {
+    const { channelId, threadId: discordThreadId } =
+      this.decodeThreadId(threadId);
+
+    const targetId = discordThreadId || channelId;
+    const channel = await this.client.channels.fetch(targetId);
+
+    if (channel && "sendTyping" in channel) {
+      await channel.sendTyping();
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    await this.client.destroy();
+    logger.info("Discord native adapter disconnected");
+  }
+
+  /**
+   * Handle incoming Discord message.
+   */
+  private async handleIncomingMessage(
+    msg: OmitPartialGroupDMChannel<DiscordMessage>,
+  ): Promise<void> {
+    // Ignore bot messages
+    if (msg.author.bot) return;
+    if (msg.author.id === this.client.user?.id) return;
+
+    // Ignore empty messages
+    if (!msg.content && msg.attachments.size === 0) return;
+
+    const guildId = msg.guildId || "@me";
+    const channelId = msg.channelId;
+    const threadId = msg.thread?.id;
+
+    const fullThreadId = this.encodeThreadId({ guildId, channelId, threadId });
+
+    // Convert mentions for trigger matching
+    let text = msg.content;
+    if (this.client.user?.id) {
+      text = text.replace(
+        new RegExp(`<@!?${this.client.user.id}>`, "g"),
+        `@${this.userName}`,
+      );
+    }
+
+    const isDM = guildId === "@me";
+    const isMention =
+      msg.mentions.users.has(this.client.user?.id || "") ||
+      msg.content.includes(`<@${this.client.user?.id}>`);
+
+    // Check if this is a reply to one of our messages
+    let isReplyToBot = false;
+    if (msg.reference?.messageId && this.client.user?.id) {
+      try {
+        const channel = msg.channel;
+        if ("messages" in channel) {
+          const repliedTo = await channel.messages.fetch(
+            msg.reference.messageId,
+          );
+          isReplyToBot = repliedTo.author.id === this.client.user.id;
+        }
+      } catch {
+        // Referenced message may be deleted or inaccessible
+      }
+    }
+
+    logger.debug("Discord native inbound", {
+      guildId,
+      channelId,
+      threadId,
+      isDM,
+      isMention,
+      isReplyToBot,
+      preview: text.slice(0, 80),
+    });
+
+    const incoming = new Message<DiscordMessage>({
+      id: msg.id,
+      threadId: fullThreadId,
+      text,
+      formatted: parseMarkdown(text),
+      raw: msg as DiscordMessage,
+      isMention: isMention || isDM,
+      author: {
+        userId: msg.author.id,
+        userName: msg.author.username,
+        fullName: msg.author.displayName || msg.author.username,
+        isBot: msg.author.bot,
+        isMe: false,
+      },
+      metadata: {
+        dateSent: msg.createdAt,
+        edited: msg.editedAt !== null,
+        // Store reply flag and platform IDs in metadata for downstream consumers
+        ...({
+          isReplyToBot,
+          replyToMessageId: msg.reference?.messageId ?? undefined,
+          platformMessageId: msg.id,
+        } as Record<string, unknown>),
+      },
+      attachments: msg.attachments.map((a) => ({
+        type: this.getAttachmentType(a.contentType),
+        url: a.url,
+        name: a.name,
+        size: a.size,
+        mimeType: a.contentType || undefined,
+      })),
+    });
+
+    this.chat?.processMessage(this, fullThreadId, incoming);
+  }
+
+  private postableToText(message: AdapterPostableMessage): string {
+    if (typeof message === "string") return message;
+    if (typeof message === "object" && message !== null) {
+      if ("markdown" in message && typeof message.markdown === "string")
+        return message.markdown;
+      if ("ast" in message && message.ast)
+        return stringifyMarkdown(message.ast);
+      if ("raw" in message && typeof message.raw === "string")
+        return message.raw;
+    }
+    return "";
+  }
+
+  private getAttachmentType(
+    mimeType: string | null,
+  ): "image" | "video" | "audio" | "file" {
+    if (!mimeType) return "file";
+    if (mimeType.startsWith("image/")) return "image";
+    if (mimeType.startsWith("video/")) return "video";
+    if (mimeType.startsWith("audio/")) return "audio";
+    return "file";
+  }
+}
+
+export function createDiscordNativeAdapter(
+  options?: Partial<DiscordNativeAdapterOptions>,
+): DiscordNativeAdapter {
+  const botToken = options?.botToken || process.env.MERCURY_DISCORD_BOT_TOKEN;
+
+  if (!botToken) {
+    throw new Error(
+      "Discord native adapter requires MERCURY_DISCORD_BOT_TOKEN environment variable",
+    );
+  }
+
+  return new DiscordNativeAdapter({
+    botToken,
+    userName: options?.userName,
+  });
+}

package/src/adapters/discord.ts

@@ -0,0 +1,38 @@
+/**
+ * Discord adapter factory for the webhook-based (serverless) adapter.
+ *
+ * Note: Mercury primarily uses the native adapter (discord-native.ts) with
+ * persistent WebSocket. This factory is kept for potential fallback use.
+ */
+
+import {
+  createDiscordAdapter as createBaseDiscordAdapter,
+  type DiscordAdapter,
+  type DiscordThreadId,
+} from "@chat-adapter/discord";
+import { logger } from "../logger.js";
+
+export type { DiscordAdapter, DiscordThreadId };
+
+export function createDiscordAdapter(options?: {
+  userName?: string;
+}): DiscordAdapter {
+  const botToken = process.env.MERCURY_DISCORD_BOT_TOKEN;
+  const publicKey = process.env.MERCURY_DISCORD_PUBLIC_KEY;
+  const applicationId = process.env.MERCURY_DISCORD_APPLICATION_ID;
+
+  if (!botToken || !publicKey || !applicationId) {
+    throw new Error(
+      "Discord adapter requires MERCURY_DISCORD_BOT_TOKEN, MERCURY_DISCORD_PUBLIC_KEY, and MERCURY_DISCORD_APPLICATION_ID",
+    );
+  }
+
+  logger.info("Creating Discord adapter", { applicationId });
+
+  return createBaseDiscordAdapter({
+    botToken,
+    publicKey,
+    applicationId,
+    userName: options?.userName,
+  });
+}