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

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/client/use-settings-shortcut.js

@@ -1,7 +1,8 @@
 import { useEffect } from "react";
-import { useLocation, useNavigate } from "react-router";
+import { useHref, useLocation, useNavigate } from "react-router";
 import { buildSettingsRoute, STANDARD_APP_ROUTES, } from "../navigation/index.js";
 import { appPath } from "./api-path.js";
+import { rememberRouteChunkRecoveryNavigation } from "./route-chunk-recovery.js";
 /** Dispatched on `window` to open Settings; `detail.page` names a page id. */
 export const OPEN_SETTINGS_PAGE_EVENT = "agent-native:open-settings-page";
 /** The page ⌘, opens. Legacy ids resolve through the settings redirect table. */
@@ -46,13 +47,17 @@ export function openSettingsPage(page) {
 export function useSettingsShortcut({ enabled = true, } = {}) {
     const navigate = useNavigate();
     const { pathname } = useLocation();
+    const routerRootHref = useHref("/");
     useEffect(() => {
         if (!enabled)
             return;
         const open = (page) => {
             if (!page && isSettingsRoutePath(pathname))
                 return;
-            void navigate(settingsPagePath(page));
+            const target = settingsPagePath(page);
+            const basePath = new URL(routerRootHref, window.location.href).pathname.replace(/\/+$/, "");
+            rememberRouteChunkRecoveryNavigation(`${basePath}${target}`);
+            void navigate(target);
         };
         const handleKeyDown = (event) => {
             // A second mounted instance has already claimed this press.
@@ -78,7 +83,7 @@ export function useSettingsShortcut({ enabled = true, } = {}) {
             window.removeEventListener("keydown", handleKeyDown, true);
             window.removeEventListener(OPEN_SETTINGS_PAGE_EVENT, handleOpenRequest);
         };
-    }, [enabled, navigate, pathname]);
+    }, [enabled, navigate, pathname, routerRootHref]);
 }
 /** Mount point for `useSettingsShortcut`; must render inside a router. */
 export function SettingsShortcut() {

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/routes.d.ts

@@ -13,8 +13,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

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/extensions/fetch-tool.js

@@ -334,18 +334,24 @@ export function createFetchToolEntry(opts = {}) {
                         };
                     }
                     let body;
+                    let bodyResult;
                     try {
                         const readLimit = saveToFilePath
                             ? 20 * 1024 * 1024
                             : MAX_EXTENSION_PROXY_RESPONSE_SIZE;
-                        const result = await readResponseTextWithLimit(response, readLimit);
-                        body = result.text;
+                        bodyResult = await readResponseTextWithLimit(response, readLimit);
                     }
                     catch {
                         fail("(could not read response body)", {
                             errorCode: httpErrorCode ?? "web_request_body_unreadable",
                         });
                     }
+                    if (bodyResult.truncated) {
+                        fail(`HTTP ${response.status} ${response.statusText}\n\n${bodyResult.text}`, {
+                            errorCode: httpErrorCode ?? "web_request_response_too_large",
+                        });
+                    }
+                    body = bodyResult.text;
                     body = redactString(body, secretValues);
                     if (response.ok) {
                         const { providerApiResponseOutcomeForUrl } = await import("../provider-api/index.js");

package/dist/extensions/routes.js

@@ -655,13 +655,17 @@ async function handleProxy(event, userEmail) {
                 },
             };
         }
