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

package/dist/mcp/build-server.js

@@ -25,6 +25,7 @@ import { buildDeepLink, toAbsoluteOpenUrl, toDesktopOpenUrl, toVsCodeOpenUrl, }
 import { getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { isAgentNativeOpenDeepLink, withCollapsedAgentSidebarParam, } from "../shared/agent-sidebar-url.js";
 import { MCP_APP_CHAT_BRIDGE_QUERY_PARAM } from "../shared/embed-auth.js";
+import { describeMcpError, readClientInfoFromRequest, trackMcpResourceRead, trackMcpResourcesList, trackMcpToolCall, trackMcpToolsList, } from "./analytics.js";
 import { consumeMcpApprovalGrant, createMcpApprovalGrant, } from "./approval-store.js";
 import { getBuiltinCrossAppTools } from "./builtin-tools.js";
 import { MCP_CONNECT_OAUTH_CLIENT_ID, MCP_CONNECT_SCOPE, } from "./connect-store.js";
@@ -1168,6 +1169,30 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
         ...(requestMeta ?? {}),
         inlineMcpApps: requestMeta?.inlineMcpApps ?? isMcpAppsInlineEnabled(effectiveIdentity),
     };
+    // The caller columns every `$mcp_*` event this request emits shares. A 2026
+    // client also carries its own name/version in per-request `_meta`, which is
+    // merged over this at each handler — the HTTP user agent is a fallback, not
+    // the client's own claim about itself.
+    const analyticsBase = {
+        source: requestMeta.transport ?? "http",
+        serverName: config.name,
+        serverVersion: config.version ?? "1.0.0",
+        ...(config.appId ? { appId: config.appId } : {}),
+        ...(requestMeta.clientHint ? { clientName: requestMeta.clientHint } : {}),
+        ...(requestMeta.clientName
+            ? { clientUserAgent: requestMeta.clientName }
+            : {}),
+        ...(effectiveIdentity?.userEmail
+            ? { userId: effectiveIdentity.userEmail }
+            : {}),
+    };
+    function analyticsContext(request, ctx) {
+        return {
+            ...analyticsBase,
+            ...readClientInfoFromRequest(request),
+            ...(ctx?.sessionId ? { sessionId: ctx.sessionId } : {}),
+        };
+    }
     // The action set the request handlers operate on = base actions + generic
     // cross-app builtins (template wins on name collision). An authenticated
     // real caller (connect-minted token / `mcp install` owner / production —
@@ -1430,8 +1455,9 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
     // tools/list — return all actions + ask-agent meta-tool. Wrapped in the
     // request context so per-user MCP visibility (mcp-client/visibility.ts)
     // applies to the listing too.
