@agent-native/core 0.201.0 → 0.201.1

package/dist/mcp/build-server.js

@@ -1,4 +1,5 @@
 import "../authorization/check-action.js";
+import { verifyA2AOrganizationIdentity } from "../a2a/organization-identity.js";
 import { actionCallEmitsChange, actionChangeResource, } from "../action-call-classification.js";
 import { MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, } from "../action.js";
 import { isActionContractError, isActionExposedToExternalAgents, } from "../action.js";
@@ -7,6 +8,7 @@ import { getAppConfig } from "../app-config/store.js";
 import { isMcpActionResult } from "../mcp-client/app-result.js";
 import { writeActionChangeMarker } from "../server/action-change-marker-write.js";
 import { getConfiguredAppBasePath } from "../server/app-base-path.js";
+import { readDeployCredentialEnv } from "../server/credential-provider.js";
 import { buildDeepLink, isAgentNativeOpenUrl, isSameOriginUrl, toAbsoluteOpenUrl, toDesktopOpenUrl, toVsCodeOpenUrl, } from "../server/deep-link.js";
 import { getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { agentNativeMcpInstructions, agentNativeToolTitle, } from "../shared/agent-mcp-metadata.js";
@@ -849,7 +851,7 @@ function openAiWidgetCsp(cspConfig, requestMeta) {
         csp.frame_domains = frameDomains;
     return Object.keys(csp).length > 0 ? csp : undefined;
 }
-function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDomain) {
+function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDomain, directoryMode = false) {
     const base = resource._meta && typeof resource._meta === "object"
         ? { ...resource._meta }
         : {};
@@ -858,13 +860,28 @@ function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDom
         : {};
     const ui = { ...existingUi };
     delete ui.domain;
+    if (directoryMode &&
+        ui.csp &&
+        typeof ui.csp === "object" &&
+        !Array.isArray(ui.csp)) {
+        const csp = { ...ui.csp };
+        delete csp.baseUriDomains;
+        ui.csp = csp;
+    }
     if (resolvedCsp) {
+        const csp = { ...resolvedCsp };
+        if (directoryMode)
+            delete csp.baseUriDomains;
         ui.csp = {
-            ...resolvedCsp,
+            ...csp,
             connectDomains: expandRequestOriginSources(resolvedCsp.connectDomains, requestMeta),
             resourceDomains: expandRequestOriginSources(resolvedCsp.resourceDomains, requestMeta),
             frameDomains: expandRequestOriginSources(resolvedCsp.frameDomains, requestMeta),
-            baseUriDomains: expandRequestOriginSources(resolvedCsp.baseUriDomains, requestMeta),
+            ...(!directoryMode
+                ? {
+                    baseUriDomains: expandRequestOriginSources(resolvedCsp.baseUriDomains, requestMeta),
+                }
+                : {}),
         };
     }
     if (resource.permissions)
@@ -923,7 +940,7 @@ async function resolveMcpAppResource(config, actionName, entry, requestMeta) {
         requestOrigin: requestMeta?.origin,
         catalogMode: config.catalogMode,
     });
