@chat-adapter/gchat 4.0.0

package/dist/index.js

@@ -0,0 +1,1642 @@
+// src/index.ts
+import {
+  convertEmojiPlaceholders as convertEmojiPlaceholders2,
+  defaultEmojiResolver,
+  isCardElement,
+  RateLimitError
+} from "chat";
+import { google as google2 } from "googleapis";
+
+// src/cards.ts
+import {
+  convertEmojiPlaceholders
+} from "chat";
+function convertEmoji(text) {
+  return convertEmojiPlaceholders(text, "gchat");
+}
+function cardToGoogleCard(card, cardId) {
+  const sections = [];
+  let header;
+  if (card.title || card.subtitle || card.imageUrl) {
+    header = {
+      title: convertEmoji(card.title || "")
+    };
+    if (card.subtitle) {
+      header.subtitle = convertEmoji(card.subtitle);
+    }
+    if (card.imageUrl) {
+      header.imageUrl = card.imageUrl;
+      header.imageType = "SQUARE";
+    }
+  }
+  let currentWidgets = [];
+  for (const child of card.children) {
+    if (child.type === "section") {
+      if (currentWidgets.length > 0) {
+        sections.push({ widgets: currentWidgets });
+        currentWidgets = [];
+      }
+      const sectionWidgets = convertSectionToWidgets(child);
+      sections.push({ widgets: sectionWidgets });
+    } else {
+      const widgets = convertChildToWidgets(child);
+      currentWidgets.push(...widgets);
+    }
+  }
+  if (currentWidgets.length > 0) {
+    sections.push({ widgets: currentWidgets });
+  }
+  if (sections.length === 0) {
+    sections.push({
+      widgets: [{ textParagraph: { text: "" } }]
+    });
+  }
+  const googleCard = {
+    card: {
+      sections
+    }
+  };
+  if (header) {
+    googleCard.card.header = header;
+  }
+  if (cardId) {
+    googleCard.cardId = cardId;
+  }
+  return googleCard;
+}
+function convertChildToWidgets(child) {
+  switch (child.type) {
+    case "text":
+      return [convertTextToWidget(child)];
+    case "image":
+      return [convertImageToWidget(child)];
+    case "divider":
+      return [convertDividerToWidget(child)];
+    case "actions":
+      return [convertActionsToWidget(child)];
+    case "section":
+      return convertSectionToWidgets(child);
+    case "fields":
+      return convertFieldsToWidgets(child);
+    default:
+      return [];
+  }
+}
+function convertTextToWidget(element) {
+  let text = convertEmoji(element.content);
+  if (element.style === "bold") {
+    text = `*${text}*`;
+  } else if (element.style === "muted") {
+    text = convertEmoji(element.content);
+  }
+  return {
+    textParagraph: { text }
+  };
+}
+function convertImageToWidget(element) {
+  return {
+    image: {
+      imageUrl: element.url,
+      altText: element.alt || "Image"
+    }
+  };
+}
+function convertDividerToWidget(_element) {
+  return { divider: {} };
+}
+function convertActionsToWidget(element) {
+  const buttons = element.children.map(
+    (button) => convertButtonToGoogleButton(button)
+  );
+  return {
+    buttonList: { buttons }
+  };
+}
+function convertButtonToGoogleButton(button) {
+  const googleButton = {
+    text: convertEmoji(button.label),
+    onClick: {
+      action: {
+        function: button.id,
+        parameters: button.value ? [{ key: "value", value: button.value }] : []
+      }
+    }
+  };
+  if (button.style === "primary") {
+    googleButton.color = { red: 0.2, green: 0.5, blue: 0.9 };
+  } else if (button.style === "danger") {
+    googleButton.color = { red: 0.9, green: 0.2, blue: 0.2 };
+  }
+  return googleButton;
+}
+function convertSectionToWidgets(element) {
+  const widgets = [];
+  for (const child of element.children) {
+    widgets.push(...convertChildToWidgets(child));
+  }
+  return widgets;
+}
+function convertFieldsToWidgets(element) {
+  return element.children.map((field) => ({
+    decoratedText: {
+      topLabel: convertEmoji(field.label),
+      text: convertEmoji(field.value)
+    }
+  }));
+}
+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;
+  }
+}
+
+// src/markdown.ts
+import {
+  BaseFormatConverter,
+  parseMarkdown
+} from "chat";
+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");
+  }
+  /**
+   * Parse Google Chat message into an AST.
+   */
+  toAst(gchatText) {
+    let markdown = gchatText;
+    markdown = markdown.replace(/(?<![_*\\])\*([^*\n]+)\*(?![_*])/g, "**$1**");
+    markdown = markdown.replace(/(?<!~)~([^~\n]+)~(?!~)/g, "~~$1~~");
+    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}
+\`\`\``;
+      }
+      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 "";
+    }
+  }
+};
+
+// src/workspace-events.ts
+import { google } from "googleapis";
+async function createSpaceSubscription(options, auth) {
+  const { spaceName, pubsubTopic, ttlSeconds = 86400 } = options;
+  let authClient;
+  if ("credentials" in auth) {
+    authClient = new google.auth.JWT({
+      email: auth.credentials.client_email,
+      key: auth.credentials.private_key,
+      // For domain-wide delegation, impersonate a user
+      subject: auth.impersonateUser,
+      scopes: [
+        "https://www.googleapis.com/auth/chat.spaces.readonly",
+        "https://www.googleapis.com/auth/chat.messages.readonly"
+      ]
+    });
+  } else if ("useApplicationDefaultCredentials" in auth) {
+    authClient = new google.auth.GoogleAuth({
+      // Note: ADC with impersonation requires different setup
+      scopes: [
+        "https://www.googleapis.com/auth/chat.spaces.readonly",
+        "https://www.googleapis.com/auth/chat.messages.readonly"
+      ]
+    });
+  } else {
+    authClient = auth.auth;
+  }
+  const workspaceEvents = google.workspaceevents({
+    version: "v1",
+    auth: authClient
+  });
+  const response = await workspaceEvents.subscriptions.create({
+    requestBody: {
+      targetResource: `//chat.googleapis.com/${spaceName}`,
+      eventTypes: [
+        "google.workspace.chat.message.v1.created",
+        "google.workspace.chat.message.v1.updated",
+        "google.workspace.chat.reaction.v1.created",
+        "google.workspace.chat.reaction.v1.deleted"
+      ],
+      notificationEndpoint: {
+        pubsubTopic
+      },
+      payloadOptions: {
+        includeResource: true
+      },
+      ttl: `${ttlSeconds}s`
+    }
+  });
+  const operation = response.data;
+  if (operation.done && operation.response) {
+    const subscription = operation.response;
+    return {
+      name: subscription.name || "",
+      expireTime: subscription.expireTime || ""
+    };
+  }
+  return {
+    name: operation.name || "pending",
+    expireTime: ""
+  };
+}
+async function listSpaceSubscriptions(spaceName, auth) {
+  let authClient;
+  if ("credentials" in auth) {
+    authClient = new google.auth.JWT({
+      email: auth.credentials.client_email,
+      key: auth.credentials.private_key,
+      subject: auth.impersonateUser,
+      scopes: ["https://www.googleapis.com/auth/chat.spaces.readonly"]
+    });
+  } else if ("useApplicationDefaultCredentials" in auth) {
+    authClient = new google.auth.GoogleAuth({
+      scopes: ["https://www.googleapis.com/auth/chat.spaces.readonly"]
+    });
+  } else {
+    authClient = auth.auth;
+  }
+  const workspaceEvents = google.workspaceevents({
+    version: "v1",
+    auth: authClient
+  });
+  const response = await workspaceEvents.subscriptions.list({
+    filter: `target_resource="//chat.googleapis.com/${spaceName}"`
+  });
+  return (response.data.subscriptions || []).map((sub) => ({
+    name: sub.name || "",
+    expireTime: sub.expireTime || "",
+    eventTypes: sub.eventTypes || []
+  }));
+}
+async function deleteSpaceSubscription(subscriptionName, auth) {
+  let authClient;
+  if ("credentials" in auth) {
+    authClient = new google.auth.JWT({
+      email: auth.credentials.client_email,
+      key: auth.credentials.private_key,
+      subject: auth.impersonateUser,
+      scopes: ["https://www.googleapis.com/auth/chat.spaces.readonly"]
+    });
+  } else if ("useApplicationDefaultCredentials" in auth) {
+    authClient = new google.auth.GoogleAuth({
+      scopes: ["https://www.googleapis.com/auth/chat.spaces.readonly"]
+    });
+  } else {
+    authClient = auth.auth;
+  }
+  const workspaceEvents = google.workspaceevents({
+    version: "v1",
+    auth: authClient
+  });
+  await workspaceEvents.subscriptions.delete({
+    name: subscriptionName
+  });
+}
+function decodePubSubMessage(pushMessage) {
+  const data = Buffer.from(pushMessage.message.data, "base64").toString(
+    "utf-8"
+  );
+  const payload = JSON.parse(data);
+  const attributes = pushMessage.message.attributes || {};
+  return {
+    subscription: pushMessage.subscription,
+    targetResource: attributes["ce-subject"] || "",
+    eventType: attributes["ce-type"] || "",
+    eventTime: attributes["ce-time"] || pushMessage.message.publishTime,
+    message: payload.message,
+    reaction: payload.reaction
+  };
+}
+function verifyPubSubRequest(request, _expectedAudience) {
+  if (request.method !== "POST") {
+    return false;
+  }
+  const contentType = request.headers.get("content-type");
+  if (!contentType?.includes("application/json")) {
+    return false;
+  }
+  return true;
+}
+
+// src/index.ts
+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;
+  /** Bot's user ID (e.g., "users/123...") - learned from annotations */
+  botUserId;
+  chatApi;
+  chat = null;
+  state = null;
+  logger = null;
+  formatConverter = new GoogleChatFormatConverter();
+  pubsubTopic;
+  credentials;
+  useADC = false;
+  /** Custom auth client (e.g., Vercel OIDC) */
+  customAuth;
+  /** Auth client for making authenticated requests */
+  authClient;
+  /** User email to impersonate for Workspace Events API (domain-wide delegation) */
+  impersonateUser;
+  /** In-progress subscription creations to prevent duplicate requests */
+  pendingSubscriptions = /* @__PURE__ */ new Map();
+  /** Chat API client with impersonation for user-context operations (DMs, etc.) */
+  impersonatedChatApi;
+  constructor(config) {
+    this.userName = config.userName || "bot";
+    this.pubsubTopic = config.pubsubTopic;
+    this.impersonateUser = config.impersonateUser;
+    let auth;
+    const scopes = [
+      "https://www.googleapis.com/auth/chat.bot",
+      "https://www.googleapis.com/auth/chat.messages.reactions.create",
+      "https://www.googleapis.com/auth/chat.messages.reactions",
+      "https://www.googleapis.com/auth/chat.spaces.create"
+    ];
+    if ("credentials" in config && config.credentials) {
+      this.credentials = config.credentials;
+      auth = new google2.auth.JWT({
+        email: config.credentials.client_email,
+        key: config.credentials.private_key,
+        scopes
+      });
+    } else if ("useApplicationDefaultCredentials" in config && config.useApplicationDefaultCredentials) {
+      this.useADC = true;
+      auth = new google2.auth.GoogleAuth({
+        scopes
+      });
+    } else if ("auth" in config && config.auth) {
+      this.customAuth = config.auth;
+      auth = config.auth;
+    } else {
+      throw new Error(
+        "GoogleChatAdapter requires one of: credentials, useApplicationDefaultCredentials, or auth"
+      );
+    }
+    this.authClient = auth;
+    this.chatApi = google2.chat({ version: "v1", auth });
+    if (this.impersonateUser) {
+      if (this.credentials) {
+        const impersonatedAuth = new google2.auth.JWT({
+          email: this.credentials.client_email,
+          key: this.credentials.private_key,
+          scopes: [
+            "https://www.googleapis.com/auth/chat.spaces",
+            "https://www.googleapis.com/auth/chat.spaces.create"
+          ],
+          subject: this.impersonateUser
+        });
+        this.impersonatedChatApi = google2.chat({
+          version: "v1",
+          auth: impersonatedAuth
+        });
+      } else if (this.useADC) {
+        const impersonatedAuth = new google2.auth.GoogleAuth({
+          scopes: [
+            "https://www.googleapis.com/auth/chat.spaces",
+            "https://www.googleapis.com/auth/chat.spaces.create"
+          ],
+          clientOptions: {
+            subject: this.impersonateUser
+          }
+        });
+        this.impersonatedChatApi = google2.chat({
+          version: "v1",
+          auth: impersonatedAuth
+        });
+      }
+    }
+  }
+  async initialize(chat) {
+    this.chat = chat;
+    this.state = chat.getState();
+    this.logger = chat.getLogger(this.name);
+    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", {
+          botUserId: this.botUserId
+        });
+      }
+    }
+  }
+  /**
+   * Called when a thread is subscribed to.
+   * Ensures the space has a Workspace Events subscription so we receive all messages.
+   */
+  async onThreadSubscribe(threadId) {
+    this.logger?.info("onThreadSubscribe called", {
+      threadId,
+      hasPubsubTopic: !!this.pubsubTopic,
+      pubsubTopic: this.pubsubTopic
+    });
+    if (!this.pubsubTopic) {
+      this.logger?.warn(
+        "No pubsubTopic configured, skipping space subscription. Set GOOGLE_CHAT_PUBSUB_TOPIC env var."
+      );
+      return;
+    }
+    const { spaceName } = this.decodeThreadId(threadId);
+    await this.ensureSpaceSubscription(spaceName);
+  }
+  /**
+   * Ensure a Workspace Events subscription exists for a space.
+   * Creates one if it doesn't exist or is about to expire.
+   */
+  async ensureSpaceSubscription(spaceName) {
+    this.logger?.info("ensureSpaceSubscription called", {
+      spaceName,
+      hasPubsubTopic: !!this.pubsubTopic,
+      hasState: !!this.state,
+      hasCredentials: !!this.credentials,
+      hasADC: this.useADC
+    });
+    if (!this.pubsubTopic || !this.state) {
+      this.logger?.warn("ensureSpaceSubscription skipped - missing config", {
+        hasPubsubTopic: !!this.pubsubTopic,
+        hasState: !!this.state
+      });
+      return;
+    }
+    const cacheKey = `${SPACE_SUB_KEY_PREFIX}${spaceName}`;
+    const cached = await this.state.get(cacheKey);
+    if (cached) {
+      const timeUntilExpiry = cached.expireTime - Date.now();
+      if (timeUntilExpiry > SUBSCRIPTION_REFRESH_BUFFER_MS) {
+        this.logger?.debug("Space subscription still valid", {
+          spaceName,
+          expiresIn: Math.round(timeUntilExpiry / 1e3 / 60)
+        });
+        return;
+      }
+      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", {
+        spaceName
+      });
+      return pending;
+    }
+    const createPromise = this.createSpaceSubscriptionWithCache(
+      spaceName,
+      cacheKey
+    );
+    this.pendingSubscriptions.set(spaceName, createPromise);
+    try {
+      await createPromise;
+    } finally {
+      this.pendingSubscriptions.delete(spaceName);
+    }
+  }
+  /**
+   * Create a Workspace Events subscription and cache the result.
+   */
+  async createSpaceSubscriptionWithCache(spaceName, cacheKey) {
+    const authOptions = this.getAuthOptions();
+    this.logger?.info("createSpaceSubscriptionWithCache", {
+      spaceName,
+      hasAuthOptions: !!authOptions,
+      hasCredentials: !!this.credentials,
+      hasADC: this.useADC
+    });
+    if (!authOptions) {
+      this.logger?.error(
+        "Cannot create subscription: no auth configured. Use GOOGLE_CHAT_CREDENTIALS, GOOGLE_CHAT_USE_ADC=true, or custom auth."
+      );
+      return;
+    }
+    const pubsubTopic = this.pubsubTopic;
+    if (!pubsubTopic) return;
+    try {
+      const existing = await this.findExistingSubscription(
+        spaceName,
+        authOptions
+      );
+      if (existing) {
+        this.logger?.debug("Found existing subscription", {
+          spaceName,
+          subscriptionName: existing.subscriptionName
+        });
+        if (this.state) {
+          await this.state.set(
+            cacheKey,
+            existing,
+            SUBSCRIPTION_CACHE_TTL_MS
+          );
+        }
+        return;
+      }
+      this.logger?.info("Creating Workspace Events subscription", {
+        spaceName,
+        pubsubTopic
+      });
+      const result = await createSpaceSubscription(
+        { spaceName, pubsubTopic },
+        authOptions
+      );
+      const subscriptionInfo = {
+        subscriptionName: result.name,
+        expireTime: new Date(result.expireTime).getTime()
+      };
+      if (this.state) {
+        await this.state.set(
+          cacheKey,
+          subscriptionInfo,
+          SUBSCRIPTION_CACHE_TTL_MS
+        );
+      }
+      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", {
+        spaceName,
+        error
+      });
+    }
+  }
+  /**
+   * Check if a subscription already exists for this space.
+   */
+  async findExistingSubscription(spaceName, authOptions) {
+    try {
+      const subscriptions = await listSpaceSubscriptions(
+        spaceName,
+        authOptions
+      );
+      for (const sub of subscriptions) {
+        const expireTime = new Date(sub.expireTime).getTime();
+        if (expireTime > Date.now() + SUBSCRIPTION_REFRESH_BUFFER_MS) {
+          return {
+            subscriptionName: sub.name,
+            expireTime
+          };
+        }
+      }
+    } catch (error) {
+      this.logger?.debug("Error checking existing subscriptions", { error });
+    }
+    return null;
+  }
+  /**
+   * Get auth options for Workspace Events API calls.
+   */
+  getAuthOptions() {
+    if (this.credentials) {
+      return {
+        credentials: this.credentials,
+        impersonateUser: this.impersonateUser
+      };
+    }
+    if (this.useADC) {
+      return {
+        useApplicationDefaultCredentials: true,
+        impersonateUser: this.impersonateUser
+      };
+    }
+    if (this.customAuth) {
+      return { auth: this.customAuth };
+    }
+    return null;
+  }
+  async handleWebhook(request, options) {
+    const body = await request.text();
+    this.logger?.debug("GChat webhook raw body", { body });
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return new Response("Invalid JSON", { status: 400 });
+    }
+    const maybePubSub = parsed;
+    if (maybePubSub.message?.data && maybePubSub.subscription) {
+      return this.handlePubSubMessage(maybePubSub, options);
+    }
+    const event = parsed;
+    const addedPayload = event.chat?.addedToSpacePayload;
+    if (addedPayload) {
+      this.logger?.debug("Bot added to space", {
+        space: addedPayload.space.name,
+        spaceType: addedPayload.space.type
+      });
+      this.handleAddedToSpace(addedPayload.space, options);
+    }
+    const removedPayload = event.chat?.removedFromSpacePayload;
+    if (removedPayload) {
+      this.logger?.debug("Bot removed from space", {
+        space: removedPayload.space.name
+      });
+    }
+    const buttonClickedPayload = event.chat?.buttonClickedPayload;
+    const invokedFunction = event.commonEventObject?.invokedFunction;
+    if (buttonClickedPayload || invokedFunction) {
+      this.handleCardClick(event, options);
+      return new Response(
+        JSON.stringify({
+          actionResponse: {
+            type: "UPDATE_MESSAGE"
+          }
+        }),
+        {
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const messagePayload = event.chat?.messagePayload;
+    if (messagePayload) {
+      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", {
+        hasChat: !!event.chat,
+        hasCommonEventObject: !!event.commonEventObject
+      });
+    }
+    return new Response(JSON.stringify({}), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Handle Pub/Sub push messages from Workspace Events subscriptions.
+   * These contain all messages in a space, not just @mentions.
+   */
+  handlePubSubMessage(pushMessage, options) {
+    const eventType = pushMessage.message?.attributes?.["ce-type"];
+    const allowedEventTypes = [
+      "google.workspace.chat.message.v1.created",
+      "google.workspace.chat.reaction.v1.created",
+      "google.workspace.chat.reaction.v1.deleted"
+    ];
+    if (eventType && !allowedEventTypes.includes(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", {
+        eventType: notification.eventType,
+        messageId: notification.message?.name,
+        reactionName: notification.reaction?.name
+      });
+      if (notification.message) {
+        this.handlePubSubMessageEvent(notification, options);
+      }
+      if (notification.reaction) {
+        this.handlePubSubReactionEvent(notification, options);
+      }
+      return new Response(JSON.stringify({ success: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (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" }
+      });
+    }
+  }
+  /**
+   * Handle message events received via Pub/Sub (Workspace Events).
+   */
+  handlePubSubMessageEvent(notification, options) {
+    if (!this.chat || !notification.message) {
+      return;
+    }
+    const message = notification.message;
+    const spaceName = notification.targetResource?.replace(
+      "//chat.googleapis.com/",
+      ""
+    );
+    const threadName = message.thread?.name || message.name;
+    const threadId = this.encodeThreadId({
+      spaceName: spaceName || message.space?.name || "",
+      threadName
+    });
+    const resolvedSpaceName = spaceName || message.space?.name;
+    if (resolvedSpaceName && options?.waitUntil) {
+      options.waitUntil(
+        this.ensureSpaceSubscription(resolvedSpaceName).catch((err) => {
+          this.logger?.debug("Subscription refresh failed", { error: err });
+        })
+      );
+    }
+    this.chat.processMessage(
+      this,
+      threadId,
+      () => this.parsePubSubMessage(notification, threadId),
+      options
+    );
+  }
+  /**
+   * Handle reaction events received via Pub/Sub (Workspace Events).
+   * Fetches the message to get thread context for proper reply threading.
+   */
+  handlePubSubReactionEvent(notification, options) {
+    if (!this.chat || !notification.reaction) {
+      return;
+    }
+    const reaction = notification.reaction;
+    const rawEmoji = reaction.emoji?.unicode || "";
+    const normalizedEmoji = defaultEmojiResolver.fromGChat(rawEmoji);
+    const reactionName = reaction.name || "";
+    const messageNameMatch = reactionName.match(
+      /(spaces\/[^/]+\/messages\/[^/]+)/
+    );
+    const messageName = messageNameMatch ? messageNameMatch[1] : "";
+    const spaceName = notification.targetResource?.replace(
+      "//chat.googleapis.com/",
+      ""
+    );
+    const isMe = this.botUserId !== void 0 && reaction.user?.name === this.botUserId;
+    const added = notification.eventType.includes("created");
+    const chat = this.chat;
+    const buildReactionEvent = async () => {
+      let threadId;
+      if (messageName) {
+        try {
+          const messageResponse = await this.chatApi.spaces.messages.get({
+            name: messageName
+          });
+          const threadName = messageResponse.data.thread?.name;
+          threadId = this.encodeThreadId({
+            spaceName: spaceName || "",
+            threadName: threadName ?? void 0
+          });
+          this.logger?.debug("Fetched thread context for reaction", {
+            messageName,
+            threadName,
+            threadId
+          });
+        } catch (error) {
+          this.logger?.warn("Failed to fetch message for thread context", {
+            messageName,
+            error
+          });
+          threadId = this.encodeThreadId({
+            spaceName: spaceName || ""
+          });
+        }
+      } else {
+        threadId = this.encodeThreadId({
+          spaceName: spaceName || ""
+        });
+      }
+      return {
+        emoji: normalizedEmoji,
+        rawEmoji,
+        added,
+        user: {
+          userId: reaction.user?.name || "unknown",
+          userName: reaction.user?.displayName || "unknown",
+          fullName: reaction.user?.displayName || "unknown",
+          isBot: reaction.user?.type === "BOT",
+          isMe
+        },
+        messageId: messageName,
+        threadId,
+        raw: notification,
+        adapter: this
+      };
+    };
+    const processTask = buildReactionEvent().then((reactionEvent) => {
+      chat.processReaction(reactionEvent, options);
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(processTask);
+    }
+  }
+  /**
+   * Parse a Pub/Sub message into the standard Message format.
+   * Resolves user display names from cache since Pub/Sub messages don't include them.
+   */
+  async parsePubSubMessage(notification, threadId) {
+    const message = notification.message;
+    if (!message) {
+      throw new Error("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(
+      userId,
+      message.sender?.displayName
+    );
+    const parsedMessage = {
+      id: message.name,
+      threadId,
+      text: this.formatConverter.extractPlainText(text),
+      formatted: this.formatConverter.toAst(text),
+      raw: notification,
+      author: {
+        userId,
+        userName: displayName,
+        fullName: displayName,
+        isBot,
+        isMe
+      },
+      metadata: {
+        dateSent: new Date(message.createTime),
+        edited: false
+      },
+      attachments: (message.attachment || []).map(
+        (att) => this.createAttachment(att)
+      )
+    };
+    this.logger?.debug("Pub/Sub parsed message", {
+      threadId,
+      messageId: parsedMessage.id,
+      text: parsedMessage.text,
+      author: parsedMessage.author.fullName,
+      isBot: parsedMessage.author.isBot,
+      isMe: parsedMessage.author.isMe
+    });
+    return parsedMessage;
+  }
+  /**
+   * Handle bot being added to a space - create Workspace Events subscription.
+   */
+  handleAddedToSpace(space, options) {
+    const subscribeTask = this.ensureSpaceSubscription(space.name);
+    if (options?.waitUntil) {
+      options.waitUntil(subscribeTask);
+    }
+  }
+  /**
+   * Handle card button clicks.
+   * Google Chat sends action data via commonEventObject.invokedFunction and parameters.
+   */
+  handleCardClick(event, options) {
+    if (!this.chat) {
+      this.logger?.warn("Chat instance not initialized, ignoring card click");
+      return;
+    }
+    const buttonPayload = event.chat?.buttonClickedPayload;
+    const commonEvent = event.commonEventObject;
+    const actionId = commonEvent?.invokedFunction;
+    if (!actionId) {
+      this.logger?.debug("Card click missing invokedFunction");
+      return;
+    }
+    const value = commonEvent?.parameters?.value;
+    const space = buttonPayload?.space;
+    const message = buttonPayload?.message;
+    const user = buttonPayload?.user || event.chat?.user;
+    if (!space) {
+      this.logger?.warn("Card click missing space info");
+      return;
+    }
+    const threadName = message?.thread?.name || message?.name;
+    const threadId = this.encodeThreadId({
+      spaceName: space.name,
+      threadName
+    });
+    const actionEvent = {
+      actionId,
+      value,
+      user: {
+        userId: user?.name || "unknown",
+        userName: user?.displayName || "unknown",
+        fullName: user?.displayName || "unknown",
+        isBot: user?.type === "BOT",
+        isMe: false
+      },
+      messageId: message?.name || "",
+      threadId,
+      adapter: this,
+      raw: event
+    };
+    this.logger?.debug("Processing GChat card click", {
+      actionId,
+      value,
+      messageId: actionEvent.messageId,
+      threadId
+    });
+    this.chat.processAction(actionEvent, options);
+  }
+  /**
+   * Handle direct webhook message events (Add-ons format).
+   */
+  handleMessageEvent(event, options) {
+    if (!this.chat) {
+      this.logger?.warn("Chat instance not initialized, ignoring event");
+      return;
+    }
+    const messagePayload = event.chat?.messagePayload;
+    if (!messagePayload) {
+      this.logger?.debug("Ignoring event without messagePayload");
+      return;
+    }
+    const message = messagePayload.message;
+    const isDM = messagePayload.space.type === "DM" || messagePayload.space.spaceType === "DIRECT_MESSAGE";
+    const threadName = isDM ? void 0 : message.thread?.name || message.name;
+    const threadId = this.encodeThreadId({
+      spaceName: messagePayload.space.name,
+      threadName,
+      isDM
+    });
+    this.chat.processMessage(
+      this,
+      threadId,
+      this.parseGoogleChatMessage(event, threadId),
+      options
+    );
+  }
+  parseGoogleChatMessage(event, threadId) {
+    const message = event.chat?.messagePayload?.message;
+    if (!message) {
+      throw new Error("Event has no message payload");
+    }
+    const text = this.normalizeBotMentions(message);
+    const isBot = message.sender?.type === "BOT";
+    const isMe = this.isMessageFromSelf(message);
+    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(
+        () => {
+        }
+      );
+    }
+    return {
+      id: message.name,
+      threadId,
+      text: this.formatConverter.extractPlainText(text),
+      formatted: this.formatConverter.toAst(text),
+      raw: event,
+      author: {
+        userId,
+        userName: displayName,
+        fullName: displayName,
+        isBot,
+        isMe
+      },
+      metadata: {
+        dateSent: new Date(message.createTime),
+        edited: false
+      },
+      attachments: (message.attachment || []).map(
+        (att) => this.createAttachment(att)
+      )
+    };
+  }
+  async postMessage(threadId, message) {
+    const { spaceName, threadName } = this.decodeThreadId(threadId);
+    try {
+      const files = this.extractFiles(message);
+      if (files.length > 0) {
+        this.logger?.warn(
+          "File uploads are not yet supported for Google Chat. Files will be ignored.",
+          { fileCount: files.length }
+        );
+      }
+      const card = this.extractCard(message);
+      if (card) {
+        const googleCard = cardToGoogleCard(card);
+        this.logger?.debug("GChat API: spaces.messages.create (card)", {
+          spaceName,
+          threadName,
+          googleCard: JSON.stringify(googleCard)
+        });
+        const response2 = await this.chatApi.spaces.messages.create({
+          parent: spaceName,
+          messageReplyOption: threadName ? "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD" : void 0,
+          requestBody: {
+            // Don't include text - GChat shows both text and card if text is present
+            cardsV2: [googleCard],
+            thread: threadName ? { name: threadName } : void 0
+          }
+        });
+        this.logger?.debug("GChat API: spaces.messages.create response", {
+          messageName: response2.data.name
+        });
+        return {
+          id: response2.data.name || "",
+          threadId,
+          raw: response2.data
+        };
+      }
+      const text = convertEmojiPlaceholders2(
+        this.formatConverter.renderPostable(message),
+        "gchat"
+      );
+      this.logger?.debug("GChat API: spaces.messages.create", {
+        spaceName,
+        threadName,
+        textLength: text.length
+      });
+      const response = await this.chatApi.spaces.messages.create({
+        parent: spaceName,
+        // Required to reply in an existing thread
+        messageReplyOption: threadName ? "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD" : void 0,
+        requestBody: {
+          text,
+          thread: threadName ? { name: threadName } : void 0
+        }
+      });
+      this.logger?.debug("GChat API: spaces.messages.create response", {
+        messageName: response.data.name
+      });
+      return {
+        id: response.data.name || "",
+        threadId,
+        raw: response.data
+      };
+    } catch (error) {
+      this.handleGoogleChatError(error, "postMessage");
+    }
+  }
+  /**
+   * Extract card element from a PostableMessage 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 PostableMessage 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.
+   */
+  createAttachment(att) {
+    const url = att.downloadUri || void 0;
+    const authClient = this.authClient;
+    let type = "file";
+    if (att.contentType?.startsWith("image/")) {
+      type = "image";
+    } else if (att.contentType?.startsWith("video/")) {
+      type = "video";
+    } else if (att.contentType?.startsWith("audio/")) {
+      type = "audio";
+    }
+    const auth = authClient;
+    return {
+      type,
+      url,
+      name: att.contentName || void 0,
+      mimeType: att.contentType || void 0,
+      fetchData: url ? async () => {
+        if (typeof auth === "string" || !auth) {
+          throw new Error("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");
+        }
+        const response = await fetch(url, {
+          headers: {
+            Authorization: `Bearer ${token}`
+          }
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Failed to fetch file: ${response.status} ${response.statusText}`
+          );
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+      } : void 0
+    };
+  }
+  async editMessage(threadId, messageId, message) {
+    try {
+      const card = this.extractCard(message);
+      if (card) {
+        const googleCard = cardToGoogleCard(card);
+        this.logger?.debug("GChat API: spaces.messages.update (card)", {
+          messageId
+        });
+        const response2 = await this.chatApi.spaces.messages.update({
+          name: messageId,
+          updateMask: "cardsV2",
+          requestBody: {
+            // Don't include text - GChat shows both text and card if text is present
+            cardsV2: [googleCard]
+          }
+        });
+        this.logger?.debug("GChat API: spaces.messages.update response", {
+          messageName: response2.data.name
+        });
+        return {
+          id: response2.data.name || "",
+          threadId,
+          raw: response2.data
+        };
+      }
+      const text = convertEmojiPlaceholders2(
+        this.formatConverter.renderPostable(message),
+        "gchat"
+      );
+      this.logger?.debug("GChat API: spaces.messages.update", {
+        messageId,
+        textLength: text.length
+      });
+      const response = await this.chatApi.spaces.messages.update({
+        name: messageId,
+        updateMask: "text",
+        requestBody: {
+          text
+        }
+      });
+      this.logger?.debug("GChat API: spaces.messages.update response", {
+        messageName: response.data.name
+      });
+      return {
+        id: response.data.name || "",
+        threadId,
+        raw: response.data
+      };
+    } catch (error) {
+      this.handleGoogleChatError(error, "editMessage");
+    }
+  }
+  async deleteMessage(_threadId, messageId) {
+    try {
+      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", {
+        ok: true
+      });
+    } catch (error) {
+      this.handleGoogleChatError(error, "deleteMessage");
+    }
+  }
+  async addReaction(_threadId, messageId, emoji) {
+    const gchatEmoji = defaultEmojiResolver.toGChat(emoji);
+    try {
+      this.logger?.debug("GChat API: spaces.messages.reactions.create", {
+        messageId,
+        emoji: gchatEmoji
+      });
+      await this.chatApi.spaces.messages.reactions.create({
+        parent: messageId,
+        requestBody: {
+          emoji: { unicode: gchatEmoji }
+        }
+      });
+      this.logger?.debug(
+        "GChat API: spaces.messages.reactions.create response",
+        {
+          ok: true
+        }
+      );
+    } catch (error) {
+      this.handleGoogleChatError(error, "addReaction");
+    }
+  }
+  async removeReaction(_threadId, messageId, emoji) {
+    const gchatEmoji = defaultEmojiResolver.toGChat(emoji);
+    try {
+      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", {
+        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", {
+          messageId,
+          emoji: gchatEmoji
+        });
+        return;
+      }
+      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(
+        "GChat API: spaces.messages.reactions.delete response",
+        {
+          ok: true
+        }
+      );
+    } catch (error) {
+      this.handleGoogleChatError(error, "removeReaction");
+    }
+  }
+  async startTyping(_threadId) {
+  }
+  /**
+   * Open a direct message conversation with a user.
+   * Returns a thread ID that can be used to post messages.
+   *
+   * For Google Chat, this first tries to find an existing DM space with the user.
+   * If no DM exists, it creates one using spaces.setup.
+   *
+   * @param userId - The user's resource name (e.g., "users/123456")
+   */
+  async openDM(userId) {
+    try {
+      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", {
+          spaceName: findResponse.data.name
+        });
+        return this.encodeThreadId({
+          spaceName: findResponse.data.name,
+          isDM: true
+        });
+      }
+    } catch (error) {
+      const gError = error;
+      if (gError.code !== 404) {
+        this.logger?.debug("GChat API: findDirectMessage failed", { error });
+      }
+    }
+    const chatApi = this.impersonatedChatApi || this.chatApi;
+    if (!this.impersonatedChatApi) {
+      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)", {
+        userId,
+        hasImpersonation: !!this.impersonatedChatApi,
+        impersonateUser: this.impersonateUser
+      });
+      const response = await chatApi.spaces.setup({
+        requestBody: {
+          space: {
+            spaceType: "DIRECT_MESSAGE"
+          },
+          memberships: [
+            {
+              member: {
+                name: userId,
+                type: "HUMAN"
+              }
+            }
+          ]
+        }
+      });
+      const spaceName = response.data.name;
+      if (!spaceName) {
+        throw new Error("Failed to create DM - no space name returned");
+      }
+      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);
+    try {
+      this.logger?.debug("GChat API: spaces.messages.list", {
+        spaceName,
+        pageSize: options.limit || 100
+      });
+      const response = await this.chatApi.spaces.messages.list({
+        parent: spaceName,
+        pageSize: options.limit || 100,
+        pageToken: options.before
+      });
+      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");
+    }
+  }
+  async fetchThread(threadId) {
+    const { spaceName } = this.decodeThreadId(threadId);
+    try {
+      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", {
+        displayName: response.data.displayName
+      });
+      return {
+        id: threadId,
+        channelId: spaceName,
+        channelName: response.data.displayName ?? void 0,
+        metadata: {
+          space: response.data
+        }
+      };
+    } catch (error) {
+      this.handleGoogleChatError(error, "fetchThread");
+    }
+  }
+  encodeThreadId(platformData) {
+    const threadPart = platformData.threadName ? `:${Buffer.from(platformData.threadName).toString("base64url")}` : "";
+    const dmPart = platformData.isDM ? ":dm" : "";
+    return `gchat:${platformData.spaceName}${threadPart}${dmPart}`;
+  }
+  /**
+   * 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");
+  }
+  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 };
+  }
+  parseMessage(raw) {
+    const event = raw;
+    const messagePayload = event.chat?.messagePayload;
+    if (!messagePayload) {
+      throw new Error("Cannot parse non-message event");
+    }
+    const threadName = messagePayload.message.thread?.name || messagePayload.message.name;
+    const threadId = this.encodeThreadId({
+      spaceName: messagePayload.space.name,
+      threadName
+    });
+    return this.parseGoogleChatMessage(event, threadId);
+  }
+  renderFormatted(content) {
+    return this.formatConverter.fromAst(content);
+  }
+  /**
+   * Normalize bot mentions in message text.
+   * Google Chat uses the bot's display name (e.g., "@Chat SDK Demo") but the
+   * Chat SDK expects "@{userName}" format. This method replaces bot mentions
+   * with the adapter's userName so mention detection works properly.
+   * Also learns the bot's user ID from annotations for isMe detection.
+   */
+  normalizeBotMentions(message) {
+    let text = message.text || "";
+    const annotations = message.annotations || [];
+    for (const annotation of annotations) {
+      if (annotation.type === "USER_MENTION" && annotation.userMention?.user?.type === "BOT") {
+        const botUser = annotation.userMention.user;
+        const botDisplayName = botUser.displayName;
+        if (botUser.name && !this.botUserId) {
+          this.botUserId = botUser.name;
+          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 })
+          );
+        }
+        if (annotation.startIndex !== void 0 && annotation.length !== void 0) {
+          const startIndex = annotation.startIndex;
+          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", {
+            original: mentionText,
+            replacement: `@${this.userName}`
+          });
+        } else if (botDisplayName) {
+          const mentionText = `@${botDisplayName}`;
+          text = text.replace(mentionText, `@${this.userName}`);
+        }
+      }
+    }
+    return text;
+  }
+  /**
+   * Check if a message is from this bot.
+   *
+   * Bot user ID is learned dynamically from message annotations when the bot
+   * is @mentioned. Until we learn the ID, we cannot reliably determine isMe.
+   *
+   * This is safer than the previous approach of assuming all BOT messages are
+   * from self, which would incorrectly filter messages from other bots in
+   * multi-bot spaces (especially via Pub/Sub).
+   */
+  isMessageFromSelf(message) {
+    const senderId = message.sender?.name;
+    if (this.botUserId && senderId) {
+      return senderId === this.botUserId;
+    }
+    if (!this.botUserId && message.sender?.type === "BOT") {
+      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})` : ""}`, {
+      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 error;
+  }
+};
+function createGoogleChatAdapter(config) {
+  return new GoogleChatAdapter(config);
+}
+export {
+  GoogleChatAdapter,
+  GoogleChatFormatConverter,
+  cardToFallbackText,
+  cardToGoogleCard,
+  createGoogleChatAdapter,
+  createSpaceSubscription,
+  decodePubSubMessage,
+  deleteSpaceSubscription,
+  listSpaceSubscriptions,
+  verifyPubSubRequest
+};
+//# sourceMappingURL=index.js.map