@chat-adapter/teams 4.2.0 → 4.4.0

package/dist/index.js

@@ -11,19 +11,29 @@ import {
   TeamsInfo
 } from "botbuilder";
 import {
-  convertEmojiPlaceholders as convertEmojiPlaceholders2,
+  AdapterRateLimitError,
+  AuthenticationError,
+  bufferToDataUri,
+  extractCard,
+  extractFiles,
+  NetworkError,
+  PermissionError,
+  toBuffer,
+  ValidationError
+} from "@chat-adapter/shared";
+import {
+  convertEmojiPlaceholders,
   defaultEmojiResolver,
-  isCardElement,
   NotImplementedError
 } from "chat";
 
 // src/cards.ts
 import {
-  convertEmojiPlaceholders
-} from "chat";
-function convertEmoji(text) {
-  return convertEmojiPlaceholders(text, "teams");
-}
+  createEmojiConverter,
+  mapButtonStyle,
+  cardToFallbackText as sharedCardToFallbackText
+} from "@chat-adapter/shared";
+var convertEmoji = createEmojiConverter("teams");
 var ADAPTIVE_CARD_SCHEMA = "http://adaptivecards.io/schemas/adaptive-card.json";
 var ADAPTIVE_CARD_VERSION = "1.4";
 function cardToAdaptiveCard(card) {
@@ -130,10 +140,9 @@ function convertButtonToAction(button) {
       value: button.value
     }
   };
-  if (button.style === "primary") {
-    action.style = "positive";
-  } else if (button.style === "danger") {
-    action.style = "destructive";
+  const style = mapButtonStyle(button.style, "teams");
+  if (style) {
+    action.style = style;
   }
   return action;
 }
