@agent-native/core 0.201.1-nightly-20261005213104 → 0.201.1

package/dist/provider-api/actions/provider-api.d.ts

@@ -311,10 +311,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        provider?: undefined;
+        id?: undefined;
         deleted?: undefined;
         message?: undefined;
-        id?: undefined;
         providers: {
             id: string;
             label: string;
@@ -325,44 +324,45 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
+        provider?: undefined;
         found?: undefined;
         registered?: undefined;
         label?: undefined;
     } | {
+        id?: undefined;
         count?: undefined;
         deleted?: undefined;
         message?: undefined;
-        id?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
         count?: undefined;
         deleted?: undefined;
         message?: undefined;
         providers?: undefined;
+        provider?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
         count?: undefined;
         message?: undefined;
         providers?: undefined;
+        provider?: undefined;
         found?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
         count?: undefined;
         deleted?: undefined;
         providers?: undefined;
+        provider?: undefined;
         found?: undefined;
         registered: boolean;
         id: string;

package/dist/resources/handlers.d.ts

@@ -39,8 +39,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
     error: string;
 }>;
 export declare function handleDeleteResource(event: any): Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.d.ts

@@ -58,47 +58,47 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     error: string;
     errorCode?: undefined;
     retryable?: undefined;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error: string;
     errorCode: string;
     retryable?: undefined;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error: string;
     errorCode: string;
     retryable: boolean;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     errorCode?: undefined;
     retryable?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -126,11 +126,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/action-routes.js

@@ -1,13 +1,14 @@
 import { createError, defineEventHandler, setResponseStatus, setResponseHeader, getMethod, getQuery, getHeader, readBody as readH3Body, } from "h3";
 import "../authorization/check-action.js";
 import { verifyA2ATokenWithClaims } from "../a2a-claims.js";
