@agent-native/core 0.221.0 → 0.221.1-nightly-20261028032829

package/dist/client/agent-chat.js

@@ -4,6 +4,7 @@ import { parseBase64DataUrl } from "../shared/data-url.js";
 import { trackEvent } from "./analytics.js";
 import { agentNativePath } from "./api-path.js";
 import { readClientAppState, writeClientAppState, } from "./application-state.js";
+import { getBrowserTabId } from "./browser-tab-id.js";
 import { isInBuilderFrame, isTrustedBuilderMessage, sendToBuilderChat, } from "./builder-frame.js";
 import { trackRoutedTurnSubmitted } from "./chat/turn-submitted-telemetry.js";
 import { DEFAULT_TURN_SURFACE } from "./chat/turn-submitted.js";
@@ -662,7 +663,11 @@ function dispatchAgentChatRunning(isRunning, tabId) {
     if (typeof window === "undefined")
         return;
     window.dispatchEvent(new CustomEvent("agentNative.chatRunning", {
-        detail: { isRunning, ...(tabId ? { tabId } : {}) },
+        detail: {
+            isRunning,
+            ...(tabId ? { tabId } : {}),
+            browserTabId: getBrowserTabId(),
+        },
     }));
 }
 function normalizeAgentChatRequestMode(value) {

package/dist/client/api-path.d.ts

@@ -15,6 +15,8 @@ export declare function isWorkspaceRuntime(): boolean;
  * keep the basename supplied by the server instead of guessing from the URL.
  */
 export declare function configureClientRouterBasename(): boolean;
+export declare function resolveExternalEmbedTargetAppBasePath(target: string): string | undefined;
+export declare function resolveAppBasePath(): string;
 export declare function appBasePath(): string;
 export declare function isWorkspaceAppPath(path: string): boolean;
 export declare function appMountPath(appLocalRoute: string): string;

package/dist/client/api-path.js

@@ -1,4 +1,5 @@
 import { FRAMEWORK_INTERNAL_ROUTE_PREFIX, matchesPathPrefix, normalizeFrameworkRoutePrefix, SERVER_ROUTE_PREFIXES, toPublicFrameworkPath, } from "../shared/framework-route-prefix.js";
+import { resolveExternalEmbedTargetBasePath, resolveWorkspaceAppMountPath, } from "../shared/mcp-app-widget-embed.js";
 import { isTruthyRuntimeValue } from "../shared/runtime-config.js";
 import { injectedAgentNativeConfig } from "./app-config.js";
 import { initializeAgentNativeClient } from "./client-bootstrap.js";
@@ -69,10 +70,6 @@ function frameworkMarkerIndex(pathname) {
     }
     return -1;
 }
