@elizaos/plugin-agent-orchestrator 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/index.js

@@ -1,3 +1,1032 @@
+// index.ts
+import { getSessionProviders as getSessionProviders2 } from "@elizaos/core";
+
+// src/actions/messaging.ts
+function extractMessagingParams(message, _state) {
+  const params = message.content?.params;
+  if (!params) {
+    return {};
+  }
+  let target;
+  if (params.target) {
+    target = params.target;
+  } else {
+    target = {};
+    if (params.channel)
+      target.channel = params.channel;
+    if (params.to)
+      target.to = params.to;
+    if (params.threadId !== undefined)
+      target.threadId = params.threadId;
+    if (params.replyTo)
+      target.replyToMessageId = params.replyTo;
+  }
+  let content;
+  if (params.content) {
+    content = params.content;
+  } else {
+    content = {};
+    const text = params.text ?? message.content?.text;
+    if (text)
+      content.text = text;
+  }
+  return { target, content };
+}
+var sendCrossPlatformMessageAction = {
+  name: "SEND_CROSS_PLATFORM_MESSAGE",
+  similes: [
+    "CROSS_PLATFORM_MESSAGE",
+    "UNIFIED_SEND",
+    "SEND_TO_CHANNEL",
+    "RELAY_MESSAGE",
+    "BROADCAST_MESSAGE"
+  ],
+  description: "Send a message to any supported platform (Discord, Telegram, Slack, WhatsApp, Twitch). " + "Requires specifying the target channel/platform and recipient.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      return false;
+    }
+    const params = message.content?.params;
+    if (!params) {
+      return true;
+    }
+    const hasTarget = params.target || params.channel && params.to;
+    const hasContent = params.content || params.text || message.content?.text;
+    return !!(hasTarget && hasContent);
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available. Please ensure the orchestrator plugin is properly configured."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
+    }
+    const { target, content } = extractMessagingParams(message, state);
+    if (!target?.channel) {
+      if (callback) {
+        await callback({
+          text: "Please specify the target channel (discord, telegram, slack, whatsapp, twitch)."
+        });
+      }
+      return { success: false, error: "Missing target channel" };
+    }
+    if (!target?.to) {
+      if (callback) {
+        await callback({
+          text: "Please specify the recipient (channel ID, chat ID, or room ID)."
+        });
+      }
+      return { success: false, error: "Missing recipient" };
+    }
+    if (!content?.text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
+    }
+    const sendTarget = {
+      channel: target.channel,
+      to: target.to
+    };
+    if (target.threadId !== undefined)
+      sendTarget.threadId = target.threadId;
+    if (target.replyToMessageId)
+      sendTarget.replyToMessageId = target.replyToMessageId;
+    const sendContent = {
+      text: content.text
+    };
+    if (content.attachments)
+      sendContent.attachments = content.attachments;
+    if (content.embed)
+      sendContent.embed = content.embed;
+    if (content.buttons)
+      sendContent.buttons = content.buttons;
+    if (content.disableLinkPreview !== undefined)
+      sendContent.disableLinkPreview = content.disableLinkPreview;
+    if (content.silent !== undefined)
+      sendContent.silent = content.silent;
+    const result = await messagingService.send({
+      target: sendTarget,
+      content: sendContent
+    });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        if (result.sentAt)
+          callbackData.sentAt = result.sentAt;
+        await callback({
+          text: `Message sent successfully to ${target.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to send message: ${result.error}`
+        });
+      }
+    }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send 'Hello from the agent!' to Discord channel 123456789",
+          params: {
+            channel: "discord",
+            to: "123456789",
+            text: "Hello from the agent!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent successfully to Discord.",
+          actions: ["SEND_CROSS_PLATFORM_MESSAGE"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send a Telegram message",
+          params: {
+            channel: "telegram",
+            to: "-1001234567890",
+            text: "Automated notification from your AI assistant."
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent successfully to Telegram.",
+          actions: ["SEND_CROSS_PLATFORM_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var sendToDeliveryContextAction = {
+  name: "SEND_TO_DELIVERY_CONTEXT",
+  similes: ["DELIVER_MESSAGE", "SEND_TO_CONTEXT", "ROUTE_MESSAGE"],
+  description: "Send a message using a delivery context that specifies the target channel and recipient. " + "Useful for routing messages back to the original requester or to a specific context.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      return false;
+    }
+    const params = message.content?.params;
+    if (!params?.deliveryContext) {
+      return false;
+    }
+    const hasText = params.text || message.content?.text;
+    return !!hasText;
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
+    }
+    const params = message.content?.params;
+    const deliveryContext = params?.deliveryContext;
+    const text = params?.text ?? message.content?.text;
+    if (!deliveryContext) {
+      if (callback) {
+        await callback({
+          text: "Please provide a delivery context with channel and recipient information."
+        });
+      }
+      return { success: false, error: "Missing delivery context" };
+    }
+    if (!text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
+    }
+    const result = await messagingService.sendToDeliveryContext(deliveryContext, {
+      text
+    });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        await callback({
+          text: `Message delivered successfully via ${result.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to deliver message: ${result.error}`
+        });
+      }
+    }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send result to delivery context",
+          params: {
+            deliveryContext: {
+              channel: "discord",
+              to: "123456789"
+            },
+            text: "Task completed successfully!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message delivered successfully via discord.",
+          actions: ["SEND_TO_DELIVERY_CONTEXT"]
+        }
+      }
+    ]
+  ]
+};
+var sendToRoomAction = {
+  name: "SEND_TO_ROOM",
+  similes: ["MESSAGE_ROOM", "ROOM_MESSAGE", "NOTIFY_ROOM"],
+  description: "Send a message to an Eliza room. The room's metadata determines which platform and recipient to use.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      return false;
+    }
+    const params = message.content?.params;
+    if (!params?.roomId) {
+      return false;
+    }
+    const hasText = params.text || message.content?.text;
+    return !!hasText;
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
+    }
+    const params = message.content?.params;
+    const roomId = params?.roomId;
+    const text = params?.text ?? message.content?.text;
+    if (!roomId) {
+      if (callback) {
+        await callback({
+          text: "Please specify the room ID to send the message to."
+        });
+      }
+      return { success: false, error: "Missing room ID" };
+    }
+    if (!text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
+    }
+    const result = await messagingService.sendToRoom(roomId, { text });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        await callback({
+          text: `Message sent to room via ${result.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to send to room: ${result.error}`
+        });
+      }
+    }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send to room",
+          params: {
+            roomId: "550e8400-e29b-41d4-a716-446655440000",
+            text: "Hello, room!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent to room via discord.",
+          actions: ["SEND_TO_ROOM"]
+        }
+      }
+    ]
+  ]
+};
+var sendToSessionMessageAction = {
+  name: "SEND_TO_SESSION_MESSAGE",
+  similes: ["SESSION_MESSAGE", "MESSAGE_SESSION", "NOTIFY_SESSION"],
+  description: "Send a message to a session by its session key. The session key is mapped to an Eliza room.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      return false;
+    }
+    const params = message.content?.params;
+    if (!params?.sessionKey) {
+      return false;
+    }
+    const hasText = params.text || message.content?.text;
+    return !!hasText;
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
+    }
+    const params = message.content?.params;
+    const sessionKey = params?.sessionKey;
+    const text = params?.text ?? message.content?.text;
+    if (!sessionKey) {
+      if (callback) {
+        await callback({
+          text: "Please specify the session key to send the message to."
+        });
+      }
+      return { success: false, error: "Missing session key" };
+    }
+    if (!text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
+    }
+    const result = await messagingService.sendToSession(sessionKey, { text });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        await callback({
+          text: `Message sent to session via ${result.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to send to session: ${result.error}`
+        });
+      }
+    }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send to session",
+          params: {
+            sessionKey: "agent:main:dm:user123",
+            text: "Update from your subagent!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent to session via discord.",
+          actions: ["SEND_TO_SESSION_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var listMessagingChannelsAction = {
+  name: "LIST_MESSAGING_CHANNELS",
+  similes: ["AVAILABLE_CHANNELS", "GET_CHANNELS", "MESSAGING_PLATFORMS"],
+  description: "List all available messaging channels/platforms that the agent can send messages to.",
+  validate: async (runtime, _message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    return !!messagingService;
+  },
+  handler: async (runtime, _message, _state, _options, callback) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
+    }
+    const channels = messagingService.getAvailableChannels();
+    if (callback) {
+      if (channels.length > 0) {
+        await callback({
+          text: `Available messaging channels: ${channels.join(", ")}`,
+          data: { channels }
+        });
+      } else {
+        await callback({
+          text: "No messaging channels are currently available.",
+          data: { channels: [] }
+        });
+      }
+    }
+    return {
+      success: true,
+      data: { channels }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "What messaging platforms can you use?"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Available messaging channels: discord, telegram, internal",
+          actions: ["LIST_MESSAGING_CHANNELS"]
+        }
+      }
+    ]
+  ]
+};
+
+// src/utils/session.ts
+import crypto from "node:crypto";
+import {
+  buildAcpSessionKey,
+  buildAgentMainSessionKey,
+  buildAgentPeerSessionKey,
+  buildAgentSessionKey,
+  buildGroupHistoryKey,
+  buildSubagentSessionKey,
+  createSendPolicyProvider,
+  createSessionEntry,
+  createSessionProvider,
+  createSessionSkillsProvider,
+  deleteSessionEntry,
+  extractSessionContext,
+  getSessionEntry,
+  getSessionProviders,
+  isAcpSessionKey,
+  isSubagentSessionKey,
+  isValidSessionEntry,
+  listSessionKeys,
+  loadSessionStore,
+  mergeSessionEntry,
+  normalizeAccountId,
+  normalizeAgentId,
+  normalizeMainKey,
+  parseAgentSessionKey,
+  resolveAgentIdFromSessionKey,
+  resolveAgentSessionsDir,
+  resolveDefaultSessionStorePath,
+  resolveSessionTranscriptPath,
+  resolveStateDir,
+  resolveStorePath,
+  resolveThreadParentSessionKey,
+  resolveThreadSessionKeys,
+  SessionStateManager,
+  saveSessionStore,
+  toAgentRequestSessionKey,
+  toAgentStoreSessionKey,
+  updateSessionStore,
+  updateSessionStoreEntry,
+  upsertSessionEntry
+} from "@elizaos/core";
+function hashToUUID(input) {
+  const hash = crypto.createHash("sha256").update(input).digest("hex");
+  const uuid = [
+    hash.slice(0, 8),
+    hash.slice(8, 12),
+    `5${hash.slice(13, 16)}`,
+    `${(parseInt(hash.slice(16, 17), 16) & 3 | 8).toString(16)}${hash.slice(17, 20)}`,
+    hash.slice(20, 32)
+  ].join("-");
+  return uuid;
+}
+function sessionKeyToRoomId(sessionKey, agentId) {
+  const normalized = normalizeSessionKey(sessionKey);
+  const input = agentId ? `${agentId}:${normalized}` : normalized;
+  return hashToUUID(input);
+}
+function normalizeSessionKey(sessionKey) {
+  const trimmed = sessionKey.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed.startsWith("agent:")) {
+    return trimmed;
+  }
+  return trimmed;
+}
+function parseSessionKey(sessionKey) {
+  const trimmed = sessionKey.trim();
+  if (!trimmed) {
+    return {
+      agentId: "unknown",
+      keyType: "unknown",
+      identifier: ""
+    };
+  }
+  if (trimmed.startsWith("agent:")) {
+    const parts = trimmed.split(":");
+    if (parts.length >= 4) {
+      const agentId = parts[1];
+      const keyTypeRaw = parts[2];
+      const identifier = parts.slice(3).join(":");
+      const keyType = normalizeKeyType(keyTypeRaw);
+      return {
+        agentId,
+        keyType,
+        identifier
+      };
+    }
+    if (parts.length >= 2) {
+      return {
+        agentId: parts[1],
+        keyType: "unknown",
+        identifier: parts.slice(2).join(":")
+      };
+    }
+  }
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex > 0) {
+    const keyTypeRaw = trimmed.slice(0, colonIndex);
+    const identifier = trimmed.slice(colonIndex + 1);
+    const keyType = normalizeKeyType(keyTypeRaw);
+    return {
+      agentId: "unknown",
+      keyType,
+      identifier
+    };
+  }
+  return {
+    agentId: "unknown",
+    keyType: "unknown",
+    identifier: trimmed
+  };
+}
+function normalizeKeyType(raw) {
+  const lower = raw.toLowerCase();
+  switch (lower) {
+    case "dm":
+    case "direct":
+      return "dm";
+    case "subagent":
+    case "sub":
+      return "subagent";
+    case "group":
+    case "server":
+      return "group";
+    case "channel":
+      return "channel";
+    default:
+      return "unknown";
+  }
+}
+function buildSessionKey(agentId, keyType, identifier) {
+  const normalizedAgentId = normalizeAgentId2(agentId);
+  return `agent:${normalizedAgentId}:${keyType}:${identifier}`;
+}
+function normalizeAgentId2(agentId) {
+  return agentId.trim().toLowerCase();
+}
+function isSubagentSessionKey2(sessionKey) {
+  const parsed = parseSessionKey(sessionKey);
+  return parsed.keyType === "subagent";
+}
+function extractAgentIdFromSessionKey(sessionKey) {
+  const parsed = parseSessionKey(sessionKey);
+  return parsed.agentId;
+}
+function createSubagentSessionKey(agentId) {
+  const uuid = crypto.randomUUID();
+  return buildSessionKey(agentId, "subagent", uuid);
+}
+function normalizeDeliveryContext(context) {
+  if (!context) {
+    return;
+  }
+  const result = {};
+  if (context.channel && typeof context.channel === "string") {
+    const trimmed = context.channel.trim();
+    if (trimmed)
+      result.channel = trimmed;
+  }
+  if (context.accountId && typeof context.accountId === "string") {
+    const trimmed = context.accountId.trim();
+    if (trimmed)
+      result.accountId = trimmed;
+  }
+  if (context.to && typeof context.to === "string") {
+    const trimmed = context.to.trim();
+    if (trimmed)
+      result.to = trimmed;
+  }
+  if (context.threadId !== undefined && context.threadId !== null) {
+    result.threadId = context.threadId;
+  }
+  if (context.groupId && typeof context.groupId === "string") {
+    const trimmed = context.groupId.trim();
+    if (trimmed)
+      result.groupId = trimmed;
+  }
+  if (context.groupChannel && typeof context.groupChannel === "string") {
+    const trimmed = context.groupChannel.trim();
+    if (trimmed)
+      result.groupChannel = trimmed;
+  }
+  if (context.groupSpace && typeof context.groupSpace === "string") {
+    const trimmed = context.groupSpace.trim();
+    if (trimmed)
+      result.groupSpace = trimmed;
+  }
+  const hasValues = Object.values(result).some((v) => v !== undefined && v !== null);
+  return hasValues ? result : undefined;
+}
+function mergeDeliveryContext(primary, secondary) {
+  if (!primary && !secondary) {
+    return;
+  }
+  if (!primary) {
+    return normalizeDeliveryContext(secondary);
+  }
+  if (!secondary) {
+    return normalizeDeliveryContext(primary);
+  }
+  const merged = {};
+  const ch = primary.channel || secondary.channel;
+  if (ch)
+    merged.channel = ch;
+  const acct = primary.accountId || secondary.accountId;
+  if (acct)
+    merged.accountId = acct;
+  const to = primary.to || secondary.to;
+  if (to)
+    merged.to = to;
+  const tid = primary.threadId ?? secondary.threadId;
+  if (tid !== undefined)
+    merged.threadId = tid;
+  const gid = primary.groupId || secondary.groupId;
+  if (gid)
+    merged.groupId = gid;
+  const gch = primary.groupChannel || secondary.groupChannel;
+  if (gch)
+    merged.groupChannel = gch;
+  const gsp = primary.groupSpace || secondary.groupSpace;
+  if (gsp)
+    merged.groupSpace = gsp;
+  return normalizeDeliveryContext(merged);
+}
+function formatDurationShort(ms) {
+  if (!ms || !Number.isFinite(ms) || ms <= 0) {
+    return;
+  }
+  const totalSeconds = Math.round(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}h${minutes}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function formatTokenCount(count) {
+  if (!count || !Number.isFinite(count)) {
+    return "0";
+  }
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}m`;
+  }
+  if (count >= 1000) {
+    return `${(count / 1000).toFixed(1)}k`;
+  }
+  return String(Math.round(count));
+}
+
+// src/actions/subagent-management.ts
+function getSubagentService(runtime) {
+  const svc = runtime.getService("SUBAGENT");
+  if (!svc) {
+    throw new Error("SubagentService not available (SUBAGENT)");
+  }
+  return svc;
+}
+function extractSessionContext2(_runtime, message) {
+  const metadata = message.content?.metadata;
+  const sessionKey = typeof metadata?.sessionKey === "string" ? metadata.sessionKey : undefined;
+  const result = {};
+  if (sessionKey)
+    result.sessionKey = sessionKey;
+  if (message.roomId)
+    result.roomId = message.roomId;
+  return result;
+}
+var spawnSubagentAction = {
+  name: "SPAWN_SUBAGENT",
+  similes: ["SPAWN_TASK", "BACKGROUND_TASK", "START_SUBAGENT", "SESSIONS_SPAWN", "CREATE_SUBAGENT"],
+  description: "Spawn a background sub-agent run to execute a task asynchronously. The subagent will complete the task and announce results back.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("SUBAGENT");
+    if (!svc) {
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() ?? "";
+    const hasSpawnIntent = text.includes("spawn") || text.includes("background") || text.includes("subagent") || text.includes("async task");
+    const hasTaskWords = text.includes("task") || text.includes("research") || text.includes("investigate") || text.includes("analyze") || text.includes("look into");
+    return hasSpawnIntent || hasTaskWords && text.includes("in background");
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = getSubagentService(runtime);
+    const context = extractSessionContext2(runtime, message);
+    const opts = options;
+    const task = opts?.task ?? message.content.text ?? "";
+    if (!task.trim()) {
+      const msg2 = "Please specify a task for the subagent to execute.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const spawnParams = {
+      task,
+      runTimeoutSeconds: opts?.timeoutSeconds ?? 300,
+      cleanup: opts?.cleanup ?? "keep"
+    };
+    if (opts?.label)
+      spawnParams.label = opts.label;
+    if (opts?.agentId)
+      spawnParams.agentId = opts.agentId;
+    if (opts?.model)
+      spawnParams.model = opts.model;
+    if (opts?.thinking)
+      spawnParams.thinking = opts.thinking;
+    const result = await svc.spawnSubagent(spawnParams, context);
+    if (result.status !== "accepted") {
+      const msg2 = `Failed to spawn subagent: ${result.error ?? "unknown error"}`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const labelText = opts?.label ? ` "${opts.label}"` : "";
+    const msg = `Spawned background task${labelText}. Run ID: ${result.runId?.slice(0, 8)}...
+I'll announce results when complete.`;
+    await callback?.({ content: { text: msg } });
+    return {
+      success: true,
+      text: msg,
+      data: {
+        runId: result.runId,
+        childSessionKey: result.childSessionKey,
+        childRoomId: result.childRoomId
+      }
+    };
+  }
+};
+var sendToSessionAction = {
+  name: "SEND_TO_SESSION",
+  similes: ["SESSIONS_SEND", "SEND_MESSAGE", "MESSAGE_AGENT", "A2A_SEND"],
+  description: "Send a message to another agent session. Use sessionKey or label to identify the target.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("SUBAGENT");
+    if (!svc) {
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() ?? "";
+    return text.includes("send to session") || text.includes("message session") || text.includes("send") && text.includes("agent") || text.includes("sessions_send");
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = getSubagentService(runtime);
+    const context = extractSessionContext2(runtime, message);
+    const opts = options;
+    const targetMessage = opts?.message ?? message.content.text ?? "";
+    if (!targetMessage.trim()) {
+      const msg2 = "Please specify a message to send.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    if (!opts?.sessionKey && !opts?.label) {
+      const msg2 = "Please specify either a sessionKey or label to identify the target session.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const sendParams = {
+      message: targetMessage,
+      timeoutSeconds: opts?.timeoutSeconds ?? 30
+    };
+    if (opts?.sessionKey)
+      sendParams.sessionKey = opts.sessionKey;
+    if (opts?.label)
+      sendParams.label = opts.label;
+    if (opts?.agentId)
+      sendParams.agentId = opts.agentId;
+    const result = await svc.sendToAgent(sendParams, context);
+    if (result.status === "forbidden") {
+      const msg2 = `Access denied: ${result.error}`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    if (result.status === "error") {
+      const msg2 = `Failed to send message: ${result.error ?? "unknown error"}`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    if (result.status === "timeout") {
+      const msg2 = `Request timed out waiting for response.`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const replyText = result.reply ? `
+
+Reply: ${result.reply}` : "";
+    const msg = `Message sent to ${result.sessionKey}.${replyText}`;
+    await callback?.({ content: { text: msg } });
+    return {
+      success: true,
+      text: msg,
+      data: {
+        runId: result.runId,
+        sessionKey: result.sessionKey,
+        reply: result.reply
+      }
+    };
+  }
+};
+var listSubagentsAction = {
+  name: "LIST_SUBAGENTS",
+  similes: ["SHOW_SUBAGENTS", "SUBAGENT_STATUS", "RUNNING_TASKS"],
+  description: "List active and recent subagent runs.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("SUBAGENT");
+    if (!svc) {
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() ?? "";
+    return text.includes("list subagent") || text.includes("show subagent") || text.includes("subagent status") || text.includes("running task") || text.includes("background task");
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const svc = getSubagentService(runtime);
+    const context = extractSessionContext2(runtime, message);
+    const runs = svc.listSubagentRuns(context.sessionKey);
+    if (runs.length === 0) {
+      const msg2 = "No subagent runs found.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: true, text: msg2 };
+    }
+    const lines = ["Subagent Runs:"];
+    for (const run of runs.slice(0, 20)) {
+      const status = run.outcome?.status ?? (run.endedAt ? "done" : "running");
+      const duration = run.endedAt ? formatDurationShort(run.endedAt - (run.startedAt ?? run.createdAt)) : "...";
+      const label = run.label || run.task.slice(0, 40);
+      lines.push(`- [${status}] ${label} (${duration})`);
+    }
+    const msg = lines.join(`
+`);
+    await callback?.({ content: { text: msg } });
+    return {
+      success: true,
+      text: msg,
+      data: { count: runs.length }
+    };
+  }
+};
+var cancelSubagentAction = {
+  name: "CANCEL_SUBAGENT",
+  similes: ["STOP_SUBAGENT", "ABORT_TASK", "KILL_SUBAGENT"],
+  description: "Cancel a running subagent by its run ID.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("SUBAGENT");
+    if (!svc) {
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() ?? "";
+    return (text.includes("cancel") || text.includes("stop") || text.includes("abort")) && (text.includes("subagent") || text.includes("background"));
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const svc = getSubagentService(runtime);
+    const opts = options;
+    const runId = opts?.runId;
+    if (!runId) {
+      const msg2 = "Please specify the run ID to cancel. Use LIST_SUBAGENTS to see active runs.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const cancelled = svc.cancelSubagentRun(runId);
+    if (!cancelled) {
+      const msg2 = `No active run found with ID: ${runId.slice(0, 8)}...`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const msg = `Cancelled subagent run: ${runId.slice(0, 8)}...`;
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg, data: { runId } };
+  }
+};
+var getSubagentStatusAction = {
+  name: "GET_SUBAGENT_STATUS",
+  similes: ["SUBAGENT_INFO", "TASK_STATUS", "CHECK_SUBAGENT"],
+  description: "Get detailed status of a specific subagent run.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("SUBAGENT");
+    if (!svc) {
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() ?? "";
+    return text.includes("subagent status") || text.includes("task status") || text.includes("check subagent") || text.includes("subagent info");
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const svc = getSubagentService(runtime);
+    const opts = options;
+    const runId = opts?.runId;
+    if (!runId) {
+      const msg2 = "Please specify the run ID to check. Use LIST_SUBAGENTS to see available runs.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const run = svc.getSubagentRun(runId);
+    if (!run) {
+      const msg2 = `No run found with ID: ${runId.slice(0, 8)}...`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const status = run.outcome?.status ?? (run.endedAt ? "done" : "running");
+    const duration = run.endedAt ? formatDurationShort(run.endedAt - (run.startedAt ?? run.createdAt)) : "in progress";
+    const lines = [
+      `## Subagent Run: ${runId.slice(0, 8)}...`,
+      "",
+      `**Status:** ${status}`,
+      `**Task:** ${run.task}`,
+      run.label ? `**Label:** ${run.label}` : undefined,
+      `**Duration:** ${duration}`,
+      `**Session:** ${run.childSessionKey}`,
+      run.outcome?.error ? `**Error:** ${run.outcome.error}` : undefined
+    ].filter((l) => l !== undefined);
+    const msg = lines.join(`
+`);
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg, data: { run } };
+  }
+};
+
 // src/actions/task-management.ts
 function getService(runtime) {
   const svc = runtime.getService("CODE_TASK");
@@ -13,7 +1042,11 @@ var createTaskAction = {
   name: "CREATE_TASK",
   similes: ["START_TASK", "SPAWN_TASK", "NEW_TASK", "BEGIN_TASK"],
   description: "Create an orchestrated background task to be executed by a selected agent provider.",
-  validate: async (_runtime, message) => {
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
+    }
     const text = message.content.text?.toLowerCase() ?? "";
     const hasExplicit = text.includes("create task") || text.includes("new task") || text.includes("start a task");
     const hasIntent = text.includes("implement") || text.includes("build") || text.includes("create") || text.includes("develop") || text.includes("refactor") || text.includes("fix") || text.includes("add");
@@ -44,7 +1077,10 @@ ${stepLines.map((s, i) => `${i + 1}. ${s}`).join(`
 Provider: ${task.metadata.providerLabel ?? task.metadata.providerId}
 Starting execution…`;
     await callback?.({ content: { text: msg } });
-    svc.startTaskExecution(task.id ?? "").catch(() => {});
+    svc.startTaskExecution(task.id ?? "").catch((err) => {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      svc.appendOutput(task.id ?? "", `Execution error: ${errorMsg}`).catch(() => {});
+    });
     return { success: true, text: msg, data: { taskId: task.id ?? "" } };
   }
 };
@@ -52,8 +1088,12 @@ var listTasksAction = {
   name: "LIST_TASKS",
   similes: ["SHOW_TASKS", "GET_TASKS", "TASKS", "VIEW_TASKS"],
   description: "List tasks managed by the orchestrator.",
-  validate: async (_runtime, message) => {
-    const t = message.content.text?.toLowerCase() ?? "";
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
+    }
+    const t = message.content.text?.toLowerCase() ?? "";
     return t.includes("list task") || t.includes("show task") || t === "tasks" || t.includes("my task");
   },
   handler: async (runtime, _message, _state, _options, callback) => {
@@ -80,7 +1120,11 @@ var switchTaskAction = {
   name: "SWITCH_TASK",
   similes: ["SELECT_TASK", "SET_TASK", "CHANGE_TASK", "GO_TO_TASK"],
   description: "Switch the current task context to a different task.",
-  validate: async (_runtime, message) => {
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
+    }
     const t = message.content.text?.toLowerCase() ?? "";
     return t.includes("switch to task") || t.includes("select task") || t.includes("task") && t.includes("switch");
   },
@@ -109,7 +1153,11 @@ var searchTasksAction = {
   name: "SEARCH_TASKS",
   similes: ["FIND_TASK", "LOOKUP_TASK"],
   description: "Search tasks by query.",
-  validate: async (_runtime, message) => {
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
+    }
     const t = message.content.text?.toLowerCase() ?? "";
     return t.includes("search task") || t.includes("find task") || t.includes("look for task");
   },
@@ -142,7 +1190,11 @@ var pauseTaskAction = {
   name: "PAUSE_TASK",
   similes: ["STOP_TASK", "HALT_TASK"],
   description: "Pause a running task.",
-  validate: async (_runtime, message) => {
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
+    }
     const t = message.content.text?.toLowerCase() ?? "";
     return (t.includes("pause") || t.includes("stop") || t.includes("halt")) && t.includes("task");
   },
@@ -165,7 +1217,11 @@ var resumeTaskAction = {
   name: "RESUME_TASK",
   similes: ["CONTINUE_TASK", "RESTART_TASK", "RUN_TASK"],
   description: "Resume a paused task.",
-  validate: async (_runtime, message) => {
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
+    }
     const t = message.content.text?.toLowerCase() ?? "";
     return t.includes("task") && (t.includes("resume") || t.includes("restart") || t.includes("continue"));
   },
@@ -179,7 +1235,11 @@ var resumeTaskAction = {
       return { success: false, text: msg2 };
     }
     await svc.resumeTask(task.id);
-    svc.startTaskExecution(task.id).catch(() => {});
+    const taskId = task.id;
+    svc.startTaskExecution(taskId).catch((err) => {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      svc.appendOutput(taskId, `Execution error: ${errorMsg}`).catch(() => {});
+    });
     const msg = `Resumed task: ${task.name}`;
     await callback?.({ content: { text: msg } });
     return { success: true, text: msg };
@@ -189,7 +1249,11 @@ var cancelTaskAction = {
   name: "CANCEL_TASK",
   similes: ["DELETE_TASK", "REMOVE_TASK", "ABORT_TASK"],
   description: "Cancel a task.",
-  validate: async (_runtime, message) => {
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
+    }
     const t = message.content.text?.toLowerCase() ?? "";
     return (t.includes("cancel") || t.includes("delete") || t.includes("remove")) && t.includes("task");
   },
@@ -218,6 +1282,96 @@ function getConfiguredAgentOrchestratorOptions() {
   return globalOptions;
 }
 
+// src/providers/orchestrator-config.ts
+var DEFAULT_CONFIG = {
+  subagents: {
+    enabled: true,
+    timeoutSeconds: 300,
+    allowAgents: [],
+    archiveAfterMinutes: 60
+  },
+  agentToAgent: {
+    enabled: false,
+    allow: []
+  },
+  sandbox: {
+    mode: "off",
+    scope: "session",
+    workspaceAccess: "rw"
+  }
+};
+function getOrchestratorConfig(runtime) {
+  const settings = runtime.character?.settings;
+  if (!settings) {
+    return DEFAULT_CONFIG;
+  }
+  const subagentsRaw = settings.subagents ?? {};
+  const a2aRaw = settings.agentToAgent ?? {};
+  const sandboxRaw = settings.sandbox ?? {};
+  const subagents = {
+    enabled: subagentsRaw.enabled ?? true,
+    timeoutSeconds: subagentsRaw.timeoutSeconds ?? 300,
+    allowAgents: subagentsRaw.allowAgents ?? [],
+    archiveAfterMinutes: subagentsRaw.archiveAfterMinutes ?? 60
+  };
+  if (subagentsRaw.model)
+    subagents.model = subagentsRaw.model;
+  if (subagentsRaw.thinking)
+    subagents.thinking = subagentsRaw.thinking;
+  return {
+    subagents,
+    agentToAgent: {
+      enabled: a2aRaw.enabled ?? DEFAULT_CONFIG.agentToAgent.enabled,
+      allow: a2aRaw.allow ?? DEFAULT_CONFIG.agentToAgent.allow
+    },
+    sandbox: {
+      ...DEFAULT_CONFIG.sandbox,
+      ...sandboxRaw
+    }
+  };
+}
+function formatConfigContext(config) {
+  const lines = ["## Orchestrator Configuration", ""];
+  lines.push("### Subagents");
+  lines.push(`- Enabled: ${config.subagents.enabled}`);
+  if (config.subagents.model) {
+    lines.push(`- Default Model: ${config.subagents.model}`);
+  }
+  if (config.subagents.thinking) {
+    lines.push(`- Thinking Level: ${config.subagents.thinking}`);
+  }
+  lines.push(`- Timeout: ${config.subagents.timeoutSeconds}s`);
+  const allowAgents = config.subagents.allowAgents ?? [];
+  if (allowAgents.length > 0) {
+    lines.push(`- Allowed Agents: ${allowAgents.join(", ")}`);
+  }
+  lines.push("");
+  lines.push("### Agent-to-Agent Communication");
+  lines.push(`- Enabled: ${config.agentToAgent.enabled}`);
+  if (config.agentToAgent.allow.length > 0) {
+    lines.push("- Allow Rules:");
+    for (const rule of config.agentToAgent.allow) {
+      lines.push(`  - ${rule.source} → ${rule.target}`);
+    }
+  }
+  lines.push("");
+  lines.push("### Sandbox");
+  lines.push(`- Mode: ${config.sandbox.mode ?? "off"}`);
+  lines.push(`- Scope: ${config.sandbox.scope ?? "session"}`);
+  lines.push(`- Workspace Access: ${config.sandbox.workspaceAccess ?? "rw"}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+var orchestratorConfigProvider = {
+  name: "orchestrator_config",
+  description: "Provides orchestrator configuration including subagents, A2A, and sandbox settings",
+  get: async (runtime, _message, _state) => {
+    const config = getOrchestratorConfig(runtime);
+    return { text: formatConfigContext(config) };
+  }
+};
+
 // src/providers/task-context.ts
 function getService2(runtime) {
   return runtime.getService("CODE_TASK");
@@ -279,7 +1433,7 @@ import {
   Service
 } from "@elizaos/core";
 
-// ../../../node_modules/uuid/dist-node/stringify.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/stringify.js
 var byteToHex = [];
 for (let i = 0;i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -288,7 +1442,7 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// ../../../node_modules/uuid/dist-node/rng.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/rng.js
 import { randomFillSync } from "node:crypto";
 var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
@@ -300,11 +1454,11 @@ function rng() {
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
 }
 
-// ../../../node_modules/uuid/dist-node/native.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/native.js
 import { randomUUID } from "node:crypto";
 var native_default = { randomUUID };
 
-// ../../../node_modules/uuid/dist-node/v4.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/v4.js
 function _v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random ?? options.rng?.() ?? rng();
@@ -782,12 +1936,1824 @@ Provider: ${provider.label} (${provider.id})`);
 `).trim();
   }
 }
+
+// src/services/messaging-service.ts
+import crypto2 from "node:crypto";
+import { EventEmitter as EventEmitter2 } from "node:events";
+import { EventType, Service as Service2 } from "@elizaos/core";
+class MessagingService extends Service2 {
+  static serviceType = "MESSAGING";
+  capabilityDescription = "Unified cross-platform messaging for sending messages to any supported channel";
+  emitter = new EventEmitter2;
+  adapters = new Map;
+  pendingDeliveries = new Map;
+  initialized = false;
+  static async start(runtime) {
+    const service = new MessagingService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    this.registerBuiltInAdapters();
+  }
+  registerBuiltInAdapters() {
+    this.registerAdapter({
+      channel: "discord",
+      isAvailable: () => {
+        const service = this.runtime.getService("DISCORD");
+        return !!service;
+      },
+      send: async (params) => this.sendViaDiscord(params)
+    });
+    this.registerAdapter({
+      channel: "telegram",
+      isAvailable: () => {
+        const service = this.runtime.getService("TELEGRAM");
+        return !!service;
+      },
+      send: async (params) => this.sendViaTelegram(params)
+    });
+    this.registerAdapter({
+      channel: "slack",
+      isAvailable: () => {
+        const service = this.runtime.getService("slack");
+        return !!service;
+      },
+      send: async (params) => this.sendViaSlack(params)
+    });
+    this.registerAdapter({
+      channel: "whatsapp",
+      isAvailable: () => {
+        const service = this.runtime.getService("whatsapp");
+        return !!service;
+      },
+      send: async (params) => this.sendViaWhatsApp(params)
+    });
+    this.registerAdapter({
+      channel: "twitch",
+      isAvailable: () => {
+        const service = this.runtime.getService("twitch");
+        return !!service;
+      },
+      send: async (params) => this.sendViaTwitch(params)
+    });
+    this.registerAdapter({
+      channel: "internal",
+      isAvailable: () => true,
+      send: async (params) => this.sendViaInternal(params)
+    });
+  }
+  registerAdapter(adapter) {
+    this.adapters.set(adapter.channel, adapter);
+  }
+  getAdapter(channel) {
+    return this.adapters.get(channel);
+  }
+  getAvailableChannels() {
+    const channels = [];
+    for (const [channel, adapter] of this.adapters) {
+      if (adapter.isAvailable()) {
+        channels.push(channel);
+      }
+    }
+    return channels;
+  }
+  async send(params) {
+    const idempotencyKey = params.idempotencyKey ?? crypto2.randomUUID();
+    const channel = params.target.channel;
+    const existing = this.pendingDeliveries.get(idempotencyKey);
+    if (existing) {
+      const result = {
+        success: existing.status.status === "sent" || existing.status.status === "delivered",
+        channel,
+        targetId: params.target.to
+      };
+      if (existing.status.messageId)
+        result.messageId = existing.status.messageId;
+      if (existing.status.error)
+        result.error = existing.status.error;
+      if (existing.status.status === "sent")
+        result.sentAt = existing.status.updatedAt;
+      return result;
+    }
+    const status = {
+      status: "pending",
+      updatedAt: Date.now()
+    };
+    this.pendingDeliveries.set(idempotencyKey, { params, status });
+    this.emitMessagingEvent("MESSAGING_SEND_REQUESTED", {
+      idempotencyKey,
+      channel,
+      targetId: params.target.to,
+      status: "pending"
+    });
+    const adapter = this.adapters.get(channel);
+    if (!adapter) {
+      const errorMsg = `No adapter registered for channel: ${channel}`;
+      const result = {
+        success: false,
+        channel,
+        targetId: params.target.to,
+        error: errorMsg
+      };
+      status.status = "failed";
+      status.error = errorMsg;
+      status.updatedAt = Date.now();
+      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
+        idempotencyKey,
+        channel,
+        targetId: params.target.to,
+        status: "failed",
+        error: errorMsg
+      });
+      return result;
+    }
+    if (!adapter.isAvailable()) {
+      const errorMsg = `${channel} service is not available`;
+      const result = {
+        success: false,
+        channel,
+        targetId: params.target.to,
+        error: errorMsg
+      };
+      status.status = "failed";
+      status.error = errorMsg;
+      status.updatedAt = Date.now();
+      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
+        idempotencyKey,
+        channel,
+        targetId: params.target.to,
+        status: "failed",
+        error: errorMsg
+      });
+      return result;
+    }
+    try {
+      const result = await adapter.send({ ...params, idempotencyKey });
+      status.status = result.success ? "sent" : "failed";
+      if (result.messageId)
+        status.messageId = result.messageId;
+      if (result.error)
+        status.error = result.error;
+      status.updatedAt = Date.now();
+      if (result.success) {
+        const sentPayload = {
+          idempotencyKey,
+          channel,
+          targetId: params.target.to,
+          status: "sent"
+        };
+        if (result.messageId)
+          sentPayload.messageId = result.messageId;
+        if (result.sentAt)
+          sentPayload.sentAt = result.sentAt;
+        this.emitMessagingEvent("MESSAGING_SENT", sentPayload);
+      } else {
+        const failedPayload = {
+          idempotencyKey,
+          channel,
+          targetId: params.target.to,
+          status: "failed"
+        };
+        if (result.error)
+          failedPayload.error = result.error;
+        this.emitMessagingEvent("MESSAGING_SEND_FAILED", failedPayload);
+      }
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      status.status = "failed";
+      status.error = errorMessage;
+      status.updatedAt = Date.now();
+      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
+        idempotencyKey,
+        channel,
+        targetId: params.target.to,
+        status: "failed",
+        error: errorMessage
+      });
+      return {
+        success: false,
+        channel,
+        targetId: params.target.to,
+        error: errorMessage
+      };
+    }
+  }
+  async sendToDeliveryContext(deliveryContext, content, options) {
+    const channel = this.normalizeChannel(deliveryContext.channel);
+    const to = deliveryContext.to ?? deliveryContext.accountId ?? "";
+    if (!to) {
+      return {
+        success: false,
+        channel,
+        targetId: "",
+        error: "No recipient specified in delivery context"
+      };
+    }
+    return this.send({
+      target: {
+        channel,
+        to,
+        ...deliveryContext.accountId ? { accountId: deliveryContext.accountId } : {},
+        ...deliveryContext.threadId !== undefined ? { threadId: deliveryContext.threadId } : {}
+      },
+      content,
+      ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+      ...options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  async sendToRoom(roomId, content, options) {
+    const room = await this.runtime.getRoom(roomId);
+    if (!room) {
+      return {
+        success: false,
+        channel: "unknown",
+        targetId: roomId,
+        error: `Room not found: ${roomId}`
+      };
+    }
+    const metadata = room.metadata;
+    const channel = this.normalizeChannel(metadata?.messagingChannel);
+    const to = metadata?.messagingTo ?? room.channelId ?? "";
+    if (!to) {
+      return {
+        success: false,
+        channel,
+        targetId: roomId,
+        error: "Room has no messaging target configured"
+      };
+    }
+    return this.send({
+      target: {
+        channel,
+        to,
+        ...metadata?.messagingAccountId ? { accountId: metadata.messagingAccountId } : {},
+        ...metadata?.messagingThreadId !== undefined ? { threadId: metadata.messagingThreadId } : {}
+      },
+      content,
+      ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+      ...options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  async sendToSession(sessionKey, content, options) {
+    const agentId = extractAgentIdFromSessionKey(sessionKey);
+    const roomId = sessionKeyToRoomId(sessionKey, agentId);
+    return this.sendToRoom(roomId, content, options);
+  }
+  async sendViaDiscord(params) {
+    const discordService = this.runtime.getService("DISCORD");
+    if (!discordService?.client) {
+      return {
+        success: false,
+        channel: "discord",
+        targetId: params.target.to,
+        error: "Discord service not available"
+      };
+    }
+    try {
+      const channel = await discordService.client.channels.fetch(params.target.to);
+      if (!channel?.send) {
+        return {
+          success: false,
+          channel: "discord",
+          targetId: params.target.to,
+          error: "Channel not found or not a text channel"
+        };
+      }
+      const message = await channel.send({
+        content: params.content.text,
+        ...params.target.replyToMessageId ? { reply: { messageReference: params.target.replyToMessageId } } : {}
+      });
+      return {
+        success: true,
+        messageId: message.id,
+        channel: "discord",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "discord",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async sendViaTelegram(params) {
+    const telegramService = this.runtime.getService("TELEGRAM");
+    if (!telegramService?.bot?.telegram) {
+      return {
+        success: false,
+        channel: "telegram",
+        targetId: params.target.to,
+        error: "Telegram service not available"
+      };
+    }
+    try {
+      const chatId = Number.isNaN(Number(params.target.to)) ? params.target.to : Number(params.target.to);
+      const result = await telegramService.bot.telegram.sendMessage(chatId, params.content.text, {
+        reply_to_message_id: params.target.replyToMessageId ? Number(params.target.replyToMessageId) : undefined,
+        disable_web_page_preview: params.content.disableLinkPreview,
+        disable_notification: params.content.silent
+      });
+      return {
+        success: true,
+        messageId: String(result.message_id),
+        channel: "telegram",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "telegram",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async sendViaSlack(params) {
+    const slackService = this.runtime.getService("slack");
+    if (!slackService?.sendMessage) {
+      return {
+        success: false,
+        channel: "slack",
+        targetId: params.target.to,
+        error: "Slack service not available or sendMessage method not found"
+      };
+    }
+    try {
+      const result = await slackService.sendMessage(params.target.to, params.content.text, {
+        ...params.target.threadId ? { threadTs: String(params.target.threadId) } : {},
+        replyBroadcast: false
+      });
+      return {
+        success: true,
+        messageId: result.ts,
+        channel: "slack",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "slack",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async sendViaWhatsApp(params) {
+    const whatsappService = this.runtime.getService("whatsapp");
+    if (!whatsappService?.sendText) {
+      return {
+        success: false,
+        channel: "whatsapp",
+        targetId: params.target.to,
+        error: "WhatsApp service not available or sendText method not found"
+      };
+    }
+    try {
+      const result = await whatsappService.sendText(params.target.to, params.content.text);
+      const messageId = result.messages?.[0]?.id;
+      return {
+        success: true,
+        ...messageId ? { messageId } : {},
+        channel: "whatsapp",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "whatsapp",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async sendViaTwitch(params) {
+    const twitchService = this.runtime.getService("twitch");
+    if (!twitchService?.sendMessage) {
+      return {
+        success: false,
+        channel: "twitch",
+        targetId: params.target.to,
+        error: "Twitch service not available or sendMessage method not found"
+      };
+    }
+    try {
+      const result = await twitchService.sendMessage(params.content.text, {
+        channel: params.target.to,
+        ...params.target.replyToMessageId ? { replyTo: params.target.replyToMessageId } : {}
+      });
+      return {
+        success: result.success,
+        ...result.messageId !== undefined ? { messageId: result.messageId } : {},
+        channel: "twitch",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "twitch",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async sendViaInternal(params) {
+    const roomId = params.target.to;
+    const messageId = crypto2.randomUUID();
+    try {
+      const memory = {
+        id: messageId,
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId,
+        content: {
+          text: params.content.text,
+          type: "text",
+          source: "internal",
+          metadata: {
+            isInternalMessage: true,
+            idempotencyKey: params.idempotencyKey
+          }
+        },
+        createdAt: Date.now()
+      };
+      await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message: memory,
+        source: "internal_messaging"
+      });
+      return {
+        success: true,
+        messageId,
+        channel: "internal",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "internal",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  normalizeChannel(channel) {
+    if (!channel) {
+      return "unknown";
+    }
+    const lower = channel.toLowerCase();
+    if (lower === "discord" || lower.includes("discord")) {
+      return "discord";
+    }
+    if (lower === "telegram" || lower.includes("telegram")) {
+      return "telegram";
+    }
+    if (lower === "slack" || lower.includes("slack")) {
+      return "slack";
+    }
+    if (lower === "whatsapp" || lower.includes("whatsapp")) {
+      return "whatsapp";
+    }
+    if (lower === "twitch" || lower.includes("twitch")) {
+      return "twitch";
+    }
+    if (lower === "google_chat" || lower.includes("google") || lower.includes("gchat")) {
+      return "google_chat";
+    }
+    if (lower === "internal" || lower === "a2a") {
+      return "internal";
+    }
+    return "unknown";
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  emitMessagingEvent(type, payload) {
+    this.emitter.emit(type, payload);
+    this.emitter.emit("messaging", { type, ...payload });
+  }
+  async stop() {
+    this.pendingDeliveries.clear();
+    this.emitter.removeAllListeners();
+  }
+}
+
+// src/services/sandbox-service.ts
+import { spawn } from "node:child_process";
+import { EventEmitter as EventEmitter3 } from "node:events";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Service as Service3 } from "@elizaos/core";
+var DEFAULT_DOCKER_CONFIG = {
+  image: "ubuntu:22.04",
+  containerPrefix: "eliza-sandbox",
+  workdir: "/workspace",
+  autoRemove: true,
+  memoryLimit: "2g",
+  cpuLimit: "2",
+  network: "none",
+  env: {},
+  mounts: [],
+  extraArgs: []
+};
+var DEFAULT_BROWSER_CONFIG = {
+  enabled: false,
+  image: "browserless/chrome:latest",
+  containerPrefix: "eliza-browser",
+  cdpPort: 9222,
+  vncPort: 5900,
+  noVncPort: 6080,
+  headless: true,
+  enableNoVnc: false,
+  allowHostControl: false,
+  autoStart: false,
+  autoStartTimeoutMs: 30000
+};
+var DEFAULT_PRUNE_CONFIG = {
+  idleHours: 1,
+  maxAgeDays: 7
+};
+
+class SandboxService extends Service3 {
+  static serviceType = "SANDBOX";
+  capabilityDescription = "Manages sandboxed execution environments for secure tool execution";
+  emitter = new EventEmitter3;
+  contexts = new Map;
+  activeContainers = new Set;
+  containerLocks = new Map;
+  sweeper = null;
+  initialized = false;
+  static async start(runtime) {
+    const service = new SandboxService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    this.startSweeper();
+  }
+  getConfig() {
+    const settings = this.runtime.character?.settings;
+    const sandbox = settings?.sandbox ?? {};
+    return {
+      mode: sandbox.mode ?? "off",
+      scope: sandbox.scope ?? "session",
+      workspaceAccess: sandbox.workspaceAccess ?? "rw",
+      workspaceRoot: sandbox.workspaceRoot ?? path.join(os.homedir(), ".eliza", "sandboxes"),
+      docker: { ...DEFAULT_DOCKER_CONFIG, ...sandbox.docker },
+      browser: { ...DEFAULT_BROWSER_CONFIG, ...sandbox.browser },
+      tools: sandbox.tools ?? { allow: [], deny: [] },
+      prune: { ...DEFAULT_PRUNE_CONFIG, ...sandbox.prune }
+    };
+  }
+  shouldSandbox(sessionKey) {
+    const config = this.getConfig();
+    if (config.mode === "off") {
+      return false;
+    }
+    if (config.mode === "all") {
+      return true;
+    }
+    const parsed = parseSessionKey(sessionKey);
+    if (parsed.keyType === "subagent") {
+      return true;
+    }
+    const identifier = parsed.identifier.toLowerCase();
+    if (identifier === "main" || identifier === "global") {
+      return false;
+    }
+    return true;
+  }
+  isToolAllowed(toolName, policy) {
+    const config = this.getConfig();
+    const p = policy ?? config.tools;
+    if (p.allow && p.allow.length > 0) {
+      const allowed = p.allow.some((pattern) => pattern === "*" || pattern.toLowerCase() === toolName.toLowerCase() || pattern.endsWith("*") && toolName.toLowerCase().startsWith(pattern.slice(0, -1).toLowerCase()));
+      if (allowed) {
+        return true;
+      }
+    }
+    if (p.deny && p.deny.length > 0) {
+      const denied = p.deny.some((pattern) => pattern === "*" || pattern.toLowerCase() === toolName.toLowerCase() || pattern.endsWith("*") && toolName.toLowerCase().startsWith(pattern.slice(0, -1).toLowerCase()));
+      if (denied) {
+        return false;
+      }
+    }
+    return !p.allow || p.allow.length === 0;
+  }
+  async getSandboxContext(sessionKey, options) {
+    const trimmedKey = sessionKey.trim();
+    if (!trimmedKey) {
+      return null;
+    }
+    if (!this.shouldSandbox(trimmedKey)) {
+      return null;
+    }
+    const cached = this.contexts.get(trimmedKey);
+    if (cached) {
+      cached.lastAccessedAt = Date.now();
+      return cached;
+    }
+    const config = this.getConfig();
+    const agentId = extractAgentIdFromSessionKey(trimmedKey);
+    const agentWorkspaceDir = options?.workspaceDir ?? path.join(os.homedir(), ".eliza", "workspace");
+    const scopeKey = this.resolveScopeKey(config.scope, trimmedKey);
+    const sandboxWorkspaceDir = config.scope === "shared" ? config.workspaceRoot : path.join(config.workspaceRoot, scopeKey);
+    const workspaceDir = config.workspaceAccess === "rw" ? agentWorkspaceDir : sandboxWorkspaceDir;
+    await fs.mkdir(workspaceDir, { recursive: true });
+    const containerName = `${config.docker.containerPrefix}-${scopeKey.slice(0, 12)}`;
+    const context = {
+      enabled: true,
+      sessionKey: trimmedKey,
+      roomId: options?.roomId ?? sessionKeyToRoomId(trimmedKey, agentId),
+      workspaceDir,
+      agentWorkspaceDir,
+      workspaceAccess: config.workspaceAccess,
+      containerName,
+      containerWorkdir: config.docker.workdir,
+      docker: config.docker,
+      tools: config.tools,
+      browserAllowHostControl: config.browser.allowHostControl,
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now()
+    };
+    this.contexts.set(trimmedKey, context);
+    this.emitSandboxEvent("SANDBOX_CREATED", {
+      sessionKey: trimmedKey,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
+      containerName
+    });
+    return context;
+  }
+  resolveScopeKey(scope, sessionKey) {
+    const parsed = parseSessionKey(sessionKey);
+    switch (scope) {
+      case "session":
+        return hashToUUID(sessionKey).slice(0, 16);
+      case "agent":
+        return hashToUUID(parsed.agentId).slice(0, 16);
+      case "shared":
+        return "shared";
+      default:
+        return hashToUUID(sessionKey).slice(0, 16);
+    }
+  }
+  async destroySandbox(sessionKey) {
+    const context = this.contexts.get(sessionKey);
+    if (!context) {
+      return;
+    }
+    if (this.activeContainers.has(context.containerName)) {
+      await this.stopContainer(context.containerName);
+    }
+    if (context.browser) {
+      await this.stopContainer(context.browser.containerName);
+    }
+    this.contexts.delete(sessionKey);
+    this.emitSandboxEvent("SANDBOX_DESTROYED", {
+      sessionKey,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
+      containerName: context.containerName
+    });
+  }
+  async execute(sessionKey, params) {
+    const context = await this.getSandboxContext(sessionKey);
+    if (!context) {
+      return this.executeLocal(params);
+    }
+    const startTime = Date.now();
+    this.emitSandboxEvent("SANDBOX_COMMAND_STARTED", {
+      sessionKey,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
+      containerName: context.containerName,
+      command: params.command
+    });
+    try {
+      const result = await this.executeInContainer(context, params);
+      this.emitSandboxEvent("SANDBOX_COMMAND_COMPLETED", {
+        sessionKey,
+        ...context.roomId !== undefined ? { roomId: context.roomId } : {},
+        containerName: context.containerName,
+        command: params.command,
+        result
+      });
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const result = {
+        success: false,
+        exitCode: 1,
+        stdout: "",
+        stderr: errorMessage,
+        durationMs: Date.now() - startTime,
+        timedOut: false,
+        error: errorMessage
+      };
+      this.emitSandboxEvent("SANDBOX_COMMAND_FAILED", {
+        sessionKey,
+        ...context.roomId !== undefined ? { roomId: context.roomId } : {},
+        containerName: context.containerName,
+        command: params.command,
+        result,
+        error: errorMessage
+      });
+      return result;
+    }
+  }
+  executeLocal(params) {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const timeout = params.timeoutMs ?? 60000;
+      const child = spawn(params.command, params.args ?? [], {
+        cwd: params.cwd,
+        env: { ...process.env, ...params.env },
+        shell: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      const timeoutId = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, timeout);
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      if (params.stdin) {
+        child.stdin?.write(params.stdin);
+        child.stdin?.end();
+      }
+      child.on("close", (code) => {
+        clearTimeout(timeoutId);
+        const result = {
+          success: code === 0 && !timedOut,
+          exitCode: code ?? 1,
+          stdout: stdout.slice(0, 1e5),
+          stderr: stderr.slice(0, 1e5),
+          durationMs: Date.now() - startTime,
+          timedOut
+        };
+        if (timedOut)
+          result.error = "Command timed out";
+        resolve(result);
+      });
+      child.on("error", (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          success: false,
+          exitCode: 1,
+          stdout,
+          stderr: error.message,
+          durationMs: Date.now() - startTime,
+          timedOut: false,
+          error: error.message
+        });
+      });
+    });
+  }
+  executeDockerCommand(args, options) {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const timeout = options?.timeoutMs ?? 60000;
+      const child = spawn("docker", args, {
+        env: process.env
+      });
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      const timeoutId = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, timeout);
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        clearTimeout(timeoutId);
+        const result = {
+          success: code === 0 && !timedOut,
+          exitCode: code ?? 1,
+          stdout: stdout.slice(0, 1e5),
+          stderr: stderr.slice(0, 1e5),
+          durationMs: Date.now() - startTime,
+          timedOut
+        };
+        if (timedOut)
+          result.error = "Command timed out";
+        resolve(result);
+      });
+      child.on("error", (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          success: false,
+          exitCode: 1,
+          stdout,
+          stderr: error.message,
+          durationMs: Date.now() - startTime,
+          timedOut: false,
+          error: error.message
+        });
+      });
+    });
+  }
+  async executeInContainer(context, params) {
+    const startTime = Date.now();
+    const timeout = params.timeoutMs ?? 60000;
+    await this.ensureContainer(context);
+    const dockerArgs = ["exec"];
+    const workdir = params.cwd ? path.join(context.containerWorkdir, params.cwd) : context.containerWorkdir;
+    dockerArgs.push("-w", workdir);
+    for (const [key, value] of Object.entries(params.env ?? {})) {
+      dockerArgs.push("-e", `${key}=${value}`);
+    }
+    dockerArgs.push(context.containerName);
+    dockerArgs.push("sh", "-c", params.command);
+    return new Promise((resolve) => {
+      const child = spawn("docker", dockerArgs, {
+        env: process.env
+      });
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      const timeoutId = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, timeout);
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      if (params.stdin) {
+        child.stdin?.write(params.stdin);
+        child.stdin?.end();
+      }
+      child.on("close", (code) => {
+        clearTimeout(timeoutId);
+        const result = {
+          success: code === 0 && !timedOut,
+          exitCode: code ?? 1,
+          stdout: stdout.slice(0, 1e5),
+          stderr: stderr.slice(0, 1e5),
+          durationMs: Date.now() - startTime,
+          timedOut
+        };
+        if (timedOut)
+          result.error = "Command timed out";
+        resolve(result);
+      });
+      child.on("error", (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          success: false,
+          exitCode: 1,
+          stdout,
+          stderr: error.message,
+          durationMs: Date.now() - startTime,
+          timedOut: false,
+          error: error.message
+        });
+      });
+    });
+  }
+  async ensureContainer(context) {
+    if (this.activeContainers.has(context.containerName)) {
+      return;
+    }
+    const existingLock = this.containerLocks.get(context.containerName);
+    if (existingLock) {
+      await existingLock;
+      return;
+    }
+    const lockPromise = this.ensureContainerInternal(context);
+    this.containerLocks.set(context.containerName, lockPromise);
+    try {
+      await lockPromise;
+    } finally {
+      this.containerLocks.delete(context.containerName);
+    }
+  }
+  async ensureContainerInternal(context) {
+    if (this.activeContainers.has(context.containerName)) {
+      return;
+    }
+    const checkResult = await this.executeDockerCommand([
+      "ps",
+      "-a",
+      "-q",
+      "-f",
+      `name=^${context.containerName}$`
+    ]);
+    if (checkResult.stdout.trim()) {
+      const startResult = await this.executeDockerCommand(["start", context.containerName]);
+      if (startResult.success) {
+        this.activeContainers.add(context.containerName);
+        return;
+      }
+    }
+    const dockerArgs = ["run", "-d", "--name", context.containerName];
+    if (context.docker.memoryLimit) {
+      dockerArgs.push("-m", context.docker.memoryLimit);
+    }
+    if (context.docker.cpuLimit) {
+      dockerArgs.push("--cpus", context.docker.cpuLimit);
+    }
+    if (context.docker.network) {
+      dockerArgs.push("--network", context.docker.network);
+    }
+    const mountMode = context.workspaceAccess === "ro" ? "ro" : "rw";
+    dockerArgs.push("-v", `${context.workspaceDir}:${context.containerWorkdir}:${mountMode}`);
+    for (const mount of context.docker.mounts ?? []) {
+      dockerArgs.push("-v", `${mount.host}:${mount.container}:${mount.mode}`);
+    }
+    for (const [key, value] of Object.entries(context.docker.env ?? {})) {
+      dockerArgs.push("-e", `${key}=${value}`);
+    }
+    if (context.docker.extraArgs) {
+      dockerArgs.push(...context.docker.extraArgs);
+    }
+    dockerArgs.push(context.docker.image, "tail", "-f", "/dev/null");
+    const result = await this.executeDockerCommand(dockerArgs);
+    if (result.success) {
+      this.activeContainers.add(context.containerName);
+    } else {
+      throw new Error(`Failed to create container: ${result.stderr}`);
+    }
+  }
+  async stopContainer(containerName) {
+    await this.executeDockerCommand(["stop", containerName], { timeoutMs: 1e4 });
+    await this.executeDockerCommand(["rm", "-f", containerName], { timeoutMs: 1e4 });
+    this.activeContainers.delete(containerName);
+  }
+  async startBrowser(sessionKey) {
+    const context = await this.getSandboxContext(sessionKey);
+    if (!context) {
+      return null;
+    }
+    const config = this.getConfig();
+    if (!config.browser.enabled) {
+      return null;
+    }
+    if (context.browser) {
+      return context.browser;
+    }
+    const browserContainerName = `${config.browser.containerPrefix}-${context.containerName.slice(-12)}`;
+    const browserArgs = [
+      "run",
+      "-d",
+      "--name",
+      browserContainerName,
+      "-p",
+      `${config.browser.cdpPort}:9222`
+    ];
+    if (config.browser.enableNoVnc) {
+      browserArgs.push("-p", `${config.browser.noVncPort}:6080`);
+    }
+    browserArgs.push(config.browser.image);
+    const result = await this.executeDockerCommand(browserArgs);
+    if (!result.success) {
+      this.runtime.logger.error({
+        sessionKey,
+        error: result.stderr
+      }, "Failed to start browser container");
+      return null;
+    }
+    const browserContext = {
+      bridgeUrl: `http://localhost:${config.browser.cdpPort}`,
+      ...config.browser.enableNoVnc ? { noVncUrl: `http://localhost:${config.browser.noVncPort}` } : {},
+      containerName: browserContainerName
+    };
+    context.browser = browserContext;
+    this.emitSandboxEvent("SANDBOX_BROWSER_STARTED", {
+      sessionKey,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
+      containerName: browserContainerName
+    });
+    return browserContext;
+  }
+  async stopBrowser(sessionKey) {
+    const context = this.contexts.get(sessionKey);
+    if (!context?.browser) {
+      return;
+    }
+    await this.stopContainer(context.browser.containerName);
+    this.emitSandboxEvent("SANDBOX_BROWSER_STOPPED", {
+      sessionKey,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
+      containerName: context.browser.containerName
+    });
+    delete context.browser;
+  }
+  startSweeper() {
+    if (this.sweeper) {
+      return;
+    }
+    const config = this.getConfig();
+    const intervalMs = Math.max(config.prune.idleHours * 60 * 60 * 1000 / 4, 60000);
+    this.sweeper = setInterval(() => {
+      this.sweepIdleSandboxes();
+    }, intervalMs);
+    this.sweeper.unref?.();
+  }
+  sweepIdleSandboxes() {
+    const config = this.getConfig();
+    const idleMs = config.prune.idleHours * 60 * 60 * 1000;
+    const maxAgeMs = config.prune.maxAgeDays * 24 * 60 * 60 * 1000;
+    const now2 = Date.now();
+    for (const [sessionKey, context] of this.contexts.entries()) {
+      const idle = now2 - context.lastAccessedAt > idleMs;
+      const tooOld = now2 - context.createdAt > maxAgeMs;
+      if (idle || tooOld) {
+        this.destroySandbox(sessionKey).catch((err) => {
+          this.runtime.logger.error({
+            sessionKey,
+            error: err instanceof Error ? err.message : String(err)
+          }, "Failed to destroy idle sandbox");
+        });
+      }
+    }
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  emitSandboxEvent(type, payload) {
+    this.emitter.emit(type, payload);
+    this.emitter.emit("sandbox", { type, ...payload });
+  }
+  async stop() {
+    if (this.sweeper) {
+      clearInterval(this.sweeper);
+      this.sweeper = null;
+    }
+    for (const sessionKey of this.contexts.keys()) {
+      await this.destroySandbox(sessionKey);
+    }
+    this.emitter.removeAllListeners();
+  }
+}
+
+// src/services/subagent-service.ts
+import crypto3 from "node:crypto";
+import { EventEmitter as EventEmitter4 } from "node:events";
+import {
+  ChannelType,
+  EventType as EventType2,
+  Service as Service4
+} from "@elizaos/core";
+class SubagentService extends Service4 {
+  static serviceType = "SUBAGENT";
+  capabilityDescription = "Manages subagent spawning, lifecycle, and communication";
+  emitter = new EventEmitter4;
+  subagentRuns = new Map;
+  activeRuns = new Map;
+  sweeper = null;
+  initialized = false;
+  static async start(runtime) {
+    const service = new SubagentService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    this.runtime.registerEvent(EventType2.RUN_ENDED, async (payload) => {
+      await this.handleRunEnded(payload);
+    });
+    this.runtime.registerEvent(EventType2.RUN_TIMEOUT, async (payload) => {
+      await this.handleRunTimeout(payload);
+    });
+    this.startSweeper();
+  }
+  getConfig() {
+    const settings = this.runtime.character?.settings;
+    const subagents = settings?.subagents ?? {};
+    return {
+      enabled: subagents.enabled !== false,
+      ...subagents.model !== undefined ? { model: subagents.model } : {},
+      ...subagents.thinking !== undefined ? { thinking: subagents.thinking } : {},
+      timeoutSeconds: subagents.timeoutSeconds ?? 300,
+      allowAgents: subagents.allowAgents ?? [],
+      archiveAfterMinutes: subagents.archiveAfterMinutes ?? 60
+    };
+  }
+  getAgentToAgentPolicy() {
+    const settings = this.runtime.character?.settings;
+    const a2aConfig = settings?.agentToAgent ?? {};
+    const enabled = a2aConfig.enabled === true;
+    const allowRules = (a2aConfig.allow ?? []).map((rule) => ({
+      source: rule.source ?? "*",
+      target: rule.target ?? "*"
+    }));
+    return {
+      enabled,
+      allowRules,
+      isAllowed: (sourceAgentId, targetAgentId) => {
+        if (!enabled) {
+          return false;
+        }
+        if (sourceAgentId === targetAgentId) {
+          return true;
+        }
+        const sourceNorm = normalizeAgentId2(sourceAgentId);
+        const targetNorm = normalizeAgentId2(targetAgentId);
+        for (const rule of allowRules) {
+          const sourceMatch = rule.source === "*" || normalizeAgentId2(rule.source) === sourceNorm;
+          const targetMatch = rule.target === "*" || normalizeAgentId2(rule.target) === targetNorm;
+          if (sourceMatch && targetMatch) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+  }
+  async spawnSubagent(params, requesterContext) {
+    const config = this.getConfig();
+    if (!config.enabled) {
+      return {
+        status: "forbidden",
+        error: "Subagent spawning is disabled"
+      };
+    }
+    if (requesterContext.sessionKey && isSubagentSessionKey2(requesterContext.sessionKey)) {
+      return {
+        status: "forbidden",
+        error: "sessions_spawn is not allowed from sub-agent sessions"
+      };
+    }
+    const requesterAgentId = requesterContext.sessionKey ? extractAgentIdFromSessionKey(requesterContext.sessionKey) : this.runtime.character?.name ?? "unknown";
+    const targetAgentId = params.agentId ? normalizeAgentId2(params.agentId) : requesterAgentId;
+    if (targetAgentId !== requesterAgentId) {
+      const allowAgents = config.allowAgents ?? [];
+      const allowAny = allowAgents.some((v) => v.trim() === "*");
+      const allowSet = new Set(allowAgents.filter((v) => v.trim() && v.trim() !== "*").map((v) => normalizeAgentId2(v)));
+      if (!allowAny && !allowSet.has(targetAgentId)) {
+        return {
+          status: "forbidden",
+          error: `agentId "${targetAgentId}" is not allowed for subagent spawning`
+        };
+      }
+    }
+    const childSessionKey = createSubagentSessionKey(targetAgentId);
+    const runId = crypto3.randomUUID();
+    const childRoomId = sessionKeyToRoomId(childSessionKey, targetAgentId);
+    const roomMetadata = {
+      isSubagent: true,
+      sessionKey: childSessionKey,
+      task: params.task,
+      spawnedAt: Date.now(),
+      cleanup: params.cleanup ?? "keep"
+    };
+    if (requesterContext.roomId)
+      roomMetadata.parentRoomId = requesterContext.roomId;
+    if (requesterContext.sessionKey)
+      roomMetadata.parentSessionKey = requesterContext.sessionKey;
+    if (params.label)
+      roomMetadata.label = params.label;
+    const childRoom = {
+      id: childRoomId,
+      name: params.label || `Subagent: ${params.task.slice(0, 50)}`,
+      source: "subagent",
+      type: ChannelType.SELF,
+      channelId: childSessionKey,
+      agentId: this.runtime.agentId,
+      worldId: this.runtime.agentId,
+      metadata: roomMetadata
+    };
+    await this.runtime.ensureRoomExists(childRoom);
+    const now2 = Date.now();
+    const archiveAfterMs = config.archiveAfterMinutes ? config.archiveAfterMinutes * 60000 : undefined;
+    const record = {
+      runId,
+      childSessionKey,
+      requesterSessionKey: requesterContext.sessionKey ?? "unknown",
+      requesterDisplayKey: requesterContext.sessionKey ?? "main",
+      task: params.task,
+      cleanup: params.cleanup ?? "keep",
+      createdAt: now2,
+      startedAt: now2,
+      cleanupHandled: false,
+      roomId: childRoomId,
+      worldId: this.runtime.agentId
+    };
+    const normalizedOrigin = normalizeDeliveryContext(requesterContext.origin);
+    if (normalizedOrigin)
+      record.requesterOrigin = normalizedOrigin;
+    if (params.label)
+      record.label = params.label;
+    if (archiveAfterMs)
+      record.archiveAtMs = now2 + archiveAfterMs;
+    this.subagentRuns.set(runId, record);
+    const spawnPayload = {
+      runId,
+      childSessionKey,
+      childRoomId,
+      task: params.task
+    };
+    if (requesterContext.sessionKey)
+      spawnPayload.requesterSessionKey = requesterContext.sessionKey;
+    if (requesterContext.roomId)
+      spawnPayload.requesterRoomId = requesterContext.roomId;
+    if (params.label)
+      spawnPayload.label = params.label;
+    this.emitSubagentEvent("SUBAGENT_SPAWN_REQUESTED", spawnPayload);
+    const systemPromptParams = {
+      childSessionKey,
+      task: params.task
+    };
+    if (requesterContext.sessionKey)
+      systemPromptParams.requesterSessionKey = requesterContext.sessionKey;
+    if (requesterContext.origin)
+      systemPromptParams.requesterOrigin = requesterContext.origin;
+    if (params.label)
+      systemPromptParams.label = params.label;
+    const systemPrompt = this.buildSubagentSystemPrompt(systemPromptParams);
+    const taskMetadata = {
+      isSubagentTask: true,
+      runId,
+      systemPromptOverride: systemPrompt
+    };
+    const modelOverride = params.model || config.model;
+    const thinkingOverride = params.thinking || config.thinking;
+    if (modelOverride)
+      taskMetadata.modelOverride = modelOverride;
+    if (thinkingOverride)
+      taskMetadata.thinkingOverride = thinkingOverride;
+    const initialMessage = {
+      id: hashToUUID(`${runId}-initial`),
+      entityId: this.runtime.agentId,
+      agentId: this.runtime.agentId,
+      roomId: childRoomId,
+      content: {
+        text: params.task,
+        type: "text",
+        metadata: taskMetadata
+      }
+    };
+    this.executeSubagentRun(runId, initialMessage, params.runTimeoutSeconds).catch((error) => {
+      this.runtime.logger.error(`Subagent execution error [runId=${runId}]: ${error}`);
+      this.handleSubagentError(runId, error);
+    });
+    return {
+      status: "accepted",
+      childSessionKey,
+      childRoomId,
+      runId,
+      modelApplied: !!(params.model || config.model)
+    };
+  }
+  async executeSubagentRun(runId, initialMessage, timeoutSeconds) {
+    const config = this.getConfig();
+    const timeout = (timeoutSeconds ?? config.timeoutSeconds ?? 300) * 1000;
+    const controller = new AbortController;
+    this.activeRuns.set(runId, controller);
+    const timeoutId = timeout > 0 ? setTimeout(() => {
+      controller.abort();
+      this.handleSubagentTimeout(runId);
+    }, timeout) : null;
+    try {
+      await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message: initialMessage,
+        source: "subagent"
+      });
+      await this.waitForCompletion(runId, timeout, controller.signal);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      this.activeRuns.delete(runId);
+    }
+  }
+  async waitForCompletion(runId, timeoutMs, signal) {
+    const startTime = Date.now();
+    const pollInterval = 500;
+    while (!signal.aborted) {
+      const record = this.subagentRuns.get(runId);
+      if (!record) {
+        return;
+      }
+      if (record.endedAt) {
+        return;
+      }
+      if (Date.now() - startTime > timeoutMs + 5000) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+  handleSubagentTimeout(runId) {
+    const record = this.subagentRuns.get(runId);
+    if (!record || record.endedAt) {
+      return;
+    }
+    record.endedAt = Date.now();
+    record.outcome = { status: "timeout" };
+    const timeoutPayload = {
+      runId,
+      childSessionKey: record.childSessionKey,
+      task: record.task,
+      status: "timeout"
+    };
+    if (record.roomId)
+      timeoutPayload.childRoomId = record.roomId;
+    this.emitSubagentEvent("SUBAGENT_RUN_TIMEOUT", timeoutPayload);
+    this.announceSubagentResult(runId).catch((err) => {
+      this.runtime.logger.error(`Failed to announce timeout [runId=${runId}]: ${err}`);
+    });
+  }
+  handleSubagentError(runId, error) {
+    const record = this.subagentRuns.get(runId);
+    if (!record) {
+      return;
+    }
+    record.endedAt = Date.now();
+    record.outcome = {
+      status: "error",
+      error: error instanceof Error ? error.message : String(error)
+    };
+    const errorPayload = {
+      runId,
+      childSessionKey: record.childSessionKey,
+      task: record.task,
+      status: "error"
+    };
+    if (record.outcome.error)
+      errorPayload.error = record.outcome.error;
+    if (record.roomId)
+      errorPayload.childRoomId = record.roomId;
+    this.emitSubagentEvent("SUBAGENT_RUN_FAILED", errorPayload);
+    this.announceSubagentResult(runId).catch((err) => {
+      this.runtime.logger.error(`Failed to announce error [runId=${runId}]: ${err}`);
+    });
+  }
+  async handleRunEnded(payload) {
+    const p = payload;
+    if (!p.roomId) {
+      return;
+    }
+    for (const [runId, record] of this.subagentRuns.entries()) {
+      if (record.roomId === p.roomId && !record.endedAt) {
+        record.endedAt = Date.now();
+        record.outcome = { status: "ok" };
+        const completedPayload = {
+          runId,
+          childSessionKey: record.childSessionKey,
+          childRoomId: record.roomId,
+          task: record.task,
+          status: "completed",
+          endedAt: record.endedAt,
+          durationMs: record.endedAt - (record.startedAt ?? record.createdAt)
+        };
+        if (record.startedAt)
+          completedPayload.startedAt = record.startedAt;
+        this.emitSubagentEvent("SUBAGENT_RUN_COMPLETED", completedPayload);
+        await this.announceSubagentResult(runId);
+        break;
+      }
+    }
+  }
+  async handleRunTimeout(payload) {
+    const p = payload;
+    if (!p.roomId) {
+      return;
+    }
+    for (const [runId, record] of this.subagentRuns.entries()) {
+      if (record.roomId === p.roomId && !record.endedAt) {
+        this.handleSubagentTimeout(runId);
+        break;
+      }
+    }
+  }
+  async announceSubagentResult(runId) {
+    const record = this.subagentRuns.get(runId);
+    if (!record) {
+      return false;
+    }
+    if (record.cleanupCompletedAt || record.cleanupHandled) {
+      return false;
+    }
+    record.cleanupHandled = true;
+    let reply;
+    if (record.roomId) {
+      const memories = await this.runtime.getMemories({
+        tableName: "messages",
+        roomId: record.roomId,
+        count: 10
+      });
+      const lastAssistant = memories.filter((m) => m.entityId === this.runtime.agentId).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0];
+      reply = lastAssistant?.content?.text;
+    }
+    const durationMs = record.endedAt ? record.endedAt - (record.startedAt ?? record.createdAt) : undefined;
+    const statsLine = `Runtime: ${formatDurationShort(durationMs) ?? "n/a"} • Session: ${record.childSessionKey}`;
+    const outcome = record.outcome ?? { status: "unknown" };
+    const statusLabel = outcome.status === "ok" ? "completed successfully" : outcome.status === "timeout" ? "timed out" : outcome.status === "error" ? `failed: ${outcome.error || "unknown error"}` : "finished with unknown status";
+    const taskLabel = record.label || record.task || "background task";
+    const triggerMessage = [
+      `A background task "${taskLabel}" just ${statusLabel}.`,
+      "",
+      "Findings:",
+      reply || "(no output)",
+      "",
+      statsLine,
+      "",
+      "Summarize this naturally for the user. Keep it brief (1-2 sentences).",
+      "Do not mention technical details like tokens, stats, or that this was a background task.",
+      "You can respond with NO_REPLY if no announcement is needed."
+    ].join(`
+`);
+    if (record.requesterSessionKey && record.requesterSessionKey !== "unknown") {
+      const requesterRoomId = sessionKeyToRoomId(record.requesterSessionKey, extractAgentIdFromSessionKey(record.requesterSessionKey));
+      const metadata = {
+        isSubagentAnnouncement: true,
+        subagentRunId: runId
+      };
+      if (record.requesterOrigin) {
+        metadata.deliveryContext = record.requesterOrigin;
+      }
+      const announceMessage = {
+        id: hashToUUID(`${runId}-announce`),
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId: requesterRoomId,
+        content: {
+          text: triggerMessage,
+          type: "text",
+          metadata
+        }
+      };
+      await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message: announceMessage,
+        source: "subagent_announce"
+      });
+    }
+    const announcePayload = {
+      runId,
+      childSessionKey: record.childSessionKey,
+      task: record.task,
+      outcome
+    };
+    if (record.requesterSessionKey)
+      announcePayload.requesterSessionKey = record.requesterSessionKey;
+    this.emitSubagentEvent("SUBAGENT_ANNOUNCE_SENT", announcePayload);
+    record.cleanupCompletedAt = Date.now();
+    if (record.cleanup === "delete") {
+      this.subagentRuns.delete(runId);
+    }
+    return true;
+  }
+  buildSubagentSystemPrompt(params) {
+    const taskText = typeof params.task === "string" && params.task.trim() ? params.task.replace(/\s+/g, " ").trim() : "{{TASK_DESCRIPTION}}";
+    const lines = [
+      "# Subagent Context",
+      "",
+      "You are a **subagent** spawned by the main agent for a specific task.",
+      "",
+      "## Your Role",
+      `- You were created to handle: ${taskText}`,
+      "- Complete this task. That's your entire purpose.",
+      "- You are NOT the main agent. Don't try to be.",
+      "",
+      "## Rules",
+      "1. **Stay focused** - Do your assigned task, nothing else",
+      "2. **Complete the task** - Your final message will be automatically reported to the main agent",
+      "3. **Don't initiate** - No heartbeats, no proactive actions, no side quests",
+      "4. **Be ephemeral** - You may be terminated after task completion. That's fine.",
+      "",
+      "## Output Format",
+      "When complete, your final response should include:",
+      "- What you accomplished or found",
+      "- Any relevant details the main agent should know",
+      "- Keep it concise but informative",
+      "",
+      "## What You DON'T Do",
+      "- NO user conversations (that's main agent's job)",
+      "- NO external messages unless explicitly tasked with a specific recipient",
+      "- NO cron jobs or persistent state",
+      "- NO pretending to be the main agent",
+      "",
+      "## Session Context",
+      params.label ? `- Label: ${params.label}` : undefined,
+      params.requesterSessionKey ? `- Requester session: ${params.requesterSessionKey}` : undefined,
+      params.requesterOrigin?.channel ? `- Requester channel: ${params.requesterOrigin.channel}` : undefined,
+      `- Your session: ${params.childSessionKey}`,
+      ""
+    ].filter((line) => line !== undefined);
+    return lines.join(`
+`);
+  }
+  async sendToAgent(params, requesterContext) {
+    const runId = crypto3.randomUUID();
+    const policy = this.getAgentToAgentPolicy();
+    let targetSessionKey = params.sessionKey;
+    if (!targetSessionKey && params.label) {
+      const matchingRun = this.findSubagentRunByLabel(params.label, params.agentId);
+      if (matchingRun) {
+        targetSessionKey = matchingRun.childSessionKey;
+      } else {
+        return {
+          status: "error",
+          runId,
+          error: `No subagent found with label "${params.label}"`
+        };
+      }
+    }
+    if (!targetSessionKey) {
+      return {
+        status: "error",
+        runId,
+        error: "Either sessionKey or label is required"
+      };
+    }
+    const requesterAgentId = requesterContext.sessionKey ? extractAgentIdFromSessionKey(requesterContext.sessionKey) : this.runtime.character?.name ?? "unknown";
+    const targetAgentId = extractAgentIdFromSessionKey(targetSessionKey);
+    if (requesterAgentId !== targetAgentId) {
+      if (!policy.enabled) {
+        return {
+          status: "forbidden",
+          runId,
+          error: "Agent-to-agent messaging is disabled. Set settings.agentToAgent.enabled=true to allow cross-agent sends."
+        };
+      }
+      if (!policy.isAllowed(requesterAgentId, targetAgentId)) {
+        return {
+          status: "forbidden",
+          runId,
+          error: "Agent-to-agent messaging denied by policy."
+        };
+      }
+    }
+    const targetRoomId = sessionKeyToRoomId(targetSessionKey, targetAgentId);
+    const a2aContextParams = {
+      targetSessionKey
+    };
+    if (requesterContext.sessionKey)
+      a2aContextParams.requesterSessionKey = requesterContext.sessionKey;
+    const contextMessage = this.buildAgentToAgentContext(a2aContextParams);
+    const a2aMetadata = {
+      isAgentToAgent: true,
+      runId,
+      systemPromptOverride: contextMessage
+    };
+    if (requesterContext.sessionKey)
+      a2aMetadata.senderSessionKey = requesterContext.sessionKey;
+    if (requesterContext.roomId)
+      a2aMetadata.senderRoomId = requesterContext.roomId;
+    const message = {
+      id: hashToUUID(`${runId}-a2a`),
+      entityId: this.runtime.agentId,
+      agentId: this.runtime.agentId,
+      roomId: targetRoomId,
+      content: {
+        text: params.message,
+        type: "text",
+        metadata: a2aMetadata
+      }
+    };
+    const timeoutMs = (params.timeoutSeconds ?? 30) * 1000;
+    if (params.timeoutSeconds === 0) {
+      this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message,
+        source: "a2a"
+      }).catch((err) => {
+        this.runtime.logger.error(`A2A send error [runId=${runId}]: ${err}`);
+      });
+      const asyncPayload = {
+        runId,
+        childSessionKey: targetSessionKey,
+        task: params.message
+      };
+      if (requesterContext.sessionKey)
+        asyncPayload.requesterSessionKey = requesterContext.sessionKey;
+      this.emitSubagentEvent("A2A_MESSAGE_SENT", asyncPayload);
+      return {
+        status: "accepted",
+        runId,
+        sessionKey: targetSessionKey,
+        delivery: { status: "pending", mode: "async" }
+      };
+    }
+    const sentAt = Date.now();
+    await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+      runtime: this.runtime,
+      message,
+      source: "a2a"
+    });
+    const pollIntervalMs = 500;
+    const maxPolls = Math.ceil(timeoutMs / pollIntervalMs);
+    let lastReply;
+    for (let poll = 0;poll < maxPolls; poll++) {
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+      const memories = await this.runtime.getMemories({
+        tableName: "messages",
+        roomId: targetRoomId,
+        count: 10
+      });
+      const newReplies = memories.filter((m) => m.entityId === this.runtime.agentId && m.id !== message.id && m.createdAt && m.createdAt > sentAt);
+      if (newReplies.length > 0) {
+        lastReply = newReplies.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0];
+        break;
+      }
+    }
+    const syncPayload = {
+      runId,
+      childSessionKey: targetSessionKey,
+      task: params.message
+    };
+    if (requesterContext.sessionKey)
+      syncPayload.requesterSessionKey = requesterContext.sessionKey;
+    this.emitSubagentEvent("A2A_MESSAGE_SENT", syncPayload);
+    if (!lastReply) {
+      return {
+        status: "timeout",
+        runId,
+        sessionKey: targetSessionKey,
+        error: `No response received within ${params.timeoutSeconds ?? 30} seconds`,
+        delivery: { status: "timeout", mode: "sync" }
+      };
+    }
+    const result = {
+      status: "ok",
+      runId,
+      sessionKey: targetSessionKey,
+      delivery: { status: "delivered", mode: "sync" }
+    };
+    if (lastReply.content?.text)
+      result.reply = lastReply.content.text;
+    return result;
+  }
+  buildAgentToAgentContext(params) {
+    return [
+      "# Agent-to-Agent Message Context",
+      "",
+      "This message was sent by another agent session.",
+      params.requesterSessionKey ? `- Sender: ${params.requesterSessionKey}` : undefined,
+      `- Target: ${params.targetSessionKey}`,
+      "",
+      "Process this message and respond appropriately."
+    ].filter((l) => l !== undefined).join(`
+`);
+  }
+  getSubagentRun(runId) {
+    return this.subagentRuns.get(runId);
+  }
+  findSubagentRunByLabel(label, agentId) {
+    const normalizedLabel = label.toLowerCase().trim();
+    const normalizedAgentId = agentId ? normalizeAgentId2(agentId) : undefined;
+    for (const run of this.subagentRuns.values()) {
+      const runLabel = run.label?.toLowerCase().trim();
+      if (runLabel !== normalizedLabel) {
+        continue;
+      }
+      if (normalizedAgentId) {
+        const runAgentId = extractAgentIdFromSessionKey(run.childSessionKey);
+        if (normalizeAgentId2(runAgentId) !== normalizedAgentId) {
+          continue;
+        }
+      }
+      if (!run.endedAt) {
+        return run;
+      }
+    }
+    const completedRuns = [...this.subagentRuns.values()].filter((run) => {
+      const runLabel = run.label?.toLowerCase().trim();
+      if (runLabel !== normalizedLabel) {
+        return false;
+      }
+      if (normalizedAgentId) {
+        const runAgentId = extractAgentIdFromSessionKey(run.childSessionKey);
+        if (normalizeAgentId2(runAgentId) !== normalizedAgentId) {
+          return false;
+        }
+      }
+      return true;
+    }).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+    return completedRuns[0];
+  }
+  listSubagentRuns(requesterSessionKey) {
+    const runs = [...this.subagentRuns.values()];
+    if (!requesterSessionKey) {
+      return runs;
+    }
+    return runs.filter((r) => r.requesterSessionKey === requesterSessionKey);
+  }
+  cancelSubagentRun(runId) {
+    const controller = this.activeRuns.get(runId);
+    if (controller) {
+      controller.abort();
+      return true;
+    }
+    return false;
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  emitSubagentEvent(type, payload) {
+    this.emitter.emit(type, payload);
+    this.emitter.emit("task", { type, ...payload });
+  }
+  startSweeper() {
+    if (this.sweeper) {
+      return;
+    }
+    this.sweeper = setInterval(() => {
+      this.sweepOldRuns();
+    }, 60000);
+    this.sweeper.unref?.();
+  }
+  sweepOldRuns() {
+    const now2 = Date.now();
+    for (const [runId, record] of this.subagentRuns.entries()) {
+      if (record.archiveAtMs && record.archiveAtMs <= now2) {
+        this.subagentRuns.delete(runId);
+      }
+    }
+  }
+  async stop() {
+    if (this.sweeper) {
+      clearInterval(this.sweeper);
+      this.sweeper = null;
+    }
+    for (const controller of this.activeRuns.values()) {
+      controller.abort();
+    }
+    this.activeRuns.clear();
+    this.emitter.removeAllListeners();
+  }
+}
+// src/types/messaging.ts
+var MessagingEventType = {
+  SEND_REQUESTED: "MESSAGING_SEND_REQUESTED",
+  SENT: "MESSAGING_SENT",
+  SEND_FAILED: "MESSAGING_SEND_FAILED",
+  DELIVERED: "MESSAGING_DELIVERED",
+  READ: "MESSAGING_READ"
+};
+// src/types/sandbox.ts
+var SandboxEventType = {
+  CREATED: "SANDBOX_CREATED",
+  DESTROYED: "SANDBOX_DESTROYED",
+  COMMAND_STARTED: "SANDBOX_COMMAND_STARTED",
+  COMMAND_COMPLETED: "SANDBOX_COMMAND_COMPLETED",
+  COMMAND_FAILED: "SANDBOX_COMMAND_FAILED",
+  BROWSER_STARTED: "SANDBOX_BROWSER_STARTED",
+  BROWSER_STOPPED: "SANDBOX_BROWSER_STOPPED"
+};
+// src/types/subagent.ts
+var SubagentEventType = {
+  SPAWN_REQUESTED: "SUBAGENT_SPAWN_REQUESTED",
+  RUN_STARTED: "SUBAGENT_RUN_STARTED",
+  RUN_COMPLETED: "SUBAGENT_RUN_COMPLETED",
+  RUN_FAILED: "SUBAGENT_RUN_FAILED",
+  RUN_TIMEOUT: "SUBAGENT_RUN_TIMEOUT",
+  ANNOUNCE_SENT: "SUBAGENT_ANNOUNCE_SENT",
+  A2A_MESSAGE_SENT: "A2A_MESSAGE_SENT",
+  A2A_MESSAGE_RECEIVED: "A2A_MESSAGE_RECEIVED"
+};
 // index.ts
+var sessionProviders = getSessionProviders2();
 var agentOrchestratorPlugin = {
   name: "agent-orchestrator",
-  description: "Orchestrate tasks across one or more agent providers (no filesystem tools)",
-  services: [AgentOrchestratorService],
-  providers: [taskContextProvider],
+  description: "Orchestrate tasks across agent providers with subagent spawning, agent-to-agent communication, sandboxed execution, and cross-platform messaging",
+  services: [AgentOrchestratorService, SubagentService, SandboxService, MessagingService],
+  providers: [taskContextProvider, orchestratorConfigProvider, ...sessionProviders],
   actions: [
     createTaskAction,
     listTasksAction,
@@ -795,23 +3761,103 @@ var agentOrchestratorPlugin = {
     searchTasksAction,
     pauseTaskAction,
     resumeTaskAction,
-    cancelTaskAction
+    cancelTaskAction,
+    spawnSubagentAction,
+    sendToSessionAction,
+    listSubagentsAction,
+    cancelSubagentAction,
+    getSubagentStatusAction,
+    sendCrossPlatformMessageAction,
+    sendToDeliveryContextAction,
+    sendToRoomAction,
+    sendToSessionMessageAction,
+    listMessagingChannelsAction
   ]
 };
 var typescript_default = agentOrchestratorPlugin;
 export {
+  upsertSessionEntry,
+  updateSessionStoreEntry,
+  updateSessionStore,
+  toAgentStoreSessionKey,
+  toAgentRequestSessionKey,
   switchTaskAction,
+  spawnSubagentAction,
+  sessionKeyToRoomId,
+  sendToSessionMessageAction,
+  sendToSessionAction,
+  sendToRoomAction,
+  sendToDeliveryContextAction,
+  sendCrossPlatformMessageAction,
   searchTasksAction,
+  saveSessionStore,
   resumeTaskAction,
+  resolveThreadSessionKeys,
+  resolveThreadParentSessionKey,
+  resolveStorePath,
+  resolveStateDir,
+  resolveSessionTranscriptPath,
+  resolveDefaultSessionStorePath,
+  resolveAgentSessionsDir,
+  resolveAgentIdFromSessionKey,
   pauseTaskAction,
+  parseSessionKey,
+  parseAgentSessionKey,
+  orchestratorConfigProvider,
+  normalizeSessionKey,
+  normalizeMainKey,
+  normalizeDeliveryContext,
+  normalizeAgentId as normalizeCoreAgentId,
+  normalizeAgentId2 as normalizeAgentId,
+  normalizeAccountId,
+  mergeSessionEntry,
+  mergeDeliveryContext,
+  loadSessionStore,
   listTasksAction,
+  listSubagentsAction,
+  listSessionKeys,
+  listMessagingChannelsAction,
+  isValidSessionEntry,
+  isSubagentSessionKey2 as isSubagentSessionKey,
+  isSubagentSessionKey as isCoreSubagentSessionKey,
+  isAcpSessionKey,
+  hashToUUID,
+  getSubagentStatusAction,
+  getSessionProviders,
+  getSessionEntry,
+  getOrchestratorConfig,
   getConfiguredAgentOrchestratorOptions,
+  formatTokenCount,
+  formatDurationShort,
+  extractSessionContext,
+  extractAgentIdFromSessionKey,
+  deleteSessionEntry,
   typescript_default as default,
   createTaskAction,
+  createSubagentSessionKey,
+  createSessionSkillsProvider,
+  createSessionProvider,
+  createSessionEntry,
+  createSendPolicyProvider,
   configureAgentOrchestratorPlugin,
   cancelTaskAction,
+  cancelSubagentAction,
+  buildSubagentSessionKey,
+  buildSessionKey,
+  buildGroupHistoryKey,
+  buildAgentSessionKey,
+  buildAgentPeerSessionKey,
+  buildAgentMainSessionKey,
+  buildAcpSessionKey,
   agentOrchestratorPlugin,
+  SubagentService,
+  SubagentEventType,
+  SessionStateManager,
+  SandboxService,
+  SandboxEventType,
+  MessagingService,
+  MessagingEventType,
   AgentOrchestratorService
 };
 
-//# debugId=CC8D88226518D89764756E2164756E21
+//# debugId=4AD40853FB59A54864756E2164756E21