+import { isA2AIdentityVerificationUnavailableError } from "../a2a/server.js";
 import { actionCallEmitsChange, actionChangeResource, } from "../action-call-classification.js";
 import { ActionContractError, isActionContractError, isActionExposedToExternalAgents, isAgentActionStopError, validateActionArgs, } from "../action.js";
 import { LLM_CREDENTIAL_KEYS, LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "../agent/engine/credential-errors.js";
 import { isTransientDatabaseError } from "../db/client.js";
 import { declaresFeatureFlagDelegation } from "../feature-flags/a2a-action-route.js";
 import { isFeatureFlagAdminEmail } from "../feature-flags/permissions.js";
-import { isFederationMembershipValidatedForEvent, resolveOrgByDomain, resolveOrgIdForEmail, } from "../org/context.js";
+import { isFederationMembershipValidatedForEvent, resolveOrgIdForEmail, } from "../org/context.js";
 import { LLM_PROVIDER_MISSING_ERROR_CODE, LLM_PROVIDER_MISSING_STATUS, } from "../shared/action-error-codes.js";
 import { agentNativeMcpInstructions, agentNativeToolTitle, } from "../shared/agent-mcp-metadata.js";
 import { EMBED_TARGET_HEADER, EMBED_TARGET_QUERY_PARAM, EMBED_TOKEN_QUERY_PARAM, } from "../shared/embed-auth.js";
@@ -66,8 +67,8 @@ async function resolveFeatureFlagA2ACaller(event, actionName) {
     const claims = await verifyA2ATokenWithClaims(token, event);
     if (!claims || !claims.scope.includes(required))
         throw new Error("Invalid feature flag delegation");
-    const localOrg = await resolveOrgByDomain(claims.orgDomain);
-    if (!localOrg && !isFeatureFlagAdminEmail(claims.email))
+    const orgId = claims.orgId?.trim() || null;
+    if (!orgId && !isFeatureFlagAdminEmail(claims.email))
         throw new Error("Invalid feature flag delegation");
     if (actionName === "set-feature-flag" &&
         (await consumeOneTimeJti(claims.jti))) {
@@ -75,7 +76,7 @@ async function resolveFeatureFlagA2ACaller(event, actionName) {
     }
     return {
         owner: claims.email,
-        orgId: localOrg?.orgId ?? null,
+        orgId,
         anonymous: false,
         delegationJti: claims.jti,
         delegationIssuer: claims.issuer,
@@ -386,7 +387,13 @@ function mountActionRoutesInternal(nitroApp, actions, options) {
                     if (!caller)
                         caller = await resolveFeatureFlagA2ACaller(event, name);
                 }
-                catch {
+                catch (error) {
+                    if (isA2AIdentityVerificationUnavailableError(error)) {
+                        throw createError({
+                            statusCode: 503,
+                            statusMessage: "Identity verification temporarily unavailable",
+                        });
+                    }
                     throw createError({
                         statusCode: 401,
                         statusMessage: "Unauthorized",

package/dist/server/agent-engine-default-model-route.d.ts

@@ -16,9 +16,9 @@ export declare function createAgentEngineDisconnectHandler(): import("h3").Event
     error: any;
     scope?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     scope: "org" | "user";
+    error?: undefined;
 }>>;
 export interface DefaultModelSelectionRequest {
     engine: string;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,9 +1,9 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     models?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     models: string[];
+    error?: undefined;
 }>>;

package/dist/server/builder-browser.d.ts

@@ -43,8 +43,8 @@ export declare class BuilderAccountProvisioningError extends Error {
 export declare function isBuilderAccountAlreadyExistsError(error: unknown): boolean;
 export declare function createBuilderConnectState(): string;
 export declare function isSignedBuilderConnectState(value: string | null | undefined): boolean;
-export declare function isBuilderConnectCallbackUrlAllowed(candidate: string, event: H3Event): boolean;
-export declare function resolveBuilderConnectCallbackUrl(event: H3Event, state?: string): string | null;
+export declare function isBuilderConnectCallbackUrlAllowed(candidate: string, event: H3Event, callbackOriginOverride?: string): boolean;
+export declare function resolveBuilderConnectCallbackUrl(event: H3Event, state?: string, callbackOriginOverride?: string): string | null;
 export declare function isSafeBuilderRelayTargetOrigin(value: string): boolean;
 export declare function isTrustedBuilderRelayTargetOrigin(value: string): boolean;
 export declare function resolveBuilderPreviewRelayTargetOrigin(previewOrigin: string): string;
@@ -94,6 +94,7 @@ export declare const BUILDER_AGENT_NATIVE_CONNECT_SOURCE_PARAM = "agentNativeCon
 export declare const BUILDER_AGENT_NATIVE_APP_PARAM = "agentNativeApp";
 export declare const BUILDER_AGENT_NATIVE_TEMPLATE_PARAM = "agentNativeTemplate";
 export declare const BUILDER_CONNECT_MODE_PARAM = "_an_mode";
+export declare const BUILDER_PREVIEW_ORIGIN_HEADER = "x-agent-native-preview-origin";
 export declare const BUILDER_AGENT_NATIVE_PROVISION_MODE = "agent-native";
 export declare const BUILDER_PROVISIONING_TOKEN_PARAM = "_an_provision";
 export declare const BUILDER_CONNECT_ATTEMPT_PARAM = "_an_connect_attempt";
@@ -207,6 +208,7 @@ export declare function buildBuilderCliAuthUrl(callbackOrigin: string, state?: s
 }): string;
 export declare function getBuilderBrowserConnectUrl(origin: string): string;
 export declare function getBuilderBrowserConnectUrlForOwner(origin: string, ownerEmail: string | null | undefined): string;
+export declare function getBuilderConnectCallbackOriginFromUrl(callbackUrl: string): string | null;
 export declare function getBuilderBrowserOriginForEvent(event: H3Event): string;
 export declare function getBuilderCliAuthCallbackOriginForEvent(event: H3Event): string;
 export declare function getBuilderBrowserStatus(origin: string): BuilderBrowserStatus;

package/dist/server/builder-browser.js

@@ -1,5 +1,5 @@
 import { createHash, createHmac, randomBytes, timingSafeEqual, } from "node:crypto";
-import { getHeader, getRequestIP, setResponseHeader, setResponseStatus, } from "h3";
+import { getHeader, getQuery, getRequestIP, setResponseHeader, setResponseStatus, } from "h3";
 import { ActionContractError } from "../action.js";
 import { getSetting } from "../settings/store.js";
 import { applyBuilderUtmTrackingParams } from "../shared/builder-link-tracking.js";
@@ -112,8 +112,8 @@ export function isSignedBuilderConnectState(value) {
         return safeEqualText(expected, signature);
     });
 }
-export function isBuilderConnectCallbackUrlAllowed(candidate, event) {
-    const callbackOrigin = getBuilderConnectCallbackOrigin(event);
+export function isBuilderConnectCallbackUrlAllowed(candidate, event, callbackOriginOverride) {
+    const callbackOrigin = getBuilderConnectCallbackOrigin(event, callbackOriginOverride);
     if (!callbackOrigin ||
         !isAllowedOAuthRedirectUri(candidate, event, callbackOrigin))
         return false;
@@ -137,16 +137,18 @@ export function isBuilderConnectCallbackUrlAllowed(candidate, event) {
     }
     return url.protocol === "https:";
 }
-export function resolveBuilderConnectCallbackUrl(event, state) {
+export function resolveBuilderConnectCallbackUrl(event, state, callbackOriginOverride) {
     const stateSuffix = state ? `?state=${encodeURIComponent(state)}` : "";
-    const callbackOrigin = getBuilderConnectCallbackOrigin(event);
+    const callbackOrigin = getBuilderConnectCallbackOrigin(event, callbackOriginOverride);
     if (!callbackOrigin)
         return null;
     const withBase = `${callbackOrigin}${getAppBasePath()}${BUILDER_CALLBACK_PATH}${stateSuffix}`;
-    if (isBuilderConnectCallbackUrlAllowed(withBase, event))
+    if (isBuilderConnectCallbackUrlAllowed(withBase, event, callbackOriginOverride)) {
         return withBase;
+    }
     const root = `${callbackOrigin}${BUILDER_CALLBACK_PATH}${stateSuffix}`;
-    if (root !== withBase && isBuilderConnectCallbackUrlAllowed(root, event)) {
+    if (root !== withBase &&
+        isBuilderConnectCallbackUrlAllowed(root, event, callbackOriginOverride)) {
         return root;
     }
     return null;
@@ -429,6 +431,9 @@ export const BUILDER_AGENT_NATIVE_CONNECT_SOURCE_PARAM = "agentNativeConnectSour
 export const BUILDER_AGENT_NATIVE_APP_PARAM = "agentNativeApp";
 export const BUILDER_AGENT_NATIVE_TEMPLATE_PARAM = "agentNativeTemplate";
 export const BUILDER_CONNECT_MODE_PARAM = "_an_mode";
+export const BUILDER_PREVIEW_ORIGIN_HEADER = "x-agent-native-preview-origin";
+const BUILDER_PREVIEW_ORIGIN_PARAM = "_an_preview_origin";
+const BUILDER_PREVIEW_ORIGIN_SIGNATURE_PARAM = "_an_preview_origin_signature";
 export const BUILDER_AGENT_NATIVE_PROVISION_MODE = "agent-native";
 export const BUILDER_PROVISIONING_TOKEN_PARAM = "_an_provision";
 export const BUILDER_CONNECT_ATTEMPT_PARAM = "_an_connect_attempt";
@@ -958,7 +963,15 @@ function isConfiguredBuilderRequestHost(event, host) {
         (process.env.NODE_ENV === "production" ? "https" : "http");
     return isConfiguredAppOrigin(`${proto}://${host}`);
 }
-function getBuilderConnectCallbackOrigin(event) {
+function getBuilderConnectCallbackOrigin(event, originOverride) {
+    if (originOverride) {
+        return isAllowedBuilderConnectOrigin(originOverride)
+            ? originOverride
+            : null;
+    }
+    const signedPreviewOrigin = getSignedBuilderPreviewOriginFromEvent(event);
+    if (signedPreviewOrigin)
+        return signedPreviewOrigin;
     const requestHost = firstHeaderValue(readEventHeader(event, "host"));
     const headerHost = getBuilderRequestHost(event);
     if (isRejectedDirectBuilderCloudHost(requestHost, headerHost)) {
@@ -978,6 +991,123 @@ function getBuilderConnectCallbackOrigin(event) {
     }
     return configuredOrigin;
 }
+function isAllowedBuilderConnectOrigin(origin) {
+    let url;
+    try {
+        url = new URL(origin);
+    }
+    catch {
+        // coercion-ok: a malformed callback origin is explicitly rejected.
+        return false;
+    }
+    if (url.origin !== origin ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash) {
+        return false;
+    }
+    if (isTrustedBuilderRequestHost(url.host)) {
+        return (url.protocol === "https:" ||
+            (url.protocol === "http:" && process.env.NODE_ENV !== "production"));
+    }
+    return isConfiguredAppOrigin(origin);
+}
+function normalizeBuilderPreviewOrigin(value) {
+    try {
+        const url = new URL(value);
+        if (url.origin !== value ||
+            url.username ||
+            url.password ||
+            url.pathname !== "/" ||
+            url.search ||
+            url.hash ||
+            (url.protocol !== "https:" &&
+                !(url.protocol === "http:" && process.env.NODE_ENV !== "production"))) {
+            return null;
+        }
+        return url.origin;
+    }
+    catch {
+        // coercion-ok: a malformed preview origin is not an allowed origin.
+        return null;
+    }
+}
+function getSameOriginBuilderPreviewOrigin(event) {
+    const rawOrigin = firstHeaderValue(readEventHeader(event, BUILDER_PREVIEW_ORIGIN_HEADER));
+    if (!rawOrigin || readEventHeader(event, "sec-fetch-site") === "cross-site") {
+        return null;
+    }
+    const origin = normalizeBuilderPreviewOrigin(rawOrigin);
+    if (!origin || !isTrustedBuilderRequestHost(new URL(origin).host)) {
+        return null;
+    }
+    const requestHost = firstHeaderValue(readEventHeader(event, "host"));
+    if (!requestHost ||
+        (!isLoopbackBuilderRequestHost(requestHost) &&
+            requestHost.toLowerCase() !== new URL(origin).host.toLowerCase())) {
+        return null;
+    }
+    const fetchSite = readEventHeader(event, "sec-fetch-site");
+    const requestOrigin = firstHeaderValue(readEventHeader(event, "origin"));
+    if (fetchSite === "same-origin" || requestOrigin === origin)
+        return origin;
+    const referer = firstHeaderValue(readEventHeader(event, "referer"));
+    if (!referer)
+        return null;
+    try {
+        return new URL(referer).origin === origin ? origin : null;
+    }
+    catch {
+        // coercion-ok: an unreadable Referer cannot authorize a preview origin.
+        return null;
+    }
+}
+function signBuilderPreviewOrigin(origin) {
+    return createHmac("sha256", builderConnectStateSigningKeys()[0])
+        .update(`builder-connect-preview-origin\0${origin}`)
+        .digest("base64url");
+}
+function getSignedBuilderPreviewOriginFromEvent(event) {
+    const query = getQuery(event);
+    const rawOrigin = query[BUILDER_PREVIEW_ORIGIN_PARAM];
+    const signature = query[BUILDER_PREVIEW_ORIGIN_SIGNATURE_PARAM];
+    if (typeof rawOrigin !== "string" || typeof signature !== "string") {
+        return null;
+    }
+    const origin = normalizeBuilderPreviewOrigin(rawOrigin);
+    if (!origin || !isTrustedBuilderRequestHost(new URL(origin).host)) {
+        return null;
+    }
+    const requestHost = firstHeaderValue(readEventHeader(event, "host"));
+    if (!requestHost ||
+        (!isLoopbackBuilderRequestHost(requestHost) &&
+            requestHost.toLowerCase() !== new URL(origin).host.toLowerCase())) {
+        return null;
+    }
+    return builderConnectStateSigningKeys().some((key) => safeEqualText(createHmac("sha256", key)
+        .update(`builder-connect-preview-origin\0${origin}`)
+        .digest("base64url"), signature))
+        ? origin
+        : null;
+}
+function addSignedBuilderPreviewOrigin(url, origin) {
+    const parsed = new URL(url);
+    parsed.searchParams.set(BUILDER_PREVIEW_ORIGIN_PARAM, origin);
+    parsed.searchParams.set(BUILDER_PREVIEW_ORIGIN_SIGNATURE_PARAM, signBuilderPreviewOrigin(origin));
+    return parsed.toString();
+}
+export function getBuilderConnectCallbackOriginFromUrl(callbackUrl) {
+    try {
+        const origin = new URL(callbackUrl).origin;
+        return isAllowedBuilderConnectOrigin(origin) ? origin : null;
+    }
+    catch {
+        // coercion-ok: a malformed stored callback URL must fail verification.
+        return null;
+    }
+}
 function isRejectedDirectBuilderCloudHost(requestHost, resolvedHost) {
     return isBuilderCloudRequestHost(requestHost) && requestHost !== resolvedHost;
 }
@@ -986,6 +1116,9 @@ function getConfiguredBuilderFallbackOrigin(event) {
     return isConfiguredAppOrigin(origin) ? origin : null;
 }
 export function getBuilderBrowserOriginForEvent(event) {
+    const signedPreviewOrigin = getSignedBuilderPreviewOriginFromEvent(event);
+    if (signedPreviewOrigin)
+        return signedPreviewOrigin;
     const requestHost = firstHeaderValue(readEventHeader(event, "host"));
     const headerHost = getBuilderRequestHost(event);
     if (isRejectedDirectBuilderCloudHost(requestHost, headerHost)) {
@@ -1057,7 +1190,12 @@ function parseOptionalEnvBoolean(value) {
     return /^(1|true)$/i.test(value);
 }
 export function getBuilderBrowserStatusForEvent(event) {
-    return getBuilderBrowserStatus(getBuilderBrowserOriginForEvent(event));
+    const previewOrigin = getSameOriginBuilderPreviewOrigin(event);
+    const status = getBuilderBrowserStatus(previewOrigin ?? getBuilderBrowserOriginForEvent(event));
+    if (previewOrigin && status.connectUrl) {
+        status.connectUrl = addSignedBuilderPreviewOrigin(status.connectUrl, previewOrigin);
+    }
+    return status;
 }
 export const BUILDER_ENV_KEYS = [
     "BUILDER_PRIVATE_KEY",

package/dist/server/core-routes-plugin.js

@@ -59,7 +59,7 @@ import { getSession } from "./auth.js";
 import { createAutomationFailureUnsubscribeHandler } from "./automation-failure-notifications.js";
 import { getBetterAuthInternalAdapter, getBetterAuthSync, } from "./better-auth-instance.js";
 import { resolveBuilderRequestAuthorization } from "./builder-api-auth.js";
-import { BUILDER_CONNECT_PARAM, BUILDER_CONNECT_MODE_PARAM, BUILDER_AGENT_NATIVE_PROVISION_MODE, BUILDER_CONNECT_ATTEMPT_PARAM, BUILDER_CONNECT_STATE_COOKIE, BUILDER_ENV_KEYS, BUILDER_OPENER_PARAM, BUILDER_RELAY_FLOW_HEADER, BUILDER_RELAY_SIGNATURE_HEADER, BUILDER_RELAY_STATE_PARAM, BUILDER_RELAY_TIMESTAMP_HEADER, appendBuilderConnectToken, appendBuilderConnectStateCookie, builderConnectTrackingProperties, BUILDER_UPSTREAM_FAILURE_STATUS, createBuilderConnectState, createBuilderBrowserCallbackErrorPage, createBuilderBrowserCallbackPage, createBuilderRelayRequest, getBuilderConnectTrackingParams, getBuilderBrowserOriginForEvent, getBuilderBrowserStatusForEvent, isBuilderAccountAlreadyExistsError, isBuilderAccountProvisioningEnabled, isBuilderConnectCallbackUrlAllowed, isSignedBuilderConnectState, normalizeBuilderAgentContext, parseBuilderConnectStateCookie, provisionBuilderAccount, resolveBuilderBranchProjectId, resolveBuilderConnectCallbackUrl, resolveBuilderConnectCallbackState, resolveBuilderPreviewRelayParentOrigin, removeBuilderConnectStateCookie, runBuilderAgent, sendBuilderPopupErrorPage, verifyBuilderRelayRequest, verifyBuilderPreviewRelayStateForCallback, verifyBuilderConnectTokenAndGetOwner, signBuilderProvisioningToken, verifyBuilderProvisioningToken, withBuilderConnectTrackingParams, } from "./builder-browser.js";
+import { BUILDER_CONNECT_PARAM, BUILDER_CONNECT_MODE_PARAM, BUILDER_AGENT_NATIVE_PROVISION_MODE, BUILDER_CONNECT_ATTEMPT_PARAM, BUILDER_CONNECT_STATE_COOKIE, BUILDER_ENV_KEYS, BUILDER_OPENER_PARAM, BUILDER_RELAY_FLOW_HEADER, BUILDER_RELAY_SIGNATURE_HEADER, BUILDER_RELAY_STATE_PARAM, BUILDER_RELAY_TIMESTAMP_HEADER, appendBuilderConnectToken, appendBuilderConnectStateCookie, builderConnectTrackingProperties, BUILDER_UPSTREAM_FAILURE_STATUS, createBuilderConnectState, createBuilderBrowserCallbackErrorPage, createBuilderBrowserCallbackPage, createBuilderRelayRequest, getBuilderConnectCallbackOriginFromUrl, getBuilderConnectTrackingParams, getBuilderBrowserOriginForEvent, getBuilderBrowserStatusForEvent, isBuilderAccountAlreadyExistsError, isBuilderAccountProvisioningEnabled, isBuilderConnectCallbackUrlAllowed, isSignedBuilderConnectState, normalizeBuilderAgentContext, parseBuilderConnectStateCookie, provisionBuilderAccount, resolveBuilderBranchProjectId, resolveBuilderConnectCallbackUrl, resolveBuilderConnectCallbackState, resolveBuilderPreviewRelayParentOrigin, removeBuilderConnectStateCookie, runBuilderAgent, sendBuilderPopupErrorPage, verifyBuilderRelayRequest, verifyBuilderPreviewRelayStateForCallback, verifyBuilderConnectTokenAndGetOwner, signBuilderProvisioningToken, verifyBuilderProvisioningToken, withBuilderConnectTrackingParams, } from "./builder-browser.js";
 import { BUILDER_ASSETS_WRITE_SCOPE, BUILDER_OAUTH_SCOPE, builderOAuthScopeFor, canRoleConnectPersonalBuilder, deleteBuilderOAuthSession, exchangeBuilderOAuthAuthorization, getBuilderOAuthGrants, getBuilderOAuthStoredScope, hasStoredBuilderOAuthGrant, isBuilderOrgManagerRole, isPersonalBuilderGrantAllowed, saveBuilderOAuthCredentials, startBuilderOAuthAuthorization, } from "./builder-oauth.js";
 import { captureError, registerErrorCaptureProvider } from "./capture-error.js";
 import { createChatGPTSubscriptionOAuthCallbackHandler, createChatGPTSubscriptionOAuthStartHandler, } from "./chatgpt-subscription-oauth.js";
@@ -3472,7 +3472,8 @@ export function createCoreRoutesPlugin(options = {}) {
                     ? await selectLiveBuilderConnectStates(cookieStates)
                     : cookieStates;
                 const { state, resetStateCookie } = resolveBuilderConnectCallbackState(queryState, liveStates ? liveStates.join(",") : rawStateCookie);
-                const parentOrigin = getBuilderBrowserOriginForEvent(event);
+                let parentOrigin = getBuilderBrowserOriginForEvent(event);
+                let callbackOriginOverride;
                 let callbackAttemptId = requestConnectAttemptId;
                 // A finished attempt — succeeded or failed — must not leave its
                 // state in the cookie, or the next restart resolves against two
@@ -3492,8 +3493,7 @@ export function createCoreRoutesPlugin(options = {}) {
                     }
                     setCookie(event, BUILDER_CONNECT_STATE_COOKIE, remaining, {
                         httpOnly: true,
-                        secure: (resolveBuilderConnectCallbackUrl(event, finishedState) ??
-                            parentOrigin).startsWith("https://"),
+                        secure: (resolveBuilderConnectCallbackUrl(event, finishedState, callbackOriginOverride) ?? parentOrigin).startsWith("https://"),
                         sameSite: "lax",
                         path: "/",
                         maxAge: Math.ceil(BUILDER_CONNECT_PENDING_TTL_MS / 1_000),
@@ -3553,7 +3553,14 @@ export function createCoreRoutesPlugin(options = {}) {
                 const redirectUri = typeof pending.redirectUri === "string"
                     ? pending.redirectUri
                     : null;
-                const expectedRedirectUri = resolveBuilderConnectCallbackUrl(event, state);
+                const storedCallbackOrigin = redirectUri
+                    ? getBuilderConnectCallbackOriginFromUrl(redirectUri)
+                    : null;
+                if (storedCallbackOrigin) {
+                    callbackOriginOverride = storedCallbackOrigin;
+                    parentOrigin = storedCallbackOrigin;
+                }
+                const expectedRedirectUri = resolveBuilderConnectCallbackUrl(event, state, callbackOriginOverride);
                 if (!ownerEmail ||
                     !isBuilderConnectCallbackOwner(ownerEmail, session?.email) ||
                     Date.now() >= expiresAt ||
@@ -3561,7 +3568,7 @@ export function createCoreRoutesPlugin(options = {}) {
                     !redirectUri ||
                     !expectedRedirectUri ||
                     redirectUri !== expectedRedirectUri ||
-                    !isBuilderConnectCallbackUrlAllowed(redirectUri, event)) {
+                    !isBuilderConnectCallbackUrlAllowed(redirectUri, event, callbackOriginOverride)) {
                     if (Date.now() >= expiresAt) {
                         await deleteSetting(`builder-connect-pending:${state}`).catch(() => false); // coercion-ok: expired pending cleanup is best-effort; callback already failed verification
                     }

package/dist/server/entry-server.js

@@ -2,8 +2,49 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import ReactDOMServer from "react-dom/server.browser";
 const { renderToReadableStream } = ReactDOMServer;
 import { isbot } from "isbot";
+import { ROUTE_CHUNK_RECOVERY_BOOTSTRAP_SCRIPT } from "../shared/route-chunk-recovery-bootstrap.js";
 import { wrapWithAnalytics } from "./analytics.js";
 export const streamTimeout = 5_000;
+const HEAD_OPEN_PATTERN = /<head\b[^>]*>/i;
+const CHUNK_RECOVERY_BOOTSTRAP_TAG = `<script data-agent-native-chunk-recovery-bootstrap>${ROUTE_CHUNK_RECOVERY_BOOTSTRAP_SCRIPT}</script>`;
+function installEarlyChunkRecoveryBootstrap(body) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let pending = "";
+    let injected = false;
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            pending += decoder.decode(chunk, { stream: true });
+            if (!injected) {
+                const headOpenMatch = HEAD_OPEN_PATTERN.exec(pending);
+                if (!headOpenMatch || headOpenMatch.index === undefined)
+                    return;
+                const headEnd = headOpenMatch.index + headOpenMatch[0].length;
+                controller.enqueue(encoder.encode(pending.slice(0, headEnd) + CHUNK_RECOVERY_BOOTSTRAP_TAG));
+                pending = pending.slice(headEnd);
+                injected = true;
+            }
+            if (pending) {
+                controller.enqueue(encoder.encode(pending));
+                pending = "";
+            }
+        },
+        flush(controller) {
+            pending += decoder.decode();
+            if (!injected) {
+                const headOpenMatch = HEAD_OPEN_PATTERN.exec(pending);
+                if (headOpenMatch && headOpenMatch.index !== undefined) {
+                    const headEnd = headOpenMatch.index + headOpenMatch[0].length;
+                    controller.enqueue(encoder.encode(pending.slice(0, headEnd) + CHUNK_RECOVERY_BOOTSTRAP_TAG));
+                    pending = pending.slice(headEnd);
+                    injected = true;
+                }
+            }
+            if (pending)
+                controller.enqueue(encoder.encode(pending));
+        },
+    }));
+}
 export function createDocumentRequestHandler(ServerRouter) {
     return async function handleDocumentRequest(request, responseStatusCode, responseHeaders, routerContext, _loadContext) {
         if (request.method.toUpperCase() === "HEAD") {
@@ -33,8 +74,8 @@ export function createDocumentRequestHandler(ServerRouter) {
             if (waitForAll) {
                 await body.allReady;
             }
-            responseHeaders.set("Content-Type", "text/html");
-            return new Response(wrapWithAnalytics(body), {
+            responseHeaders.set("Content-Type", "text/html; charset=utf-8");
+            return new Response(wrapWithAnalytics(installEarlyChunkRecoveryBootstrap(body)), {
                 headers: responseHeaders,
                 status: responseStatusCode,
             });

package/dist/server/sentry.js

@@ -258,8 +258,10 @@ export function setSentryRequestContext(ctx) {
 export function captureAuthError(error, context) {
     if (getRequestContext()?.isSyntheticTraffic)
         return undefined;
-    if (!_initSucceeded || !Sentry)
+    if (!_initSucceeded || !Sentry) {
+        logSignupErrorWhenSentryUnavailable(context.route);
         return undefined;
+    }
     const sentry = Sentry;
     try {
         return sentry.withScope((scope) => {
@@ -274,9 +276,15 @@ export function captureAuthError(error, context) {
         });
     }
     catch {
+        logSignupErrorWhenSentryUnavailable(context.route);
         return undefined;
     }
 }
+function logSignupErrorWhenSentryUnavailable(route) {
+    if (route !== "signup")
+        return;
+    console.error("[agent-native][auth] signup error (Sentry unavailable)");
+}
 export function captureRouteError(error, context = {}) {
     if (getRequestContext()?.isSyntheticTraffic)
         return undefined;

package/dist/server/ssr-handler.d.ts

@@ -1,2 +1,2 @@
-export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
+export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrNetlifyQueryVary, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
 export declare function createH3SSRHandler(getBuild: () => unknown): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<Response>>;

package/dist/server/ssr-handler.js

@@ -13,7 +13,7 @@ import { getFrameworkRoutePrefix } from "./framework-route-prefix.js";
 import { getPostHogClientConfigScript } from "./posthog-config.js";
 import { runWithRequestContext } from "./request-context.js";
 import { getRealtimeClientConfigScript, getSentryClientConfigScript, } from "./sentry-config.js";
-export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
+export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrNetlifyQueryVary, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
 function getAppBasePath() {
     return getAppBasePathFromViteEnv();
 }
@@ -215,12 +215,8 @@ function applyDefaultSsrCacheHeader(headers, status, pathname) {
     for (const [name, value] of Object.entries(resolveSsrCacheHeaders())) {
         headers.set(name, value);
     }
-    const cacheKeyHeaders = resolveSsrCacheKeyHeaders();
-    const netlifyVary = varyByQuery
-        ? cacheKeyHeaders["netlify-vary"]
-            ? "query"
-            : undefined
-        : cacheKeyHeaders["netlify-vary"];
+    const cacheKeyHeaders = resolveSsrCacheKeyHeaders(undefined, { varyByQuery });
+    const netlifyVary = cacheKeyHeaders["netlify-vary"];
     if (netlifyVary)
         headers.set("netlify-vary", netlifyVary);
     else

package/dist/shared/cache-control.d.ts

@@ -32,7 +32,10 @@ export type SsrCacheHeaders = Record<"cache-control" | "cdn-cache-control" | "ne
 export declare function parseSsrCacheSetting(raw: string | undefined | null): SsrCachePolicy;
 export declare function ssrCacheHeadersForPolicy(policy: SsrCachePolicy): SsrCacheHeaders;
 export declare function resolveSsrCacheHeaders(env?: Record<string, string | undefined>): Readonly<SsrCacheHeaders>;
-export declare function resolveSsrCacheKeyHeaders(env?: Record<string, string | undefined>): Readonly<Record<string, string>>;
+export declare function resolveSsrNetlifyQueryVary(varyByQuery?: boolean): string;
+export declare function resolveSsrCacheKeyHeaders(env?: Record<string, string | undefined>, options?: {
+    varyByQuery?: boolean;
+}): Readonly<Record<string, string>>;
 export declare function isSsrCacheEnabled(env?: Record<string, string | undefined>): boolean;
 export declare const DEFAULT_SPECULATION_RULES_PATH = "/_agent-native/speculation-rules.json";
 export declare const DEFAULT_SPECULATION_RULES_HEADER = "\"/_agent-native/speculation-rules.json\"";