hypermail-mcp 0.7.17 → 0.7.18

package/README.md

@@ -3,6 +3,12 @@
 A **Model Context Protocol** server that lets an agent operate any of the user's
 inboxes through a single, unified tool surface.
 
+> **v0.7.18** — `search_emails` can now omit `account` to search all
+> registered accounts in parallel, returning account-annotated results plus
+> per-account errors without discarding successful matches. All-account
+> `get_new_emails` polling also collects and hydrates per-account batches in
+> parallel while preserving the global oldest-first limit.
+>
 > **v0.7.17** — Hardened Outlook message IDs returned by `list_emails` and
 > `search_emails`: Outlook reads now request Microsoft Graph immutable IDs,
 > `search_emails` probes results and marks stale/not-found messages with
@@ -291,7 +297,7 @@ account store.
 | `remove_account` | `email` | Deletes tokens for the account. |
 | `list_emails` | `account`, `folder?`, `limit?`, `unreadOnly?`, `skip?` | Defaults: folder=`inbox`, limit=25. Supports pagination via `skip` — response includes `hasMore`. |
 | `get_new_emails` | `account?`, `limit?` | Pull new inbox emails not previously returned by this tool. `limit` defaults to 10 and is global when `account` is omitted. Returns full markdown bodies with attachment metadata; bodies may be truncated. |
-| `search_emails` | `account`, `query`, `limit?` | KQL on Outlook. |
+| `search_emails` | `account?`, `query`, `limit?` | Search one account when `account` is provided, or omit it to search all registered accounts in parallel. Returns account-annotated summaries and partial per-account errors. Uses KQL on Outlook. |
 | `read_email` | `account`, `id`, `format?` | Returns full body + recipients + attachment metadata. `format`: `markdown` (default), `html`, or `text`. |
 | `read_attachment` | `account`, `messageId`, `attachmentId` | Download an attachment to a temporary file and return its path. |
 | `archive_email` | `account`, `id` | Move a message to the Archive folder. |
@@ -319,6 +325,8 @@ tool on their own schedule, for example every 30–60 seconds.
 - `account` is optional. When omitted, the tool checks all registered accounts.
 - `limit` defaults to `10`. In all-account mode, the limit is a global total
   across accounts, selected by oldest `receivedAt` first.
+- All-account polling performs per-account candidate collection and hydration in
+  parallel, then returns the combined batch in oldest-first order.
 - First use for an account initializes its checkpoint to the newest inbox email
   and returns no emails for that account.
 - Later calls return emails not previously returned by this tool, oldest first.

package/dist/cli.js

