agor-live 0.21.2 → 0.22.0

package/dist/core/gateway/index.js

@@ -341,12 +341,16 @@ var TABLE_MAX_ROWS = 100;
 var TABLE_MAX_COLS = 20;
 var TABLE_MAX_CELL_CHARS = 3e3;
 var SECTION_MAX_CHARS = 3e3;
+var MARKDOWN_BLOCK_MAX_CHARS = 12e3;
 var MAX_TABLES_PER_MESSAGE = 1;
 var MAX_BLOCKS_PER_MESSAGE = 50;
 var BLOCK_PAYLOAD_ERRORS = /* @__PURE__ */ new Set([
   "invalid_blocks",
   "invalid_blocks_format",
-  "message_blocks_too_long"
+  "invalid_block_type",
+  "message_blocks_too_long",
+  "unknown_block_type",
+  "unsupported_block_type"
 ]);
 var FENCE_LINE_RE = /^(`{3,}|~{3,})/;
 var PIPE_LINE_RE = /^\s*\|/;
@@ -519,12 +523,35 @@ ${tableLines.join("\n")}
     text: { type: "mrkdwn", text: wrapped }
   };
 }
+function buildMarkdownBlock(markdown) {
+  const trimmed = markdown.trim();
+  if (trimmed.length === 0 || trimmed.length > MARKDOWN_BLOCK_MAX_CHARS) return null;
+  return { type: "markdown", text: markdown };
+}
+function tableHasRichMarkdown(tableLines) {
+  return tableLines.some(
+    (line) => /(\*\*|__|~~|`|\[[^\]]+\]\([^)]*\)|<br\s*\/?\s*>|_[^_|]+_|(^|\|)\s*[-*+]\s+)/i.test(line)
+  );
+}
+function shouldUseNativeMarkdownBlock(markdown, segments) {
+  if (!buildMarkdownBlock(markdown)) return false;
+  const tableSegments = segments.filter((segment) => segment.kind === "table");
+  if (tableSegments.length > 1) return true;
+  return tableSegments.some((segment) => tableHasRichMarkdown(segment.lines));
+}
 function markdownToSlackPayload(markdown) {
   const text = markdownToMrkdwn(markdown);
   const segments = segmentMarkdown(markdown);
-  if (!segments.some((s) => s.kind === "table")) {
+  const hasTable = segments.some((s) => s.kind === "table");
+  if (!hasTable) {
     return { text };
   }
+  if (shouldUseNativeMarkdownBlock(markdown, segments)) {
+    const markdownBlock = buildMarkdownBlock(markdown);
+    if (markdownBlock) {
+      return { text, blocks: [markdownBlock] };
+    }
+  }
   const blocks = [];
   let tablesEmitted = 0;
   for (const seg of segments) {
@@ -562,12 +589,15 @@ var SlackConnector = class _SlackConnector {
   botUserId = null;
   /** Cache: Slack user ID → profile (email + display name, or null if unavailable). */
   userProfileCache = /* @__PURE__ */ new Map();
+  inboundEventDedup = /* @__PURE__ */ new Map();
   /** Cache: Slack channel ID → channel name */
   channelNameCache = /* @__PURE__ */ new Map();
   static USER_CACHE_TTL_MS = 15 * 60 * 1e3;
   // 15 min for successful lookups
   static USER_CACHE_ERROR_TTL_MS = 60 * 1e3;
   // 1 min for errors (transient recovery)
+  static INBOUND_EVENT_DEDUP_TTL_MS = 5 * 60 * 1e3;
+  // Slack may send message + app_mention for one user action
   /**
    * Cache: Slack channel ID → channel type string (channel/group/mpim/im).
    *
@@ -626,11 +656,7 @@ var SlackConnector = class _SlackConnector {
         displayName,
         expiresAt: now + _SlackConnector.USER_CACHE_TTL_MS
       });
-      if (email) {
-        console.log(
-          `[slack] Resolved user ${slackUserId} \u2192 ${displayName ?? "(no name)"} <${email}>`
-        );
-      } else {
+      if (!email) {
         console.log(
           `[slack] User ${slackUserId} has no email (missing users:read.email scope or restricted account)`
         );
@@ -679,6 +705,47 @@ var SlackConnector = class _SlackConnector {
       return null;
     }
   }
+  async lookupLatestThreadReply(event) {
+    const channel = typeof event.channel === "string" ? event.channel : void 0;
+    const message = typeof event.message === "object" && event.message !== null ? event.message : void 0;
+    const threadTs = (typeof message?.thread_ts === "string" ? message.thread_ts : void 0) ?? (typeof message?.ts === "string" ? message.ts : void 0) ?? (typeof event.thread_ts === "string" ? event.thread_ts : void 0);
+    const replies = Array.isArray(message?.replies) ? message.replies.filter((reply) => {
+      return typeof reply === "object" && reply !== null;
+    }) : [];
+    const latestReplyTs = (typeof message?.latest_reply === "string" ? message.latest_reply : void 0) ?? (typeof event.latest_reply === "string" ? event.latest_reply : void 0) ?? [...replies].reverse().map((reply) => typeof reply.ts === "string" ? reply.ts : void 0).find(Boolean);
+    if (!channel || !threadTs || !latestReplyTs) return null;
+    try {
+      const result = await this.web.conversations.replies({
+        channel,
+        ts: threadTs,
+        oldest: latestReplyTs,
+        inclusive: true,
+        limit: 1
+      });
+      const reply = result.messages?.find((candidate) => candidate.ts === latestReplyTs) ?? result.messages?.[0] ?? null;
+      if (!reply) return null;
+      return {
+        ...reply,
+        channel,
+        thread_ts: typeof reply.thread_ts === "string" ? reply.thread_ts : threadTs,
+        team: event.team
+      };
+    } catch (error) {
+      console.warn("[slack] Failed to fetch latest thread reply for message_replied event:", error);
+      return null;
+    }
+  }
+  shouldProcessInboundEventOnce(channel, ts) {
+    if (!channel || !ts) return true;
+    const now = Date.now();
+    for (const [key2, expiresAt] of this.inboundEventDedup) {
+      if (expiresAt <= now) this.inboundEventDedup.delete(key2);
+    }
+    const key = `${channel}:${ts}`;
+    if (this.inboundEventDedup.has(key)) return false;
+    this.inboundEventDedup.set(key, now + _SlackConnector.INBOUND_EVENT_DEDUP_TTL_MS);
+    return true;
+  }
   /**
    * Cache a known channel type from a trusted source (e.g. `message` event with explicit `channel_type`).
    */
@@ -724,7 +791,6 @@ var SlackConnector = class _SlackConnector {
         } else {
           resolvedType = "channel";
         }
-        console.log(`[slack] conversations.info resolved channel ${channelId} \u2192 ${resolvedType}`);
         this.cacheChannelType(channelId, resolvedType);
         if (ch.name) {
           this.channelNameCache.set(channelId, {
@@ -770,22 +836,34 @@ var SlackConnector = class _SlackConnector {
   async sendMessage(req) {
     const { channel, thread_ts } = parseThreadId2(req.threadId);
     const blocks = req.blocks && req.blocks.length > 0 ? req.blocks : void 0;
-    const post = (withBlocks) => this.web.chat.postMessage({
-      channel,
-      thread_ts,
-      text: req.text,
-      ...withBlocks && blocks ? { blocks } : {},
-      unfurl_links: false,
-      unfurl_media: false
-    });
+    const updateTs = typeof req.metadata?.slack_update_ts === "string" ? req.metadata.slack_update_ts : void 0;
+    const send = (withBlocks) => {
+      const base = {
+        channel,
+        text: req.text,
+        ...withBlocks && blocks ? { blocks } : {},
+        unfurl_links: false,
+        unfurl_media: false
+      };
+      if (updateTs) {
+        return this.web.chat.update({
+          ...base,
+          ts: updateTs
+        });
+      }
+      return this.web.chat.postMessage({
+        ...base,
+        thread_ts
+      });
+    };
     let result;
     try {
-      result = await post(true);
+      result = await send(true);
     } catch (err) {
       const code = extractSlackErrorCode(err);
       if (blocks && code && BLOCK_PAYLOAD_ERRORS.has(code)) {
         console.warn(`[slack] Block payload rejected (${code}); retrying as text-only`);
-        result = await post(false);
+        result = await send(false);
       } else {
         throw err;
       }
@@ -794,7 +872,7 @@ var SlackConnector = class _SlackConnector {
       const code = extractSlackErrorCode(result);
       if (blocks && code && BLOCK_PAYLOAD_ERRORS.has(code)) {
         console.warn(`[slack] Block payload rejected (${code}); retrying as text-only`);
-        const retry = await post(false);
+        const retry = await send(false);
         if (!retry.ok || !retry.ts) {
           throw new Error(`Slack API error: ${retry.error ?? "unknown error"}`);
         }
@@ -805,6 +883,70 @@ var SlackConnector = class _SlackConnector {
     }
     return result.ts;
   }
+  async startStream(req) {
+    const { channel, thread_ts } = parseThreadId2(req.threadId);
+    const chat = this.web.chat;
+    const result = await chat.startStream({
+      channel,
+      thread_ts,
+      markdown_text: req.text?.trim() ? req.text : " ",
+      ...req.recipientUserId ? { recipient_user_id: req.recipientUserId } : {},
+      ...req.recipientTeamId ? { recipient_team_id: req.recipientTeamId } : {}
+    });
+    if (!result.ok || !result.ts) {
+      throw new Error(`Slack stream start error: ${result.error ?? "unknown error"}`);
+    }
+    return result.ts;
+  }
+  async appendStream(req) {
+    const { channel } = parseThreadId2(req.threadId);
+    const chat = this.web.chat;
+    const result = await chat.appendStream({
+      channel,
+      ts: req.ts,
+      markdown_text: req.text
+    });
+    if (!result.ok) {
+      throw new Error(`Slack stream append error: ${result.error ?? "unknown error"}`);
+    }
+  }
+  async stopStream(req) {
+    const { channel } = parseThreadId2(req.threadId);
+    const chat = this.web.chat;
+    const result = await chat.stopStream({
+      channel,
+      ts: req.ts,
+      ...req.text ? { markdown_text: req.text } : {}
+    });
+    if (!result.ok) {
+      throw new Error(`Slack stream stop error: ${result.error ?? "unknown error"}`);
+    }
+  }
+  async deleteMessage(req) {
+    const { channel } = parseThreadId2(req.threadId);
+    const result = await this.web.chat.delete({
+      channel,
+      ts: req.messageId
+    });
+    if (!result.ok) {
+      throw new Error(`Slack delete error: ${result.error ?? "unknown error"}`);
+    }
+  }
+  async setThreadStatus(req) {
+    const { channel, thread_ts } = parseThreadId2(req.threadId);
+    const web = this.web;
+    const args = {
+      channel_id: channel,
+      thread_ts,
+      status: req.status,
+      ...req.loadingMessages?.length ? { loading_messages: req.loadingMessages } : {},
+      ...req.iconEmoji ? { icon_emoji: req.iconEmoji } : {}
+    };
+    const result = web.assistant?.threads?.setStatus ? await web.assistant.threads.setStatus(args) : await web.apiCall?.("assistant.threads.setStatus", args);
+    if (!result?.ok) {
+      throw new Error(`Slack assistant status error: ${result?.error ?? "unknown error"}`);
+    }
+  }
   /**
    * Start listening for inbound messages via Socket Mode
    *
@@ -817,27 +959,20 @@ var SlackConnector = class _SlackConnector {
    * - Channel whitelist (if allowed_channel_ids is set)
    */
   async startListening(callback) {
-    console.log("[slack] startListening called");
     if (!this.config.app_token) {
       console.error("[slack] ERROR: app_token is missing from config");
       throw new Error("Slack Socket Mode requires app_token in config");
     }
-    console.log("[slack] Creating SocketModeClient...");
     this.socketMode = new SocketModeClient({
       appToken: this.config.app_token
     });
     let botMentionPattern = null;
     let botMentionReplacePattern = null;
     try {
-      console.log("[slack] Testing bot token with auth.test()...");
       const authTest = await this.web.auth.test();
       this.botUserId = authTest.user_id;
       botMentionPattern = new RegExp(`<@${this.botUserId}>`);
       botMentionReplacePattern = new RegExp(`<@${this.botUserId}>\\s*`, "g");
-      console.log(`[slack] Bot user ID: ${this.botUserId}`);
-      console.log(
-        `[slack] Bot auth test successful - team: ${authTest.team}, user: ${authTest.user}`
-      );
     } catch (error) {
       console.error("[slack] Failed to fetch bot user ID:", error);
       console.error("[slack] This usually means the bot_token is invalid or expired");
@@ -863,13 +998,6 @@ var SlackConnector = class _SlackConnector {
         allowedChannelIds = void 0;
       }
     }
-    console.log("[slack] Message source config:", {
-      enableChannels,
-      enableGroups,
-      enableMpim,
-      requireMention,
-      allowedChannelIds: allowedChannelIds?.length || 0
-    });
     this.socketMode.on("slack_event", async ({ type, body, ack }) => {
       if (type !== "events_api") {
         await ack();
@@ -881,15 +1009,42 @@ var SlackConnector = class _SlackConnector {
         return;
       }
       await ack();
-      const event = body.event;
+      let event = body.event;
+      const slackTeamId = typeof event.team === "string" ? event.team : typeof body.team_id === "string" ? body.team_id : Array.isArray(body.authorizations) && typeof body.authorizations[0]?.team_id === "string" ? body.authorizations[0].team_id : void 0;
       console.log(
         `[slack] Processing ${eventType} event - channel: ${event.channel}, channel_type: ${event.channel_type}`
       );
       if (event.bot_id || event.subtype === "bot_message") {
-        console.log("[slack] Skipping bot message");
         return;
       }
       if (eventType === "message" && event.subtype) {
+        if (event.subtype === "message_replied") {
+          const replyEvent = await this.lookupLatestThreadReply(event);
+          if (!replyEvent) {
+            console.log(
+              `[slack] Skipping message_replied event without fetchable latest reply channel=${event.channel ?? "(none)"} ts=${event.ts ?? "(none)"}`
+            );
+            return;
+          }
+          event = {
+            ...replyEvent,
+            type: "message",
+            channel_type: event.channel_type
+          };
+          console.log(
+            `[slack] Resolved message_replied event to latest reply thread_ts=${event.thread_ts ?? "(none)"} ts=${event.ts ?? "(none)"}`
+          );
+        } else {
+          console.debug(
+            `[slack] Skipping message subtype=${event.subtype} user=${event.user ?? "(none)"} thread_ts=${event.thread_ts ?? "(none)"} ts=${event.ts ?? "(none)"}`
+          );
+          return;
+        }
+      }
+      if (event.bot_id || event.subtype === "bot_message") {
+        console.debug(
+          `[slack] Skipping resolved bot message subtype=${event.subtype ?? "(none)"} thread_ts=${event.thread_ts ?? "(none)"} ts=${event.ts ?? "(none)"}`
+        );
         return;
       }
       const channelType = event.channel ? await this.resolveChannelType(event.channel, event.channel_type) : void 0;
@@ -897,23 +1052,14 @@ var SlackConnector = class _SlackConnector {
       const isChannelMessage = channelType === "channel" || channelType === "group";
       if (isChannelMessage && !botMentionPattern) {
         if (eventType === "message" && requireMention) {
-          console.warn(
-            "[slack] Bot ID unavailable, require_mention=true - skipping message event (will use app_mention)"
-          );
           return;
         }
         if (eventType === "app_mention" && !requireMention) {
-          console.warn(
-            "[slack] Bot ID unavailable, require_mention=false - skipping app_mention (will use message)"
-          );
           return;
         }
       }
       if (isChannelMessage && botMentionPattern) {
         const mentionOutsideCodeBlock = hasActiveMention2(event.text ?? "", botMentionPattern);
-        if (eventType === "message" && mentionOutsideCodeBlock) {
-          return;
-        }
         if (eventType === "app_mention" && !mentionOutsideCodeBlock) {
           return;
         }
@@ -961,9 +1107,15 @@ var SlackConnector = class _SlackConnector {
           }
         }
       }
+      if (!this.shouldProcessInboundEventOnce(event.channel, event.ts)) {
+        console.log(
+          `[slack] Skipping duplicate inbound event type=${eventType} channel=${event.channel} ts=${event.ts}`
+        );
+        return;
+      }
       const threadId = event.thread_ts ? `${event.channel}-${event.thread_ts}` : `${event.channel}-${event.ts}`;
       console.log(
-        `[slack] Inbound message: thread=${threadId} channel_type=${channelType} user=${event.user}`
+        `[slack] Accepted inbound message: thread=${threadId} channel_type=${channelType} user=${event.user}`
       );
       let slackUserEmail = null;
       let slackUserDisplayName = null;
@@ -984,6 +1136,8 @@ var SlackConnector = class _SlackConnector {
         metadata: {
           channel: event.channel,
           channel_type: channelType,
+          ...event.user ? { slack_user_id: event.user } : {},
+          ...slackTeamId ? { slack_team_id: slackTeamId } : {},
           requires_mapping_verification: allowedViaThreadReplyException,
           ...slackUserEmail ? { slack_user_email: slackUserEmail } : {},
           ...slackUserDisplayName ? { slack_user_name: slackUserDisplayName } : {},
@@ -995,9 +1149,7 @@ var SlackConnector = class _SlackConnector {
         }
       });
     });
-    console.log("[slack] Starting Socket Mode client...");
     await this.socketMode.start();
-    console.log("[slack] Socket Mode client connected successfully!");
   }
   /**
    * Stop Socket Mode listener
@@ -1013,18 +1165,310 @@ var SlackConnector = class _SlackConnector {
    *
    * Returns `{ text, blocks? }`. `text` is the mrkdwn fallback used for
    * notifications and clients that don't render Block Kit; `blocks` is set
-   * when the message contains a GFM table that we can emit as a native
-   * Block Kit `table` block (or a monospace section fallback alongside one).
+   * when the message contains tables that can benefit from Slack's native
+   * markdown/table blocks.
    */
   formatMessage(markdown) {
     return markdownToSlackPayload(markdown);
   }
 };
 
+// src/gateway/connectors/teams.ts
+import { createServer } from "http";
+import { BotFrameworkAdapter, TurnContext } from "botbuilder";
+function parseThreadId3(threadId) {
+  const lastPipe = threadId.lastIndexOf("|");
+  if (lastPipe === -1) {
+    throw new Error(
+      `Invalid Teams thread ID format: "${threadId}" (expected "{conversationId}|{activityId}")`
+    );
+  }
+  const conversationId = threadId.substring(0, lastPipe);
+  const activityId = threadId.substring(lastPipe + 1);
+  if (!conversationId || !activityId) {
+    throw new Error(
+      `Invalid Teams thread ID format: "${threadId}" (expected "{conversationId}|{activityId}")`
+    );
+  }
+  return { conversationId, activityId };
+}
+function stripMention2(text, botName) {
+  const escaped = botName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`<at>${escaped}</at>\\s*`, "gi");
+  return text.replace(pattern, "").trim();
+}
+function hasActiveMention3(text, botName) {
+  const stripped = text.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "");
+  const escaped = botName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`<at>${escaped}</at>`, "i");
+  return pattern.test(stripped);
+}
+function stripHtmlTags(text) {
+  return text.replace(/<[^>]+>/g, "");
+}
+function extractQuotedReplyText(attachments) {
+  if (!attachments) return null;
+  for (const attachment of attachments) {
+    if (attachment.contentType !== "text/html" || !attachment.content) continue;
+    if (!attachment.content.includes("schema.skype.com/Reply")) continue;
+    const afterQuote = attachment.content.split("</blockquote>").pop();
+    if (!afterQuote) continue;
+    const text = stripHtmlTags(afterQuote).trim();
+    if (text) return text;
+  }
+  return null;
+}
+function wrapResponse(res) {
+  const wrapped = res;
+  wrapped.status = (code) => {
+    res.statusCode = code;
+    return res;
+  };
+  wrapped.send = (body) => {
+    if (body !== void 0 && body !== null) {
+      const bodyStr = typeof body === "string" ? body : JSON.stringify(body);
+      res.setHeader("Content-Type", "application/json");
+      res.end(bodyStr);
+    } else {
+      res.end();
+    }
+  };
+  return wrapped;
+}
+var TeamsConnector = class {
+  channelType = "teams";
+  adapter;
+  config;
+  server = null;
+  /** Stored ConversationReferences for proactive messaging, keyed by threadId */
+  conversationRefs = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+    if (!this.config.app_id) {
+      throw new Error("Teams connector requires app_id in config");
+    }
+    if (!this.config.app_password) {
+      throw new Error("Teams connector requires app_password in config");
+    }
+    this.adapter = new BotFrameworkAdapter({
+      appId: this.config.app_id,
+      appPassword: this.config.app_password,
+      ...this.config.tenant_id ? { channelAuthTenant: this.config.tenant_id } : {}
+    });
+  }
+  /**
+   * Send a message to a Teams thread using a stored ConversationReference.
+   *
+   * Uses the proactive messaging pattern: look up the stored reference
+   * from the inbound turn, then use adapter.continueConversation() to
+   * send a message outside of a turn.
+   */
+  async sendMessage(req) {
+    const ref = this.conversationRefs.get(req.threadId);
+    if (!ref) {
+      throw new Error(
+        `No ConversationReference stored for thread ${req.threadId}. Cannot send proactive message before receiving an inbound message.`
+      );
+    }
+    let sentActivityId = "";
+    await this.adapter.continueConversation(ref, async (turnContext) => {
+      const response = await turnContext.sendActivity(req.text);
+      sentActivityId = response?.id ?? "";
+    });
+    return sentActivityId;
+  }
+  /**
+   * Start listening for inbound messages via an HTTP webhook.
+   *
+   * Creates a lightweight HTTP server that receives Bot Framework activities
+   * from Azure Bot Service, processes them, and calls the gateway callback.
+   */
+  async startListening(callback) {
+    const port = this.config.webhook_port ?? 3978;
+    const path = this.config.webhook_path ?? "/api/messages";
+    const requireMention = this.config.require_mention ?? true;
+    const allowThreadRepliesWithoutMention = this.config.allow_thread_replies_without_mention ?? true;
+    let botName = null;
+    this.server = createServer((req, res) => {
+      if (req.method !== "POST" || req.url !== path) {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+      const bodyChunks = [];
+      req.on("data", (chunk) => bodyChunks.push(chunk));
+      req.on("end", () => {
+        const bodyStr = Buffer.concat(bodyChunks).toString("utf-8");
+        let body;
+        try {
+          body = JSON.parse(bodyStr);
+        } catch {
+          res.statusCode = 400;
+          res.end("Invalid JSON");
+          return;
+        }
+        req.body = body;
+        this.adapter.processActivity(
+          req,
+          wrapResponse(res),
+          async (turnContext) => {
+            const activity = turnContext.activity;
+            if (activity.type !== "message") {
+              return;
+            }
+            if (activity.from?.id === this.config.app_id) {
+              return;
+            }
+            const ref = TurnContext.getConversationReference(activity);
+            if (!botName && activity.recipient?.name) {
+              botName = activity.recipient.name;
+              console.log(`[teams] Bot name resolved: "${botName}"`);
+            }
+            const conversationType = activity.conversation?.conversationType;
+            const isPersonal = conversationType === "personal";
+            const isThreadReply = !isPersonal && !!activity.replyToId;
+            const rawConversationId = activity.conversation?.id ?? "";
+            const replyToId = activity.replyToId;
+            let threadId;
+            if (isPersonal) {
+              threadId = rawConversationId;
+            } else {
+              let baseConversationId = rawConversationId;
+              let messageIdFromConv;
+              const msgIdIdx = rawConversationId.indexOf(";messageid=");
+              if (msgIdIdx !== -1) {
+                baseConversationId = rawConversationId.substring(0, msgIdIdx);
+                messageIdFromConv = rawConversationId.substring(msgIdIdx + ";messageid=".length);
+              }
+              const rootId = messageIdFromConv ?? replyToId ?? activity.id ?? "";
+              threadId = `${baseConversationId}|${rootId}`;
+            }
+            this.conversationRefs.set(threadId, ref);
+            const quotedReplyText = extractQuotedReplyText(
+              activity.attachments
+            );
+            let messageText = quotedReplyText ?? activity.text ?? "";
+            let hasMention = false;
+            if (activity.entities) {
+              for (const entity of activity.entities) {
+                if (entity.type !== "mention") continue;
+                const mentioned = entity.mentioned;
+                const mentionedId = mentioned?.id ?? "";
+                const isBotMention = mentionedId === this.config.app_id || mentionedId.includes(this.config.app_id);
+                if (!isBotMention) continue;
+                hasMention = true;
+                const mentionText = entity.text;
+                if (mentionText && messageText.includes(mentionText)) {
+                  messageText = messageText.replace(mentionText, "").trim();
+                }
+              }
+            }
+            if (!hasMention) {
+              const allBotNames = /* @__PURE__ */ new Set();
+              if (botName) allBotNames.add(botName);
+              if (activity.recipient?.name) allBotNames.add(activity.recipient.name);
+              for (const name of allBotNames) {
+                if (hasActiveMention3(messageText, name)) {
+                  hasMention = true;
+                  messageText = stripMention2(messageText, name);
+                }
+              }
+            }
+            messageText = stripHtmlTags(messageText).trim();
+            if (!messageText) {
+              return;
+            }
+            if (!isPersonal && requireMention) {
+              if (!hasMention) {
+                if (isThreadReply && allowThreadRepliesWithoutMention) {
+                } else {
+                  return;
+                }
+              }
+            }
+            const userName = activity.from?.name;
+            const userAadObjectId = activity.from?.aadObjectId;
+            const channelData = activity.channelData;
+            const teamName = channelData?.team?.name;
+            const channelName = channelData?.channel?.name;
+            const tenantId = channelData?.tenant?.id;
+            callback({
+              threadId,
+              text: messageText,
+              userId: activity.from?.id ?? "unknown",
+              timestamp: activity.timestamp?.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString(),
+              metadata: {
+                teams_conversation_type: conversationType,
+                teams_channel_name: channelName,
+                teams_team_name: teamName,
+                teams_user_name: userName,
+                teams_user_aad_id: userAadObjectId,
+                teams_tenant_id: tenantId,
+                requires_mapping_verification: !hasMention && isThreadReply
+              }
+            });
+          }
+        );
+      });
+    });
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        reject(new Error("Server not created"));
+        return;
+      }
+      this.server.on("error", (err) => {
+        console.error(`[teams] HTTP server error:`, err);
+        reject(err);
+      });
+      this.server.listen(port, () => {
+        console.log(`[teams] Webhook server listening on port ${port} at ${path}`);
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the HTTP webhook server
+   */
+  async stopListening() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server?.close(() => {
+          console.log("[teams] Webhook server stopped");
+          this.server = null;
+          resolve();
+        });
+      });
+    }
+  }
+  /**
+   * Convert markdown to Teams-compatible format.
+   *
+   * Teams natively supports most markdown (bold, italic, code blocks, links, lists).
+   * Main adjustments:
+   * - Collapse <details>/<summary> blocks (not supported in Teams)
+   * - Strip unsupported HTML tags
+   */
+  formatMessage(markdown) {
+    let text = markdown;
+    text = text.replace(
+      /<details>\s*<summary>([\s\S]*?)<\/summary>\s*([\s\S]*?)<\/details>/gi,
+      (_match, summary, content) => {
+        const summaryText = summary.trim();
+        const contentText = content.trim();
+        return `**${summaryText}**
+${contentText}`;
+      }
+    );
+    text = stripHtmlTags(text);
+    return text.trim();
+  }
+};
+
 // src/gateway/connector-registry.ts
 var connectors = /* @__PURE__ */ new Map();
 connectors.set("slack", (config) => new SlackConnector(config));
 connectors.set("github", (config) => new GitHubConnector(config));
+connectors.set("teams", (config) => new TeamsConnector(config));
 function getConnector(channelType, config) {
   const factory = connectors.get(channelType);
   if (!factory) {
@@ -1045,7 +1489,8 @@ var PLATFORM_LABELS = {
   discord: "Discord",
   github: "GitHub",
   whatsapp: "WhatsApp",
-  telegram: "Telegram"
+  telegram: "Telegram",
+  teams: "Microsoft Teams"
 };
 function formatGatewayContext(ctx) {
   const label = PLATFORM_LABELS[ctx.platform] ?? ctx.platform;
@@ -1082,23 +1527,70 @@ function formatGatewayContext(ctx) {
 `;
 }
 
+// src/types/id.ts
+var SHORT_ID_LENGTH = 24;
+function toShortId(id, length = SHORT_ID_LENGTH) {
+  return id.replace(/-/g, "").slice(0, Math.min(length, 32));
+}
+function shortId(id) {
+  return toShortId(id, SHORT_ID_LENGTH);
+}
+
 // src/gateway/system-message.ts
+var GATEWAY_SYSTEM_PREFIX = "Agor:";
+function formatGatewayMarkdownSessionReference(sessionId, sessionUrl) {
+  return sessionUrl ? `[session](${sessionUrl})` : `session ${shortId(sessionId)}`;
+}
+function formatGatewaySessionCreatedMessage(sessionId, sessionUrl) {
+  return sessionUrl ? `Session created: ${sessionUrl}` : `Session ${shortId(sessionId)} created, sending prompt to agent...`;
+}
+function formatGatewayFollowUpRoutingMessage(sessionId, sessionUrl) {
+  return `Follow-up received \u2014 routing to ${formatGatewayMarkdownSessionReference(sessionId, sessionUrl)} ...`;
+}
 function formatGatewaySystemMessage(channelType, text) {
   const sessionCreatedMatch = text.match(/^Session created: (https?:\/\/\S+)$/);
   if (channelType === "slack") {
-    const markdown = sessionCreatedMatch ? `[system] Session created: [View session](${sessionCreatedMatch[1]})` : `[system] ${text}`;
+    const markdown = sessionCreatedMatch ? `${GATEWAY_SYSTEM_PREFIX} Session created: [View session](${sessionCreatedMatch[1]})` : `${GATEWAY_SYSTEM_PREFIX} ${text}`;
     return markdownToMrkdwn(markdown);
   }
-  return `[system] ${text}`;
+  return `${GATEWAY_SYSTEM_PREFIX} ${text}`;
+}
+function formatGatewaySystemPayload(channelType, text) {
+  const formatted = formatGatewaySystemMessage(channelType, text);
+  if (channelType !== "slack") {
+    return { text: formatted };
+  }
+  return {
+    text: formatted,
+    blocks: [
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: formatted
+          }
+        ]
+      }
+    ]
+  };
 }
 export {
   GitHubConnector,
   SlackConnector,
+  TeamsConnector,
+  extractQuotedReplyText,
   formatGatewayContext,
+  formatGatewayFollowUpRoutingMessage,
+  formatGatewayMarkdownSessionReference,
+  formatGatewaySessionCreatedMessage,
   formatGatewaySystemMessage,
+  formatGatewaySystemPayload,
   getConnector,
   hasConnector,
+  markdownToMrkdwn,
   normalizeOutbound,
   parseThreadId as parseGitHubThreadId,
+  parseThreadId3 as parseTeamsThreadId,
   registerConnector
 };