@agent-native/core 0.98.17 → 0.99.1

package/corpus/core/src/mcp/stdio.ts

@@ -7,12 +7,13 @@
  *
  *   - **proxy (default)** — connect an MCP `Client` over
  *     `StreamableHTTPClientTransport` to the *already-running* local app's
- *     `http://127.0.0.1:<port>/_agent-native/mcp`, and run a stdio `Server`
- *     that forwards tools and optional MCP App resources to it. The live app
- *     is the single source of truth: HMR'd actions, the real registry, correct
- *     per-request deep links, and tenant scoping all come for free. If the
- *     app isn't running, we wait briefly for it (the workspace gateway boots
- *     it lazily on first request).
+ *     `http://127.0.0.1:<port>/mcp` (falling back to the legacy
+ *     `/_agent-native/mcp` path), and run a stdio `Server` that forwards tools
+ *     and optional MCP App resources to it. The live app is the single source
+ *     of truth: HMR'd actions, the real registry, correct per-request deep
+ *     links, and tenant scoping all come for free. If the app isn't running,
+ *     we wait briefly for it (the workspace gateway boots it lazily on first
+ *     request).
  *
  *   - **standalone (`--standalone`)** — no running server, no HMR. Build the
  *     MCP server in-process from `autoDiscoverActions(cwd)` +
@@ -25,6 +26,10 @@
 
 import type { ServerCapabilities } from "@modelcontextprotocol/sdk/types.js";
 
