@chat-adapter/gchat 4.1.0 → 4.3.0

package/dist/index.js

@@ -1,19 +1,21 @@
 // src/index.ts
 import {
-  convertEmojiPlaceholders as convertEmojiPlaceholders2,
-  defaultEmojiResolver,
-  isCardElement,
-  RateLimitError
-} from "chat";
+  AdapterRateLimitError,
+  AuthenticationError,
+  extractCard,
+  extractFiles,
+  NetworkError,
+  ValidationError as ValidationError2
+} from "@chat-adapter/shared";
+import { convertEmojiPlaceholders, defaultEmojiResolver } from "chat";
 import { google as google2 } from "googleapis";
 
 // src/cards.ts
 import {
-  convertEmojiPlaceholders
-} from "chat";
-function convertEmoji(text) {
-  return convertEmojiPlaceholders(text, "gchat");
-}
+  createEmojiConverter,
+  cardToFallbackText as sharedCardToFallbackText
+} from "@chat-adapter/shared";
+var convertEmoji = createEmojiConverter("gchat");
 function cardToGoogleCard(card, options) {
   const opts = typeof options === "string" ? { cardId: options } : options || {};
   const sections = [];
@@ -154,39 +156,29 @@ function convertFieldsToWidgets(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");
-}
-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",
+    platform: "gchat"
+  });
 }
 
 // src/markdown.ts
 import {
   BaseFormatConverter,
+  getNodeChildren,
+  getNodeValue,
+  isBlockquoteNode,
+  isCodeNode,
+  isDeleteNode,
+  isEmphasisNode,
+  isInlineCodeNode,
+  isLinkNode,
+  isListItemNode,
+  isListNode,
+  isParagraphNode,
+  isStrongNode,
+  isTextNode,
   parseMarkdown
 } from "chat";
 var GoogleChatFormatConverter = class extends BaseFormatConverter {
@@ -194,11 +186,7 @@ var GoogleChatFormatConverter = class extends BaseFormatConverter {
    * Render an AST to Google Chat format.
    */
   fromAst(ast) {
-    const parts = [];
-    for (const node of ast.children) {
-      parts.push(this.nodeToGChat(node));
-    }
-    return parts.join("\n\n");
+    return this.fromAstWithNodeConverter(ast, (node) => this.nodeToGChat(node));
   }
   /**
    * Parse Google Chat message into an AST.
@@ -210,57 +198,155 @@ var GoogleChatFormatConverter = class extends BaseFormatConverter {
     return parseMarkdown(markdown);
   }
   nodeToGChat(node) {
-    switch (node.type) {
-      case "paragraph":
-        return node.children.map((child) => this.nodeToGChat(child)).join("");
-      case "text": {
-        return node.value;
-      }
-      case "strong":
-        return `*${node.children.map((child) => this.nodeToGChat(child)).join("")}*`;
-      case "emphasis":
-        return `_${node.children.map((child) => this.nodeToGChat(child)).join("")}_`;
-      case "delete":
-        return `~${node.children.map((child) => this.nodeToGChat(child)).join("")}~`;
-      case "inlineCode":
-        return `\`${node.value}\``;
-      case "code": {
-        const codeNode = node;
-        return `\`\`\`
-${codeNode.value}
+    if (isParagraphNode(node)) {
+      return getNodeChildren(node).map((child) => this.nodeToGChat(child)).join("");
+    }
+    if (isTextNode(node)) {
+      return node.value;
+    }
+    if (isStrongNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToGChat(child)).join("");
+      return `*${content}*`;
+    }
+    if (isEmphasisNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToGChat(child)).join("");
+      return `_${content}_`;
+    }
+    if (isDeleteNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToGChat(child)).join("");
+      return `~${content}~`;
+    }
+    if (isInlineCodeNode(node)) {
+      return `\`${node.value}\``;
+    }
+    if (isCodeNode(node)) {
+      return `\`\`\`
+${node.value}
 \`\`\``;
+    }
+    if (isLinkNode(node)) {
+      const linkText = getNodeChildren(node).map((child) => this.nodeToGChat(child)).join("");
+      if (linkText === node.url) {
+        return node.url;
       }
-      case "link": {
-        const linkNode = node;
-        const linkText = linkNode.children.map((child) => this.nodeToGChat(child)).join("");
-        if (linkText === linkNode.url) {
-          return linkNode.url;
-        }
-        return `${linkText} (${linkNode.url})`;
-      }
-      case "blockquote":
-        return node.children.map((child) => `> ${this.nodeToGChat(child)}`).join("\n");
-      case "list":
-        return node.children.map((item, i) => {
-          const prefix = node.ordered ? `${i + 1}.` : "\u2022";
-          const content = item.children.map((child) => this.nodeToGChat(child)).join("");
-          return `${prefix} ${content}`;
-        }).join("\n");
-      case "listItem":
-        return node.children.map((child) => this.nodeToGChat(child)).join("");
-      case "break":
-        return "\n";
-      case "thematicBreak":
-        return "---";
-      default:
-        if ("children" in node && Array.isArray(node.children)) {
-          return node.children.map((child) => this.nodeToGChat(child)).join("");
-        }
-        if ("value" in node) {
-          return String(node.value);
-        }
-        return "";
+      return `${linkText} (${node.url})`;
+    }
+    if (isBlockquoteNode(node)) {
+      return getNodeChildren(node).map((child) => `> ${this.nodeToGChat(child)}`).join("\n");
+    }
+    if (isListNode(node)) {
+      return getNodeChildren(node).map((item, i) => {
+        const prefix = node.ordered ? `${i + 1}.` : "\u2022";
+        const content = getNodeChildren(item).map((child) => this.nodeToGChat(child)).join("");
+        return `${prefix} ${content}`;
+      }).join("\n");
+    }
+    if (isListItemNode(node)) {
+      return getNodeChildren(node).map((child) => this.nodeToGChat(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.nodeToGChat(child)).join("");
     }
+    return getNodeValue(node);
+  }
+};
+
+// src/thread-utils.ts
+import { ValidationError } from "@chat-adapter/shared";
+function encodeThreadId(platformData) {
+  const threadPart = platformData.threadName ? `:${Buffer.from(platformData.threadName).toString("base64url")}` : "";
+  const dmPart = platformData.isDM ? ":dm" : "";
+  return `gchat:${platformData.spaceName}${threadPart}${dmPart}`;
+}
+function decodeThreadId(threadId) {
+  const isDM = threadId.endsWith(":dm");
+  const cleanId = isDM ? threadId.slice(0, -3) : threadId;
+  const parts = cleanId.split(":");
+  if (parts.length < 2 || parts[0] !== "gchat") {
+    throw new ValidationError(
+      "gchat",
+      `Invalid Google Chat thread ID: ${threadId}`
+    );
+  }
+  const spaceName = parts[1];
+  const threadName = parts[2] ? Buffer.from(parts[2], "base64url").toString("utf-8") : void 0;
+  return { spaceName, threadName, isDM };
+}
+function isDMThread(threadId) {
+  return threadId.endsWith(":dm");
+}
+
+// src/user-info.ts
+var USER_INFO_KEY_PREFIX = "gchat:user:";
+var USER_INFO_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var UserInfoCache = class {
+  constructor(state, logger) {
+    this.state = state;
+    this.logger = logger;
+  }
+  inMemoryCache = /* @__PURE__ */ new Map();
+  /**
+   * Cache user info for later lookup.
+   */
+  async set(userId, displayName, email) {
+    if (!displayName || displayName === "unknown") return;
+    const userInfo = { displayName, email };
+    this.inMemoryCache.set(userId, userInfo);
+    if (this.state) {
+      const cacheKey = `${USER_INFO_KEY_PREFIX}${userId}`;
+      await this.state.set(
+        cacheKey,
+        userInfo,
+        USER_INFO_CACHE_TTL_MS
+      );
+    }
+  }
+  /**
+   * Get cached user info. Checks in-memory cache first, then falls back to state adapter.
+   */
+  async get(userId) {
+    const inMemory = this.inMemoryCache.get(userId);
+    if (inMemory) {
+      return inMemory;
+    }
+    if (!this.state) return null;
+    const cacheKey = `${USER_INFO_KEY_PREFIX}${userId}`;
+    const fromState = await this.state.get(cacheKey);
+    if (fromState) {
+      this.inMemoryCache.set(userId, fromState);
+    }
+    return fromState;
+  }
+  /**
+   * Resolve user display name, using cache if available.
+   *
+   * @param userId - The user's resource name (e.g., "users/123456")
+   * @param providedDisplayName - Display name from the message if available
+   * @param botUserId - The bot's user ID (for self-identification)
+   * @param botUserName - The bot's configured username
+   */
+  async resolveDisplayName(userId, providedDisplayName, botUserId, botUserName) {
+    if (providedDisplayName && providedDisplayName !== "unknown") {
+      this.set(userId, providedDisplayName).catch((err) => {
+        this.logger.error("Failed to cache user info", { userId, error: err });
+      });
+      return providedDisplayName;
+    }
+    if (botUserId && userId === botUserId) {
+      return botUserName;
+    }
+    const cached = await this.get(userId);
+    if (cached?.displayName) {
+      return cached.displayName;
+    }
+    return userId.replace("users/", "User ");
   }
 };
 
@@ -409,8 +495,6 @@ function verifyPubSubRequest(request, _expectedAudience) {
 var SUBSCRIPTION_REFRESH_BUFFER_MS = 60 * 60 * 1e3;
 var SUBSCRIPTION_CACHE_TTL_MS = 25 * 60 * 60 * 1e3;
 var SPACE_SUB_KEY_PREFIX = "gchat:space-sub:";
-var USER_INFO_KEY_PREFIX = "gchat:user:";
-var USER_INFO_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var GoogleChatAdapter = class {
   name = "gchat";
   userName;
@@ -419,7 +503,7 @@ var GoogleChatAdapter = class {
   chatApi;
   chat = null;
   state = null;
-  logger = null;
+  logger;
   formatConverter = new GoogleChatFormatConverter();
   pubsubTopic;
   credentials;
@@ -436,8 +520,12 @@ var GoogleChatAdapter = class {
   impersonatedChatApi;
   /** HTTP endpoint URL for button click actions */
   endpointUrl;
+  /** User info cache for display name lookups - initialized later in initialize() */
+  userInfoCache;
   constructor(config) {
+    this.logger = config.logger;
     this.userName = config.userName || "bot";
+    this.userInfoCache = new UserInfoCache(null, this.logger);
     this.pubsubTopic = config.pubsubTopic;
     this.impersonateUser = config.impersonateUser;
     this.endpointUrl = config.endpointUrl;
@@ -465,7 +553,8 @@ var GoogleChatAdapter = class {
       this.customAuth = config.auth;
       auth = config.auth;
     } else {
-      throw new Error(
+      throw new ValidationError2(
+        "gchat",
         "GoogleChatAdapter requires one of: credentials, useApplicationDefaultCredentials, or auth"
       );
     }
@@ -508,12 +597,12 @@ var GoogleChatAdapter = class {
   async initialize(chat) {
     this.chat = chat;
     this.state = chat.getState();
-    this.logger = chat.getLogger(this.name);
+    this.userInfoCache = new UserInfoCache(this.state, this.logger);
     if (!this.botUserId) {
       const savedBotUserId = await this.state.get("gchat:botUserId");
       if (savedBotUserId) {
         this.botUserId = savedBotUserId;
-        this.logger?.debug("Restored bot user ID from state", {
+        this.logger.debug("Restored bot user ID from state", {
           botUserId: this.botUserId
         });
       }
@@ -524,13 +613,13 @@ var GoogleChatAdapter = class {
    * Ensures the space has a Workspace Events subscription so we receive all messages.
    */
   async onThreadSubscribe(threadId) {
-    this.logger?.info("onThreadSubscribe called", {
+    this.logger.info("onThreadSubscribe called", {
       threadId,
       hasPubsubTopic: !!this.pubsubTopic,
       pubsubTopic: this.pubsubTopic
     });
     if (!this.pubsubTopic) {
-      this.logger?.warn(
+      this.logger.warn(
         "No pubsubTopic configured, skipping space subscription. Set GOOGLE_CHAT_PUBSUB_TOPIC env var."
       );
       return;
@@ -543,7 +632,7 @@ var GoogleChatAdapter = class {
    * Creates one if it doesn't exist or is about to expire.
    */
   async ensureSpaceSubscription(spaceName) {
-    this.logger?.info("ensureSpaceSubscription called", {
+    this.logger.info("ensureSpaceSubscription called", {
       spaceName,
       hasPubsubTopic: !!this.pubsubTopic,
       hasState: !!this.state,
@@ -551,7 +640,7 @@ var GoogleChatAdapter = class {
       hasADC: this.useADC
     });
     if (!this.pubsubTopic || !this.state) {
-      this.logger?.warn("ensureSpaceSubscription skipped - missing config", {
+      this.logger.warn("ensureSpaceSubscription skipped - missing config", {
         hasPubsubTopic: !!this.pubsubTopic,
         hasState: !!this.state
       });
@@ -562,20 +651,20 @@ var GoogleChatAdapter = class {
     if (cached) {
       const timeUntilExpiry = cached.expireTime - Date.now();
       if (timeUntilExpiry > SUBSCRIPTION_REFRESH_BUFFER_MS) {
-        this.logger?.debug("Space subscription still valid", {
+        this.logger.debug("Space subscription still valid", {
           spaceName,
           expiresIn: Math.round(timeUntilExpiry / 1e3 / 60)
         });
         return;
       }
-      this.logger?.debug("Space subscription expiring soon, will refresh", {
+      this.logger.debug("Space subscription expiring soon, will refresh", {
         spaceName,
         expiresIn: Math.round(timeUntilExpiry / 1e3 / 60)
       });
     }
     const pending = this.pendingSubscriptions.get(spaceName);
     if (pending) {
-      this.logger?.debug("Subscription creation already in progress", {
+      this.logger.debug("Subscription creation already in progress", {
         spaceName
       });
       return pending;
@@ -596,14 +685,14 @@ var GoogleChatAdapter = class {
    */
   async createSpaceSubscriptionWithCache(spaceName, cacheKey) {
     const authOptions = this.getAuthOptions();
-    this.logger?.info("createSpaceSubscriptionWithCache", {
+    this.logger.info("createSpaceSubscriptionWithCache", {
       spaceName,
       hasAuthOptions: !!authOptions,
       hasCredentials: !!this.credentials,
       hasADC: this.useADC
     });
     if (!authOptions) {
-      this.logger?.error(
+      this.logger.error(
         "Cannot create subscription: no auth configured. Use GOOGLE_CHAT_CREDENTIALS, GOOGLE_CHAT_USE_ADC=true, or custom auth."
       );
       return;
@@ -616,7 +705,7 @@ var GoogleChatAdapter = class {
         authOptions
       );
       if (existing) {
-        this.logger?.debug("Found existing subscription", {
+        this.logger.debug("Found existing subscription", {
           spaceName,
           subscriptionName: existing.subscriptionName
         });
@@ -629,7 +718,7 @@ var GoogleChatAdapter = class {
         }
         return;
       }
-      this.logger?.info("Creating Workspace Events subscription", {
+      this.logger.info("Creating Workspace Events subscription", {
         spaceName,
         pubsubTopic
       });
@@ -648,13 +737,13 @@ var GoogleChatAdapter = class {
           SUBSCRIPTION_CACHE_TTL_MS
         );
       }
-      this.logger?.info("Workspace Events subscription created", {
+      this.logger.info("Workspace Events subscription created", {
         spaceName,
         subscriptionName: result.name,
         expireTime: result.expireTime
       });
     } catch (error) {
-      this.logger?.error("Failed to create Workspace Events subscription", {
+      this.logger.error("Failed to create Workspace Events subscription", {
         spaceName,
         error
       });
@@ -679,7 +768,7 @@ var GoogleChatAdapter = class {
         }
       }
     } catch (error) {
-      this.logger?.debug("Error checking existing subscriptions", { error });
+      this.logger.error("Error checking existing subscriptions", { error });
     }
     return null;
   }
@@ -709,14 +798,14 @@ var GoogleChatAdapter = class {
       try {
         const url = new URL(request.url);
         this.endpointUrl = url.toString();
-        this.logger?.debug("Auto-detected endpoint URL", {
+        this.logger.debug("Auto-detected endpoint URL", {
           endpointUrl: this.endpointUrl
         });
       } catch {
       }
     }
     const body = await request.text();
-    this.logger?.debug("GChat webhook raw body", { body });
+    this.logger.debug("GChat webhook raw body", { body });
     let parsed;
     try {
       parsed = JSON.parse(body);
@@ -730,7 +819,7 @@ var GoogleChatAdapter = class {
     const event = parsed;
     const addedPayload = event.chat?.addedToSpacePayload;
     if (addedPayload) {
-      this.logger?.debug("Bot added to space", {
+      this.logger.debug("Bot added to space", {
         space: addedPayload.space.name,
         spaceType: addedPayload.space.type
       });
@@ -738,7 +827,7 @@ var GoogleChatAdapter = class {
     }
     const removedPayload = event.chat?.removedFromSpacePayload;
     if (removedPayload) {
-      this.logger?.debug("Bot removed from space", {
+      this.logger.debug("Bot removed from space", {
         space: removedPayload.space.name
       });
     }
@@ -752,14 +841,14 @@ var GoogleChatAdapter = class {
     }
     const messagePayload = event.chat?.messagePayload;
     if (messagePayload) {
-      this.logger?.debug("message event", {
+      this.logger.debug("message event", {
         space: messagePayload.space.name,
         sender: messagePayload.message.sender?.displayName,
         text: messagePayload.message.text?.slice(0, 50)
       });
       this.handleMessageEvent(event, options);
     } else if (!addedPayload && !removedPayload) {
-      this.logger?.debug("Non-message event received", {
+      this.logger.debug("Non-message event received", {
         hasChat: !!event.chat,
         hasCommonEventObject: !!event.commonEventObject
       });
@@ -780,14 +869,14 @@ var GoogleChatAdapter = class {
       "google.workspace.chat.reaction.v1.deleted"
     ];
     if (eventType && !allowedEventTypes.includes(eventType)) {
-      this.logger?.debug("Skipping unsupported Pub/Sub event", { eventType });
+      this.logger.debug("Skipping unsupported Pub/Sub event", { eventType });
       return new Response(JSON.stringify({ success: true }), {
         headers: { "Content-Type": "application/json" }
       });
     }
     try {
       const notification = decodePubSubMessage(pushMessage);
-      this.logger?.debug("Pub/Sub notification decoded", {
+      this.logger.debug("Pub/Sub notification decoded", {
         eventType: notification.eventType,
         messageId: notification.message?.name,
         reactionName: notification.reaction?.name
@@ -802,7 +891,7 @@ var GoogleChatAdapter = class {
         headers: { "Content-Type": "application/json" }
       });
     } catch (error) {
-      this.logger?.error("Error processing Pub/Sub message", { error });
+      this.logger.error("Error processing Pub/Sub message", { error });
       return new Response(JSON.stringify({ error: "Processing failed" }), {
         status: 200,
         headers: { "Content-Type": "application/json" }
@@ -830,7 +919,10 @@ var GoogleChatAdapter = class {
     if (resolvedSpaceName && options?.waitUntil) {
       options.waitUntil(
         this.ensureSpaceSubscription(resolvedSpaceName).catch((err) => {
-          this.logger?.debug("Subscription refresh failed", { error: err });
+          this.logger.error("Subscription refresh failed", {
+            spaceName: resolvedSpaceName,
+            error: err
+          });
         })
       );
     }
@@ -876,13 +968,13 @@ var GoogleChatAdapter = class {
             spaceName: spaceName || "",
             threadName: threadName ?? void 0
           });
-          this.logger?.debug("Fetched thread context for reaction", {
+          this.logger.debug("Fetched thread context for reaction", {
             messageName,
             threadName,
             threadId
           });
         } catch (error) {
-          this.logger?.warn("Failed to fetch message for thread context", {
+          this.logger.warn("Failed to fetch message for thread context", {
             messageName,
             error
           });
@@ -926,15 +1018,17 @@ var GoogleChatAdapter = class {
   async parsePubSubMessage(notification, threadId) {
     const message = notification.message;
     if (!message) {
-      throw new Error("PubSub notification missing message");
+      throw new ValidationError2("gchat", "PubSub notification missing message");
     }
     const text = this.normalizeBotMentions(message);
     const isBot = message.sender?.type === "BOT";
     const isMe = this.isMessageFromSelf(message);
     const userId = message.sender?.name || "unknown";
-    const displayName = await this.resolveUserDisplayName(
+    const displayName = await this.userInfoCache.resolveDisplayName(
       userId,
-      message.sender?.displayName
+      message.sender?.displayName,
+      this.botUserId,
+      this.userName
     );
     const parsedMessage = {
       id: message.name,
@@ -957,7 +1051,7 @@ var GoogleChatAdapter = class {
         (att) => this.createAttachment(att)
       )
     };
-    this.logger?.debug("Pub/Sub parsed message", {
+    this.logger.debug("Pub/Sub parsed message", {
       threadId,
       messageId: parsedMessage.id,
       text: parsedMessage.text,
@@ -983,14 +1077,14 @@ var GoogleChatAdapter = class {
    */
   handleCardClick(event, options) {
     if (!this.chat) {
-      this.logger?.warn("Chat instance not initialized, ignoring card click");
+      this.logger.warn("Chat instance not initialized, ignoring card click");
       return;
     }
     const buttonPayload = event.chat?.buttonClickedPayload;
     const commonEvent = event.commonEventObject;
     const actionId = commonEvent?.parameters?.actionId || commonEvent?.invokedFunction;
     if (!actionId) {
-      this.logger?.debug("Card click missing actionId", {
+      this.logger.debug("Card click missing actionId", {
         parameters: commonEvent?.parameters,
         invokedFunction: commonEvent?.invokedFunction
       });
@@ -1001,7 +1095,7 @@ var GoogleChatAdapter = class {
     const message = buttonPayload?.message;
     const user = buttonPayload?.user || event.chat?.user;
     if (!space) {
-      this.logger?.warn("Card click missing space info");
+      this.logger.warn("Card click missing space info");
       return;
     }
     const threadName = message?.thread?.name || message?.name;
@@ -1024,7 +1118,7 @@ var GoogleChatAdapter = class {
       adapter: this,
       raw: event
     };
-    this.logger?.debug("Processing GChat card click", {
+    this.logger.debug("Processing GChat card click", {
       actionId,
       value,
       messageId: actionEvent.messageId,
@@ -1037,12 +1131,12 @@ var GoogleChatAdapter = class {
    */
   handleMessageEvent(event, options) {
     if (!this.chat) {
-      this.logger?.warn("Chat instance not initialized, ignoring event");
+      this.logger.warn("Chat instance not initialized, ignoring event");
       return;
     }
     const messagePayload = event.chat?.messagePayload;
     if (!messagePayload) {
-      this.logger?.debug("Ignoring event without messagePayload");
+      this.logger.debug("Ignoring event without messagePayload");
       return;
     }
     const message = messagePayload.message;
@@ -1063,7 +1157,7 @@ var GoogleChatAdapter = class {
   parseGoogleChatMessage(event, threadId) {
     const message = event.chat?.messagePayload?.message;
     if (!message) {
-      throw new Error("Event has no message payload");
+      throw new ValidationError2("gchat", "Event has no message payload");
     }
     const text = this.normalizeBotMentions(message);
     const isBot = message.sender?.type === "BOT";
@@ -1071,10 +1165,9 @@ var GoogleChatAdapter = class {
     const userId = message.sender?.name || "unknown";
     const displayName = message.sender?.displayName || "unknown";
     if (userId !== "unknown" && displayName !== "unknown") {
-      this.cacheUserInfo(userId, displayName, message.sender?.email).catch(
-        () => {
-        }
-      );
+      this.userInfoCache.set(userId, displayName, message.sender?.email).catch((error) => {
+        this.logger.error("Failed to cache user info", { userId, error });
+      });
     }
     return {
       id: message.name,
@@ -1101,21 +1194,21 @@ var GoogleChatAdapter = class {
   async postMessage(threadId, message) {
     const { spaceName, threadName } = this.decodeThreadId(threadId);
     try {
-      const files = this.extractFiles(message);
+      const files = extractFiles(message);
       if (files.length > 0) {
-        this.logger?.warn(
+        this.logger.warn(
           "File uploads are not yet supported for Google Chat. Files will be ignored.",
           { fileCount: files.length }
         );
       }
-      const card = this.extractCard(message);
+      const card = extractCard(message);
       if (card) {
         const cardId = `card-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
         const googleCard = cardToGoogleCard(card, {
           cardId,
           endpointUrl: this.endpointUrl
         });
-        this.logger?.debug("GChat API: spaces.messages.create (card)", {
+        this.logger.debug("GChat API: spaces.messages.create (card)", {
           spaceName,
           threadName,
           googleCard: JSON.stringify(googleCard)
@@ -1129,7 +1222,7 @@ var GoogleChatAdapter = class {
             thread: threadName ? { name: threadName } : void 0
           }
         });
-        this.logger?.debug("GChat API: spaces.messages.create response", {
+        this.logger.debug("GChat API: spaces.messages.create response", {
           messageName: response2.data.name
         });
         return {
@@ -1138,11 +1231,11 @@ var GoogleChatAdapter = class {
           raw: response2.data
         };
       }
-      const text = convertEmojiPlaceholders2(
+      const text = convertEmojiPlaceholders(
         this.formatConverter.renderPostable(message),
         "gchat"
       );
-      this.logger?.debug("GChat API: spaces.messages.create", {
+      this.logger.debug("GChat API: spaces.messages.create", {
         spaceName,
         threadName,
         textLength: text.length
@@ -1156,7 +1249,7 @@ var GoogleChatAdapter = class {
           thread: threadName ? { name: threadName } : void 0
         }
       });
-      this.logger?.debug("GChat API: spaces.messages.create response", {
+      this.logger.debug("GChat API: spaces.messages.create response", {
         messageName: response.data.name
       });
       return {
@@ -1168,27 +1261,6 @@ var GoogleChatAdapter = class {
       this.handleGoogleChatError(error, "postMessage");
     }
   }
-  /**
-   * Extract card element from a message 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 message if present.
-   */
-  extractFiles(message) {
-    if (typeof message === "object" && message !== null && "files" in message) {
-      return message.files ?? [];
-    }
-    return [];
-  }
   /**
    * Create an Attachment object from a Google Chat attachment.
    */
@@ -1211,12 +1283,18 @@ var GoogleChatAdapter = class {
       mimeType: att.contentType || void 0,
       fetchData: url ? async () => {
         if (typeof auth === "string" || !auth) {
-          throw new Error("Cannot fetch file: no auth client configured");
+          throw new AuthenticationError(
+            "gchat",
+            "Cannot fetch file: no auth client configured"
+          );
         }
         const tokenResult = await auth.getAccessToken();
         const token = typeof tokenResult === "string" ? tokenResult : tokenResult?.token;
         if (!token) {
-          throw new Error("Failed to get access token");
+          throw new AuthenticationError(
+            "gchat",
+            "Failed to get access token"
+          );
         }
         const response = await fetch(url, {
           headers: {
@@ -1224,7 +1302,8 @@ var GoogleChatAdapter = class {
           }
         });
         if (!response.ok) {
-          throw new Error(
+          throw new NetworkError(
+            "gchat",
             `Failed to fetch file: ${response.status} ${response.statusText}`
           );
         }
@@ -1235,14 +1314,14 @@ var GoogleChatAdapter = class {
   }
   async editMessage(threadId, messageId, message) {
     try {
-      const card = this.extractCard(message);
+      const card = extractCard(message);
       if (card) {
         const cardId = `card-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
         const googleCard = cardToGoogleCard(card, {
           cardId,
           endpointUrl: this.endpointUrl
         });
-        this.logger?.debug("GChat API: spaces.messages.update (card)", {
+        this.logger.debug("GChat API: spaces.messages.update (card)", {
           messageId,
           cardId
         });
@@ -1254,7 +1333,7 @@ var GoogleChatAdapter = class {
             cardsV2: [googleCard]
           }
         });
-        this.logger?.debug("GChat API: spaces.messages.update response", {
+        this.logger.debug("GChat API: spaces.messages.update response", {
           messageName: response2.data.name
         });
         return {
@@ -1263,11 +1342,11 @@ var GoogleChatAdapter = class {
           raw: response2.data
         };
       }
-      const text = convertEmojiPlaceholders2(
+      const text = convertEmojiPlaceholders(
         this.formatConverter.renderPostable(message),
         "gchat"
       );
-      this.logger?.debug("GChat API: spaces.messages.update", {
+      this.logger.debug("GChat API: spaces.messages.update", {
         messageId,
         textLength: text.length
       });
@@ -1278,7 +1357,7 @@ var GoogleChatAdapter = class {
           text
         }
       });
-      this.logger?.debug("GChat API: spaces.messages.update response", {
+      this.logger.debug("GChat API: spaces.messages.update response", {
         messageName: response.data.name
       });
       return {
@@ -1292,11 +1371,11 @@ var GoogleChatAdapter = class {
   }
   async deleteMessage(_threadId, messageId) {
     try {
-      this.logger?.debug("GChat API: spaces.messages.delete", { messageId });
+      this.logger.debug("GChat API: spaces.messages.delete", { messageId });
       await this.chatApi.spaces.messages.delete({
         name: messageId
       });
-      this.logger?.debug("GChat API: spaces.messages.delete response", {
+      this.logger.debug("GChat API: spaces.messages.delete response", {
         ok: true
       });
     } catch (error) {
@@ -1306,7 +1385,7 @@ var GoogleChatAdapter = class {
   async addReaction(_threadId, messageId, emoji) {
     const gchatEmoji = defaultEmojiResolver.toGChat(emoji);
     try {
-      this.logger?.debug("GChat API: spaces.messages.reactions.create", {
+      this.logger.debug("GChat API: spaces.messages.reactions.create", {
         messageId,
         emoji: gchatEmoji
       });
@@ -1316,7 +1395,7 @@ var GoogleChatAdapter = class {
           emoji: { unicode: gchatEmoji }
         }
       });
-      this.logger?.debug(
+      this.logger.debug(
         "GChat API: spaces.messages.reactions.create response",
         {
           ok: true
@@ -1329,32 +1408,32 @@ var GoogleChatAdapter = class {
   async removeReaction(_threadId, messageId, emoji) {
     const gchatEmoji = defaultEmojiResolver.toGChat(emoji);
     try {
-      this.logger?.debug("GChat API: spaces.messages.reactions.list", {
+      this.logger.debug("GChat API: spaces.messages.reactions.list", {
         messageId
       });
       const response = await this.chatApi.spaces.messages.reactions.list({
         parent: messageId
       });
-      this.logger?.debug("GChat API: spaces.messages.reactions.list response", {
+      this.logger.debug("GChat API: spaces.messages.reactions.list response", {
         reactionCount: response.data.reactions?.length || 0
       });
       const reaction = response.data.reactions?.find(
         (r) => r.emoji?.unicode === gchatEmoji
       );
       if (!reaction?.name) {
-        this.logger?.debug("Reaction not found to remove", {
+        this.logger.debug("Reaction not found to remove", {
           messageId,
           emoji: gchatEmoji
         });
         return;
       }
-      this.logger?.debug("GChat API: spaces.messages.reactions.delete", {
+      this.logger.debug("GChat API: spaces.messages.reactions.delete", {
         reactionName: reaction.name
       });
       await this.chatApi.spaces.messages.reactions.delete({
         name: reaction.name
       });
-      this.logger?.debug(
+      this.logger.debug(
         "GChat API: spaces.messages.reactions.delete response",
         {
           ok: true
@@ -1377,12 +1456,12 @@ var GoogleChatAdapter = class {
    */
   async openDM(userId) {
     try {
-      this.logger?.debug("GChat API: spaces.findDirectMessage", { userId });
+      this.logger.debug("GChat API: spaces.findDirectMessage", { userId });
       const findResponse = await this.chatApi.spaces.findDirectMessage({
         name: userId
       });
       if (findResponse.data.name) {
-        this.logger?.debug("GChat API: Found existing DM space", {
+        this.logger.debug("GChat API: Found existing DM space", {
           spaceName: findResponse.data.name
         });
         return this.encodeThreadId({
@@ -1393,17 +1472,17 @@ var GoogleChatAdapter = class {
     } catch (error) {
       const gError = error;
       if (gError.code !== 404) {
-        this.logger?.debug("GChat API: findDirectMessage failed", { error });
+        this.logger.debug("GChat API: findDirectMessage failed", { error });
       }
     }
     const chatApi = this.impersonatedChatApi || this.chatApi;
     if (!this.impersonatedChatApi) {
-      this.logger?.warn(
+      this.logger.warn(
         "openDM: No existing DM found and no impersonation configured. Creating new DMs requires domain-wide delegation. Set 'impersonateUser' in adapter config."
       );
     }
     try {
-      this.logger?.debug("GChat API: spaces.setup (DM)", {
+      this.logger.debug("GChat API: spaces.setup (DM)", {
         userId,
         hasImpersonation: !!this.impersonatedChatApi,
         impersonateUser: this.impersonateUser
@@ -1425,68 +1504,195 @@ var GoogleChatAdapter = class {
       });
       const spaceName = response.data.name;
       if (!spaceName) {
-        throw new Error("Failed to create DM - no space name returned");
+        throw new NetworkError(
+          "gchat",
+          "Failed to create DM - no space name returned"
+        );
       }
-      this.logger?.debug("GChat API: spaces.setup response", { spaceName });
+      this.logger.debug("GChat API: spaces.setup response", { spaceName });
       return this.encodeThreadId({ spaceName, isDM: true });
     } catch (error) {
       this.handleGoogleChatError(error, "openDM");
     }
   }
   async fetchMessages(threadId, options = {}) {
-    const { spaceName } = this.decodeThreadId(threadId);
+    const { spaceName, threadName } = this.decodeThreadId(threadId);
+    const direction = options.direction ?? "backward";
+    const limit = options.limit || 100;
     const api = this.impersonatedChatApi || this.chatApi;
     try {
-      this.logger?.debug("GChat API: spaces.messages.list", {
+      const filter = threadName ? `thread.name = "${threadName}"` : void 0;
+      if (direction === "forward") {
+        return this.fetchMessagesForward(
+          api,
+          spaceName,
+          threadId,
+          filter,
+          limit,
+          options.cursor
+        );
+      }
+      return this.fetchMessagesBackward(
+        api,
         spaceName,
-        pageSize: options.limit || 100,
-        impersonated: !!this.impersonatedChatApi
-      });
+        threadId,
+        filter,
+        limit,
+        options.cursor
+      );
+    } catch (error) {
+      this.handleGoogleChatError(error, "fetchMessages");
+    }
+  }
+  /**
+   * Fetch messages in backward direction (most recent first).
+   * GChat API defaults to createTime ASC (oldest first), so we request DESC
+   * to get the most recent messages, then reverse for chronological order within page.
+   */
+  async fetchMessagesBackward(api, spaceName, threadId, filter, limit, cursor) {
+    this.logger.debug("GChat API: spaces.messages.list (backward)", {
+      spaceName,
+      filter,
+      pageSize: limit,
+      cursor
+    });
+    const response = await api.spaces.messages.list({
+      parent: spaceName,
+      pageSize: limit,
+      pageToken: cursor,
+      filter,
+      orderBy: "createTime desc"
+      // Get newest messages first
+    });
+    const rawMessages = (response.data.messages || []).reverse();
+    this.logger.debug("GChat API: spaces.messages.list response (backward)", {
+      messageCount: rawMessages.length,
+      hasNextPageToken: !!response.data.nextPageToken
+    });
+    const messages = await Promise.all(
+      rawMessages.map(
+        (msg) => this.parseGChatListMessage(msg, spaceName, threadId)
+      )
+    );
+    return {
+      messages,
+      // nextPageToken points to older messages (backward pagination)
+      nextCursor: response.data.nextPageToken ?? void 0
+    };
+  }
+  /**
+   * Fetch messages in forward direction (oldest first).
+   *
+   * GChat API defaults to createTime ASC (oldest first), which is what we want.
+   * For forward pagination, we:
+   * 1. If no cursor: Fetch ALL messages (already in chronological order)
+   * 2. If cursor: Cursor is a message name, skip to after that message
+   *
+   * Note: This is less efficient than backward for large message histories,
+   * as it requires fetching all messages to find the cursor position.
+   */
+  async fetchMessagesForward(api, spaceName, threadId, filter, limit, cursor) {
+    this.logger.debug("GChat API: spaces.messages.list (forward)", {
+      spaceName,
+      filter,
+      limit,
+      cursor
+    });
+    const allRawMessages = [];
+    let pageToken;
+    do {
       const response = await api.spaces.messages.list({
         parent: spaceName,
-        pageSize: options.limit || 100,
-        pageToken: options.before
+        pageSize: 1e3,
+        // Max page size for efficiency
+        pageToken,
+        filter
+        // Default orderBy is createTime ASC (oldest first) - what we want
       });
-      const messages = response.data.messages || [];
-      this.logger?.debug("GChat API: spaces.messages.list response", {
-        messageCount: messages.length
-      });
-      return messages.map((msg) => {
-        const msgThreadId = this.encodeThreadId({
-          spaceName,
-          threadName: msg.thread?.name ?? void 0
-        });
-        const msgIsBot = msg.sender?.type === "BOT";
-        return {
-          id: msg.name || "",
-          threadId: msgThreadId,
-          text: this.formatConverter.extractPlainText(msg.text || ""),
-          formatted: this.formatConverter.toAst(msg.text || ""),
-          raw: msg,
-          author: {
-            userId: msg.sender?.name || "unknown",
-            userName: msg.sender?.displayName || "unknown",
-            fullName: msg.sender?.displayName || "unknown",
-            isBot: msgIsBot,
-            isMe: msgIsBot
-          },
-          metadata: {
-            dateSent: msg.createTime ? new Date(msg.createTime) : /* @__PURE__ */ new Date(),
-            edited: false
-          },
-          attachments: []
-        };
-      });
-    } catch (error) {
-      this.handleGoogleChatError(error, "fetchMessages");
+      const pageMessages = response.data.messages || [];
+      allRawMessages.push(...pageMessages);
+      pageToken = response.data.nextPageToken ?? void 0;
+    } while (pageToken);
+    this.logger.debug(
+      "GChat API: fetched all messages for forward pagination",
+      {
+        totalCount: allRawMessages.length
+      }
+    );
+    let startIndex = 0;
+    if (cursor) {
+      const cursorIndex = allRawMessages.findIndex(
+        (msg) => msg.name === cursor
+      );
+      if (cursorIndex >= 0) {
+        startIndex = cursorIndex + 1;
+      }
     }
+    const selectedMessages = allRawMessages.slice(
+      startIndex,
+      startIndex + limit
+    );
+    const messages = await Promise.all(
+      selectedMessages.map(
+        (msg) => this.parseGChatListMessage(msg, spaceName, threadId)
+      )
+    );
+    let nextCursor;
+    if (startIndex + limit < allRawMessages.length && selectedMessages.length > 0) {
+      const lastMsg = selectedMessages[selectedMessages.length - 1];
+      if (lastMsg?.name) {
+        nextCursor = lastMsg.name;
+      }
+    }
+    return {
+      messages,
+      nextCursor
+    };
+  }
+  /**
+   * Parse a message from the list API into the standard Message format.
+   * Resolves user display names and properly determines isMe.
+   */
+  async parseGChatListMessage(msg, spaceName, _threadId) {
+    const msgThreadId = this.encodeThreadId({
+      spaceName,
+      threadName: msg.thread?.name ?? void 0
+    });
+    const msgIsBot = msg.sender?.type === "BOT";
+    const userId = msg.sender?.name || "unknown";
+    const displayName = await this.userInfoCache.resolveDisplayName(
+      userId,
+      msg.sender?.displayName ?? void 0,
+      this.botUserId,
+      this.userName
+    );
+    const isMe = this.isMessageFromSelf(msg);
+    return {
+      id: msg.name || "",
+      threadId: msgThreadId,
+      text: this.formatConverter.extractPlainText(msg.text || ""),
+      formatted: this.formatConverter.toAst(msg.text || ""),
+      raw: msg,
+      author: {
+        userId,
+        userName: displayName,
+        fullName: displayName,
+        isBot: msgIsBot,
+        isMe
+      },
+      metadata: {
+        dateSent: msg.createTime ? new Date(msg.createTime) : /* @__PURE__ */ new Date(),
+        edited: false
+      },
+      attachments: []
+    };
   }
   async fetchThread(threadId) {
     const { spaceName } = this.decodeThreadId(threadId);
     try {
-      this.logger?.debug("GChat API: spaces.get", { spaceName });
+      this.logger.debug("GChat API: spaces.get", { spaceName });
       const response = await this.chatApi.spaces.get({ name: spaceName });
-      this.logger?.debug("GChat API: spaces.get response", {
+      this.logger.debug("GChat API: spaces.get response", {
         displayName: response.data.displayName
       });
       return {
@@ -1502,34 +1708,22 @@ var GoogleChatAdapter = class {
     }
   }
   encodeThreadId(platformData) {
-    const threadPart = platformData.threadName ? `:${Buffer.from(platformData.threadName).toString("base64url")}` : "";
-    const dmPart = platformData.isDM ? ":dm" : "";
-    return `gchat:${platformData.spaceName}${threadPart}${dmPart}`;
+    return encodeThreadId(platformData);
   }
   /**
    * Check if a thread is a direct message conversation.
-   * Checks for the :dm marker in the thread ID which is set when
-   * processing DM messages or opening DMs.
    */
   isDM(threadId) {
-    return threadId.endsWith(":dm");
+    return isDMThread(threadId);
   }
   decodeThreadId(threadId) {
-    const isDM = threadId.endsWith(":dm");
-    const cleanId = isDM ? threadId.slice(0, -3) : threadId;
-    const parts = cleanId.split(":");
-    if (parts.length < 2 || parts[0] !== "gchat") {
-      throw new Error(`Invalid Google Chat thread ID: ${threadId}`);
-    }
-    const spaceName = parts[1];
-    const threadName = parts[2] ? Buffer.from(parts[2], "base64url").toString("utf-8") : void 0;
-    return { spaceName, threadName, isDM };
+    return decodeThreadId(threadId);
   }
   parseMessage(raw) {
     const event = raw;
     const messagePayload = event.chat?.messagePayload;
     if (!messagePayload) {
-      throw new Error("Cannot parse non-message event");
+      throw new ValidationError2("gchat", "Cannot parse non-message event");
     }
     const threadName = messagePayload.message.thread?.name || messagePayload.message.name;
     const threadId = this.encodeThreadId({
@@ -1557,11 +1751,11 @@ var GoogleChatAdapter = class {
         const botDisplayName = botUser.displayName;
         if (botUser.name && !this.botUserId) {
           this.botUserId = botUser.name;
-          this.logger?.info("Learned bot user ID from mention", {
+          this.logger.info("Learned bot user ID from mention", {
             botUserId: this.botUserId
           });
           this.state?.set("gchat:botUserId", this.botUserId).catch(
-            (err) => this.logger?.debug("Failed to persist botUserId", { error: err })
+            (err) => this.logger.error("Failed to persist botUserId", { error: err })
           );
         }
         if (annotation.startIndex !== void 0 && annotation.length !== void 0) {
@@ -1569,7 +1763,7 @@ var GoogleChatAdapter = class {
           const length = annotation.length;
           const mentionText = text.slice(startIndex, startIndex + length);
           text = text.slice(0, startIndex) + `@${this.userName}` + text.slice(startIndex + length);
-          this.logger?.debug("Normalized bot mention", {
+          this.logger.debug("Normalized bot mention", {
             original: mentionText,
             replacement: `@${this.userName}`
           });
@@ -1597,62 +1791,23 @@ var GoogleChatAdapter = class {
       return senderId === this.botUserId;
     }
     if (!this.botUserId && message.sender?.type === "BOT") {
-      this.logger?.debug(
+      this.logger.debug(
         "Cannot determine isMe - bot user ID not yet learned. Bot ID is learned from @mentions. Assuming message is not from self.",
         { senderId }
       );
     }
     return false;
   }
-  /**
-   * Cache user info for later lookup (e.g., when processing Pub/Sub messages).
-   */
-  async cacheUserInfo(userId, displayName, email) {
-    if (!this.state || !displayName || displayName === "unknown") return;
-    const cacheKey = `${USER_INFO_KEY_PREFIX}${userId}`;
-    await this.state.set(
-      cacheKey,
-      { displayName, email },
-      USER_INFO_CACHE_TTL_MS
-    );
-  }
-  /**
-   * Get cached user info.
-   */
-  async getCachedUserInfo(userId) {
-    if (!this.state) return null;
-    const cacheKey = `${USER_INFO_KEY_PREFIX}${userId}`;
-    return this.state.get(cacheKey);
-  }
-  /**
-   * Resolve user display name, using cache if available.
-   */
-  async resolveUserDisplayName(userId, providedDisplayName) {
-    if (providedDisplayName && providedDisplayName !== "unknown") {
-      this.cacheUserInfo(userId, providedDisplayName).catch(() => {
-      });
-      return providedDisplayName;
-    }
-    const cached = await this.getCachedUserInfo(userId);
-    if (cached?.displayName) {
-      return cached.displayName;
-    }
-    return userId.replace("users/", "User ");
-  }
   handleGoogleChatError(error, context) {
     const gError = error;
-    this.logger?.error(`GChat API error${context ? ` (${context})` : ""}`, {
+    this.logger.error(`GChat API error${context ? ` (${context})` : ""}`, {
       code: gError.code,
       message: gError.message,
       errors: gError.errors,
       error
     });
     if (gError.code === 429) {
-      throw new RateLimitError(
-        "Google Chat rate limit exceeded",
-        void 0,
-        error
-      );
+      throw new AdapterRateLimitError("gchat");
     }
     throw error;
   }