@agent-native/core 0.87.0 → 0.90.1

package/corpus/templates/mail/actions/manage-snippets.ts

@@ -0,0 +1,106 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server";
+import { eq, and, asc } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+
+const schema = z.object({
+  operation: z
+    .enum(["list", "create", "update", "delete"])
+    .default("list")
+    .describe("Snippet operation to perform"),
+  id: z.string().optional().describe("Snippet ID (for update/delete)"),
+  name: z
+    .string()
+    .optional()
+    .describe("Short name shown in the compose slash menu"),
+  body: z
+    .string()
+    .optional()
+    .describe("Snippet text inserted into the compose body"),
+});
+
+export default defineAction({
+  description:
+    "List, create, update, or delete reusable email snippets (canned responses) that can be inserted into a compose draft from the slash menu.",
+  schema,
+  run: async (args) => {
+    const { db, schema: dbSchema } = await import("../server/db/index.js");
+
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) throw new Error("no authenticated user");
+
+    switch (args.operation) {
+      case "list": {
+        const rows = await db
+          .select()
+          .from(dbSchema.snippets)
+          .where(eq(dbSchema.snippets.ownerEmail, ownerEmail))
+          .orderBy(asc(dbSchema.snippets.name));
+        return { ok: true as const, snippets: rows };
+      }
+
+      case "create": {
+        if (!args.name?.trim() || !args.body?.trim()) {
+          throw new Error("name and body are required to create a snippet");
+        }
+
+        const now = Date.now();
+        const snippet = {
+          id: nanoid(12),
+          ownerEmail,
+          name: args.name.trim(),
+          body: args.body,
+          createdAt: now,
+          updatedAt: now,
+        };
+
+        await db.insert(dbSchema.snippets).values(snippet);
+        return { ok: true as const, snippet };
+      }
+
+      case "update": {
+        if (!args.id) throw new Error("id is required to update a snippet");
+
+        const updates: Record<string, unknown> = { updatedAt: Date.now() };
+        if (args.name !== undefined) {
+          if (!args.name.trim()) throw new Error("name cannot be empty");
+          updates.name = args.name.trim();
+        }
+        if (args.body !== undefined) updates.body = args.body;
+
+        const [snippet] = await db
+          .update(dbSchema.snippets)
+          .set(updates)
+          .where(
+            and(
+              eq(dbSchema.snippets.id, args.id),
+              eq(dbSchema.snippets.ownerEmail, ownerEmail),
+            ),
+          )
+          .returning();
+
+        if (!snippet) throw new Error("snippet not found");
+        return { ok: true as const, snippet };
+      }
+
+      case "delete": {
+        if (!args.id) throw new Error("id is required to delete a snippet");
+
+        await db
+          .delete(dbSchema.snippets)
+          .where(
+            and(
+              eq(dbSchema.snippets.id, args.id),
+              eq(dbSchema.snippets.ownerEmail, ownerEmail),
+            ),
+          );
+
+        return { ok: true as const, id: args.id };
+      }
+
+      default:
+        throw new Error(`Unknown operation "${args.operation}"`);
+    }
+  },
+});

package/corpus/templates/mail/actions/mark-read.ts

