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

package/dist/index.js

@@ -1,981 +0,0 @@
-// src/index.ts
-import { getConnectorAccountManager, logger as logger2 } from "@elizaos/core";
-
-// src/accounts.ts
-var DEFAULT_MATRIX_ACCOUNT_ID = "default";
-function stringSetting(runtime, key) {
-  const value = runtime.getSetting(key);
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function characterConfig(runtime) {
-  const settings = runtime.character?.settings;
-  const raw = settings?.matrix;
-  return raw && typeof raw === "object" ? raw : {};
-}
-function parseAccountsJson(runtime) {
-  const raw = stringSetting(runtime, "MATRIX_ACCOUNTS");
-  if (!raw)
-    return {};
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed)) {
-      return Object.fromEntries(parsed.filter((item) => Boolean(item) && typeof item === "object").map((item) => [normalizeMatrixAccountId(item.accountId ?? item.id), item]));
-    }
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function allAccountConfigs(runtime) {
-  return {
-    ...characterConfig(runtime).accounts ?? {},
-    ...parseAccountsJson(runtime)
-  };
-}
-function accountConfig(runtime, accountId) {
-  const accounts = allAccountConfigs(runtime);
-  return accounts[accountId] ?? accounts[normalizeMatrixAccountId(accountId)] ?? {};
-}
-function boolValue(value, fallback = false) {
-  if (typeof value === "boolean")
-    return value;
-  if (typeof value === "string")
-    return value.trim().toLowerCase() === "true";
-  return fallback;
-}
-function roomsValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((room) => String(room).trim()).filter(Boolean);
-  }
-  if (typeof value === "string") {
-    return value.split(",").map((room) => room.trim()).filter(Boolean);
-  }
-  return [];
-}
-function normalizeMatrixAccountId(accountId) {
-  if (typeof accountId !== "string")
-    return DEFAULT_MATRIX_ACCOUNT_ID;
-  const trimmed = accountId.trim();
-  return trimmed || DEFAULT_MATRIX_ACCOUNT_ID;
-}
-function listMatrixAccountIds(runtime) {
-  const ids = new Set;
-  const config = characterConfig(runtime);
-  if (stringSetting(runtime, "MATRIX_ACCESS_TOKEN") || config.homeserver && config.userId && config.accessToken) {
-    ids.add(DEFAULT_MATRIX_ACCOUNT_ID);
-  }
-  for (const id of Object.keys(allAccountConfigs(runtime))) {
-    ids.add(normalizeMatrixAccountId(id));
-  }
-  return Array.from(ids.size ? ids : new Set([DEFAULT_MATRIX_ACCOUNT_ID])).sort((a, b) => a.localeCompare(b));
-}
-function resolveDefaultMatrixAccountId(runtime) {
-  const requested = stringSetting(runtime, "MATRIX_DEFAULT_ACCOUNT_ID") ?? stringSetting(runtime, "MATRIX_ACCOUNT_ID");
-  if (requested)
-    return normalizeMatrixAccountId(requested);
-  const ids = listMatrixAccountIds(runtime);
-  return ids.includes(DEFAULT_MATRIX_ACCOUNT_ID) ? DEFAULT_MATRIX_ACCOUNT_ID : ids[0];
-}
-function readMatrixAccountId(...sources) {
-  for (const source of sources) {
-    if (!source || typeof source !== "object")
-      continue;
-    const record = source;
-    const parameters = record.parameters && typeof record.parameters === "object" ? record.parameters : {};
-    const data = record.data && typeof record.data === "object" ? record.data : {};
-    const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
-    const matrix = data.matrix && typeof data.matrix === "object" ? data.matrix : {};
-    const value = record.accountId ?? parameters.accountId ?? data.accountId ?? matrix.accountId ?? metadata.accountId;
-    if (typeof value === "string" && value.trim())
-      return normalizeMatrixAccountId(value);
-  }
-  return;
-}
-function resolveMatrixAccountSettings(runtime, requestedAccountId) {
-  const accountId = normalizeMatrixAccountId(requestedAccountId ?? resolveDefaultMatrixAccountId(runtime));
-  const base = characterConfig(runtime);
-  const account = accountConfig(runtime, accountId);
-  const allowEnv = accountId === DEFAULT_MATRIX_ACCOUNT_ID;
-  return {
-    accountId,
-    homeserver: account.homeserver ?? base.homeserver ?? (allowEnv ? stringSetting(runtime, "MATRIX_HOMESERVER") : undefined) ?? "",
-    userId: account.userId ?? base.userId ?? (allowEnv ? stringSetting(runtime, "MATRIX_USER_ID") : undefined) ?? "",
-    accessToken: account.accessToken ?? base.accessToken ?? (allowEnv ? stringSetting(runtime, "MATRIX_ACCESS_TOKEN") : undefined) ?? "",
-    deviceId: account.deviceId ?? base.deviceId ?? (allowEnv ? stringSetting(runtime, "MATRIX_DEVICE_ID") : undefined),
-    rooms: roomsValue(account.rooms ?? base.rooms ?? (allowEnv ? stringSetting(runtime, "MATRIX_ROOMS") : undefined)),
-    autoJoin: boolValue(account.autoJoin ?? base.autoJoin ?? (allowEnv ? stringSetting(runtime, "MATRIX_AUTO_JOIN") : undefined)),
-    encryption: boolValue(account.encryption ?? base.encryption ?? (allowEnv ? stringSetting(runtime, "MATRIX_ENCRYPTION") : undefined)),
-    requireMention: boolValue(account.requireMention ?? base.requireMention ?? (allowEnv ? stringSetting(runtime, "MATRIX_REQUIRE_MENTION") : undefined)),
-    enabled: boolValue(account.enabled ?? base.enabled, true)
-  };
-}
-// src/service.ts
-import {
-  logger,
-  Service
-} from "@elizaos/core";
-import * as sdk from "matrix-js-sdk";
-
-// src/types.ts
-var MAX_MATRIX_MESSAGE_LENGTH = 4000;
-var MATRIX_SERVICE_NAME = "matrix";
-var MatrixEventTypes;
-((MatrixEventTypes2) => {
-  MatrixEventTypes2["MESSAGE_RECEIVED"] = "MATRIX_MESSAGE_RECEIVED";
-  MatrixEventTypes2["MESSAGE_SENT"] = "MATRIX_MESSAGE_SENT";
-  MatrixEventTypes2["ROOM_JOINED"] = "MATRIX_ROOM_JOINED";
-  MatrixEventTypes2["ROOM_LEFT"] = "MATRIX_ROOM_LEFT";
-  MatrixEventTypes2["INVITE_RECEIVED"] = "MATRIX_INVITE_RECEIVED";
-  MatrixEventTypes2["REACTION_RECEIVED"] = "MATRIX_REACTION_RECEIVED";
-  MatrixEventTypes2["TYPING_RECEIVED"] = "MATRIX_TYPING_RECEIVED";
-  MatrixEventTypes2["SYNC_COMPLETE"] = "MATRIX_SYNC_COMPLETE";
-  MatrixEventTypes2["CONNECTION_READY"] = "MATRIX_CONNECTION_READY";
-  MatrixEventTypes2["CONNECTION_LOST"] = "MATRIX_CONNECTION_LOST";
-})(MatrixEventTypes ||= {});
-function isValidMatrixUserId(userId) {
-  return /^@[^:]+:.+$/.test(userId);
-}
-function isValidMatrixRoomId(roomId) {
-  return /^![^:]+:.+$/.test(roomId);
-}
-function isValidMatrixRoomAlias(alias) {
-  return /^#[^:]+:.+$/.test(alias);
-}
-function getMatrixLocalpart(matrixId) {
-  const match = matrixId.match(/^[@#!]([^:]+):/);
-  return match ? match[1] : matrixId;
-}
-function getMatrixServerpart(matrixId) {
-  const match = matrixId.match(/:(.+)$/);
-  return match ? match[1] : "";
-}
-function getMatrixUserDisplayName(user) {
-  return user.displayName || getMatrixLocalpart(user.userId);
-}
-function matrixMxcToHttp(mxcUrl, homeserver) {
-  if (!mxcUrl.startsWith("mxc://")) {
-    return;
-  }
-  const [serverName, mediaId] = mxcUrl.slice(6).split("/");
-  if (!serverName || !mediaId) {
-    return;
-  }
-  const base = homeserver.replace(/\/$/, "");
-  return `${base}/_matrix/media/v3/download/${serverName}/${mediaId}`;
-}
-
-class MatrixPluginError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MatrixPluginError";
-  }
-}
-
-class MatrixServiceNotInitializedError extends MatrixPluginError {
-  constructor(message = "Matrix service is not initialized") {
-    super(message);
-    this.name = "MatrixServiceNotInitializedError";
-  }
-}
-
-class MatrixNotConnectedError extends MatrixPluginError {
-  constructor(message = "Matrix client is not connected") {
-    super(message);
-    this.name = "MatrixNotConnectedError";
-  }
-}
-
-class MatrixConfigurationError extends MatrixPluginError {
-  settingName;
-  constructor(message, settingName) {
-    super(message);
-    this.name = "MatrixConfigurationError";
-    this.settingName = settingName;
-  }
-}
-
-class MatrixApiError extends MatrixPluginError {
-  errcode;
-  constructor(message, errcode) {
-    super(message);
-    this.name = "MatrixApiError";
-    this.errcode = errcode;
-  }
-}
-
-// src/service.ts
-function normalizeSearchQuery(query) {
-  return query.trim().toLowerCase();
-}
-function matrixRoomSearchText(room) {
-  return [room.roomId, room.name, room.topic, room.canonicalAlias].filter((value) => typeof value === "string" && value.length > 0).join(" ").toLowerCase();
-}
-function scoreMatrixRoom(room, query) {
-  const normalized = normalizeSearchQuery(query);
-  if (!normalized) {
-    return 0.4;
-  }
-  const candidates = [room.roomId, room.canonicalAlias, room.name].filter((value) => typeof value === "string" && value.length > 0);
-  if (candidates.some((candidate) => candidate.toLowerCase() === normalized)) {
-    return 1;
-  }
-  if (candidates.some((candidate) => candidate.toLowerCase().includes(normalized))) {
-    return 0.85;
-  }
-  return matrixRoomSearchText(room).includes(normalized) ? 0.65 : 0;
-}
-function matrixRoomToConnectorTarget(room, score = 0.5, accountId = DEFAULT_MATRIX_ACCOUNT_ID) {
-  const label = room.name || room.canonicalAlias || room.roomId;
-  return {
-    target: {
-      source: MATRIX_SERVICE_NAME,
-      accountId,
-      channelId: room.roomId
-    },
-    label,
-    kind: room.isDirect ? "user" : "room",
-    description: room.topic || `${room.memberCount} Matrix member${room.memberCount === 1 ? "" : "s"}`,
-    score,
-    contexts: ["social", "connectors"],
-    metadata: {
-      accountId,
-      roomId: room.roomId,
-      canonicalAlias: room.canonicalAlias,
-      isEncrypted: room.isEncrypted,
-      isDirect: room.isDirect,
-      memberCount: room.memberCount
-    }
-  };
-}
-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 extractMatrixSendOptions(content, target) {
-  const data = content.data;
-  const matrixData = data?.matrix && typeof data.matrix === "object" ? data.matrix : data;
-  return {
-    threadId: target.threadId || (typeof matrixData?.threadId === "string" ? matrixData.threadId : undefined),
-    replyTo: typeof matrixData?.replyTo === "string" ? matrixData.replyTo : undefined,
-    formatted: matrixData?.formatted === true
-  };
-}
-
-class MatrixService extends Service {
-  static serviceType = MATRIX_SERVICE_NAME;
-  capabilityDescription = "Matrix messaging service for chat communication";
-  states = new Map;
-  defaultAccountId = DEFAULT_MATRIX_ACCOUNT_ID;
-  static async start(runtime) {
-    const service = new MatrixService;
-    await service.initialize(runtime);
-    return service;
-  }
-  static async stopRuntime(runtime) {
-    const service = runtime.getService(MATRIX_SERVICE_NAME);
-    if (service) {
-      await service.stop();
-    }
-  }
-  static registerSendHandlers(runtime, service, accountId = service.getAccountId(runtime)) {
-    accountId = normalizeMatrixAccountId(accountId);
-    const sendHandler = async (handlerRuntime, target, content) => {
-      await service.handleSendMessage(handlerRuntime, target, content);
-      return;
-    };
-    if (typeof runtime.registerMessageConnector === "function") {
-      const registration = {
-        source: MATRIX_SERVICE_NAME,
-        accountId,
-        label: "Matrix",
-        capabilities: [
-          "send_message",
-          "send_thread_reply",
-          "send_formatted_message",
-          "react_to_message",
-          "list_rooms",
-          "join_room"
-        ],
-        supportedTargetKinds: ["room", "channel", "thread", "user"],
-        contexts: ["social", "connectors"],
-        description: "Send messages to joined Matrix rooms, aliases, encrypted rooms, and known direct-message rooms.",
-        metadata: {
-          accountId,
-          service: MATRIX_SERVICE_NAME
-        },
-        sendHandler,
-        resolveTargets: async (query) => {
-          const rooms = await service.getJoinedRooms(accountId);
-          return rooms.map((room) => ({ room, score: scoreMatrixRoom(room, query) })).filter(({ score }) => score > 0).sort((left, right) => right.score - left.score).slice(0, 10).map(({ room, score }) => matrixRoomToConnectorTarget(room, score, accountId));
-        },
-        listRecentTargets: async () => (await service.getJoinedRooms(accountId)).slice(0, 10).map((room) => matrixRoomToConnectorTarget(room, 0.5, accountId)),
-        listRooms: async () => (await service.getJoinedRooms(accountId)).map((room) => matrixRoomToConnectorTarget(room, 0.5, 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.getJoinedRooms(accountId)).slice(0, 10).map((room) => matrixRoomToConnectorTarget(room, 0.5, 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.getJoinedRooms(accountId)).slice(0, 10).map((room) => matrixRoomToConnectorTarget(room, 0.5, accountId)), Math.max(limit, 100));
-          return filterMemoriesByQuery(messages, params.query, limit);
-        },
-        reactHandler: async (handlerRuntime, params) => {
-          const target = params.target ?? { source: MATRIX_SERVICE_NAME };
-          const room = target.roomId ? await handlerRuntime.getRoom(target.roomId) : null;
-          const roomId = String(target.channelId ?? room?.channelId ?? "").trim();
-          const mutationParams = params;
-          const eventId = String(mutationParams.eventId ?? params.messageId ?? "").trim();
-          const emoji = String(params.emoji ?? "").trim();
-          if (!roomId || !eventId || !emoji) {
-            throw new Error("Matrix reactHandler requires room, event id, and emoji");
-          }
-          const result = await service.sendReaction(roomId, eventId, emoji, accountId);
-          if (!result.success) {
-            throw new Error(result.error || "Matrix reaction failed");
-          }
-        },
-        joinHandler: async (_handlerRuntime, params) => {
-          const membershipParams = params;
-          const roomIdOrAlias = String(membershipParams.roomIdOrAlias ?? params.alias ?? params.invite ?? params.channelId ?? params.roomId ?? "").trim();
-          if (!roomIdOrAlias) {
-            throw new Error("Matrix joinHandler requires a room ID or alias");
-          }
-          await service.joinRoom(roomIdOrAlias, accountId);
-        },
-        leaveHandler: async (handlerRuntime, params) => {
-          const target = params.target ?? { source: MATRIX_SERVICE_NAME };
-          const room = target.roomId ? await handlerRuntime.getRoom(target.roomId) : null;
-          const roomId = String(params?.roomId ?? params?.channelId ?? target.channelId ?? room?.channelId ?? "");
-          if (!roomId) {
-            throw new Error("Matrix leaveHandler requires a room ID");
-          }
-          await service.leaveRoom(roomId, accountId);
-        },
-        getChatContext: async (target, context) => {
-          const room = target.roomId ? await context.runtime.getRoom(target.roomId) : null;
-          const channelId = String(target.channelId ?? room?.channelId ?? "").trim();
-          const joinedRoom = (await service.getJoinedRooms(accountId)).find((candidate) => candidate.roomId === channelId || candidate.canonicalAlias === channelId);
-          if (!joinedRoom) {
-            return null;
-          }
-          return {
-            target: {
-              source: MATRIX_SERVICE_NAME,
-              accountId,
-              channelId: joinedRoom.roomId,
-              roomId: target.roomId
-            },
-            label: joinedRoom.name || joinedRoom.canonicalAlias || joinedRoom.roomId,
-            summary: joinedRoom.topic,
-            metadata: {
-              accountId,
-              roomId: joinedRoom.roomId,
-              canonicalAlias: joinedRoom.canonicalAlias,
-              isEncrypted: joinedRoom.isEncrypted,
-              isDirect: joinedRoom.isDirect,
-              memberCount: joinedRoom.memberCount
-            }
-          };
-        },
-        getUserContext: async (entityId, context) => {
-          if (typeof context.runtime.getEntityById !== "function") {
-            return null;
-          }
-          const entity = await context.runtime.getEntityById(String(entityId));
-          if (!entity) {
-            return null;
-          }
-          return {
-            entityId,
-            label: entity.names?.[0],
-            aliases: entity.names,
-            handles: {},
-            metadata: entity.metadata
-          };
-        }
-      };
-      runtime.registerMessageConnector(registration);
-      return;
-    }
-    runtime.registerSendHandler(MATRIX_SERVICE_NAME, sendHandler);
-  }
-  async initialize(runtime) {
-    this.runtime = runtime;
-    this.defaultAccountId = normalizeMatrixAccountId(resolveDefaultMatrixAccountId(runtime));
-    const accountIds = listMatrixAccountIds(runtime);
-    for (const accountId of accountIds) {
-      const settings = this.loadSettings(accountId);
-      if (settings.enabled === false) {
-        continue;
-      }
-      this.validateSettings(settings);
-      const state = {
-        accountId: normalizeMatrixAccountId(settings.accountId),
-        settings,
-        client: sdk.createClient({
-          baseUrl: settings.homeserver,
-          userId: settings.userId,
-          accessToken: settings.accessToken,
-          deviceId: settings.deviceId
-        }),
-        connected: false,
-        syncing: false
-      };
-      this.states.set(state.accountId, state);
-      this.setupEventHandlers(state);
-      await this.connect(state);
-      MatrixService.registerSendHandlers(runtime, this, state.accountId);
-      logger.info(`Matrix service initialized for ${settings.userId} on ${settings.homeserver}`);
-    }
-    if (this.states.size === 0) {
-      const settings = this.loadSettings(this.defaultAccountId);
-      this.validateSettings(settings);
-    }
-  }
-  loadSettings(accountId) {
-    return resolveMatrixAccountSettings(this.runtime, accountId);
-  }
-  validateSettings(settings) {
-    if (!settings.homeserver) {
-      throw new MatrixConfigurationError("MATRIX_HOMESERVER is required", "MATRIX_HOMESERVER");
-    }
-    if (!settings.userId) {
-      throw new MatrixConfigurationError("MATRIX_USER_ID is required", "MATRIX_USER_ID");
-    }
-    if (!settings.accessToken) {
-      throw new MatrixConfigurationError("MATRIX_ACCESS_TOKEN is required", "MATRIX_ACCESS_TOKEN");
-    }
-  }
-  setupEventHandlers(state) {
-    state.client.on(sdk.ClientEvent.Sync, (syncState) => {
-      if (syncState === "PREPARED") {
-        state.syncing = true;
-        logger.info("Matrix sync complete");
-        this.runtime.emitEvent("MATRIX_SYNC_COMPLETE" /* SYNC_COMPLETE */, {
-          runtime: this.runtime,
-          accountId: state.accountId
-        });
-      }
-    });
-    state.client.on(sdk.RoomEvent.Timeline, (event, room, toStartOfTimeline) => {
-      if (toStartOfTimeline)
-        return;
-      if (event.getType() !== "m.room.message")
-        return;
-      if (event.getSender() === state.settings.userId)
-        return;
-      this.handleRoomMessage(state, event, room);
-    });
-    state.client.on(sdk.RoomMemberEvent.Membership, (event, member) => {
-      if (member.userId !== state.settings.userId)
-        return;
-      if (member.membership === "invite" && state.settings.autoJoin) {
-        const roomId = event.getRoomId();
-        if (roomId) {
-          logger.info(`Auto-joining room ${roomId}`);
-          state.client.joinRoom(roomId).catch((err) => {
-            logger.error(`Failed to auto-join room: ${err.message}`);
-          });
-        }
-      }
-    });
-  }
-  handleRoomMessage(state, event, room) {
-    const content = event.getContent();
-    const msgType = content.msgtype;
-    if (msgType !== "m.text")
-      return;
-    const roomId = event.getRoomId();
-    if (!roomId || !room)
-      return;
-    if (state.settings.requireMention) {
-      const body = content.body || "";
-      const localpart = getMatrixLocalpart(state.settings.userId);
-      const mentionPattern = new RegExp(`@?${localpart}`, "i");
-      if (!mentionPattern.test(body)) {
-        return;
-      }
-    }
-    const sender = event.getSender();
-    const senderMember = room.getMember(sender || "");
-    const senderInfo = {
-      userId: sender || "",
-      displayName: senderMember?.name,
-      avatarUrl: senderMember?.getMxcAvatarUrl() || undefined
-    };
-    const relatesTo = content["m.relates_to"];
-    const isEdit = relatesTo?.rel_type === "m.replace";
-    const threadId = relatesTo?.rel_type === "m.thread" ? relatesTo.event_id : undefined;
-    const replyTo = relatesTo?.["m.in_reply_to"]?.event_id;
-    const message = {
-      eventId: event.getId() || "",
-      roomId,
-      sender: sender || "",
-      senderInfo,
-      content: content.body || "",
-      msgType,
-      formattedBody: content.formatted_body,
-      timestamp: event.getTs(),
-      threadId,
-      replyTo,
-      isEdit,
-      replacesEventId: isEdit ? relatesTo?.event_id : undefined
-    };
-    const matrixRoom = {
-      roomId,
-      name: room.name,
-      topic: room.currentState.getStateEvents("m.room.topic", "")?.getContent()?.topic,
-      canonicalAlias: room.getCanonicalAlias() || undefined,
-      isEncrypted: room.hasEncryptionStateEvent(),
-      isDirect: state.client.getAccountData(sdk.EventType.Direct)?.getContent()?.[sender || ""]?.includes(roomId) || false,
-      memberCount: room.getJoinedMemberCount()
-    };
-    logger.debug(`Matrix message from ${senderInfo.displayName || sender} in ${room.name || roomId}: ${message.content.slice(0, 50)}...`);
-    this.runtime.emitEvent("MATRIX_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
-      message,
-      room: matrixRoom,
-      runtime: this.runtime,
-      accountId: state.accountId
-    });
-  }
-  async connect(state) {
-    await state.client.startClient({ initialSyncLimit: 10 });
-    state.connected = true;
-    await new Promise((resolve) => {
-      const listener = (syncState) => {
-        if (syncState === "PREPARED") {
-          state.client.removeListener(sdk.ClientEvent.Sync, listener);
-          resolve();
-        }
-      };
-      state.client.on(sdk.ClientEvent.Sync, listener);
-    });
-    for (const room of state.settings.rooms) {
-      try {
-        await this.joinRoom(room, state.accountId);
-      } catch (err) {
-        logger.warn(`Failed to join room ${room}: ${err}`);
-      }
-    }
-  }
-  async stop() {
-    for (const state of this.states.values()) {
-      state.client.stopClient();
-      state.connected = false;
-      state.syncing = false;
-    }
-    logger.info("Matrix service stopped");
-  }
-  isConnected() {
-    const legacy = this;
-    const states = this.states ?? new Map;
-    if (states.size === 0 && typeof legacy.connected === "boolean") {
-      return legacy.connected && (legacy.syncing ?? true);
-    }
-    return Array.from(states.values()).some((state) => state.connected && state.syncing);
-  }
-  getAccountId(runtime) {
-    const legacy = this;
-    const states = this.states ?? new Map;
-    if (states.size === 0 && legacy.settings?.accountId) {
-      return normalizeMatrixAccountId(legacy.settings.accountId);
-    }
-    return normalizeMatrixAccountId(this.defaultAccountId !== DEFAULT_MATRIX_ACCOUNT_ID ? this.defaultAccountId : runtime ? resolveDefaultMatrixAccountId(runtime) : this.defaultAccountId);
-  }
-  getUserId() {
-    return this.getState().settings.userId;
-  }
-  getHomeserver() {
-    return this.getState().settings.homeserver;
-  }
-  async getJoinedRooms(accountId) {
-    const state = this.getState(accountId);
-    const rooms = state.client.getRooms();
-    return rooms.filter((room) => room.getMyMembership() === "join").map((room) => ({
-      roomId: room.roomId,
-      name: room.name,
-      topic: room.currentState.getStateEvents("m.room.topic", "")?.getContent()?.topic,
-      canonicalAlias: room.getCanonicalAlias() || undefined,
-      isEncrypted: room.hasEncryptionStateEvent(),
-      isDirect: false,
-      memberCount: room.getJoinedMemberCount()
-    }));
-  }
-  async sendMessage(text, options) {
-    const state = this.getState(options?.accountId);
-    if (!state.connected || !state.syncing) {
-      throw new MatrixNotConnectedError;
-    }
-    const roomId = options?.roomId;
-    if (!roomId) {
-      return { success: false, error: "Room ID is required" };
-    }
-    let resolvedRoomId = roomId;
-    if (isValidMatrixRoomAlias(roomId)) {
-      const resolved = await state.client.getRoomIdForAlias(roomId);
-      resolvedRoomId = resolved.room_id;
-    }
-    const content = {
-      msgtype: sdk.MsgType.Text,
-      body: text
-    };
-    if (options?.formatted) {
-      content.format = "org.matrix.custom.html";
-      content.formatted_body = text;
-    }
-    if (options?.threadId || options?.replyTo) {
-      content["m.relates_to"] = {};
-      if (options.threadId) {
-        content["m.relates_to"].rel_type = sdk.RelationType.Thread;
-        content["m.relates_to"].event_id = options.threadId;
-      }
-      if (options.replyTo) {
-        content["m.relates_to"]["m.in_reply_to"] = {
-          event_id: options.replyTo
-        };
-      }
-    }
-    const response = await state.client.sendMessage(resolvedRoomId, content);
-    const eventId = response.event_id;
-    this.runtime.emitEvent("MATRIX_MESSAGE_SENT" /* MESSAGE_SENT */, {
-      roomId: resolvedRoomId,
-      eventId,
-      content: text,
-      runtime: this.runtime,
-      accountId: state.accountId
-    });
-    return {
-      success: true,
-      eventId,
-      roomId: resolvedRoomId
-    };
-  }
-  async sendReaction(roomId, eventId, emoji, accountId) {
-    const state = this.getState(accountId);
-    if (!state.connected || !state.syncing) {
-      throw new MatrixNotConnectedError;
-    }
-    const content = {
-      "m.relates_to": {
-        rel_type: sdk.RelationType.Annotation,
-        event_id: eventId,
-        key: emoji
-      }
-    };
-    const response = await state.client.sendEvent(roomId, sdk.EventType.Reaction, content);
-    return {
-      success: true,
-      eventId: response.event_id,
-      roomId
-    };
-  }
-  async joinRoom(roomIdOrAlias, accountId) {
-    const state = this.getState(accountId);
-    if (!state.connected || !state.syncing) {
-      throw new MatrixNotConnectedError;
-    }
-    const response = await state.client.joinRoom(roomIdOrAlias);
-    const roomId = response.roomId;
-    logger.info(`Joined room ${roomId}`);
-    this.runtime.emitEvent("MATRIX_ROOM_JOINED" /* ROOM_JOINED */, {
-      room: { roomId },
-      runtime: this.runtime,
-      accountId: state.accountId
-    });
-    return roomId;
-  }
-  async leaveRoom(roomId, accountId) {
-    const state = this.getState(accountId);
-    if (!state.connected || !state.syncing) {
-      throw new MatrixNotConnectedError;
-    }
-    await state.client.leave(roomId);
-    logger.info(`Left room ${roomId}`);
-    this.runtime.emitEvent("MATRIX_ROOM_LEFT" /* ROOM_LEFT */, {
-      roomId,
-      runtime: this.runtime,
-      accountId: state.accountId
-    });
-  }
-  async sendTyping(roomId, typing, timeout = 30000, accountId) {
-    const state = this.getState(accountId);
-    if (!state.connected || !state.syncing) {
-      return;
-    }
-    await state.client.sendTyping(roomId, typing, timeout);
-  }
-  async sendReadReceipt(roomId, eventId, accountId) {
-    const state = this.getState(accountId);
-    if (!state.connected || !state.syncing) {
-      return;
-    }
-    await state.client.sendReadReceipt(new sdk.MatrixEvent({ event_id: eventId, room_id: roomId }));
-  }
-  async sendRoomMessage(roomIdOrAlias, content) {
-    const text = typeof content.text === "string" ? content.text.trim() : "";
-    if (!text) {
-      return;
-    }
-    await this.sendMessage(text, {
-      accountId: readMatrixAccountId(content) ?? this.getAccountId(),
-      roomId: roomIdOrAlias
-    });
-  }
-  async sendDirectMessage(roomIdOrAlias, content) {
-    await this.sendRoomMessage(roomIdOrAlias, content);
-  }
-  async handleSendMessage(runtime, target, content) {
-    const requestedAccountId = normalizeMatrixAccountId(target.accountId ?? readMatrixAccountId(content, target) ?? this.getAccountId());
-    this.getState(requestedAccountId);
-    const text = typeof content.text === "string" ? content.text.trim() : "";
-    if (!text) {
-      return;
-    }
-    const room = target.roomId ? await runtime.getRoom(target.roomId) : null;
-    const roomIdOrAlias = String(target.channelId || room?.channelId || (typeof target.roomId === "string" && (isValidMatrixRoomId(target.roomId) || isValidMatrixRoomAlias(target.roomId)) ? target.roomId : "")).trim();
-    if (!roomIdOrAlias) {
-      throw new Error("Matrix target is missing a room ID or alias");
-    }
-    await this.sendMessage(text, {
-      accountId: requestedAccountId,
-      roomId: roomIdOrAlias,
-      ...extractMatrixSendOptions(content, target)
-    });
-  }
-  getState(accountId = this.defaultAccountId) {
-    const normalized = normalizeMatrixAccountId(accountId);
-    const states = this.states ?? new Map;
-    const state = states.get(normalized);
-    if (state) {
-      return state;
-    }
-    const legacy = this;
-    if (legacy.settings) {
-      return {
-        accountId: normalizeMatrixAccountId(legacy.settings.accountId ?? normalized),
-        settings: legacy.settings,
-        client: legacy.client ?? {},
-        connected: legacy.connected ?? true,
-        syncing: legacy.syncing ?? true
-      };
-    }
-    throw new Error(`Matrix account '${normalized}' is not available in this service instance`);
-  }
-}
-// src/connector-account-provider.ts
-var MATRIX_PROVIDER_ID = "matrix";
-function accountKey(settings) {
-  if (settings.homeserver && settings.userId) {
-    return `${settings.homeserver}/${settings.userId}`;
-  }
-  return normalizeMatrixAccountId(settings.accountId);
-}
-function toConnectorAccount(settings) {
-  const now = Date.now();
-  const configured = Boolean(settings.homeserver && settings.userId && settings.accessToken);
-  return {
-    id: normalizeMatrixAccountId(settings.accountId),
-    provider: MATRIX_PROVIDER_ID,
-    label: settings.userId || settings.accountId,
-    role: "OWNER",
-    purpose: ["messaging"],
-    accessGate: "open",
-    status: settings.enabled !== false && configured ? "connected" : "disabled",
-    externalId: accountKey(settings),
-    displayHandle: settings.userId || undefined,
-    createdAt: now,
-    updatedAt: now,
-    metadata: {
-      homeserver: settings.homeserver ?? "",
-      userId: settings.userId ?? "",
-      deviceId: settings.deviceId ?? "",
-      encryption: settings.encryption ?? false,
-      autoJoin: settings.autoJoin ?? false
-    }
-  };
-}
-function createMatrixConnectorAccountProvider(runtime) {
-  return {
-    provider: MATRIX_PROVIDER_ID,
-    label: "Matrix",
-    listAccounts: async (_manager) => {
-      const ids = listMatrixAccountIds(runtime);
-      if (ids.length === 0) {
-        return [
-          toConnectorAccount(resolveMatrixAccountSettings(runtime, DEFAULT_MATRIX_ACCOUNT_ID))
-        ];
-      }
-      return ids.map((id) => toConnectorAccount(resolveMatrixAccountSettings(runtime, id)));
-    },
-    createAccount: async (input, _manager) => {
-      return {
-        ...input,
-        provider: MATRIX_PROVIDER_ID,
-        role: input.role ?? "OWNER",
-        purpose: input.purpose ?? ["messaging"],
-        accessGate: input.accessGate ?? "open",
-        status: input.status ?? "pending"
-      };
-    },
-    patchAccount: async (_accountId, patch, _manager) => {
-      return { ...patch, provider: MATRIX_PROVIDER_ID };
-    },
-    deleteAccount: async (_accountId, _manager) => {}
-  };
-}
-
-// src/workflow-credential-provider.ts
-import { Service as Service2 } from "@elizaos/core";
-var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
-var SUPPORTED = ["matrixApi"];
-
-class MatrixWorkflowCredentialProvider extends Service2 {
-  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
-  capabilityDescription = "Supplies Matrix credentials to the workflow plugin.";
-  static async start(runtime) {
-    return new MatrixWorkflowCredentialProvider(runtime);
-  }
-  async stop() {}
-  async resolve(_userId, credType) {
-    if (credType !== "matrixApi")
-      return null;
-    const accessToken = this.runtime.getSetting("MATRIX_ACCESS_TOKEN");
-    const homeserver = this.runtime.getSetting("MATRIX_HOMESERVER");
-    if (!accessToken?.trim() || !homeserver?.trim())
-      return null;
-    return {
-      status: "credential_data",
-      data: { accessToken: accessToken.trim(), homeserverUrl: homeserver.trim() }
-    };
-  }
-  checkCredentialTypes(credTypes) {
-    return {
-      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
-      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
-    };
-  }
-}
-
-// src/index.ts
-var matrixPlugin = {
-  name: "matrix",
-  description: "Matrix messaging integration plugin for ElizaOS with E2EE support",
-  services: [MatrixService, MatrixWorkflowCredentialProvider],
-  actions: [],
-  providers: [],
-  tests: [],
-  autoEnable: {
-    connectorKeys: ["matrix"]
-  },
-  init: async (_config, runtime) => {
-    try {
-      const manager = getConnectorAccountManager(runtime);
-      manager.registerProvider(createMatrixConnectorAccountProvider(runtime));
-    } catch (err) {
-      logger2.warn({
-        src: "plugin:matrix",
-        err: err instanceof Error ? err.message : String(err)
-      }, "Failed to register Matrix provider with ConnectorAccountManager");
-    }
-    const homeserver = runtime.getSetting("MATRIX_HOMESERVER");
-    const userId = runtime.getSetting("MATRIX_USER_ID");
-    const accessToken = runtime.getSetting("MATRIX_ACCESS_TOKEN");
-    logger2.info("=".repeat(60));
-    logger2.info("Matrix Plugin Configuration");
-    logger2.info("=".repeat(60));
-    logger2.info(`  Homeserver: ${homeserver ? `✓ ${homeserver}` : "✗ Missing (required)"}`);
-    logger2.info(`  User ID: ${userId ? `✓ ${userId}` : "✗ Missing (required)"}`);
-    logger2.info(`  Access Token: ${accessToken ? "✓ Set" : "✗ Missing (required)"}`);
-    logger2.info("=".repeat(60));
-    const missing = [];
-    if (!homeserver)
-      missing.push("MATRIX_HOMESERVER");
-    if (!userId)
-      missing.push("MATRIX_USER_ID");
-    if (!accessToken)
-      missing.push("MATRIX_ACCESS_TOKEN");
-    if (missing.length > 0) {
-      logger2.warn(`Matrix plugin: Missing required configuration: ${missing.join(", ")}`);
-    }
-    const deviceId = runtime.getSetting("MATRIX_DEVICE_ID");
-    const rooms = runtime.getSetting("MATRIX_ROOMS");
-    const autoJoin = runtime.getSetting("MATRIX_AUTO_JOIN");
-    const encryption = runtime.getSetting("MATRIX_ENCRYPTION");
-    const requireMention = runtime.getSetting("MATRIX_REQUIRE_MENTION");
-    if (deviceId) {
-      logger2.info(`  Device ID: ${deviceId}`);
-    }
-    if (rooms) {
-      logger2.info(`  Auto-join Rooms: ${rooms}`);
-    }
-    if (autoJoin === "true") {
-      logger2.info("  Auto-join Invites: ✓ Enabled");
-    }
-    if (encryption === "true") {
-      logger2.info("  End-to-End Encryption: ✓ Enabled");
-    }
-    if (requireMention === "true") {
-      logger2.info("  Require Mention: ✓ Enabled (will only respond to mentions in rooms)");
-    }
-  }
-};
-var src_default = matrixPlugin;
-export {
-  resolveMatrixAccountSettings,
-  resolveDefaultMatrixAccountId,
-  readMatrixAccountId,
-  normalizeMatrixAccountId,
-  matrixMxcToHttp,
-  listMatrixAccountIds,
-  isValidMatrixUserId,
-  isValidMatrixRoomId,
-  isValidMatrixRoomAlias,
-  getMatrixUserDisplayName,
-  getMatrixServerpart,
-  getMatrixLocalpart,
-  src_default as default,
-  MatrixServiceNotInitializedError,
-  MatrixService,
-  MatrixPluginError,
-  MatrixNotConnectedError,
-  MatrixEventTypes,
-  MatrixConfigurationError,
-  MatrixApiError,
-  MAX_MATRIX_MESSAGE_LENGTH,
-  MATRIX_SERVICE_NAME,
-  DEFAULT_MATRIX_ACCOUNT_ID
-};
-
-//# debugId=2890053EB234064664756E2164756E21