-        const { text } = await readResponseTextWithLimit(response);
+        const responseText = await readResponseTextWithLimit(response);
+        if (responseText.truncated) {
+            setResponseStatus(event, 502);
+            return { error: responseText.text };
+        }
         let responseBody;
         try {
-            responseBody = JSON.parse(text);
+            responseBody = JSON.parse(responseText.text);
         }
         catch {
-            responseBody = text;
+            responseBody = responseText.text;
         }
         return {
             status: response.status,

package/dist/extensions/web-content.js

@@ -67,8 +67,9 @@ export async function processWebContent(options) {
     const search = options.search ?? null;
     const html = isHtmlResponse(contentType, options.body);
     const mode = resolveMode(requestedMode, html, search);
+    const emptyHtmlBody = html && !options.body.trim();
     const maxChars = normalizeBoundedNumber(options.maxChars, DEFAULT_MAX_CONTENT_CHARS, 1, 200_000);
-    const extracted = html && (mode !== "raw" || hasWebContentSearch(search))
+    const extracted = html && !emptyHtmlBody && (mode !== "raw" || hasWebContentSearch(search))
         ? await extractHtml(options.body, options.url, extract, mode === "markdown" || mode === "matches")
         : null;
     const baseContent = contentForMode(mode, options.body, extracted);
@@ -78,6 +79,17 @@ export async function processWebContent(options) {
         contentType,
         ...metadataFromExtraction(extracted),
     };
+    if (emptyHtmlBody &&
+        mode !== "raw" &&
+        mode !== "links" &&
+        mode !== "metadata" &&
+        mode !== "matches") {
+        result.content = "(empty response body)";
+        result.truncated = false;
+        if (options.includeLinks)
+            result.links = [];
+        return result;
+    }
     if (mode === "links") {
         result.links = extracted?.links ?? [];
         return result;
@@ -317,7 +329,10 @@ function removeNonContentNodes(document) {
     }
 }
 function parseFullDocument(html, parseDocument) {
-    return parseDocument(html);
+    const document = parseDocument(html);
+    return document.documentElement
+        ? document
+        : parseHtmlFragment(html, parseDocument);
 }
 function parseHtmlFragment(html, parseDocument) {
     return parseDocument(`<!doctype html><html><head></head><body>${html}</body></html>`);

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

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/mcp/build-server.js

@@ -1171,6 +1171,11 @@ function mcpDirectoryWidgetSessionTool(config) {
             },
             required: ["sourceTicket"],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
         _meta: { ui: { visibility: ["app"] } },
     };
 }

package/dist/observability/routes.d.ts

@@ -33,26 +33,26 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     spans?: undefined;
     ok?: undefined;
 } | {
+    error?: undefined;
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
-    error?: undefined;
     ok?: undefined;
 } | {
+    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
-    error?: undefined;
     ok?: undefined;
 } | {
+    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
-    error?: undefined;
     ok?: undefined;
 } | {
     message?: undefined;
@@ -61,9 +61,9 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     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/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;

package/dist/secrets/routes.d.ts

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

package/dist/server/agent-engine-api-key-route.d.ts

@@ -66,6 +66,7 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     error: any;
     code: any;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     code?: undefined;
     ok: boolean;
@@ -73,6 +74,5 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
     defaultModel?: import("./agent-engine-default-model-route.js").SavedKeyDefaultModelOutcome;
-    error?: undefined;
 }>>;
 export {};

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

@@ -9,16 +9,16 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     scope?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     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

@@ -3,7 +3,7 @@ export declare function createAgentEngineOllamaModelsHandler(): import("h3").Eve
     models?: undefined;
     ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     models: string[];
-    error?: undefined;
 }>>;

package/dist/server/realtime-token.d.ts

@@ -54,8 +54,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
+    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
-    error?: undefined;
 }>>;

package/dist/server/transcribe-voice.d.ts

@@ -20,6 +20,6 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    text: string;
     error?: undefined;
+    text: string;
 }>>;

package/dist/server/visual-edit-bridge-capability.d.ts

@@ -0,0 +1,26 @@
+export declare const LOCALHOST_BRIDGE_OPERATION_CAPABILITY_FIELD = "bridgeOperationCapability";
+export interface IssueLocalhostBridgeOperationCapabilityOptions {
+    bridgeToken: string;
+    audience: string;
+    operation: string;
+    body: Record<string, unknown>;
+    issuedAt?: number;
+}
+export interface VerifyLocalhostBridgeOperationCapabilityOptions {
+    bridgeToken: string;
+    audience: string;
+    operation: string;
+    body: Record<string, unknown>;
+    capability: string;
+    now?: number;
+}
+export declare function createLocalhostBridgeAudience(rootPath: string): string;
+export declare function issueLocalhostBridgeOperationCapability({ bridgeToken, audience, operation, body, issuedAt, }: IssueLocalhostBridgeOperationCapabilityOptions): {
+    capability: string;
+    nonce: string;
+    expiresAt: number;
+};
+export declare function verifyLocalhostBridgeOperationCapability({ bridgeToken, audience, operation, body, capability, now, }: VerifyLocalhostBridgeOperationCapabilityOptions): {
+    nonce: string;
+    expiresAt: number;
+} | null;