@elizaos/plugin-google-chat 2.0.0-beta.1 → 2.0.3-beta.3

package/dist/src/service.js

@@ -1,724 +0,0 @@
-/**
- * Google Chat service implementation for ElizaOS.
- */
-import { logger, Service, } from "@elizaos/core";
-import { GoogleAuth } from "google-auth-library";
-import { DEFAULT_GOOGLE_CHAT_ACCOUNT_ID, listGoogleChatAccountIds, normalizeGoogleChatAccountId, readGoogleChatAccountId, resolveDefaultGoogleChatAccountId, resolveGoogleChatAccountSettings, } from "./accounts.js";
-import { GOOGLE_CHAT_SERVICE_NAME, GoogleChatApiError, GoogleChatAuthenticationError, GoogleChatConfigurationError, GoogleChatEventTypes, getSpaceDisplayName, isDirectMessage, normalizeSpaceTarget, normalizeUserTarget, } from "./types.js";
-const CHAT_API_BASE = "https://chat.googleapis.com/v1";
-const CHAT_UPLOAD_BASE = "https://chat.googleapis.com/upload/v1";
-const CHAT_SCOPE = "https://www.googleapis.com/auth/chat.bot";
-function normalizeGoogleChatQuery(query) {
-    return query.trim().toLowerCase();
-}
-function scoreGoogleChatSpace(space, query) {
-    const normalized = normalizeGoogleChatQuery(query);
-    if (!normalized) {
-        return 0.45;
-    }
-    const candidates = [space.name, space.displayName, space.spaceType, space.type]
-        .filter((value) => typeof value === "string" && value.length > 0)
-        .map((value) => value.toLowerCase());
-    if (candidates.some((candidate) => candidate === normalized)) {
-        return 1;
-    }
-    return candidates.some((candidate) => candidate.includes(normalized)) ? 0.8 : 0;
-}
-function googleChatSpaceToConnectorTarget(space, score = 0.55, accountId = DEFAULT_GOOGLE_CHAT_ACCOUNT_ID) {
-    return {
-        target: {
-            source: GOOGLE_CHAT_SERVICE_NAME,
-            accountId,
-            channelId: space.name,
-        },
-        label: getSpaceDisplayName(space),
-        kind: isDirectMessage(space) ? "user" : "room",
-        description: space.threaded ? "Threaded Google Chat space" : "Google Chat space",
-        score,
-        contexts: ["social", "connectors"],
-        metadata: {
-            accountId,
-            spaceType: space.type,
-            singleUserBotDm: space.singleUserBotDm,
-            threaded: space.threaded,
-        },
-    };
-}
-function normalizeConnectorLimit(limit, fallback = 50) {
-    if (!Number.isFinite(limit) || !limit || limit <= 0) {
-        return fallback;
-    }
-    return Math.min(Math.floor(limit), 200);
-}
-async function readStoredMessageMemories(runtime, roomId, limit) {
-    return runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        limit,
-        orderBy: "createdAt",
-        orderDirection: "desc",
-    });
-}
-async function readStoredMessagesForTargets(runtime, targets, limit) {
-    const roomIds = Array.from(new Set(targets.map((target) => target.target.roomId).filter((id) => Boolean(id))));
-    const chunks = await Promise.all(roomIds.map((roomId) => readStoredMessageMemories(runtime, roomId, limit)));
-    return chunks
-        .flat()
-        .sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0))
-        .slice(0, limit);
-}
-function filterMemoriesByQuery(memories, query, limit) {
-    const normalized = query.trim().toLowerCase();
-    if (!normalized) {
-        return memories.slice(0, limit);
-    }
-    return memories
-        .filter((memory) => {
-        const text = typeof memory.content?.text === "string" ? memory.content.text : "";
-        return text.toLowerCase().includes(normalized);
-    })
-        .slice(0, limit);
-}
-function getMutationMessageName(params) {
-    const messageName = String(params.messageId ?? params.id ?? "").trim();
-    if (!messageName) {
-        throw new Error("Google Chat message operation requires messageId");
-    }
-    return messageName;
-}
-function googleChatOptionsFromContent(space, content, target) {
-    const data = content.data;
-    const googleChatData = (data?.googleChat && typeof data.googleChat === "object" ? data.googleChat : data);
-    return {
-        space,
-        text: typeof content.text === "string" ? content.text : undefined,
-        thread: target?.threadId ||
-            (typeof googleChatData?.thread === "string" ? googleChatData.thread : undefined),
-        attachments: Array.isArray(googleChatData?.attachments)
-            ? googleChatData.attachments
-            : undefined,
-    };
-}
-export class GoogleChatService extends Service {
-    static serviceType = GOOGLE_CHAT_SERVICE_NAME;
-    capabilityDescription = "Google Chat service for sending and receiving messages in Google Workspace";
-    states = new Map();
-    defaultAccountId = DEFAULT_GOOGLE_CHAT_ACCOUNT_ID;
-    static async start(runtime) {
-        logger.info("Starting Google Chat service...");
-        const service = new GoogleChatService(runtime);
-        service.defaultAccountId = normalizeGoogleChatAccountId(resolveDefaultGoogleChatAccountId(runtime));
-        for (const accountId of listGoogleChatAccountIds(runtime)) {
-            const settings = service.loadSettings(accountId);
-            if (settings.enabled === false) {
-                continue;
-            }
-            service.validateSettings(settings);
-            const state = {
-                accountId: normalizeGoogleChatAccountId(settings.accountId),
-                settings,
-                auth: service.createAuth(settings),
-                connected: false,
-                cachedSpaces: [],
-            };
-            await service.testConnection(state);
-            state.connected = true;
-            service.states.set(state.accountId, state);
-            GoogleChatService.registerSendHandlers(runtime, service, state.accountId);
-            runtime.emitEvent(GoogleChatEventTypes.CONNECTION_READY, {
-                runtime,
-                service,
-                accountId: state.accountId,
-            });
-        }
-        if (service.states.size === 0) {
-            const settings = service.loadSettings(service.defaultAccountId);
-            service.validateSettings(settings);
-        }
-        logger.info("Google Chat service started successfully");
-        return service;
-    }
-    static registerSendHandlers(runtime, service, accountId = service.getAccountId(runtime)) {
-        accountId = normalizeGoogleChatAccountId(accountId);
-        const sendHandler = async (handlerRuntime, target, content) => {
-            await service.handleSendMessage(handlerRuntime, target, content);
-            return undefined;
-        };
-        if (typeof runtime.registerMessageConnector === "function") {
-            const registration = {
-                source: GOOGLE_CHAT_SERVICE_NAME,
-                accountId,
-                label: "Google Chat",
-                capabilities: [
-                    "send_message",
-                    "send_thread_reply",
-                    "send_attachment",
-                    "send_reaction",
-                    "list_spaces",
-                    "direct_message",
-                ],
-                supportedTargetKinds: ["room", "channel", "thread", "user"],
-                contexts: ["social", "connectors"],
-                description: "Send Google Chat messages to spaces, threaded conversations, and direct-message spaces.",
-                metadata: {
-                    accountId,
-                    service: GOOGLE_CHAT_SERVICE_NAME,
-                },
-                sendHandler,
-                resolveTargets: async (query) => {
-                    const directUser = normalizeUserTarget(query);
-                    const directTarget = directUser
-                        ? [
-                            {
-                                target: {
-                                    source: GOOGLE_CHAT_SERVICE_NAME,
-                                    accountId,
-                                    channelId: directUser,
-                                },
-                                label: directUser,
-                                kind: "user",
-                                score: 0.95,
-                                contexts: ["social", "connectors"],
-                                metadata: { accountId },
-                            },
-                        ]
-                        : [];
-                    const spaces = await service.listConnectorSpaces(accountId);
-                    const spaceTargets = spaces
-                        .map((space) => ({ space, score: scoreGoogleChatSpace(space, query) }))
-                        .filter(({ score }) => score > 0)
-                        .map(({ space, score }) => googleChatSpaceToConnectorTarget(space, score, accountId));
-                    return [...directTarget, ...spaceTargets]
-                        .sort((left, right) => (right.score ?? 0) - (left.score ?? 0))
-                        .slice(0, 10);
-                },
-                listRecentTargets: async () => (await service.listConnectorSpaces(accountId))
-                    .slice(0, 10)
-                    .map((space) => googleChatSpaceToConnectorTarget(space, 0.55, accountId)),
-                listRooms: async () => (await service.listConnectorSpaces(accountId)).map((space) => googleChatSpaceToConnectorTarget(space, 0.55, accountId)),
-                fetchMessages: async (context, params) => {
-                    const limit = normalizeConnectorLimit(params?.limit);
-                    const target = params?.target ?? context.target;
-                    if (target?.roomId) {
-                        return readStoredMessageMemories(context.runtime, target.roomId, limit);
-                    }
-                    const targets = (await service.listConnectorSpaces(accountId))
-                        .slice(0, 10)
-                        .map((space) => googleChatSpaceToConnectorTarget(space, 0.55, accountId));
-                    return readStoredMessagesForTargets(context.runtime, targets, limit);
-                },
-                searchMessages: async (context, params) => {
-                    const limit = normalizeConnectorLimit(params?.limit);
-                    const target = params?.target ?? context.target;
-                    const messages = target?.roomId
-                        ? await readStoredMessageMemories(context.runtime, target.roomId, Math.max(limit, 100))
-                        : await readStoredMessagesForTargets(context.runtime, (await service.listConnectorSpaces(accountId))
-                            .slice(0, 10)
-                            .map((space) => googleChatSpaceToConnectorTarget(space, 0.55, accountId)), Math.max(limit, 100));
-                    return filterMemoriesByQuery(messages, params.query, limit);
-                },
-                reactHandler: async (_handlerRuntime, params) => {
-                    const messageName = getMutationMessageName(params);
-                    const emoji = String(params.emoji ?? "").trim();
-                    if (!emoji) {
-                        throw new Error("Google Chat reactHandler requires emoji");
-                    }
-                    const result = await service.sendReaction(messageName, emoji, accountId);
-                    if (!result.success) {
-                        throw new Error(result.error || "Google Chat reaction failed");
-                    }
-                },
-                editHandler: async (_handlerRuntime, params) => {
-                    const messageName = getMutationMessageName(params);
-                    const mutationParams = params;
-                    const text = String(mutationParams.text ?? params.content?.text ?? "").trim();
-                    if (!text) {
-                        throw new Error("Google Chat editHandler requires text content");
-                    }
-                    const result = await service.updateMessage(messageName, text, accountId);
-                    if (!result.success) {
-                        throw new Error(result.error || "Google Chat message edit failed");
-                    }
-                },
-                deleteHandler: async (_handlerRuntime, params) => {
-                    const messageName = getMutationMessageName(params);
-                    const result = await service.deleteMessage(messageName, accountId);
-                    if (!result.success) {
-                        throw new Error(result.error || "Google Chat message delete failed");
-                    }
-                },
-                getChatContext: async (target, context) => {
-                    const room = target.roomId ? await context.runtime.getRoom(target.roomId) : null;
-                    const channelId = String(target.channelId ?? room?.channelId ?? "").trim();
-                    const spaceName = normalizeSpaceTarget(channelId);
-                    if (!spaceName) {
-                        return null;
-                    }
-                    const space = (await service.listConnectorSpaces(accountId)).find((candidate) => candidate.name === spaceName);
-                    if (!space) {
-                        return null;
-                    }
-                    return {
-                        target: {
-                            source: GOOGLE_CHAT_SERVICE_NAME,
-                            accountId,
-                            roomId: target.roomId,
-                            channelId: space.name,
-                            threadId: target.threadId,
-                        },
-                        label: getSpaceDisplayName(space),
-                        summary: isDirectMessage(space) ? "Google Chat direct message" : "Google Chat space",
-                        metadata: {
-                            accountId,
-                            spaceType: space.type,
-                            threaded: space.threaded,
-                            singleUserBotDm: space.singleUserBotDm,
-                        },
-                    };
-                },
-                getUserContext: async (entityId, context) => {
-                    const entity = typeof context.runtime.getEntityById === "function"
-                        ? await context.runtime.getEntityById(String(entityId))
-                        : null;
-                    if (!entity) {
-                        return null;
-                    }
-                    return {
-                        entityId,
-                        label: entity.names?.[0],
-                        aliases: entity.names,
-                        handles: {},
-                        metadata: entity.metadata,
-                    };
-                },
-            };
-            runtime.registerMessageConnector(registration);
-            return;
-        }
-        runtime.registerSendHandler(GOOGLE_CHAT_SERVICE_NAME, sendHandler);
-    }
-    async stop() {
-        logger.info("Stopping Google Chat service...");
-        for (const state of this.states.values()) {
-            state.connected = false;
-        }
-        logger.info("Google Chat service stopped");
-    }
-    loadSettings(accountId) {
-        const runtime = this.runtime;
-        if (!runtime) {
-            throw new GoogleChatConfigurationError("Runtime not initialized");
-        }
-        return resolveGoogleChatAccountSettings(runtime, accountId);
-    }
-    validateSettings(settings) {
-        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");
-        }
-    }
-    createAuth(settings) {
-        if (settings.serviceAccountFile) {
-            return new GoogleAuth({
-                keyFile: settings.serviceAccountFile,
-                scopes: [CHAT_SCOPE],
-            });
-        }
-        if (settings.serviceAccount) {
-            const credentials = JSON.parse(settings.serviceAccount);
-            return new GoogleAuth({
-                credentials,
-                scopes: [CHAT_SCOPE],
-            });
-        }
-        return new GoogleAuth({
-            scopes: [CHAT_SCOPE],
-        });
-    }
-    async testConnection(state = this.getState()) {
-        const token = await this.getAccessToken(state.accountId);
-        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);
-        }
-        logger.info("Google Chat API connection verified");
-    }
-    isConnected() {
-        const legacy = this;
-        const states = this.states ?? new Map();
-        if (states.size === 0 && typeof legacy.connected === "boolean") {
-            return legacy.connected;
-        }
-        return Array.from(states.values()).some((state) => state.connected);
-    }
-    getAccountId(runtime) {
-        const legacy = this;
-        const states = this.states ?? new Map();
-        if (states.size === 0 && legacy.settings?.accountId) {
-            return normalizeGoogleChatAccountId(legacy.settings.accountId);
-        }
-        return normalizeGoogleChatAccountId(this.defaultAccountId !== DEFAULT_GOOGLE_CHAT_ACCOUNT_ID
-            ? this.defaultAccountId
-            : runtime
-                ? resolveDefaultGoogleChatAccountId(runtime)
-                : this.defaultAccountId);
-    }
-    getBotUser() {
-        return this.getState().settings.botUser;
-    }
-    async getAccessToken(accountId) {
-        const state = this.getState(accountId);
-        const client = await state.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 = {}, accountId) {
-        const token = await this.getAccessToken(accountId);
-        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(accountId) {
-        const state = this.getState(accountId);
-        const url = `${CHAT_API_BASE}/spaces`;
-        const response = await this.fetchApi(url, {}, state.accountId);
-        state.cachedSpaces = response.spaces || [];
-        return state.cachedSpaces;
-    }
-    async sendMessage(options) {
-        const state = this.getState(options.accountId);
-        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),
-        }, state.accountId);
-        logger.debug(`Message sent to ${options.space}: ${result.name}`);
-        if (this.runtime) {
-            this.runtime.emitEvent(GoogleChatEventTypes.MESSAGE_SENT, {
-                runtime: this.runtime,
-                accountId: state.accountId,
-                messageName: result.name,
-                space: options.space,
-            });
-        }
-        return {
-            success: true,
-            messageName: result.name,
-            space: options.space,
-        };
-    }
-    async updateMessage(messageName, text, accountId) {
-        const url = `${CHAT_API_BASE}/${messageName}?updateMask=text`;
-        const result = await this.fetchApi(url, {
-            method: "PATCH",
-            body: JSON.stringify({ text }),
-        }, accountId);
-        return {
-            success: true,
-            messageName: result.name,
-        };
-    }
-    async deleteMessage(messageName, accountId) {
-        const url = `${CHAT_API_BASE}/${messageName}`;
-        const token = await this.getAccessToken(accountId);
-        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, accountId) {
-        const state = this.getState(accountId);
-        const url = `${CHAT_API_BASE}/${messageName}/reactions`;
-        const result = await this.fetchApi(url, {
-            method: "POST",
-            body: JSON.stringify({ emoji: { unicode: emoji } }),
-        }, state.accountId);
-        if (this.runtime) {
-            this.runtime.emitEvent(GoogleChatEventTypes.REACTION_SENT, {
-                runtime: this.runtime,
-                accountId: state.accountId,
-                messageName,
-                emoji,
-                reactionName: result.name,
-            });
-        }
-        return {
-            success: true,
-            name: result.name,
-        };
-    }
-    async deleteReaction(reactionName, accountId) {
-        const url = `${CHAT_API_BASE}/${reactionName}`;
-        const token = await this.getAccessToken(accountId);
-        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, accountId) {
-        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(), {}, accountId);
-        return result.reactions || [];
-    }
-    async findDirectMessage(userName, accountId) {
-        const url = new URL(`${CHAT_API_BASE}/spaces:findDirectMessage`);
-        url.searchParams.set("name", userName);
-        const result = await this.fetchApi(url.toString(), {}, accountId);
-        return result;
-    }
-    async uploadAttachment(space, filename, buffer, contentType, accountId) {
-        const boundary = `elizaos-${crypto.randomUUID()}`;
-        const metadata = JSON.stringify({ filename });
-        const header = `--${boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n${metadata}\r\n`;
-        const mediaHeader = `--${boundary}\r\nContent-Type: ${contentType || "application/octet-stream"}\r\n\r\n`;
-        const footer = `\r\n--${boundary}--\r\n`;
-        const body = Buffer.concat([
-            Buffer.from(header, "utf8"),
-            Buffer.from(mediaHeader, "utf8"),
-            buffer,
-            Buffer.from(footer, "utf8"),
-        ]);
-        const token = await this.getAccessToken(accountId);
-        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, accountId) {
-        const url = `${CHAT_API_BASE}/media/${resourceName}?alt=media`;
-        const token = await this.getAccessToken(accountId);
-        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() {
-        try {
-            return this.getState().settings;
-        }
-        catch {
-            return null;
-        }
-    }
-    async sendDirectMessage(target, content) {
-        const accountId = readGoogleChatAccountId(content) ?? this.getAccountId();
-        const userName = normalizeUserTarget(target);
-        if (!userName) {
-            throw new Error(`Invalid Google Chat user target: ${target}`);
-        }
-        const space = await this.findDirectMessage(userName, accountId);
-        if (!space?.name) {
-            throw new Error(`Could not resolve Google Chat direct message for ${target}`);
-        }
-        await this.sendConnectorContent(space.name, content, undefined, accountId);
-    }
-    async sendRoomMessage(target, content) {
-        const accountId = readGoogleChatAccountId(content) ?? this.getAccountId();
-        const spaceName = normalizeSpaceTarget(target);
-        if (!spaceName) {
-            throw new Error(`Invalid Google Chat space target: ${target}`);
-        }
-        await this.sendConnectorContent(spaceName, content, undefined, accountId);
-    }
-    async handleSendMessage(runtime, target, content) {
-        const requestedAccountId = normalizeGoogleChatAccountId(target.accountId ?? readGoogleChatAccountId(content, target) ?? this.getAccountId());
-        this.getState(requestedAccountId);
-        const room = target.roomId ? await runtime.getRoom(target.roomId) : null;
-        const channelId = String(target.channelId ?? room?.channelId ?? "").trim();
-        if (!channelId) {
-            throw new Error("Google Chat target is missing a space or user resource name");
-        }
-        const userName = normalizeUserTarget(channelId);
-        if (userName && !channelId.startsWith("spaces/")) {
-            await this.sendConnectorDirectMessage(userName, content, requestedAccountId);
-            return;
-        }
-        const spaceName = normalizeSpaceTarget(channelId);
-        if (!spaceName) {
-            throw new Error(`Invalid Google Chat target: ${channelId}`);
-        }
-        await this.sendConnectorContent(spaceName, content, target, requestedAccountId);
-    }
-    async sendConnectorDirectMessage(userName, content, accountId) {
-        const space = await this.findDirectMessage(userName, accountId);
-        if (!space?.name) {
-            throw new Error(`Could not resolve Google Chat direct message for ${userName}`);
-        }
-        await this.sendConnectorContent(space.name, content, undefined, accountId);
-    }
-    async sendConnectorContent(space, content, target, accountId) {
-        const text = typeof content.text === "string" ? content.text.trim() : "";
-        const options = googleChatOptionsFromContent(space, { ...content, text }, target);
-        if (!options.text && (!options.attachments || options.attachments.length === 0)) {
-            return;
-        }
-        const result = await this.sendMessage({ ...options, accountId });
-        if (!result.success) {
-            throw new Error(result.error || "Google Chat message send failed");
-        }
-    }
-    async listConnectorSpaces(accountId) {
-        const state = this.getState(accountId);
-        try {
-            return await this.getSpaces(state.accountId);
-        }
-        catch {
-            return [...state.cachedSpaces];
-        }
-    }
-    async processWebhookEvent(event, accountId) {
-        const eventType = event.type;
-        const resolvedAccountId = normalizeGoogleChatAccountId(accountId ?? readGoogleChatAccountId(event) ?? this.getAccountId());
-        this.getState(resolvedAccountId);
-        if (!this.runtime)
-            return;
-        if (eventType === "MESSAGE") {
-            this.runtime.emitEvent(GoogleChatEventTypes.MESSAGE_RECEIVED, {
-                runtime: this.runtime,
-                accountId: resolvedAccountId,
-                event,
-                message: event.message,
-                space: event.space,
-                user: event.user,
-            });
-        }
-        else if (eventType === "ADDED_TO_SPACE") {
-            this.runtime.emitEvent(GoogleChatEventTypes.SPACE_JOINED, {
-                runtime: this.runtime,
-                accountId: resolvedAccountId,
-                space: event.space,
-                user: event.user,
-            });
-        }
-        else if (eventType === "REMOVED_FROM_SPACE") {
-            this.runtime.emitEvent(GoogleChatEventTypes.SPACE_LEFT, {
-                runtime: this.runtime,
-                accountId: resolvedAccountId,
-                space: event.space,
-                user: event.user,
-            });
-        }
-    }
-    getState(accountId = this.defaultAccountId) {
-        const normalized = normalizeGoogleChatAccountId(accountId);
-        const states = this.states ?? new Map();
-        const state = states.get(normalized);
-        if (state) {
-            return state;
-        }
-        const legacy = this;
-        if (legacy.settings) {
-            return {
-                accountId: normalizeGoogleChatAccountId(legacy.settings.accountId ?? normalized),
-                settings: legacy.settings,
-                auth: legacy.auth ?? this.createAuth(legacy.settings),
-                connected: legacy.connected ?? true,
-                cachedSpaces: legacy.cachedSpaces ?? [],
-            };
-        }
-        throw new Error(`Google Chat account '${normalized}' is not available in this service instance`);
-    }
-}
-//# sourceMappingURL=service.js.map