aamp-openclaw-plugin 0.1.6

package/dist/index.js

@@ -0,0 +1,2222 @@
+// src/index.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+// node_modules/aamp-sdk/dist/client.js
+import { EventEmitter as EventEmitter2 } from "events";
+
+// node_modules/aamp-sdk/dist/jmap-push.js
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+
+// node_modules/aamp-sdk/dist/types.js
+var AAMP_HEADER = {
+  INTENT: "X-AAMP-Intent",
+  TASK_ID: "X-AAMP-TaskId",
+  TIMEOUT: "X-AAMP-Timeout",
+  CONTEXT_LINKS: "X-AAMP-ContextLinks",
+  STATUS: "X-AAMP-Status",
+  OUTPUT: "X-AAMP-Output",
+  ERROR_MSG: "X-AAMP-ErrorMsg",
+  STRUCTURED_RESULT: "X-AAMP-StructuredResult",
+  QUESTION: "X-AAMP-Question",
+  BLOCKED_REASON: "X-AAMP-BlockedReason",
+  SUGGESTED_OPTIONS: "X-AAMP-SuggestedOptions",
+  PARENT_TASK_ID: "X-AAMP-ParentTaskId"
+};
+
+// node_modules/aamp-sdk/dist/parser.js
+function normalizeHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers).map(([k, v]) => [
+    k.toLowerCase(),
+    Array.isArray(v) ? v[0] : v
+  ]));
+}
+function getAampHeader(headers, headerName) {
+  return headers[headerName.toLowerCase()];
+}
+function decodeStructuredResult(value) {
+  if (!value)
+    return void 0;
+  try {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const padding = normalized.length % 4 === 0 ? "" : "=".repeat(4 - normalized.length % 4);
+    const decoded = Buffer.from(normalized + padding, "base64").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    return void 0;
+  }
+}
+function encodeStructuredResult(value) {
+  if (!value)
+    return void 0;
+  const json = JSON.stringify(value);
+  return Buffer.from(json, "utf-8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function parseAampHeaders(meta) {
+  const headers = normalizeHeaders(meta.headers);
+  const intent = getAampHeader(headers, AAMP_HEADER.INTENT);
+  const taskId = getAampHeader(headers, AAMP_HEADER.TASK_ID);
+  if (!intent || !taskId)
+    return null;
+  const from = meta.from.replace(/^<|>$/g, "");
+  const to = meta.to.replace(/^<|>$/g, "");
+  if (intent === "task.dispatch") {
+    const timeoutStr = getAampHeader(headers, AAMP_HEADER.TIMEOUT) ?? "300";
+    const contextLinksStr = getAampHeader(headers, AAMP_HEADER.CONTEXT_LINKS) ?? "";
+    const parentTaskId = getAampHeader(headers, AAMP_HEADER.PARENT_TASK_ID);
+    const dispatch = {
+      intent: "task.dispatch",
+      taskId,
+      title: meta.subject.replace(/^\[AAMP Task\]\s*/, "").trim() || "Untitled Task",
+      timeoutSecs: parseInt(timeoutStr, 10) || 300,
+      contextLinks: contextLinksStr ? contextLinksStr.split(",").map((s) => s.trim()).filter(Boolean) : [],
+      ...parentTaskId ? { parentTaskId } : {},
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+      // filled in by jmap-push.ts after parsing
+    };
+    return dispatch;
+  }
+  if (intent === "task.result") {
+    const status = getAampHeader(headers, AAMP_HEADER.STATUS) ?? "completed";
+    const output = getAampHeader(headers, AAMP_HEADER.OUTPUT) ?? "";
+    const errorMsg = getAampHeader(headers, AAMP_HEADER.ERROR_MSG);
+    const structuredResult = decodeStructuredResult(getAampHeader(headers, AAMP_HEADER.STRUCTURED_RESULT));
+    const result = {
+      intent: "task.result",
+      taskId,
+      status,
+      output,
+      errorMsg,
+      structuredResult,
+      from,
+      to
+    };
+    return result;
+  }
+  if (intent === "task.help") {
+    const question = getAampHeader(headers, AAMP_HEADER.QUESTION) ?? "";
+    const blockedReason = getAampHeader(headers, AAMP_HEADER.BLOCKED_REASON) ?? "";
+    const suggestedOptionsStr = getAampHeader(headers, AAMP_HEADER.SUGGESTED_OPTIONS) ?? "";
+    const help = {
+      intent: "task.help",
+      taskId,
+      question,
+      blockedReason,
+      suggestedOptions: suggestedOptionsStr ? suggestedOptionsStr.split("|").map((s) => s.trim()).filter(Boolean) : [],
+      from,
+      to
+    };
+    return help;
+  }
+  if (intent === "task.ack") {
+    const ack = {
+      intent: "task.ack",
+      taskId,
+      from,
+      to
+    };
+    return ack;
+  }
+  return null;
+}
+function buildDispatchHeaders(params) {
+  const headers = {
+    [AAMP_HEADER.INTENT]: "task.dispatch",
+    [AAMP_HEADER.TASK_ID]: params.taskId
+  };
+  if (params.timeoutSecs != null) {
+    headers[AAMP_HEADER.TIMEOUT] = String(params.timeoutSecs);
+  }
+  if (params.contextLinks.length > 0) {
+    headers[AAMP_HEADER.CONTEXT_LINKS] = params.contextLinks.join(",");
+  }
+  if (params.parentTaskId) {
+    headers[AAMP_HEADER.PARENT_TASK_ID] = params.parentTaskId;
+  }
+  return headers;
+}
+function buildAckHeaders(opts) {
+  return {
+    [AAMP_HEADER.INTENT]: "task.ack",
+    [AAMP_HEADER.TASK_ID]: opts.taskId
+  };
+}
+function buildResultHeaders(params) {
+  const headers = {
+    [AAMP_HEADER.INTENT]: "task.result",
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.STATUS]: params.status,
+    [AAMP_HEADER.OUTPUT]: params.output
+  };
+  if (params.errorMsg) {
+    headers[AAMP_HEADER.ERROR_MSG] = params.errorMsg;
+  }
+  const structuredResult = encodeStructuredResult(params.structuredResult);
+  if (structuredResult) {
+    headers[AAMP_HEADER.STRUCTURED_RESULT] = structuredResult;
+  }
+  return headers;
+}
+function buildHelpHeaders(params) {
+  return {
+    [AAMP_HEADER.INTENT]: "task.help",
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.QUESTION]: params.question,
+    [AAMP_HEADER.BLOCKED_REASON]: params.blockedReason,
+    [AAMP_HEADER.SUGGESTED_OPTIONS]: params.suggestedOptions.join("|")
+  };
+}
+
+// node_modules/aamp-sdk/dist/jmap-push.js
+var JmapPushClient = class extends EventEmitter {
+  ws = null;
+  session = null;
+  reconnectTimer = null;
+  pollTimer = null;
+  pingTimer = null;
+  seenMessageIds = /* @__PURE__ */ new Set();
+  connected = false;
+  pollingActive = false;
+  running = false;
+  connecting = false;
+  /** JMAP Email state — tracks processed position; null = not yet initialized */
+  emailState = null;
+  startedAtMs = Date.now();
+  email;
+  password;
+  jmapUrl;
+  reconnectInterval;
+  rejectUnauthorized;
+  pingIntervalMs = 5e3;
+  constructor(opts) {
+    super();
+    this.email = opts.email;
+    this.password = opts.password;
+    this.jmapUrl = opts.jmapUrl.replace(/\/$/, "");
+    this.reconnectInterval = opts.reconnectInterval ?? 5e3;
+    this.rejectUnauthorized = opts.rejectUnauthorized ?? true;
+  }
+  /**
+   * Start the JMAP Push listener
+   */
+  async start() {
+    this.running = true;
+    await this.connect();
+  }
+  /**
+   * Stop the JMAP Push listener
+   */
+  stop() {
+    this.running = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.pollingActive = false;
+    this.connecting = false;
+  }
+  getAuthHeader() {
+    const creds = `${this.email}:${this.password}`;
+    return `Basic ${Buffer.from(creds).toString("base64")}`;
+  }
+  /**
+   * Fetch the JMAP session object
+   */
+  async fetchSession() {
+    const url = `${this.jmapUrl}/.well-known/jmap`;
+    const res = await fetch(url, {
+      headers: { Authorization: this.getAuthHeader() }
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to fetch JMAP session: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /**
+   * Perform a JMAP API call
+   */
+  async jmapCall(methods) {
+    if (!this.session)
+      throw new Error("No JMAP session");
+    const apiUrl = `${this.jmapUrl}/jmap/`;
+    const res = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: this.getAuthHeader(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        using: [
+          "urn:ietf:params:jmap:core",
+          "urn:ietf:params:jmap:mail"
+        ],
+        methodCalls: methods
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`JMAP API call failed: ${res.status}`);
+    }
+    return res.json();
+  }
+  /**
+   * Initialize emailState by fetching the current state without loading any emails.
+   * Called on first connect so we only process emails that arrive AFTER this point.
+   */
+  async initEmailState(accountId) {
+    const response = await this.jmapCall([
+      ["Email/get", { accountId, ids: [] }, "g0"]
+    ]);
+    const getResp = response.methodResponses.find(([name]) => name === "Email/get");
+    if (getResp) {
+      this.emailState = getResp[1].state ?? null;
+    }
+  }
+  /**
+   * Fetch only emails created since `sinceState` using Email/changes.
+   * Updates `this.emailState` to the new state after fetching.
+   * Returns [] and resets state if the server cannot calculate changes (state too old).
+   */
+  async fetchEmailsSince(accountId, sinceState) {
+    const changesResp = await this.jmapCall([
+      ["Email/changes", { accountId, sinceState, maxChanges: 50 }, "c1"]
+    ]);
+    const changesResult = changesResp.methodResponses.find(([name]) => name === "Email/changes");
+    if (!changesResult || changesResult[0] === "error") {
+      await this.initEmailState(accountId);
+      return [];
+    }
+    const changes = changesResult[1];
+    if (changes.newState) {
+      this.emailState = changes.newState;
+    }
+    const newIds = changes.created ?? [];
+    if (newIds.length === 0)
+      return [];
+    const emailResp = await this.jmapCall([
+      [
+        "Email/get",
+        {
+          accountId,
+          ids: newIds,
+          properties: ["id", "subject", "from", "to", "headers", "messageId", "receivedAt", "textBody", "bodyValues", "attachments"],
+          fetchTextBodyValues: true,
+          maxBodyValueBytes: 262144
+        },
+        "g1"
+      ]
+    ]);
+    const getResult = emailResp.methodResponses.find(([name]) => name === "Email/get");
+    if (!getResult)
+      return [];
+    const data = getResult[1];
+    return data.list ?? [];
+  }
+  /**
+   * Process a received email.
+   *
+   * Priority:
+   * 1. If X-AAMP-Intent is present → emit typed AAMP event (task.dispatch / task.result / task.help)
+   * 2. If In-Reply-To is present → emit 'reply' event so the application layer can
+   *    resolve the thread (inReplyTo → taskId via Redis/DB) and handle human replies.
+   * 3. Otherwise → ignore (not an AAMP-related email)
+   */
+  processEmail(email) {
+    const headerMap = {};
+    for (const h of email.headers ?? []) {
+      headerMap[h.name.toLowerCase()] = h.value.trim();
+    }
+    const fromAddr = email.from?.[0]?.email ?? "";
+    const toAddr = email.to?.[0]?.email ?? "";
+    const messageId = email.messageId?.[0] ?? email.id;
+    if (this.seenMessageIds.has(messageId))
+      return;
+    this.seenMessageIds.add(messageId);
+    const msg = parseAampHeaders({
+      from: fromAddr,
+      to: toAddr,
+      messageId,
+      subject: email.subject ?? "",
+      headers: headerMap
+    });
+    if (msg && "intent" in msg) {
+      const aampTextPartId = email.textBody?.[0]?.partId;
+      const aampBodyText = aampTextPartId ? (email.bodyValues?.[aampTextPartId]?.value ?? "").trim() : "";
+      msg.bodyText = aampBodyText;
+      const receivedAttachments = (email.attachments ?? []).map((a) => ({
+        filename: a.name ?? "attachment",
+        contentType: a.type,
+        size: a.size,
+        blobId: a.blobId
+      }));
+      if (receivedAttachments.length > 0) {
+        ;
+        msg.attachments = receivedAttachments;
+      }
+      if (msg.intent === "task.dispatch") {
+        this.emit("_autoAck", { to: fromAddr, taskId: msg.taskId, messageId });
+      }
+      this.emit(msg.intent, msg);
+      return;
+    }
+    const rawInReplyTo = headerMap["in-reply-to"] ?? "";
+    if (!rawInReplyTo)
+      return;
+    const rawReferences = headerMap["references"] ?? "";
+    const referencesIds = rawReferences.split(/\s+/).map((s) => s.replace(/[<>]/g, "").trim()).filter(Boolean);
+    const inReplyTo = rawInReplyTo.replace(/[<>]/g, "").trim();
+    const textPartId = email.textBody?.[0]?.partId;
+    const bodyText = textPartId ? (email.bodyValues?.[textPartId]?.value ?? "").trim() : "";
+    const reply = {
+      inReplyTo,
+      messageId,
+      from: fromAddr,
+      to: toAddr,
+      subject: email.subject ?? "",
+      bodyText
+    };
+    if (referencesIds.length > 0) {
+      Object.assign(reply, { references: referencesIds });
+    }
+    this.emit("reply", reply);
+  }
+  async fetchRecentEmails(accountId) {
+    const queryResp = await this.jmapCall([
+      [
+        "Email/query",
+        {
+          accountId,
+          sort: [{ property: "receivedAt", isAscending: false }],
+          limit: 20
+        },
+        "q1"
+      ]
+    ]);
+    const queryResult = queryResp.methodResponses.find(([name]) => name === "Email/query");
+    if (!queryResult)
+      return [];
+    const ids = (queryResult[1].ids ?? []).slice(0, 20);
+    if (ids.length === 0)
+      return [];
+    const emailResp = await this.jmapCall([
+      [
+        "Email/get",
+        {
+          accountId,
+          ids,
+          properties: ["id", "subject", "from", "to", "headers", "messageId", "receivedAt", "textBody", "bodyValues", "attachments"],
+          fetchTextBodyValues: true,
+          maxBodyValueBytes: 262144
+        },
+        "gRecent"
+      ]
+    ]);
+    const getResult = emailResp.methodResponses.find(([name]) => name === "Email/get");
+    if (!getResult)
+      return [];
+    return getResult[1].list ?? [];
+  }
+  shouldProcessBootstrapEmail(email) {
+    const receivedAtMs = new Date(email.receivedAt).getTime();
+    return Number.isFinite(receivedAtMs) && receivedAtMs >= this.startedAtMs - 15e3;
+  }
+  /**
+   * Connect to JMAP WebSocket
+   */
+  async connect() {
+    if (this.connecting || !this.running)
+      return;
+    this.connecting = true;
+    try {
+      this.session = await this.fetchSession();
+    } catch (err) {
+      this.connecting = false;
+      this.emit("error", new Error(`Failed to get JMAP session: ${err.message}`));
+      this.startPolling("session fetch failed");
+      this.scheduleReconnect();
+      return;
+    }
+    const stalwartWsUrl = `${this.jmapUrl}/_jmap_ws`.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+    this.ws = new WebSocket(stalwartWsUrl, "jmap", {
+      headers: {
+        Authorization: this.getAuthHeader()
+      },
+      perMessageDeflate: false,
+      rejectUnauthorized: this.rejectUnauthorized
+    });
+    this.ws.on("unexpected-response", (_req, res) => {
+      this.connecting = false;
+      const headerSummary = Object.entries(res.headers).map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(", ") : value ?? ""}`).join("; ");
+      this.startPolling(`websocket handshake failed: ${res.statusCode ?? "unknown"}`);
+      this.emit("error", new Error(`JMAP WebSocket handshake failed: ${res.statusCode ?? "unknown"} ${res.statusMessage ?? ""}${headerSummary ? ` | headers: ${headerSummary}` : ""}`));
+      this.scheduleReconnect();
+    });
+    this.ws.on("open", async () => {
+      this.connecting = false;
+      this.connected = true;
+      this.stopPolling();
+      this.startPingHeartbeat();
+      const accountId = this.session?.primaryAccounts["urn:ietf:params:jmap:mail"];
+      if (accountId && this.emailState === null) {
+        await this.initEmailState(accountId);
+      }
+      this.ws.send(JSON.stringify({
+        "@type": "WebSocketPushEnable",
+        dataTypes: ["Email"],
+        pushState: null
+      }));
+      this.emit("connected");
+    });
+    this.ws.on("pong", () => {
+    });
+    this.ws.on("message", async (rawData) => {
+      try {
+        const msg = JSON.parse(rawData.toString());
+        if (msg["@type"] === "StateChange") {
+          await this.handleStateChange(msg);
+        }
+      } catch (err) {
+        this.emit("error", new Error(`Failed to process JMAP push message: ${err.message}`));
+      }
+    });
+    this.ws.on("close", (code, reason) => {
+      this.connecting = false;
+      this.connected = false;
+      this.stopPingHeartbeat();
+      const reasonStr = reason?.toString() ?? "connection closed";
+      this.startPolling(reasonStr);
+      this.emit("disconnected", reasonStr);
+      if (this.running) {
+        this.scheduleReconnect();
+      }
+    });
+    this.ws.on("error", (err) => {
+      this.connecting = false;
+      this.stopPingHeartbeat();
+      this.startPolling(err.message);
+      this.emit("error", err);
+    });
+  }
+  startPingHeartbeat() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    this.pingTimer = setInterval(() => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+        return;
+      try {
+        this.ws.ping();
+      } catch (err) {
+        this.emit("error", new Error(`Failed to send WebSocket ping: ${err.message}`));
+      }
+    }, this.pingIntervalMs);
+  }
+  stopPingHeartbeat() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  async handleStateChange(stateChange) {
+    if (!this.session)
+      return;
+    const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"];
+    if (!accountId)
+      return;
+    const changedAccount = stateChange.changed[accountId];
+    if (!changedAccount?.Email)
+      return;
+    try {
+      if (this.emailState === null) {
+        await this.initEmailState(accountId);
+        return;
+      }
+      const emails = await this.fetchEmailsSince(accountId, this.emailState);
+      for (const email of emails) {
+        this.processEmail(email);
+      }
+    } catch (err) {
+      this.emit("error", new Error(`Failed to fetch emails: ${err.message}`));
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer)
+      return;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (this.running) {
+        await this.connect();
+      }
+    }, this.reconnectInterval);
+  }
+  isConnected() {
+    return this.connected || this.pollingActive;
+  }
+  isUsingPollingFallback() {
+    return this.pollingActive && !this.connected;
+  }
+  stopPolling() {
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.pollingActive = false;
+  }
+  startPolling(reason) {
+    if (!this.running || this.pollingActive)
+      return;
+    this.pollingActive = true;
+    this.emit("error", new Error(`JMAP WebSocket unavailable, falling back to polling: ${reason}`));
+    this.emit("connected");
+    const poll = async () => {
+      if (!this.running || this.connected) {
+        this.stopPolling();
+        return;
+      }
+      try {
+        if (!this.session) {
+          this.session = await this.fetchSession();
+        }
+        const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"] ?? Object.keys(this.session.accounts)[0];
+        if (!accountId) {
+          throw new Error("No mail account available in JMAP session");
+        }
+        if (this.emailState === null) {
+          const recentEmails = await this.fetchRecentEmails(accountId);
+          for (const email of recentEmails.sort((a, b) => {
+            const aTs = new Date(a.receivedAt).getTime();
+            const bTs = new Date(b.receivedAt).getTime();
+            return aTs - bTs;
+          })) {
+            if (!this.shouldProcessBootstrapEmail(email))
+              continue;
+            this.processEmail(email);
+          }
+          await this.initEmailState(accountId);
+        } else {
+          const emails = await this.fetchEmailsSince(accountId, this.emailState);
+          for (const email of emails) {
+            this.processEmail(email);
+          }
+        }
+      } catch (err) {
+        this.emit("error", new Error(`Polling fallback failed: ${err.message}`));
+      } finally {
+        if (this.running && !this.connected) {
+          this.pollTimer = setTimeout(poll, this.reconnectInterval);
+        }
+      }
+    };
+    this.pollTimer = setTimeout(poll, 0);
+  }
+  /**
+   * Download a blob (attachment) by its JMAP blobId.
+   * Returns the raw binary content as a Buffer.
+   */
+  async downloadBlob(blobId, filename) {
+    if (!this.session) {
+      this.session = await this.fetchSession();
+    }
+    const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"] ?? Object.keys(this.session.accounts)[0];
+    let downloadUrl = this.session.downloadUrl ?? `${this.jmapUrl}/jmap/download/{accountId}/{blobId}/{name}`;
+    try {
+      const parsed = new URL(downloadUrl);
+      const configured = new URL(this.jmapUrl);
+      parsed.protocol = configured.protocol;
+      parsed.host = configured.host;
+      downloadUrl = parsed.toString();
+    } catch {
+    }
+    const safeFilename = filename ?? "attachment";
+    downloadUrl = downloadUrl.replace(/\{accountId\}|%7BaccountId%7D/gi, encodeURIComponent(accountId)).replace(/\{blobId\}|%7BblobId%7D/gi, encodeURIComponent(blobId)).replace(/\{name\}|%7Bname%7D/gi, encodeURIComponent(safeFilename)).replace(/\{type\}|%7Btype%7D/gi, "application/octet-stream");
+    const maxAttempts = 8;
+    let lastStatus = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const res = await fetch(downloadUrl, {
+        headers: { Authorization: this.getAuthHeader() }
+      });
+      lastStatus = res.status;
+      if (res.ok) {
+        const arrayBuffer = await res.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+      }
+      if (attempt < maxAttempts && (res.status === 404 || res.status === 429 || res.status === 503)) {
+        console.warn(`[AAMP-SDK] blob download retry status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`);
+        const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 15e3);
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      console.error(`[AAMP-SDK] blob download failed status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`);
+      throw new Error(`Blob download failed: status=${res.status} attempt=${attempt}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`);
+    }
+    throw new Error(`Blob download failed after retries: status=${lastStatus ?? "unknown"} attempt=${maxAttempts}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`);
+  }
+  /**
+   * Actively reconcile recent mailbox contents via JMAP HTTP.
+   * Useful as a safety net when the WebSocket stays "connected"
+   * but a notification is missed by an intermediate layer.
+   */
+  async reconcileRecentEmails(limit = 20) {
+    if (!this.session) {
+      this.session = await this.fetchSession();
+    }
+    const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"] ?? Object.keys(this.session.accounts)[0];
+    if (!accountId) {
+      throw new Error("No mail account available in JMAP session");
+    }
+    const queryResp = await this.jmapCall([
+      [
+        "Email/query",
+        {
+          accountId,
+          sort: [{ property: "receivedAt", isAscending: false }],
+          limit
+        },
+        "qReconcile"
+      ]
+    ]);
+    const queryResult = queryResp.methodResponses.find(([name]) => name === "Email/query");
+    if (!queryResult)
+      return 0;
+    const ids = (queryResult[1].ids ?? []).slice(0, limit);
+    if (ids.length === 0)
+      return 0;
+    const emailResp = await this.jmapCall([
+      [
+        "Email/get",
+        {
+          accountId,
+          ids,
+          properties: ["id", "subject", "from", "to", "headers", "messageId", "receivedAt", "textBody", "bodyValues", "attachments"],
+          fetchTextBodyValues: true,
+          maxBodyValueBytes: 262144
+        },
+        "gReconcile"
+      ]
+    ]);
+    const getResult = emailResp.methodResponses.find(([name]) => name === "Email/get");
+    if (!getResult)
+      return 0;
+    const emails = getResult[1].list ?? [];
+    for (const email of emails.sort((a, b) => {
+      const aTs = new Date(a.receivedAt).getTime();
+      const bTs = new Date(b.receivedAt).getTime();
+      return aTs - bTs;
+    })) {
+      if (!this.shouldProcessBootstrapEmail(email))
+        continue;
+      this.processEmail(email);
+    }
+    return emails.length;
+  }
+};
+
+// node_modules/aamp-sdk/dist/smtp-sender.js
+import { createTransport } from "nodemailer";
+import { randomUUID } from "crypto";
+var sanitize = (s) => s.replace(/[\r\n]/g, " ").trim();
+var SmtpSender = class {
+  config;
+  transport;
+  constructor(config) {
+    this.config = config;
+    this.transport = createTransport({
+      host: config.host,
+      port: config.port,
+      secure: config.secure ?? false,
+      auth: {
+        user: config.user,
+        pass: config.password
+      },
+      tls: {
+        rejectUnauthorized: config.rejectUnauthorized ?? true
+      }
+    });
+  }
+  senderDomain() {
+    return this.config.user.split("@")[1]?.toLowerCase() ?? "";
+  }
+  recipientDomain(email) {
+    return email.split("@")[1]?.toLowerCase() ?? "";
+  }
+  shouldUseHttpFallback(to) {
+    return Boolean(this.config.httpBaseUrl && this.config.authToken && this.senderDomain() && this.senderDomain() === this.recipientDomain(to));
+  }
+  async sendViaHttp(opts) {
+    const base = this.config.httpBaseUrl?.replace(/\/$/, "");
+    if (!base || !this.config.authToken) {
+      throw new Error("HTTP send fallback is not configured");
+    }
+    const res = await fetch(`${base}/api/send`, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${this.config.authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        to: opts.to,
+        subject: opts.subject,
+        text: opts.text,
+        aampHeaders: opts.aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? a.content : a.content.toString("base64")
+        }))
+      })
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(data.details || `HTTP send failed: ${res.status}`);
+    }
+    return { messageId: data.messageId };
+  }
+  /**
+   * Send a task.dispatch email.
+   * Returns both the generated taskId and the SMTP Message-ID so callers can
+   * store a reverse-index (messageId → taskId) for In-Reply-To thread routing.
+   */
+  async sendTask(opts) {
+    const taskId = randomUUID();
+    const aampHeaders = buildDispatchHeaders({
+      taskId,
+      timeoutSecs: opts.timeoutSecs,
+      contextLinks: opts.contextLinks ?? [],
+      parentTaskId: opts.parentTaskId
+    });
+    const sendMailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Task] ${sanitize(opts.title)}`,
+      text: [
+        `Task: ${opts.title}`,
+        `Task ID: ${taskId}`,
+        opts.timeoutSecs ? `Deadline: ${opts.timeoutSecs}s` : `Deadline: none`,
+        opts.contextLinks?.length ? `Context:
+${opts.contextLinks.map((l) => `  ${l}`).join("\n")}` : "",
+        ``,
+        `--- This email was sent by AAMP. Reply directly to submit your result. ---`
+      ].filter(Boolean).join("\n"),
+      headers: aampHeaders
+    };
+    if (opts.attachments?.length) {
+      sendMailOpts.attachments = opts.attachments.map((a) => ({
+        filename: a.filename,
+        content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content,
+        contentType: a.contentType
+      }));
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: sendMailOpts.subject,
+        text: sendMailOpts.text,
+        aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
+        }))
+      });
+      return { taskId, messageId: info2.messageId ?? "" };
+    }
+    const info = await this.transport.sendMail(sendMailOpts);
+    return { taskId, messageId: info.messageId ?? "" };
+  }
+  /**
+   * Send a task.result email back to the dispatcher
+   */
+  async sendResult(opts) {
+    const aampHeaders = buildResultHeaders({
+      taskId: opts.taskId,
+      status: opts.status,
+      output: opts.output,
+      errorMsg: opts.errorMsg,
+      structuredResult: opts.structuredResult
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Result] Task ${opts.taskId} \u2014 ${opts.status}`,
+      text: [
+        `AAMP Task Result`,
+        ``,
+        `Task ID: ${opts.taskId}`,
+        `Status: ${opts.status}`,
+        ``,
+        `Output:`,
+        opts.output,
+        opts.errorMsg ? `
+Error: ${opts.errorMsg}` : ""
+      ].filter((s) => s !== "").join("\n"),
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (opts.attachments?.length) {
+      mailOpts.attachments = opts.attachments.map((a) => ({
+        filename: a.filename,
+        content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content,
+        contentType: a.contentType
+      }));
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
+        }))
+      });
+      return;
+    }
+    await this.transport.sendMail(mailOpts);
+  }
+  /**
+   * Send a task.help email when the agent is blocked
+   */
+  async sendHelp(opts) {
+    const aampHeaders = buildHelpHeaders({
+      taskId: opts.taskId,
+      question: opts.question,
+      blockedReason: opts.blockedReason,
+      suggestedOptions: opts.suggestedOptions
+    });
+    const helpMailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Help] Task ${opts.taskId} needs assistance`,
+      text: [
+        `AAMP Task Help Request`,
+        ``,
+        `Task ID: ${opts.taskId}`,
+        ``,
+        `Question: ${opts.question}`,
+        ``,
+        `Blocked reason: ${opts.blockedReason}`,
+        ``,
+        opts.suggestedOptions.length ? `Suggested options:
+${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
+      ].filter(Boolean).join("\n"),
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      helpMailOpts.inReplyTo = opts.inReplyTo;
+      helpMailOpts.references = opts.inReplyTo;
+    }
+    if (opts.attachments?.length) {
+      helpMailOpts.attachments = opts.attachments.map((a) => ({
+        filename: a.filename,
+        content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content,
+        contentType: a.contentType
+      }));
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      await this.sendViaHttp({
+        to: opts.to,
+        subject: helpMailOpts.subject,
+        text: helpMailOpts.text,
+        aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
+        }))
+      });
+      return;
+    }
+    await this.transport.sendMail(helpMailOpts);
+  }
+  /**
+   * Send a task.ack email to confirm receipt of a dispatch
+   */
+  async sendAck(opts) {
+    const aampHeaders = buildAckHeaders({ taskId: opts.taskId });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP ACK] Task ${opts.taskId}`,
+      text: "",
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      return;
+    }
+    await this.transport.sendMail(mailOpts);
+  }
+  /**
+   * Verify SMTP connection
+   */
+  async verify() {
+    try {
+      await this.transport.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  close() {
+    this.transport.close();
+  }
+};
+
+// node_modules/aamp-sdk/dist/client.js
+var AampClient = class extends EventEmitter2 {
+  jmapClient;
+  smtpSender;
+  config;
+  constructor(config) {
+    super();
+    this.config = config;
+    let password;
+    try {
+      const decoded = Buffer.from(config.jmapToken, "base64").toString("utf-8");
+      const colonIdx = decoded.indexOf(":");
+      if (colonIdx < 0)
+        throw new Error("Invalid jmapToken format: expected base64(email:password)");
+      password = decoded.slice(colonIdx + 1);
+      if (!password)
+        throw new Error("Invalid jmapToken: empty password");
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("Invalid jmapToken"))
+        throw err;
+      throw new Error(`Failed to decode jmapToken: ${err.message}`);
+    }
+    this.jmapClient = new JmapPushClient({
+      email: config.email,
+      password: password ?? config.smtpPassword,
+      jmapUrl: config.jmapUrl,
+      reconnectInterval: config.reconnectInterval ?? 5e3,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+    this.smtpSender = new SmtpSender({
+      host: config.smtpHost,
+      port: config.smtpPort ?? 587,
+      user: config.email,
+      password: config.smtpPassword,
+      httpBaseUrl: config.httpSendBaseUrl ?? config.jmapUrl,
+      authToken: config.jmapToken,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+    this.jmapClient.on("task.dispatch", (task) => {
+      this.emit("task.dispatch", task);
+    });
+    this.jmapClient.on("task.result", (result) => {
+      this.emit("task.result", result);
+    });
+    this.jmapClient.on("task.help", (help) => {
+      this.emit("task.help", help);
+    });
+    this.jmapClient.on("task.ack", (ack) => {
+      this.emit("task.ack", ack);
+    });
+    this.jmapClient.on("_autoAck", async ({ to, taskId, messageId }) => {
+      try {
+        await this.smtpSender.sendAck({ to, taskId, inReplyTo: messageId });
+      } catch (err) {
+        console.warn(`[AAMP] Failed to send ACK for task ${taskId}: ${err.message}`);
+      }
+    });
+    this.jmapClient.on("reply", (reply) => {
+      this.emit("reply", reply);
+    });
+    this.jmapClient.on("connected", () => {
+      this.emit("connected");
+    });
+    this.jmapClient.on("disconnected", (reason) => {
+      this.emit("disconnected", reason);
+    });
+    this.jmapClient.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  // =====================================================
+  // Type-safe event emitter methods
+  // =====================================================
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  // =====================================================
+  // Lifecycle
+  // =====================================================
+  /**
+   * Connect to JMAP and start listening for tasks
+   */
+  async connect() {
+    await this.jmapClient.start();
+  }
+  /**
+   * Disconnect and clean up
+   */
+  disconnect() {
+    this.jmapClient.stop();
+    this.smtpSender.close();
+  }
+  /**
+   * Returns true if the JMAP connection is active
+   */
+  isConnected() {
+    return this.jmapClient.isConnected();
+  }
+  isUsingPollingFallback() {
+    return this.jmapClient.isUsingPollingFallback();
+  }
+  // =====================================================
+  // Sending
+  // =====================================================
+  /**
+   * Send a task.dispatch email to an agent.
+   * Returns the generated taskId and the SMTP Message-ID.
+   * Store messageId → taskId in Redis/DB to support In-Reply-To thread routing
+   * for human replies that arrive without X-AAMP headers.
+   */
+  async sendTask(opts) {
+    return this.smtpSender.sendTask(opts);
+  }
+  /**
+   * Send a task.result email (agent → system/dispatcher)
+   */
+  async sendResult(opts) {
+    return this.smtpSender.sendResult(opts);
+  }
+  /**
+   * Send a task.help email when the agent needs human assistance
+   */
+  async sendHelp(opts) {
+    return this.smtpSender.sendHelp(opts);
+  }
+  /**
+   * Download a blob (attachment) by its JMAP blobId.
+   * Use this to retrieve attachment content from received TaskDispatch or TaskResult messages.
+   * Returns the raw binary content as a Buffer.
+   */
+  async downloadBlob(blobId, filename) {
+    return this.jmapClient.downloadBlob(blobId, filename);
+  }
+  /**
+   * Reconcile recent mailbox contents via JMAP HTTP to catch messages missed by
+   * a flaky WebSocket path. Safe to call periodically; duplicate processing is
+   * suppressed by the JMAP push client.
+   */
+  async reconcileRecentEmails(limit) {
+    return this.jmapClient.reconcileRecentEmails(limit);
+  }
+  /**
+   * Verify SMTP connectivity
+   */
+  async verifySmtp() {
+    return this.smtpSender.verify();
+  }
+  get email() {
+    return this.config.email;
+  }
+};
+
+// src/index.ts
+function baseUrl(aampHost) {
+  if (aampHost.startsWith("http://") || aampHost.startsWith("https://")) {
+    return aampHost.replace(/\/$/, "");
+  }
+  return `https://${aampHost}`;
+}
+var pendingTasks = /* @__PURE__ */ new Map();
+var dispatchedSubtasks = /* @__PURE__ */ new Map();
+var waitingDispatches = /* @__PURE__ */ new Map();
+var aampClient = null;
+var agentEmail = "";
+var lastConnectionError = "";
+var lastDisconnectReason = "";
+var lastTransportMode = "disconnected";
+var reconcileTimer = null;
+var currentSessionKey = "agent:main:main";
+var channelRuntime = null;
+var channelCfg = null;
+function defaultCredentialsPath() {
+  return join(homedir(), ".openclaw", "extensions", "aamp", ".credentials.json");
+}
+function loadCachedIdentity(cfg) {
+  const file = cfg.credentialsFile ?? defaultCredentialsPath();
+  if (!existsSync(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf-8"));
+    if (!parsed.email || !parsed.jmapToken || !parsed.smtpPassword) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveCachedIdentity(cfg, identity) {
+  const file = cfg.credentialsFile ?? defaultCredentialsPath();
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(identity, null, 2), "utf-8");
+}
+async function registerNode(cfg) {
+  const slug = (cfg.slug ?? "openclaw-agent").toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "");
+  const base = baseUrl(cfg.aampHost);
+  const res = await fetch(`${base}/api/nodes/self-register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ slug, description: "OpenClaw AAMP agent node" })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(`AAMP registration failed (${res.status}): ${err.error ?? res.statusText}`);
+  }
+  const regData = await res.json();
+  const credRes = await fetch(
+    `${base}/api/nodes/credentials?code=${encodeURIComponent(regData.registrationCode)}`
+  );
+  if (!credRes.ok) {
+    const err = await credRes.json().catch(() => ({}));
+    throw new Error(`AAMP credential exchange failed (${credRes.status}): ${err.error ?? credRes.statusText}`);
+  }
+  const credData = await credRes.json();
+  return {
+    email: credData.email,
+    jmapToken: credData.jmap.token,
+    smtpPassword: credData.smtp.password
+  };
+}
+async function resolveIdentity(cfg) {
+  const cached = loadCachedIdentity(cfg);
+  if (cached)
+    return cached;
+  const identity = await registerNode(cfg);
+  saveCachedIdentity(cfg, identity);
+  return identity;
+}
+var src_default = {
+  id: "aamp",
+  name: "AAMP Agent Mail Protocol",
+  configSchema: {
+    type: "object",
+    properties: {
+      aampHost: {
+        type: "string",
+        description: "AAMP service host, e.g. https://meshmail.ai"
+      },
+      slug: {
+        type: "string",
+        default: "openclaw-agent",
+        description: "Agent name prefix used in the mailbox address"
+      },
+      credentialsFile: {
+        type: "string",
+        description: "Absolute path to cache AAMP credentials between gateway restarts. Default: ~/.openclaw/extensions/aamp/.credentials.json. Delete this file to force re-registration with a new mailbox."
+      },
+      allowedSenders: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Sender whitelist. Only task.dispatch emails from these addresses are accepted. Matching is case-insensitive and exact. If omitted, all senders are accepted. If set to [], all senders are rejected. Example: ["meego-abc123@aamp.local", "ci-bot-ff09@aamp.local"]'
+      }
+    }
+  },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  register(api) {
+    const cfg = api.pluginConfig ?? {};
+    api.registerChannel({
+      id: "aamp",
+      meta: { label: "AAMP" },
+      capabilities: { chatTypes: ["dm"] },
+      config: {
+        listAccountIds: () => cfg.aampHost ? ["default"] : [],
+        resolveAccount: () => ({ aampHost: cfg.aampHost }),
+        isEnabled: () => !!cfg.aampHost,
+        isConfigured: () => !!loadCachedIdentity(cfg)
+      },
+      gateway: {
+        startAccount: async (ctx) => {
+          channelRuntime = ctx.channelRuntime ?? null;
+          channelCfg = ctx.cfg ?? null;
+          api.logger.info(`[AAMP] Channel adapter started \u2014 channelRuntime ${channelRuntime ? "available" : "NOT available"}`);
+          await new Promise((resolve) => {
+            ctx.abortSignal?.addEventListener("abort", () => resolve());
+          });
+          channelRuntime = null;
+          channelCfg = null;
+        },
+        stopAccount: async () => {
+          channelRuntime = null;
+          channelCfg = null;
+        }
+      }
+    });
+    async function doConnect(identity) {
+      if (reconcileTimer) {
+        clearInterval(reconcileTimer);
+        reconcileTimer = null;
+      }
+      agentEmail = identity.email;
+      lastConnectionError = "";
+      lastDisconnectReason = "";
+      const base = baseUrl(cfg.aampHost);
+      aampClient = new AampClient({
+        email: identity.email,
+        jmapToken: identity.jmapToken,
+        jmapUrl: base,
+        smtpHost: new URL(base).hostname,
+        smtpPort: 587,
+        smtpPassword: identity.smtpPassword,
+        // Local/dev: management-service proxy uses plain HTTP, no TLS cert to verify.
+        // Production: set to true when using wss:// with valid certs.
+        rejectUnauthorized: false
+      });
+      aampClient.on("task.dispatch", (task) => {
+        api.logger.info(`[AAMP] \u2190 task.dispatch  ${task.taskId}  "${task.title}"  from=${task.from}`);
+        const allowed = cfg.allowedSenders;
+        if (allowed !== void 0) {
+          const fromLower = task.from.toLowerCase();
+          const permitted = allowed.some((e) => e.toLowerCase() === fromLower);
+          if (!permitted) {
+            api.logger.warn(`[AAMP] \u2717 rejected (not in allowedSenders): ${task.from}  task=${task.taskId}`);
+            void aampClient.sendResult({
+              to: task.from,
+              taskId: task.taskId,
+              status: "rejected",
+              output: "",
+              errorMsg: `Sender ${task.from} is not in the allowed senders list.`
+            }).catch((err) => {
+              api.logger.error(`[AAMP] Failed to send rejection for task ${task.taskId}: ${err.message}`);
+            });
+            return;
+          }
+        }
+        pendingTasks.set(task.taskId, {
+          taskId: task.taskId,
+          from: task.from,
+          title: task.title,
+          bodyText: task.bodyText ?? "",
+          contextLinks: task.contextLinks,
+          timeoutSecs: task.timeoutSecs,
+          messageId: task.messageId ?? "",
+          receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        try {
+          api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: currentSessionKey });
+          api.logger.info(`[AAMP] Heartbeat triggered for session ${currentSessionKey}`);
+        } catch (err) {
+          api.logger.warn(`[AAMP] Could not trigger heartbeat: ${err.message}`);
+        }
+      });
+      aampClient.on("task.result", (result) => {
+        api.logger.info(`[AAMP] \u2190 task.result  ${result.taskId}  status=${result.status}  from=${result.from}`);
+        const sub = dispatchedSubtasks.get(result.taskId);
+        dispatchedSubtasks.delete(result.taskId);
+        const waiter = waitingDispatches.get(result.taskId);
+        if (waiter) {
+          waitingDispatches.delete(result.taskId);
+          api.logger.info(`[AAMP] Resolving sync waiter for sub-task ${result.taskId}`);
+          waiter({ type: "result", data: result });
+          return;
+        }
+        const downloadedFiles = [];
+        const downloadPromise = (async () => {
+          if (!result.attachments?.length)
+            return;
+          const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
+          const dir = "/tmp/aamp-files";
+          mkdirSync2(dir, { recursive: true });
+          for (const att of result.attachments) {
+            try {
+              const buffer = await aampClient.downloadBlob(att.blobId, att.filename);
+              const filepath = `${dir}/${att.filename}`;
+              writeFileSync2(filepath, buffer);
+              downloadedFiles.push({ filename: att.filename, path: filepath, size: buffer.length });
+              api.logger.info(`[AAMP] Pre-downloaded: ${att.filename} (${(buffer.length / 1024).toFixed(1)} KB) \u2192 ${filepath}`);
+            } catch (dlErr) {
+              api.logger.warn(`[AAMP] Pre-download failed for ${att.filename}: ${dlErr.message}`);
+            }
+          }
+        })();
+        downloadPromise.then(() => {
+          const MAX_OUTPUT_CHARS = 800;
+          const label = result.status === "completed" ? "Sub-task completed" : "Sub-task rejected";
+          const rawOutput = result.output ?? "";
+          const truncatedOutput = rawOutput.length > MAX_OUTPUT_CHARS ? rawOutput.slice(0, MAX_OUTPUT_CHARS) + `
+
+... [truncated, ${rawOutput.length} chars total]` : rawOutput;
+          let attachmentInfo = "";
+          if (downloadedFiles.length > 0) {
+            attachmentInfo = `
+
+Attachments (pre-downloaded to local disk):
+${downloadedFiles.map(
+              (f) => `- ${f.filename} (${(f.size / 1024).toFixed(1)} KB) \u2192 ${f.path}`
+            ).join("\n")}
+Use aamp_send_result with attachments: [${downloadedFiles.map((f) => `{ filename: "${f.filename}", path: "${f.path}" }`).join(", ")}] to forward them.`;
+          } else if (result.attachments?.length) {
+            const files = result.attachments.map(
+              (a) => `${a.filename} (${(a.size / 1024).toFixed(1)} KB, blobId: ${a.blobId})`
+            );
+            attachmentInfo = `
+
+Attachments (download failed \u2014 use aamp_download_attachment manually):
+${files.join("\n")}`;
+          }
+          pendingTasks.set(`result:${result.taskId}`, {
+            taskId: result.taskId,
+            from: result.from,
+            title: `${label}: ${sub?.title ?? result.taskId}`,
+            bodyText: result.status === "completed" ? `Agent ${result.from} completed the sub-task.
+
+Output:
+${truncatedOutput}${attachmentInfo}` : `Agent ${result.from} rejected the sub-task.
+
+Reason: ${result.errorMsg ?? "unknown"}`,
+            contextLinks: [],
+            timeoutSecs: 0,
+            messageId: "",
+            receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (channelRuntime && channelCfg) {
+            const notifyBody = pendingTasks.get(`result:${result.taskId}`);
+            const actionableTasks = [...pendingTasks.entries()].filter(([key]) => !key.startsWith("result:") && !key.startsWith("help:")).map(([, t]) => t);
+            const actionSection = actionableTasks.length > 0 ? `
+
+### Action Required
+You MUST call aamp_send_result to complete the pending task(s):
+${actionableTasks.map((t) => `- Task ID: ${t.taskId} | From: ${t.from} | Title: "${t.title}"`).join("\n")}` : "";
+            const prompt = `## Sub-task Update
+
+${notifyBody?.bodyText ?? "Sub-task completed."}${actionSection}`;
+            channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+              ctx: {
+                Body: `Sub-task result: ${result.taskId}`,
+                BodyForAgent: prompt,
+                From: result.from,
+                To: agentEmail,
+                SessionKey: `aamp:default:${result.from}`,
+                AccountId: "default",
+                ChatType: "dm",
+                Provider: "aamp",
+                Surface: "aamp",
+                OriginatingChannel: "aamp",
+                OriginatingTo: result.from,
+                MessageSid: result.taskId,
+                Timestamp: Date.now(),
+                SenderName: result.from,
+                SenderId: result.from,
+                CommandAuthorized: true
+              },
+              cfg: channelCfg,
+              dispatcherOptions: {
+                deliver: async () => {
+                },
+                onError: (err) => {
+                  api.logger.error(`[AAMP] Channel dispatch error: ${err instanceof Error ? err.message : String(err)}`);
+                }
+              }
+            }).then(() => {
+              api.logger.info(`[AAMP] Channel dispatch completed for sub-task result ${result.taskId}`);
+              pendingTasks.delete(`result:${result.taskId}`);
+            }).catch((err) => {
+              api.logger.error(`[AAMP] Channel dispatch failed: ${err.message}`);
+            });
+          } else {
+            const notifySessionKey = `agent:main:aamp-notify-${Date.now()}`;
+            try {
+              api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: notifySessionKey });
+              api.logger.info(`[AAMP] Heartbeat for sub-task result ${result.taskId}`);
+            } catch (err) {
+              api.logger.warn(`[AAMP] Heartbeat for sub-task result failed: ${err.message}`);
+            }
+          }
+        }).catch((err) => {
+          api.logger.error(`[AAMP] Sub-task result processing failed: ${err.message}`);
+        });
+      });
+      aampClient.on("task.help", (help) => {
+        api.logger.info(`[AAMP] \u2190 task.help  ${help.taskId}  question="${help.question}"  from=${help.from}`);
+        const waiter = waitingDispatches.get(help.taskId);
+        if (waiter) {
+          waitingDispatches.delete(help.taskId);
+          api.logger.info(`[AAMP] Resolving sync waiter for sub-task help ${help.taskId}`);
+          waiter({ type: "help", data: help });
+          return;
+        }
+        const sub = dispatchedSubtasks.get(help.taskId);
+        pendingTasks.set(`help:${help.taskId}`, {
+          taskId: help.taskId,
+          from: help.from,
+          title: `Sub-task needs help: ${sub?.title ?? help.taskId}`,
+          bodyText: `Agent ${help.from} is asking for help on the sub-task.
+
+Question: ${help.question}
+Blocked reason: ${help.blockedReason}${help.suggestedOptions?.length ? `
+Suggested options: ${help.suggestedOptions.join(", ")}` : ""}`,
+          contextLinks: [],
+          timeoutSecs: 0,
+          messageId: "",
+          receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (channelRuntime && channelCfg) {
+          const notifyBody = pendingTasks.get(`help:${help.taskId}`);
+          const prompt = `## Sub-task Help Request
+
+${notifyBody?.bodyText ?? help.question}`;
+          channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: {
+              Body: `Sub-task help: ${help.taskId}`,
+              BodyForAgent: prompt,
+              From: help.from,
+              To: agentEmail,
+              SessionKey: `aamp:default:${help.from}`,
+              AccountId: "default",
+              ChatType: "dm",
+              Provider: "aamp",
+              Surface: "aamp",
+              OriginatingChannel: "aamp",
+              OriginatingTo: help.from,
+              MessageSid: help.taskId,
+              Timestamp: Date.now(),
+              SenderName: help.from,
+              SenderId: help.from,
+              CommandAuthorized: true
+            },
+            cfg: channelCfg,
+            dispatcherOptions: {
+              deliver: async () => {
+              },
+              onError: (err) => {
+                api.logger.error(`[AAMP] Channel dispatch error (help): ${err instanceof Error ? err.message : String(err)}`);
+              }
+            }
+          }).then(() => {
+            pendingTasks.delete(`help:${help.taskId}`);
+          }).catch((err) => {
+            api.logger.error(`[AAMP] Channel dispatch failed for help: ${err.message}`);
+          });
+        } else {
+          const helpSessionKey = `agent:main:aamp-notify-${Date.now()}`;
+          try {
+            api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: helpSessionKey });
+            api.logger.info(`[AAMP] Heartbeat fallback for sub-task help ${help.taskId}`);
+          } catch (err) {
+            api.logger.warn(`[AAMP] Heartbeat for sub-task help failed: ${err.message}`);
+          }
+        }
+      });
+      aampClient.on("connected", () => {
+        lastConnectionError = "";
+        lastDisconnectReason = "";
+        const mode = aampClient?.isUsingPollingFallback() ? "polling" : "websocket";
+        if (mode === lastTransportMode)
+          return;
+        if (mode === "polling") {
+          api.logger.warn(`[AAMP] Connected (polling fallback active) \u2014 listening as ${agentEmail}`);
+        } else if (lastTransportMode === "polling") {
+          api.logger.info(`[AAMP] WebSocket restored \u2014 listening as ${agentEmail}`);
+        } else {
+          api.logger.info(`[AAMP] Connected \u2014 listening as ${agentEmail}`);
+        }
+        lastTransportMode = mode;
+      });
+      aampClient.on("disconnected", (reason) => {
+        lastDisconnectReason = reason;
+        if (lastTransportMode !== "disconnected") {
+          api.logger.warn(`[AAMP] Disconnected: ${reason} (will auto-reconnect)`);
+          lastTransportMode = "disconnected";
+        }
+      });
+      aampClient.on("error", (err) => {
+        lastConnectionError = err.message;
+        api.logger.error(`[AAMP] ${err.message}`);
+      });
+      await aampClient.connect();
+      reconcileTimer = setInterval(() => {
+        if (!aampClient)
+          return;
+        void aampClient.reconcileRecentEmails(20).catch((err) => {
+          lastConnectionError = err.message;
+          api.logger.warn(`[AAMP] Mailbox reconcile failed: ${err.message}`);
+        });
+      }, 15e3);
+    }
+    api.registerTool({
+      name: "aamp_connect",
+      description: "Connect this agent to the AAMP service. Call this once at the start of a session to obtain an email identity and begin receiving AAMP tasks via JMAP WebSocket Push. Credentials are cached to disk so the same mailbox address is reused after a gateway restart. Delete the credentials file (default: ~/.openclaw/extensions/aamp/.credentials.json) to get a fresh identity.",
+      parameters: {
+        type: "object",
+        properties: {
+          slug: {
+            type: "string",
+            description: 'Optional agent name prefix (e.g. "code-reviewer"). Defaults to the slug set in plugin config, or "openclaw-agent".'
+          }
+        }
+      },
+      execute: async (_id, params) => {
+        const p = params;
+        if (aampClient?.isConnected()) {
+          return {
+            content: [{ type: "text", text: `Already connected as ${agentEmail}.` }]
+          };
+        }
+        if (!cfg.aampHost) {
+          return {
+            content: [{
+              type: "text",
+              text: 'Error: aampHost is not configured. Add "aampHost" to the aamp plugin config in openclaw.json.'
+            }]
+          };
+        }
+        try {
+          const effectiveCfg = p.slug ? { ...cfg, slug: p.slug } : cfg;
+          const identity = await resolveIdentity(effectiveCfg);
+          await doConnect(identity);
+          return {
+            content: [{
+              type: "text",
+              text: [
+                `Connected as ${agentEmail}`,
+                `JMAP push active \u2014 incoming task.dispatch emails will appear in aamp_pending_tasks.`
+              ].join("\n")
+            }]
+          };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Error: ${err.message}` }]
+          };
+        }
+      }
+    }, { name: "aamp_connect" });
+    api.registerService({
+      id: "aamp-service",
+      start: async () => {
+        if (!cfg.aampHost) {
+          api.logger.info("[AAMP] aampHost not configured \u2014 skipping auto-connect");
+          return;
+        }
+        const cached = loadCachedIdentity(cfg);
+        if (!cached) {
+          api.logger.info("[AAMP] No cached credentials \u2014 call aamp_connect to register");
+          return;
+        }
+        try {
+          await doConnect(cached);
+        } catch (err) {
+          api.logger.warn(`[AAMP] Service auto-connect failed: ${err.message}`);
+        }
+      },
+      stop: () => {
+        if (reconcileTimer) {
+          clearInterval(reconcileTimer);
+          reconcileTimer = null;
+        }
+        if (aampClient) {
+          try {
+            aampClient.disconnect();
+            api.logger.info("[AAMP] Disconnected on gateway stop");
+          } catch {
+          }
+        }
+      }
+    });
+    api.on("gateway_start", () => {
+      if (pendingTasks.size === 0)
+        return;
+      api.logger.info(`[AAMP] gateway_start: re-triggering heartbeat for ${pendingTasks.size} pending task(s)`);
+      try {
+        api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: currentSessionKey });
+      } catch (err) {
+        api.logger.warn(`[AAMP] gateway_start heartbeat failed: ${err.message}`);
+      }
+    });
+    api.on(
+      "before_prompt_build",
+      (_event, ctx) => {
+        if (ctx?.sessionKey && !String(ctx.sessionKey).startsWith("aamp:")) {
+          currentSessionKey = ctx.sessionKey;
+        }
+        const now = Date.now();
+        for (const [id, t] of pendingTasks) {
+          if (t.timeoutSecs && now - new Date(t.receivedAt).getTime() > t.timeoutSecs * 1e3) {
+            api.logger.warn(`[AAMP] Task ${id} timed out \u2014 removing from queue`);
+            pendingTasks.delete(id);
+          }
+        }
+        if (pendingTasks.size === 0)
+          return {};
+        const allEntries = [...pendingTasks.entries()];
+        const notifications = allEntries.filter(([key]) => key.startsWith("result:") || key.startsWith("help:"));
+        const actionable = allEntries.filter(([key]) => !key.startsWith("result:") && !key.startsWith("help:"));
+        const [taskKey, task] = notifications.length > 0 ? notifications.sort((a, b) => new Date(a[1].receivedAt).getTime() - new Date(b[1].receivedAt).getTime())[0] : actionable.sort((a, b) => new Date(a[1].receivedAt).getTime() - new Date(b[1].receivedAt).getTime())[0];
+        const isNotification = taskKey.startsWith("result:") || taskKey.startsWith("help:");
+        if (isNotification && taskKey) {
+          pendingTasks.delete(taskKey);
+        }
+        const actionableTasks = [...pendingTasks.entries()].filter(([key]) => !key.startsWith("result:") && !key.startsWith("help:")).map(([, t]) => t);
+        const hasAttachmentInfo = isNotification && (task.bodyText?.includes("aamp_download_attachment") ?? false);
+        const actionRequiredSection = isNotification && actionableTasks.length > 0 ? [
+          ``,
+          `### Action Required`,
+          ``,
+          `You still have ${actionableTasks.length} pending task(s) that need a response.`,
+          `Use the sub-task result above to complete them by calling aamp_send_result.`,
+          ``,
+          ...actionableTasks.map(
+            (t) => `- Task ID: ${t.taskId} | From: ${t.from} | Title: "${t.title}"`
+          ),
+          ...hasAttachmentInfo ? [
+            ``,
+            `### Forwarding Attachments`,
+            `The sub-task result includes file attachments. To forward them:`,
+            `1. Call aamp_download_attachment for each blobId listed above`,
+            `2. Include the downloaded files in aamp_send_result via the attachments parameter`,
+            `   Example: attachments: [{ filename: "file.html", path: "/tmp/aamp-files/file.html" }]`
+          ] : []
+        ].join("\n") : "";
+        const lines = isNotification ? [
+          `## Sub-task Update`,
+          ``,
+          `A sub-task you dispatched has returned a result. Review the information below.`,
+          `If the sub-task included attachments, use aamp_download_attachment to fetch them.`,
+          ``,
+          `Task ID:  ${task.taskId}`,
+          `From:     ${task.from}`,
+          `Title:    ${task.title}`,
+          task.bodyText ? `
+${task.bodyText}` : "",
+          actionRequiredSection,
+          pendingTasks.size > 1 ? `
+(+${pendingTasks.size - 1} more items queued)` : ""
+        ] : [
+          `## Pending AAMP Task (action required)`,
+          ``,
+          `You have received a task via AAMP email. You MUST call one of the two tools below`,
+          `BEFORE responding to the user \u2014 do not skip this step.`,
+          ``,
+          `### Tool selection rules (follow strictly):`,
+          ``,
+          `Use aamp_send_result ONLY when ALL of the following are true:`,
+          `  1. The title contains a clear, specific action verb (e.g. "summarise", "review",`,
+          `     "translate", "generate", "fix", "search", "compare", "list")`,
+          `  2. You know exactly what input/resource to act on`,
+          `  3. No ambiguity remains \u2014 you could start work immediately without asking anything`,
+          ``,
+          `Use aamp_send_help in ALL other cases, including:`,
+          `  - Title is a greeting or salutation ("hello", "hi", "hey", "test", "ping", etc.)`,
+          `  - Title is fewer than 4 words and contains no actionable verb`,
+          `  - Title is too vague to act on without guessing (e.g. "help", "task", "question")`,
+          `  - Required context is missing (which file? which URL? which criteria?)`,
+          `  - Multiple interpretations are equally plausible`,
+          ``,
+          `IMPORTANT: Responding to a greeting with a greeting is WRONG. "hello" is not a`,
+          `valid task description \u2014 ask what specific task the dispatcher needs done.`,
+          ``,
+          `### Sub-task dispatch rules:`,
+          `If you delegate work to another agent via aamp_dispatch_task, you MUST pass`,
+          `parentTaskId: "${task.taskId}" to establish the parent-child relationship.`,
+          ``,
+          `Task ID:  ${task.taskId}`,
+          `From:     ${task.from}`,
+          `Title:    ${task.title}`,
+          task.bodyText ? `Description:
+${task.bodyText}` : "",
+          task.contextLinks.length ? `Context Links:
+${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
+          task.timeoutSecs ? `Deadline: ${task.timeoutSecs}s from dispatch` : `Deadline: none`,
+          `Received: ${task.receivedAt}`,
+          pendingTasks.size > 1 ? `
+(+${pendingTasks.size - 1} more tasks queued)` : ""
+        ].filter(Boolean).join("\n");
+        return { prependContext: lines };
+      },
+      { priority: 5 }
+    );
+    api.registerTool({
+      name: "aamp_send_result",
+      description: "Send the result of an AAMP task back to the dispatcher. Call this after you have finished processing the task.",
+      parameters: {
+        type: "object",
+        required: ["taskId", "status", "output"],
+        properties: {
+          taskId: {
+            type: "string",
+            description: "The AAMP task ID to reply to (from the system context)"
+          },
+          status: {
+            type: "string",
+            enum: ["completed", "rejected"],
+            description: '"completed" on success, "rejected" if the task cannot be done'
+          },
+          output: {
+            type: "string",
+            description: "Your result or explanation"
+          },
+          errorMsg: {
+            type: "string",
+            description: "Optional error details (use only when status = rejected)"
+          },
+          attachments: {
+            type: "array",
+            description: "File attachments. Each item: { filename, contentType, path (local file path) }",
+            items: {
+              type: "object",
+              properties: {
+                filename: { type: "string" },
+                contentType: { type: "string" },
+                path: { type: "string", description: "Absolute path to the file on disk" }
+              },
+              required: ["filename", "path"]
+            }
+          },
+          structuredResult: {
+            type: "array",
+            description: "Optional structured Meego field values.",
+            items: {
+              type: "object",
+              required: ["fieldKey", "fieldTypeKey"],
+              properties: {
+                fieldKey: { type: "string" },
+                fieldTypeKey: { type: "string" },
+                fieldAlias: { type: "string" },
+                value: {
+                  description: "Field value in the exact format required by Meego for this field type."
+                },
+                index: { type: "string" },
+                attachmentFilenames: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "For attachment fields, filenames from attachments[] that should be uploaded into this field."
+                }
+              }
+            }
+          }
+        }
+      },
+      execute: async (_id, params) => {
+        const p = params;
+        const task = pendingTasks.get(p.taskId);
+        if (!task) {
+          return {
+            content: [{ type: "text", text: `Error: task ${p.taskId} not found in pending queue.` }]
+          };
+        }
+        if (!aampClient?.isConnected()) {
+          return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
+        }
+        api.logger.info(`[AAMP] aamp_send_result params ${JSON.stringify({
+          taskId: p.taskId,
+          status: p.status,
+          output: p.output,
+          errorMsg: p.errorMsg,
+          attachments: p.attachments?.map((a) => ({
+            filename: a.filename,
+            contentType: a.contentType ?? "application/octet-stream",
+            path: a.path
+          })) ?? [],
+          structuredResult: p.structuredResult?.map((field) => ({
+            fieldKey: field.fieldKey,
+            fieldTypeKey: field.fieldTypeKey,
+            fieldAlias: field.fieldAlias,
+            value: field.value,
+            index: field.index,
+            attachmentFilenames: field.attachmentFilenames ?? []
+          })) ?? []
+        })}`);
+        let attachments;
+        if (p.attachments?.length) {
+          const { readFileSync: readFileSync2 } = await import("node:fs");
+          attachments = p.attachments.map((a) => ({
+            filename: a.filename,
+            contentType: a.contentType ?? "application/octet-stream",
+            content: readFileSync2(a.path)
+          }));
+        }
+        await aampClient.sendResult({
+          to: task.from,
+          taskId: task.taskId,
+          status: p.status,
+          output: p.output,
+          errorMsg: p.errorMsg,
+          structuredResult: p.structuredResult?.length ? p.structuredResult : void 0,
+          inReplyTo: task.messageId || void 0,
+          attachments
+        });
+        pendingTasks.delete(task.taskId);
+        api.logger.info(`[AAMP] \u2192 task.result  ${task.taskId}  ${p.status}`);
+        if (pendingTasks.size > 0) {
+          try {
+            api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: currentSessionKey });
+          } catch {
+          }
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Result sent for task ${task.taskId} (status: ${p.status}).`
+            }
+          ]
+        };
+      }
+    }, { name: "aamp_send_result" });
+    api.registerTool({
+      name: "aamp_send_help",
+      description: "Send a help request for an AAMP task when you are blocked or need human clarification before you can proceed.",
+      parameters: {
+        type: "object",
+        required: ["taskId", "question", "blockedReason"],
+        properties: {
+          taskId: {
+            type: "string",
+            description: "The AAMP task ID"
+          },
+          question: {
+            type: "string",
+            description: "Your question for the human dispatcher"
+          },
+          blockedReason: {
+            type: "string",
+            description: "Why you cannot proceed without their input"
+          },
+          suggestedOptions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional list of choices for the dispatcher to pick from"
+          }
+        }
+      },
+      execute: async (_id, params) => {
+        const p = params;
+        const task = pendingTasks.get(p.taskId);
+        if (!task) {
+          return {
+            content: [{ type: "text", text: `Error: task ${p.taskId} not found in pending queue.` }]
+          };
+        }
+        if (!aampClient?.isConnected()) {
+          return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
+        }
+        await aampClient.sendHelp({
+          to: task.from,
+          taskId: task.taskId,
+          question: p.question,
+          blockedReason: p.blockedReason,
+          suggestedOptions: p.suggestedOptions ?? [],
+          inReplyTo: task.messageId || void 0
+        });
+        api.logger.info(`[AAMP] \u2192 task.help  ${task.taskId}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Help request sent for task ${task.taskId}. The task remains pending until the dispatcher replies.`
+            }
+          ]
+        };
+      }
+    }, { name: "aamp_send_help" });
+    api.registerTool({
+      name: "aamp_pending_tasks",
+      description: "List all AAMP tasks currently waiting to be processed.",
+      parameters: { type: "object", properties: {} },
+      execute: async () => {
+        if (pendingTasks.size === 0) {
+          return { content: [{ type: "text", text: "No pending AAMP tasks." }] };
+        }
+        const lines = [...pendingTasks.values()].sort((a, b) => new Date(a.receivedAt).getTime() - new Date(b.receivedAt).getTime()).map(
+          (t, i) => `${i + 1}. [${t.taskId}] "${t.title}"${t.bodyText ? `
+   Description: ${t.bodyText}` : ""} \u2014 from ${t.from} (received ${t.receivedAt})`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${pendingTasks.size} pending task(s):
+${lines.join("\n")}`
+            }
+          ]
+        };
+      }
+    }, { name: "aamp_pending_tasks" });
+    api.registerTool({
+      name: "aamp_dispatch_task",
+      description: "Send a task to another AAMP agent and WAIT for the result. This tool blocks until the sub-agent replies (typically 5-60s). The sub-agent's output and any attachment file paths are returned directly.",
+      parameters: {
+        type: "object",
+        required: ["to", "title"],
+        properties: {
+          to: { type: "string", description: "Target agent AAMP email address" },
+          title: { type: "string", description: "Task title (concise summary)" },
+          bodyText: { type: "string", description: "Detailed task description" },
+          parentTaskId: { type: "string", description: "If you are processing a pending AAMP task, pass its Task ID here to establish parent-child nesting. Omit for top-level tasks." },
+          timeoutSecs: { type: "number", description: "Timeout in seconds (optional)" },
+          contextLinks: {
+            type: "array",
+            items: { type: "string" },
+            description: "URLs providing context (optional)"
+          },
+          attachments: {
+            type: "array",
+            description: "File attachments. Each item: { filename, contentType, path (local file path) }",
+            items: {
+              type: "object",
+              properties: {
+                filename: { type: "string" },
+                contentType: { type: "string" },
+                path: { type: "string", description: "Absolute path to the file on disk" }
+              },
+              required: ["filename", "path"]
+            }
+          }
+        }
+      },
+      execute: async (_id, params) => {
+        if (!aampClient?.isConnected()) {
+          return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
+        }
+        try {
+          let attachments;
+          if (params.attachments?.length) {
+            const { readFileSync: readFileSync2 } = await import("node:fs");
+            attachments = params.attachments.map((a) => ({
+              filename: a.filename,
+              contentType: a.contentType ?? "application/octet-stream",
+              content: readFileSync2(a.path)
+            }));
+          }
+          const result = await aampClient.sendTask({
+            to: params.to,
+            title: params.title,
+            parentTaskId: params.parentTaskId,
+            timeoutSecs: params.timeoutSecs,
+            contextLinks: params.contextLinks,
+            attachments
+          });
+          dispatchedSubtasks.set(result.taskId, {
+            to: params.to,
+            title: params.title,
+            dispatchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            parentTaskId: params.parentTaskId
+          });
+          api.logger.info(`[AAMP] \u2192 task.dispatch  ${result.taskId}  to=${params.to}  parent=${params.parentTaskId ?? "none"}  (waiting for reply\u2026)`);
+          const timeoutMs = (params.timeoutSecs ?? 300) * 1e3;
+          const reply = await new Promise((resolve, reject) => {
+            waitingDispatches.set(result.taskId, resolve);
+            setTimeout(() => {
+              if (waitingDispatches.delete(result.taskId)) {
+                reject(new Error(`Sub-task ${result.taskId} timed out after ${params.timeoutSecs ?? 300}s`));
+              }
+            }, timeoutMs);
+          });
+          api.logger.info(`[AAMP] \u2190 sync reply for ${result.taskId}: type=${reply.type} attachments=${JSON.stringify(reply.data?.attachments?.length ?? 0)}`);
+          if (reply.type === "result") {
+            const r = reply.data;
+            let attachmentLines = "";
+            if (r.attachments?.length) {
+              api.logger.info(`[AAMP] Downloading ${r.attachments.length} attachment(s) from sync reply...`);
+              const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
+              const dir = "/tmp/aamp-files";
+              mkdirSync2(dir, { recursive: true });
+              const downloaded = [];
+              const base = baseUrl(cfg.aampHost);
+              const identity = loadCachedIdentity(cfg);
+              const authHeader = identity ? `Basic ${Buffer.from(identity.email + ":" + identity.smtpPassword).toString("base64")}` : "";
+              for (const att of r.attachments) {
+                try {
+                  const dlUrl = `${base}/jmap/download/n/${encodeURIComponent(att.blobId)}/${encodeURIComponent(att.filename)}?accept=application/octet-stream`;
+                  api.logger.info(`[AAMP] Fetching ${dlUrl}`);
+                  const dlRes = await fetch(dlUrl, { headers: { Authorization: authHeader } });
+                  if (!dlRes.ok)
+                    throw new Error(`HTTP ${dlRes.status}`);
+                  const buffer = Buffer.from(await dlRes.arrayBuffer());
+                  const filepath = `${dir}/${att.filename}`;
+                  writeFileSync2(filepath, buffer);
+                  downloaded.push(`${att.filename} (${(buffer.length / 1024).toFixed(1)} KB) \u2192 ${filepath}`);
+                  api.logger.info(`[AAMP] Downloaded: ${att.filename} (${(buffer.length / 1024).toFixed(1)} KB)`);
+                } catch (dlErr) {
+                  api.logger.error(`[AAMP] Download failed for ${att.filename}: ${dlErr.message}`);
+                }
+              }
+              if (downloaded.length) {
+                attachmentLines = `
+
+Attachments downloaded:
+${downloaded.join("\n")}`;
+              }
+            }
+            return {
+              content: [{
+                type: "text",
+                text: [
+                  `Sub-task ${r.status}: ${params.title}`,
+                  `Agent: ${r.from}`,
+                  `Task ID: ${result.taskId}`,
+                  r.status === "completed" ? `
+Output:
+${r.output}` : `
+Error: ${r.errorMsg ?? "rejected"}`,
+                  attachmentLines
+                ].filter(Boolean).join("\n")
+              }]
+            };
+          } else {
+            const h = reply.data;
+            return {
+              content: [{
+                type: "text",
+                text: [
+                  `Sub-task needs help: ${params.title}`,
+                  `Agent: ${h.from}`,
+                  `Task ID: ${result.taskId}`,
+                  `
+Question: ${h.question}`,
+                  `Blocked reason: ${h.blockedReason}`,
+                  h.suggestedOptions?.length ? `Options: ${h.suggestedOptions.join(" | ")}` : ""
+                ].filter(Boolean).join("\n")
+              }]
+            };
+          }
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Error dispatching task: ${err.message}` }]
+          };
+        }
+      }
+    }, { name: "aamp_dispatch_task" });
+    api.registerTool({
+      name: "aamp_check_protocol",
+      description: "Check if an email address supports the AAMP protocol. Returns { aamp: true/false } indicating whether the address is an AAMP agent.",
+      parameters: {
+        type: "object",
+        required: ["email"],
+        properties: {
+          email: { type: "string", description: "Email address to check" }
+        }
+      },
+      execute: async (_id, params) => {
+        const base = baseUrl(cfg.aampHost);
+        const email = params?.email ?? "";
+        if (!email) {
+          return { content: [{ type: "text", text: "Error: email parameter is required" }] };
+        }
+        try {
+          const res = await fetch(`${base}/api/aamp-check?email=${encodeURIComponent(email)}`);
+          if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+          const data = await res.json();
+          return {
+            content: [{
+              type: "text",
+              text: data.aamp ? `${params.email} supports AAMP protocol (domain: ${data.domain ?? "unknown"})` : `${params.email} does not support AAMP protocol`
+            }]
+          };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Could not check ${params.email}: ${err.message}` }]
+          };
+        }
+      }
+    }, { name: "aamp_check_protocol" });
+    api.registerTool({
+      name: "aamp_download_attachment",
+      description: "Download an AAMP email attachment to local disk by its blobId. Use this to retrieve files received from sub-agent task results.",
+      parameters: {
+        type: "object",
+        required: ["blobId", "filename"],
+        properties: {
+          blobId: { type: "string", description: "The JMAP blobId from the attachment metadata" },
+          filename: { type: "string", description: "Filename to save as" },
+          saveTo: { type: "string", description: "Directory to save to (default: /tmp/aamp-files)" }
+        }
+      },
+      execute: async (_id, params) => {
+        if (!aampClient?.isConnected()) {
+          return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
+        }
+        const dir = params.saveTo ?? "/tmp/aamp-files";
+        const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
+        mkdirSync2(dir, { recursive: true });
+        try {
+          const buffer = await aampClient.downloadBlob(params.blobId, params.filename);
+          const filepath = `${dir}/${params.filename}`;
+          writeFileSync2(filepath, buffer);
+          return {
+            content: [{
+              type: "text",
+              text: `Downloaded ${params.filename} (${(buffer.length / 1024).toFixed(1)} KB) to ${filepath}`
+            }]
+          };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Download failed: ${err.message}` }]
+          };
+        }
+      }
+    }, { name: "aamp_download_attachment" });
+    api.registerCommand({
+      name: "aamp-status",
+      description: "Show AAMP connection status and pending task queue",
+      acceptsArgs: false,
+      requireAuth: false,
+      handler: () => {
+        const isPollingFallback = aampClient?.isUsingPollingFallback?.() ?? false;
+        const connectionLine = aampClient?.isConnected() ? isPollingFallback ? "\u{1F7E1} connected (polling fallback)" : "\u2705 connected" : "\u274C disconnected";
+        return {
+          text: [
+            `**AAMP Plugin Status**`,
+            `Host:       ${cfg.aampHost || "(not configured)"}`,
+            `Identity:   ${agentEmail || "(not yet registered)"}`,
+            `Connection: ${connectionLine}`,
+            `Cached:     ${loadCachedIdentity(cfg) ? "yes" : "no"}`,
+            lastConnectionError ? `Last error: ${lastConnectionError}` : "",
+            lastDisconnectReason ? `Last disconnect: ${lastDisconnectReason}` : "",
+            `Pending:    ${pendingTasks.size} task(s)`,
+            ...[...pendingTasks.values()].map(
+              (t) => `  \u2022 ${t.taskId.slice(0, 8)}\u2026 "${t.title}" from ${t.from}`
+            )
+          ].filter(Boolean).join("\n")
+        };
+      }
+    });
+  }
+};
+export {
+  src_default as default
+};
+//# sourceMappingURL=index.js.map