@elizaos/plugin-signal 2.0.0-alpha

package/dist/index.js

@@ -0,0 +1,1488 @@
+// src/index.ts
+import { logger } from "@elizaos/core";
+
+// src/types.ts
+var SignalEventTypes;
+((SignalEventTypes2) => {
+  SignalEventTypes2["MESSAGE_RECEIVED"] = "SIGNAL_MESSAGE_RECEIVED";
+  SignalEventTypes2["MESSAGE_SENT"] = "SIGNAL_MESSAGE_SENT";
+  SignalEventTypes2["REACTION_RECEIVED"] = "SIGNAL_REACTION_RECEIVED";
+  SignalEventTypes2["GROUP_JOINED"] = "SIGNAL_GROUP_JOINED";
+  SignalEventTypes2["GROUP_LEFT"] = "SIGNAL_GROUP_LEFT";
+  SignalEventTypes2["TYPING_STARTED"] = "SIGNAL_TYPING_STARTED";
+  SignalEventTypes2["TYPING_STOPPED"] = "SIGNAL_TYPING_STOPPED";
+  SignalEventTypes2["READ_RECEIPT"] = "SIGNAL_READ_RECEIPT";
+})(SignalEventTypes ||= {});
+var SIGNAL_SERVICE_NAME = "signal";
+var ServiceType = {
+  SIGNAL: "signal"
+};
+
+class SignalPluginError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SignalPluginError";
+  }
+}
+
+class SignalServiceNotInitializedError extends SignalPluginError {
+  constructor() {
+    super("Signal service is not initialized", "SERVICE_NOT_INITIALIZED");
+    this.name = "SignalServiceNotInitializedError";
+  }
+}
+
+class SignalClientNotAvailableError extends SignalPluginError {
+  constructor() {
+    super("Signal client is not available", "CLIENT_NOT_AVAILABLE");
+    this.name = "SignalClientNotAvailableError";
+  }
+}
+
+class SignalConfigurationError extends SignalPluginError {
+  constructor(missingConfig) {
+    super(`Missing required configuration: ${missingConfig}`, "MISSING_CONFIG");
+    this.name = "SignalConfigurationError";
+  }
+}
+
+class SignalApiError extends SignalPluginError {
+  apiErrorCode;
+  constructor(message, apiErrorCode) {
+    super(message, "API_ERROR");
+    this.apiErrorCode = apiErrorCode;
+    this.name = "SignalApiError";
+  }
+}
+function normalizeE164(number) {
+  let cleaned = number.replace(/[^\d+]/g, "");
+  if (!cleaned.startsWith("+")) {
+    if (cleaned.length === 10) {
+      cleaned = `+1${cleaned}`;
+    } else if (cleaned.length === 11 && cleaned.startsWith("1")) {
+      cleaned = `+${cleaned}`;
+    } else {
+      cleaned = `+${cleaned}`;
+    }
+  }
+  if (!/^\+\d{7,15}$/.test(cleaned)) {
+    return null;
+  }
+  return cleaned;
+}
+function isValidE164(number) {
+  return /^\+\d{7,15}$/.test(number);
+}
+function isValidGroupId(id) {
+  return /^[A-Za-z0-9+/]+=*$/.test(id) && id.length >= 32;
+}
+function isValidUuid(uuid) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(uuid);
+}
+function getSignalContactDisplayName(contact) {
+  return contact.profileName || contact.name || contact.number;
+}
+var MAX_SIGNAL_MESSAGE_LENGTH = 4000;
+var MAX_SIGNAL_ATTACHMENT_SIZE = 100 * 1024 * 1024;
+
+// src/actions/listContacts.ts
+var listContacts = {
+  name: "SIGNAL_LIST_CONTACTS",
+  similes: [
+    "LIST_SIGNAL_CONTACTS",
+    "SHOW_CONTACTS",
+    "GET_CONTACTS",
+    "SIGNAL_CONTACTS"
+  ],
+  description: "List Signal contacts",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "signal";
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const signalService = runtime.getService(SIGNAL_SERVICE_NAME);
+    if (!signalService || !signalService.isServiceConnected()) {
+      await callback?.({
+        text: "Signal service is not available.",
+        source: "signal"
+      });
+      return { success: false, error: "Signal service not available" };
+    }
+    const contacts = await signalService.getContacts();
+    const activeContacts = contacts.filter((c) => !c.blocked).sort((a, b) => {
+      const nameA = getSignalContactDisplayName(a);
+      const nameB = getSignalContactDisplayName(b);
+      return nameA.localeCompare(nameB);
+    });
+    const contactList = activeContacts.map((c) => {
+      const name = getSignalContactDisplayName(c);
+      const number = c.number;
+      return `• ${name} (${number})`;
+    });
+    const response = {
+      text: `Found ${activeContacts.length} contacts:
+
+${contactList.join(`
+`)}`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:signal:action:list-contacts",
+      contactCount: activeContacts.length
+    }, "[SIGNAL_LIST_CONTACTS] Contacts listed");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        contactCount: activeContacts.length,
+        contacts: activeContacts.map((c) => ({
+          number: c.number,
+          name: getSignalContactDisplayName(c),
+          uuid: c.uuid
+        }))
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Show me my Signal contacts"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll list your Signal contacts.",
+          actions: ["SIGNAL_LIST_CONTACTS"]
+        }
+      }
+    ]
+  ]
+};
+var listContacts_default = listContacts;
+
+// src/actions/listGroups.ts
+var listGroups = {
+  name: "SIGNAL_LIST_GROUPS",
+  similes: ["LIST_SIGNAL_GROUPS", "SHOW_GROUPS", "GET_GROUPS", "SIGNAL_GROUPS"],
+  description: "List Signal groups",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "signal";
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const signalService = runtime.getService(SIGNAL_SERVICE_NAME);
+    if (!signalService || !signalService.isServiceConnected()) {
+      await callback?.({
+        text: "Signal service is not available.",
+        source: "signal"
+      });
+      return { success: false, error: "Signal service not available" };
+    }
+    const groups = await signalService.getGroups();
+    const activeGroups = groups.filter((g) => g.isMember && !g.isBlocked).sort((a, b) => a.name.localeCompare(b.name));
+    const groupList = activeGroups.map((g) => {
+      const memberCount = g.members.length;
+      const description = g.description ? ` - ${g.description.slice(0, 50)}${g.description.length > 50 ? "..." : ""}` : "";
+      return `• ${g.name} (${memberCount} members)${description}`;
+    });
+    const response = {
+      text: `Found ${activeGroups.length} groups:
+
+${groupList.join(`
+`)}`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:signal:action:list-groups",
+      groupCount: activeGroups.length
+    }, "[SIGNAL_LIST_GROUPS] Groups listed");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        groupCount: activeGroups.length,
+        groups: activeGroups.map((g) => ({
+          id: g.id,
+          name: g.name,
+          description: g.description,
+          memberCount: g.members.length
+        }))
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Show me my Signal groups"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll list your Signal groups.",
+          actions: ["SIGNAL_LIST_GROUPS"]
+        }
+      }
+    ]
+  ]
+};
+var listGroups_default = listGroups;
+
+// src/actions/sendMessage.ts
+import {
+  composePromptFromState,
+  ModelType,
+  parseJSONObjectFromText
+} from "@elizaos/core";
+var sendMessageTemplate = `You are helping to extract send message parameters for Signal.
+
+The user wants to send a message to a Signal contact or group.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. text: The message text to send
+2. recipient: The phone number (E.164 format like +1234567890) or group ID to send to (default: "current" for current conversation)
+
+Respond with a JSON object like:
+{
+  "text": "The message to send",
+  "recipient": "current"
+}
+
+Only respond with the JSON object, no other text.`;
+var sendMessage = {
+  name: "SIGNAL_SEND_MESSAGE",
+  similes: [
+    "SEND_SIGNAL_MESSAGE",
+    "TEXT_SIGNAL",
+    "MESSAGE_SIGNAL",
+    "SIGNAL_TEXT"
+  ],
+  description: "Send a message to a Signal contact or group",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "signal";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const signalService = runtime.getService(SIGNAL_SERVICE_NAME);
+    if (!signalService || !signalService.isServiceConnected()) {
+      await callback?.({
+        text: "Signal service is not available.",
+        source: "signal"
+      });
+      return { success: false, error: "Signal service not available" };
+    }
+    const composedState = state ?? {
+      values: {},
+      data: {},
+      text: ""
+    };
+    const prompt = composePromptFromState({
+      state: composedState,
+      template: sendMessageTemplate
+    });
+    let messageInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText(response2);
+      if (parsedResponse?.text) {
+        messageInfo = {
+          text: String(parsedResponse.text),
+          recipient: parsedResponse.recipient ? String(parsedResponse.recipient) : "current"
+        };
+        break;
+      }
+    }
+    if (!messageInfo || !messageInfo.text) {
+      await callback?.({
+        text: "I couldn't understand what message you want me to send. Please try again with a clearer request.",
+        source: "signal"
+      });
+      return { success: false, error: "Could not extract message parameters" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    if (!room) {
+      await callback?.({
+        text: "I couldn't determine the current conversation.",
+        source: "signal"
+      });
+      return { success: false, error: "Could not determine conversation" };
+    }
+    let targetRecipient = room.channelId || "";
+    const isGroup = room.metadata?.isGroup || false;
+    if (messageInfo.recipient && messageInfo.recipient !== "current") {
+      const normalized = normalizeE164(messageInfo.recipient);
+      if (normalized) {
+        targetRecipient = normalized;
+      } else if (isValidGroupId(messageInfo.recipient)) {
+        targetRecipient = messageInfo.recipient;
+      }
+    }
+    let result;
+    if (isGroup || isValidGroupId(targetRecipient)) {
+      result = await signalService.sendGroupMessage(targetRecipient, messageInfo.text);
+    } else {
+      result = await signalService.sendMessage(targetRecipient, messageInfo.text);
+    }
+    const response = {
+      text: "Message sent successfully.",
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:signal:action:send-message",
+      timestamp: result.timestamp,
+      recipient: targetRecipient
+    }, "[SIGNAL_SEND_MESSAGE] Message sent successfully");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        timestamp: result.timestamp,
+        recipient: targetRecipient
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Send a message to +1234567890 saying 'Hello!'"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll send that message for you.",
+          actions: ["SIGNAL_SEND_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var sendMessage_default = sendMessage;
+
+// src/actions/sendReaction.ts
+import {
+  composePromptFromState as composePromptFromState2,
+  ModelType as ModelType2,
+  parseJSONObjectFromText as parseJSONObjectFromText2
+} from "@elizaos/core";
+var sendReactionTemplate = `You are helping to extract reaction parameters for Signal.
+
+The user wants to react to a Signal message with an emoji.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. emoji: The emoji to react with (single emoji character)
+2. targetTimestamp: The timestamp of the message to react to (number)
+3. targetAuthor: The phone number of the message author
+4. remove: Whether to remove the reaction instead of adding it (default: false)
+
+Respond with a JSON object like:
+{
+  "emoji": "\uD83D\uDC4D",
+  "targetTimestamp": 1234567890000,
+  "targetAuthor": "+1234567890",
+  "remove": false
+}
+
+Only respond with the JSON object, no other text.`;
+var sendReaction = {
+  name: "SIGNAL_SEND_REACTION",
+  similes: [
+    "REACT_SIGNAL",
+    "SIGNAL_REACT",
+    "ADD_SIGNAL_REACTION",
+    "SIGNAL_EMOJI"
+  ],
+  description: "React to a Signal message with an emoji",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "signal";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const signalService = runtime.getService(SIGNAL_SERVICE_NAME);
+    if (!signalService || !signalService.isServiceConnected()) {
+      await callback?.({
+        text: "Signal service is not available.",
+        source: "signal"
+      });
+      return { success: false, error: "Signal service not available" };
+    }
+    const composedState = state ?? {
+      values: {},
+      data: {},
+      text: ""
+    };
+    const prompt = composePromptFromState2({
+      state: composedState,
+      template: sendReactionTemplate
+    });
+    let reactionInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType2.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText2(response2);
+      if (parsedResponse?.emoji && parsedResponse?.targetTimestamp && parsedResponse?.targetAuthor) {
+        reactionInfo = {
+          emoji: String(parsedResponse.emoji),
+          targetTimestamp: Number(parsedResponse.targetTimestamp),
+          targetAuthor: String(parsedResponse.targetAuthor),
+          remove: Boolean(parsedResponse.remove)
+        };
+        break;
+      }
+    }
+    if (!reactionInfo) {
+      await callback?.({
+        text: "I couldn't understand the reaction request. Please specify the emoji and message to react to.",
+        source: "signal"
+      });
+      return { success: false, error: "Could not extract reaction parameters" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    const recipient = room?.channelId || reactionInfo.targetAuthor;
+    if (reactionInfo.remove) {
+      await signalService.removeReaction(recipient, reactionInfo.emoji, reactionInfo.targetTimestamp, reactionInfo.targetAuthor);
+    } else {
+      await signalService.sendReaction(recipient, reactionInfo.emoji, reactionInfo.targetTimestamp, reactionInfo.targetAuthor);
+    }
+    const actionWord = reactionInfo.remove ? "removed" : "added";
+    const response = {
+      text: `Reaction ${reactionInfo.emoji} ${actionWord} successfully.`,
+      source: message.content.source
+    };
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        emoji: reactionInfo.emoji,
+        targetTimestamp: reactionInfo.targetTimestamp,
+        targetAuthor: reactionInfo.targetAuthor,
+        action: actionWord
+      }
+    };
+  },
+  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: ["SIGNAL_SEND_REACTION"]
+        }
+      }
+    ]
+  ]
+};
+var sendReaction_default = sendReaction;
+
+// src/providers/conversationState.ts
+var conversationStateProvider = {
+  name: "signalConversationState",
+  description: "Provides information about the current Signal conversation context",
+  get: async (runtime, message, state) => {
+    const room = state.data?.room ?? await runtime.getRoom(message.roomId);
+    if (!room) {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    if (message.content.source !== "signal") {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const agentName = String(state?.agentName || "The agent");
+    const senderName = String(state?.senderName || "someone");
+    let responseText = "";
+    let conversationType = "";
+    let contactName = "";
+    let groupName = "";
+    const channelId = room.channelId ?? "";
+    const signalService = runtime.getService(ServiceType.SIGNAL);
+    if (!signalService || !signalService.isServiceConnected()) {
+      return {
+        data: {
+          room,
+          conversationType: "unknown",
+          channelId
+        },
+        values: {
+          conversationType: "unknown",
+          channelId
+        },
+        text: ""
+      };
+    }
+    const isGroup = room.metadata?.isGroup || false;
+    if (isGroup) {
+      conversationType = "GROUP";
+      const groupId = room.metadata?.groupId;
+      const group = signalService.getCachedGroup(groupId);
+      groupName = group?.name || room.name || "Unknown Group";
+      responseText = `${agentName} is currently in a Signal group chat: "${groupName}".`;
+      responseText += `
+${agentName} should be aware that multiple people can see this conversation and should participate when relevant.`;
+      if (group?.description) {
+        responseText += `
+Group description: ${group.description}`;
+      }
+    } else {
+      conversationType = "DM";
+      const contact = signalService.getContact(channelId);
+      contactName = contact ? String(getSignalContactDisplayName(contact)) : senderName;
+      responseText = `${agentName} is currently in a direct message conversation with ${contactName} on Signal.`;
+      responseText += `
+${agentName} should engage naturally in conversation, responding to messages addressed to them.`;
+    }
+    responseText += `
+
+Signal is an encrypted messaging platform, so all messages are secure and private.`;
+    return {
+      data: {
+        room,
+        conversationType,
+        contactName,
+        groupName,
+        channelId,
+        isGroup,
+        accountNumber: signalService.getAccountNumber()
+      },
+      values: {
+        conversationType,
+        contactName,
+        groupName,
+        channelId,
+        isGroup
+      },
+      text: responseText
+    };
+  }
+};
+
+// src/service.ts
+import {
+  ChannelType,
+  createUniqueUuid,
+  Service,
+  stringToUuid
+} from "@elizaos/core";
+var getMessageService = (runtime) => {
+  if ("messageService" in runtime) {
+    const withMessageService = runtime;
+    return withMessageService.messageService ?? null;
+  }
+  return null;
+};
+
+class SignalApiClient {
+  baseUrl;
+  accountNumber;
+  constructor(baseUrl, accountNumber) {
+    this.baseUrl = baseUrl;
+    this.accountNumber = accountNumber;
+  }
+  async request(method, endpoint, body) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const options = {
+      method,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Signal API error: ${response.status} - ${errorText}`);
+    }
+    const text = await response.text();
+    return text ? JSON.parse(text) : {};
+  }
+  async sendMessage(recipient, message, options) {
+    const body = {
+      message,
+      number: this.accountNumber,
+      recipients: [recipient]
+    };
+    if (options?.attachments) {
+      body.base64_attachments = options.attachments;
+    }
+    if (options?.quote) {
+      body.quote_timestamp = options.quote.timestamp;
+      body.quote_author = options.quote.author;
+    }
+    return this.request("POST", "/v2/send", body);
+  }
+  async sendGroupMessage(groupId, message, options) {
+    const body = {
+      message,
+      number: this.accountNumber,
+      recipients: [`group.${groupId}`]
+    };
+    if (options?.attachments) {
+      body.base64_attachments = options.attachments;
+    }
+    return this.request("POST", "/v2/send", body);
+  }
+  async sendReaction(recipient, emoji, targetTimestamp, targetAuthor, remove = false) {
+    await this.request("POST", `/v1/reactions/${this.accountNumber}`, {
+      recipient,
+      reaction: emoji,
+      target_author: targetAuthor,
+      timestamp: targetTimestamp,
+      remove
+    });
+  }
+  async getContacts() {
+    const result = await this.request("GET", `/v1/contacts/${this.accountNumber}`);
+    return result.contacts || [];
+  }
+  async getGroups() {
+    const result = await this.request("GET", `/v1/groups/${this.accountNumber}`);
+    return result || [];
+  }
+  async getGroup(groupId) {
+    const groups = await this.getGroups();
+    return groups.find((g) => g.id === groupId) || null;
+  }
+  async receive() {
+    const result = await this.request("GET", `/v1/receive/${this.accountNumber}`);
+    return result || [];
+  }
+  async sendTyping(recipient, stop = false) {
+    await this.request("PUT", `/v1/typing-indicator/${this.accountNumber}`, {
+      recipient,
+      stop
+    });
+  }
+  async setProfile(name, about) {
+    await this.request("PUT", `/v1/profiles/${this.accountNumber}`, {
+      name,
+      about: about || ""
+    });
+  }
+  async getIdentities() {
+    const result = await this.request("GET", `/v1/identities/${this.accountNumber}`);
+    return result || [];
+  }
+  async trustIdentity(number, trustLevel) {
+    await this.request("PUT", `/v1/identities/${this.accountNumber}/trust/${number}`, {
+      trust_level: trustLevel
+    });
+  }
+}
+
+class SignalService extends Service {
+  static serviceType = SIGNAL_SERVICE_NAME;
+  capabilityDescription = "The agent is able to send and receive messages on Signal";
+  async stop() {
+    await this.shutdown();
+  }
+  character;
+  accountNumber = null;
+  isConnected = false;
+  client = null;
+  settings;
+  contactCache = new Map;
+  groupCache = new Map;
+  pollInterval = null;
+  isPolling = false;
+  constructor(runtime) {
+    super(runtime);
+    if (runtime) {
+      this.character = runtime.character;
+      this.settings = this.loadSettings();
+    } else {
+      this.character = {};
+      this.settings = {
+        shouldIgnoreGroupMessages: false,
+        allowedGroups: undefined,
+        blockedNumbers: undefined
+      };
+    }
+  }
+  loadSettings() {
+    const ignoreGroups = this.runtime.getSetting("SIGNAL_SHOULD_IGNORE_GROUP_MESSAGES");
+    return {
+      shouldIgnoreGroupMessages: ignoreGroups === "true" || ignoreGroups === true,
+      allowedGroups: undefined,
+      blockedNumbers: undefined
+    };
+  }
+  static async start(runtime) {
+    const service = new SignalService(runtime);
+    const accountNumber = runtime.getSetting("SIGNAL_ACCOUNT_NUMBER");
+    const httpUrl = runtime.getSetting("SIGNAL_HTTP_URL");
+    if (!accountNumber) {
+      runtime.logger.warn({ src: "plugin:signal", agentId: runtime.agentId }, "SIGNAL_ACCOUNT_NUMBER not provided, Signal service will not start");
+      return service;
+    }
+    const normalizedNumber = normalizeE164(accountNumber);
+    if (!normalizedNumber) {
+      runtime.logger.error({ src: "plugin:signal", agentId: runtime.agentId, accountNumber }, "Invalid SIGNAL_ACCOUNT_NUMBER format");
+      return service;
+    }
+    service.accountNumber = normalizedNumber;
+    if (httpUrl) {
+      service.client = new SignalApiClient(httpUrl, normalizedNumber);
+      await service.initialize();
+    } else {
+      runtime.logger.warn({ src: "plugin:signal", agentId: runtime.agentId }, "SIGNAL_HTTP_URL not provided, Signal service will not be able to communicate");
+    }
+    return service;
+  }
+  static async stop(runtime) {
+    const service = runtime.getService(SIGNAL_SERVICE_NAME);
+    if (service) {
+      await service.shutdown();
+    }
+  }
+  async initialize() {
+    if (!this.client)
+      return;
+    this.runtime.logger.info({
+      src: "plugin:signal",
+      agentId: this.runtime.agentId,
+      accountNumber: this.accountNumber
+    }, "Initializing Signal service");
+    const contacts = await this.client.getContacts();
+    this.runtime.logger.info({
+      src: "plugin:signal",
+      agentId: this.runtime.agentId,
+      contactCount: contacts.length
+    }, "Signal service connected");
+    for (const contact of contacts) {
+      this.contactCache.set(contact.number, contact);
+    }
+    const groups = await this.client.getGroups();
+    for (const group of groups) {
+      this.groupCache.set(group.id, group);
+    }
+    this.isConnected = true;
+    this.startPolling();
+  }
+  async shutdown() {
+    this.stopPolling();
+    this.client = null;
+    this.isConnected = false;
+    this.runtime.logger.info({ src: "plugin:signal", agentId: this.runtime.agentId }, "Signal service stopped");
+  }
+  startPolling() {
+    if (this.pollInterval)
+      return;
+    this.pollInterval = setInterval(async () => {
+      await this.pollMessages();
+    }, 2000);
+  }
+  stopPolling() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+  }
+  async pollMessages() {
+    if (!this.client || this.isPolling)
+      return;
+    this.isPolling = true;
+    const messages = await this.client.receive();
+    for (const msg of messages) {
+      await this.handleIncomingMessage(msg);
+    }
+    this.isPolling = false;
+  }
+  async handleIncomingMessage(msg) {
+    if (msg.reaction) {
+      await this.handleReaction(msg);
+      return;
+    }
+    if (!msg.message && msg.attachments.length === 0) {
+      return;
+    }
+    const isGroupMessage = Boolean(msg.groupId);
+    if (isGroupMessage && this.settings.shouldIgnoreGroupMessages) {
+      return;
+    }
+    const memory = await this.buildMemoryFromMessage(msg);
+    if (!memory)
+      return;
+    const room = await this.ensureRoomExists(msg.sender, msg.groupId);
+    await this.runtime.createMemory(memory, "messages");
+    await this.runtime.emitEvent("SIGNAL_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
+      runtime: this.runtime,
+      source: "signal"
+    });
+    await this.processMessage(memory, room, msg.sender, msg.groupId);
+  }
+  async handleReaction(msg) {
+    if (!msg.reaction)
+      return;
+    await this.runtime.emitEvent("SIGNAL_REACTION_RECEIVED" /* REACTION_RECEIVED */, {
+      runtime: this.runtime,
+      source: "signal"
+    });
+  }
+  async processMessage(memory, room, sender, groupId) {
+    const callback = async (response) => {
+      if (groupId) {
+        await this.sendGroupMessage(groupId, response.text || "");
+      } else {
+        await this.sendMessage(sender, response.text || "");
+      }
+      const responseMemory = {
+        id: createUniqueUuid(this.runtime, `signal-response-${Date.now()}`),
+        agentId: this.runtime.agentId,
+        roomId: room.id,
+        entityId: this.runtime.agentId,
+        content: {
+          text: response.text || "",
+          source: "signal",
+          inReplyTo: memory.id
+        },
+        createdAt: Date.now()
+      };
+      await this.runtime.createMemory(responseMemory, "messages");
+      await this.runtime.emitEvent("SIGNAL_MESSAGE_SENT" /* MESSAGE_SENT */, {
+        runtime: this.runtime,
+        source: "signal"
+      });
+      return [responseMemory];
+    };
+    const messageService = getMessageService(this.runtime);
+    if (messageService) {
+      await messageService.handleMessage(this.runtime, memory, callback);
+    }
+  }
+  async buildMemoryFromMessage(msg) {
+    const roomId = await this.getRoomId(msg.sender, msg.groupId);
+    const entityId = this.getEntityId(msg.sender);
+    const contact = this.contactCache.get(msg.sender);
+    const displayName = contact ? getSignalContactDisplayName(contact) : msg.sender;
+    const media = msg.attachments.map((att) => ({
+      id: att.id,
+      url: `signal://attachment/${att.id}`,
+      title: att.filename || att.id,
+      source: "signal",
+      description: att.caption || att.filename,
+      contentType: att.contentType
+    }));
+    const memory = {
+      id: createUniqueUuid(this.runtime, `signal-${msg.timestamp}`),
+      agentId: this.runtime.agentId,
+      roomId,
+      entityId,
+      content: {
+        text: msg.message || "",
+        source: "signal",
+        name: displayName,
+        ...media.length > 0 ? { attachments: media } : {}
+      },
+      createdAt: msg.timestamp
+    };
+    return memory;
+  }
+  async getRoomId(sender, groupId) {
+    const roomKey = groupId || sender;
+    return createUniqueUuid(this.runtime, `signal-room-${roomKey}`);
+  }
+  getEntityId(number) {
+    return stringToUuid(`signal-user-${number}`);
+  }
+  async ensureRoomExists(sender, groupId) {
+    const roomId = await this.getRoomId(sender, groupId);
+    const existingRoom = await this.runtime.getRoom(roomId);
+    if (existingRoom)
+      return existingRoom;
+    const isGroup = Boolean(groupId);
+    const group = groupId ? this.groupCache.get(groupId) : null;
+    const contact = this.contactCache.get(sender);
+    const room = {
+      id: roomId,
+      name: isGroup ? group?.name || `Signal Group ${groupId}` : contact ? getSignalContactDisplayName(contact) : sender,
+      agentId: this.runtime.agentId,
+      source: "signal",
+      type: isGroup ? ChannelType.GROUP : ChannelType.DM,
+      channelId: groupId || sender,
+      metadata: {
+        isGroup,
+        groupId,
+        sender,
+        groupName: group?.name,
+        groupDescription: group?.description
+      }
+    };
+    await this.runtime.createRoom(room);
+    return room;
+  }
+  async sendMessage(recipient, text, options) {
+    if (!this.client) {
+      throw new Error("Signal client not initialized");
+    }
+    const normalizedRecipient = normalizeE164(recipient);
+    if (!normalizedRecipient) {
+      throw new Error(`Invalid recipient number: ${recipient}`);
+    }
+    const messages = this.splitMessage(text);
+    let lastTimestamp = 0;
+    for (const msg of messages) {
+      const result = await this.client.sendMessage(normalizedRecipient, msg, options);
+      lastTimestamp = result.timestamp;
+    }
+    return { timestamp: lastTimestamp };
+  }
+  async sendGroupMessage(groupId, text, options) {
+    if (!this.client) {
+      throw new Error("Signal client not initialized");
+    }
+    const messages = this.splitMessage(text);
+    let lastTimestamp = 0;
+    for (const msg of messages) {
+      const result = await this.client.sendGroupMessage(groupId, msg, options);
+      lastTimestamp = result.timestamp;
+    }
+    return { timestamp: lastTimestamp };
+  }
+  async sendReaction(recipient, emoji, targetTimestamp, targetAuthor) {
+    if (!this.client) {
+      throw new Error("Signal client not initialized");
+    }
+    await this.client.sendReaction(recipient, emoji, targetTimestamp, targetAuthor);
+  }
+  async removeReaction(recipient, emoji, targetTimestamp, targetAuthor) {
+    if (!this.client) {
+      throw new Error("Signal client not initialized");
+    }
+    await this.client.sendReaction(recipient, emoji, targetTimestamp, targetAuthor, true);
+  }
+  async getContacts() {
+    if (!this.client) {
+      throw new Error("Signal client not initialized");
+    }
+    const contacts = await this.client.getContacts();
+    for (const contact of contacts) {
+      this.contactCache.set(contact.number, contact);
+    }
+    return contacts;
+  }
+  async getGroups() {
+    if (!this.client) {
+      throw new Error("Signal client not initialized");
+    }
+    const groups = await this.client.getGroups();
+    for (const group of groups) {
+      this.groupCache.set(group.id, group);
+    }
+    return groups;
+  }
+  async getGroup(groupId) {
+    if (!this.client) {
+      throw new Error("Signal client not initialized");
+    }
+    const group = await this.client.getGroup(groupId);
+    if (group) {
+      this.groupCache.set(group.id, group);
+    }
+    return group;
+  }
+  async sendTypingIndicator(recipient) {
+    if (!this.client)
+      return;
+    await this.client.sendTyping(recipient);
+  }
+  async stopTypingIndicator(recipient) {
+    if (!this.client)
+      return;
+    await this.client.sendTyping(recipient, true);
+  }
+  splitMessage(text) {
+    if (text.length <= MAX_SIGNAL_MESSAGE_LENGTH) {
+      return [text];
+    }
+    const messages = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+      if (remaining.length <= MAX_SIGNAL_MESSAGE_LENGTH) {
+        messages.push(remaining);
+        break;
+      }
+      let splitIndex = MAX_SIGNAL_MESSAGE_LENGTH;
+      const lastNewline = remaining.lastIndexOf(`
+`, MAX_SIGNAL_MESSAGE_LENGTH);
+      if (lastNewline > MAX_SIGNAL_MESSAGE_LENGTH / 2) {
+        splitIndex = lastNewline + 1;
+      } else {
+        const lastSpace = remaining.lastIndexOf(" ", MAX_SIGNAL_MESSAGE_LENGTH);
+        if (lastSpace > MAX_SIGNAL_MESSAGE_LENGTH / 2) {
+          splitIndex = lastSpace + 1;
+        }
+      }
+      messages.push(remaining.slice(0, splitIndex));
+      remaining = remaining.slice(splitIndex);
+    }
+    return messages;
+  }
+  getContact(number) {
+    return this.contactCache.get(number) || null;
+  }
+  getCachedGroup(groupId) {
+    return this.groupCache.get(groupId) || null;
+  }
+  getAccountNumber() {
+    return this.accountNumber;
+  }
+  isServiceConnected() {
+    return this.isConnected;
+  }
+}
+
+// src/accounts.ts
+var DEFAULT_ACCOUNT_ID = "default";
+function normalizeAccountId(accountId) {
+  if (!accountId || typeof accountId !== "string") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  const trimmed = accountId.trim().toLowerCase();
+  return trimmed || DEFAULT_ACCOUNT_ID;
+}
+function getMultiAccountConfig(runtime) {
+  const characterSignal = runtime.character?.settings?.signal;
+  return {
+    enabled: characterSignal?.enabled,
+    account: characterSignal?.account,
+    httpUrl: characterSignal?.httpUrl,
+    accounts: characterSignal?.accounts
+  };
+}
+function listSignalAccountIds(runtime) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  const ids = Object.keys(accounts).filter(Boolean);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return ids.toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultSignalAccountId(runtime) {
+  const ids = listSignalAccountIds(runtime);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function getAccountConfig(runtime, accountId) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return;
+  }
+  return accounts[accountId];
+}
+function filterDefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+function mergeSignalAccountConfig(runtime, accountId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const { accounts: _ignored, ...baseConfig } = multiConfig;
+  const accountConfig = getAccountConfig(runtime, accountId) ?? {};
+  const envAccount = runtime.getSetting("SIGNAL_ACCOUNT_NUMBER");
+  const envHttpUrl = runtime.getSetting("SIGNAL_HTTP_URL");
+  const envCliPath = runtime.getSetting("SIGNAL_CLI_PATH");
+  const envIgnoreGroups = runtime.getSetting("SIGNAL_SHOULD_IGNORE_GROUP_MESSAGES");
+  const envConfig = {
+    account: envAccount || undefined,
+    httpUrl: envHttpUrl || undefined,
+    cliPath: envCliPath || undefined,
+    shouldIgnoreGroupMessages: envIgnoreGroups?.toLowerCase() === "true"
+  };
+  return {
+    ...filterDefined(envConfig),
+    ...filterDefined(baseConfig),
+    ...filterDefined(accountConfig)
+  };
+}
+function resolveBaseUrl(config) {
+  if (config.httpUrl?.trim()) {
+    return config.httpUrl.trim().replace(/\/+$/, "");
+  }
+  const host = config.httpHost?.trim() || "127.0.0.1";
+  const port = config.httpPort ?? 8080;
+  return `http://${host}:${port}`;
+}
+function resolveSignalAccount(runtime, accountId) {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const multiConfig = getMultiAccountConfig(runtime);
+  const baseEnabled = multiConfig.enabled !== false;
+  const merged = mergeSignalAccountConfig(runtime, normalizedAccountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const baseUrl = resolveBaseUrl(merged);
+  const configured = Boolean(merged.account?.trim() || merged.httpUrl?.trim() || merged.cliPath?.trim() || merged.httpHost?.trim() || typeof merged.httpPort === "number" || typeof merged.autoStart === "boolean");
+  return {
+    accountId: normalizedAccountId,
+    enabled,
+    name: merged.name?.trim() || undefined,
+    account: merged.account?.trim(),
+    baseUrl,
+    configured,
+    config: merged
+  };
+}
+function listEnabledSignalAccounts(runtime) {
+  return listSignalAccountIds(runtime).map((accountId) => resolveSignalAccount(runtime, accountId)).filter((account) => account.enabled && account.configured);
+}
+function isMultiAccountEnabled(runtime) {
+  const accounts = listEnabledSignalAccounts(runtime);
+  return accounts.length > 1;
+}
+// src/rpc.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+function normalizeBaseUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    throw new Error("Signal base URL is required");
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed.replace(/\/+$/, "");
+  }
+  return `http://${trimmed}`.replace(/\/+$/, "");
+}
+function generateId() {
+  return crypto.randomUUID();
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function signalRpcRequest(method, params, opts) {
+  const baseUrl = normalizeBaseUrl(opts.baseUrl);
+  const id = generateId();
+  const body = JSON.stringify({
+    jsonrpc: "2.0",
+    method,
+    params,
+    id
+  });
+  const res = await fetchWithTimeout(`${baseUrl}/api/v1/rpc`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body
+  }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  if (res.status === 201) {
+    return;
+  }
+  const text = await res.text();
+  if (!text) {
+    throw new Error(`Signal RPC empty response (status ${res.status})`);
+  }
+  const parsed = JSON.parse(text);
+  if (parsed.error) {
+    const code = parsed.error.code ?? "unknown";
+    const msg = parsed.error.message ?? "Signal RPC error";
+    throw new Error(`Signal RPC ${code}: ${msg}`);
+  }
+  return parsed.result;
+}
+async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const normalized = normalizeBaseUrl(baseUrl);
+  try {
+    const res = await fetchWithTimeout(`${normalized}/api/v1/check`, { method: "GET" }, timeoutMs);
+    if (!res.ok) {
+      return { ok: false, status: res.status, error: `HTTP ${res.status}` };
+    }
+    return { ok: true, status: res.status, error: null };
+  } catch (err) {
+    return {
+      ok: false,
+      status: null,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function signalGetVersion(opts) {
+  return signalRpcRequest("version", undefined, opts);
+}
+async function signalListAccounts(opts) {
+  return signalRpcRequest("listAccounts", undefined, opts);
+}
+async function signalListContacts(account, opts) {
+  return signalRpcRequest("listContacts", { account }, opts);
+}
+async function signalListGroups(account, opts) {
+  return signalRpcRequest("listGroups", { account }, opts);
+}
+async function signalSend(params, opts) {
+  return signalRpcRequest("send", params, opts);
+}
+async function signalSendReaction(params, opts) {
+  return signalRpcRequest("sendReaction", params, opts);
+}
+async function signalSendTyping(params, opts) {
+  return signalRpcRequest("sendTyping", params, opts);
+}
+async function signalSendReadReceipt(params, opts) {
+  return signalRpcRequest("sendReadReceipt", params, opts);
+}
+async function streamSignalEvents(params) {
+  const baseUrl = normalizeBaseUrl(params.baseUrl);
+  const url = new URL(`${baseUrl}/api/v1/events`);
+  if (params.account) {
+    url.searchParams.set("account", params.account);
+  }
+  const res = await fetch(url, {
+    method: "GET",
+    headers: { Accept: "text/event-stream" },
+    signal: params.abortSignal
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(`Signal SSE failed (${res.status} ${res.statusText || "error"})`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let currentEvent = {};
+  const flushEvent = () => {
+    if (!currentEvent.data && !currentEvent.event && !currentEvent.id) {
+      return;
+    }
+    params.onEvent({
+      event: currentEvent.event,
+      data: currentEvent.data,
+      id: currentEvent.id
+    });
+    currentEvent = {};
+  };
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    let lineEnd = buffer.indexOf(`
+`);
+    while (lineEnd !== -1) {
+      let line = buffer.slice(0, lineEnd);
+      buffer = buffer.slice(lineEnd + 1);
+      if (line.endsWith("\r")) {
+        line = line.slice(0, -1);
+      }
+      if (line === "") {
+        flushEvent();
+        lineEnd = buffer.indexOf(`
+`);
+        continue;
+      }
+      if (line.startsWith(":")) {
+        lineEnd = buffer.indexOf(`
+`);
+        continue;
+      }
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1) {
+        lineEnd = buffer.indexOf(`
+`);
+        continue;
+      }
+      const field = line.slice(0, colonIndex).trim();
+      let value2 = line.slice(colonIndex + 1);
+      if (value2.startsWith(" ")) {
+        value2 = value2.slice(1);
+      }
+      if (field === "event") {
+        currentEvent.event = value2;
+      } else if (field === "data") {
+        currentEvent.data = currentEvent.data ? `${currentEvent.data}
+${value2}` : value2;
+      } else if (field === "id") {
+        currentEvent.id = value2;
+      }
+      lineEnd = buffer.indexOf(`
+`);
+    }
+  }
+  flushEvent();
+}
+function parseSignalEventData(data) {
+  if (!data) {
+    return null;
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function createSignalEventStream(params) {
+  let abortController = null;
+  let running = false;
+  let reconnectDelay = params.reconnectDelayMs ?? 1000;
+  const maxDelay = params.maxReconnectDelayMs ?? 30000;
+  const connect = async () => {
+    if (!running) {
+      return;
+    }
+    abortController = new AbortController;
+    try {
+      params.onConnect?.();
+      reconnectDelay = params.reconnectDelayMs ?? 1000;
+      await streamSignalEvents({
+        baseUrl: params.baseUrl,
+        account: params.account,
+        abortSignal: abortController.signal,
+        onEvent: params.onEvent
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      params.onError?.(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      params.onDisconnect?.();
+    }
+    if (running) {
+      setTimeout(connect, reconnectDelay);
+      reconnectDelay = Math.min(reconnectDelay * 2, maxDelay);
+    }
+  };
+  return {
+    start: () => {
+      if (running) {
+        return;
+      }
+      running = true;
+      connect();
+    },
+    stop: () => {
+      running = false;
+      abortController?.abort();
+      abortController = null;
+    },
+    isRunning: () => running
+  };
+}
+
+// src/index.ts
+var signalPlugin = {
+  name: "signal",
+  description: "Signal messaging integration plugin for ElizaOS with end-to-end encryption",
+  services: [SignalService],
+  actions: [sendMessage_default, sendReaction_default, listContacts_default, listGroups_default],
+  providers: [conversationStateProvider],
+  init: async (_config, runtime) => {
+    const accountNumber = runtime.getSetting("SIGNAL_ACCOUNT_NUMBER");
+    const httpUrl = runtime.getSetting("SIGNAL_HTTP_URL");
+    const cliPath = runtime.getSetting("SIGNAL_CLI_PATH");
+    const ignoreGroups = runtime.getSetting("SIGNAL_SHOULD_IGNORE_GROUP_MESSAGES");
+    const maskNumber = (number) => {
+      if (!number || number.trim() === "")
+        return "[not set]";
+      if (number.length <= 6)
+        return "***";
+      return `${number.slice(0, 3)}...${number.slice(-2)}`;
+    };
+    logger.info({
+      src: "plugin:signal",
+      agentId: runtime.agentId,
+      settings: {
+        accountNumber: maskNumber(accountNumber),
+        httpUrl: httpUrl || "[not set]",
+        cliPath: cliPath || "[not set]",
+        ignoreGroups: ignoreGroups || "false"
+      }
+    }, "Signal plugin initializing");
+    if (!accountNumber || accountNumber.trim() === "") {
+      logger.warn({ src: "plugin:signal", agentId: runtime.agentId }, "SIGNAL_ACCOUNT_NUMBER not provided - Signal plugin is loaded but will not be functional");
+      return;
+    }
+    const normalizedNumber = normalizeE164(accountNumber);
+    if (!normalizedNumber) {
+      logger.error({ src: "plugin:signal", agentId: runtime.agentId, accountNumber }, "SIGNAL_ACCOUNT_NUMBER is not a valid E.164 phone number");
+      return;
+    }
+    if (!httpUrl && !cliPath) {
+      logger.warn({ src: "plugin:signal", agentId: runtime.agentId }, "Neither SIGNAL_HTTP_URL nor SIGNAL_CLI_PATH provided - Signal plugin will not be able to communicate");
+      return;
+    }
+    logger.info({ src: "plugin:signal", agentId: runtime.agentId }, "Signal plugin configuration validated successfully");
+  }
+};
+var src_default = signalPlugin;
+export {
+  streamSignalEvents,
+  signalSendTyping,
+  signalSendReadReceipt,
+  signalSendReaction,
+  signalSend,
+  signalRpcRequest,
+  signalListGroups,
+  signalListContacts,
+  signalListAccounts,
+  signalGetVersion,
+  signalCheck,
+  sendReaction,
+  sendMessage,
+  resolveSignalAccount,
+  resolveDefaultSignalAccountId,
+  parseSignalEventData,
+  normalizeE164,
+  normalizeBaseUrl,
+  normalizeAccountId,
+  listSignalAccountIds,
+  listGroups,
+  listEnabledSignalAccounts,
+  listContacts,
+  isValidUuid,
+  isValidGroupId,
+  isValidE164,
+  isMultiAccountEnabled,
+  getSignalContactDisplayName,
+  src_default as default,
+  createSignalEventStream,
+  conversationStateProvider,
+  SignalServiceNotInitializedError,
+  SignalService,
+  SignalPluginError,
+  SignalEventTypes,
+  SignalConfigurationError,
+  SignalClientNotAvailableError,
+  SignalApiError,
+  SIGNAL_SERVICE_NAME,
+  MAX_SIGNAL_MESSAGE_LENGTH,
+  MAX_SIGNAL_ATTACHMENT_SIZE,
+  DEFAULT_ACCOUNT_ID
+};
+
+//# debugId=35D8D7AB25F728BD64756E2164756E21