@@ -165,39 +174,29 @@ function convertFieldsToElement(element) {
   };
 }
 function cardToFallbackText(card) {
-  const parts = [];
-  if (card.title) {
-    parts.push(`**${convertEmoji(card.title)}**`);
-  }
-  if (card.subtitle) {
-    parts.push(convertEmoji(card.subtitle));
-  }
-  for (const child of card.children) {
-    const text = childToFallbackText(child);
-    if (text) {
-      parts.push(text);
-    }
-  }
-  return parts.join("\n\n");
-}
-function childToFallbackText(child) {
-  switch (child.type) {
-    case "text":
-      return convertEmoji(child.content);
-    case "fields":
-      return child.children.map((f) => `**${convertEmoji(f.label)}**: ${convertEmoji(f.value)}`).join("\n");
-    case "actions":
-      return `[${child.children.map((b) => convertEmoji(b.label)).join("] [")}]`;
-    case "section":
-      return child.children.map((c) => childToFallbackText(c)).filter(Boolean).join("\n");
-    default:
-      return null;
-  }
+  return sharedCardToFallbackText(card, {
+    boldFormat: "**",
+    lineBreak: "\n\n",
+    platform: "teams"
+  });
 }
 
 // src/markdown.ts
 import {
   BaseFormatConverter,
+  getNodeChildren,
+  getNodeValue,
+  isBlockquoteNode,
+  isCodeNode,
+  isDeleteNode,
+  isEmphasisNode,
+  isInlineCodeNode,
+  isLinkNode,
+  isListItemNode,
+  isListNode,
+  isParagraphNode,
+  isStrongNode,
+  isTextNode,
   parseMarkdown
 } from "chat";
 var TeamsFormatConverter = class extends BaseFormatConverter {
@@ -231,11 +230,7 @@ var TeamsFormatConverter = class extends BaseFormatConverter {
    * Teams accepts standard markdown, so we just stringify cleanly.
    */
   fromAst(ast) {
-    const parts = [];
-    for (const node of ast.children) {
-      parts.push(this.nodeToTeams(node));
-    }
-    return parts.join("\n\n");
+    return this.fromAstWithNodeConverter(ast, (node) => this.nodeToTeams(node));
   }
   /**
    * Parse Teams message into an AST.
@@ -264,55 +259,60 @@ var TeamsFormatConverter = class extends BaseFormatConverter {
     return parseMarkdown(markdown);
   }
   nodeToTeams(node) {
-    switch (node.type) {
-      case "paragraph":
-        return node.children.map((child) => this.nodeToTeams(child)).join("");
-      case "text": {
-        const textValue = node.value;
-        return textValue.replace(/@(\w+)/g, "<at>$1</at>");
-      }
-      case "strong":
-        return `**${node.children.map((child) => this.nodeToTeams(child)).join("")}**`;
-      case "emphasis":
-        return `_${node.children.map((child) => this.nodeToTeams(child)).join("")}_`;
-      case "delete":
-        return `~~${node.children.map((child) => this.nodeToTeams(child)).join("")}~~`;
-      case "inlineCode":
-        return `\`${node.value}\``;
-      case "code": {
-        const codeNode = node;
-        return `\`\`\`${codeNode.lang || ""}
-${codeNode.value}
+    if (isParagraphNode(node)) {
+      return getNodeChildren(node).map((child) => this.nodeToTeams(child)).join("");
+    }
+    if (isTextNode(node)) {
+      return node.value.replace(/@(\w+)/g, "<at>$1</at>");
+    }
+    if (isStrongNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToTeams(child)).join("");
+      return `**${content}**`;
+    }
+    if (isEmphasisNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToTeams(child)).join("");
+      return `_${content}_`;
+    }
+    if (isDeleteNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToTeams(child)).join("");
+      return `~~${content}~~`;
+    }
+    if (isInlineCodeNode(node)) {
+      return `\`${node.value}\``;
+    }
+    if (isCodeNode(node)) {
+      return `\`\`\`${node.lang || ""}
+${node.value}
 \`\`\``;
-      }
-      case "link": {
-        const linkNode = node;
-        const linkText = linkNode.children.map((child) => this.nodeToTeams(child)).join("");
-        return `[${linkText}](${linkNode.url})`;
-      }
-      case "blockquote":
-        return node.children.map((child) => `> ${this.nodeToTeams(child)}`).join("\n");
-      case "list":
-        return node.children.map((item, i) => {
-          const prefix = node.ordered ? `${i + 1}.` : "-";
-          const content = item.children.map((child) => this.nodeToTeams(child)).join("");
-          return `${prefix} ${content}`;
-        }).join("\n");
-      case "listItem":
-        return node.children.map((child) => this.nodeToTeams(child)).join("");
-      case "break":
-        return "\n";
-      case "thematicBreak":
-        return "---";
-      default:
-        if ("children" in node && Array.isArray(node.children)) {
-          return node.children.map((child) => this.nodeToTeams(child)).join("");
-        }
-        if ("value" in node) {
-          return String(node.value);
-        }
-        return "";
     }
+    if (isLinkNode(node)) {
+      const linkText = getNodeChildren(node).map((child) => this.nodeToTeams(child)).join("");
+      return `[${linkText}](${node.url})`;
+    }
+    if (isBlockquoteNode(node)) {
+      return getNodeChildren(node).map((child) => `> ${this.nodeToTeams(child)}`).join("\n");
+    }
+    if (isListNode(node)) {
+      return getNodeChildren(node).map((item, i) => {
+        const prefix = node.ordered ? `${i + 1}.` : "-";
+        const content = getNodeChildren(item).map((child) => this.nodeToTeams(child)).join("");
+        return `${prefix} ${content}`;
+      }).join("\n");
+    }
+    if (isListItemNode(node)) {
+      return getNodeChildren(node).map((child) => this.nodeToTeams(child)).join("");
+    }
+    if (node.type === "break") {
+      return "\n";
+    }
+    if (node.type === "thematicBreak") {
+      return "---";
+    }
+    const children = getNodeChildren(node);
+    if (children.length > 0) {
+      return children.map((child) => this.nodeToTeams(child)).join("");
+    }
+    return getNodeValue(node);
   }
 };
 
@@ -329,14 +329,18 @@ var TeamsAdapter = class {
   botAdapter;
   graphClient = null;
   chat = null;
-  logger = null;
+  logger;
   formatConverter = new TeamsFormatConverter();
   config;
   constructor(config) {
     this.config = config;
+    this.logger = config.logger;
     this.userName = config.userName || "bot";
     if (config.appType === "SingleTenant" && !config.appTenantId) {
-      throw new Error("appTenantId is required for SingleTenant app type");
+      throw new ValidationError(
+        "teams",
+        "appTenantId is required for SingleTenant app type"
+      );
     }
     const auth = new ConfigurationBotFrameworkAuthentication({
       MicrosoftAppId: config.appId,
@@ -362,16 +366,15 @@ var TeamsAdapter = class {
   }
   async initialize(chat) {
     this.chat = chat;
-    this.logger = chat.getLogger(this.name);
   }
   async handleWebhook(request, options) {
     const body = await request.text();
-    this.logger?.debug("Teams webhook raw body", { body });
+    this.logger.debug("Teams webhook raw body", { body });
     let activity;
     try {
       activity = JSON.parse(body);
     } catch (e) {
-      this.logger?.error("Failed to parse request body", { error: e });
+      this.logger.error("Failed to parse request body", { error: e });
       return new Response("Invalid JSON", { status: 400 });
     }
     const authHeader = request.headers.get("authorization") || "";
@@ -388,7 +391,7 @@ var TeamsAdapter = class {
         headers: { "Content-Type": "application/json" }
       });
     } catch (error) {
-      this.logger?.error("Bot adapter process error", { error });
+      this.logger.error("Bot adapter process error", { error });
       return new Response(JSON.stringify({ error: "Internal error" }), {
         status: 500,
         headers: { "Content-Type": "application/json" }
@@ -397,7 +400,7 @@ var TeamsAdapter = class {
   }
   async handleTurn(context, options) {
     if (!this.chat) {
-      this.logger?.warn("Chat instance not initialized, ignoring event");
+      this.logger.warn("Chat instance not initialized, ignoring event");
       return;
     }
     const activity = context.activity;
@@ -406,9 +409,19 @@ var TeamsAdapter = class {
       const channelData = activity.channelData;
       const tenantId = channelData?.tenant?.id;
       const ttl = 30 * 24 * 60 * 60 * 1e3;
-      this.chat.getState().set(`teams:serviceUrl:${userId}`, activity.serviceUrl, ttl);
+      this.chat.getState().set(`teams:serviceUrl:${userId}`, activity.serviceUrl, ttl).catch((err) => {
+        this.logger.error("Failed to cache serviceUrl", {
+          userId,
+          error: err
+        });
+      });
       if (tenantId) {
-        this.chat.getState().set(`teams:tenantId:${userId}`, tenantId, ttl);
+        this.chat.getState().set(`teams:tenantId:${userId}`, tenantId, ttl).catch((err) => {
+          this.logger.error("Failed to cache tenantId", {
+            userId,
+            error: err
+          });
+        });
       }
       const team = channelData?.team;
       const teamAadGroupId = team?.aadGroupId;
@@ -423,11 +436,21 @@ var TeamsAdapter = class {
           tenantId
         };
         const contextJson = JSON.stringify(context2);
-        this.chat.getState().set(`teams:channelContext:${baseChannelId}`, contextJson, ttl);
+        this.chat.getState().set(`teams:channelContext:${baseChannelId}`, contextJson, ttl).catch((err) => {
+          this.logger.error("Failed to cache channel context", {
+            conversationId: baseChannelId,
+            error: err
+          });
+        });
         if (teamThreadId) {
-          this.chat.getState().set(`teams:teamContext:${teamThreadId}`, contextJson, ttl);
+          this.chat.getState().set(`teams:teamContext:${teamThreadId}`, contextJson, ttl).catch((err) => {
+            this.logger.error("Failed to cache team context", {
+              teamThreadId,
+              error: err
+            });
+          });
         }
-        this.logger?.info(
+        this.logger.info(
           "Cached Teams team GUID from installation/update event",
           {
             activityType: activity.type,
@@ -444,8 +467,13 @@ var TeamsAdapter = class {
             `teams:channelContext:${baseChannelId}`,
             cachedTeamContext,
             ttl
-          );
-          this.logger?.info("Using cached Teams team GUID for channel", {
+          ).catch((err) => {
+            this.logger.error("Failed to cache channel context from team", {
+              conversationId: baseChannelId,
+              error: err
+            });
+          });
+          this.logger.info("Using cached Teams team GUID for channel", {
             conversationId: baseChannelId,
             teamThreadId
           });
@@ -459,9 +487,19 @@ var TeamsAdapter = class {
                 tenantId
               };
               const contextJson = JSON.stringify(fetchedContext);
-              this.chat.getState().set(`teams:channelContext:${baseChannelId}`, contextJson, ttl);
-              this.chat.getState().set(`teams:teamContext:${teamThreadId}`, contextJson, ttl);
-              this.logger?.info(
+              this.chat.getState().set(`teams:channelContext:${baseChannelId}`, contextJson, ttl).catch((err) => {
+                this.logger.error("Failed to cache fetched channel context", {
+                  conversationId: baseChannelId,
+                  error: err
+                });
+              });
+              this.chat.getState().set(`teams:teamContext:${teamThreadId}`, contextJson, ttl).catch((err) => {
+                this.logger.error("Failed to cache fetched team context", {
+                  teamThreadId,
+                  error: err
+                });
+              });
+              this.logger.info(
                 "Fetched and cached Teams team GUID via TeamsInfo API",
                 {
                   conversationId: baseChannelId,
@@ -472,7 +510,7 @@ var TeamsAdapter = class {
               );
             }
           } catch (error) {
-            this.logger?.debug(
+            this.logger.debug(
               "Could not fetch team details (may not be a team scope)",
               { teamThreadId, error }
             );
@@ -489,7 +527,7 @@ var TeamsAdapter = class {
       return;
     }
     if (activity.type !== ActivityTypes.Message) {
-      this.logger?.debug("Ignoring non-message activity", {
+      this.logger.debug("Ignoring non-message activity", {
         type: activity.type
       });
       return;
@@ -536,7 +574,7 @@ var TeamsAdapter = class {
       adapter: this,
       raw: activity
     };
-    this.logger?.debug("Processing Teams message action (Action.Submit)", {
+    this.logger.debug("Processing Teams message action (Action.Submit)", {
       actionId: actionValue.actionId,
       value: actionValue.value,
       messageId: actionEvent.messageId,
@@ -553,7 +591,7 @@ var TeamsAdapter = class {
       await this.handleAdaptiveCardAction(context, activity, options);
       return;
     }
-    this.logger?.debug("Ignoring unsupported invoke", {
+    this.logger.debug("Ignoring unsupported invoke", {
       name: activity.name
     });
   }
@@ -565,7 +603,7 @@ var TeamsAdapter = class {
     if (!this.chat) return;
     const actionData = activity.value?.action?.data;
     if (!actionData?.actionId) {
-      this.logger?.debug("Adaptive card action missing actionId", {
+      this.logger.debug("Adaptive card action missing actionId", {
         value: activity.value
       });
       await context.sendActivity({
@@ -593,7 +631,7 @@ var TeamsAdapter = class {
       adapter: this,
       raw: activity
     };
-    this.logger?.debug("Processing Teams adaptive card action", {
+    this.logger.debug("Processing Teams adaptive card action", {
       actionId: actionData.actionId,
       value: actionData.value,
       messageId: actionEvent.messageId,
@@ -637,7 +675,7 @@ var TeamsAdapter = class {
         threadId,
         raw: activity
       };
-      this.logger?.debug("Processing Teams reaction added", {
+      this.logger.debug("Processing Teams reaction added", {
         emoji: emojiValue.name,
         rawEmoji,
         messageId
@@ -657,7 +695,7 @@ var TeamsAdapter = class {
         threadId,
         raw: activity
       };
-      this.logger?.debug("Processing Teams reaction removed", {
+      this.logger.debug("Processing Teams reaction removed", {
         emoji: emojiValue.name,
         rawEmoji,
         messageId
@@ -718,7 +756,8 @@ var TeamsAdapter = class {
       fetchData: url ? async () => {
         const response = await fetch(url);
         if (!response.ok) {
-          throw new Error(
+          throw new NetworkError(
+            "teams",
             `Failed to fetch file: ${response.status} ${response.statusText}`
           );
         }
@@ -732,9 +771,9 @@ var TeamsAdapter = class {
   }
   async postMessage(threadId, message) {
     const { conversationId, serviceUrl } = this.decodeThreadId(threadId);
-    const files = this.extractFiles(message);
+    const files = extractFiles(message);
     const fileAttachments = files.length > 0 ? await this.filesToAttachments(files) : [];
-    const card = this.extractCard(message);
+    const card = extractCard(message);
     let activity;
     if (card) {
       const adaptiveCard = cardToAdaptiveCard(card);
@@ -749,13 +788,13 @@ var TeamsAdapter = class {
           ...fileAttachments
         ]
       };
-      this.logger?.debug("Teams API: sendActivity (adaptive card)", {
+      this.logger.debug("Teams API: sendActivity (adaptive card)", {
         conversationId,
         serviceUrl,
         fileCount: fileAttachments.length
       });
     } else {
-      const text = convertEmojiPlaceholders2(
+      const text = convertEmojiPlaceholders(
         this.formatConverter.renderPostable(message),
         "teams"
       );
@@ -765,7 +804,7 @@ var TeamsAdapter = class {
         textFormat: "markdown",
         attachments: fileAttachments.length > 0 ? fileAttachments : void 0
       };
-      this.logger?.debug("Teams API: sendActivity (message)", {
+      this.logger.debug("Teams API: sendActivity (message)", {
         conversationId,
         serviceUrl,
         textLength: text.length,
@@ -778,42 +817,29 @@ var TeamsAdapter = class {
       conversation: { id: conversationId }
     };
     let messageId = "";
-    await this.botAdapter.continueConversationAsync(
-      this.config.appId,
-      conversationReference,
-      async (context) => {
-        const response = await context.sendActivity(activity);
-        messageId = response?.id || "";
-      }
-    );
-    this.logger?.debug("Teams API: sendActivity response", { messageId });
+    try {
+      await this.botAdapter.continueConversationAsync(
+        this.config.appId,
+        conversationReference,
+        async (context) => {
+          const response = await context.sendActivity(activity);
+          messageId = response?.id || "";
+        }
+      );
+    } catch (error) {
+      this.logger.error("Teams API: sendActivity failed", {
+        conversationId,
+        error
+      });
+      this.handleTeamsError(error, "postMessage");
+    }
+    this.logger.debug("Teams API: sendActivity response", { messageId });
     return {
       id: messageId,
       threadId,
       raw: activity
     };
   }
-  /**
-   * Extract card element from a AdapterPostableMessage if present.
-   */
-  extractCard(message) {
-    if (isCardElement(message)) {
-      return message;
-    }
-    if (typeof message === "object" && message !== null && "card" in message) {
-      return message.card;
-    }
-    return null;
-  }
-  /**
-   * Extract files from a AdapterPostableMessage if present.
-   */
-  extractFiles(message) {
-    if (typeof message === "object" && message !== null && "files" in message) {
-      return message.files ?? [];
-    }
-    return [];
-  }
   /**
    * Convert files to Teams attachments.
    * Uses inline data URIs for small files.
@@ -821,20 +847,15 @@ var TeamsAdapter = class {
   async filesToAttachments(files) {
     const attachments = [];
     for (const file of files) {
-      let buffer;
-      if (Buffer.isBuffer(file.data)) {
-        buffer = file.data;
-      } else if (file.data instanceof ArrayBuffer) {
-        buffer = Buffer.from(file.data);
-      } else if (file.data instanceof Blob) {
-        const arrayBuffer = await file.data.arrayBuffer();
-        buffer = Buffer.from(arrayBuffer);
-      } else {
+      const buffer = await toBuffer(file.data, {
+        platform: "teams",
+        throwOnUnsupported: false
+      });
+      if (!buffer) {
         continue;
       }
       const mimeType = file.mimeType || "application/octet-stream";
-      const base64 = buffer.toString("base64");
-      const dataUri = `data:${mimeType};base64,${base64}`;
+      const dataUri = bufferToDataUri(buffer, mimeType);
       attachments.push({
         contentType: mimeType,
         contentUrl: dataUri,
@@ -845,7 +866,7 @@ var TeamsAdapter = class {
   }
   async editMessage(threadId, messageId, message) {
     const { conversationId, serviceUrl } = this.decodeThreadId(threadId);
-    const card = this.extractCard(message);
+    const card = extractCard(message);
     let activity;
     if (card) {
       const adaptiveCard = cardToAdaptiveCard(card);
@@ -860,12 +881,12 @@ var TeamsAdapter = class {
           }
         ]
       };
-      this.logger?.debug("Teams API: updateActivity (adaptive card)", {
+      this.logger.debug("Teams API: updateActivity (adaptive card)", {
         conversationId,
         messageId
       });
     } else {
-      const text = convertEmojiPlaceholders2(
+      const text = convertEmojiPlaceholders(
         this.formatConverter.renderPostable(message),
         "teams"
       );
@@ -875,7 +896,7 @@ var TeamsAdapter = class {
         text,
         textFormat: "markdown"
       };
-      this.logger?.debug("Teams API: updateActivity", {
+      this.logger.debug("Teams API: updateActivity", {
         conversationId,
         messageId,
         textLength: text.length
@@ -886,14 +907,23 @@ var TeamsAdapter = class {
       serviceUrl,
       conversation: { id: conversationId }
     };
-    await this.botAdapter.continueConversationAsync(
-      this.config.appId,
-      conversationReference,
-      async (context) => {
-        await context.updateActivity(activity);
-      }
-    );
-    this.logger?.debug("Teams API: updateActivity response", { ok: true });
+    try {
+      await this.botAdapter.continueConversationAsync(
+        this.config.appId,
+        conversationReference,
+        async (context) => {
+          await context.updateActivity(activity);
+        }
+      );
+    } catch (error) {
+      this.logger.error("Teams API: updateActivity failed", {
+        conversationId,
+        messageId,
+        error
+      });
+      this.handleTeamsError(error, "editMessage");
+    }
+    this.logger.debug("Teams API: updateActivity response", { ok: true });
     return {
       id: messageId,
       threadId,
@@ -907,18 +937,27 @@ var TeamsAdapter = class {
       serviceUrl,
       conversation: { id: conversationId }
     };
-    this.logger?.debug("Teams API: deleteActivity", {
+    this.logger.debug("Teams API: deleteActivity", {
       conversationId,
       messageId
     });
-    await this.botAdapter.continueConversationAsync(
-      this.config.appId,
-      conversationReference,
-      async (context) => {
-        await context.deleteActivity(messageId);
-      }
-    );
-    this.logger?.debug("Teams API: deleteActivity response", { ok: true });
+    try {
+      await this.botAdapter.continueConversationAsync(
+        this.config.appId,
+        conversationReference,
+        async (context) => {
+          await context.deleteActivity(messageId);
+        }
+      );
+    } catch (error) {
+      this.logger.error("Teams API: deleteActivity failed", {
+        conversationId,
+        messageId,
+        error
+      });
+      this.handleTeamsError(error, "deleteMessage");
+    }
+    this.logger.debug("Teams API: deleteActivity response", { ok: true });
   }
   async addReaction(_threadId, _messageId, _emoji) {
     throw new NotImplementedError(
@@ -939,15 +978,23 @@ var TeamsAdapter = class {
       serviceUrl,
       conversation: { id: conversationId }
     };
-    this.logger?.debug("Teams API: sendActivity (typing)", { conversationId });
-    await this.botAdapter.continueConversationAsync(
-      this.config.appId,
-      conversationReference,
-      async (context) => {
-        await context.sendActivity({ type: ActivityTypes.Typing });
-      }
-    );
-    this.logger?.debug("Teams API: sendActivity (typing) response", {
+    this.logger.debug("Teams API: sendActivity (typing)", { conversationId });
+    try {
+      await this.botAdapter.continueConversationAsync(
+        this.config.appId,
+        conversationReference,
+        async (context) => {
+          await context.sendActivity({ type: ActivityTypes.Typing });
+        }
+      );
+    } catch (error) {
+      this.logger.error("Teams API: sendActivity (typing) failed", {
+        conversationId,
+        error
+      });
+      this.handleTeamsError(error, "startTyping");
+    }
+    this.logger.debug("Teams API: sendActivity (typing) response", {
       ok: true
     });
   }
@@ -963,7 +1010,7 @@ var TeamsAdapter = class {
     const cachedTenantId = await this.chat?.getState().get(`teams:tenantId:${userId}`);
     const serviceUrl = cachedServiceUrl || "https://smba.trafficmanager.net/teams/";
     const tenantId = cachedTenantId || this.config.appTenantId;
-    this.logger?.debug("Teams: creating 1:1 conversation", {
+    this.logger.debug("Teams: creating 1:1 conversation", {
       userId,
       serviceUrl,
       tenantId,
@@ -971,7 +1018,8 @@ var TeamsAdapter = class {
       cachedTenantId: !!cachedTenantId
     });
     if (!tenantId) {
-      throw new Error(
+      throw new ValidationError(
+        "teams",
         "Cannot open DM: tenant ID not found. User must interact with the bot first (via @mention) to cache their tenant ID."
       );
     }
@@ -993,16 +1041,19 @@ var TeamsAdapter = class {
       },
       async (turnContext) => {
         conversationId = turnContext?.activity?.conversation?.id || "";
-        this.logger?.debug("Teams: conversation created in callback", {
+        this.logger.debug("Teams: conversation created in callback", {
           conversationId,
           activityId: turnContext?.activity?.id
         });
       }
     );
     if (!conversationId) {
-      throw new Error("Failed to create 1:1 conversation - no ID returned");
+      throw new NetworkError(
+        "teams",
+        "Failed to create 1:1 conversation - no ID returned"
+      );
     }
-    this.logger?.debug("Teams: 1:1 conversation created", { conversationId });
+    this.logger.debug("Teams: 1:1 conversation created", { conversationId });
     return this.encodeThreadId({
       conversationId,
       serviceUrl
@@ -1033,7 +1084,7 @@ var TeamsAdapter = class {
       }
     }
     try {
-      this.logger?.debug("Teams Graph API: fetching messages", {
+      this.logger.debug("Teams Graph API: fetching messages", {
         conversationId: baseConversationId,
         threadMessageId,
         hasChannelContext: !!channelContext,
@@ -1086,12 +1137,12 @@ var TeamsAdapter = class {
         graphMessages = graphMessages.filter((msg) => {
           return msg.id && msg.id >= threadMessageId;
         });
-        this.logger?.debug("Filtered group chat messages to thread", {
+        this.logger.debug("Filtered group chat messages to thread", {
           threadMessageId,
           filteredCount: graphMessages.length
         });
       }
-      this.logger?.debug("Teams Graph API: fetched messages", {
+      this.logger.debug("Teams Graph API: fetched messages", {
         count: graphMessages.length,
         direction,
         hasMoreMessages
@@ -1136,7 +1187,7 @@ var TeamsAdapter = class {
       }
       return { messages, nextCursor };
     } catch (error) {
-      this.logger?.error("Teams Graph API: fetchMessages error", { error });
+      this.logger.error("Teams Graph API: fetchMessages error", { error });
       if (error instanceof Error && error.message?.includes("403")) {
         throw new NotImplementedError(
           "Teams fetchMessages requires one of these Azure AD app permissions: ChatMessage.Read.Chat, Chat.Read.All, or Chat.Read.WhereInstalled",
@@ -1156,7 +1207,7 @@ var TeamsAdapter = class {
     const limit = options.limit || 50;
     const cursor = options.cursor;
     const direction = options.direction ?? "backward";
-    this.logger?.debug("Teams Graph API: fetching channel thread messages", {
+    this.logger.debug("Teams Graph API: fetching channel thread messages", {
       teamId: context.teamId,
       channelId: context.channelId,
       threadMessageId,
@@ -1168,13 +1219,13 @@ var TeamsAdapter = class {
     const repliesUrl = `${parentUrl}/replies`;
     const graphClient = this.graphClient;
     if (!graphClient) {
-      throw new Error("Graph client not initialized");
+      throw new AuthenticationError("teams", "Graph client not initialized");
     }
     let parentMessage = null;
     try {
       parentMessage = await graphClient.api(parentUrl).get();
     } catch (err) {
-      this.logger?.warn("Failed to fetch parent message", {
+      this.logger.warn("Failed to fetch parent message", {
         threadMessageId,
         err
       });
@@ -1231,7 +1282,7 @@ var TeamsAdapter = class {
         hasMoreMessages = allMessages.length > limit;
       }
     }
-    this.logger?.debug("Teams Graph API: fetched channel thread messages", {
+    this.logger.debug("Teams Graph API: fetched channel thread messages", {
       count: graphMessages.length,
       direction,
       hasMoreMessages
@@ -1376,7 +1427,10 @@ var TeamsAdapter = class {
   decodeThreadId(threadId) {
     const parts = threadId.split(":");
     if (parts.length !== 3 || parts[0] !== "teams") {
-      throw new Error(`Invalid Teams thread ID: ${threadId}`);
+      throw new ValidationError(
+        "teams",
+        `Invalid Teams thread ID: ${threadId}`
+      );
     }
     const conversationId = Buffer.from(
       parts[1],
@@ -1421,6 +1475,47 @@ var TeamsAdapter = class {
   renderFormatted(content) {
     return this.formatConverter.fromAst(content);
   }
+  /**
+   * Convert Teams/BotBuilder errors to standardized AdapterError types.
+   */
+  handleTeamsError(error, operation) {
+    if (error && typeof error === "object") {
+      const err = error;
+      const statusCode = err.statusCode || err.status || err.code;
+      if (statusCode === 401 || statusCode === 403) {
+        throw new AuthenticationError(
+          "teams",
+          `Authentication failed for ${operation}: ${err.message || "unauthorized"}`
+        );
+      }
+      if (statusCode === 404) {
+        throw new NetworkError(
+          "teams",
+          `Resource not found during ${operation}: conversation or message may no longer exist`,
+          error instanceof Error ? error : void 0
+        );
+      }
+      if (statusCode === 429) {
+        const retryAfter = typeof err.retryAfter === "number" ? err.retryAfter : void 0;
+        throw new AdapterRateLimitError("teams", retryAfter);
+      }
+      if (statusCode === 403 || err.message && typeof err.message === "string" && err.message.toLowerCase().includes("permission")) {
+        throw new PermissionError("teams", operation);
+      }
+      if (err.message && typeof err.message === "string") {
+        throw new NetworkError(
+          "teams",
+          `Teams API error during ${operation}: ${err.message}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+    throw new NetworkError(
+      "teams",
+      `Teams API error during ${operation}: ${String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
 };
 function createTeamsAdapter(config) {
   return new TeamsAdapter(config);