@@ -17839,20 +17839,36 @@ function registerNewEmailTool(server, ctx) {
       const collected = [];
       const providersByEmail = /* @__PURE__ */ new Map();
       const accountsByEmail = /* @__PURE__ */ new Map();
-      for (const stored of accounts) {
-        try {
-          const { provider, account } = registry.resolveByEmail(stored.email);
-          const result = await collectCandidatesForAccount(store, provider, account, logger);
-          providersByEmail.set(result.account.email, provider);
-          accountsByEmail.set(result.account.email, result.account);
-          collected.push(...result.candidates);
-        } catch (err) {
-          logger.debug("get-new-emails", "accountError", {
-            account: stored.email,
-            message: errMsg(err)
-          });
-          errors.push({ account: stored.email, message: errMsg(err) });
+      const collectedByAccount = await Promise.all(
+        accounts.map(async (stored) => {
+          try {
+            const { provider, account } = registry.resolveByEmail(stored.email);
+            const result = await collectCandidatesForAccount(store, provider, account, logger);
+            return {
+              status: "ok",
+              account: result.account,
+              provider,
+              candidates: result.candidates
+            };
+          } catch (err) {
+            const message = errMsg(err);
+            logger.debug("get-new-emails", "accountError", { account: stored.email, message });
+            return {
+              status: "error",
+              account: stored.email,
+              message
+            };
+          }
+        })
+      );
+      for (const result of collectedByAccount) {
+        if (result.status === "error") {
+          errors.push({ account: result.account, message: result.message });
+          continue;
         }
+        providersByEmail.set(result.account.email, result.provider);
+        accountsByEmail.set(result.account.email, result.account);
+        collected.push(...result.candidates);
       }
       const selected = oldestCandidatesFirst(collected).slice(0, limit);
       logger.debug("get-new-emails", "selected", {
@@ -17871,27 +17887,33 @@ function registerNewEmailTool(server, ctx) {
           items.push(candidate);
           byAccount.set(candidate.account.email, items);
         }
-        for (const [email, accountCandidates] of byAccount) {
-          const provider = providersByEmail.get(email);
-          const account = accountsByEmail.get(email);
-          if (!provider || !account) continue;
-          try {
-            emails.push(
-              ...await hydrateAndAdvance(
-                store,
-                provider,
-                account,
-                accountCandidates,
-                logger
-              )
-            );
-          } catch (err) {
-            logger.debug("get-new-emails", "accountError", {
-              account: email,
-              message: errMsg(err)
-            });
-            errors.push({ account: email, message: errMsg(err) });
+        const hydratedByAccount = await Promise.all(
+          [...byAccount].map(async ([email, accountCandidates]) => {
+            const provider = providersByEmail.get(email);
+            const account = accountsByEmail.get(email);
+            if (!provider || !account) return { status: "ok", emails: [] };
+            try {
+              return {
+                status: "ok",
+                emails: await hydrateAndAdvance(store, provider, account, accountCandidates, logger)
+              };
+            } catch (err) {
+              const message = errMsg(err);
+              logger.debug("get-new-emails", "accountError", { account: email, message });
+              return {
+                status: "error",
+                account: email,
+                message
+              };
+            }
+          })
+        );
+        for (const result of hydratedByAccount) {
+          if (result.status === "error") {
+            errors.push({ account: result.account, message: result.message });
+            continue;
           }
+          emails.push(...result.emails);
         }
       }
       const orderedEmails = emails.sort(compareNewEmailOutputOldestFirst);
@@ -18082,10 +18104,15 @@ function registerBrowseTools(server, ctx) {
     skip: z5.number(),
     hasMore: z5.boolean()
   });
+  const searchEmailSummaryOutputSchema = emailSummaryOutputSchema.extend({
+    account: z5.string()
+  });
   const searchEmailsOutputSchema = z5.object({
     account: z5.string(),
     count: z5.number(),
-    items: z5.array(emailSummaryOutputSchema)
+    items: z5.array(searchEmailSummaryOutputSchema),
+    accounts: z5.array(z5.string()).optional(),
+    errors: z5.array(z5.object({ account: z5.string(), message: z5.string() })).optional()
   });
   if (shouldRegister("list_emails", tools)) {
     server.registerTool(
@@ -18129,29 +18156,67 @@ function registerBrowseTools(server, ctx) {
     server.registerTool(
       "search_emails",
       {
-        description: "Search emails by free-text query (KQL on Outlook). Returns lightweight summaries.",
+        description: "Search emails by free-text query (KQL on Outlook). Returns lightweight summaries. Pass `account` to search one account, or omit it to search all registered accounts in parallel.",
         inputSchema: z5.object({
-          account: z5.string().email(),
+          account: z5.string().email().optional(),
           query: z5.string().min(1),
           limit: z5.number().int().positive().max(100).optional()
         }),
         outputSchema: searchEmailsOutputSchema
       },
       async (args) => {
-        try {
-          const { provider, account } = registry.resolveByEmail(args.account);
-          const items = await provider.searchEmails(account, args.query, {
-            limit: args.limit
-          });
-          const data = {
-            account: account.email,
-            count: items.length,
-            items
-          };
-          return ok(data, data);
-        } catch (err) {
-          return fail(errMsg(err));
+        if (args.account) {
+          try {
+            const { provider, account } = registry.resolveByEmail(args.account);
+            const items2 = await provider.searchEmails(account, args.query, {
+              limit: args.limit
+            });
+            const data2 = {
+              account: account.email,
+              count: items2.length,
+              items: items2.map((item) => ({ ...item, account: account.email })),
+              errors: []
+            };
+            return ok(data2, data2);
+          } catch (err) {
+            return fail(errMsg(err));
+          }
+        }
+        const accounts = store.listAccounts();
+        if (accounts.length === 0) {
+          return fail("no accounts registered. Call add_account first.");
         }
+        const results = await Promise.all(
+          accounts.map(async (stored) => {
+            try {
+              const { provider, account } = registry.resolveByEmail(stored.email);
+              const items2 = await provider.searchEmails(account, args.query, {
+                limit: args.limit
+              });
+              return {
+                account: account.email,
+                items: items2.map((item) => ({ ...item, account: account.email }))
+              };
+            } catch (err) {
+              return {
+                account: stored.email,
+                error: errMsg(err)
+              };
+            }
+          })
+        );
+        const items = results.flatMap((result) => result.items ?? []);
+        const errors = results.filter(
+          (result) => "error" in result
+        ).map((result) => ({ account: result.account, message: result.error }));
+        const data = {
+          account: "all",
+          accounts: accounts.map((account) => account.email),
+          count: items.length,
+          items,
+          errors
+        };
+        return ok(data, data);
       }
     );
   }
@@ -18999,7 +19064,7 @@ function registerTools(server, opts) {
 // package.json
 var package_default = {
   name: "hypermail-mcp",
-  version: "0.7.17",
+  version: "0.7.18",
   description: "Unified email MCP server \u2014 operate any inbox (Outlook now, IMAP/Gmail later) by passing an email address.",
   type: "module",
   bin: {