-    server.setRequestHandler("tools/list", async () => {
-        return withCallerContext(async () => {
+    server.setRequestHandler("tools/list", async (request, ctx) => {
+        const startedAt = Date.now();
+        const result = await withCallerContext(async () => {
             const tools = await Promise.all(Object.entries(advertisedActions)
                 .sort(([a], [b]) => compareMcpCatalogValues(a, b))
                 .map(async ([name, entry]) => {
@@ -1519,21 +1545,38 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
             tools.sort((a, b) => compareMcpCatalogValues(a.name, b.name));
             return { tools };
         });
+        trackMcpToolsList(analyticsContext(request, ctx), {
+            toolNames: result.tools.map((tool) => tool.name),
+            durationMs: Date.now() - startedAt,
+        });
+        return result;
     });
     // tools/call — dispatch to action registry or ask-agent. Wrapped in the
     // request context so the action's `run(args)` and `askAgent()` execute
     // with the verified caller's identity, not the platform default.
     server.setRequestHandler("tools/call", async (request, ctx) => {
-        return withCallerContext(async () => {
+        const startedAt = Date.now();
+        // Set at each failure return below so the emitted event carries the
+        // reason, not just `isError: true` recovered from the rendered result.
+        let failure;
+        const result = await withCallerContext(async () => {
             const { name, arguments: args } = request.params;
             if (name === "ask-agent" && config.askAgent) {
                 if (!fullCatalogRequested) {
+                    failure = {
+                        errorType: "unknown_tool",
+                        errorMessage: `Unknown tool: ${name}`,
+                    };
                     return {
                         content: [{ type: "text", text: `Unknown tool: ${name}` }],
                         isError: true,
                     };
                 }
                 if (!hasMcpOAuthScope(effectiveIdentity?.oauthScopes, "mcp:write")) {
+                    failure = {
+                        errorType: "forbidden_scope",
+                        errorMessage: "OAuth scope does not allow ask-agent",
+                    };
                     return {
                         content: [
                             {
@@ -1568,6 +1611,7 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                     };
                 }
                 catch (err) {
+                    failure = describeMcpError(err);
                     return {
                         content: [{ type: "text", text: `Error: ${err.message}` }],
                         isError: true,
@@ -1584,12 +1628,20 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 : advertisedActions;
             const entry = callableActions[name];
             if (!entry) {
+                failure = {
+                    errorType: "unknown_tool",
+                    errorMessage: `Unknown tool: ${name}`,
+                };
                 return {
                     content: [{ type: "text", text: `Unknown tool: ${name}` }],
                     isError: true,
                 };
             }
             if (!isActionVisibleForOAuthScope(entry, effectiveIdentity?.oauthScopes)) {
+                failure = {
+                    errorType: "forbidden_scope",
+                    errorMessage: `OAuth scope does not allow tool ${name}`,
+                };
                 return {
                     content: [
                         {
@@ -1699,6 +1751,7 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 const errorCode = isActionContractError(err) && err.errorCode !== "action_failed"
                     ? ` (errorCode: ${err.errorCode})`
                     : "";
+                failure = describeMcpError(err);
                 return {
                     content: [
                         { type: "text", text: `Error: ${err.message}${errorCode}` },
@@ -1707,10 +1760,27 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 };
             }
         });
+        const toolName = request.params?.name;
+        const calledEntry = actions[toolName];
+        trackMcpToolCall(analyticsContext(request, ctx), {
+            toolName,
+            ...(calledEntry?.tool.description
+                ? { toolDescription: calledEntry.tool.description }
+                : {}),
+            ...(calledEntry
+                ? { toolCategory: calledEntry.readOnly === true ? "read" : "write" }
+                : {}),
+            parameters: (request.params?.arguments ?? {}),
+            durationMs: Date.now() - startedAt,
+            isError: result.isError === true,
+            ...(failure ?? {}),
+        });
+        return result;
     });
     if (supportsMcpApps) {
-        server.setRequestHandler("resources/list", async () => {
-            return withCallerContext(async () => {
+        server.setRequestHandler("resources/list", async (request, ctx) => {
+            const startedAt = Date.now();
+            const result = await withCallerContext(async () => {
                 const mcpAppResources = await getMcpAppResources(config, advertisedActions, requestMeta);
                 return {
                     resources: mcpAppResources
@@ -1727,6 +1797,11 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                     })),
                 };
             });
+            trackMcpResourcesList(analyticsContext(request, ctx), {
+                resourceCount: result.resources.length,
+                durationMs: Date.now() - startedAt,
+            });
+            return result;
         });
         server.setRequestHandler("resources/templates/list", async () => {
             return withCallerContext(async () => {
@@ -1747,38 +1822,60 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 };
             });
         });
-        server.setRequestHandler("resources/read", async (request) => {
-            return withCallerContext(async () => {
-                const uri = request.params?.uri;
-                let found = null;
-                for (const [name, entry] of Object.entries(advertisedActions)) {
-                    const resourceUri = getMcpAppResourceUri(config, name, entry);
-                    if (!resourceUri || !matchesMcpAppResourceUri(resourceUri, uri)) {
-                        continue;
+        server.setRequestHandler("resources/read", async (request, ctx) => {
+            const startedAt = Date.now();
+            const emitRead = (outcome) => {
+                const failure = "error" in outcome ? describeMcpError(outcome.error) : undefined;
+                trackMcpResourceRead(analyticsContext(request, ctx), {
+                    ...("error" in outcome ? {} : outcome),
+                    ...(typeof request.params?.uri === "string"
+                        ? { resourceUri: request.params.uri }
+                        : {}),
+                    durationMs: Date.now() - startedAt,
+                    isError: !!failure,
+                    ...(failure ?? {}),
+                });
+            };
+            try {
+                return await withCallerContext(async () => {
+                    const uri = request.params?.uri;
+                    let found = null;
+                    for (const [name, entry] of Object.entries(advertisedActions)) {
+                        const resourceUri = getMcpAppResourceUri(config, name, entry);
+                        if (!resourceUri || !matchesMcpAppResourceUri(resourceUri, uri)) {
+                            continue;
+                        }
+                        const resource = await resolveMcpAppResourceSafely(config, name, entry, requestMeta);
+                        if (resource) {
+                            found = { actionName: name, resource };
+                            break;
+                        }
+                        // resolveMcpAppResourceSafely returned null (e.g. an async resolver
+                        // threw) — keep scanning the remaining candidates rather than
+                        // aborting and reporting the resource as missing.
                     }
-                    const resource = await resolveMcpAppResourceSafely(config, name, entry, requestMeta);
-                    if (resource) {
-                        found = { actionName: name, resource };
-                        break;
+                    if (!found) {
+                        throw new ResourceNotFoundError(String(uri ?? ""), `MCP App resource not found: ${uri}`);
                     }
-                    // resolveMcpAppResourceSafely returned null (e.g. an async resolver
-                    // threw) — keep scanning the remaining candidates rather than
-                    // aborting and reporting the resource as missing.
-                }
-                if (!found) {
-                    throw new ResourceNotFoundError(String(uri ?? ""), `MCP App resource not found: ${uri}`);
-                }
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: found.resource.mimeType,
-                            text: renderMcpAppHtml(found.resource, found.actionName, config, requestMeta),
-                            ...(found.resource._meta ? { _meta: found.resource._meta } : {}),
-                        },
-                    ],
-                };
-            });
+                    emitRead({ resourceName: found.resource.name });
+                    return {
+                        contents: [
+                            {
+                                uri,
+                                mimeType: found.resource.mimeType,
+                                text: renderMcpAppHtml(found.resource, found.actionName, config, requestMeta),
+                                ...(found.resource._meta
+                                    ? { _meta: found.resource._meta }
+                                    : {}),
+                            },
+                        ],
+                    };
+                });
+            }
+            catch (err) {
+                emitRead({ error: err });
+                throw err;
+            }
         });
     }
     return server;

package/dist/mcp/screen-memory-stdio.d.ts

@@ -137,13 +137,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -159,7 +159,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -175,6 +174,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -190,7 +190,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             minutes: {
                 type: string;
                 description: string;
@@ -200,6 +199,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -216,7 +216,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -235,6 +234,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -250,7 +250,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
@@ -264,6 +263,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
@@ -314,13 +314,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -349,13 +349,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;

package/dist/mcp/server.js

@@ -1,8 +1,10 @@
 import { defineEventHandler, setResponseStatus, setResponseHeader, getMethod, getRequestHeader, } from "h3";
+import { getAppConfig } from "../app-config/store.js";
 import { getConfiguredAppBasePath } from "../server/app-base-path.js";
 import { isLoopbackRequest } from "../server/auth.js";
 import { getH3App } from "../server/framework-request-handler.js";
 import { readBody } from "../server/h3-helpers.js";
+import { trackMcpInitialize } from "./analytics.js";
 import { createMCPServerForRequest, verifyAuth, getAccessTokens, resolveOrgIdFromDomain, buildLinkArtifacts, } from "./build-server.js";
 import { buildMcpOAuthChallenge, getMcpOAuthAudiences, getMcpOAuthIssuer, getMcpOAuthProtectedResourceMetadataUrl, getMcpOAuthResource, } from "./oauth-route.js";
 import { MCP_PUBLIC_ROUTE_PREFIX, MCP_ROUTE_PREFIXES, joinMcpRoute, } from "./route-paths.js";
@@ -44,6 +46,7 @@ function deriveRequestMeta(event) {
         origin,
         ...(basePath ? { basePath } : {}),
         target,
+        transport: "http",
         clientName,
         clientHint,
         ...(fullCatalog ? { fullCatalog } : {}),
@@ -214,16 +217,19 @@ export async function handleMcpRequest(event, config, routePath = MCP_PUBLIC_ROU
     // parsed value, so neither its modern classifier nor its legacy fallback
     // consumes the request stream a second time.
     const body = method === "POST" ? await readBody(event) : undefined;
+    // The handshake is the only message that carries the client's own name and
+    // version, and the stateless mount builds a fresh server per request — so
+    // `$mcp_initialize` is emitted here rather than from a handler, and the
+    // catalog/call events fall back to the per-request `_meta` and user agent.
+    const initializeRequest = body
+        ? (Array.isArray(body) ? body : [body]).find((m) => typeof m === "object" &&
+            m !== null &&
+            m.method === "initialize")
+        : undefined;
     // Optional diagnostics for host capability negotiation. Keep disabled by
     // default because initialize payloads can include client-specific metadata.
-    if (process.env.MCP_DEBUG_INIT && body) {
-        const msgs = Array.isArray(body) ? body : [body];
-        const init = msgs.find((m) => typeof m === "object" &&
-            m !== null &&
-            m.method === "initialize");
-        if (init) {
-            console.error("[MCP_DEBUG_INIT] clientInfo=", JSON.stringify(init.params?.clientInfo), "capabilities=", JSON.stringify(init.params?.capabilities));
-        }
+    if (getAppConfig().observability.mcpDebugInitialize && initializeRequest) {
+        console.error("[MCP_DEBUG_INIT] clientInfo=", JSON.stringify(initializeRequest.params?.clientInfo), "capabilities=", JSON.stringify(initializeRequest.params?.capabilities));
     }
     const serverRequestMeta = {
         ...requestMeta,
@@ -236,6 +242,29 @@ export async function handleMcpRequest(event, config, routePath = MCP_PUBLIC_ROU
         // "full" JWT claim), bypass the connector-catalog tier filter.
         ...(authResult.fullCatalog === true ? { fullCatalog: true } : {}),
     };
+    if (initializeRequest) {
+        const clientInfo = initializeRequest.params?.clientInfo;
+        const protocolVersion = initializeRequest.params?.protocolVersion;
+        trackMcpInitialize({
+            source: "http",
+            serverName: config.name,
+            serverVersion: config.version ?? "1.0.0",
+            ...(config.appId ? { appId: config.appId } : {}),
+            ...(typeof clientInfo?.name === "string"
+                ? { clientName: clientInfo.name }
+                : {}),
+            ...(typeof clientInfo?.version === "string"
+                ? { clientVersion: clientInfo.version }
+                : {}),
+            ...(requestMeta.clientName
+                ? { clientUserAgent: requestMeta.clientName }
+                : {}),
+            ...(typeof protocolVersion === "string" ? { protocolVersion } : {}),
+            ...(authResult.identity?.userEmail
+                ? { userId: authResult.identity.userEmail }
+                : {}),
+        });
+    }
     const { createMcpHandler } = await import("@modelcontextprotocol/server");
     const handler = createMcpHandler(() => createMCPServerForRequest(config, authResult.identity, serverRequestMeta), {
         legacy: "stateless",

package/dist/mcp/stdio.js

@@ -219,6 +219,7 @@ async function runStandalone(opts) {
     // platform-default scope, same as a tokenless local HTTP mount.
     undefined, {
         origin,
+        transport: "stdio",
         clientName: "agent-native-mcp-standalone",
         // Compact by default; opt into the full catalog with the env flag.
         fullCatalog: process.env.AGENT_NATIVE_MCP_FULL_CATALOG === "1",

package/dist/mcp-client/errors.js

@@ -23,33 +23,53 @@ function stringifyError(error) {
             : "[unserializable]";
     }
 }
+function httpStatusFromError(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const record = error;
+    const nested = record.data && typeof record.data === "object"
+        ? record.data
+        : undefined;
+    const status = record.status ?? nested?.status ?? record.code ?? nested?.code;
+    return typeof status === "number" && status >= 100 && status <= 599
+        ? status
+        : undefined;
+}
 export function formatMcpConnectError(error) {
     const raw = stringifyError(error);
     const text = raw.trim();
-    if (!text)
-        return "Could not connect to that MCP server.";
+    const status = httpStatusFromError(error);
+    const statusPrefix = status !== undefined ? `HTTP ${status}: ` : "";
+    const hasStatusInText = status !== undefined &&
+        new RegExp(`\\bHTTP(?:\\/\\d+(?:\\.\\d+)?)?\\s+${status}\\b`, "i").test(text);
+    const formattedText = hasStatusInText ? text : `${statusPrefix}${text}`;
+    if (!text) {
+        return `${statusPrefix}Could not connect to that MCP server.`;
+    }
     if (/<!doctype|<html[\s>]|<\/html>|unexpected token '<'|is not valid json/i.test(text)) {
-        return "That URL returned a web page instead of an MCP response. Check that you pasted the Streamable HTTP endpoint, often ending in /mcp.";
+        return `${statusPrefix}That URL returned a web page instead of an MCP response. Check that you pasted the Streamable HTTP endpoint, often ending in /mcp.`;
     }
     if (/invalid_union|unrecognized_keys|invalid_type|invalid_value/i.test(text) &&
         /jsonrpc|method|unrecognized keys|args|origin|url/i.test(text)) {
-        return "That URL returned JSON, but not an MCP JSON-RPC response. Check that you pasted the Streamable HTTP endpoint, often ending in /mcp.";
+        return `${statusPrefix}That URL returned JSON, but not an MCP JSON-RPC response. Check that you pasted the Streamable HTTP endpoint, often ending in /mcp.`;
     }
     if (/401|403|unauthorized|forbidden/i.test(text)) {
-        return "The MCP server rejected the request. Reconnect or update the required Authorization header.";
+        return `${statusPrefix}The MCP server rejected the request. Reconnect or update the required Authorization header.`;
     }
     if (/streamable http/i.test(text) &&
         /error|failed|non-200|status/i.test(text)) {
-        return "The server did not complete the Streamable HTTP MCP handshake. Check the URL and any required authorization headers.";
+        return `${statusPrefix}The server did not complete the Streamable HTTP MCP handshake. Check the URL and any required authorization headers.`;
     }
     if (/failed to fetch|fetch failed|networkerror|econnrefused|enotfound|timed out/i.test(text)) {
-        return "Could not reach that MCP server. Check the URL and make sure it is publicly reachable from this app.";
+        return `${statusPrefix}Could not reach that MCP server. Check the URL and make sure it is publicly reachable from this app.`;
     }
     if (/404|not found|405|method not allowed/i.test(text)) {
-        return "That URL is reachable, but it does not look like the MCP endpoint. Check the server's Streamable HTTP path.";
+        return `${statusPrefix}That URL is reachable, but it does not look like the MCP endpoint. Check the server's Streamable HTTP path.`;
     }
     if (text === "[object ErrorEvent]" || text === "error") {
-        return "The MCP server connection failed while opening its event stream. Check the URL and any required authorization headers.";
+        return `${statusPrefix}The MCP server connection failed while opening its event stream. Check the URL and any required authorization headers.`;
     }
-    return text.length > 240 ? `${text.slice(0, 237).trimEnd()}...` : text;
+    return formattedText.length > 240
+        ? `${formattedText.slice(0, 237).trimEnd()}...`
+        : formattedText;
 }

package/dist/mcp-client/oauth-routes.d.ts

@@ -1,7 +1,7 @@
 import type { StoredOAuthClientInformation } from "@modelcontextprotocol/client";
 import { type H3Event } from "h3";
 import { type McpOAuthDiscoveryState } from "./oauth-client.js";
-import { type RemoteMcpScope } from "./remote-store.js";
+import { type StoredRemoteMcpServer, type RemoteMcpScope } from "./remote-store.js";
 export interface McpOAuthFlow {
     name: string;
     url: string;
@@ -20,8 +20,13 @@ export interface McpOAuthFlow {
     expiresAt: number;
 }
 export interface McpOAuthRoutesOptions {
-    reconfigure: () => Promise<void>;
+    reconfigure: (target: {
+        scope: RemoteMcpScope;
+        scopeId: string;
+        server: StoredRemoteMcpServer;
+    }) => Promise<boolean>;
 }
+export declare function resolveMcpOAuthReturnPath(connected: boolean, flow: Pick<McpOAuthFlow, "name" | "returnUrl">): string;
 export declare function redirectWithStagedCookies(event: H3Event, location: string): Response;
 export declare function mountMcpOAuthRoutes(nitroApp: any, options: McpOAuthRoutesOptions): void;
 export declare function resolveMcpOAuthStartError(error: unknown): {

package/dist/mcp-client/oauth-routes.js

@@ -41,6 +41,12 @@ const MANAGED_MCP_OAUTH_CLIENTS = [
         credentialPairs: [["GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET"]],
     },
 ];
+export function resolveMcpOAuthReturnPath(connected, flow) {
+    if (!connected)
+        return "/settings/integrations";
+    return (flow.returnUrl ??
+        `/settings/integrations?connected=mcp-${encodeURIComponent(flow.name)}`);
+}
 export function redirectWithStagedCookies(event, location) {
     const headers = new Headers({
         Location: location,
@@ -351,9 +357,12 @@ async function handleMcpOAuthCallback(event, options) {
             setResponseStatus(event, 400);
             return { error: result.error };
         }
-        await options.reconfigure();
-        const returnPath = flow.returnUrl ??
-            `/settings/integrations?connected=mcp-${encodeURIComponent(flow.name)}`;
+        const connected = await options.reconfigure({
+            scope: flow.scope,
+            scopeId: flow.scopeId,
+            server: result.server,
+        });
+        const returnPath = resolveMcpOAuthReturnPath(connected, flow);
         return redirectWithStagedCookies(event, getAppUrl(event, stripMcpOAuthAppBasePath(returnPath, getAppBasePath())));
     }
     catch {

package/dist/mcp-client/routes.js

@@ -333,9 +333,10 @@ export function mountMcpServersRoutes(nitroApp, manager, options = {}) {
         return;
     mountedApps.add(nitroApp);
     mountMcpOAuthRoutes(nitroApp, {
-        reconfigure: async () => {
+        reconfigure: async ({ scope, scopeId, server }) => {
             await options.waitUntilReady?.();
             await reconfigureManager(manager);
+            return manager.hasServer(mergedConfigKey(scope, server, scopeId));
         },
     });
     try {

package/dist/oauth-tokens/store.js

@@ -209,7 +209,8 @@ export async function replaceOAuthTokensIfRevision(provider, accountId, owner, e
             expectedStorageVersion,
         ],
     });
-    return result.rowsAffected === 1;
+    const replaced = result.rowsAffected === 1;
+    return replaced;
 }
 /** Delete only the exact credential revision the caller inspected. */
 export async function deleteOAuthTokensIfRevision(provider, accountId, owner, expectedRevision, expectedLegacyRevision, expectedStorageVersion) {
@@ -227,7 +228,8 @@ export async function deleteOAuthTokensIfRevision(provider, accountId, owner, ex
             expectedStorageVersion,
         ],
     });
-    return result.rowsAffected === 1;
+    const deleted = result.rowsAffected === 1;
+    return deleted;
 }
 /**
  * Thrown when an OAuth save would re-bind an `(provider, account_id)` row
@@ -340,8 +342,9 @@ export async function saveOAuthTokens(provider, accountId, tokens, owner) {
             Date.now(),
         ],
     });
-    if (result.rowsAffected === 1)
+    if (result.rowsAffected === 1) {
         return;
+    }
     const { rows: conflict } = await client.execute({
         sql: `SELECT owner FROM ${table} WHERE provider = ? AND account_id = ?`,
         args: [provider, accountId],

package/dist/observability/routes.d.ts

@@ -41,27 +41,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
+    error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;