-    const resourceMeta = mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, config.catalogMode === "directory" ? config.widgetDomain : undefined);
+    const resourceMeta = mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, config.catalogMode === "directory" ? config.widgetDomain : undefined, config.catalogMode === "directory");
     return {
         uri: resolvedUri.uri,
         ...(resolvedUri.legacyUris ? { legacyUris: resolvedUri.legacyUris } : {}),
@@ -1925,11 +1942,13 @@ export function getBearerToken(authHeader) {
     const match = /^Bearer\s+(.+)$/i.exec(authHeader.trim());
     return match?.[1]?.trim() || undefined;
 }
-function addSecretCandidate(candidates, secret) {
-    const trimmed = secret?.trim();
-    if (!trimmed || candidates.includes(trimmed))
-        return;
-    candidates.push(trimmed);
+export class McpIdentityVerificationUnavailableError extends Error {
+    cause;
+    constructor(cause) {
+        super("MCP identity verification is temporarily unavailable");
+        this.name = "McpIdentityVerificationUnavailableError";
+        this.cause = cause;
+    }
 }
 async function verifyA2AJwtForMcp(token, resourceUrl) {
     const jose = await import("jose");
@@ -1940,37 +1959,96 @@ async function verifyA2AJwtForMcp(token, resourceUrl) {
     catch {
         return null;
     }
-    const candidateSecrets = [];
-    addSecretCandidate(candidateSecrets, process.env.A2A_SECRET);
     const orgDomain = typeof unverifiedPayload.org_domain === "string"
-        ? unverifiedPayload.org_domain
+        ? unverifiedPayload.org_domain.trim().toLowerCase()
         : undefined;
-    if (orgDomain) {
-        try {
-            const { getA2ASecretByDomain } = await import("../org/context.js");
-            addSecretCandidate(candidateSecrets, await getA2ASecretByDomain(orgDomain));
-        }
-        catch {
-            // DB not ready or org lookup unavailable — fall back to other candidates.
-        }
-    }
     const firstPartyMcp = unverifiedPayload.agent_native_first_party_mcp === true;
     const audiences = firstPartyMcp ? mcpAudienceList(resourceUrl) : null;
     if (firstPartyMcp && !audiences?.length)
         return null;
-    for (const secret of candidateSecrets) {
-        const encodedSecret = new TextEncoder().encode(secret);
+    const verifyWithSecret = async (secret) => {
         for (const audience of audiences ?? [undefined]) {
             try {
-                const { payload } = await jose.jwtVerify(token, encodedSecret, audience ? { audience } : undefined);
+                const { payload } = await jose.jwtVerify(token, new TextEncoder().encode(secret), audience ? { audience } : undefined);
                 return payload;
             }
             catch {
-                // Try the next candidate without exposing which secret matched.
+                // coercion-ok: bad signature or audience rejects this candidate; credential lookup failures throw separately.
+            }
+        }
+        return null;
+    };
+    const globalSecret = readDeployCredentialEnv("A2A_SECRET")?.trim();
+    if (globalSecret) {
+        const payload = await verifyWithSecret(globalSecret);
+        if (payload) {
+            const tokenScope = typeof payload.scope === "string" ? payload.scope : undefined;
+            const firstPartyMcp = payload.agent_native_first_party_mcp === true;
+            const hasOrganizationClaim = Object.prototype.hasOwnProperty.call(payload, "org_id") &&
+                payload.org_id !== null;
+            const locallyIssuedConnectToken = tokenScope === MCP_CONNECT_SCOPE && !firstPartyMcp;
+            const unclaimedFirstPartyToken = firstPartyMcp && !hasOrganizationClaim;
+            if (locallyIssuedConnectToken || unclaimedFirstPartyToken) {
+                return payload;
+            }
+            let verifiedOrganization;
+            try {
+                verifiedOrganization = await verifyA2AOrganizationIdentity(payload);
+            }
+            catch (error) {
+                throw new McpIdentityVerificationUnavailableError(error);
             }
+            if (verifiedOrganization === null)
+                return null;
+            return verifiedOrganization
+                ? {
+                    ...payload,
+                    org_id: verifiedOrganization.orgId,
+                    org_domain: verifiedOrganization.orgDomain,
+                }
+                : payload;
         }
     }
-    return null;
+    if (!orgDomain)
+        return null;
+    let organization;
+    try {
+        const { resolveA2AOrganizationCredentialsByDomain } = await import("../org/context.js");
+        organization = await resolveA2AOrganizationCredentialsByDomain(orgDomain);
+    }
+    catch (error) {
+        throw new McpIdentityVerificationUnavailableError(error);
+    }
+    if (!organization)
+        return null;
+    const payload = await verifyWithSecret(organization.secret);
+    if (!payload)
+        return null;
+    const verifiedDomain = typeof payload.org_domain === "string"
+        ? payload.org_domain.trim().toLowerCase()
+        : "";
+    const email = typeof payload.sub === "string" ? payload.sub.trim() : "";
+    const claimedOrgId = payload.org_id;
+    if (!email ||
+        verifiedDomain !== organization.orgDomain ||
+        (typeof claimedOrgId !== "undefined" &&
+            (typeof claimedOrgId !== "string" ||
+                claimedOrgId.trim() !== organization.orgId))) {
+        return null;
+    }
+    try {
+        const { isOrgMemberForA2A } = await import("../org/membership.js");
+        if (!(await isOrgMemberForA2A(organization.orgId, email)))
+            return null;
+    }
+    catch (error) {
+        throw new McpIdentityVerificationUnavailableError(error);
+    }
+    return {
+        ...payload,
+        org_id: organization.orgId,
+        org_domain: organization.orgDomain,
+    };
 }
 function mcpAudienceList(resource) {
     const raw = Array.isArray(resource) ? resource : resource ? [resource] : [];
@@ -2043,13 +2121,24 @@ function orgIdFromConnectTokenResolution(resolution) {
     if (resolution.status === "claimed" || resolution.status === "found") {
         return resolution.orgId;
     }
-    // A connect token with no row here was not issued for any org this app
-    // knows. Its `org_domain` claim must not grant that domain's org, so it
-    // runs Personal.
+    // A first-party cross-app token with no row here was not issued for any org
+    // this app knows. Its `org_domain` claim must not grant that domain's org.
     if (resolution.status === "missing")
         return null;
     return undefined;
 }
+function matchesStoredConnectTokenIdentity(resolution, input) {
+    const stored = resolution.status === "found"
+        ? resolution
+        : resolution.status === "claimed"
+            ? resolution.storedConnectToken
+            : undefined;
+    if (!stored || !input.ownerEmail?.trim())
+        return false;
+    return (stored.ownerEmail.trim().toLowerCase() ===
+        input.ownerEmail.trim().toLowerCase() &&
+        (input.orgId === undefined || stored.orgId === input.orgId));
+}
 /**
  * Credentials this app issues (MCP OAuth access tokens and connect tokens)
  * carry the organization chosen when they were issued: the signed `org_id`
@@ -2061,9 +2150,10 @@ function orgIdFromConnectTokenResolution(resolution) {
  * They also carry the subject's address, which an email change retires; a
  * credential signed for it before the change is refused, Personal or not.
  *
- * Cross-app A2A JWTs, first-party MCP tokens included, are not checked: their
- * `org_id`, like `org_domain`, is the signing app's assertion, and the caller
- * may have no membership row in this app's database.
+ * Shared-secret A2A org claims must resolve against local metadata before they
+ * become request scope. A sibling app's user roster is not this app's roster;
+ * locally issued connect credentials instead use their stored JTI owner and
+ * organization.
  */
 async function admitIssuedCredential(result, requestOrigin, orgResolution, issuedAt) {
     const { checkCredentialEmailRetirement, checkCredentialOrgMembership } = await import("./credential-membership.js");
@@ -2124,7 +2214,7 @@ async function admitIssuedCredential(result, requestOrigin, orgResolution, issue
  */
 export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
     const accessTokens = getAccessTokens();
-    const hasA2ASecret = !!process.env.A2A_SECRET?.trim();
+    const hasA2ASecret = !!readDeployCredentialEnv("A2A_SECRET")?.trim();
     const token = getBearerToken(authHeader);
     if (token) {
         const oauthIdentity = await verifyMcpOAuthAccessToken(token, options.resourceUrl);
@@ -2140,6 +2230,13 @@ export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
             if (orgResolution.status === "unavailable") {
                 return { authed: false, unavailable: true };
             }
+            if (oauthIdentity.clientId === MCP_CONNECT_OAUTH_CLIENT_ID &&
+                !matchesStoredConnectTokenIdentity(orgResolution, {
+                    ownerEmail: oauthIdentity.userEmail,
+                    orgId: oauthIdentity.orgId,
+                })) {
+                return { authed: false };
+            }
             const orgId = orgIdFromConnectTokenResolution(orgResolution);
             const admitted = await admitIssuedCredential({
                 authed: true,
@@ -2172,7 +2269,16 @@ export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
     }
     if (!token)
         return { authed: false };
-    const payload = await verifyA2AJwtForMcp(token, options.resourceUrl);
+    let payload;
+    try {
+        payload = await verifyA2AJwtForMcp(token, options.resourceUrl);
+    }
+    catch (error) {
+        if (error instanceof McpIdentityVerificationUnavailableError) {
+            return { authed: false, unavailable: true };
+        }
+        throw error;
+    }
     if (payload) {
         const tokenScope = typeof payload.scope === "string" ? payload.scope : undefined;
         if (tokenScope && tokenScope !== MCP_CONNECT_SCOPE) {
@@ -2198,6 +2304,14 @@ export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
         if (orgResolution.status === "unavailable") {
             return { authed: false, unavailable: true };
         }
+        if (tokenScope === MCP_CONNECT_SCOPE && !firstPartyMcp) {
+            if (!matchesStoredConnectTokenIdentity(orgResolution, {
+                ownerEmail: typeof payload.sub === "string" ? payload.sub : undefined,
+                orgId: orgIdClaim.orgId,
+            })) {
+                return { authed: false };
+            }
+        }
         const orgId = orgIdFromConnectTokenResolution(orgResolution);
         const verified = {
             authed: true,
@@ -2222,15 +2336,10 @@ export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
         }
         return admitted;
     }
-    if (accessTokens.length === 0 && !hasA2ASecret) {
-        if (options.allowDevOpen === false) {
-            return { authed: false };
-        }
-        return {
-            authed: true,
-            identity: deriveStaticTokenIdentity(ownerEmailHeader),
-            fullSurface: !!(ownerEmailHeader && ownerEmailHeader.trim()),
-        };
+    if (accessTokens.length === 0) {
+        // A supplied bearer that failed JWT verification must not fall through to
+        // dev-open auth or reuse a forwarded owner-email hint.
+        return { authed: false };
     }
     // Try ACCESS_TOKEN / ACCESS_TOKENS exact match. Static tokens carry no
     // per-caller claims, so derive identity from the forwarded owner-email

package/dist/mcp/embed-app.js

@@ -98,7 +98,6 @@ export function embedApp(options = {}) {
     const nativeBridgeInitializeTimeoutMs = 5000;
     const nativeBridgeRequestTimeoutMs = 30000;
     const wrapperRequestTimeoutMs = 5000;
-    const remoteBridgeFallbackEnabled = ${remoteBridgeFallbackEnabled};
     let app = null;
     let appConnectPromise = null;
     let openAiBridge = null;
@@ -2144,7 +2143,8 @@ export function embedApp(options = {}) {
       sendHostContext();
     }
 
-    async function startMcpAppsBridge() {
+    ${remoteBridgeFallbackEnabled
+                ? `async function startMcpAppsBridge() {
       const { App } = await import("${MCP_APP_IMPORT}");
       app = new App(
         { name: "Agent-Native Embed", version: "1.0.0" },
@@ -2174,7 +2174,8 @@ export function embedApp(options = {}) {
       updateDisplayButton();
       notifyHostHeight();
       sendHostContext();
-    }
+    }`
+                : ""}
 
     try {
       const initialOpenAiBridge = await waitForOpenAiBridge();
@@ -2183,8 +2184,7 @@ export function embedApp(options = {}) {
           await startNativeMcpAppsBridge();
         } catch (nativeErr) {
           console.warn("[agent-native] native MCP Apps bridge failed", nativeErr);
-          if (!remoteBridgeFallbackEnabled) throw nativeErr;
-          await startMcpAppsBridge();
+          ${remoteBridgeFallbackEnabled ? "await startMcpAppsBridge();" : "throw nativeErr;"}
         }
       }
     } catch (err) {

package/dist/mcp/server.d.ts

@@ -2,24 +2,6 @@ import type { H3Event } from "h3";
 import { createMCPServerForRequest, verifyAuth, getAccessTokens, resolveOrgIdFromDomain, buildLinkArtifacts, type MCPConfig, type MCPCallerIdentity, type MCPRequestMeta } from "./build-server.js";
 export { createMCPServerForRequest, verifyAuth, getAccessTokens, resolveOrgIdFromDomain, buildLinkArtifacts, };
 export type { MCPConfig, MCPCallerIdentity, MCPRequestMeta };
-/**
- * Handle a single `{routePrefix}/mcp` request on either runtime.
- *
- * Builds one request-scoped MCP `Server` from the verified caller identity and
- * drives it through the SDK's v2 `createMcpHandler`. That entry serves native
- * 2026-07-28 envelopes and stateless 2025-era traffic from the same factory,
- * so protocol generations cannot drift apart.
- *
- * The handler is Web Standard on every runtime. H3 owns the Node response when
- * one exists, avoiding the double-write race from a transport writing directly
- * to `node.res`.
- *
- * Returns:
- *   - `undefined` when the request targets a sub-route (so management/status
- *     routes mounted under `/_agent-native/mcp/*` handle it themselves) — the
- *     h3 mount falls through to the next handler.
- *   - a Web `Response` or an auth-error object otherwise.
- */
 export declare function handleMcpRequest(event: H3Event, config: MCPConfig, routePath?: string): Promise<Response | string | {
     error: string;
 } | Record<string, unknown> | undefined>;

package/dist/mcp/server.js

@@ -7,7 +7,7 @@ import { getH3App } from "../server/framework-request-handler.js";
 import { getOrigin } from "../server/google-oauth.js";
 import { readBody } from "../server/h3-helpers.js";
 import { trackMcpInitialize } from "./analytics.js";
-import { createMCPServerForRequest, verifyAuth, getAccessTokens, resolveOrgIdFromDomain, buildLinkArtifacts, McpDirectoryProfileValidationError, validateMcpDirectoryProfile, validateMcpDirectoryWidgetDomain, selectMcpActionSurface, } from "./build-server.js";
+import { createMCPServerForRequest, verifyAuth, McpIdentityVerificationUnavailableError, getAccessTokens, resolveOrgIdFromDomain, buildLinkArtifacts, McpDirectoryProfileValidationError, validateMcpDirectoryProfile, validateMcpDirectoryWidgetDomain, selectMcpActionSurface, } from "./build-server.js";
 import { buildMcpOAuthChallenge, getMcpOAuthAudiences, getMcpOAuthIssuer, getMcpOAuthProtectedResourceMetadataUrl, getMcpOAuthResource, } from "./oauth-route.js";
 import { MCP_DIRECTORY_ROUTE_PREFIX, MCP_PUBLIC_ROUTE_PREFIX, MCP_ROUTE_PREFIXES, joinMcpRoute, } from "./route-paths.js";
 export { createMCPServerForRequest, verifyAuth, getAccessTokens, resolveOrgIdFromDomain, buildLinkArtifacts, };
@@ -121,6 +121,51 @@ function buildUnauthorizedBody(event, routePath = MCP_PUBLIC_ROUTE_PREFIX) {
     };
 }
 const loggedDirectoryProfileFailures = new Set();
+const directoryLogMethods = new Set([
+    "initialize",
+    "notifications/initialized",
+    "server/discover",
+    "tools/list",
+    "tools/call",
+    "resources/list",
+    "resources/templates/list",
+    "resources/read",
+    "prompts/list",
+    "prompts/get",
+    "ping",
+]);
+function directoryLogMethod(body) {
+    if (!body || typeof body !== "object")
+        return undefined;
+    if (Array.isArray(body))
+        return "batch";
+    const method = body.method;
+    if (typeof method !== "string")
+        return "other";
+    return directoryLogMethods.has(method) ? method : "other";
+}
+function responseStatusFromEvent(event) {
+    const status = event.res?.status ??
+        event.node?.res?.statusCode ??
+        event._status;
+    return typeof status === "number" && Number.isInteger(status) && status > 0
+        ? status
+        : 200;
+}
+function responseStatusFromError(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const status = error;
+    for (const candidate of [status.status, status.statusCode]) {
+        if (typeof candidate === "number" &&
+            Number.isInteger(candidate) &&
+            candidate >= 100 &&
+            candidate <= 599) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
 function directoryProfileUnavailable(event, validationError) {
     const failureKey = `${validationError.code}\0${validationError.message}`;
     if (!loggedDirectoryProfileFailures.has(failureKey)) {
@@ -155,7 +200,7 @@ function directoryProfileUnavailable(event, validationError) {
  *     h3 mount falls through to the next handler.
  *   - a Web `Response` or an auth-error object otherwise.
  */
-export async function handleMcpRequest(event, config, routePath = MCP_PUBLIC_ROUTE_PREFIX) {
+async function handleMcpRequestInternal(event, config, routePath = MCP_PUBLIC_ROUTE_PREFIX, onMcpMethod) {
     const pathname = event.url?.pathname || "/";
     const subpath = pathname.replace(/^\/+/, "").replace(/\/+$/, "");
     if (subpath) {
@@ -183,13 +228,26 @@ export async function handleMcpRequest(event, config, routePath = MCP_PUBLIC_ROU
             widgetDomain: requestMeta.origin,
         }
         : config;
-    const authResult = await verifyAuth(authHeader, ownerEmailHeader, {
-        allowDevOpen: isLoopbackRequest(event) &&
-            isLoopbackOrigin(requestMeta.origin) &&
-            (hasLocalOwnerHint || process.env.AGENT_NATIVE_MCP_DEV_OPEN === "1"),
-        resourceUrl: getMcpOAuthAudiences(event, routePath),
-        requestOrigin: getOrigin(event),
-    });
+    let authResult;
+    try {
+        authResult = await verifyAuth(authHeader, ownerEmailHeader, {
+            allowDevOpen: isLoopbackRequest(event) &&
+                isLoopbackOrigin(requestMeta.origin) &&
+                (hasLocalOwnerHint || getAppConfig().mcp.allowDevOpen),
+            resourceUrl: getMcpOAuthAudiences(event, routePath),
+            requestOrigin: getOrigin(event),
+        });
+    }
+    catch (error) {
+        if (!(error instanceof McpIdentityVerificationUnavailableError))
+            throw error;
+        setResponseStatus(event, 503);
+        setResponseHeader(event, "Retry-After", "5");
+        return {
+            error: "Service Unavailable",
+            message: CREDENTIAL_MEMBERSHIP_UNAVAILABLE_MESSAGE,
+        };
+    }
     if (!authResult.authed && authResult.unavailable) {
         // The token is valid but its org membership could not be checked. No auth
         // challenge: re-authenticating would not help, and the client must keep
@@ -207,6 +265,7 @@ export async function handleMcpRequest(event, config, routePath = MCP_PUBLIC_ROU
         return buildUnauthorizedBody(event, routePath);
     }
     const body = method === "POST" ? await readBody(event) : undefined;
+    onMcpMethod?.(directoryLogMethod(body) ?? method);
     const initializeRequest = body
         ? (Array.isArray(body) ? body : [body]).find((m) => typeof m === "object" &&
             m !== null &&
@@ -266,6 +325,37 @@ export async function handleMcpRequest(event, config, routePath = MCP_PUBLIC_ROU
     const webRequest = buildWebRequest(event, method, routePath);
     return handler.fetch(webRequest, method === "POST" ? { parsedBody: body } : undefined);
 }
+export async function handleMcpRequest(event, config, routePath = MCP_PUBLIC_ROUTE_PREFIX) {
+    const pathname = event.url?.pathname || "/";
+    const subpath = pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+    const isDirectoryRequest = routePath === MCP_DIRECTORY_ROUTE_PREFIX && !subpath;
+    const startedAt = performance.now();
+    let method = getMethod(event);
+    let status = 500;
+    try {
+        const result = await handleMcpRequestInternal(event, config, routePath, (requestMethod) => {
+            method = requestMethod;
+        });
+        status =
+            result instanceof Response
+                ? result.status
+                : responseStatusFromEvent(event);
+        return result;
+    }
+    catch (error) {
+        status = responseStatusFromError(error) ?? 500;
+        throw error;
+    }
+    finally {
+        if (isDirectoryRequest) {
+            console.info("[mcp:directory] request", {
+                method,
+                status,
+                durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
+            });
+        }
+    }
+}
 export function mountMCP(nitroApp, config, routePrefix = "/_agent-native") {
     const routePaths = routePrefix === "/_agent-native"
         ? [...MCP_ROUTE_PREFIXES]

package/dist/onboarding/app-profile.js

@@ -7,7 +7,8 @@ const SYSTEM_ONE_CAPABILITY = {
     suggested: true,
     builderIncluded: true,
     keySummary: "Jev decision model key",
-    why: "Jev is an optional decision model that helps choose relevant tools and skills before the agent's first model request. Use Builder-managed access when available, or add a direct JEV_API_KEY.",
+    whyKey: "agentChat.onboarding.capability.systemOne.why",
+    why: "Jev is an optional decision model that helps choose relevant tools and skills before the agent's first model request.",
 };
 const PROFILES = {
     analytics: {

package/dist/onboarding/workspace-services.js

@@ -15,6 +15,7 @@ export const LLM_CAPABILITY = {
     keySummary: "Connect your own AI model",
     labelKey: "agentChat.settingsInfra.aiModel",
     keySummaryKey: "agentChat.onboarding.capability.llm.keySummary",
+    whyKey: "agentChat.onboarding.capability.llm.why",
     why: "The agent uses a language model to understand requests and produce answers.",
 };
 export const FILE_UPLOAD_STORAGE_CAPABILITY = {
@@ -26,6 +27,7 @@ export const FILE_UPLOAD_STORAGE_CAPABILITY = {
     keySummary: "File uploads and storage",
     labelKey: "agentChat.settingsShell.search.fileUploads",
     keySummaryKey: "agentChat.onboarding.capability.fileStorage.keySummary",
+    whyKey: "agentChat.onboarding.capability.fileStorage.why",
     why: "Uploaded images and files need durable object storage so the agent can reuse them throughout a thread.",
 };
 export const VOICE_INPUT_CAPABILITY = {
@@ -70,6 +72,7 @@ export const DESIGN_SYSTEM_INTELLIGENCE_CAPABILITY = {
     builderIncluded: true,
     keySummary: "Builder Design System Intelligence",
     labelKey: "agentChat.settingsInfra.designSystem",
+    whyKey: "agentChat.settingsInfra.whyDesignSystem",
     why: "Uses your brand and design-system guidance to keep generated work on brand.",
 };
 export const BACKGROUND_AGENTS_CAPABILITY = {

package/dist/org/context.d.ts

@@ -47,4 +47,17 @@ export declare function resolveOrgByDomain(domain: string): Promise<{
     orgId: string;
     orgName: string;
 } | null>;
+export declare function resolveA2AOrganizationMetadataByDomain(domain: string): Promise<{
+    orgId: string;
+    orgDomain: string | null;
+} | null>;
+export declare function resolveA2AOrganizationMetadataById(orgId: string): Promise<{
+    orgId: string;
+    orgDomain: string | null;
+} | null>;
+export declare function resolveA2AOrganizationCredentialsByDomain(domain: string): Promise<{
+    orgId: string;
+    orgDomain: string;
+    secret: string;
+} | null>;
 export declare function isSoleOrgDomain(domain: string): Promise<boolean>;

package/dist/org/context.js

@@ -743,6 +743,66 @@ export async function resolveOrgByDomain(domain) {
         return null;
     }
 }
+export async function resolveA2AOrganizationMetadataByDomain(domain) {
+    const normalizedDomain = domain.trim().toLowerCase();
+    if (!normalizedDomain)
+        return null;
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT id, allowed_domain
+          FROM organizations WHERE LOWER(allowed_domain) = ? LIMIT 1`,
+        args: [normalizedDomain],
+    });
+    const row = rows[0];
+    if (!row)
+        return null;
+    const orgId = String(row.id ?? "").trim();
+    const orgDomain = String(row.allowed_domain ?? "")
+        .trim()
+        .toLowerCase();
+    if (!orgId || !orgDomain || orgDomain !== normalizedDomain)
+        return null;
+    return { orgId, orgDomain };
+}
+export async function resolveA2AOrganizationMetadataById(orgId) {
+    const normalizedOrgId = orgId.trim();
+    if (!normalizedOrgId)
+        return null;
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT id, allowed_domain FROM organizations WHERE id = ? LIMIT 1`,
+        args: [normalizedOrgId],
+    });
+    const row = rows[0];
+    if (!row)
+        return null;
+    const resolvedOrgId = String(row.id ?? "").trim();
+    if (!resolvedOrgId || resolvedOrgId !== normalizedOrgId)
+        return null;
+    const rawDomain = String(row.allowed_domain ?? "")
+        .trim()
+        .toLowerCase();
+    return { orgId: resolvedOrgId, orgDomain: rawDomain || null };
+}
+export async function resolveA2AOrganizationCredentialsByDomain(domain) {
+    const normalizedDomain = domain.trim().toLowerCase();
+    if (!normalizedDomain)
+        return null;
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT id, allowed_domain, a2a_secret
+          FROM organizations WHERE LOWER(allowed_domain) = ? LIMIT 1`,
+        args: [normalizedDomain],
+    });
+    const row = rows[0];
+    if (!row)
+        return null;
+    const orgId = String(row.id ?? "").trim();
+    const orgDomain = String(row.allowed_domain ?? "")
+        .trim()
+        .toLowerCase();
+    const secret = String(row.a2a_secret ?? "").trim();
+    if (!orgId || orgDomain !== normalizedDomain || !secret)
+        return null;
+    return { orgId, orgDomain, secret };
+}
 export async function isSoleOrgDomain(domain) {
     try {
         const exec = getDbExec();

package/dist/org/handlers.d.ts

@@ -72,9 +72,9 @@ export declare const setWorkspaceAppDefaultVisibilityHandler: import("h3").Event
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     success: boolean;
+    id?: undefined;
     name?: undefined;
     role?: undefined;
-    id?: undefined;
 } | {
     success?: undefined;
     id: string;

package/dist/org/index.d.ts

@@ -179,8 +179,8 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     name?: undefined;
     success: boolean;
-    role?: undefined;
     id?: undefined;
+    role?: undefined;
 } | {
     success?: undefined;
     id: string;