@elizaos/plugin-matrix 2.0.0-alpha.3

package/dist/index.js

@@ -0,0 +1,1045 @@
+// src/index.ts
+import { logger as logger2 } from "@elizaos/core";
+
+// src/service.ts
+import { Service, logger } 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
+class MatrixService extends Service {
+  static serviceType = MATRIX_SERVICE_NAME;
+  capabilityDescription = "Matrix messaging service for chat communication";
+  settings;
+  client;
+  connected = false;
+  syncing = false;
+  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();
+    }
+  }
+  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}`);
+  }
+  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
+    };
+  }
+  validateSettings() {
+    if (!this.settings.homeserver) {
+      throw new MatrixConfigurationError("MATRIX_HOMESERVER is required", "MATRIX_HOMESERVER");
+    }
+    if (!this.settings.userId) {
+      throw new MatrixConfigurationError("MATRIX_USER_ID is required", "MATRIX_USER_ID");
+    }
+    if (!this.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;
+        logger.info("Matrix sync complete");
+        this.runtime.emitEvent("MATRIX_SYNC_COMPLETE" /* SYNC_COMPLETE */, {
+          runtime: this.runtime
+        });
+      }
+    });
+    this.client.on(sdk.RoomEvent.Timeline, (event, room, toStartOfTimeline) => {
+      if (toStartOfTimeline)
+        return;
+      if (event.getType() !== "m.room.message")
+        return;
+      if (event.getSender() === this.settings.userId)
+        return;
+      this.handleRoomMessage(event, room);
+    });
+    this.client.on(sdk.RoomMemberEvent.Membership, (event, member) => {
+      if (member.userId !== this.settings.userId)
+        return;
+      if (member.membership === "invite" && this.settings.autoJoin) {
+        const roomId = event.getRoomId();
+        if (roomId) {
+          logger.info(`Auto-joining room ${roomId}`);
+          this.client.joinRoom(roomId).catch((err) => {
+            logger.error(`Failed to auto-join room: ${err.message}`);
+          });
+        }
+      }
+    });
+  }
+  handleRoomMessage(event, room) {
+    const content = event.getContent();
+    const msgType = content.msgtype;
+    if (msgType !== "m.text")
+      return;
+    const roomId = event.getRoomId();
+    if (!roomId || !room)
+      return;
+    if (this.settings.requireMention) {
+      const body = content.body || "";
+      const localpart = getMatrixLocalpart(this.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: this.client.getAccountData("m.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
+    });
+  }
+  async connect() {
+    await this.client.startClient({ initialSyncLimit: 10 });
+    this.connected = true;
+    await new Promise((resolve) => {
+      const listener = (state) => {
+        if (state === "PREPARED") {
+          this.client.removeListener(sdk.ClientEvent.Sync, listener);
+          resolve();
+        }
+      };
+      this.client.on(sdk.ClientEvent.Sync, listener);
+    });
+    for (const room of this.settings.rooms) {
+      try {
+        await this.joinRoom(room);
+      } catch (err) {
+        logger.warn(`Failed to join room ${room}: ${err}`);
+      }
+    }
+  }
+  async stop() {
+    if (this.client) {
+      this.client.stopClient();
+    }
+    this.connected = false;
+    logger.info("Matrix service stopped");
+  }
+  isConnected() {
+    return this.connected && this.syncing;
+  }
+  getUserId() {
+    return this.settings.userId;
+  }
+  getHomeserver() {
+    return this.settings.homeserver;
+  }
+  async getJoinedRooms() {
+    const rooms = this.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) {
+    if (!this.isConnected()) {
+      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 this.client.getRoomIdForAlias(roomId);
+      resolvedRoomId = resolved.room_id;
+    }
+    const content = {
+      msgtype: "m.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 = "m.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 this.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
+    });
+    return {
+      success: true,
+      eventId,
+      roomId: resolvedRoomId
+    };
+  }
+  async sendReaction(roomId, eventId, emoji) {
+    if (!this.isConnected()) {
+      throw new MatrixNotConnectedError;
+    }
+    const content = {
+      "m.relates_to": {
+        rel_type: "m.annotation",
+        event_id: eventId,
+        key: emoji
+      }
+    };
+    const response = await this.client.sendEvent(roomId, "m.reaction", content);
+    return {
+      success: true,
+      eventId: response.event_id,
+      roomId
+    };
+  }
+  async joinRoom(roomIdOrAlias) {
+    if (!this.isConnected()) {
+      throw new MatrixNotConnectedError;
+    }
+    const response = await this.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
+    });
+    return roomId;
+  }
+  async leaveRoom(roomId) {
+    if (!this.isConnected()) {
+      throw new MatrixNotConnectedError;
+    }
+    await this.client.leave(roomId);
+    logger.info(`Left room ${roomId}`);
+    this.runtime.emitEvent("MATRIX_ROOM_LEFT" /* ROOM_LEFT */, {
+      roomId,
+      runtime: this.runtime
+    });
+  }
+  async sendTyping(roomId, typing, timeout = 30000) {
+    if (!this.isConnected()) {
+      return;
+    }
+    await this.client.sendTyping(roomId, typing, timeout);
+  }
+  async sendReadReceipt(roomId, eventId) {
+    if (!this.isConnected()) {
+      return;
+    }
+    await this.client.sendReadReceipt(new sdk.MatrixEvent({ event_id: eventId, room_id: roomId }));
+  }
+}
+// src/actions/sendMessage.ts
+import { composePromptFromState, ModelType, parseJSONObjectFromText } 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"
+}
+
+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 composePromptFromState({
+      template: SEND_MESSAGE_TEMPLATE,
+      state: composedState
+    });
+    let messageInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText(response);
+      if (parsed?.text) {
+        messageInfo = {
+          text: String(parsed.text),
+          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 composePromptFromState2, ModelType as ModelType2, parseJSONObjectFromText as parseJSONObjectFromText2 } 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"
+}
+
+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 composePromptFromState2({
+      template: SEND_REACTION_TEMPLATE,
+      state: composedState
+    });
+    let reactionInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response = await runtime.useModel(ModelType2.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText2(response);
+      if (parsed?.emoji && parsed?.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/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/joinRoom.ts
+import { composePromptFromState as composePromptFromState3, ModelType as ModelType3, parseJSONObjectFromText as parseJSONObjectFromText3 } 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" };
+    }
+    const composedState = state ?? {
+      values: {},
+      data: {},
+      text: ""
+    };
+    const prompt = await composePromptFromState3({
+      template: JOIN_ROOM_TEMPLATE,
+      state: composedState
+    });
+    let room = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response = await runtime.useModel(ModelType3.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText3(response);
+      if (parsed?.room) {
+        const roomStr = String(parsed.room).trim();
+        if (isValidMatrixRoomId(roomStr) || isValidMatrixRoomAlias(roomStr)) {
+          room = roomStr;
+          break;
+        }
+      }
+    }
+    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" };
+    }
+    try {
+      const roomId = await matrixService.joinRoom(room);
+      if (callback) {
+        await callback({
+          text: `Joined room ${room}.`,
+          source: message.content.source
+        });
+      }
+      return {
+        success: true,
+        data: {
+          roomId,
+          joined: room
+        }
+      };
+    } 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/providers/roomState.ts
+var roomStateProvider = {
+  name: "matrixRoomState",
+  description: "Provides information about the current Matrix room context",
+  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: { connected: false },
+        values: { connected: false },
+        text: ""
+      };
+    }
+    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 += `
+
+Matrix is a decentralized communication protocol. ${agentName} is logged in as ${userId}.`;
+    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
+    };
+  }
+};
+
+// src/providers/userContext.ts
+var userContextProvider = {
+  name: "matrixUserContext",
+  description: "Provides information about the Matrix user in the current conversation",
+  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.`;
+    return {
+      data: {
+        userId: senderInfo.userId,
+        displayName,
+        localpart,
+        avatarUrl: senderInfo.avatarUrl
+      },
+      values: {
+        userId: senderInfo.userId,
+        displayName,
+        localpart
+      },
+      text: responseText
+    };
+  }
+};
+
+// 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],
+  tests: [],
+  init: async (_config, runtime) => {
+    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 {
+  userContextProvider,
+  sendReaction,
+  sendMessage,
+  roomStateProvider,
+  matrixMxcToHttp,
+  listRooms,
+  joinRoom,
+  isValidMatrixUserId,
+  isValidMatrixRoomId,
+  isValidMatrixRoomAlias,
+  getMatrixUserDisplayName,
+  getMatrixServerpart,
+  getMatrixLocalpart,
+  src_default as default,
+  MatrixServiceNotInitializedError,
+  MatrixService,
+  MatrixPluginError,
+  MatrixNotConnectedError,
+  MatrixEventTypes,
+  MatrixConfigurationError,
+  MatrixApiError,
+  MAX_MATRIX_MESSAGE_LENGTH,
+  MATRIX_SERVICE_NAME
+};
+
+//# debugId=35E58066575BB30D64756E2164756E21