@agent-native/core 0.176.1 → 0.176.2-nightly-20260831184159

package/corpus/templates/macros/server/plugins/core-routes.ts

@@ -1,5 +1,6 @@
 import { createCoreRoutesPlugin } from "@agent-native/core/server";
 
 export default createCoreRoutesPlugin({
+  googleOAuthManagedConnection: "not_applicable",
   envKeys: [{ key: "ANTHROPIC_API_KEY", label: "Anthropic API Key" }],
 });

package/corpus/templates/mail/.agents/skills/frontend-design/SKILL.md

@@ -68,6 +68,10 @@ is the target: a surface full of information and nearly empty of narration. So
 "make it minimal" is never satisfied by removing data or by burying it behind
 extra clicks, and never blocked by deleting a sentence.
 
+Keep on-screen text and badging minimal: show the shortest label needed for the
+next action, remove decorative or duplicate status chips, and put context in a
+tooltip or progressive disclosure when it is not needed to decide.
+
 Do not add, unless asked:
 
 - A page title that repeats the nav item or route the user just clicked, or a

package/corpus/templates/mail/.agents/skills/inbox-automations/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: inbox-automations
 description: >-
-  Natural-language inbox automation rules (manage-automations,
+  Natural-language inbox automation rules (manage-email-rules,
   trigger-automations) and provider-native Gmail filters
   (manage-gmail-filters), including how the two differ. Use when the user asks
   to auto-label, auto-archive, auto-star, or otherwise handle incoming mail
@@ -10,9 +10,20 @@ description: >-
 
 # Inbox Automations and Gmail Filters
 
+## AI filter
+
+Use `apply-ai-filter` when the user manually marks mail as unwanted or keeps a
+message that was filtered. It adds or removes the reversible
+`agent-native-filtered` label, archives or restores the conversation, and
+records the feedback for future classification. User comments become editable
+natural-language AI filter instructions; the AI filter uses Luna when
+available, auto-filters only above its configured confidence threshold, and
+keeps lower-confidence matches in the review queue. It never claims the
+custom label is Gmail's provider-controlled Spam system label.
+
 ## Automation rules
 
-`manage-automations` rules match new inbound mail against a natural-language
+`manage-email-rules` rules match new inbound mail against a natural-language
 `condition` using AI, then apply `actions` (`label`, `archive`, `mark_read`,
 `star`, `trash`). Rules run on a per-minute cron automatically;
 `trigger-automations` forces immediate processing (debounced — a

package/corpus/templates/mail/.agents/skills/inbox-reads-and-triage/SKILL.md

@@ -47,7 +47,7 @@ relying on ambient screen text.
 `navigate` accepts `view` (`inbox`, `starred`, `sent`, `drafts`, `scheduled`,
 `archive`, `trash`, `draft-queue`, `settings`), plus `threadId`,
 `settingsSection` (`drafting`, `automations`, `gmail-filters`, `aliases`,
-`tracking`, `slack`, `team`), `queuedDraftId`, or `composeDraftId`.
+  `ai-filter`, `tracking`, `slack`, `team`), `queuedDraftId`, or `composeDraftId`.
 
 ## Related Skills
 

package/corpus/templates/mail/.agents/skills/secrets/SKILL.md

@@ -31,6 +31,53 @@ standard workspace connections and org/workspace vault scopes; never put them
 in `.env` or deployment environment variables, and never add a provider-specific
 action or startup bootstrap just to write a credential for one organization.
 
+## Google OAuth triage
+
+| Observation | Meaning | Next action |
+| --- | --- | --- |
+| `invalid_grant` from a deliberately fake code | Google accepted the client pair and rejected only the code | Do not rotate credentials; check flow state and callback registration |
+| `invalid_client` | Google rejected the client id/secret pair | Verify the exact pair and deployment source before rotating |
+| `redirect_uri_mismatch` | The client, host, callback path, and Google registration disagree | Compare that exact tuple in Google Cloud Console; publish a new deploy if site-scoped or build-time configuration changes |
+
+Do not reason about this from memory. The probe checks both contracts: the
+unqualified `/health/google` endpoint reports the sign-in contract, while
+`/health/google?client=managed` reports deployment-level managed OAuth. It asks
+Google directly whether each live `(client_id, redirect_uri)` pair is
+registered:
+
+```bash
+pnpm check:google-redirect-uris -- --env all
+```
+
+The sign-in health path calls `checkGoogleSignInCredential()`, which prefers
+the active Better Auth pair and otherwise uses `resolveGoogleSignInCredentials()`
+from `packages/core/src/server/google-oauth-credentials.ts`. Managed health
+calls `checkGoogleManagedCredential()`, which resolves
+`["GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET"]` through `resolveSecretPair()` in
+`packages/core/src/server/credential-provider.ts`. App provider handlers use
+`resolveGoogleProviderCredentialCandidatesWithReader()` with `resolveSecret`
+under request context. These are separate flows and can intentionally land on
+different Google clients, so a clean result for one says nothing about the
+other. Read both contracts before changing anything:
+
+```bash
+curl -s https://HOST/_agent-native/health/google | jq '{clientId,mismatchedPairs,credentialSource}'
+curl -s "https://HOST/_agent-native/health/google?client=managed" | jq '{clientId,mismatchedPairs,credentialSource}'
+```
+
+Different `clientId` values across those two, or `mismatchedPairs: true`, is a
+divergence to understand, not damage to undo. Never repair it by rotating a
+secret: writing a fresh value into whichever namespace the failing flow does
+not read verifies clean and changes nothing. Do not collapse the namespaces
+without first confirming which flow uses which client; separate sign-in and
+managed clients on one host can be deliberate. For prebuilt Netlify deploys,
+uploaded Functions read site-scoped secrets at runtime, and the health route
+resolves them per request. The build may receive masked placeholder values.
+After changing a site-scoped env var, publish a new deploy before verifying
+live behavior. Call it a rebuild when the changed value is baked into build
+output or static assets; a runtime-only secret does not need to be baked into
+the bundle.
+
 ## Credential Modeling Preflight
 
 Before registering a provider's fields, inspect the workspace/provider connection

package/corpus/templates/mail/AGENTS.md

@@ -14,7 +14,7 @@ Read the relevant skill before deeper work:
 - `draft-queue` for org and Slack draft review/send workflows.
 - `contacts-and-crm` for resolving recipients and CRM reach.
 - `mail-backends` for real Gmail vs synthetic local fallback.
-- `inbox-automations` for automation rules and Gmail-native filters.
+- `inbox-automations` for automation rules, AI filtering, and Gmail-native filters.
 - `provider-api-scans` for raw provider API calls and staged large scans.
 
 ## Core Rules
@@ -73,7 +73,9 @@ Read the relevant skill before deeper work:
 | `mark-read` / `mark-thread-read` / `star-email` / `archive-email` / `unarchive-email` / `trash-email` / `untrash-email` / `move-email` | Message/thread state; `mark-read` does bulk cleanup. |
 | `send-scheduled-email-now` / `cancel-scheduled-email` | Send or cancel a scheduled send. |
 | `manage-gmail-filters` | Gmail-native filters. |
-| `manage-automations` / `trigger-automations` | Inbox automation rules. |
+| `manage-automations` | Recurring and event-triggered automations shown in Settings. |
+| `manage-email-rules` / `trigger-automations` | Inbox automation rules. |
+| `get-ai-filter` / `apply-ai-filter` | Reversible AI filtering, feedback, and learned instructions. |
 | `respond-calendar-invite` | Accept/decline/tentative an invite. |
 | `get-mail-settings` / `update-mail-settings` / `import-gmail-signature` | Signature and writing style. |
 | `manage-snippets` | Saved reply snippets. |
@@ -88,6 +90,7 @@ Read the relevant skill before deeper work:
 - `navigate` moves the UI via `view`, `threadId`, `settingsSection`,
   `queuedDraftId`, or `composeDraftId`; the accepted values are listed in
   `inbox-reads-and-triage`.
+- `settingsSection: "ai-filter"` opens the AI filter controls and review ledger.
 
 ## Source Changes
 

package/corpus/templates/mail/actions/apply-ai-filter.ts

@@ -0,0 +1,294 @@
+import { defineAction } from "@agent-native/core/action";
+import { writeAppState } from "@agent-native/core/application-state";
+import { getRequestUserEmail } from "@agent-native/core/server";
+import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
+import {
+  AI_FILTER_ACTIONS,
+  AI_FILTER_LABEL,
+  AI_FILTER_RULE_NAME,
+  aiFilterTargetSchema,
+  type AiFilterTarget,
+} from "@shared/ai-filter.js";
+import type { Label } from "@shared/types.js";
+import { z } from "zod";
+
+import {
+  getAiFilterState,
+  recordAiFilterFeedback,
+  saveAiFilterState,
+} from "../server/lib/ai-filter.js";
+import {
+  buildLabelCache,
+  ensureGmailLabel,
+} from "../server/lib/automation-actions.js";
+import {
+  createAutomationRule,
+  listAutomationRules,
+} from "../server/lib/automations.js";
+import {
+  gmailGetMessage,
+  gmailModifyThread,
+} from "../server/lib/google-api.js";
+import { isConnected } from "../server/lib/google-auth.js";
+import {
+  readLocalEmails,
+  withLocalEmailMutationLock,
+  writeLocalEmails,
+} from "../server/lib/local-email-store.js";
+import { getAccessTokens } from "./helpers.js";
+
+const settingsSchema = z.object({
+  enabled: z.boolean().optional(),
+  autoFilter: z.boolean().optional(),
+  autoFilterThreshold: z.number().min(0.5).max(1).optional(),
+  suggestionThreshold: z.number().min(0.5).max(1).optional(),
+});
+
+const headerValue = (message: any, name: string): string => {
+  const headers = message.payload?.headers ?? [];
+  return (
+    headers.find(
+      (header: any) =>
+        typeof header.name === "string" &&
+        header.name.toLowerCase() === name.toLowerCase(),
+    )?.value ?? ""
+  );
+};
+
+async function ensureLocalLabel(ownerEmail: string): Promise<void> {
+  const stored = await getUserSetting(ownerEmail, "labels");
+  const labels =
+    stored && Array.isArray((stored as any).labels)
+      ? ((stored as any).labels as Label[])
+      : [];
+  if (
+    labels.some(
+      (label) =>
+        label.id === AI_FILTER_LABEL ||
+        label.name.toLowerCase() === AI_FILTER_LABEL,
+    )
+  ) {
+    return;
+  }
+  await putUserSetting(ownerEmail, "labels", {
+    labels: [
+      ...labels,
+      { id: AI_FILTER_LABEL, name: AI_FILTER_LABEL, type: "user" },
+    ],
+  });
+}
+
+function localTarget(target: AiFilterTarget, email: any): AiFilterTarget {
+  return {
+    ...target,
+    threadId: target.threadId ?? email.threadId ?? email.id,
+    accountEmail: target.accountEmail ?? email.accountEmail,
+    sender:
+      target.sender ??
+      (email.from?.name
+        ? `${email.from.name} <${email.from.email}>`
+        : (email.from?.email ?? email.from)),
+    subject: target.subject ?? email.subject,
+  };
+}
+
+async function ensureLearnedRule(
+  ownerEmail: string,
+  comment?: string,
+): Promise<void> {
+  const rules = await listAutomationRules(ownerEmail);
+  if (
+    !rules.some(
+      (rule) => rule.kind === "ai-filter" && rule.name === AI_FILTER_RULE_NAME,
+    )
+  ) {
+    await createAutomationRule(ownerEmail, {
+      name: AI_FILTER_RULE_NAME,
+      condition:
+        "Use my confirmed examples and comments to identify unwanted email.",
+      actions: AI_FILTER_ACTIONS,
+      kind: "ai-filter",
+    });
+  }
+
+  const normalizedComment = comment?.trim();
+  if (
+    normalizedComment &&
+    !rules.some(
+      (rule) =>
+        rule.kind === "ai-filter" &&
+        rule.condition.toLowerCase() === normalizedComment.toLowerCase(),
+    )
+  ) {
+    await createAutomationRule(ownerEmail, {
+      name: `Remember: ${normalizedComment.slice(0, 72)}`,
+      condition: normalizedComment,
+      actions: AI_FILTER_ACTIONS,
+      kind: "ai-filter",
+    });
+  }
+}
+
+export default defineAction({
+  description:
+    "Filter or keep email with the reversible Mail AI filter. Filtering adds the agent-native-filtered Gmail label, archives the conversation, and learns from the decision. Keeping a message restores it to Inbox and also teaches the filter.",
+  schema: z.object({
+    mode: z.enum(["filter", "keep", "settings"]),
+    targets: z.array(aiFilterTargetSchema).max(100).optional(),
+    comment: z.string().max(500).optional(),
+    settings: settingsSchema.optional(),
+  }),
+  run: async (args) => {
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) throw new Error("no authenticated user");
+
+    if (args.mode === "settings") {
+      const state = await getAiFilterState(ownerEmail);
+      const next = {
+        ...state,
+        ...args.settings,
+      };
+      await saveAiFilterState(ownerEmail, next);
+      await writeAppState("refresh-signal", { ts: Date.now() });
+      return { changed: 0, failures: [], state: next };
+    }
+
+    const targets = args.targets ?? [];
+    if (targets.length === 0) throw new Error("targets are required");
+
+    const action = args.mode === "filter" ? "filter" : "keep";
+    const succeededTargets: AiFilterTarget[] = [];
+    const failures: Array<{ id: string; error: string }> = [];
+
+    if (!(await isConnected(ownerEmail))) {
+      await ensureLocalLabel(ownerEmail);
+      await withLocalEmailMutationLock(ownerEmail, async () => {
+        const emails = await readLocalEmails(ownerEmail);
+        const requestedIds = new Set(targets.map((target) => target.id));
+        const requestedThreads = new Set(
+          targets.map((target) => target.threadId).filter(Boolean),
+        );
+        const matching = emails.filter(
+          (email) =>
+            requestedIds.has(email.id) ||
+            requestedThreads.has(email.threadId || email.id),
+        );
+        if (matching.length === 0) throw new Error("No matching local emails");
+
+        const changedThreads = new Set(
+          matching.map((email) => email.threadId || email.id),
+        );
+        const updated = emails.map((email) => {
+          const threadId = email.threadId || email.id;
+          if (!changedThreads.has(threadId)) return email;
+          const labelIds = new Set(email.labelIds ?? []);
+          for (const label of [...labelIds]) {
+            if (label.toLowerCase() === AI_FILTER_LABEL) labelIds.delete(label);
+            if (action === "filter" && label.toLowerCase() === "inbox") {
+              labelIds.delete(label);
+            }
+          }
+          if (action === "filter") labelIds.add(AI_FILTER_LABEL);
+          else {
+            labelIds.delete(AI_FILTER_LABEL);
+            labelIds.add("inbox");
+          }
+          return {
+            ...email,
+            isArchived: action === "filter" ? true : false,
+            labelIds: [...labelIds],
+          };
+        });
+        await writeLocalEmails(ownerEmail, updated);
+        for (const target of targets) {
+          const email = matching.find(
+            (candidate) =>
+              candidate.id === target.id ||
+              (candidate.threadId || candidate.id) === target.threadId,
+          );
+          if (email) succeededTargets.push(localTarget(target, email));
+        }
+      });
+    } else {
+      const accounts = await getAccessTokens();
+      if (accounts.length === 0)
+        throw new Error("No Google account connected.");
+      const labelCaches = new Map<string, Map<string, string>>();
+
+      for (const target of targets) {
+        const candidates = target.accountEmail
+          ? accounts.filter(
+              (account) =>
+                account.email.toLowerCase() ===
+                target.accountEmail!.toLowerCase(),
+            )
+          : accounts;
+        const errors: string[] = [];
+        let applied = false;
+        for (const account of candidates) {
+          try {
+            const message = await gmailGetMessage(
+              account.accessToken,
+              target.id,
+              "metadata",
+            );
+            const labelCache =
+              labelCaches.get(account.email) ??
+              (await buildLabelCache(account.accessToken));
+            labelCaches.set(account.email, labelCache);
+            const labelId = await ensureGmailLabel(
+              account.accessToken,
+              AI_FILTER_LABEL,
+              labelCache,
+            );
+            const threadId = target.threadId ?? message.threadId ?? target.id;
+            await gmailModifyThread(
+              account.accessToken,
+              threadId,
+              action === "filter" ? [labelId] : ["INBOX"],
+              action === "filter" ? ["INBOX"] : [labelId],
+            );
+            succeededTargets.push({
+              ...target,
+              threadId,
+              accountEmail: account.email,
+              sender: target.sender ?? headerValue(message, "From"),
+              subject: target.subject ?? headerValue(message, "Subject"),
+            });
+            applied = true;
+            break;
+          } catch (error: any) {
+            errors.push(error?.message ?? "Gmail update failed");
+          }
+        }
+        if (!applied) {
+          failures.push({
+            id: target.id,
+            error: errors.join("; ") || "Account not found",
+          });
+        }
+      }
+    }
+
+    if (succeededTargets.length === 0) {
+      throw new Error(failures.map((failure) => failure.error).join("; "));
+    }
+
+    await recordAiFilterFeedback(ownerEmail, {
+      targets: succeededTargets,
+      disposition: action === "filter" ? "spam" : "not_spam",
+      comment: args.comment,
+    });
+    await ensureLearnedRule(
+      ownerEmail,
+      action === "filter" ? args.comment : undefined,
+    );
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      changed: succeededTargets.length,
+      failures,
+      state: await getAiFilterState(ownerEmail),
+    };
+  },
+});

package/corpus/templates/mail/actions/create-automation.ts

@@ -14,6 +14,7 @@ export default defineAction({
       .array(automationActionSchema)
       .describe("Actions applied when the condition matches"),
     domain: z.enum(["mail", "calendar"]).optional().describe("Rule domain"),
+    kind: z.enum(["automation", "ai-filter"]).optional().describe("Rule kind"),
     enabled: z.boolean().optional().describe("Whether the rule starts enabled"),
   }),
   agentTool: false,

package/corpus/templates/mail/actions/get-ai-filter.ts

@@ -0,0 +1,19 @@
+import { defineAction } from "@agent-native/core/action";
+import { getRequestUserEmail } from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getAiFilterState } from "../server/lib/ai-filter.js";
+
+export default defineAction({
+  description:
+    "Read the Mail AI filter settings, recent decisions, and learned examples.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  agentTool: false,
+  run: async () => {
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) throw new Error("Unauthenticated");
+    return getAiFilterState(ownerEmail);
+  },
+});