+import {
+  MCP_LEGACY_ROUTE_PREFIX,
+  MCP_PUBLIC_ROUTE_PREFIX,
+} from "./route-paths.js";
 import { resolveLocalAppOrigin } from "./workspace-resolve.js";
 
 export interface RunMCPStdioOptions {
@@ -42,7 +47,10 @@ export interface RunMCPStdioOptions {
   waitForAppMs?: number;
 }
 
-const MCP_SUBPATH = "/_agent-native/mcp";
+const MCP_SUBPATHS = [
+  MCP_PUBLIC_ROUTE_PREFIX,
+  MCP_LEGACY_ROUTE_PREFIX,
+] as const;
 
 function log(msg: string): void {
   // stderr only — stdout is the MCP protocol channel and must stay clean.
@@ -74,9 +82,13 @@ function authHeaders(env: NodeJS.ProcessEnv): Record<string, string> {
   return headers;
 }
 
-async function probeOrigin(origin: string, timeoutMs = 800): Promise<boolean> {
+async function probeOrigin(
+  origin: string,
+  subpath: string,
+  timeoutMs = 800,
+): Promise<boolean> {
   try {
-    const res = await fetch(`${origin}${MCP_SUBPATH}`, {
+    const res = await fetch(`${origin}${subpath}`, {
       method: "GET",
       signal: AbortSignal.timeout(timeoutMs),
     });
@@ -87,6 +99,13 @@ async function probeOrigin(origin: string, timeoutMs = 800): Promise<boolean> {
   }
 }
 
+async function resolveMcpSubpath(origin: string): Promise<string | null> {
+  for (const subpath of MCP_SUBPATHS) {
+    if (await probeOrigin(origin, subpath)) return subpath;
+  }
+  return null;
+}
+
 /**
  * Proxy mode: stdio Server ⇄ HTTP Client to the running app.
  *
@@ -103,27 +122,26 @@ async function runProxy(opts: RunMCPStdioOptions): Promise<void> {
     port: opts.port,
   });
   const env = opts.env ?? process.env;
-  const target = `${origin}${MCP_SUBPATH}`;
-
   // Wait for the app to come up. The workspace gateway lazily boots an app's
   // dev server on first request, so a fresh `mcp serve` may briefly race the
   // boot. Hit the gateway path too so the lazy start is triggered.
   const deadline = Date.now() + (opts.waitForAppMs ?? 60_000);
-  let up = await probeOrigin(origin);
-  if (!up) {
+  let mcpSubpath = await resolveMcpSubpath(origin);
+  if (!mcpSubpath) {
     log(`Waiting for ${appId} at ${origin} …`);
-    while (!up && Date.now() < deadline) {
+    while (!mcpSubpath && Date.now() < deadline) {
       await new Promise((r) => setTimeout(r, 750));
-      up = await probeOrigin(origin);
+      mcpSubpath = await resolveMcpSubpath(origin);
     }
   }
-  if (!up) {
+  if (!mcpSubpath) {
     throw new Error(
       `Timed out waiting for the local app at ${origin}. Start it with ` +
         `\`agent-native dev\` (or \`agent-native workspace-dev\`), or run ` +
         `\`agent-native mcp serve --standalone\` to build the server from disk.`,
     );
   }
+  const target = `${origin}${mcpSubpath}`;
 
   const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
   const { StreamableHTTPClientTransport } =

package/corpus/core/src/mcp/workspace-resolve.ts

@@ -213,7 +213,8 @@ export async function resolveWorkspace(
 /**
  * Resolve the local app the stdio proxy should connect its MCP HTTP client
  * to. Honours an explicit `--app` / appId and `--port` / explicit port.
- * Returns the chosen app's origin (where `/_agent-native/mcp` is mounted).
+ * Returns the chosen app's origin (where `/mcp` is mounted; the legacy
+ * `/_agent-native/mcp` alias is supported too).
  *
  * Order of precedence:
  *   1. explicit `port` → http://127.0.0.1:<port>

package/corpus/core/src/mcp-client/manager.ts

@@ -954,9 +954,11 @@ function firstPartyMcpAudienceForUrl(rawUrl: string): string | undefined {
   try {
     const url = new URL(rawUrl);
     const pathname = url.pathname.replace(/\/+$/, "");
-    url.pathname = pathname.endsWith("/_agent-native/mcp")
-      ? pathname
-      : `${pathname}/_agent-native/mcp`;
+    if (pathname.endsWith("/_agent-native/mcp")) {
+      url.pathname = `${pathname.slice(0, -"/_agent-native/mcp".length)}/mcp`;
+    } else {
+      url.pathname = pathname.endsWith("/mcp") ? pathname : `${pathname}/mcp`;
+    }
     url.search = "";
     url.hash = "";
     return url.toString().replace(/\/+$/, "");

package/corpus/core/src/mcp-client/remote-store.ts

@@ -438,22 +438,22 @@ function normalizeEndpointPath(pathname: string): string {
   return pathname.replace(/\/+$/, "") || "/";
 }
 
-function expectedFirstPartyMcpUrl(appUrl: string): URL | null {
+function expectedFirstPartyMcpUrls(appUrl: string): URL[] {
   try {
-    return new URL(`${appUrl.replace(/\/+$/, "")}/_agent-native/mcp`);
+    const base = appUrl.replace(/\/+$/, "");
+    return [new URL(`${base}/mcp`), new URL(`${base}/_agent-native/mcp`)];
   } catch {
-    return null;
+    return [];
   }
 }
 
 function sameFirstPartyMcpEndpoint(endpointUrl: URL, appUrl: string): boolean {
-  const expected = expectedFirstPartyMcpUrl(appUrl);
-  if (!expected) return false;
-  return (
-    endpointUrl.origin === expected.origin &&
-    normalizeEndpointPath(endpointUrl.pathname) ===
-      normalizeEndpointPath(expected.pathname) &&
-    endpointUrl.search === expected.search
+  return expectedFirstPartyMcpUrls(appUrl).some(
+    (expected) =>
+      endpointUrl.origin === expected.origin &&
+      normalizeEndpointPath(endpointUrl.pathname) ===
+        normalizeEndpointPath(expected.pathname) &&
+      endpointUrl.search === expected.search,
   );
 }
 

package/corpus/core/src/server/agent-chat/action-filters-a2a.ts

@@ -6,9 +6,11 @@ import {
   type A2AToolResultSummary,
 } from "../../a2a/artifact-response.js";
 import { collectFinalResponseTextFromAgentEvents } from "../../a2a/response-text.js";
+import { resolveMainChatMaxOutputTokens } from "../../agent/engine/output-tokens.js";
 import type { EngineTool } from "../../agent/engine/types.js";
 import {
   filterInitialEngineTools,
+  resolveAgentRequestReasoningEffort,
   type ActionEntry,
 } from "../../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../../agent/run-loop-with-resume.js";
@@ -160,6 +162,17 @@ function runDelegatedAgentLoop(
   return runner(
     {
       ...runOptions,
+      // Delegated runs resolve their own model and do not pass through the
+      // interactive request handler's output-token setup. Use the same
+      // model-aware headroom here so reasoning models (notably GPT-5.x) do
+      // not spend the small internal default entirely on reasoning before
+      // emitting a tool call or answer. Preserve explicit test/caller values.
+      maxOutputTokens:
+        runOptions.maxOutputTokens ??
+        resolveMainChatMaxOutputTokens(runOptions.model),
+      reasoningEffort:
+        runOptions.reasoningEffort ??
+        resolveAgentRequestReasoningEffort({ model: runOptions.model }),
       finalResponseGuard: pluginOptions.finalResponseGuard,
     },
     pluginOptions.runSoftTimeoutMs,

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -168,6 +168,7 @@ import {
 import { mountRealtimeVoiceRoutes } from "./realtime-voice.js";
 import {
   runWithRequestContext,
+  getRequestContext,
   getRequestOrgId,
   getRequestUserEmail,
   getRequestRunContext,
@@ -1267,6 +1268,22 @@ export function createAgentChatPlugin(
           if (a2aRunContext) {
             a2aRunContext.owner = userEmail;
             a2aRunContext.userApiKey = ownerApiKey;
+            // The async processor restores the original request origin from
+            // task metadata. Only derive a fallback for synchronous A2A calls
+            // where the inbound event is still the caller request.
+            if (!a2aRunContext.requestOrigin) {
+              const restoredOrigin = getRequestContext()?.requestOrigin;
+              if (restoredOrigin) {
+                a2aRunContext.requestOrigin = restoredOrigin;
+              }
+            }
+            if (!a2aRunContext.requestOrigin) {
+              try {
+                a2aRunContext.requestOrigin = getOrigin(context.event as any);
+              } catch {
+                // Keep the owner context even when no browser origin exists.
+              }
+            }
           }
           const a2aEngine = await resolveEngine({
             engineOption: options?.engine,
@@ -1287,15 +1304,6 @@ export function createAgentChatPlugin(
             ? ""
             : await buildSchemaBlock(owner, databaseToolsMode);
           const extra = await resolveExtraContext(context.event, owner);
-          // Stable content first, most-volatile-per-day last: the
-          // runtime-context block is appended after resources/schema/extra so
-          // a day rollover (or the resources/extra content changing) only
-          // invalidates the cached prompt prefix as late as possible.
-          const runtimeContext = runtimeContextForEvent(context.event);
-          const systemPrompt = devActive
-            ? devPrompt + resources + schemaBlock + extra + runtimeContext
-            : basePrompt + resources + schemaBlock + extra + runtimeContext;
-          if (a2aRunContext) a2aRunContext.systemPrompt = systemPrompt;
 
           const a2aModelCandidate =
             options?.model ??
@@ -1309,6 +1317,30 @@ export function createAgentChatPlugin(
             a2aRunContext.model = model;
           }
 
+          // Keep delegated runs aligned with the interactive production
+          // prompt's model-specific behavior without importing interactive
+          // onboarding into a background/cross-app task.
+          const modelOverlay = getModelFamilyOverlay(model);
+          // Stable content first, most-volatile-per-day last: the
+          // runtime-context block is appended after resources/schema/extra so
+          // a day rollover (or the resources/extra content changing) only
+          // invalidates the cached prompt prefix as late as possible.
+          const runtimeContext = runtimeContextForEvent(context.event);
+          const systemPrompt = devActive
+            ? devPrompt +
+              resources +
+              schemaBlock +
+              extra +
+              modelOverlay +
+              runtimeContext
+            : basePrompt +
+              resources +
+              schemaBlock +
+              extra +
+              modelOverlay +
+              runtimeContext;
+          if (a2aRunContext) a2aRunContext.systemPrompt = systemPrompt;
+
           // Build tools — same as interactive handler but WITHOUT call-agent
           // to prevent infinite recursive A2A loops (agent calling itself).
           // In dev mode, template actions are invoked via bash (not native tools),
@@ -5361,6 +5393,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
         "/_agent-native/actions",
         "/_agent-native/agent-model-defaults",
         "/_agent-native/mcp",
+        "/mcp",
       ],
     });
   };

package/corpus/core/src/server/agent-teams.ts

@@ -18,6 +18,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
 import { applyAgentTextEventToBuffer } from "../a2a/response-text.js";
+import { resolveMainChatMaxOutputTokens } from "../agent/engine/output-tokens.js";
 import type { AgentEngine, EngineMessage } from "../agent/engine/types.js";
 import type {
   ActionEntry,
@@ -26,6 +27,7 @@ import type {
 import {
   actionsToEngineTools,
   filterInitialEngineTools,
+  resolveAgentRequestReasoningEffort,
 } from "../agent/production-agent.js";
 import {
   runAgentLoop,
@@ -589,6 +591,11 @@ function createTaskMessageFinalGuard(
       retryMessage: formatQueuedTaskMessages(queuedMessages),
       fallbackMessage:
         "I received an orchestrator update while finishing, but could not continue from it. Please check the task status and send the update again if needed.",
+      // A queued update can introduce a request for an action that was
+      // deferred behind tool-search. The retry is already a corrective turn,
+      // so expose the full authorized registry rather than making the
+      // sub-agent spend that turn rediscovering the same tool.
+      expandToolSurface: true,
     };
   };
 }
@@ -1835,6 +1842,16 @@ export async function processAgentTeamRun(
                   chunkUsage = await runAgentLoop({
                     engine: config.engine,
                     model: config.model,
+                    // Agent-team runs are delegated turns too. Keep their
+                    // first attempt on the same model-aware budget as A2A /
+                    // MCP so reasoning models do not spend the old 4K
+                    // default before emitting a tool call or answer.
+                    maxOutputTokens: resolveMainChatMaxOutputTokens(
+                      config.model,
+                    ),
+                    reasoningEffort: resolveAgentRequestReasoningEffort({
+                      model: config.model,
+                    }),
                     systemPrompt,
                     tools,
                     availableTools,

package/corpus/core/src/server/auth.ts

@@ -74,6 +74,11 @@ import {
 } from "../db/client.js";
 import { ensureColumnExists, ensureTableExists } from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
+import {
+  MCP_LEGACY_ROUTE_PREFIX,
+  MCP_PUBLIC_ROUTE_PREFIX,
+  isMcpProtocolPath,
+} from "../mcp/route-paths.js";
 import { readBody } from "../server/h3-helpers.js";
 import { putSetting } from "../settings/store.js";
 import { DEFAULT_SSR_CACHE_HEADERS } from "../shared/cache-control.js";
@@ -718,8 +723,9 @@ async function getBearerLegacySession(
  * `agent-native connect` mints this token for the local Plans publish flow and
  * POSTs it to the HOSTED action route
  * `/_agent-native/actions/import-visual-plan-source`. That token is audience-
- * bound to the app's MCP resource (`{appUrl}/_agent-native/mcp`), not to the
- * legacy `sessions` table — so the legacy bearer lookup above never matches it.
+ * bound to the app's canonical MCP resource (`{appUrl}/mcp`; the legacy
+ * `/_agent-native/mcp` resource is also accepted), not to the legacy `sessions`
+ * table — so the legacy bearer lookup above never matches it.
  * Reuse the MCP surface's canonical `verifyAuth` here so the HTTP action surface
  * honors EXACTLY the tokens the MCP endpoint honors: same signature check, same
  * audience binding to THIS app's resource, same connect-token revocation gate.
@@ -740,13 +746,13 @@ async function getMcpOAuthBearerSession(
   if (!bearerToken) return null;
 
   try {
-    const [{ getMcpOAuthResource }, { verifyAuth, resolveOrgIdFromDomain }] =
+    const [{ getMcpOAuthAudiences }, { verifyAuth, resolveOrgIdFromDomain }] =
       await Promise.all([
         import("../mcp/oauth-route.js"),
         import("../mcp/build-server.js"),
       ]);
     const result = await verifyAuth(authHeader, undefined, {
-      resourceUrl: getMcpOAuthResource(event),
+      resourceUrl: getMcpOAuthAudiences(event),
       allowDevOpen: false,
     });
     const identity = result.authed ? result.identity : undefined;
@@ -1775,7 +1781,11 @@ function createAuthGuardFn(): (
     // the stdio proxy or HTTP can never reach it. Exact protocol endpoint only:
     // tolerate the common trailing slash, but keep
     // `/_agent-native/mcp/*` management subroutes on normal session auth.
-    if (p === "/_agent-native/mcp" || p === "/_agent-native/mcp/") {
+    if (
+      isMcpProtocolPath(p) ||
+      p === `${MCP_PUBLIC_ROUTE_PREFIX}/` ||
+      p === `${MCP_LEGACY_ROUTE_PREFIX}/`
+    ) {
       return;
     }
 
@@ -1806,7 +1816,13 @@ function createAuthGuardFn(): (
       p === "/_agent-native/mcp/connect/device/poll" ||
       p === "/_agent-native/mcp/oauth/authorize" ||
       p === "/_agent-native/mcp/oauth/token" ||
-      p === "/_agent-native/mcp/oauth/register"
+      p === "/_agent-native/mcp/oauth/register" ||
+      p === `${MCP_PUBLIC_ROUTE_PREFIX}/connect` ||
+      p === `${MCP_PUBLIC_ROUTE_PREFIX}/connect/device/start` ||
+      p === `${MCP_PUBLIC_ROUTE_PREFIX}/connect/device/poll` ||
+      p === `${MCP_PUBLIC_ROUTE_PREFIX}/oauth/authorize` ||
+      p === `${MCP_PUBLIC_ROUTE_PREFIX}/oauth/token` ||
+      p === `${MCP_PUBLIC_ROUTE_PREFIX}/oauth/register`
     ) {
       return;
     }

package/corpus/core/src/server/core-routes-plugin.ts

@@ -64,6 +64,7 @@ import {
   handleMcpOAuthAuthorizationServerMetadata,
   handleMcpOAuthProtectedResourceMetadata,
 } from "../mcp/oauth-route.js";
+import { MCP_ROUTE_PREFIXES } from "../mcp/route-paths.js";
 import { registerBuiltinNotificationChannels } from "../notifications/channels.js";
 import { createNotificationsHandler } from "../notifications/routes.js";
 import { getOrgContext } from "../org/context.js";
@@ -873,9 +874,10 @@ export interface CoreRoutesPluginOptions {
   /** Disable the /_agent-native/embed/start iframe session launcher. */
   disableEmbedRoute?: boolean;
   /**
-   * Disable the /_agent-native/mcp/connect routes (browser Connect page +
-   * CLI device-code flow that mints per-user, revocable MCP tokens) and the
-   * standard remote-MCP OAuth endpoints under /_agent-native/mcp/oauth.
+   * Disable the /mcp/connect routes (browser Connect page + CLI device-code
+   * flow that mints per-user, revocable MCP tokens) and the standard remote-MCP
+   * OAuth endpoints under /mcp/oauth. The legacy /_agent-native/mcp aliases
+   * are disabled at the same time.
    * Enabled by default — the routes are session-gated where they approve user
    * access; token endpoints are protected by single-use codes / refresh
    * tokens.
@@ -939,7 +941,7 @@ export function createCoreRoutesPlugin(
       rejectInit = reject;
     });
     trackPluginInit(nitroApp, initPromise, {
-      paths: [FRAMEWORK_ROUTE_PREFIX, "/.well-known"],
+      paths: [FRAMEWORK_ROUTE_PREFIX, "/mcp", "/.well-known"],
     });
     try {
       await awaitBootstrap(nitroApp);
@@ -3497,16 +3499,18 @@ export function createCoreRoutesPlugin(
             handleMcpOAuthAuthorizationServerMetadata(event),
           ),
         );
-        getH3App(nitroApp).use(
-          `${P}/mcp/oauth`,
-          defineEventHandler(async (event: H3Event) => {
-            const subpath = event.url?.pathname || "";
-            return handleMcpOAuth(event, subpath, {
-              appId: options.mcpConnectAppId,
-              appName: options.mcpConnectAppName ?? getAppName(),
-            });
-          }),
-        );
+        for (const mcpRoutePrefix of MCP_ROUTE_PREFIXES) {
+          getH3App(nitroApp).use(
+            `${mcpRoutePrefix}/oauth`,
+            defineEventHandler(async (event: H3Event) => {
+              const subpath = event.url?.pathname || "";
+              return handleMcpOAuth(event, subpath, {
+                appId: options.mcpConnectAppId,
+                appName: options.mcpConnectAppName ?? getAppName(),
+              });
+            }),
+          );
+        }
 
         // Frictionless external-agent connection. A logged-in user mints a
         // per-user, scoped, revocable MCP bearer token here — via the browser
@@ -3522,16 +3526,18 @@ export function createCoreRoutesPlugin(
           appName: options.mcpConnectAppName ?? getAppName(),
           serverName: options.mcpConnectServerName,
         };
-        getH3App(nitroApp).use(
-          `${P}/mcp/connect`,
-          defineEventHandler(async (event: H3Event) => {
-            // The framework strips the mount prefix from event.url.pathname,
-            // so what remains is the subpath after `/connect` (e.g. `/token`,
-            // `/device/start`, or `` for the page itself).
-            const subpath = event.url?.pathname || "";
-            return handleMcpConnect(event, subpath, mcpConnectOpts);
-          }),
-        );
+        for (const mcpRoutePrefix of MCP_ROUTE_PREFIXES) {
+          getH3App(nitroApp).use(
+            `${mcpRoutePrefix}/connect`,
+            defineEventHandler(async (event: H3Event) => {
+              // The framework strips the mount prefix from event.url.pathname,
+              // so what remains is the subpath after `/connect` (e.g. `/token`,
+              // `/device/start`, or `` for the page itself).
+              const subpath = event.url?.pathname || "";
+              return handleMcpConnect(event, subpath, mcpConnectOpts);
+            }),
+          );
+        }
       }
 
       // Cross-app SSO ("Sign in with Agent-Native") — CLIENT side. Mounted

package/corpus/core/src/server/csrf.ts

@@ -50,6 +50,7 @@ import {
   setResponseStatus,
 } from "h3";
 
+import { MCP_PUBLIC_ROUTE_PREFIX } from "../mcp/route-paths.js";
 import { getConfiguredAppBasePath } from "./app-base-path.js";
 
 /**
@@ -166,12 +167,28 @@ function matchingFrameworkPrefix(
 ): string | undefined {
   if (pathname.startsWith(frameworkPrefix)) return frameworkPrefix;
 
+  if (
+    pathname === MCP_PUBLIC_ROUTE_PREFIX ||
+    pathname.startsWith(`${MCP_PUBLIC_ROUTE_PREFIX}/`)
+  ) {
+    return MCP_PUBLIC_ROUTE_PREFIX;
+  }
+
   const basePath = getConfiguredAppBasePath();
   const basePathFrameworkPrefix = `${basePath}${frameworkPrefix}`;
   if (basePath && pathname.startsWith(basePathFrameworkPrefix)) {
     return basePathFrameworkPrefix;
   }
 
+  const basePathMcpPrefix = `${basePath}${MCP_PUBLIC_ROUTE_PREFIX}`;
+  if (
+    basePath &&
+    (pathname === basePathMcpPrefix ||
+      pathname.startsWith(`${basePathMcpPrefix}/`))
+  ) {
+    return basePathMcpPrefix;
+  }
+
   return undefined;
 }
 

package/corpus/core/src/server/framework-request-handler.ts

@@ -15,6 +15,7 @@ import type { EventHandler, H3Event } from "h3";
 import { setResponseHeader, setResponseStatus } from "h3";
 
 import { getMissingDefaultPlugins } from "../deploy/route-discovery.js";
+import { MCP_PUBLIC_ROUTE_PREFIX } from "../mcp/route-paths.js";
 import { getConfiguredAppBasePath } from "./app-base-path.js";
 import { captureError } from "./capture-error.js";
 import { createCsrfMiddleware } from "./csrf.js";
@@ -48,7 +49,8 @@ function pathMatchesPrefix(reqPath: string, prefix: string): boolean {
 function supportsAppBasePathMount(path: string): boolean {
   return (
     pathMatchesPrefix(path, FRAMEWORK_PREFIX) ||
-    pathMatchesPrefix(path, WELL_KNOWN_PREFIX)
+    pathMatchesPrefix(path, WELL_KNOWN_PREFIX) ||
+    pathMatchesPrefix(path, MCP_PUBLIC_ROUTE_PREFIX)
   );
 }
 
@@ -164,6 +166,9 @@ export function getH3App(nitroApp: any): H3AppShim {
     registerMiddleware(nitroApp, WELL_KNOWN_PREFIX, readinessGate, {
       prepend: true,
     });
+    registerMiddleware(nitroApp, MCP_PUBLIC_ROUTE_PREFIX, readinessGate, {
+      prepend: true,
+    });
 
     // CSRF (see csrf.ts): registered here — synchronously, on the very
     // first `getH3App()` call for this nitroApp — rather than inside
@@ -196,7 +201,8 @@ export function getH3App(nitroApp: any): H3AppShim {
       const reqPath = event.url?.pathname ?? "";
       if (
         resolveMountMatch(reqPath, FRAMEWORK_PREFIX) ||
-        resolveMountMatch(reqPath, WELL_KNOWN_PREFIX)
+        resolveMountMatch(reqPath, WELL_KNOWN_PREFIX) ||
+        resolveMountMatch(reqPath, MCP_PUBLIC_ROUTE_PREFIX)
       ) {
         await awaitFrameworkRoutesReadyForRequest(nitroApp, reqPath);
       }

package/corpus/core/src/server/google-oauth.ts

@@ -17,7 +17,7 @@ import {
   type H3Event,
 } from "h3";
 
-import { getConfiguredAppBasePath } from "./app-base-path.js";
+import { getAppBasePathFromViteEnv } from "./app-base-path.js";
 import { getAppName } from "./app-name.js";
 import { signupAttributionFromCookieHeader } from "./attribution.js";
 import {
@@ -170,6 +170,12 @@ function getConfiguredOriginAllowlist(): Set<string> {
   return out;
 }
 
+/** Return whether a candidate is one of this deployment's configured origins. */
+export function isConfiguredAppOrigin(value: string | undefined): boolean {
+  const origin = normalizeOrigin(value);
+  return !!origin && getConfiguredOriginAllowlist().has(origin);
+}
+
 function getWorkspaceCallbackOrigin(): string | undefined {
   const publicAuthOrigin = firstOriginFromEnv(EXPLICIT_PUBLIC_ORIGIN_ENV_KEYS, {
     allowLoopback: true,
@@ -275,7 +281,11 @@ export function getOrigin(event: H3Event): string {
 
 /** App mount prefix, if the template is served under APP_BASE_PATH. */
 export function getAppBasePath(): string {
-  return getConfiguredAppBasePath();
+  // Vite statically replaces VITE_* values in the server bundle during the
+  // build, but Netlify/Nitro does not necessarily expose those build vars at
+  // runtime. Keep auth and OAuth path matching aligned with the SSR handler by
+  // falling back to import.meta.env (including BASE_URL).
+  return getAppBasePathFromViteEnv();
 }
 
 /** Build an absolute same-origin URL that preserves APP_BASE_PATH. */

package/corpus/core/src/server/http-response-telemetry.ts

@@ -2,6 +2,7 @@ import { defineEventHandler, getHeader, getMethod } from "h3";
 import type { EventHandler, H3Event } from "h3";
 
 import { getDatabaseRuntimeFingerprint } from "../db/runtime-diagnostics.js";
+import { isMcpPublicPath } from "../mcp/route-paths.js";
 import { track } from "../tracking/index.js";
 import { getAppName } from "./app-name.js";
 
@@ -74,7 +75,11 @@ function statusClass(statusCode: number): string {
 }
 
 function routeKind(pathname: string): string {
-  if (pathname === "/_agent-native" || pathname.startsWith("/_agent-native/")) {
+  if (
+    isMcpPublicPath(pathname) ||
+    pathname === "/_agent-native" ||
+    pathname.startsWith("/_agent-native/")
+  ) {
     return "framework";
   }
   if (pathname === "/api" || pathname.startsWith("/api/")) return "api";

package/corpus/core/src/server/recap-image-route.ts

@@ -5,7 +5,7 @@
  *     Auth: `Authorization: Bearer <token>` — accepts the SAME tokens the MCP /
  *     action surface accepts: a legacy `sessions` bearer (desktop/native) OR a
  *     connect-minted MCP OAuth access token (the `agent-native connect` token,
- *     audience-bound to this app's `{origin}/_agent-native/mcp` resource). A
+ *     audience-bound to this app's `{origin}/mcp` resource). A
  *     normal browser session cookie is also accepted. Rejects unauthenticated
  *     callers with 401.
  *     Body: raw `image/png` bytes, or JSON `{ "pngBase64": "..." }`. Capped at
@@ -74,13 +74,13 @@ async function resolveUploadSession(
   if (!authHeader || !bearer) return null;
 
   try {
-    const [{ getMcpOAuthResource }, { verifyAuth, resolveOrgIdFromDomain }] =
+    const [{ getMcpOAuthAudiences }, { verifyAuth, resolveOrgIdFromDomain }] =
       await Promise.all([
         import("../mcp/oauth-route.js"),
         import("../mcp/build-server.js"),
       ]);
     const result = await verifyAuth(authHeader, undefined, {
-      resourceUrl: getMcpOAuthResource(event),
+      resourceUrl: getMcpOAuthAudiences(event),
       allowDevOpen: false,
     });
     const identity = result.authed ? result.identity : undefined;