@agent-native/core 0.176.1 → 0.177.0-nightly-20260828143953

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8675
+- template files: 8677

package/corpus/templates/analytics/actions/set-workspace-feature-flag.ts

@@ -30,7 +30,7 @@ const schema = z.discriminatedUnion("operation", [
 ]);
 export default defineAction({
   description:
-    "Persist one feature-flag change on a trusted organization app. The app target is resolved only through the organization directory.",
+    "Persist one feature-flag change on Analytics or a trusted organization app. Analytics uses its local flag action; peer targets are resolved through the organization directory.",
   schema,
   agentInputSchema: z.object({
     appId: z.string(),
@@ -40,6 +40,6 @@ export default defineAction({
   }),
   run: async (args, ctx) => {
     const admin = await requireAnalyticsAdminContext(ctx);
-    return setWorkspaceFeatureFlag(admin, args);
+    return setWorkspaceFeatureFlag(admin, args, ctx);
   },
 });

package/corpus/templates/analytics/app/components/agents/FeatureFlagsFleetPanel.tsx

@@ -89,6 +89,10 @@ function asDirectory(value: unknown): FlagDirectory {
   return value && typeof value === "object" ? (value as FlagDirectory) : {};
 }
 
+export function hasFleetApps(value: unknown): boolean {
+  return (asDirectory(value).apps?.length ?? 0) > 0;
+}
+
 function isReady(app: FlagApp) {
   return app.state === "ready" || app.status === "ready";
 }
@@ -188,7 +192,10 @@ export function FeatureFlagsFleetPanel() {
   const directory = asDirectory(flags.data);
   const apps = directory.apps ?? [];
   if (flags.isLoading) return <PanelLoading />;
-  if (flags.error || directory.directoryStatus === "unavailable")
+  if (
+    flags.error ||
+    (directory.directoryStatus === "unavailable" && !hasFleetApps(directory))
+  )
     return (
       <StatusState
         title={t("agents.flagsUnavailable")}
@@ -226,6 +233,14 @@ export function FeatureFlagsFleetPanel() {
           {t("agents.reloadFlags")}
         </Button>
       </div>
+      {directory.directoryStatus === "unavailable" ? (
+        <p
+          className="rounded-lg border px-4 py-3 text-sm text-muted-foreground"
+          role="status"
+        >
+          {t("agents.flagsUnreachable")}
+        </p>
+      ) : null}
       {apps.map((app) => (
         <section key={appId(app)} className="overflow-hidden rounded-lg border">
           <div className="flex items-center justify-between gap-3 border-b bg-muted/30 px-4 py-3">

package/corpus/templates/analytics/changelog/2026-08-27-show-analytics-s-own-registered-flags-in-fleet-feature-flag-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-27
+---
+
+Show Analytics's own registered flags in fleet feature flag management.

package/corpus/templates/analytics/server/lib/workspace-feature-flags.ts

@@ -4,14 +4,18 @@ import { signA2AToken } from "@agent-native/core/a2a";
 import {
   ActionContractError,
   AgentActionStopError,
+  type ActionRunContext,
 } from "@agent-native/core/action";
 import { isFeatureFlagEnabled } from "@agent-native/core/feature-flags";
+import listLocalFeatureFlagsAction from "@agent-native/core/feature-flags/actions/list-feature-flags";
+import setLocalFeatureFlagAction from "@agent-native/core/feature-flags/actions/set-feature-flag";
 import {
   fetchOrgApps,
   fetchOrgAppsResult,
   type OrgApp,
 } from "@agent-native/core/mcp";
 import { getOrgDomain } from "@agent-native/core/org";
+import { getAppConfig } from "@agent-native/core/server";
 
 import {
   RESILIENT_FLEET_FLAG_DIRECTORY,
@@ -23,6 +27,7 @@ const TARGET_TIMEOUT_MS = 3_000;
 const DIRECTORY_ATTEMPTS = 2;
 const VERIFICATION_ATTEMPTS = 2;
 const CONCURRENCY = 4;
+const ANALYTICS_APP_ID = "analytics";
 
 export type FleetFlagState =
   | "ready"
@@ -91,6 +96,37 @@ export function workspaceFeatureFlagTargetInput(
     : rawTargetInput;
 }
 
+function mutationValidationExpectation(
+  admin: AnalyticsAdminContext,
+  input: WorkspaceFeatureFlagMutationInput,
+  orgDomain: string,
+) {
+  return {
+    key: input.key,
+    orgDomain,
+    allowExplicitNoOrgTarget: true,
+    ...(input.operation === "replace-rules" && input.rules
+      ? {
+          rules: {
+            mode: input.rules.mode,
+            emails: input.rules.emails ?? [],
+            orgIds: input.rules.orgIds ?? [],
+            percentage: input.rules.percentage ?? 0,
+          },
+        }
+      : input.operation === "off"
+        ? {
+            rules: {
+              mode: "off",
+              emails: [],
+              orgIds: [],
+              percentage: 0,
+            },
+          }
+        : { enabledForEmail: admin.userEmail }),
+  };
+}
+
 export function validateWorkspaceFeatureFlagMutation(
   body: unknown,
   expected: {
@@ -179,6 +215,54 @@ function targetOrigin(app: OrgApp): string {
   return new URL(app.url).origin;
 }
 
+function localAnalyticsApp(): OrgApp {
+  const configuredUrl = getAppConfig().app.url;
+  const url = configuredUrl ?? "http://analytics.local";
+  return {
+    id: ANALYTICS_APP_ID,
+    name: "Analytics",
+    url,
+    a2aUrl: url,
+  };
+}
+
+function localActionContext(
+  admin: AnalyticsAdminContext,
+  actionName: "list-feature-flags" | "set-feature-flag",
+  sourceContext?: ActionRunContext,
+) {
+  return {
+    ...sourceContext,
+    caller: sourceContext?.caller ?? ("http" as const),
+    userEmail: admin.userEmail,
+    orgId: admin.orgId,
+    appId: ANALYTICS_APP_ID,
+    actionName,
+  };
+}
+
+async function listLocalAnalyticsFeatureFlags(admin: AnalyticsAdminContext) {
+  return classifyWorkspaceFeatureFlagList(localAnalyticsApp(), {
+    status: 200,
+    body: await listLocalFeatureFlagsAction.run(
+      {},
+      localActionContext(admin, "list-feature-flags"),
+    ),
+  });
+}
+
+function unreachableLocalAnalyticsEntry(): FleetFlagApp {
+  const app = localAnalyticsApp();
+  return {
+    appId: app.id,
+    appName: app.name,
+    appOrigin: targetOrigin(app),
+    state: "unreachable",
+    flags: [],
+    reason: "target-execution",
+  };
+}
+
 async function delegatedToken(
   admin: AnalyticsAdminContext,
   origin: string,
@@ -298,6 +382,18 @@ function targetFailure(error: unknown): WorkspaceFeatureFlagFailure {
   return new WorkspaceFeatureFlagFailure(reason);
 }
 
+function localMutationFailure(error: unknown): WorkspaceFeatureFlagFailure {
+  const statusCode =
+    error && typeof error === "object" && "statusCode" in error
+      ? (error as { statusCode?: unknown }).statusCode
+      : undefined;
+  return new WorkspaceFeatureFlagFailure(
+    statusCode === 401 || statusCode === 403
+      ? "authorization"
+      : "target-action",
+  );
+}
+
 async function resolveTargetApp(
   admin: AnalyticsAdminContext,
   appId: string,
@@ -471,13 +567,20 @@ async function mapBounded<T, R>(
 export async function listWorkspaceFeatureFlags(
   admin: AnalyticsAdminContext,
 ): Promise<WorkspaceFeatureFlagsResult> {
-  const apps = await fetchOrgApps({
-    selfId: "analytics",
-    includeDirectoryApp: true,
-    serviceOrgId: admin.orgId,
-  });
-  if (apps.length === 0) return { directoryStatus: "unavailable", apps: [] };
-  const entries = await mapBounded(apps, async (app) => {
+  const [localEntry, directoryResult] = await Promise.all([
+    listLocalAnalyticsFeatureFlags(admin).catch(() =>
+      unreachableLocalAnalyticsEntry(),
+    ),
+    fetchOrgAppsResult({
+      selfId: ANALYTICS_APP_ID,
+      includeDirectoryApp: true,
+      serviceOrgId: admin.orgId,
+    }),
+  ]);
+  if (directoryResult.status === "unavailable")
+    return { directoryStatus: "unavailable", apps: [localEntry] };
+  const directoryApps = directoryResult.apps;
+  const entries = await mapBounded(directoryApps, async (app) => {
     try {
       return classifyWorkspaceFeatureFlagList(
         app,
@@ -494,13 +597,101 @@ export async function listWorkspaceFeatureFlags(
       };
     }
   });
-  return { directoryStatus: "available", apps: entries };
+  return { directoryStatus: "available", apps: [localEntry, ...entries] };
 }
 
 export async function setWorkspaceFeatureFlag(
   admin: AnalyticsAdminContext,
   input: WorkspaceFeatureFlagMutationInput,
+  sourceContext?: ActionRunContext,
 ): Promise<WorkspaceFeatureFlagMutationResult> {
+  if (input.appId === ANALYTICS_APP_ID) {
+    if (input.operation === "replace-rules" && !input.rules)
+      throw new WorkspaceFeatureFlagFailure("target-action");
+    const localRules = input.rules as
+      | {
+          mode: "off" | "on" | "rules";
+          emails?: string[];
+          orgIds?: string[];
+          percentage?: number;
+        }
+      | undefined;
+    const targetInput =
+      input.operation === "replace-rules"
+        ? {
+            operation: input.operation,
+            key: input.key,
+            rules: localRules!,
+          }
+        : { operation: input.operation, key: input.key };
+    let result;
+    try {
+      result = await setLocalFeatureFlagAction.run(
+        targetInput,
+        localActionContext(admin, "set-feature-flag", sourceContext),
+      );
+    } catch (error) {
+      throw localMutationFailure(error);
+    }
+    const orgDomain = result.scope.orgDomain ?? "";
+    let mutation: TargetFeatureFlagMutationResult;
+    try {
+      mutation = validateWorkspaceFeatureFlagMutation(
+        result,
+        mutationValidationExpectation(admin, input, orgDomain),
+      );
+    } catch {
+      throw new WorkspaceFeatureFlagFailure("persistence");
+    }
+    let verifiedApp: FleetFlagApp;
+    try {
+      verifiedApp = await listLocalAnalyticsFeatureFlags(admin);
+    } catch {
+      throw new WorkspaceFeatureFlagFailure("verification");
+    }
+    if (verifiedApp.state === "forbidden")
+      throw new WorkspaceFeatureFlagFailure("authorization");
+    const verifiedFlag = verifiedApp.flags.find(
+      (flag) => flag.key === input.key,
+    );
+    if (
+      verifiedApp.state !== "ready" ||
+      !verifiedFlag ||
+      typeof verifiedFlag.enabledForCurrentUser !== "boolean" ||
+      (input.operation === "enable-for-current-user" &&
+        !verifiedFlag.enabledForCurrentUser) ||
+      (input.operation === "off" && verifiedFlag.enabledForCurrentUser)
+    ) {
+      throw new WorkspaceFeatureFlagFailure("verification");
+    }
+    try {
+      validateWorkspaceFeatureFlagMutation(
+        {
+          contractVersion: 2,
+          status: "ready",
+          key: input.key,
+          rules: verifiedFlag.rules,
+          scope: mutation.scope,
+        },
+        {
+          key: input.key,
+          orgDomain,
+          allowExplicitNoOrgTarget: true,
+          rules: mutation.rules,
+        },
+      );
+    } catch {
+      throw new WorkspaceFeatureFlagFailure("verification");
+    }
+    return {
+      contractVersion: 3,
+      status: "verified",
+      key: mutation.key,
+      rules: verifiedFlag.rules as Record<string, unknown>,
+      scope: mutation.scope,
+      enabledForCurrentUser: verifiedFlag.enabledForCurrentUser,
+    };
+  }
   const app = await resolveTargetApp(admin, input.appId);
   const targetInput = workspaceFeatureFlagTargetInput(input);
   let orgDomain: string | undefined;
@@ -533,30 +724,10 @@ export async function setWorkspaceFeatureFlag(
     throw new WorkspaceFeatureFlagFailure("target-action");
   let mutation: TargetFeatureFlagMutationResult;
   try {
-    mutation = validateWorkspaceFeatureFlagMutation(result.body, {
-      key: input.key,
-      orgDomain,
-      allowExplicitNoOrgTarget: true,
-      ...(input.operation === "replace-rules" && input.rules
-        ? {
-            rules: {
-              mode: input.rules.mode,
-              emails: input.rules.emails ?? [],
-              orgIds: input.rules.orgIds ?? [],
-              percentage: input.rules.percentage ?? 0,
-            },
-          }
-        : input.operation === "off"
-          ? {
-              rules: {
-                mode: "off",
-                emails: [],
-                orgIds: [],
-                percentage: 0,
-              },
-            }
-          : { enabledForEmail: admin.userEmail }),
-    });
+    mutation = validateWorkspaceFeatureFlagMutation(
+      result.body,
+      mutationValidationExpectation(admin, input, orgDomain),
+    );
   } catch {
     throw new WorkspaceFeatureFlagFailure("persistence");
   }
@@ -632,6 +803,7 @@ export async function getWorkspaceFlagTarget(
   admin: AnalyticsAdminContext,
   appId: string,
 ): Promise<FleetFlagApp> {
+  if (appId === ANALYTICS_APP_ID) return listLocalAnalyticsFeatureFlags(admin);
   const apps = await fetchOrgApps({
     selfId: "analytics",
     includeDirectoryApp: true,

package/corpus/templates/calendar/app/components/calendar/EventDetailPopover.tsx

@@ -1524,7 +1524,7 @@ export function EventDetailPopover({
         side={isMobile ? "bottom" : (popoverSide ?? "right")}
         sideOffset={isMobile ? 6 : 8}
         collisionPadding={12}
-        className="flex max-h-[var(--radix-popover-content-available-height)] w-[min(18rem,calc(100vw-2rem))] flex-col overflow-hidden p-0"
+        className="flex max-h-[var(--radix-popover-content-available-height)] w-[min(420px,calc(100vw-2rem))] flex-col overflow-hidden p-0"
         onClick={(e) => e.stopPropagation()}
         onOpenAutoFocus={(e) => {
           e.preventDefault();
@@ -1553,8 +1553,8 @@ export function EventDetailPopover({
       >
         <TooltipProvider>
           {/* Header */}
-          <div className="flex items-center justify-between border-b border-border/60 px-4 py-3">
-            <div className="text-base font-medium text-foreground">
+          <div className="flex items-center justify-between border-b border-border px-4 py-2.5">
+            <div className="text-[11px] font-medium uppercase tracking-wider text-muted-foreground">
               <span>
                 {isWorkingLocation
                   ? t("eventForm.workingLocation")

package/corpus/templates/slides/app/lib/sanitize-slide-html.ts

@@ -311,6 +311,92 @@ function cleanNode(
   return out;
 }
 
+/**
+ * Elements whose unclosed start tag swallows the rest of the document in a real
+ * parser. `embed` is deliberately absent: it is void, so it never has a closing
+ * tag and requiring one would truncate every slide that contains a valid one.
+ */
+const SWALLOWING_ELEMENTS = /^(script|style|textarea|iframe|object|svg|math)$/i;
+
+/** Elements whose children the HTML parser reads as text rather than markup. */
+const RAW_TEXT_ELEMENTS = /^(script|style|textarea|title)$/i;
+
+/**
+ * Start-tag positions in `html`, skipping comments and anything inside a quoted
+ * attribute value.
+ *
+ * Scanning the serialized string with a bare regex cannot tell a tag from text:
+ * `<p title="Use <style> here">` reads as a `<style>` start tag, and truncating
+ * there drops the rest of a perfectly valid slide.
+ */
+function startTagPositions(html: string): { name: string; index: number }[] {
+  const found: { name: string; index: number }[] = [];
+  for (let i = 0; i < html.length; i++) {
+    if (html[i] !== "<") continue;
+    if (html.startsWith("<!--", i)) {
+      const end = html.indexOf("-->", i + 4);
+      i = end === -1 ? html.length : end + 2;
+      continue;
+    }
+    const name = /^<([a-z][a-z0-9-]*)/i.exec(html.slice(i, i + 32))?.[1];
+    // Walk to this tag's `>`, stepping over quoted values so a `<` or `>`
+    // inside one is not read as markup.
+    let cursor = i + 1;
+    let quote = "";
+    while (cursor < html.length) {
+      const char = html[cursor];
+      if (quote) {
+        if (char === quote) quote = "";
+      } else if (char === '"' || char === "'") {
+        quote = char;
+      } else if (char === ">") {
+        break;
+      }
+      cursor++;
+    }
+    if (!name) {
+      i = cursor;
+      continue;
+    }
+    const lower = name.toLowerCase();
+    found.push({ name: lower, index: i });
+    if (RAW_TEXT_ELEMENTS.test(lower)) {
+      // A raw-text element's body is text, not markup — `content: "<script>"`
+      // inside a stylesheet is a CSS string, and reading it as a start tag
+      // truncated everything after it. Skip to the close tag; no close tag is
+      // the unclosed case the caller is looking for, and everything past it is
+      // swallowed anyway, so there is nothing further to find.
+      const closing = new RegExp(`</\\s*${lower}\\s*>`, "i").exec(
+        html.slice(cursor),
+      );
+      if (!closing) return found;
+      i = cursor + closing.index + closing[0].length - 1;
+      continue;
+    }
+    i = cursor;
+  }
+  return found;
+}
+
+/**
+ * Truncates at the first swallowing element that never closes.
+ *
+ * The regex path has to drop the remainder to agree with `cleanNode`. It must
+ * check for the closing tag to do that: the sweep used to match any of these
+ * tags and cut to the end of the string unconditionally, which ate the
+ * sanitized `<style>` block the pass above it had just emitted — and every
+ * heading and paragraph after it. A deck with one stylesheet rendered as an
+ * empty slide on the SSR'd share and present pages.
+ */
+function dropFromFirstUnclosedRawText(html: string): string {
+  for (const { name, index } of startTagPositions(html)) {
+    if (!SWALLOWING_ELEMENTS.test(name)) continue;
+    const closing = new RegExp(`</\\s*${name}\\s*>`, "i");
+    if (!closing.test(html.slice(index))) return html.slice(0, index);
+  }
+  return html;
+}
+
 function sanitizeHtmlString(
   html: string,
   scopeSelector?: string,
@@ -335,10 +421,7 @@ function sanitizeHtmlString(
       // twin runs instead of cleanNode(). An unclosed raw-text or embedding
       // element swallows the rest of the document in a real parser, so dropping
       // the remainder is what keeps this path agreeing with the DOM path.
-      .replace(
-        /<(script|style|textarea|iframe|object|embed|svg|math)\b[\s\S]*$/i,
-        "",
-      )
+      .replace(/[\s\S]*/, dropFromFirstUnclosedRawText)
       .replace(
         /<(script|iframe|object|embed|form|input|button|select|textarea|meta|base|link|svg|math)\b[^>]*\/?>/gi,
         "",

package/corpus/templates/slides/changelog/2026-08-28-shared-slides-with-a-style-block-render-again.md

@@ -0,0 +1,5 @@
+---
+type: fixed
+date: 2026-08-28
+---
+A slide containing a `<style>` block no longer renders empty on shared and presented links — the block and everything after it now survive.

package/dist/action.d.ts

@@ -19,8 +19,10 @@ import type { ActionAuditConfig } from "./audit/types.js";
  *   selected actions are attributed as `"tool"`.
  * - `"automation"` — an event-triggered automation dispatched from a stored
  *   workspace trigger with trusted trigger lineage.
+ * - `"webmcp"` — a browser agent invoking an automatically projected action
+ *   through the authenticated page-local WebMCP bridge.
  */
-export type ActionCaller = "tool" | "http" | "frontend" | "cli" | "mcp" | "a2a" | "automation";
+export type ActionCaller = "tool" | "http" | "frontend" | "cli" | "mcp" | "webmcp" | "a2a" | "automation";
 /**
  * Trusted automation lineage added by the trigger dispatcher. Action inputs
  * must never be used to create or override this context.

package/dist/client/app-providers.js

@@ -66,6 +66,7 @@ import { AgentNativeRouteWarmup } from "./route-warmup.js";
 import { RouteTransitionIndicator } from "./RouteTransitionIndicator.js";
 import { RuntimeConfigNotice } from "./RuntimeConfigNotice.js";
 import { EMBEDDED_THEME_CHANGE_EVENT, applyEmbeddedThemeUpdate, parseEmbeddedThemeUpdate, } from "./theme.js";
+import { createAgentNativeServerActionWebMcpRegistration } from "./webmcp.js";
 const DEFAULT_TOASTER = (_jsx(Toaster, { richColors: true, position: "bottom-left", offset: { bottom: 44, left: 32 }, mobileOffset: { bottom: 44, left: 16 } }));
 function RoutedAppEnhancements() {
     const isInRouter = useInRouterContext();
@@ -73,6 +74,17 @@ function RoutedAppEnhancements() {
         return null;
     return (_jsxs(_Fragment, { children: [_jsx(AgentNativeRouteWarmup, {}), _jsx(RouteTransitionIndicator, {})] }));
 }
+function AutomaticWebMcpActionRegistration() {
+    useEffect(() => {
+        const registration = createAgentNativeServerActionWebMcpRegistration();
+        void registration.start().catch(() => {
+            // WebMCP is progressive enhancement. Session expiry or a transient
+            // manifest failure must not prevent the authenticated app from loading.
+        });
+        return () => registration.stop();
+    }, []);
+    return null;
+}
 function readDocumentTitleFallback() {
     const selectors = [
         'meta[name="application-name"]',
@@ -153,5 +165,5 @@ export function AppProviders({ queryClient, isPublicPath = false, clientOnlyFall
     if (isPublicPath) {
         return (_jsx(ProvidersInner, { queryClient: queryClient, defaultTheme: defaultTheme, themeAttribute: themeAttribute, tooltipDelayDuration: tooltipDelayDuration, toaster: toaster, disableThemeTransitions: disableThemeTransitions, i18n: i18n, documentTitleFallback: documentTitleFallback, showProductionEnvironmentBadge: false, children: children }));
     }
-    return (_jsx(ClientOnly, { fallback: fallback, children: _jsx(ProvidersInner, { queryClient: queryClient, defaultTheme: defaultTheme, themeAttribute: themeAttribute, tooltipDelayDuration: tooltipDelayDuration, toaster: toaster, disableThemeTransitions: disableThemeTransitions, i18n: i18n, documentTitleFallback: documentTitleFallback, showProductionEnvironmentBadge: !sessionBypass, children: _jsx(RequireSession, { bypass: sessionBypass, fallback: fallback, children: sessionBypass ? (children) : (_jsx(FirstRunOnboardingStartupGate, { children: children })) }) }) }));
+    return (_jsx(ClientOnly, { fallback: fallback, children: _jsx(ProvidersInner, { queryClient: queryClient, defaultTheme: defaultTheme, themeAttribute: themeAttribute, tooltipDelayDuration: tooltipDelayDuration, toaster: toaster, disableThemeTransitions: disableThemeTransitions, i18n: i18n, documentTitleFallback: documentTitleFallback, showProductionEnvironmentBadge: !sessionBypass, children: _jsx(RequireSession, { bypass: sessionBypass, fallback: fallback, children: sessionBypass ? (children) : (_jsxs(FirstRunOnboardingStartupGate, { children: [_jsx(AutomaticWebMcpActionRegistration, {}), children] })) }) }) }));
 }

package/dist/client/host-bridge.d.ts

@@ -52,6 +52,7 @@ export interface AgentNativeHostSession {
 }
 export interface AgentNativeClientActionRuntime {
     requestId?: string;
+    signal?: AbortSignal;
     origin: string;
     context: AgentNativeHostContext;
     session: AgentNativeHostSession;

package/dist/client/webmcp.d.ts

@@ -71,4 +71,8 @@ export interface AgentNativeWebMcpRegistration {
     start(): Promise<void>;
     stop(): void;
 }
+export declare function createAgentNativeServerActionWebMcpRegistration(options?: {
+    document?: Document;
+    fetch?: typeof fetch;
+}): AgentNativeWebMcpRegistration;
 export declare function createAgentNativeWebMcpRegistration(options: AgentNativeWebMcpRegistrationOptions): AgentNativeWebMcpRegistration;

package/dist/client/webmcp.js

@@ -234,6 +234,52 @@ export function createAgentNativeWebMcpClient(options = {}) {
     };
     return client;
 }
+export function createAgentNativeServerActionWebMcpRegistration(options) {
+    const fetchImpl = options?.fetch ?? ((...args) => fetch(...args));
+    return createAgentNativeWebMcpRegistration({
+        document: options?.document,
+        maxToolCount: 1_000,
+        maxDescriptionChars: 10_000,
+        actions: async () => {
+            const response = await fetchImpl("/_agent-native/webmcp/manifest", {
+                credentials: "same-origin",
+                headers: { Accept: "application/json" },
+            });
+            if (!response.ok) {
+                throw new Error(`Unable to load WebMCP actions (${response.status})`);
+            }
+            const manifest = (await response.json());
+            if (!Array.isArray(manifest)) {
+                throw new Error("WebMCP action manifest must be an array");
+            }
+            return manifest.map((action) => ({
+                name: action.name,
+                description: action.description,
+                ...(action.inputSchema ? { schema: action.inputSchema } : {}),
+                ...(action.readOnly ? { readOnly: true } : {}),
+                run: async (args, runtime) => {
+                    const result = await fetchImpl(`/_agent-native/webmcp/actions/${encodeURIComponent(action.name)}`, {
+                        method: "POST",
+                        credentials: "same-origin",
+                        headers: {
+                            Accept: "application/json",
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify(args),
+                        ...(runtime.signal ? { signal: runtime.signal } : {}),
+                    });
+                    const body = await result.json();
+                    if (!result.ok) {
+                        throw new Error(isRecord(body) && typeof body.error === "string"
+                            ? body.error
+                            : `WebMCP action failed (${result.status})`);
+                    }
+                    return body;
+                },
+            }));
+        },
+    });
+}
 function resolveActions(actions) {
     return Promise.resolve(typeof actions === "function" ? actions() : actions).then((value) => {
         if (!Array.isArray(value)) {
@@ -271,7 +317,7 @@ function actionManifest(action) {
 function actionInputSchema(action) {
     return action.schema ?? action.parameters ?? EMPTY_INPUT_SCHEMA;
 }
-function actionRuntime(options, context, session) {
+function actionRuntime(options, context, session, signal) {
     const origin = options.origin ?? "agent-native-webmcp";
     const runCommand = async (command, payload) => {
         const handler = options.commands?.[command] ??
@@ -281,6 +327,7 @@ function actionRuntime(options, context, session) {
         return handler({ command, payload, origin }, undefined);
     };
     return {
+        ...(signal ? { signal } : {}),
         origin,
         context,
         session,
@@ -381,7 +428,7 @@ export function createAgentNativeWebMcpRegistration(options) {
                             : {}),
                     },
                     execute: async (input, executionOptions) => {
-                        if (executionOptions.signal.aborted) {
+                        if (executionOptions?.signal.aborted) {
                             throw new Error(`WebMCP action "${action.name}" was aborted`);
                         }
                         validateBoundedJson(input, `WebMCP action "${action.name}" input`, options.maxInputChars ?? DEFAULT_INPUT_CHARS);
@@ -417,8 +464,8 @@ export function createAgentNativeWebMcpRegistration(options) {
                                 throw new Error(`WebMCP action "${action.name}" was not approved`);
                             }
                         }
-                        const result = await action.run(input, actionRuntime(options, context, session));
-                        if (executionOptions.signal.aborted) {
+                        const result = await action.run(input, actionRuntime(options, context, session, executionOptions?.signal));
+                        if (executionOptions?.signal.aborted) {
                             throw new Error(`WebMCP action "${action.name}" was aborted`);
                         }
                         return serializeWebMcpResult(result, `WebMCP action "${action.name}" result`, options.maxResultChars ?? DEFAULT_RESULT_CHARS);

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/index.browser.d.ts

@@ -2,7 +2,7 @@ export * from "./config.js";
 export { addContextToAgentChat, appendAgentChatContextToMessage, clearAgentChatContext, formatAgentChatContextItemsForPrompt, listAgentChatContext, refreshAgentChatContext, removeAgentChatContextItem, sendToAgentChat, sendToAgentChatAndConfirm, setAgentChatContextItem, setContextToAgentChat, isEmbedMcpChatBridgeActive, useAgentChatContext, useAgentChatGenerating, useDevMode, useSendToAgentChat, AGENT_NATIVE_MCP_APP_HOST_MESSAGE_TYPES, getMcpAppHostContext, openMcpAppHostLink, requestMcpAppDisplayMode, sendMcpAppHostMessage, updateMcpAppModelContext, useMcpAppHostContext, CodeRequiredDialog, AgentNativeI18nProvider, LanguagePicker, getLocaleInitScript, localeDirection, normalizeLocaleCode, normalizeLocalePreference, normalizeLocalizationPreference, resolveLocaleFromCandidates, resolveLocaleFromPreference, useFormatters, useLocale, useT, DEFAULT_LOCALE, LOCALE_HYDRATION_GLOBAL, LOCALE_METADATA, LOCALE_STORAGE_KEY, SUPPORTED_LOCALES, useDbSync, useFileWatcher, useSession, cn, ApiKeySettings, type AgentChatContextItem, type AgentChatContextMessage, type AgentChatContextMutationOptions, type AgentChatContextRemoveOptions, type AgentChatContextSetOptions, type AgentChatContextState, type AgentChatMessage, type AgentNativeMcpAppHostMessageType, type McpAppDisplayMode, type McpAppHostChatMessage, type McpAppHostCapabilities, type McpAppHostContext, type McpAppHostContextSnapshot, type McpAppModelContextContentPart, type McpAppModelContextUpdate, type CodeRequiredDialogProps, type AuthSession, type UseAgentChatContextResult, type AgentNativeI18nCatalog, type AgentNativeI18nProviderProps, type LocaleCode, type LocaleHydrationPayload, type LocaleMessages, type LocaleMetadata, type LocalePreference, type LocalizationPreference, } from "./client/index.js";
 export { agentChat } from "./shared/index.js";
 export { parseArgs, camelCaseArgs } from "./scripts/parse-args.js";
-export { AgentNativeWebMcpUnsupportedError, createAgentNativeWebMcpClient, createAgentNativeWebMcpRegistration, isAgentNativeWebMcpSupported, type AgentNativeWebMcpApprovalRequest, type AgentNativeWebMcpClient, type AgentNativeWebMcpClientOptions, type AgentNativeWebMcpRegistration, type AgentNativeWebMcpRegistrationOptions, type AgentNativeWebMcpTool, type AgentNativeWebMcpToolAnnotations, type AgentNativeWebMcpToolExecutionOptions, type AgentNativeWebMcpToolResult, } from "./client/webmcp.js";
+export { AgentNativeWebMcpUnsupportedError, createAgentNativeWebMcpClient, createAgentNativeWebMcpRegistration, createAgentNativeServerActionWebMcpRegistration, isAgentNativeWebMcpSupported, type AgentNativeWebMcpApprovalRequest, type AgentNativeWebMcpClient, type AgentNativeWebMcpClientOptions, type AgentNativeWebMcpRegistration, type AgentNativeWebMcpRegistrationOptions, type AgentNativeWebMcpTool, type AgentNativeWebMcpToolAnnotations, type AgentNativeWebMcpToolExecutionOptions, type AgentNativeWebMcpToolResult, } from "./client/webmcp.js";
 export { defineAction, fail, type FailOptions, ActionContractError, isActionContractError, type ActionContractErrorOptions, AgentActionStopError, isAgentActionStopError, type ActionHttpConfig, type AgentActionStopOptions, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, type ActionMcpAppConfig, type ActionMcpAppCsp, type ActionMcpAppCspBuilder, type ActionMcpAppHtmlBuilder, type ActionMcpAppPermissions, type ActionMcpAppResourceConfig, type ActionMcpAppResourceMeta, } from "./action.js";
 export { isEmailDerivedName, normalizeUserProfileName, resolveUserProfileName, USER_PROFILE_SETTING_KEY, type UserProfile, } from "./user-profile/index.js";
 export { ACTION_CHAT_UI_DATA_CHART_RENDERER, ACTION_CHAT_UI_DATA_INSIGHTS_RENDERER, ACTION_CHAT_UI_DATA_TABLE_RENDERER, ACTION_CHAT_UI_DATA_WIDGET_RENDERER, ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER, ACTION_CHAT_UI_WORKSPACE_FILE_RENDERER, type ActionChatUIConfig, } from "./action-ui.js";

package/dist/index.browser.js

@@ -8,7 +8,7 @@ export { addContextToAgentChat, appendAgentChatContextToMessage, clearAgentChatC
 export { agentChat } from "./shared/index.js";
 // Pure utilities (no Node.js deps — safe for browser and SSR)
 export { parseArgs, camelCaseArgs } from "./scripts/parse-args.js";
-export { AgentNativeWebMcpUnsupportedError, createAgentNativeWebMcpClient, createAgentNativeWebMcpRegistration, isAgentNativeWebMcpSupported, } from "./client/webmcp.js";
+export { AgentNativeWebMcpUnsupportedError, createAgentNativeWebMcpClient, createAgentNativeWebMcpRegistration, createAgentNativeServerActionWebMcpRegistration, isAgentNativeWebMcpSupported, } from "./client/webmcp.js";
 // defineAction — used by template actions, no Node.js deps
 export { defineAction, fail, ActionContractError, isActionContractError, AgentActionStopError, isAgentActionStopError, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, } from "./action.js";
 export { isEmailDerivedName, normalizeUserProfileName, resolveUserProfileName, USER_PROFILE_SETTING_KEY, } from "./user-profile/index.js";

package/dist/resources/handlers.d.ts

@@ -51,8 +51,8 @@ export declare function handleDeleteResource(event: any): Promise<{
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>;
 /** POST /_agent-native/resources/upload — upload a file as a resource */
 export declare function handleUploadResource(event: any): Promise<import("./store.js").Resource | {
@@ -73,10 +73,10 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     runId: string | null;
     expiresAt: number | null;
     metadata: string | null;
+    error?: undefined;
     url: string;
     provider: string;
     storageSetupRequired?: undefined;
-    error?: undefined;
 } | {
     error: string;
     storageSetupRequired: boolean;

package/dist/server/action-routes.d.ts

@@ -60,10 +60,5 @@ export interface MountActionRoutesOptions {
      */
     actionRouteAuth?: ActionRouteAuthAdapter;
 }
-/**
- * Mount discovered actions as HTTP endpoints.
- *
- * Only actions from `autoDiscoverActions` (template actions) are mounted.
- * Built-in actions (resource-*, chat-*, shell, etc.) are NOT passed here.
- */
 export declare function mountActionRoutes(nitroApp: any, actions: Record<string, ActionEntry>, options?: MountActionRoutesOptions): void;
+export declare function mountWebMcpActionRoutes(nitroApp: any, actions: Record<string, ActionEntry>, options?: MountActionRoutesOptions): void;

package/dist/server/action-routes.js

@@ -240,21 +240,23 @@ async function resolveRequestAuthCapability(event) {
  * Only actions from `autoDiscoverActions` (template actions) are mounted.
  * Built-in actions (resource-*, chat-*, shell, etc.) are NOT passed here.
  */
-export function mountActionRoutes(nitroApp, actions, options) {
+function mountActionRoutesInternal(nitroApp, actions, options) {
     const mounted = [];
     const app = getH3App(nitroApp);
     for (const [name, entry] of Object.entries(actions)) {
         // Skip agent-only actions
-        if (entry.http === false)
+        if (entry.http === false && !options?.includeAgentOnly)
             continue;
-        const method = entry.http?.method ?? "POST";
-        const path = entry.http?.path ?? name;
-        const routePath = `${ROUTE_PREFIX}/${path}`;
+        const http = entry.http || undefined;
+        const method = options?.forcePost ? "POST" : (http?.method ?? "POST");
+        const path = options?.forcePost ? name : (http?.path ?? name);
+        const routePath = `${options?.routePrefix ?? ROUTE_PREFIX}/${path}`;
         // These two actions authenticate with a scoped A2A bearer rather than a
         // browser session. Let that verifier see the request before the cookie
         // auth guard rejects it; the action route still fails closed on invalid
         // or missing credentials.
-        if (name === "list-feature-flags" || name === "set-feature-flag") {
+        if (!options?.caller &&
+            (name === "list-feature-flags" || name === "set-feature-flag")) {
             registerAuthPublicPaths([routePath], app);
         }
         app.use(routePath, defineEventHandler(async (event) => {
@@ -329,7 +331,7 @@ export function mountActionRoutes(nitroApp, actions, options) {
             // through, so a live same-origin session cookie can't silently execute
             // the request as the logged-in user.
             let resolvedCaller = null;
-            {
+            if (options?.allowDelegatedCaller !== false) {
                 let caller;
                 try {
                     caller = options?.actionRouteAuth?.resolveCaller
@@ -468,11 +470,12 @@ export function mountActionRoutes(nitroApp, actions, options) {
                 // userEmail / orgId mirror the request context resolved above (do
                 // NOT inject a dev identity — leave undefined when unauthenticated).
                 try {
-                    const caller = resolvedCaller
-                        ? "a2a"
-                        : isFrontendActionRequest(event)
-                            ? "frontend"
-                            : "http";
+                    const caller = options?.caller ??
+                        (resolvedCaller
+                            ? "a2a"
+                            : isFrontendActionRequest(event)
+                                ? "frontend"
+                                : "http");
                     const result = await entry.run(params, {
                         userEmail,
                         orgId: orgId ?? null,
@@ -574,11 +577,12 @@ export function mountActionRoutes(nitroApp, actions, options) {
                         method: reqMethod,
                         tags: {
                             action: name,
-                            caller: resolvedCaller
-                                ? "a2a"
-                                : isFrontendActionRequest(event)
-                                    ? "frontend"
-                                    : "http",
+                            caller: options?.caller ??
+                                (resolvedCaller
+                                    ? "a2a"
+                                    : isFrontendActionRequest(event)
+                                        ? "frontend"
+                                        : "http"),
                             status_code: String(status),
                         },
                         ...(requestId ? { extra: { request_id: requestId } } : {}),
@@ -598,3 +602,40 @@ export function mountActionRoutes(nitroApp, actions, options) {
     if (mounted.length > 0 && process.env.DEBUG)
         console.log(`[action-routes] Mounted ${mounted.length} action route(s): ${mounted.join(", ")}`);
 }
+export function mountActionRoutes(nitroApp, actions, options) {
+    mountActionRoutesInternal(nitroApp, actions, options);
+}
+export function mountWebMcpActionRoutes(nitroApp, actions, options) {
+    const eligible = Object.fromEntries(Object.entries(actions).filter(([name, entry]) => /^[A-Za-z0-9_.-]{1,128}$/.test(name) &&
+        entry.agentTool !== false &&
+        entry.needsApproval === undefined));
+    if (Object.keys(eligible).length === 0)
+        return;
+    const app = getH3App(nitroApp);
+    app.use("/_agent-native/webmcp/manifest", defineEventHandler(async (event) => {
+        if (getMethod(event) !== "GET") {
+            setResponseStatus(event, 405);
+            return { error: "Method not allowed. Use GET." };
+        }
+        if (!options?.getOwnerFromEvent) {
+            throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+        }
+        await options.getOwnerFromEvent(event);
+        setResponseHeader(event, "Cache-Control", "no-store");
+        return Object.entries(eligible).map(([name, entry]) => ({
+            name,
+            description: entry.tool.description,
+            inputSchema: entry.tool.parameters,
+            readOnly: entry.readOnly === true,
+        }));
+    }));
+    mountActionRoutesInternal(nitroApp, eligible, {
+        ...options,
+        routePrefix: "/_agent-native/webmcp/actions",
+        includeAgentOnly: true,
+        forcePost: true,
+        caller: "webmcp",
+        actionRouteAuth: undefined,
+        allowDelegatedCaller: false,
+    });
+}

package/dist/server/agent-chat-plugin.js

@@ -2128,7 +2128,7 @@ export function createAgentChatPlugin(options) {
                 // Ignore — templates without sharing still work.
             }
             if (Object.keys(httpActions).length > 0) {
-                const { mountActionRoutes } = await import("./action-routes.js");
+                const { mountActionRoutes, mountWebMcpActionRoutes } = await import("./action-routes.js");
                 if (options?.actionRoutePublicPaths?.length) {
                     registerAuthPublicPaths(options.actionRoutePublicPaths, getH3App(nitroApp));
                 }
@@ -2139,6 +2139,13 @@ export function createAgentChatPlugin(options) {
                     resolveOrgId: options?.resolveOrgId,
                     actionRouteAuth: options?.actionRouteAuth,
                 });
+                mountWebMcpActionRoutes(nitroApp, httpActions, {
+                    getOwnerFromEvent,
+                    getUserNameFromEvent,
+                    appId: options?.appId,
+                    resolveOrgId: options?.resolveOrgId,
+                    actionRouteAuth: options?.actionRouteAuth,
+                });
             }
             const preRunGitStatusByThread = new Map();
             async function recordPreRunGitStatus(threadId) {

package/docs/content/webmcp.mdx

@@ -1,6 +1,6 @@
 ---
 title: "WebMCP"
-description: "Expose explicit Agent-Native client actions to browser agents and consume page-local WebMCP tools from Agent-Native chat."
+description: "Automatically expose Agent-Native actions to browser agents, register explicit client actions, and consume page-local WebMCP tools from Agent-Native chat."
 search: "WebMCP browser tools modelContext registerTool getTools executeTool browser session"
 ---
 
@@ -15,24 +15,42 @@ discover them, and the browser mediates execution.
 
 The framework supports both directions:
 
-<!-- i18n-copy-ignore: oxfmt-only table alignment; no translated prose changed. -->
-
 | You want to...                                                           | Use                                                                                                      |
 | ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| Make selected actions in your app available to a browser agent           | `createAgentNativeWebMcpRegistration`                                                                    |
+| Make backend actions available to a browser agent                        | Automatic on authenticated pages through `AppProviders`                                                  |
+| Make page-local client actions available to a browser agent              | `createAgentNativeWebMcpRegistration`                                                                    |
 | Let Agent-Native chat discover and call WebMCP tools in the current page | `createAgentNativeWebMcpClient` plus `webmcp` on `AgentNativeEmbedded` or `AgentNativeFrame`             |
 | Connect a headless or remote agent to an app                             | [MCP Server](/docs/mcp-protocol), [External Agents](/docs/external-agents), or [A2A](/docs/a2a-protocol) |
 
 WebMCP is not a network MCP server and does not make a closed app globally
 discoverable. A consuming agent needs an open, connected browser page and the
-page must explicitly opt into the tools it exposes.
+page must expose tools to it.
 
 The browser API is experimental and may change. See the [Chrome WebMCP
 Imperative API](https://developer.chrome.com/docs/ai/webmcp/imperative-api) and
 the [WebMCP specification](https://webmachinelearning.github.io/webmcp/) for
 the current browser contract.
 
-## Produce WebMCP tools
+## Automatic backend actions
+
+On an authenticated app page, `AppProviders` automatically registers eligible
+backend actions with `document.modelContext`. The tools are derived from the
+same action registry used by the in-app agent and execute through the same
+validated, authenticated server dispatcher. This includes agent-only actions
+declared with `http: false`; WebMCP does not turn those actions into public HTTP
+APIs.
+
+An action is eligible when `agentTool` is not `false` and `needsApproval` is
+not declared. The latter is a fail-closed boundary: the server action approval
+contract belongs to the agent loop and cannot be delegated to a browser hint.
+Public paths, signed-out pages, and `sessionBypass` surfaces do not register
+backend action tools. Browsers without `document.modelContext` simply keep the
+normal app behavior.
+
+No per-app WebMCP list or new `defineAction` metadata is required. Change the
+existing action definition when its exposure should change.
+
+## Explicit page-local actions
 
 Register only the actions that should be available to a page agent. The
 framework removes the action's local `run` function from the descriptor and
@@ -181,10 +199,10 @@ remote or headless tool calls, and use A2A when another app's agent should
 receive work and reason over it. WebMCP is an opt-in browser bridge, not a
 replacement for either network protocol.
 
-The framework does not auto-register every backend action as a WebMCP tool.
-Choose a small explicit producer list, keep side effects behind approval, and
-retain normal MCP or A2A exposure for capabilities that must work without an
-open browser page.
+The framework automatically projects eligible backend actions and still lets a
+page register explicit client-only capabilities. Keep server-side approval
+actions on the agent loop, and retain normal MCP or A2A exposure for
+capabilities that must work without an open browser page.
 
 ## Compatibility and safety
 
@@ -195,7 +213,8 @@ open browser page.
 - Treat descriptions, schemas, annotations, and results as page-provided
   data. The framework validates and bounds them, but agents should still treat
   `untrustedContentHint` results as untrusted content.
-- Use `stop()` when the owning page or component unmounts so stale tools do not
-  remain available.
+- Automatic registrations are aborted when the private app shell unmounts. Use
+  `stop()` for explicit page-local registrations so stale tools do not remain
+  available.
 - Keep server MCP and A2A endpoints for remote access. WebMCP only reaches the
   tools registered in a connected browser context.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.176.1",
+  "version": "0.177.0-nightly-20260828143953",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {