@elizaos/plugin-matrix 2.0.0-alpha.8 → 2.0.0-beta.1

package/dist/index.js

@@ -1,8 +1,119 @@
 // src/index.ts
-import { logger as logger2 } from "@elizaos/core";
+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 {
+  logger,
+  Service
+} from "@elizaos/core";
 import * as sdk from "matrix-js-sdk";
 
 // src/types.ts
@@ -93,13 +204,94 @@ class MatrixApiError extends MatrixPluginError {
 }
 
 // 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";
-  settings;
-  client;
-  connected = false;
-  syncing = false;
+  states = new Map;
+  defaultAccountId = DEFAULT_MATRIX_ACCOUNT_ID;
   static async start(runtime) {
     const service = new MatrixService;
     await service.initialize(runtime);
@@ -111,91 +303,216 @@ class MatrixService extends 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.settings = this.loadSettings();
-    this.validateSettings();
-    this.client = sdk.createClient({
-      baseUrl: this.settings.homeserver,
-      userId: this.settings.userId,
-      accessToken: this.settings.accessToken,
-      deviceId: this.settings.deviceId
-    });
-    this.setupEventHandlers();
-    await this.connect();
-    logger.info(`Matrix service initialized for ${this.settings.userId} on ${this.settings.homeserver}`);
+    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() {
-    const getStringSetting = (key) => {
-      const value = this.runtime.getSetting(key);
-      return typeof value === "string" ? value : undefined;
-    };
-    const homeserver = getStringSetting("MATRIX_HOMESERVER");
-    const userId = getStringSetting("MATRIX_USER_ID");
-    const accessToken = getStringSetting("MATRIX_ACCESS_TOKEN");
-    const deviceId = getStringSetting("MATRIX_DEVICE_ID");
-    const roomsStr = getStringSetting("MATRIX_ROOMS");
-    const autoJoinStr = getStringSetting("MATRIX_AUTO_JOIN");
-    const encryptionStr = getStringSetting("MATRIX_ENCRYPTION");
-    const requireMentionStr = getStringSetting("MATRIX_REQUIRE_MENTION");
-    const rooms = roomsStr ? roomsStr.split(",").map((r) => r.trim()).filter(Boolean) : [];
-    return {
-      homeserver: homeserver || "",
-      userId: userId || "",
-      accessToken: accessToken || "",
-      deviceId,
-      rooms,
-      autoJoin: autoJoinStr === "true",
-      encryption: encryptionStr === "true",
-      requireMention: requireMentionStr === "true",
-      enabled: true
-    };
+  loadSettings(accountId) {
+    return resolveMatrixAccountSettings(this.runtime, accountId);
   }
-  validateSettings() {
-    if (!this.settings.homeserver) {
+  validateSettings(settings) {
+    if (!settings.homeserver) {
       throw new MatrixConfigurationError("MATRIX_HOMESERVER is required", "MATRIX_HOMESERVER");
     }
-    if (!this.settings.userId) {
+    if (!settings.userId) {
       throw new MatrixConfigurationError("MATRIX_USER_ID is required", "MATRIX_USER_ID");
     }
-    if (!this.settings.accessToken) {
+    if (!settings.accessToken) {
       throw new MatrixConfigurationError("MATRIX_ACCESS_TOKEN is required", "MATRIX_ACCESS_TOKEN");
     }
   }
-  setupEventHandlers() {
-    this.client.on(sdk.ClientEvent.Sync, (state) => {
-      if (state === "PREPARED") {
-        this.syncing = true;
+  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
+          runtime: this.runtime,
+          accountId: state.accountId
         });
       }
     });
-    this.client.on(sdk.RoomEvent.Timeline, (event, room, toStartOfTimeline) => {
+    state.client.on(sdk.RoomEvent.Timeline, (event, room, toStartOfTimeline) => {
       if (toStartOfTimeline)
         return;
       if (event.getType() !== "m.room.message")
         return;
-      if (event.getSender() === this.settings.userId)
+      if (event.getSender() === state.settings.userId)
         return;
-      this.handleRoomMessage(event, room);
+      this.handleRoomMessage(state, event, room);
     });
-    this.client.on(sdk.RoomMemberEvent.Membership, (event, member) => {
-      if (member.userId !== this.settings.userId)
+    state.client.on(sdk.RoomMemberEvent.Membership, (event, member) => {
+      if (member.userId !== state.settings.userId)
         return;
-      if (member.membership === "invite" && this.settings.autoJoin) {
+      if (member.membership === "invite" && state.settings.autoJoin) {
         const roomId = event.getRoomId();
         if (roomId) {
           logger.info(`Auto-joining room ${roomId}`);
-          this.client.joinRoom(roomId).catch((err) => {
+          state.client.joinRoom(roomId).catch((err) => {
             logger.error(`Failed to auto-join room: ${err.message}`);
           });
         }
       }
     });
   }
-  handleRoomMessage(event, room) {
+  handleRoomMessage(state, event, room) {
     const content = event.getContent();
     const msgType = content.msgtype;
     if (msgType !== "m.text")
@@ -203,9 +520,9 @@ class MatrixService extends Service {
     const roomId = event.getRoomId();
     if (!roomId || !room)
       return;
-    if (this.settings.requireMention) {
+    if (state.settings.requireMention) {
       const body = content.body || "";
-      const localpart = getMatrixLocalpart(this.settings.userId);
+      const localpart = getMatrixLocalpart(state.settings.userId);
       const mentionPattern = new RegExp(`@?${localpart}`, "i");
       if (!mentionPattern.test(body)) {
         return;
@@ -242,54 +559,70 @@ class MatrixService extends Service {
       topic: room.currentState.getStateEvents("m.room.topic", "")?.getContent()?.topic,
       canonicalAlias: room.getCanonicalAlias() || undefined,
       isEncrypted: room.hasEncryptionStateEvent(),
-      isDirect: this.client.getAccountData("m.direct")?.getContent()?.[sender || ""]?.includes(roomId) || false,
+      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
+      runtime: this.runtime,
+      accountId: state.accountId
     });
   }
-  async connect() {
-    await this.client.startClient({ initialSyncLimit: 10 });
-    this.connected = true;
+  async connect(state) {
+    await state.client.startClient({ initialSyncLimit: 10 });
+    state.connected = true;
     await new Promise((resolve) => {
-      const listener = (state) => {
-        if (state === "PREPARED") {
-          this.client.removeListener(sdk.ClientEvent.Sync, listener);
+      const listener = (syncState) => {
+        if (syncState === "PREPARED") {
+          state.client.removeListener(sdk.ClientEvent.Sync, listener);
           resolve();
         }
       };
-      this.client.on(sdk.ClientEvent.Sync, listener);
+      state.client.on(sdk.ClientEvent.Sync, listener);
     });
-    for (const room of this.settings.rooms) {
+    for (const room of state.settings.rooms) {
       try {
-        await this.joinRoom(room);
+        await this.joinRoom(room, state.accountId);
       } catch (err) {
         logger.warn(`Failed to join room ${room}: ${err}`);
       }
     }
   }
   async stop() {
-    if (this.client) {
-      this.client.stopClient();
+    for (const state of this.states.values()) {
+      state.client.stopClient();
+      state.connected = false;
+      state.syncing = false;
     }
-    this.connected = false;
     logger.info("Matrix service stopped");
   }
   isConnected() {
-    return this.connected && this.syncing;
+    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.settings.userId;
+    return this.getState().settings.userId;
   }
   getHomeserver() {
-    return this.settings.homeserver;
+    return this.getState().settings.homeserver;
   }
-  async getJoinedRooms() {
-    const rooms = this.client.getRooms();
+  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,
@@ -301,7 +634,8 @@ class MatrixService extends Service {
     }));
   }
   async sendMessage(text, options) {
-    if (!this.isConnected()) {
+    const state = this.getState(options?.accountId);
+    if (!state.connected || !state.syncing) {
       throw new MatrixNotConnectedError;
     }
     const roomId = options?.roomId;
@@ -310,11 +644,11 @@ class MatrixService extends Service {
     }
     let resolvedRoomId = roomId;
     if (isValidMatrixRoomAlias(roomId)) {
-      const resolved = await this.client.getRoomIdForAlias(roomId);
+      const resolved = await state.client.getRoomIdForAlias(roomId);
       resolvedRoomId = resolved.room_id;
     }
     const content = {
-      msgtype: "m.text",
+      msgtype: sdk.MsgType.Text,
       body: text
     };
     if (options?.formatted) {
@@ -324,7 +658,7 @@ class MatrixService extends Service {
     if (options?.threadId || options?.replyTo) {
       content["m.relates_to"] = {};
       if (options.threadId) {
-        content["m.relates_to"].rel_type = "m.thread";
+        content["m.relates_to"].rel_type = sdk.RelationType.Thread;
         content["m.relates_to"].event_id = options.threadId;
       }
       if (options.replyTo) {
@@ -333,13 +667,14 @@ class MatrixService extends Service {
         };
       }
     }
-    const response = await this.client.sendMessage(resolvedRoomId, content);
+    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
+      runtime: this.runtime,
+      accountId: state.accountId
     });
     return {
       success: true,
@@ -347,618 +682,233 @@ class MatrixService extends Service {
       roomId: resolvedRoomId
     };
   }
-  async sendReaction(roomId, eventId, emoji) {
-    if (!this.isConnected()) {
+  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: "m.annotation",
+        rel_type: sdk.RelationType.Annotation,
         event_id: eventId,
         key: emoji
       }
     };
-    const response = await this.client.sendEvent(roomId, "m.reaction", content);
+    const response = await state.client.sendEvent(roomId, sdk.EventType.Reaction, content);
     return {
       success: true,
       eventId: response.event_id,
       roomId
     };
   }
-  async joinRoom(roomIdOrAlias) {
-    if (!this.isConnected()) {
+  async joinRoom(roomIdOrAlias, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
       throw new MatrixNotConnectedError;
     }
-    const response = await this.client.joinRoom(roomIdOrAlias);
+    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
+      runtime: this.runtime,
+      accountId: state.accountId
     });
     return roomId;
   }
-  async leaveRoom(roomId) {
-    if (!this.isConnected()) {
+  async leaveRoom(roomId, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
       throw new MatrixNotConnectedError;
     }
-    await this.client.leave(roomId);
+    await state.client.leave(roomId);
     logger.info(`Left room ${roomId}`);
     this.runtime.emitEvent("MATRIX_ROOM_LEFT" /* ROOM_LEFT */, {
       roomId,
-      runtime: this.runtime
+      runtime: this.runtime,
+      accountId: state.accountId
     });
   }
-  async sendTyping(roomId, typing, timeout = 30000) {
-    if (!this.isConnected()) {
+  async sendTyping(roomId, typing, timeout = 30000, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
       return;
     }
-    await this.client.sendTyping(roomId, typing, timeout);
+    await state.client.sendTyping(roomId, typing, timeout);
   }
-  async sendReadReceipt(roomId, eventId) {
-    if (!this.isConnected()) {
+  async sendReadReceipt(roomId, eventId, accountId) {
+    const state = this.getState(accountId);
+    if (!state.connected || !state.syncing) {
       return;
     }
-    await this.client.sendReadReceipt(new sdk.MatrixEvent({ event_id: eventId, room_id: roomId }));
+    await state.client.sendReadReceipt(new sdk.MatrixEvent({ event_id: eventId, room_id: roomId }));
   }
-}
-// src/actions/joinRoom.ts
-import { composePromptFromState, ModelType, parseJSONObjectFromText } from "@elizaos/core";
-var JOIN_ROOM_TEMPLATE = `You are helping to extract a Matrix room identifier.
-
-The user wants to join a Matrix room.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract the room ID (!room:server) or room alias (#alias:server) to join.
-
-Respond with a JSON object like:
-{
-  "room": "!room:matrix.org"
-}
-
-or:
-
-{
-  "room": "#alias:matrix.org"
-}
-
-Only respond with the JSON object, no other text.`;
-var joinRoom = {
-  name: "MATRIX_JOIN_ROOM",
-  similes: ["JOIN_MATRIX_ROOM", "ENTER_ROOM"],
-  description: "Join a Matrix room by ID or alias",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "matrix";
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const matrixService = runtime.getService(MATRIX_SERVICE_NAME);
-    if (!matrixService || !matrixService.isConnected()) {
-      if (callback) {
-        await callback({ text: "Matrix service is not available.", source: "matrix" });
-      }
-      return { success: false, error: "Matrix service not available" };
+  async sendRoomMessage(roomIdOrAlias, content) {
+    const text = typeof content.text === "string" ? content.text.trim() : "";
+    if (!text) {
+      return;
     }
-    const composedState = state ?? {
-      values: {},
-      data: {},
-      text: ""
-    };
-    const prompt = await composePromptFromState({
-      template: JOIN_ROOM_TEMPLATE,
-      state: composedState
+    await this.sendMessage(text, {
+      accountId: readMatrixAccountId(content) ?? this.getAccountId(),
+      roomId: roomIdOrAlias
     });
-    let room = null;
-    for (let attempt = 0;attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt
-      });
-      const parsed = parseJSONObjectFromText(response);
-      if (parsed?.room) {
-        const roomStr = String(parsed.room).trim();
-        if (isValidMatrixRoomId(roomStr) || isValidMatrixRoomAlias(roomStr)) {
-          room = roomStr;
-          break;
-        }
-      }
+  }
+  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;
     }
-    if (!room) {
-      if (callback) {
-        await callback({
-          text: "I couldn't understand which room you want me to join. Please specify a room ID (!room:server) or alias (#alias:server).",
-          source: "matrix"
-        });
-      }
-      return { success: false, error: "Could not extract room identifier" };
+    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");
     }
-    try {
-      const roomId = await matrixService.joinRoom(room);
-      if (callback) {
-        await callback({
-          text: `Joined room ${room}.`,
-          source: message.content.source
-        });
-      }
+    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 {
-        success: true,
-        data: {
-          roomId,
-          joined: room
-        }
+        accountId: normalizeMatrixAccountId(legacy.settings.accountId ?? normalized),
+        settings: legacy.settings,
+        client: legacy.client ?? {},
+        connected: legacy.connected ?? true,
+        syncing: legacy.syncing ?? true
       };
-    } catch (err) {
-      const error = err instanceof Error ? err.message : String(err);
-      if (callback) {
-        await callback({
-          text: `Failed to join room: ${error}`,
-          source: "matrix"
-        });
-      }
-      return { success: false, error };
     }
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Join #general:matrix.org" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll join that room.",
-          actions: ["MATRIX_JOIN_ROOM"]
-        }
-      }
-    ]
-  ]
-};
-
-// src/actions/listRooms.ts
-var listRooms = {
-  name: "MATRIX_LIST_ROOMS",
-  similes: ["LIST_MATRIX_ROOMS", "SHOW_ROOMS", "GET_ROOMS", "MY_ROOMS"],
-  description: "List all Matrix rooms the bot has joined",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "matrix";
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    const matrixService = runtime.getService(MATRIX_SERVICE_NAME);
-    if (!matrixService || !matrixService.isConnected()) {
-      if (callback) {
-        await callback({ text: "Matrix service is not available.", source: "matrix" });
-      }
-      return { success: false, error: "Matrix service not available" };
-    }
-    const rooms = await matrixService.getJoinedRooms();
-    const roomList = rooms.map((room) => {
-      const name = room.name || room.canonicalAlias || room.roomId;
-      const members = `${room.memberCount} members`;
-      const encrypted = room.isEncrypted ? " (encrypted)" : "";
-      return `- ${name} (${members})${encrypted}`;
-    });
-    const responseText = rooms.length > 0 ? `Joined ${rooms.length} room(s):
-
-${roomList.join(`
-`)}` : "Not currently in any rooms.";
-    if (callback) {
-      await callback({
-        text: responseText,
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        roomCount: rooms.length,
-        rooms: rooms.map((r) => ({
-          roomId: r.roomId,
-          name: r.name,
-          alias: r.canonicalAlias,
-          memberCount: r.memberCount,
-          isEncrypted: r.isEncrypted
-        }))
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "What rooms are you in?" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll list the rooms I've joined.",
-          actions: ["MATRIX_LIST_ROOMS"]
-        }
-      }
-    ]
-  ]
-};
-
-// src/actions/sendMessage.ts
-import { composePromptFromState as composePromptFromState2, ModelType as ModelType2, parseJSONObjectFromText as parseJSONObjectFromText2 } from "@elizaos/core";
-var SEND_MESSAGE_TEMPLATE = `You are helping to extract send message parameters for Matrix.
-
-The user wants to send a message to a Matrix room.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract the following:
-1. text: The message text to send
-2. roomId: The room ID (!room:server) or alias (#alias:server), or "current" for the current room
-
-Respond with a JSON object like:
-{
-  "text": "The message to send",
-  "roomId": "current"
+    throw new Error(`Matrix account '${normalized}' is not available in this service instance`);
+  }
 }
-
-Only respond with the JSON object, no other text.`;
-var sendMessage = {
-  name: "MATRIX_SEND_MESSAGE",
-  similes: ["SEND_MATRIX_MESSAGE", "MESSAGE_MATRIX", "MATRIX_TEXT"],
-  description: "Send a message to a Matrix room",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "matrix";
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const matrixService = runtime.getService(MATRIX_SERVICE_NAME);
-    if (!matrixService || !matrixService.isConnected()) {
-      if (callback) {
-        await callback({ text: "Matrix service is not available.", source: "matrix" });
-      }
-      return { success: false, error: "Matrix service not available" };
-    }
-    const composedState = state ?? {
-      values: {},
-      data: {},
-      text: ""
-    };
-    const prompt = await composePromptFromState2({
-      template: SEND_MESSAGE_TEMPLATE,
-      state: composedState
-    });
-    let messageInfo = null;
-    for (let attempt = 0;attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType2.TEXT_SMALL, {
-        prompt
-      });
-      const parsed = parseJSONObjectFromText2(response);
-      if (parsed?.text) {
-        messageInfo = {
-          text: String(parsed.text),
-          roomId: String(parsed.roomId || "current")
-        };
-        break;
-      }
-    }
-    if (!messageInfo || !messageInfo.text) {
-      if (callback) {
-        await callback({
-          text: "I couldn't understand what message you want me to send. Please try again.",
-          source: "matrix"
-        });
-      }
-      return { success: false, error: "Could not extract message parameters" };
-    }
-    let targetRoomId;
-    if (messageInfo.roomId && messageInfo.roomId !== "current") {
-      if (isValidMatrixRoomId(messageInfo.roomId) || isValidMatrixRoomAlias(messageInfo.roomId)) {
-        targetRoomId = messageInfo.roomId;
-      }
-    }
-    const roomData = state?.data?.room;
-    if (!targetRoomId && roomData?.roomId) {
-      targetRoomId = roomData.roomId;
-    }
-    if (!targetRoomId) {
-      if (callback) {
-        await callback({
-          text: "I couldn't determine which room to send to. Please specify a room.",
-          source: "matrix"
-        });
-      }
-      return { success: false, error: "Could not determine target room" };
-    }
-    const result = await matrixService.sendMessage(messageInfo.text, {
-      roomId: targetRoomId
-    });
-    if (!result.success) {
-      if (callback) {
-        await callback({
-          text: `Failed to send message: ${result.error}`,
-          source: "matrix"
-        });
-      }
-      return { success: false, error: result.error };
-    }
-    if (callback) {
-      await callback({
-        text: "Message sent successfully.",
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        roomId: result.roomId,
-        eventId: result.eventId
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Send a message saying 'Hello everyone!'" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll send that message to the room.",
-          actions: ["MATRIX_SEND_MESSAGE"]
-        }
-      }
-    ]
-  ]
-};
-
-// src/actions/sendReaction.ts
-import { composePromptFromState as composePromptFromState3, ModelType as ModelType3, parseJSONObjectFromText as parseJSONObjectFromText3 } from "@elizaos/core";
-var SEND_REACTION_TEMPLATE = `You are helping to extract reaction parameters for Matrix.
-
-The user wants to react to a Matrix message with an emoji.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract the following:
-1. emoji: The emoji to react with (single emoji character)
-2. eventId: The event ID of the message to react to (starts with $)
-
-Respond with a JSON object like:
-{
-  "emoji": "\uD83D\uDC4D",
-  "eventId": "$event123"
+// 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);
 }
-
-Only respond with the JSON object, no other text.`;
-var sendReaction = {
-  name: "MATRIX_SEND_REACTION",
-  similes: ["REACT_MATRIX", "MATRIX_REACT", "ADD_MATRIX_REACTION"],
-  description: "React to a Matrix message with an emoji",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "matrix";
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const matrixService = runtime.getService(MATRIX_SERVICE_NAME);
-    if (!matrixService || !matrixService.isConnected()) {
-      if (callback) {
-        await callback({ text: "Matrix service is not available.", source: "matrix" });
-      }
-      return { success: false, error: "Matrix service not available" };
-    }
-    const composedState = state ?? {
-      values: {},
-      data: {},
-      text: ""
-    };
-    const prompt = await composePromptFromState3({
-      template: SEND_REACTION_TEMPLATE,
-      state: composedState
-    });
-    let reactionInfo = null;
-    for (let attempt = 0;attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType3.TEXT_SMALL, {
-        prompt
-      });
-      const parsed = parseJSONObjectFromText3(response);
-      if (parsed?.emoji && parsed?.eventId) {
-        reactionInfo = {
-          emoji: String(parsed.emoji),
-          eventId: String(parsed.eventId)
-        };
-        break;
-      }
-    }
-    if (!reactionInfo) {
-      if (callback) {
-        await callback({
-          text: "I couldn't understand the reaction request. Please specify the emoji and message.",
-          source: "matrix"
-        });
-      }
-      return { success: false, error: "Could not extract reaction parameters" };
-    }
-    const roomData = state?.data?.room;
-    const roomId = roomData?.roomId;
-    if (!roomId) {
-      if (callback) {
-        await callback({
-          text: "I couldn't determine which room this is in.",
-          source: "matrix"
-        });
-      }
-      return { success: false, error: "Could not determine room" };
-    }
-    const result = await matrixService.sendReaction(roomId, reactionInfo.eventId, reactionInfo.emoji);
-    if (!result.success) {
-      if (callback) {
-        await callback({
-          text: `Failed to add reaction: ${result.error}`,
-          source: "matrix"
-        });
-      }
-      return { success: false, error: result.error };
-    }
-    if (callback) {
-      await callback({
-        text: `Added ${reactionInfo.emoji} reaction.`,
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        emoji: reactionInfo.emoji,
-        eventId: reactionInfo.eventId,
-        roomId
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "React to the last message with a thumbs up" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll add a thumbs up reaction.",
-          actions: ["MATRIX_SEND_REACTION"]
-        }
-      }
-    ]
-  ]
-};
-
-// src/providers/roomState.ts
-var roomStateProvider = {
-  name: "matrixRoomState",
-  description: "Provides information about the current Matrix room context",
-  dynamic: true,
-  get: async (runtime, message, state) => {
-    if (message.content.source !== "matrix") {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const matrixService = runtime.getService(MATRIX_SERVICE_NAME);
-    if (!matrixService || !matrixService.isConnected()) {
+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 {
-        data: { connected: false },
-        values: { connected: false },
-        text: ""
+        ...input,
+        provider: MATRIX_PROVIDER_ID,
+        role: input.role ?? "OWNER",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
       };
-    }
-    const agentName = state?.agentName || "The agent";
-    const room = state?.data?.room;
-    const roomId = room?.roomId;
-    const roomName = room?.name;
-    const isEncrypted = room?.isEncrypted;
-    const isDirect = room?.isDirect;
-    const memberCount = room?.memberCount;
-    const userId = matrixService.getUserId();
-    const displayName = getMatrixLocalpart(userId);
-    let responseText = "";
-    if (isDirect) {
-      responseText = `${agentName} is in a direct message conversation on Matrix.`;
-    } else {
-      const roomLabel = roomName || roomId || "a Matrix room";
-      responseText = `${agentName} is currently in Matrix room "${roomLabel}".`;
-      if (memberCount) {
-        responseText += ` The room has ${memberCount} members.`;
-      }
-    }
-    if (isEncrypted) {
-      responseText += " This room has end-to-end encryption enabled.";
-    }
-    responseText += `
+    },
+    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"];
 
-Matrix is a decentralized communication protocol. ${agentName} is logged in as ${userId}.`;
+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 {
-      data: {
-        roomId,
-        roomName,
-        isEncrypted: isEncrypted || false,
-        isDirect: isDirect || false,
-        memberCount: memberCount || 0,
-        userId,
-        displayName,
-        homeserver: matrixService.getHomeserver(),
-        connected: true
-      },
-      values: {
-        roomId,
-        roomName,
-        isEncrypted: isEncrypted || false,
-        isDirect: isDirect || false,
-        memberCount: memberCount || 0,
-        userId
-      },
-      text: responseText
+      status: "credential_data",
+      data: { accessToken: accessToken.trim(), homeserverUrl: homeserver.trim() }
     };
   }
-};
-
-// src/providers/userContext.ts
-var userContextProvider = {
-  name: "matrixUserContext",
-  description: "Provides information about the Matrix user in the current conversation",
-  dynamic: true,
-  get: async (runtime, message, state) => {
-    if (message.content.source !== "matrix") {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const matrixService = runtime.getService(MATRIX_SERVICE_NAME);
-    if (!matrixService || !matrixService.isConnected()) {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const agentName = state?.agentName || "The agent";
-    const metadata = message.content.metadata;
-    const senderInfo = metadata?.senderInfo;
-    if (!senderInfo) {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const displayName = getMatrixUserDisplayName(senderInfo);
-    const localpart = getMatrixLocalpart(senderInfo.userId);
-    const responseText = `${agentName} is talking to ${displayName} (${senderInfo.userId}) on Matrix.`;
+  checkCredentialTypes(credTypes) {
     return {
-      data: {
-        userId: senderInfo.userId,
-        displayName,
-        localpart,
-        avatarUrl: senderInfo.avatarUrl
-      },
-      values: {
-        userId: senderInfo.userId,
-        displayName,
-        localpart
-      },
-      text: responseText
+      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],
-  actions: [sendMessage, sendReaction, listRooms, joinRoom],
-  providers: [roomStateProvider, userContextProvider],
+  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");
@@ -1003,13 +953,12 @@ var matrixPlugin = {
 };
 var src_default = matrixPlugin;
 export {
-  userContextProvider,
-  sendReaction,
-  sendMessage,
-  roomStateProvider,
+  resolveMatrixAccountSettings,
+  resolveDefaultMatrixAccountId,
+  readMatrixAccountId,
+  normalizeMatrixAccountId,
   matrixMxcToHttp,
-  listRooms,
-  joinRoom,
+  listMatrixAccountIds,
   isValidMatrixUserId,
   isValidMatrixRoomId,
   isValidMatrixRoomAlias,
@@ -1025,7 +974,8 @@ export {
   MatrixConfigurationError,
   MatrixApiError,
   MAX_MATRIX_MESSAGE_LENGTH,
-  MATRIX_SERVICE_NAME
+  MATRIX_SERVICE_NAME,
+  DEFAULT_MATRIX_ACCOUNT_ID
 };
 
-//# debugId=5529CFEE8ACF852C64756E2164756E21
+//# debugId=2890053EB234064664756E2164756E21