-function isFrameworkSegment(segment) {
-    return (`/${segment}` === FRAMEWORK_INTERNAL_ROUTE_PREFIX ||
-        `/${segment}` === frameworkRoutePrefix());
-}
 function pathDerivedBasePath() {
     if (typeof window === "undefined" ||
         typeof window.location?.pathname !== "string") {
@@ -106,7 +103,8 @@ function hasExplicitWorkspaceRootPath() {
         return false;
     const config = window;
     const env = clientEnv();
-    return (isDeclaredRootPath(config.__AGENT_NATIVE_CONFIG__?.workspaceAppPath) ||
+    return (config.__AGENT_NATIVE_CONFIG__?.explicitRootPath === true ||
+        isDeclaredRootPath(config.__AGENT_NATIVE_CONFIG__?.workspaceAppPath) ||
         isDeclaredRootPath(env?.VITE_APP_BASE_PATH ?? env?.APP_BASE_PATH));
 }
 export function isWorkspaceRuntime() {
@@ -125,38 +123,21 @@ function workspacePathBasePath(fallbackPath = "") {
     const pathname = window.location?.pathname;
     if (typeof pathname !== "string")
         return "";
-    const routerBasePath = routerContextBasePath();
-    if (routerBasePath && pathMatchesBasePath(pathname, routerBasePath)) {
-        return routerBasePath;
-    }
-    const configuredWorkspacePath = workspaceAppConfiguredPath();
-    if (configuredWorkspacePath &&
-        pathMatchesBasePath(pathname, configuredWorkspacePath)) {
-        return configuredWorkspacePath;
-    }
     const segment = pathname.split("/").find(Boolean);
+    const mounts = workspaceAppMountPaths();
+    const resolved = resolveWorkspaceAppMountPath(pathname, {
+        routerBasePath: routerContextBasePath(),
+        workspaceAppPath: workspaceAppConfiguredPath(),
+        workspaceAppMountPaths: mounts ? [...mounts] : undefined,
+        fallbackPath,
+        explicitRootPath: hasExplicitWorkspaceRootPath(),
+        frameworkRoutePrefix: frameworkRoutePrefix(),
+    });
+    if (resolved !== undefined)
+        return resolved;
     if (!segment) {
-        if (hasExplicitWorkspaceRootPath())
-            return "";
-        if (fallbackPath)
-            return fallbackPath;
         throw new WorkspaceAppMountResolutionError("Cannot resolve workspace app mount path without explicit mount metadata.");
     }
-    if (isFrameworkSegment(segment) || segment === "api") {
-        return fallbackPath;
-    }
-    if (hasExplicitWorkspaceRootPath())
-        return "";
-    const mounts = workspaceAppMountPaths();
-    const matchingMount = mounts
-        ? [...mounts]
-            .filter((mount) => pathMatchesBasePath(pathname, mount))
-            .sort((a, b) => b.length - a.length)[0]
-        : undefined;
-    if (matchingMount)
-        return matchingMount;
-    if (fallbackPath)
-        return fallbackPath;
     throw new WorkspaceAppMountResolutionError(mounts
         ? "Cannot resolve workspace app mount path because the current URL matches no projected mount."
         : "Cannot resolve workspace app mount path without explicit mount metadata.");
@@ -188,34 +169,70 @@ export function configureClientRouterBasename() {
         context.basename = routerBasePath;
     return true;
 }
+export function resolveExternalEmbedTargetAppBasePath(target) {
+    const mounts = workspaceAppMountPaths();
+    return resolveExternalEmbedTargetBasePath(target, {
+        workspaceRuntime: isWorkspaceRuntime(),
+        routerBasePath: routerContextBasePath(),
+        workspaceAppPath: workspaceAppConfiguredPath(),
+        workspaceAppMountPaths: mounts ? [...mounts] : undefined,
+        explicitRootPath: hasExplicitWorkspaceRootPath(),
+        frameworkRoutePrefix: frameworkRoutePrefix(),
+    });
+}
 function externalEmbedTargetBasePath() {
     if (typeof window === "undefined")
-        return "";
-    const target = window.__AGENT_NATIVE_EXTERNAL_EMBED?.target;
-    if (typeof target !== "string" || !target.startsWith("/"))
-        return "";
-    try {
-        const url = new URL(target, "http://agent-native.invalid");
-        const markerIndex = frameworkMarkerIndex(url.pathname);
-        if (markerIndex > 0) {
-            return normalizeBasePath(url.pathname.slice(0, markerIndex));
-        }
-        if (isWorkspaceRuntime()) {
-            const segment = url.pathname.split("/").find(Boolean);
-            if (segment && !isFrameworkSegment(segment) && segment !== "api") {
-                return normalizeBasePath(segment);
-            }
-        }
+        return undefined;
+    const externalEmbed = window.__AGENT_NATIVE_EXTERNAL_EMBED;
+    if (!externalEmbed || typeof externalEmbed !== "object")
+        return undefined;
+    const config = externalEmbed;
+    const target = config.target;
+    if (typeof target !== "string" || !target.startsWith("/")) {
+        return undefined;
     }
-    catch {
-        return "";
+    const basePath = resolveExternalEmbedTargetAppBasePath(target);
+    const pathname = window.location.pathname;
+    if (!pathname.startsWith("/")) {
+        return basePath;
+    }
+    const storedPathState = config.__agentNativePathState;
+    let pathState = storedPathState && typeof storedPathState === "object"
+        ? storedPathState
+        : undefined;
+    if (!pathState ||
+        pathState.target !== target ||
+        typeof pathState.initialPathname !== "string" ||
+        typeof pathState.navigated !== "boolean") {
+        const nextPathState = {
+            target,
+            initialPathname: pathname,
+            navigated: false,
+        };
+        config.__agentNativePathState = nextPathState;
+        pathState = nextPathState;
+    }
+    else if (pathState.initialPathname !== pathname) {
+        pathState.navigated = true;
     }
-    return "";
+    // Keep the target for handoff, then follow later route changes.
+    if (!pathState.navigated || !pathname.startsWith("/"))
+        return basePath;
+    const mounts = workspaceAppMountPaths();
+    const currentMount = resolveWorkspaceAppMountPath(pathname, {
+        workspaceAppMountPaths: mounts ? [...mounts] : undefined,
+        frameworkRoutePrefix: frameworkRoutePrefix(),
+    });
+    if (currentMount !== undefined && currentMount !== basePath) {
+        return currentMount;
+    }
+    if (basePath && !pathMatchesBasePath(pathname, basePath))
+        return undefined;
+    return basePath;
 }
-export function appBasePath() {
-    initializeAgentNativeClient();
+export function resolveAppBasePath() {
     const externalEmbed = externalEmbedTargetBasePath();
-    if (externalEmbed)
+    if (externalEmbed !== undefined)
         return externalEmbed;
     const configured = configuredBasePath();
     const derived = pathDerivedBasePath();
@@ -228,6 +245,10 @@ export function appBasePath() {
         return configured;
     return derived || workspacePathBasePath(configured);
 }
+export function appBasePath() {
+    initializeAgentNativeClient();
+    return resolveAppBasePath();
+}
 function workspaceAppMountPaths() {
     const projected = typeof window === "undefined"
         ? undefined

package/dist/client/application-state.js

@@ -1,6 +1,6 @@
 import { agentNativePath } from "./api-path.js";
 import { assertAgentNativeApiEnabled } from "./api-surface.js";
-import { getBrowserTabId } from "./browser-tab-id.js";
+import { getBrowserTabId, isBrowserTabIdForCurrentDocument, } from "./browser-tab-id.js";
 import { recordStateWrite } from "./recorder.js";
 const APP_STATE_KEY_PATTERN = /^[a-zA-Z0-9_:-]+$/;
 const pendingMutations = new Map();
@@ -18,10 +18,18 @@ function buildHeaders(requestSource) {
     if (typeof window !== "undefined") {
         headers["X-Agent-Native-Browser-Tab"] = getBrowserTabId();
     }
-    if (requestSource)
-        headers["X-Request-Source"] = requestSource;
+    Object.assign(headers, requestSourceHeader(requestSource));
     return headers;
 }
+function requestSourceHeader(requestSource) {
+    if (!requestSource)
+        return {};
+    return {
+        "X-Request-Source": isBrowserTabIdForCurrentDocument(requestSource)
+            ? getBrowserTabId()
+            : requestSource,
+    };
+}
 function browserTabHeaders() {
     return typeof window === "undefined"
         ? undefined
@@ -239,9 +247,7 @@ export async function deleteClientAppState(key, options = {}) {
             headers: {
                 "X-Agent-Native-CSRF": "1",
                 ...(browserTabHeaders() ?? {}),
-                ...(options.requestSource
-                    ? { "X-Request-Source": options.requestSource }
-                    : {}),
+                ...requestSourceHeader(options.requestSource),
             },
             keepalive: options.keepalive,
             signal: options.signal,

package/dist/client/browser-tab-id.d.ts

@@ -1 +1,3 @@
 export declare function getBrowserTabId(): string;
+export declare function resolveBrowserTabIdAlias(tabId?: string): string | undefined;
+export declare function isBrowserTabIdForCurrentDocument(tabId?: string): boolean;

package/dist/client/browser-tab-id.js

@@ -1,7 +1,18 @@
-import { appBasePath, isWorkspaceRuntime } from "./api-path.js";
-let cached;
+import { appBasePath, isWorkspaceRuntime, WorkspaceAppMountResolutionError, } from "./api-path.js";
 const STORAGE_KEY = "agent-native:browser-tab-id";
 const SAFE_BROWSER_TAB_ID_RE = /^[A-Za-z0-9_-]{1,96}$/;
+const BROWSER_TAB_ID_STATE_SYMBOL = Symbol.for("@agent-native/core/client/browser-tab-id");
+const browserTabIdGlobal = globalThis;
+// Vite can load optimized package and deep-import copies in the same tab.
+const browserTabIdState = browserTabIdGlobal[BROWSER_TAB_ID_STATE_SYMBOL] ??
+    (browserTabIdGlobal[BROWSER_TAB_ID_STATE_SYMBOL] = {
+        ids: new Map(),
+        aliases: new Map(),
+        pendingId: null,
+    });
+browserTabIdState.pendingId ??= null;
+const browserTabIdAliases = (browserTabIdState.aliases ??= new Map());
+let serverCached;
 function storageKey() {
     const appScope = isWorkspaceRuntime() ? appBasePath() : "";
     return appScope ? `${STORAGE_KEY}:${appScope}` : STORAGE_KEY;
@@ -21,28 +32,117 @@ function shouldReuseStoredTabId() {
     return navigation?.type === "reload" || navigation?.type === "back_forward";
 }
 export function getBrowserTabId() {
-    if (cached)
-        return cached;
     if (typeof window === "undefined") {
-        cached = generate();
+        serverCached ??= generate();
+        return serverCached;
+    }
+    let key;
+    try {
+        key = storageKey();
+    }
+    catch {
+        return getOrCreatePendingId();
+    }
+    const cached = browserTabIdState.ids.get(key);
+    if (cached) {
+        const pending = browserTabIdState.pendingId;
+        if (pending && pending !== cached) {
+            browserTabIdAliases.set(pending, { storageKey: key, id: cached });
+        }
+        browserTabIdState.pendingId = null;
         return cached;
     }
+    let existing;
+    let storageReadable = true;
     try {
-        const key = storageKey();
-        const existing = sessionStorage.getItem(key);
+        existing = sessionStorage.getItem(key);
+    }
+    catch {
+        existing = null;
+        storageReadable = false;
+    }
+    const pending = browserTabIdState.pendingId;
+    if (pending) {
         if (existing &&
             SAFE_BROWSER_TAB_ID_RE.test(existing) &&
             shouldReuseStoredTabId()) {
-            cached = existing;
+            browserTabIdState.pendingId = null;
+            browserTabIdState.ids.set(key, existing);
+            browserTabIdAliases.set(pending, { storageKey: key, id: existing });
             return existing;
         }
-        const id = generate();
+        browserTabIdState.pendingId = null;
+        try {
+            sessionStorage.setItem(key, pending);
+        }
+        catch {
+            browserTabIdState.ids.set(key, pending);
+            return pending;
+        }
+        browserTabIdState.ids.set(key, pending);
+        return pending;
+    }
+    if (!storageReadable)
+        return getOrCreateMemoryId(key);
+    if (existing &&
+        SAFE_BROWSER_TAB_ID_RE.test(existing) &&
+        shouldReuseStoredTabId()) {
+        browserTabIdState.ids.set(key, existing);
+        return existing;
+    }
+    const id = generate();
+    try {
         sessionStorage.setItem(key, id);
-        cached = id;
-        return id;
     }
     catch {
-        cached = generate();
-        return cached;
+        browserTabIdState.ids.set(key, id);
+        return id;
+    }
+    browserTabIdState.ids.set(key, id);
+    return id;
+}
+export function resolveBrowserTabIdAlias(tabId) {
+    if (typeof tabId !== "string")
+        return undefined;
+    const alias = browserTabIdAliases.get(tabId);
+    if (!alias)
+        return undefined;
+    return browserTabIdState.ids.get(alias.storageKey) === alias.id
+        ? alias.id
+        : undefined;
+}
+export function isBrowserTabIdForCurrentDocument(tabId) {
+    if (typeof tabId !== "string")
+        return false;
+    if (browserTabIdState.pendingId === tabId)
+        return true;
+    for (const knownTabId of browserTabIdState.ids.values()) {
+        if (knownTabId === tabId)
+            return true;
     }
+    const alias = browserTabIdAliases.get(tabId);
+    if (!alias || resolveBrowserTabIdAlias(tabId) === undefined)
+        return false;
+    let currentStorageKey;
+    try {
+        currentStorageKey = storageKey();
+    }
+    catch (error) {
+        if (error instanceof WorkspaceAppMountResolutionError)
+            return false;
+        throw error;
+    }
+    return currentStorageKey === alias.storageKey;
+}
+function getOrCreateMemoryId(key) {
+    const cached = browserTabIdState.ids.get(key);
+    if (cached)
+        return cached;
+    const id = generate();
+    browserTabIdState.ids.set(key, id);
+    return id;
+}
+function getOrCreatePendingId() {
+    browserTabIdState.pendingId ??= generate();
+    return browserTabIdState.pendingId;
 }

package/dist/client/collab/index.d.ts

@@ -1,4 +1,4 @@
-export { useCollaborativeDoc, isReconcileLeadClient, emailToColor, emailToName, dedupeCollabUsersByEmail, type CollabUser, type UseCollaborativeDocOptions, type UseCollaborativeDocResult, type CollabInitializationErrorCategory, type CollabInitializationState, type CollaborativeDocSyncResult, } from "../../collab/client.js";
+export { useCollaborativeDoc, isReconcileLeadClient, emailToColor, emailToName, dedupeCollabUsersByEmail, type CollabUser, type UseCollaborativeDocOptions, type UseCollaborativeDocResult, type CollabInitializationErrorCategory, type CollabInitializationState, type CollaborativeDocSyncResult, type CollabUpdateAck, } from "../../collab/client.js";
 export { AGENT_CLIENT_ID } from "../../collab/agent-identity.js";
 export { usePresence, toNormalized, fromNormalized, type OtherPresence, type PresencePayload, type UsePresenceResult, type NormalizedPoint, } from "../../collab/presence.js";
 export { useFollowUser, type UseFollowUserOptions, type UseFollowUserResult, type ViewportDescriptor, } from "../../collab/follow-mode.js";