@@ -4,6 +4,10 @@ import { getRequestUserEmail } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { markRead } from "../server/lib/email-state.js";
+import {
+  gmailBatchModifyByAccount,
+  isConnected,
+} from "../server/lib/google-auth.js";
 
 export default defineAction({
   description: "Mark one or more emails as read or unread.",
@@ -17,6 +21,12 @@ export default defineAction({
       .string()
       .optional()
       .describe("Specific connected account to use"),
+    accountEmails: z
+      .string()
+      .optional()
+      .describe(
+        "Per-id account emails, comma-separated and positionally matched to --id (bulk UI calls only)",
+      ),
   }),
   run: async (args) => {
     const ids = args.id
@@ -29,19 +39,43 @@ export default defineAction({
     const ownerEmail = getRequestUserEmail();
     if (!ownerEmail) throw new Error("no authenticated user");
 
+    const accountEmailList = args.accountEmails
+      ?.split(",")
+      .map((s) => s.trim());
+
     const results: { id: string; success: boolean; error?: string }[] = [];
 
-    for (const id of ids) {
-      try {
-        await markRead({
-          id,
-          ownerEmail,
-          isRead,
-          accountEmail: args.accountEmail,
-        });
-        results.push({ id, success: true });
-      } catch (err: any) {
-        results.push({ id, success: false, error: err?.message ?? "failed" });
+    // Mark-read/unread is message-level (no thread cache invalidation needed,
+    // matching markRead's own reconciliation notes), so the batch path here
+    // is simpler than archive/star.
+    if (ids.length > 1 && (await isConnected(ownerEmail))) {
+      const targets = ids.map((id, i) => ({
+        id,
+        accountEmail: accountEmailList?.[i] || args.accountEmail,
+      }));
+      const { succeeded, failed } = await gmailBatchModifyByAccount(
+        ownerEmail,
+        targets,
+        isRead ? undefined : ["UNREAD"],
+        isRead ? ["UNREAD"] : undefined,
+      );
+      for (const id of succeeded) results.push({ id, success: true });
+      for (const f of failed)
+        results.push({ id: f.id, success: false, error: f.error });
+    } else {
+      for (let i = 0; i < ids.length; i++) {
+        const id = ids[i];
+        try {
+          await markRead({
+            id,
+            ownerEmail,
+            isRead,
+            accountEmail: accountEmailList?.[i] || args.accountEmail,
+          });
+          results.push({ id, success: true });
+        } catch (err: any) {
+          results.push({ id, success: false, error: err?.message ?? "failed" });
+        }
       }
     }
 

package/corpus/templates/mail/actions/send-queued-drafts.ts

@@ -2,9 +2,10 @@ import { defineAction } from "@agent-native/core";
 import { z } from "zod";
 
 import {
+  claimQueuedDraftForSending,
   listQueuedDrafts,
   markQueuedDraftSent,
-  requireQueuedDraft,
+  releaseQueuedDraftClaim,
   type QueuedEmailDraft,
 } from "../server/lib/queued-drafts.js";
 import sendEmailAction from "./send-email.js";
@@ -21,28 +22,60 @@ function extractSentMessageId(result: unknown): string | undefined {
   return result.match(/\bid:\s*([^)]+)/)?.[1]?.trim();
 }
 
-async function sendOne(draft: QueuedEmailDraft) {
-  const result = await (sendEmailAction as any).run({
-    to: draft.to,
-    cc: draft.cc || undefined,
-    bcc: draft.bcc || undefined,
-    subject: draft.subject,
-    body: draft.body,
-    account: draft.accountEmail || undefined,
-  });
+type SendOutcome =
+  | {
+      outcome: "sent";
+      id: string;
+      sentMessageId?: string;
+      draft: QueuedEmailDraft;
+    }
+  | { outcome: "skipped"; id: string; reason: string }
+  | { outcome: "failed"; id: string; error: string };
 
-  if (typeof result === "string" && result.startsWith("Error")) {
-    throw new Error(result);
+async function sendOne(id: string): Promise<SendOutcome> {
+  const claim = await claimQueuedDraftForSending(id);
+  if (!claim.claimed) {
+    if (claim.reason === "sent") {
+      return { outcome: "skipped", id, reason: "Already sent." };
+    }
+    if (claim.reason === "sending") {
+      return {
+        outcome: "skipped",
+        id,
+        reason: "Already being sent by another request.",
+      };
+    }
+    return { outcome: "skipped", id, reason: "No longer active." };
   }
 
-  const sentMessageId = extractSentMessageId(result);
-  const updated = await markQueuedDraftSent(draft.id, sentMessageId);
-  return {
-    id: draft.id,
-    status: "sent" as const,
-    sentMessageId,
-    draft: updated,
-  };
+  const { ctx, draft, claimId, priorStatus } = claim;
+  try {
+    const result = await (sendEmailAction as any).run({
+      to: draft.to,
+      cc: draft.cc || undefined,
+      bcc: draft.bcc || undefined,
+      subject: draft.subject,
+      body: draft.body,
+      account: draft.accountEmail || undefined,
+    });
+
+    if (typeof result === "string" && result.startsWith("Error")) {
+      throw new Error(result);
+    }
+
+    const sentMessageId = extractSentMessageId(result);
+    const updated = await markQueuedDraftSent(id, ctx, claimId, sentMessageId);
+    return { outcome: "sent", id, sentMessageId, draft: updated };
+  } catch (err) {
+    // Release the claim so the draft goes back to a sendable state instead
+    // of being stuck as "sending" forever after a failed send attempt.
+    await releaseQueuedDraftClaim(id, ctx, claimId, priorStatus);
+    return {
+      outcome: "failed",
+      id,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
 }
 
 export default defineAction({
@@ -63,25 +96,26 @@ export default defineAction({
       .describe("Maximum drafts to send when all=true"),
   }),
   run: async (args) => {
-    let drafts: QueuedEmailDraft[] = [];
+    let ids: string[] = [];
 
     if (args.all) {
-      drafts = (
-        await listQueuedDrafts({
-          scope: "review",
-          status: "active",
-          limit: args.limit ?? 50,
-        })
-      ).filter(
-        (draft) => draft.status === "queued" || draft.status === "in_review",
-      );
+      const drafts = await listQueuedDrafts({
+        scope: "review",
+        status: "active",
+        limit: args.limit ?? 50,
+      });
+      ids = drafts
+        .filter(
+          (draft: QueuedEmailDraft) =>
+            draft.status === "queued" || draft.status === "in_review",
+        )
+        .map((draft: QueuedEmailDraft) => draft.id);
     } else {
       if (!args.id) throw new Error("Provide id, or set all=true.");
-      const { draft } = await requireQueuedDraft(args.id, { ownerOnly: true });
-      drafts = [draft];
+      ids = [args.id];
     }
 
-    if (drafts.length === 0) {
+    if (ids.length === 0) {
       return {
         sent: [],
         failed: [],
@@ -89,18 +123,19 @@ export default defineAction({
       };
     }
 
-    const sent: Array<Awaited<ReturnType<typeof sendOne>>> = [];
+    const sent: Array<Extract<SendOutcome, { outcome: "sent" }>> = [];
     const failed: Array<{ id: string; error: string }> = [];
 
-    for (const draft of drafts) {
-      try {
-        sent.push(await sendOne(draft));
-      } catch (err) {
-        failed.push({
-          id: draft.id,
-          error: err instanceof Error ? err.message : String(err),
-        });
+    for (const id of ids) {
+      const result = await sendOne(id);
+      if (result.outcome === "sent") {
+        sent.push(result);
+      } else if (result.outcome === "failed") {
+        failed.push({ id: result.id, error: result.error });
       }
+      // "skipped" (already sent / already sending / no longer active)
+      // reports cleanly by simply not appearing in either list — re-running
+      // an already-sent draft is a clean no-op, not an error.
     }
 
     return { sent, failed };

package/corpus/templates/mail/actions/star-email.ts

@@ -4,6 +4,11 @@ import { getRequestUserEmail } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { toggleStar } from "../server/lib/email-state.js";
+import {
+  gmailBatchModifyByAccount,
+  isConnected,
+} from "../server/lib/google-auth.js";
+import { invalidateThreadCache } from "../server/lib/thread-cache.js";
 
 export default defineAction({
   description: "Star or unstar one or more emails.",
@@ -17,6 +22,18 @@ export default defineAction({
       .string()
       .optional()
       .describe("Specific connected account to use"),
+    accountEmails: z
+      .string()
+      .optional()
+      .describe(
+        "Per-id account emails, comma-separated and positionally matched to --id (bulk UI calls only)",
+      ),
+    threadIds: z
+      .string()
+      .optional()
+      .describe(
+        "Per-id thread ID hints, comma-separated and positionally matched to --id (bulk UI calls only)",
+      ),
   }),
   run: async (args) => {
     const ids = args.id
@@ -29,19 +46,47 @@ export default defineAction({
     const ownerEmail = getRequestUserEmail();
     if (!ownerEmail) throw new Error("no authenticated user");
 
+    const threadIdList = args.threadIds?.split(",").map((s) => s.trim());
+    const accountEmailList = args.accountEmails
+      ?.split(",")
+      .map((s) => s.trim());
+
     const results: { id: string; success: boolean; error?: string }[] = [];
 
-    for (const id of ids) {
-      try {
-        await toggleStar({
-          id,
-          ownerEmail,
-          isStarred,
-          accountEmail: args.accountEmail,
-        });
+    if (ids.length > 1 && (await isConnected(ownerEmail))) {
+      const targets = ids.map((id, i) => ({
+        id,
+        threadId: threadIdList?.[i],
+        accountEmail: accountEmailList?.[i] || args.accountEmail,
+      }));
+      const { succeeded, failed } = await gmailBatchModifyByAccount(
+        ownerEmail,
+        targets,
+        isStarred ? ["STARRED"] : undefined,
+        isStarred ? undefined : ["STARRED"],
+      );
+      const threadIdById = new Map(targets.map((t) => [t.id, t.threadId]));
+      for (const id of succeeded) {
+        const tid = threadIdById.get(id);
+        if (tid) invalidateThreadCache(ownerEmail, tid);
         results.push({ id, success: true });
-      } catch (err: any) {
-        results.push({ id, success: false, error: err?.message ?? "failed" });
+      }
+      for (const f of failed)
+        results.push({ id: f.id, success: false, error: f.error });
+    } else {
+      for (let i = 0; i < ids.length; i++) {
+        const id = ids[i];
+        try {
+          await toggleStar({
+            id,
+            ownerEmail,
+            isStarred,
+            accountEmail: accountEmailList?.[i] || args.accountEmail,
+          });
+          results.push({ id, success: true });
+        } catch (err: any) {
+          results.push({ id, success: false, error: err?.message ?? "failed" });
+        }
       }
     }
 

package/corpus/templates/mail/actions/trash-email.ts

@@ -5,6 +5,38 @@ import { z } from "zod";
 
 import { trashEmail } from "../server/lib/email-state.js";
 
+// Gmail has no batch endpoint for trash (unlike label add/remove), so bulk
+// trash uses bounded-concurrency parallel calls instead of one-at-a-time or
+// fully-unbounded fan-out.
+const TRASH_CONCURRENCY = 5;
+
+async function trashWithBoundedConcurrency(
+  ids: string[],
+  run: (id: string, index: number) => Promise<void>,
+): Promise<{ id: string; success: boolean; error?: string }[]> {
+  const results: { id: string; success: boolean; error?: string }[] = new Array(
+    ids.length,
+  );
+  let next = 0;
+  async function worker() {
+    while (true) {
+      const i = next++;
+      if (i >= ids.length) return;
+      const id = ids[i];
+      try {
+        await run(id, i);
+        results[i] = { id, success: true };
+      } catch (err: any) {
+        results[i] = { id, success: false, error: err?.message ?? "failed" };
+      }
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(TRASH_CONCURRENCY, ids.length) }, worker),
+  );
+  return results;
+}
+
 export default defineAction({
   description: "Move one or more emails to trash by ID.",
   schema: z.object({
@@ -13,6 +45,12 @@ export default defineAction({
       .string()
       .optional()
       .describe("Specific connected account to use"),
+    accountEmails: z
+      .string()
+      .optional()
+      .describe(
+        "Per-id account emails, comma-separated and positionally matched to --id (bulk UI calls only)",
+      ),
   }),
   run: async (args) => {
     const ids = args.id
@@ -24,16 +62,17 @@ export default defineAction({
     const ownerEmail = getRequestUserEmail();
     if (!ownerEmail) throw new Error("no authenticated user");
 
-    const results: { id: string; success: boolean; error?: string }[] = [];
+    const accountEmailList = args.accountEmails
+      ?.split(",")
+      .map((s) => s.trim());
 
-    for (const id of ids) {
-      try {
-        await trashEmail({ id, ownerEmail, accountEmail: args.accountEmail });
-        results.push({ id, success: true });
-      } catch (err: any) {
-        results.push({ id, success: false, error: err?.message ?? "failed" });
-      }
-    }
+    const results = await trashWithBoundedConcurrency(ids, (id, i) =>
+      trashEmail({
+        id,
+        ownerEmail,
+        accountEmail: accountEmailList?.[i] || args.accountEmail,
+      }).then(() => undefined),
+    );
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 

package/corpus/templates/mail/app/components/GoogleConnectBanner.tsx

@@ -4,7 +4,6 @@ import {
   oauthRedirectUri,
   useT,
 } from "@agent-native/core/client";
-import { Button } from "@agent-native/toolkit/ui/button";
 import {
   IconMail,
   IconX,
@@ -19,6 +18,7 @@ import {
 } from "@tabler/icons-react";
 import { useState, useEffect, useCallback, useRef, useMemo } from "react";
 
+import { Button } from "@/components/ui/button";
 import {
   useGoogleAuthStatus,
   useGoogleAuthUrl,

package/corpus/templates/mail/app/components/ThemeToggle.tsx

@@ -1,14 +1,14 @@
 import { useT } from "@agent-native/core/client";
-import { Button } from "@agent-native/toolkit/ui/button";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from "@agent-native/toolkit/ui/tooltip";
 import { IconSun, IconMoon } from "@tabler/icons-react";
 import { useTheme } from "next-themes";
 import { useState, useEffect } from "react";
 
+import { Button } from "@/components/ui/button";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 import { getResolvedTheme } from "@/lib/theme";
 import { cn } from "@/lib/utils";
 

package/corpus/templates/mail/app/components/agent-engine-picker.tsx

@@ -1,14 +1,4 @@
 import { agentNativePath, useT } from "@agent-native/core/client";
-import { Badge } from "@agent-native/toolkit/ui/badge";
-import { Button } from "@agent-native/toolkit/ui/button";
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from "@agent-native/toolkit/ui/select";
-import { Skeleton } from "@agent-native/toolkit/ui/skeleton";
 import {
   IconCheck,
   IconLoader2,
@@ -20,6 +10,16 @@ import {
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { useState } from "react";
 
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Skeleton } from "@/components/ui/skeleton";
 import { cn } from "@/lib/utils";
 
 // ─── Types ────────────────────────────────────────────────────────────────────

package/corpus/templates/mail/app/components/email/CodeBlockLangPicker.tsx

@@ -1,13 +1,14 @@
 import { useT } from "@agent-native/core/client";
+import type { Editor } from "@tiptap/react";
+import { useEffect, useState, useRef } from "react";
+
 import {
   Select,
   SelectContent,
   SelectItem,
   SelectTrigger,
   SelectValue,
-} from "@agent-native/toolkit/ui/select";
-import type { Editor } from "@tiptap/react";
-import { useEffect, useState, useRef } from "react";
+} from "@/components/ui/select";
 
 const LANGUAGES = [
   { value: "", label: "" },

package/corpus/templates/mail/app/components/email/ComposeBubbleToolbar.tsx

@@ -1,9 +1,4 @@
 import { useT } from "@agent-native/core/client";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from "@agent-native/toolkit/ui/tooltip";
 import {
   IconBold,
   IconItalic,
@@ -17,6 +12,11 @@ import type { Editor } from "@tiptap/react";
 import { useState, useEffect, useRef, useCallback } from "react";
 import { createPortal } from "react-dom";
 
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 import { cn, formatShortcut } from "@/lib/utils";
 
 import { getSelectedMarkdown } from "./compose-draft-context";