@elizaos/plugin-google-chat 2.0.0-alpha.6 → 2.0.3-beta.2

package/dist/index.js

@@ -1,1115 +0,0 @@
-// src/index.ts
-import { logger as logger3 } from "@elizaos/core";
-
-// src/types.ts
-var MAX_GOOGLE_CHAT_MESSAGE_LENGTH = 4000;
-var GOOGLE_CHAT_SERVICE_NAME = "google-chat";
-var GoogleChatEventTypes;
-((GoogleChatEventTypes2) => {
-  GoogleChatEventTypes2["MESSAGE_RECEIVED"] = "GOOGLE_CHAT_MESSAGE_RECEIVED";
-  GoogleChatEventTypes2["MESSAGE_SENT"] = "GOOGLE_CHAT_MESSAGE_SENT";
-  GoogleChatEventTypes2["SPACE_JOINED"] = "GOOGLE_CHAT_SPACE_JOINED";
-  GoogleChatEventTypes2["SPACE_LEFT"] = "GOOGLE_CHAT_SPACE_LEFT";
-  GoogleChatEventTypes2["REACTION_RECEIVED"] = "GOOGLE_CHAT_REACTION_RECEIVED";
-  GoogleChatEventTypes2["REACTION_SENT"] = "GOOGLE_CHAT_REACTION_SENT";
-  GoogleChatEventTypes2["WEBHOOK_READY"] = "GOOGLE_CHAT_WEBHOOK_READY";
-  GoogleChatEventTypes2["CONNECTION_READY"] = "GOOGLE_CHAT_CONNECTION_READY";
-})(GoogleChatEventTypes ||= {});
-
-class GoogleChatPluginError extends Error {
-  code;
-  cause;
-  constructor(message, code, cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = "GoogleChatPluginError";
-  }
-}
-
-class GoogleChatConfigurationError extends GoogleChatPluginError {
-  setting;
-  constructor(message, setting, cause) {
-    super(message, "CONFIGURATION_ERROR", cause);
-    this.name = "GoogleChatConfigurationError";
-    this.setting = setting;
-  }
-}
-
-class GoogleChatApiError extends GoogleChatPluginError {
-  statusCode;
-  constructor(message, statusCode, cause) {
-    super(message, "API_ERROR", cause);
-    this.name = "GoogleChatApiError";
-    this.statusCode = statusCode;
-  }
-}
-
-class GoogleChatAuthenticationError extends GoogleChatPluginError {
-  constructor(message, cause) {
-    super(message, "AUTHENTICATION_ERROR", cause);
-    this.name = "GoogleChatAuthenticationError";
-  }
-}
-var SPACE_NAME_REGEX = /^spaces\/[A-Za-z0-9_-]+$/;
-var USER_NAME_REGEX = /^users\/[A-Za-z0-9_-]+$/;
-function isValidGoogleChatSpaceName(name) {
-  return SPACE_NAME_REGEX.test(name);
-}
-function isValidGoogleChatUserName(name) {
-  return USER_NAME_REGEX.test(name);
-}
-function normalizeSpaceTarget(target) {
-  const trimmed = target.trim();
-  if (!trimmed) {
-    return null;
-  }
-  if (trimmed.startsWith("spaces/")) {
-    return trimmed;
-  }
-  if (/^[A-Za-z0-9_-]+$/.test(trimmed)) {
-    return `spaces/${trimmed}`;
-  }
-  return null;
-}
-function normalizeUserTarget(target) {
-  const trimmed = target.trim();
-  if (!trimmed) {
-    return null;
-  }
-  if (trimmed.startsWith("users/")) {
-    return trimmed;
-  }
-  if (/^[A-Za-z0-9_-]+$/.test(trimmed)) {
-    return `users/${trimmed}`;
-  }
-  return null;
-}
-function extractResourceId(resourceName) {
-  const parts = resourceName.split("/");
-  return parts[parts.length - 1];
-}
-function getUserDisplayName(user) {
-  return user.displayName || extractResourceId(user.name);
-}
-function getSpaceDisplayName(space) {
-  return space.displayName || extractResourceId(space.name);
-}
-function isDirectMessage(space) {
-  return space.type === "DM" || space.singleUserBotDm === true;
-}
-function splitMessageForGoogleChat(text, maxLength = MAX_GOOGLE_CHAT_MESSAGE_LENGTH) {
-  if (text.length <= maxLength) {
-    return [text];
-  }
-  const chunks = [];
-  let remaining = text;
-  while (remaining.length > 0) {
-    if (remaining.length <= maxLength) {
-      chunks.push(remaining);
-      break;
-    }
-    let breakPoint = maxLength;
-    const newlineIndex = remaining.lastIndexOf(`
-`, maxLength);
-    if (newlineIndex > maxLength * 0.5) {
-      breakPoint = newlineIndex + 1;
-    } else {
-      const spaceIndex = remaining.lastIndexOf(" ", maxLength);
-      if (spaceIndex > maxLength * 0.5) {
-        breakPoint = spaceIndex + 1;
-      }
-    }
-    chunks.push(remaining.slice(0, breakPoint).trimEnd());
-    remaining = remaining.slice(breakPoint).trimStart();
-  }
-  return chunks;
-}
-
-// src/actions/listSpaces.ts
-var listSpaces = {
-  name: "GOOGLE_CHAT_LIST_SPACES",
-  similes: [
-    "LIST_GOOGLE_CHAT_SPACES",
-    "GCHAT_SPACES",
-    "SHOW_GOOGLE_CHAT_SPACES"
-  ],
-  description: "List all Google Chat spaces the bot is a member of",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "google-chat";
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    const gchatService = runtime.getService(GOOGLE_CHAT_SERVICE_NAME);
-    if (!gchatService || !gchatService.isConnected()) {
-      if (callback) {
-        callback({
-          text: "Google Chat service is not available.",
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: "Google Chat service not available" };
-    }
-    const spaces = await gchatService.getSpaces();
-    if (spaces.length === 0) {
-      if (callback) {
-        callback({
-          text: "I'm not currently in any Google Chat spaces.",
-          source: message.content.source
-        });
-      }
-      return {
-        success: true,
-        data: { spaceCount: 0, spaces: [] }
-      };
-    }
-    const spaceLines = spaces.map((space) => {
-      const name = getSpaceDisplayName(space);
-      const type = isDirectMessage(space) ? "DM" : space.type || "SPACE";
-      const threaded = space.threaded ? " (threaded)" : "";
-      return `• ${name} [${type}]${threaded}`;
-    });
-    const responseText = `Currently in ${spaces.length} space(s):
-
-${spaceLines.join(`
-`)}`;
-    if (callback) {
-      callback({
-        text: responseText,
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        spaceCount: spaces.length,
-        spaces: spaces.map((s) => ({
-          name: s.name,
-          displayName: s.displayName,
-          type: s.type,
-          threaded: s.threaded
-        }))
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "What Google Chat spaces are you in?" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "Let me check my Google Chat spaces.",
-          actions: ["GOOGLE_CHAT_LIST_SPACES"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "List all spaces" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll list all the Google Chat spaces I'm in.",
-          actions: ["GOOGLE_CHAT_LIST_SPACES"]
-        }
-      }
-    ]
-  ]
-};
-// src/actions/sendMessage.ts
-import {
-  composePromptFromState,
-  logger,
-  ModelType,
-  parseJSONObjectFromText
-} from "@elizaos/core";
-var SEND_MESSAGE_TEMPLATE = `# Task: Extract Google Chat send message parameters
-Based on the conversation, determine what message to send and to which space.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract the following:
-- text: The message content to send
-- space: The target space ID (or "current" for the current space)
-- thread: Optional thread name to reply in
-
-Respond with a JSON object:
-\`\`\`json
-{
-  "text": "message content here",
-  "space": "spaces/xxx or current",
-  "thread": "optional thread name"
-}
-\`\`\``;
-var sendMessage = {
-  name: "GOOGLE_CHAT_SEND_MESSAGE",
-  similes: [
-    "SEND_GOOGLE_CHAT_MESSAGE",
-    "MESSAGE_GOOGLE_CHAT",
-    "GCHAT_SEND",
-    "GOOGLE_CHAT_TEXT"
-  ],
-  description: "Send a message to a Google Chat space",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "google-chat";
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const gchatService = runtime.getService(GOOGLE_CHAT_SERVICE_NAME);
-    if (!gchatService || !gchatService.isConnected()) {
-      if (callback) {
-        callback({
-          text: "Google Chat service is not available.",
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: "Google Chat service not available" };
-    }
-    const currentState = state ?? await runtime.composeState(message);
-    const prompt = await composePromptFromState({
-      template: SEND_MESSAGE_TEMPLATE,
-      state: currentState
-    });
-    let messageInfo = null;
-    for (let attempt = 0;attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt
-      });
-      const parsed = parseJSONObjectFromText(response);
-      if (parsed?.text) {
-        messageInfo = {
-          text: String(parsed.text),
-          space: String(parsed.space || "current"),
-          thread: parsed.thread ? String(parsed.thread) : undefined
-        };
-        break;
-      }
-    }
-    if (!messageInfo || !messageInfo.text) {
-      if (callback) {
-        callback({
-          text: "I couldn't understand what message you want me to send. Please try again.",
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: "Could not extract message parameters" };
-    }
-    let targetSpace;
-    if (messageInfo.space && messageInfo.space !== "current") {
-      const normalized = normalizeSpaceTarget(messageInfo.space);
-      if (normalized) {
-        targetSpace = normalized;
-      }
-    }
-    const spaceData = currentState.data?.space;
-    if (!targetSpace && spaceData?.name) {
-      targetSpace = String(spaceData.name);
-    }
-    if (!targetSpace) {
-      if (callback) {
-        callback({
-          text: "I couldn't determine which space to send to. Please specify a space.",
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: "Could not determine target space" };
-    }
-    const chunks = splitMessageForGoogleChat(messageInfo.text);
-    let lastResult;
-    for (const chunk of chunks) {
-      const result = await gchatService.sendMessage({
-        space: targetSpace,
-        text: chunk,
-        thread: messageInfo.thread
-      });
-      if (!result.success) {
-        if (callback) {
-          callback({
-            text: `Failed to send message: ${result.error}`,
-            source: "google-chat"
-          });
-        }
-        return { success: false, error: result.error };
-      }
-      lastResult = { messageName: result.messageName };
-      logger.debug(`Sent Google Chat message: ${result.messageName}`);
-    }
-    if (callback) {
-      callback({
-        text: "Message sent successfully.",
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        space: targetSpace,
-        messageName: lastResult?.messageName,
-        chunksCount: chunks.length
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Send a message saying 'Hello everyone!'" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll send that message to the space.",
-          actions: ["GOOGLE_CHAT_SEND_MESSAGE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: {
-          text: "Post 'Meeting starts in 5 minutes' to the team space"
-        }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll post that reminder to the team space.",
-          actions: ["GOOGLE_CHAT_SEND_MESSAGE"]
-        }
-      }
-    ]
-  ]
-};
-// src/actions/sendReaction.ts
-import {
-  composePromptFromState as composePromptFromState2,
-  ModelType as ModelType2,
-  parseJSONObjectFromText as parseJSONObjectFromText2
-} from "@elizaos/core";
-var SEND_REACTION_TEMPLATE = `# Task: Extract Google Chat reaction parameters
-Based on the conversation, determine the emoji reaction to add or remove.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract the following:
-- emoji: The emoji to react with (Unicode emoji character)
-- messageName: The message resource name to react to
-- remove: Whether to remove the reaction (true/false)
-
-Respond with a JSON object:
-\`\`\`json
-{
-  "emoji": "\uD83D\uDC4D",
-  "messageName": "spaces/xxx/messages/yyy",
-  "remove": false
-}
-\`\`\``;
-var sendReaction = {
-  name: "GOOGLE_CHAT_SEND_REACTION",
-  similes: [
-    "REACT_GOOGLE_CHAT",
-    "GCHAT_REACT",
-    "GOOGLE_CHAT_EMOJI",
-    "ADD_GOOGLE_CHAT_REACTION"
-  ],
-  description: "Add or remove an emoji reaction to a Google Chat message",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "google-chat";
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const gchatService = runtime.getService(GOOGLE_CHAT_SERVICE_NAME);
-    if (!gchatService || !gchatService.isConnected()) {
-      if (callback) {
-        callback({
-          text: "Google Chat service is not available.",
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: "Google Chat service not available" };
-    }
-    const currentState = state ?? await runtime.composeState(message);
-    const prompt = await composePromptFromState2({
-      template: SEND_REACTION_TEMPLATE,
-      state: currentState
-    });
-    let reactionInfo = null;
-    for (let attempt = 0;attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType2.TEXT_SMALL, {
-        prompt
-      });
-      const parsed = parseJSONObjectFromText2(response);
-      if (parsed?.emoji && parsed?.messageName) {
-        reactionInfo = {
-          emoji: String(parsed.emoji),
-          messageName: String(parsed.messageName),
-          remove: parsed.remove === true
-        };
-        break;
-      }
-    }
-    if (!reactionInfo) {
-      if (callback) {
-        callback({
-          text: "I couldn't understand the reaction details. Please try again.",
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: "Could not extract reaction parameters" };
-    }
-    let targetMessage = reactionInfo.messageName;
-    const messageData = currentState.data?.message;
-    if (!targetMessage && messageData?.name) {
-      targetMessage = String(messageData.name);
-    }
-    if (!targetMessage) {
-      if (callback) {
-        callback({
-          text: "I couldn't determine which message to react to. Please specify the message.",
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: "Could not determine target message" };
-    }
-    if (reactionInfo.remove) {
-      const reactions = await gchatService.listReactions(targetMessage);
-      const botUser = gchatService.getBotUser();
-      const toRemove = reactions.filter((r) => {
-        const userName = r.user?.name;
-        if (botUser && userName !== botUser && userName !== "users/app") {
-          return false;
-        }
-        if (reactionInfo?.emoji && r.emoji?.unicode !== reactionInfo?.emoji) {
-          return false;
-        }
-        return true;
-      });
-      for (const reaction of toRemove) {
-        if (reaction.name) {
-          await gchatService.deleteReaction(reaction.name);
-        }
-      }
-      if (callback) {
-        callback({
-          text: `Removed ${toRemove.length} reaction(s).`,
-          source: message.content.source
-        });
-      }
-      return {
-        success: true,
-        data: {
-          removed: toRemove.length
-        }
-      };
-    }
-    const result = await gchatService.sendReaction(targetMessage, reactionInfo.emoji);
-    if (!result.success) {
-      if (callback) {
-        callback({
-          text: `Failed to add reaction: ${result.error}`,
-          source: "google-chat"
-        });
-      }
-      return { success: false, error: result.error };
-    }
-    if (callback) {
-      callback({
-        text: `Added ${reactionInfo.emoji} reaction.`,
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        reactionName: result.name,
-        emoji: reactionInfo.emoji
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "React with a thumbs up to that message" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll add a thumbs up reaction.",
-          actions: ["GOOGLE_CHAT_SEND_REACTION"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Remove my reaction from that message" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll remove the reaction.",
-          actions: ["GOOGLE_CHAT_SEND_REACTION"]
-        }
-      }
-    ]
-  ]
-};
-// src/providers/spaceState.ts
-var spaceStateProvider = {
-  name: "googleChatSpaceState",
-  description: "Provides information about the current Google Chat space context",
-  get: async (runtime, message, state) => {
-    if (message.content.source !== "google-chat") {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const gchatService = runtime.getService(GOOGLE_CHAT_SERVICE_NAME);
-    if (!gchatService || !gchatService.isConnected()) {
-      return {
-        data: { connected: false },
-        values: { connected: false },
-        text: ""
-      };
-    }
-    const agentName = state?.agentName || "The agent";
-    const space = state?.data?.space;
-    const spaceName = space?.name;
-    const spaceDisplayName = space?.displayName;
-    const spaceType = space?.type;
-    const isThreaded = space?.threaded;
-    const isDm = spaceType === "DM" || space?.singleUserBotDm === true;
-    let responseText = "";
-    if (isDm) {
-      responseText = `${agentName} is in a direct message conversation on Google Chat.`;
-    } else {
-      const label = spaceDisplayName || spaceName || "a Google Chat space";
-      responseText = `${agentName} is currently in Google Chat space "${label}".`;
-      if (isThreaded) {
-        responseText += " This space uses threaded conversations.";
-      }
-    }
-    responseText += `
-
-Google Chat is Google Workspace's team communication platform.`;
-    return {
-      data: {
-        spaceName,
-        spaceDisplayName,
-        spaceType,
-        isThreaded: isThreaded || false,
-        isDirect: isDm || false,
-        connected: true
-      },
-      values: {
-        spaceName,
-        spaceDisplayName,
-        spaceType,
-        isThreaded: isThreaded || false,
-        isDirect: isDm || false
-      },
-      text: responseText
-    };
-  }
-};
-// src/providers/userContext.ts
-var userContextProvider = {
-  name: "googleChatUserContext",
-  description: "Provides information about the Google Chat user in the current conversation",
-  get: async (runtime, message, state) => {
-    if (message.content.source !== "google-chat") {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const gchatService = runtime.getService(GOOGLE_CHAT_SERVICE_NAME);
-    if (!gchatService || !gchatService.isConnected()) {
-      return {
-        data: { connected: false },
-        values: { connected: false },
-        text: ""
-      };
-    }
-    const agentName = state?.agentName || "The agent";
-    const sender = state?.data?.sender;
-    if (!sender) {
-      return {
-        data: { connected: true },
-        values: { connected: true },
-        text: ""
-      };
-    }
-    const userName = sender.name;
-    const displayName = getUserDisplayName(sender);
-    const userId = extractResourceId(userName);
-    const email = sender.email;
-    const userType = sender.type;
-    let responseText = `${agentName} is talking to ${displayName}`;
-    if (email) {
-      responseText += ` (${email})`;
-    }
-    responseText += " on Google Chat.";
-    if (userType === "BOT") {
-      responseText += " This user is a bot.";
-    }
-    return {
-      data: {
-        userName,
-        userId,
-        displayName,
-        email: email || undefined,
-        userType: userType || "HUMAN",
-        isBot: userType === "BOT"
-      },
-      values: {
-        userName,
-        userId,
-        displayName,
-        email: email || undefined
-      },
-      text: responseText
-    };
-  }
-};
-// src/service.ts
-import {
-  logger as logger2,
-  Service
-} from "@elizaos/core";
-import { GoogleAuth } from "google-auth-library";
-var CHAT_API_BASE = "https://chat.googleapis.com/v1";
-var CHAT_UPLOAD_BASE = "https://chat.googleapis.com/upload/v1";
-var CHAT_SCOPE = "https://www.googleapis.com/auth/chat.bot";
-
-class GoogleChatService extends Service {
-  static serviceType = GOOGLE_CHAT_SERVICE_NAME;
-  capabilityDescription = "Google Chat service for sending and receiving messages in Google Workspace";
-  settings = null;
-  auth = null;
-  connected = false;
-  cachedSpaces = [];
-  static async start(runtime) {
-    logger2.info("Starting Google Chat service...");
-    const service = new GoogleChatService(runtime);
-    service.settings = service.loadSettings();
-    service.validateSettings();
-    await service.initializeAuth();
-    await service.testConnection();
-    service.connected = true;
-    logger2.info("Google Chat service started successfully");
-    runtime.emitEvent("GOOGLE_CHAT_CONNECTION_READY" /* CONNECTION_READY */, {
-      runtime,
-      service
-    });
-    return service;
-  }
-  async stop() {
-    logger2.info("Stopping Google Chat service...");
-    this.connected = false;
-    this.auth = null;
-    logger2.info("Google Chat service stopped");
-  }
-  loadSettings() {
-    const runtime = this.runtime;
-    if (!runtime) {
-      throw new GoogleChatConfigurationError("Runtime not initialized");
-    }
-    const getStringSetting = (key, envKey, defaultValue = "") => {
-      const value = runtime.getSetting(key);
-      if (typeof value === "string")
-        return value;
-      return process.env[envKey] || defaultValue;
-    };
-    const serviceAccount = getStringSetting("GOOGLE_CHAT_SERVICE_ACCOUNT", "GOOGLE_CHAT_SERVICE_ACCOUNT");
-    const serviceAccountFile = getStringSetting("GOOGLE_CHAT_SERVICE_ACCOUNT_FILE", "GOOGLE_CHAT_SERVICE_ACCOUNT_FILE");
-    const audienceType = getStringSetting("GOOGLE_CHAT_AUDIENCE_TYPE", "GOOGLE_CHAT_AUDIENCE_TYPE", "app-url");
-    const audience = getStringSetting("GOOGLE_CHAT_AUDIENCE", "GOOGLE_CHAT_AUDIENCE");
-    const webhookPath = getStringSetting("GOOGLE_CHAT_WEBHOOK_PATH", "GOOGLE_CHAT_WEBHOOK_PATH", "/googlechat");
-    const spacesRaw = getStringSetting("GOOGLE_CHAT_SPACES", "GOOGLE_CHAT_SPACES");
-    const requireMention = getStringSetting("GOOGLE_CHAT_REQUIRE_MENTION", "GOOGLE_CHAT_REQUIRE_MENTION", "true");
-    const enabled = getStringSetting("GOOGLE_CHAT_ENABLED", "GOOGLE_CHAT_ENABLED", "true");
-    const botUser = getStringSetting("GOOGLE_CHAT_BOT_USER", "GOOGLE_CHAT_BOT_USER") || undefined;
-    return {
-      serviceAccount: serviceAccount || undefined,
-      serviceAccountFile: serviceAccountFile || undefined,
-      audienceType,
-      audience,
-      webhookPath: webhookPath.startsWith("/") ? webhookPath : `/${webhookPath}`,
-      spaces: spacesRaw ? spacesRaw.split(",").map((s) => s.trim()).filter(Boolean) : [],
-      requireMention: requireMention.toLowerCase() !== "false",
-      enabled: enabled.toLowerCase() !== "false",
-      botUser: botUser || undefined
-    };
-  }
-  validateSettings() {
-    const settings = this.settings;
-    if (!settings) {
-      throw new GoogleChatConfigurationError("Settings not loaded");
-    }
-    if (!settings.serviceAccount && !settings.serviceAccountFile) {
-      if (!process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-        throw new GoogleChatConfigurationError("Google Chat requires service account credentials. Set GOOGLE_CHAT_SERVICE_ACCOUNT, GOOGLE_CHAT_SERVICE_ACCOUNT_FILE, or GOOGLE_APPLICATION_CREDENTIALS.", "GOOGLE_CHAT_SERVICE_ACCOUNT");
-      }
-    }
-    if (!settings.audience) {
-      throw new GoogleChatConfigurationError("GOOGLE_CHAT_AUDIENCE is required for webhook verification", "GOOGLE_CHAT_AUDIENCE");
-    }
-    if (!["app-url", "project-number"].includes(settings.audienceType)) {
-      throw new GoogleChatConfigurationError("GOOGLE_CHAT_AUDIENCE_TYPE must be 'app-url' or 'project-number'", "GOOGLE_CHAT_AUDIENCE_TYPE");
-    }
-  }
-  async initializeAuth() {
-    const settings = this.settings;
-    if (!settings) {
-      throw new GoogleChatConfigurationError("Settings not loaded");
-    }
-    if (settings.serviceAccountFile) {
-      this.auth = new GoogleAuth({
-        keyFile: settings.serviceAccountFile,
-        scopes: [CHAT_SCOPE]
-      });
-    } else if (settings.serviceAccount) {
-      const credentials = JSON.parse(settings.serviceAccount);
-      this.auth = new GoogleAuth({
-        credentials,
-        scopes: [CHAT_SCOPE]
-      });
-    } else {
-      this.auth = new GoogleAuth({
-        scopes: [CHAT_SCOPE]
-      });
-    }
-    logger2.info("Google Auth initialized");
-  }
-  async testConnection() {
-    const token = await this.getAccessToken();
-    if (!token) {
-      throw new GoogleChatAuthenticationError("Failed to obtain access token");
-    }
-    const url = `${CHAT_API_BASE}/spaces?pageSize=1`;
-    const response = await fetch(url, {
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new GoogleChatApiError(`Failed to connect to Google Chat API: ${text || response.statusText}`, response.status);
-    }
-    logger2.info("Google Chat API connection verified");
-  }
-  isConnected() {
-    return this.connected;
-  }
-  getBotUser() {
-    return this.settings?.botUser;
-  }
-  async getAccessToken() {
-    if (!this.auth) {
-      throw new GoogleChatAuthenticationError("Auth not initialized");
-    }
-    const client = await this.auth.getClient();
-    const tokenResponse = await client.getAccessToken();
-    const token = typeof tokenResponse === "string" ? tokenResponse : tokenResponse?.token;
-    if (!token) {
-      throw new GoogleChatAuthenticationError("Failed to obtain access token");
-    }
-    return token;
-  }
-  async fetchApi(url, init = {}) {
-    const token = await this.getAccessToken();
-    const response = await fetch(url, {
-      ...init,
-      headers: {
-        ...init.headers,
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new GoogleChatApiError(`Google Chat API error: ${text || response.statusText}`, response.status);
-    }
-    return await response.json();
-  }
-  async getSpaces() {
-    const url = `${CHAT_API_BASE}/spaces`;
-    const response = await this.fetchApi(url);
-    this.cachedSpaces = response.spaces || [];
-    return this.cachedSpaces;
-  }
-  async sendMessage(options) {
-    if (!options.space) {
-      return {
-        success: false,
-        error: "Space is required"
-      };
-    }
-    const body = {};
-    if (options.text) {
-      body.text = options.text;
-    }
-    if (options.thread) {
-      body.thread = { name: options.thread };
-    }
-    if (options.attachments && options.attachments.length > 0) {
-      body.attachment = options.attachments.map((att) => ({
-        attachmentDataRef: { attachmentUploadToken: att.attachmentUploadToken },
-        ...att.contentName ? { contentName: att.contentName } : {}
-      }));
-    }
-    const url = `${CHAT_API_BASE}/${options.space}/messages`;
-    const result = await this.fetchApi(url, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
-    logger2.debug(`Message sent to ${options.space}: ${result.name}`);
-    if (this.runtime) {
-      this.runtime.emitEvent("GOOGLE_CHAT_MESSAGE_SENT" /* MESSAGE_SENT */, {
-        runtime: this.runtime,
-        messageName: result.name,
-        space: options.space
-      });
-    }
-    return {
-      success: true,
-      messageName: result.name,
-      space: options.space
-    };
-  }
-  async updateMessage(messageName, text) {
-    const url = `${CHAT_API_BASE}/${messageName}?updateMask=text`;
-    const result = await this.fetchApi(url, {
-      method: "PATCH",
-      body: JSON.stringify({ text })
-    });
-    return {
-      success: true,
-      messageName: result.name
-    };
-  }
-  async deleteMessage(messageName) {
-    const url = `${CHAT_API_BASE}/${messageName}`;
-    const token = await this.getAccessToken();
-    const response = await fetch(url, {
-      method: "DELETE",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      return {
-        success: false,
-        error: `Failed to delete message: ${text || response.statusText}`
-      };
-    }
-    return { success: true };
-  }
-  async sendReaction(messageName, emoji) {
-    const url = `${CHAT_API_BASE}/${messageName}/reactions`;
-    const result = await this.fetchApi(url, {
-      method: "POST",
-      body: JSON.stringify({ emoji: { unicode: emoji } })
-    });
-    if (this.runtime) {
-      this.runtime.emitEvent("GOOGLE_CHAT_REACTION_SENT" /* REACTION_SENT */, {
-        runtime: this.runtime,
-        messageName,
-        emoji,
-        reactionName: result.name
-      });
-    }
-    return {
-      success: true,
-      name: result.name
-    };
-  }
-  async deleteReaction(reactionName) {
-    const url = `${CHAT_API_BASE}/${reactionName}`;
-    const token = await this.getAccessToken();
-    const response = await fetch(url, {
-      method: "DELETE",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      return {
-        success: false,
-        error: `Failed to delete reaction: ${text || response.statusText}`
-      };
-    }
-    return { success: true };
-  }
-  async listReactions(messageName, limit) {
-    const url = new URL(`${CHAT_API_BASE}/${messageName}/reactions`);
-    if (limit && limit > 0) {
-      url.searchParams.set("pageSize", String(limit));
-    }
-    const result = await this.fetchApi(url.toString());
-    return result.reactions || [];
-  }
-  async findDirectMessage(userName) {
-    const url = new URL(`${CHAT_API_BASE}/spaces:findDirectMessage`);
-    url.searchParams.set("name", userName);
-    const result = await this.fetchApi(url.toString());
-    return result;
-  }
-  async uploadAttachment(space, filename, buffer, contentType) {
-    const boundary = `elizaos-${crypto.randomUUID()}`;
-    const metadata = JSON.stringify({ filename });
-    const header = `--${boundary}\r
-Content-Type: application/json; charset=UTF-8\r
-\r
-${metadata}\r
-`;
-    const mediaHeader = `--${boundary}\r
-Content-Type: ${contentType || "application/octet-stream"}\r
-\r
-`;
-    const footer = `\r
---${boundary}--\r
-`;
-    const body = Buffer.concat([
-      Buffer.from(header, "utf8"),
-      Buffer.from(mediaHeader, "utf8"),
-      buffer,
-      Buffer.from(footer, "utf8")
-    ]);
-    const token = await this.getAccessToken();
-    const url = `${CHAT_UPLOAD_BASE}/${space}/attachments:upload?uploadType=multipart`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": `multipart/related; boundary=${boundary}`
-      },
-      body
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new GoogleChatApiError(`Failed to upload attachment: ${text || response.statusText}`, response.status);
-    }
-    const payload = await response.json();
-    return {
-      attachmentUploadToken: payload.attachmentDataRef?.attachmentUploadToken
-    };
-  }
-  async downloadMedia(resourceName, maxBytes) {
-    const url = `${CHAT_API_BASE}/media/${resourceName}?alt=media`;
-    const token = await this.getAccessToken();
-    const response = await fetch(url, {
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new GoogleChatApiError(`Failed to download media: ${text || response.statusText}`, response.status);
-    }
-    const contentLength = response.headers.get("content-length");
-    if (maxBytes && contentLength) {
-      const length = Number(contentLength);
-      if (Number.isFinite(length) && length > maxBytes) {
-        throw new GoogleChatApiError(`Media exceeds max bytes (${maxBytes})`, 413);
-      }
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const buffer = Buffer.from(arrayBuffer);
-    const contentType = response.headers.get("content-type") || undefined;
-    return { buffer, contentType };
-  }
-  getSettings() {
-    return this.settings;
-  }
-  async processWebhookEvent(event) {
-    const eventType = event.type;
-    if (!this.runtime)
-      return;
-    if (eventType === "MESSAGE") {
-      this.runtime.emitEvent("GOOGLE_CHAT_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
-        runtime: this.runtime,
-        event,
-        message: event.message,
-        space: event.space,
-        user: event.user
-      });
-    } else if (eventType === "ADDED_TO_SPACE") {
-      this.runtime.emitEvent("GOOGLE_CHAT_SPACE_JOINED" /* SPACE_JOINED */, {
-        runtime: this.runtime,
-        space: event.space,
-        user: event.user
-      });
-    } else if (eventType === "REMOVED_FROM_SPACE") {
-      this.runtime.emitEvent("GOOGLE_CHAT_SPACE_LEFT" /* SPACE_LEFT */, {
-        runtime: this.runtime,
-        space: event.space,
-        user: event.user
-      });
-    }
-  }
-}
-// src/index.ts
-var googleChatPlugin = {
-  name: "google-chat",
-  description: "Google Chat integration plugin for ElizaOS agents",
-  services: [GoogleChatService],
-  actions: [sendMessage, sendReaction, listSpaces],
-  providers: [spaceStateProvider, userContextProvider],
-  tests: [],
-  init: async (config, _runtime) => {
-    logger3.info("Initializing Google Chat plugin...");
-    const serviceAccount = config.GOOGLE_CHAT_SERVICE_ACCOUNT || process.env.GOOGLE_CHAT_SERVICE_ACCOUNT;
-    const serviceAccountFile = config.GOOGLE_CHAT_SERVICE_ACCOUNT_FILE || process.env.GOOGLE_CHAT_SERVICE_ACCOUNT_FILE;
-    const hasCredentials = Boolean(serviceAccount || serviceAccountFile || process.env.GOOGLE_APPLICATION_CREDENTIALS);
-    logger3.info(`Google Chat plugin configuration:`);
-    logger3.info(`  - Credentials configured: ${hasCredentials ? "Yes" : "No"}`);
-    logger3.info(`  - Audience type: ${config.GOOGLE_CHAT_AUDIENCE_TYPE || process.env.GOOGLE_CHAT_AUDIENCE_TYPE || "(not set)"}`);
-    logger3.info(`  - Audience: ${config.GOOGLE_CHAT_AUDIENCE || process.env.GOOGLE_CHAT_AUDIENCE ? "(set)" : "(not set)"}`);
-    logger3.info(`  - Webhook path: ${config.GOOGLE_CHAT_WEBHOOK_PATH || process.env.GOOGLE_CHAT_WEBHOOK_PATH || "/googlechat"}`);
-    if (!hasCredentials) {
-      logger3.warn("Google Chat service account credentials not configured. " + "Set GOOGLE_CHAT_SERVICE_ACCOUNT, GOOGLE_CHAT_SERVICE_ACCOUNT_FILE, or GOOGLE_APPLICATION_CREDENTIALS.");
-    }
-    logger3.info("Google Chat plugin initialized");
-  }
-};
-var src_default = googleChatPlugin;
-export {
-  userContextProvider,
-  splitMessageForGoogleChat,
-  spaceStateProvider,
-  sendReaction,
-  sendMessage,
-  normalizeUserTarget,
-  normalizeSpaceTarget,
-  listSpaces,
-  isValidGoogleChatUserName,
-  isValidGoogleChatSpaceName,
-  isDirectMessage,
-  getUserDisplayName,
-  getSpaceDisplayName,
-  extractResourceId,
-  src_default as default,
-  MAX_GOOGLE_CHAT_MESSAGE_LENGTH,
-  GoogleChatService,
-  GoogleChatPluginError,
-  GoogleChatEventTypes,
-  GoogleChatConfigurationError,
-  GoogleChatAuthenticationError,
-  GoogleChatApiError,
-  GOOGLE_CHAT_SERVICE_NAME
-};
-
-//# debugId=636667934C16DD1564756E2164756E21