@agent-native/core 0.207.1 → 0.207.2-nightly-20261012212922

package/dist/client/action-query-cache.session-test-fixture.d.ts

@@ -0,0 +1,49 @@
+import type { PersistedClient } from "@tanstack/query-persist-client-core";
+import { QueryClient } from "@tanstack/react-query";
+import { type ComponentType, type ReactNode } from "react";
+import type { AuthSessionResponse } from "../server/auth.js";
+import type { ActionQueryCacheStorage } from "./action-query-cache.js";
+export type Gate = ComponentType<{
+    children: ReactNode;
+}>;
+export type SessionUser = AuthSessionResponse;
+export type ProbeRender = {
+    title: string | undefined;
+    status: string;
+    userId: string | undefined;
+    firstRead: boolean;
+};
+export declare const ALICE: SessionUser;
+export declare const BOB: SessionUser;
+export declare function sessionResponse(user: SessionUser): Response;
+export declare function transientSessionFailure(): Response;
+export declare function designsResponse(title: string): Response;
+export declare function memoryStorage(): {
+    records: Map<string, PersistedClient>;
+    storage: ActionQueryCacheStorage;
+};
+export declare function stubFetch(options: {
+    onSession: (request: number) => Promise<Response> | Response;
+    onAction: (request: number) => Promise<Response> | Response;
+}): {
+    calls: {
+        kind: "session" | "action";
+        path: string;
+    }[];
+    sessionCount: () => number;
+    actionCount: () => number;
+};
+export declare function StatusProbe({ onStatus, }: {
+    onStatus: (value: {
+        status: string;
+        userId: string | undefined;
+    }) => void;
+}): null;
+export declare function mountProbe(GateComponent: Gate, queryClient: QueryClient, onRender: (value: ProbeRender) => void, onStatus?: (value: {
+    status: string;
+    userId: string | undefined;
+}) => void): Promise<HTMLDivElement>;
+export declare function settle(ms?: number): Promise<void>;
+export declare function waitUntil(predicate: () => boolean, timeoutMs?: number): Promise<boolean>;
+export declare function unmountAll(): Promise<void>;
+export { QueryClient };

package/dist/client/action-query-cache.session-test-fixture.js

