@skillkit/messaging 1.8.0

package/dist/index.js

@@ -0,0 +1,854 @@
+// src/types.ts
+var DEFAULT_MESSAGING_CONFIG = {
+  maxInboxSize: 1e3,
+  retentionDays: 30
+};
+
+// src/storage/inbox.ts
+import { readFile, writeFile, mkdir, readdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var InboxStorage = class {
+  basePath;
+  constructor(agentId, basePath) {
+    this.basePath = basePath ?? join(homedir(), ".skillkit", "messages", "inbox", agentId);
+  }
+  async initialize() {
+    await mkdir(this.basePath, { recursive: true });
+  }
+  async save(message) {
+    const filePath = this.getMessagePath(message.id);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(message, null, 2), "utf-8");
+  }
+  async get(messageId) {
+    const filePath = this.getMessagePath(messageId);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async delete(messageId) {
+    const filePath = this.getMessagePath(messageId);
+    if (!existsSync(filePath)) {
+      return false;
+    }
+    try {
+      await unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list(filter = {}) {
+    if (!existsSync(this.basePath)) {
+      return [];
+    }
+    const files = await readdir(this.basePath);
+    const messages = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const filePath = join(this.basePath, file);
+      try {
+        const content = await readFile(filePath, "utf-8");
+        const message = JSON.parse(content);
+        if (this.matchesFilter(message, filter)) {
+          messages.push(message);
+        }
+      } catch {
+      }
+    }
+    messages.sort((a, b) => {
+      const priorityOrder = { urgent: 0, high: 1, normal: 2, low: 3 };
+      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+      if (priorityDiff !== 0) return priorityDiff;
+      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+    });
+    return filter.limit ? messages.slice(0, filter.limit) : messages;
+  }
+  async markAsRead(messageId) {
+    const message = await this.get(messageId);
+    if (!message) return null;
+    message.status = "read";
+    message.readAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(message);
+    return message;
+  }
+  async getUnread() {
+    return this.list({ status: "unread" });
+  }
+  async getSummary() {
+    const messages = await this.list();
+    const summary = {
+      total: messages.length,
+      unread: 0,
+      byPriority: { low: 0, normal: 0, high: 0, urgent: 0 },
+      byType: { request: 0, response: 0, notification: 0, update: 0 }
+    };
+    for (const message of messages) {
+      if (message.status === "unread") {
+        summary.unread++;
+      }
+      summary.byPriority[message.priority]++;
+      summary.byType[message.type]++;
+    }
+    return summary;
+  }
+  async count() {
+    if (!existsSync(this.basePath)) return 0;
+    const files = await readdir(this.basePath);
+    return files.filter((f) => f.endsWith(".json")).length;
+  }
+  async clear() {
+    if (!existsSync(this.basePath)) return 0;
+    const files = await readdir(this.basePath);
+    let deleted = 0;
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        await unlink(join(this.basePath, file));
+        deleted++;
+      } catch {
+      }
+    }
+    return deleted;
+  }
+  getMessagePath(messageId) {
+    return join(this.basePath, `${messageId}.json`);
+  }
+  matchesFilter(message, filter) {
+    if (filter.from && message.from !== filter.from) return false;
+    if (filter.to && message.to !== filter.to) return false;
+    if (filter.type && message.type !== filter.type) return false;
+    if (filter.priority && message.priority !== filter.priority) return false;
+    if (filter.status && message.status !== filter.status) return false;
+    if (filter.threadId && message.threadId !== filter.threadId) return false;
+    if (filter.since) {
+      const since = new Date(filter.since).getTime();
+      const created = new Date(message.createdAt).getTime();
+      if (created < since) return false;
+    }
+    if (filter.until) {
+      const until = new Date(filter.until).getTime();
+      const created = new Date(message.createdAt).getTime();
+      if (created > until) return false;
+    }
+    return true;
+  }
+};
+
+// src/storage/sent.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, readdir as readdir2, unlink as unlink2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+var SentStorage = class {
+  basePath;
+  constructor(agentId, basePath) {
+    this.basePath = basePath ?? join2(homedir2(), ".skillkit", "messages", "sent", agentId);
+  }
+  async initialize() {
+    await mkdir2(this.basePath, { recursive: true });
+  }
+  async save(message) {
+    const filePath = this.getMessagePath(message.id);
+    await mkdir2(dirname2(filePath), { recursive: true });
+    await writeFile2(filePath, JSON.stringify(message, null, 2), "utf-8");
+  }
+  async get(messageId) {
+    const filePath = this.getMessagePath(messageId);
+    if (!existsSync2(filePath)) {
+      return null;
+    }
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async delete(messageId) {
+    const filePath = this.getMessagePath(messageId);
+    if (!existsSync2(filePath)) {
+      return false;
+    }
+    try {
+      await unlink2(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list(filter = {}) {
+    if (!existsSync2(this.basePath)) {
+      return [];
+    }
+    const files = await readdir2(this.basePath);
+    const messages = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const filePath = join2(this.basePath, file);
+      try {
+        const content = await readFile2(filePath, "utf-8");
+        const message = JSON.parse(content);
+        if (this.matchesFilter(message, filter)) {
+          messages.push(message);
+        }
+      } catch {
+      }
+    }
+    messages.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return filter.limit ? messages.slice(0, filter.limit) : messages;
+  }
+  async getByThread(threadId) {
+    return this.list({ threadId });
+  }
+  async getByRecipient(to) {
+    return this.list({ to });
+  }
+  async count() {
+    if (!existsSync2(this.basePath)) return 0;
+    const files = await readdir2(this.basePath);
+    return files.filter((f) => f.endsWith(".json")).length;
+  }
+  async clear() {
+    if (!existsSync2(this.basePath)) return 0;
+    const files = await readdir2(this.basePath);
+    let deleted = 0;
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        await unlink2(join2(this.basePath, file));
+        deleted++;
+      } catch {
+      }
+    }
+    return deleted;
+  }
+  getMessagePath(messageId) {
+    return join2(this.basePath, `${messageId}.json`);
+  }
+  matchesFilter(message, filter) {
+    if (filter.to && message.to !== filter.to) return false;
+    if (filter.type && message.type !== filter.type) return false;
+    if (filter.priority && message.priority !== filter.priority) return false;
+    if (filter.threadId && message.threadId !== filter.threadId) return false;
+    if (filter.since) {
+      const since = new Date(filter.since).getTime();
+      const created = new Date(message.createdAt).getTime();
+      if (created < since) return false;
+    }
+    if (filter.until) {
+      const until = new Date(filter.until).getTime();
+      const created = new Date(message.createdAt).getTime();
+      if (created > until) return false;
+    }
+    return true;
+  }
+};
+
+// src/storage/archived.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir as readdir3, unlink as unlink3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+var ArchivedStorage = class {
+  basePath;
+  constructor(agentId, basePath) {
+    this.basePath = basePath ?? join3(homedir3(), ".skillkit", "messages", "archived", agentId);
+  }
+  async initialize() {
+    await mkdir3(this.basePath, { recursive: true });
+  }
+  async save(message) {
+    const archivedMessage = {
+      ...message,
+      status: "archived"
+    };
+    const filePath = this.getMessagePath(message.id);
+    await mkdir3(dirname3(filePath), { recursive: true });
+    await writeFile3(filePath, JSON.stringify(archivedMessage, null, 2), "utf-8");
+  }
+  async get(messageId) {
+    const filePath = this.getMessagePath(messageId);
+    if (!existsSync3(filePath)) {
+      return null;
+    }
+    try {
+      const content = await readFile3(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async delete(messageId) {
+    const filePath = this.getMessagePath(messageId);
+    if (!existsSync3(filePath)) {
+      return false;
+    }
+    try {
+      await unlink3(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list(filter = {}) {
+    if (!existsSync3(this.basePath)) {
+      return [];
+    }
+    const files = await readdir3(this.basePath);
+    const messages = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const filePath = join3(this.basePath, file);
+      try {
+        const content = await readFile3(filePath, "utf-8");
+        const message = JSON.parse(content);
+        if (this.matchesFilter(message, filter)) {
+          messages.push(message);
+        }
+      } catch {
+      }
+    }
+    messages.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return filter.limit ? messages.slice(0, filter.limit) : messages;
+  }
+  async search(query, limit = 50) {
+    const messages = await this.list();
+    const lowerQuery = query.toLowerCase();
+    return messages.filter((m) => {
+      const subject = m.subject.toLowerCase();
+      const bodyStr = typeof m.body === "string" ? m.body.toLowerCase() : JSON.stringify(m.body).toLowerCase();
+      return subject.includes(lowerQuery) || bodyStr.includes(lowerQuery);
+    }).slice(0, limit);
+  }
+  async count() {
+    if (!existsSync3(this.basePath)) return 0;
+    const files = await readdir3(this.basePath);
+    return files.filter((f) => f.endsWith(".json")).length;
+  }
+  async clear() {
+    if (!existsSync3(this.basePath)) return 0;
+    const files = await readdir3(this.basePath);
+    let deleted = 0;
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        await unlink3(join3(this.basePath, file));
+        deleted++;
+      } catch {
+      }
+    }
+    return deleted;
+  }
+  async pruneOlderThan(days) {
+    const messages = await this.list();
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+    let deleted = 0;
+    for (const message of messages) {
+      const createdAt = new Date(message.createdAt).getTime();
+      if (createdAt < cutoff) {
+        if (await this.delete(message.id)) {
+          deleted++;
+        }
+      }
+    }
+    return deleted;
+  }
+  getMessagePath(messageId) {
+    return join3(this.basePath, `${messageId}.json`);
+  }
+  matchesFilter(message, filter) {
+    if (filter.from && message.from !== filter.from) return false;
+    if (filter.to && message.to !== filter.to) return false;
+    if (filter.type && message.type !== filter.type) return false;
+    if (filter.priority && message.priority !== filter.priority) return false;
+    if (filter.threadId && message.threadId !== filter.threadId) return false;
+    if (filter.since) {
+      const since = new Date(filter.since).getTime();
+      const created = new Date(message.createdAt).getTime();
+      if (created < since) return false;
+    }
+    if (filter.until) {
+      const until = new Date(filter.until).getTime();
+      const created = new Date(message.createdAt).getTime();
+      if (created > until) return false;
+    }
+    return true;
+  }
+};
+
+// src/message/builder.ts
+import { randomUUID } from "crypto";
+var MessageBuilder = class _MessageBuilder {
+  message;
+  constructor() {
+    this.message = {
+      id: randomUUID(),
+      type: "notification",
+      priority: "normal",
+      status: "unread",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  static create() {
+    return new _MessageBuilder();
+  }
+  from(agentId) {
+    this.message.from = agentId;
+    return this;
+  }
+  to(recipient) {
+    this.message.to = recipient;
+    return this;
+  }
+  subject(subject) {
+    this.message.subject = subject;
+    return this;
+  }
+  body(body) {
+    this.message.body = body;
+    return this;
+  }
+  type(type) {
+    this.message.type = type;
+    return this;
+  }
+  priority(priority) {
+    this.message.priority = priority;
+    return this;
+  }
+  replyTo(messageId) {
+    this.message.replyTo = messageId;
+    return this;
+  }
+  threadId(threadId) {
+    this.message.threadId = threadId;
+    return this;
+  }
+  metadata(metadata) {
+    this.message.metadata = metadata;
+    return this;
+  }
+  request() {
+    this.message.type = "request";
+    return this;
+  }
+  response() {
+    this.message.type = "response";
+    return this;
+  }
+  notification() {
+    this.message.type = "notification";
+    return this;
+  }
+  update() {
+    this.message.type = "update";
+    return this;
+  }
+  low() {
+    this.message.priority = "low";
+    return this;
+  }
+  normal() {
+    this.message.priority = "normal";
+    return this;
+  }
+  high() {
+    this.message.priority = "high";
+    return this;
+  }
+  urgent() {
+    this.message.priority = "urgent";
+    return this;
+  }
+  build() {
+    if (!this.message.from) {
+      throw new Error('Message must have a "from" field');
+    }
+    if (!this.message.to) {
+      throw new Error('Message must have a "to" field');
+    }
+    if (!this.message.subject) {
+      throw new Error("Message must have a subject");
+    }
+    if (this.message.body === void 0) {
+      throw new Error("Message must have a body");
+    }
+    return this.message;
+  }
+};
+function createMessage(from, input) {
+  const builder = MessageBuilder.create().from(from).to(input.to).subject(input.subject).body(input.body);
+  if (input.type) builder.type(input.type);
+  if (input.priority) builder.priority(input.priority);
+  if (input.replyTo) builder.replyTo(input.replyTo);
+  if (input.threadId) builder.threadId(input.threadId);
+  if (input.metadata) builder.metadata(input.metadata);
+  return builder.build();
+}
+function createReply(originalMessage, from, body) {
+  return MessageBuilder.create().from(from).to(originalMessage.from).subject(`Re: ${originalMessage.subject}`).body(body).type("response").priority(originalMessage.priority).replyTo(originalMessage.id).threadId(originalMessage.threadId ?? originalMessage.id).build();
+}
+function createForward(originalMessage, from, to, additionalBody) {
+  const forwardBody = {
+    forwardedFrom: originalMessage.from,
+    originalSubject: originalMessage.subject,
+    originalBody: originalMessage.body,
+    ...additionalBody ? { note: additionalBody } : {}
+  };
+  return MessageBuilder.create().from(from).to(to).subject(`Fwd: ${originalMessage.subject}`).body(forwardBody).type(originalMessage.type).priority(originalMessage.priority).build();
+}
+
+// src/message/router.ts
+var MessageRouter = class {
+  config;
+  localAgents = /* @__PURE__ */ new Map();
+  remoteHandler;
+  constructor(config) {
+    this.config = config;
+    this.localAgents.set(config.localAgentId, config.inboxStorage);
+  }
+  registerLocalAgent(agentId, inbox) {
+    this.localAgents.set(agentId, inbox);
+  }
+  unregisterLocalAgent(agentId) {
+    if (agentId !== this.config.localAgentId) {
+      this.localAgents.delete(agentId);
+    }
+  }
+  setRemoteHandler(handler) {
+    this.remoteHandler = handler;
+  }
+  async route(message) {
+    const recipient = this.parseRecipient(message.to);
+    await this.config.sentStorage.save(message);
+    if (recipient.isLocal) {
+      return this.deliverLocal(message, recipient.agentId);
+    }
+    return this.deliverRemote(message, recipient.host, recipient.agentId);
+  }
+  async deliverLocal(message, agentId) {
+    const inbox = this.localAgents.get(agentId);
+    if (!inbox) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: `Agent ${agentId} not found locally`,
+        via: "local"
+      };
+    }
+    try {
+      await inbox.save(message);
+      return {
+        messageId: message.id,
+        delivered: true,
+        deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        via: "local"
+      };
+    } catch (err) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: err.message,
+        via: "local"
+      };
+    }
+  }
+  async deliverRemote(message, hostAddress, _agentId) {
+    if (!this.remoteHandler) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: "No remote delivery handler configured",
+        via: "remote"
+      };
+    }
+    try {
+      return await this.remoteHandler(message, hostAddress);
+    } catch (err) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: err.message,
+        via: "remote"
+      };
+    }
+  }
+  async archive(messageId) {
+    const message = await this.config.inboxStorage.get(messageId);
+    if (!message) return false;
+    await this.config.archivedStorage.save(message);
+    await this.config.inboxStorage.delete(messageId);
+    return true;
+  }
+  async unarchive(messageId) {
+    const message = await this.config.archivedStorage.get(messageId);
+    if (!message) return false;
+    message.status = "read";
+    await this.config.inboxStorage.save(message);
+    await this.config.archivedStorage.delete(messageId);
+    return true;
+  }
+  getLocalAgents() {
+    return Array.from(this.localAgents.keys());
+  }
+  isLocalAgent(agentId) {
+    return this.localAgents.has(agentId);
+  }
+  parseRecipient(to) {
+    if (to.includes("@")) {
+      const [agentId, host] = to.split("@");
+      return { agentId, host, isLocal: false };
+    }
+    return {
+      agentId: to,
+      isLocal: this.localAgents.has(to)
+    };
+  }
+};
+
+// src/transport/local.ts
+var LocalTransport = class {
+  agents = /* @__PURE__ */ new Map();
+  register(agentId, inbox) {
+    this.agents.set(agentId, inbox);
+  }
+  unregister(agentId) {
+    this.agents.delete(agentId);
+  }
+  async deliver(message) {
+    const inbox = this.agents.get(message.to);
+    if (!inbox) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: `Agent ${message.to} not found locally`,
+        via: "local"
+      };
+    }
+    try {
+      await inbox.save(message);
+      return {
+        messageId: message.id,
+        delivered: true,
+        deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        via: "local"
+      };
+    } catch (err) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: err.message,
+        via: "local"
+      };
+    }
+  }
+  async broadcast(message, excludeFrom = true) {
+    const results = /* @__PURE__ */ new Map();
+    for (const [agentId] of this.agents) {
+      if (excludeFrom && agentId === message.from) continue;
+      const targetMessage = { ...message, to: agentId };
+      const result = await this.deliver(targetMessage);
+      results.set(agentId, result);
+    }
+    return results;
+  }
+  getRegisteredAgents() {
+    return Array.from(this.agents.keys());
+  }
+  isRegistered(agentId) {
+    return this.agents.has(agentId);
+  }
+};
+var globalTransport = null;
+function getLocalTransport() {
+  if (!globalTransport) {
+    globalTransport = new LocalTransport();
+  }
+  return globalTransport;
+}
+
+// src/transport/remote.ts
+import got from "got";
+var RemoteTransport = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      timeout: options.timeout ?? 1e4,
+      retries: options.retries ?? 2
+    };
+  }
+  async deliver(message, hostAddress, hostPort) {
+    const url = `http://${hostAddress}:${hostPort}/message`;
+    try {
+      const response = await got.post(url, {
+        json: message,
+        timeout: { request: this.options.timeout },
+        retry: { limit: this.options.retries },
+        throwHttpErrors: false
+      });
+      if (response.statusCode === 200 || response.statusCode === 201) {
+        return {
+          messageId: message.id,
+          delivered: true,
+          deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          via: "remote"
+        };
+      }
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: `HTTP ${response.statusCode}: ${response.body}`,
+        via: "remote"
+      };
+    } catch (err) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: err.message || "Connection failed",
+        via: "remote"
+      };
+    }
+  }
+  async deliverToAgent(message, agentAddress) {
+    const parts = agentAddress.split("@");
+    if (parts.length !== 2) {
+      return {
+        messageId: message.id,
+        delivered: false,
+        error: "Invalid agent address format. Expected: agentId@host:port",
+        via: "remote"
+      };
+    }
+    const [, hostPart] = parts;
+    const [host, portStr] = hostPart.split(":");
+    const port = portStr ? parseInt(portStr, 10) : 9876;
+    return this.deliver(message, host, port);
+  }
+  async broadcast(message, hosts) {
+    const results = /* @__PURE__ */ new Map();
+    await Promise.all(
+      hosts.map(async ({ address, port }) => {
+        const result = await this.deliver(message, address, port);
+        results.set(`${address}:${port}`, result);
+      })
+    );
+    return results;
+  }
+  async ping(hostAddress, hostPort) {
+    const url = `http://${hostAddress}:${hostPort}/health`;
+    try {
+      const response = await got.get(url, {
+        timeout: { request: 5e3 },
+        retry: { limit: 0 },
+        throwHttpErrors: false
+      });
+      return response.statusCode === 200;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/index.ts
+var MessagingService = class {
+  config;
+  inbox;
+  sent;
+  archived;
+  router;
+  constructor(config) {
+    this.config = config;
+    this.inbox = new InboxStorage(config.agentId, config.storagePath);
+    this.sent = new SentStorage(config.agentId, config.storagePath);
+    this.archived = new ArchivedStorage(config.agentId, config.storagePath);
+    this.router = new MessageRouter({
+      localAgentId: config.agentId,
+      inboxStorage: this.inbox,
+      sentStorage: this.sent,
+      archivedStorage: this.archived
+    });
+  }
+  async initialize() {
+    await this.inbox.initialize();
+    await this.sent.initialize();
+    await this.archived.initialize();
+  }
+  async send(input) {
+    const message = createMessage(this.config.agentId, input);
+    return this.router.route(message);
+  }
+  async reply(messageId, body) {
+    const original = await this.inbox.get(messageId);
+    if (!original) {
+      throw new Error(`Message ${messageId} not found`);
+    }
+    const reply = createReply(original, this.config.agentId, body);
+    return this.router.route(reply);
+  }
+  async forward(messageId, to, note) {
+    const original = await this.inbox.get(messageId);
+    if (!original) {
+      throw new Error(`Message ${messageId} not found`);
+    }
+    const forwarded = createForward(original, this.config.agentId, to, note);
+    return this.router.route(forwarded);
+  }
+  async getInbox(filter) {
+    return this.inbox.list(filter);
+  }
+  async getSent(filter) {
+    return this.sent.list(filter);
+  }
+  async getArchived(filter) {
+    return this.archived.list(filter);
+  }
+  async getMessage(messageId) {
+    return this.inbox.get(messageId);
+  }
+  async markAsRead(messageId) {
+    return this.inbox.markAsRead(messageId);
+  }
+  async archive(messageId) {
+    return this.router.archive(messageId);
+  }
+  async deleteMessage(messageId) {
+    return this.inbox.delete(messageId);
+  }
+  async getInboxSummary() {
+    return this.inbox.getSummary();
+  }
+  getRouter() {
+    return this.router;
+  }
+};
+async function createMessagingService(agentId, storagePath) {
+  const service = new MessagingService({ agentId, storagePath });
+  await service.initialize();
+  return service;
+}
+export {
+  ArchivedStorage,
+  DEFAULT_MESSAGING_CONFIG,
+  InboxStorage,
+  LocalTransport,
+  MessageBuilder,
+  MessageRouter,
+  MessagingService,
+  RemoteTransport,
+  SentStorage,
+  createForward,
+  createMessage,
+  createMessagingService,
+  createReply,
+  getLocalTransport
+};
+//# sourceMappingURL=index.js.map