@@ -0,0 +1,151 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { vi } from "vitest";
+import { useActionQuery } from "./use-action.js";
+import { isSessionFromFirstRead, useSession } from "./use-session.js";
+const roots = [];
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+let restoreLocalStorage;
+function installLocalStorageForTest() {
+    if (restoreLocalStorage)
+        return;
+    const descriptor = Object.getOwnPropertyDescriptor(window, "localStorage");
+    Object.defineProperty(window, "localStorage", {
+        configurable: true,
+        value: {
+            length: 0,
+            setItem: () => { },
+            getItem: () => null,
+            removeItem: () => { },
+            clear: () => { },
+            key: () => null,
+        },
+    });
+    restoreLocalStorage = () => {
+        if (descriptor)
+            Object.defineProperty(window, "localStorage", descriptor);
+        else
+            Reflect.deleteProperty(window, "localStorage");
+        restoreLocalStorage = undefined;
+    };
+}
+export const ALICE = {
+    email: "alice@example.com",
+    userId: "user-alice",
+    orgId: "org-1",
+    testIdentity: false,
+};
+export const BOB = {
+    email: "bob@example.com",
+    userId: "user-bob",
+    orgId: "org-1",
+    testIdentity: false,
+};
+export function sessionResponse(user) {
+    return new Response(JSON.stringify(user), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+export function transientSessionFailure() {
+    return new Response("temporarily unavailable", { status: 503 });
+}
+export function designsResponse(title) {
+    return new Response(JSON.stringify({ designs: [{ title }] }), {
+        status: 200,
+        headers: {
+            "Content-Type": "application/json",
+            "X-Agent-Native-Browser-Persist": "allow",
+        },
+    });
+}
+export function memoryStorage() {
+    const records = new Map();
+    const storage = {
+        get: async (key) => records.get(key),
+        set: async (key, value) => {
+            records.set(key, value);
+        },
+        del: async (key) => {
+            records.delete(key);
+        },
+        keys: async () => [...records.keys()],
+        clear: async () => {
+            records.clear();
+        },
+    };
+    return { records, storage };
+}
+export function stubFetch(options) {
+    let sessionRequests = 0;
+    let actionRequests = 0;
+    const calls = [];
+    vi.stubGlobal("fetch", vi.fn(async (input) => {
+        const raw = typeof input === "object" && "url" in input
+            ? String(input.url)
+            : String(input);
+        const url = new URL(raw, window.location.href);
+        calls.push({ kind: "session", path: url.pathname });
+        if (url.pathname.endsWith("/_agent-native/auth/session")) {
+            sessionRequests += 1;
+            calls[calls.length - 1].kind = "session";
+            return options.onSession(sessionRequests);
+        }
+        if (url.pathname.includes("/_agent-native/actions/")) {
+            actionRequests += 1;
+            calls[calls.length - 1].kind = "action";
+            return options.onAction(actionRequests);
+        }
+        throw new Error(`Unexpected fetch in private probe: ${url.pathname}`);
+    }));
+    return {
+        calls,
+        sessionCount: () => sessionRequests,
+        actionCount: () => actionRequests,
+    };
+}
+function DesignsProbe({ onRender, }) {
+    const { status, session } = useSession();
+    const query = useActionQuery("list-designs");
+    const title = query.data?.designs[0]?.title;
+    onRender({
+        title,
+        status,
+        userId: session?.userId,
+        firstRead: isSessionFromFirstRead(),
+    });
+    return _jsx("span", { "data-result": true, children: title ?? "pending" });
+}
+export function StatusProbe({ onStatus, }) {
+    const { status, session } = useSession();
+    onStatus({ status, userId: session?.userId });
+    return null;
+}
+export async function mountProbe(GateComponent, queryClient, onRender, onStatus) {
+    installLocalStorageForTest();
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const root = createRoot(container);
+    roots.push({ root, container });
+    await act(async () => root.render(_jsxs(QueryClientProvider, { client: queryClient, children: [onStatus ? _jsx(StatusProbe, { onStatus: onStatus }) : null, _jsx(GateComponent, { children: _jsx(DesignsProbe, { onRender: onRender }) })] })));
+    return container;
+}
+export async function settle(ms = 20) {
+    await act(async () => new Promise((resolve) => setTimeout(resolve, ms)));
+}
+export async function waitUntil(predicate, timeoutMs = 4_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (!predicate() && Date.now() < deadline)
+        await settle(20);
+    return predicate();
+}
+export async function unmountAll() {
+    for (const { root, container } of roots.splice(0)) {
+        await act(async () => root.unmount());
+        container.remove();
+    }
+    restoreLocalStorage?.();
+}
+export { QueryClient };

package/dist/client/action-query-cache.test-fixtures.d.ts

@@ -0,0 +1,2 @@
+export declare const TEST_CACHE_EPOCH = "cache-test-epoch";
+export declare function cacheBuster(buster?: string): string;

package/dist/client/action-query-cache.test-fixtures.js

@@ -0,0 +1,56 @@
+import { beforeEach } from "vitest";
+const epochKey = "agent-native.action-query-cache.epoch";
+const values = new Map();
+const localStorageShim = {
+    get length() {
+        return values.size;
+    },
+    key(index) {
+        return [...values.keys()][index] ?? null;
+    },
+    getItem(key) {
+        return values.get(key) ?? null;
+    },
+    setItem(key, value) {
+        values.set(key, value);
+    },
+    removeItem(key) {
+        values.delete(key);
+    },
+    clear() {
+        values.clear();
+    },
+};
+beforeEach(() => {
+    values.clear();
+    values.set(epochKey, TEST_CACHE_EPOCH);
+    const global = globalThis;
+    if (!global.window) {
+        Object.defineProperty(globalThis, "window", {
+            configurable: true,
+            value: { localStorage: localStorageShim },
+        });
+        return;
+    }
+    Object.defineProperty(global.window, "localStorage", {
+        configurable: true,
+        value: localStorageShim,
+    });
+});
+export const TEST_CACHE_EPOCH = "cache-test-epoch";
+const CURRENT_CACHE_BUSTER = "action-query-cache-v1";
+const CACHE_EPOCH_KEY = "agent-native.action-query-cache.epoch";
+function currentTestEpoch() {
+    try {
+        return window.localStorage.getItem(CACHE_EPOCH_KEY) ?? TEST_CACHE_EPOCH;
+    }
+    catch {
+        return TEST_CACHE_EPOCH;
+    }
+}
+export function cacheBuster(buster = CURRENT_CACHE_BUSTER) {
+    if (buster === CURRENT_CACHE_BUSTER) {
+        return `${CURRENT_CACHE_BUSTER}:${currentTestEpoch()}`;
+    }
+    return buster;
+}

package/dist/client/use-action.d.ts

@@ -1,4 +1,4 @@
-import type { Query, UseQueryOptions, UseMutationOptions } from "@tanstack/react-query";
+import type { Query, QueryClient, UseQueryOptions, UseMutationOptions } from "@tanstack/react-query";
 /** @internal exported for tests */
 export declare function defaultActionQueryRetry(failureCount: number, error: unknown): boolean;
 /** @internal alias kept for existing specs. */
@@ -105,10 +105,18 @@ export declare function guardActionQueryRefetchInterval<TData = unknown>(refetch
 export declare function resolveActionQueryRetry(retry: unknown, failureCount: number, error: unknown): boolean;
 /** @internal exported for tests */
 export declare function resetActionCircuitTripEventsForTests(): void;
+export declare function registerActionQueryCacheRevoker(client: QueryClient, revoke: () => void, bindingToken?: object): void;
+/** @internal set only by the scoped action-query cache binder. */
+export declare function setActionQueryCacheBindingToken(token: object | undefined): void;
+export declare function setAccessDeniedActionQueryBinding(query: Query, token: object | undefined): void;
+export declare function getAccessDeniedActionQueryBinding(query: Query): object | undefined;
+export declare function clearAccessDeniedActionQueryBinding(query: Query): void;
 /** @internal read by the persisted query cache. */
 export declare function isBrowserPersistableActionQuery(query: Query): boolean;
+/** @internal a response is persistable only in the binding active at fetch start. */
+export declare function isBrowserPersistableActionQueryForBinding(query: Query, token: object): boolean;
 /** @internal used only after a persisted action result is accepted and hydrated. */
-export declare function markRestoredBrowserPersistableActionQuery(query: Query): void;
+export declare function markRestoredBrowserPersistableActionQuery(query: Query, token?: object): void;
 export declare function revokeBrowserPersistableActionQuery(query: Query): void;
 export declare function useActionQuery<TResult = undefined, TName extends ActionName = ActionName>(actionName: TName, params?: ActionParams<TName>, options?: Omit<UseQueryOptions<TResult extends undefined ? ActionResult<TName> : TResult>, "queryKey" | "queryFn"> & {
     queryKeyScope?: readonly unknown[];

package/dist/client/use-action.js

@@ -776,18 +776,60 @@ function trackActionCircuitTrip(actionName, error, trip) {
 }
 // Identical keys in another client or auth scope must earn their own permission.
 const browserPersistableActionQueries = new WeakSet();
+const browserPersistableActionQueryBindings = new WeakMap();
+const actionQueryCacheRevokers = new WeakMap();
+const actionQueryCacheBindingRevokers = new WeakMap();
+let actionQueryCacheBindingToken;
+export function registerActionQueryCacheRevoker(client, revoke, bindingToken) {
+    actionQueryCacheRevokers.set(client, revoke);
+    if (bindingToken)
+        actionQueryCacheBindingRevokers.set(bindingToken, revoke);
+}
+function revokeActionQueryCacheForClient(client, bindingToken) {
+    const bindingRevoker = bindingToken
+        ? actionQueryCacheBindingRevokers.get(bindingToken)
+        : undefined;
+    (bindingRevoker ?? actionQueryCacheRevokers.get(client))?.();
+}
+/** @internal set only by the scoped action-query cache binder. */
+export function setActionQueryCacheBindingToken(token) {
+    actionQueryCacheBindingToken = token;
+}
+const accessDeniedActionQueryBindings = new WeakMap();
+export function setAccessDeniedActionQueryBinding(query, token) {
+    if (token)
+        accessDeniedActionQueryBindings.set(query, token);
+    else
+        accessDeniedActionQueryBindings.delete(query);
+}
+export function getAccessDeniedActionQueryBinding(query) {
+    return accessDeniedActionQueryBindings.get(query);
+}
+export function clearAccessDeniedActionQueryBinding(query) {
+    accessDeniedActionQueryBindings.delete(query);
+}
 /** @internal read by the persisted query cache. */
 export function isBrowserPersistableActionQuery(query) {
     return (query.queryKey[0] === "action" &&
         query.state.status === "success" &&
         browserPersistableActionQueries.has(query));
 }
+/** @internal a response is persistable only in the binding active at fetch start. */
+export function isBrowserPersistableActionQueryForBinding(query, token) {
+    return (isBrowserPersistableActionQuery(query) &&
+        browserPersistableActionQueryBindings.get(query) === token);
+}
 /** @internal used only after a persisted action result is accepted and hydrated. */
-export function markRestoredBrowserPersistableActionQuery(query) {
+export function markRestoredBrowserPersistableActionQuery(query, token) {
     browserPersistableActionQueries.add(query);
+    if (token)
+        browserPersistableActionQueryBindings.set(query, token);
+    else
+        browserPersistableActionQueryBindings.delete(query);
 }
 export function revokeBrowserPersistableActionQuery(query) {
     browserPersistableActionQueries.delete(query);
+    browserPersistableActionQueryBindings.delete(query);
 }
 export function useActionQuery(actionName, params, options) {
     const apiDisabled = Boolean(agentNativeApiDisabledReason());
@@ -799,22 +841,49 @@ export function useActionQuery(actionName, params, options) {
         queryFn: async ({ signal, client }) => {
             const key = circuitKey();
             const query = client.getQueryCache().find({ queryKey, exact: true });
+            const bindingTokenAtFetch = actionQueryCacheBindingToken;
             assertActionCircuitClosed(key);
             let browserPersist = false;
-            const result = await actionFetch(actionName, "GET", params, {
-                signal,
-                onResponse: (response) => {
-                    browserPersist =
-                        response.headers.get(ACTION_BROWSER_PERSIST_HEADER) ===
-                            ACTION_BROWSER_PERSIST_ALLOW;
-                },
-            });
+            let result;
+            try {
+                result = await actionFetch(actionName, "GET", params, {
+                    signal,
+                    onResponse: (response) => {
+                        browserPersist =
+                            response.headers.get(ACTION_BROWSER_PERSIST_HEADER) ===
+                                ACTION_BROWSER_PERSIST_ALLOW;
+                    },
+                });
+            }
+            catch (error) {
+                const status = actionErrorStatus(error);
+                if (!signal.aborted &&
+                    (status === 401 || status === 403 || status === 404)) {
+                    if (query) {
+                        setAccessDeniedActionQueryBinding(query, bindingTokenAtFetch);
+                        revokeBrowserPersistableActionQuery(query);
+                        query.setState({ data: undefined, dataUpdatedAt: 0 });
+                    }
+                    revokeActionQueryCacheForClient(client, bindingTokenAtFetch);
+                }
+                throw error;
+            }
             resetActionFailureCircuit(key);
             if (query && !signal.aborted) {
-                if (browserPersist)
+                clearAccessDeniedActionQueryBinding(query);
+                if (browserPersist) {
                     browserPersistableActionQueries.add(query);
-                else
-                    browserPersistableActionQueries.delete(query);
+                    if (bindingTokenAtFetch !== undefined &&
+                        actionQueryCacheBindingToken === bindingTokenAtFetch) {
+                        browserPersistableActionQueryBindings.set(query, bindingTokenAtFetch);
+                    }
+                    else {
+                        browserPersistableActionQueryBindings.delete(query);
+                    }
+                }
+                else {
+                    revokeBrowserPersistableActionQuery(query);
+                }
             }
             return result;
         },

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
-    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
+    deleted?: undefined;
 }>;
 export default _default;

package/dist/observability/routes.d.ts

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

package/dist/progress/routes.d.ts

@@ -2,6 +2,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

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

@@ -75,7 +75,7 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    message?: undefined;
+    id?: undefined;
     found?: undefined;
     providers: {
         id: string;
@@ -90,42 +90,42 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     provider?: undefined;
     deleted?: undefined;
     registered?: undefined;
-    id?: undefined;
     label?: undefined;
-} | {
-    count?: undefined;
     message?: undefined;
+} | {
+    id?: undefined;
     providers?: undefined;
+    count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     deleted?: undefined;
     registered?: undefined;
-    id?: undefined;
     label?: undefined;
-} | {
-    count?: undefined;
     message?: undefined;
+} | {
     providers?: undefined;
+    count?: undefined;
     provider?: undefined;
     found: boolean;
     id: string;
     deleted?: undefined;
     registered?: undefined;
     label?: undefined;
-} | {
-    count?: undefined;
     message?: undefined;
+} | {
     found?: undefined;
     providers?: undefined;
+    count?: undefined;
     provider?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
+    message?: undefined;
 } | {
-    count?: undefined;
     found?: undefined;
     providers?: undefined;
+    count?: undefined;
     provider?: undefined;
     deleted?: undefined;
     registered: boolean;

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

@@ -311,7 +311,6 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        id?: undefined;
         message?: undefined;
         found?: undefined;
         providers: {
@@ -327,21 +326,22 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         provider?: undefined;
         deleted?: undefined;
         registered?: undefined;
+        id?: undefined;
         label?: undefined;
     } | {
-        id?: undefined;
+        count?: undefined;
         message?: undefined;
         providers?: undefined;
-        count?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         deleted?: undefined;
         registered?: undefined;
+        id?: undefined;
         label?: undefined;
     } | {
+        count?: undefined;
         message?: undefined;
         providers?: undefined;
-        count?: undefined;
         provider?: undefined;
         found: boolean;
         id: string;
@@ -349,19 +349,19 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
+        count?: undefined;
         message?: undefined;
         found?: undefined;
         providers?: undefined;
-        count?: undefined;
         provider?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
+        count?: undefined;
         found?: undefined;
         providers?: undefined;
-        count?: undefined;
         provider?: undefined;
         deleted?: undefined;
         registered: boolean;

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<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;