@agent-native/core 0.213.1 → 0.216.0

package/dist/client/chat/runtime.js

@@ -1,4 +1,5 @@
 import { AgentKitRunSlotBusyError } from "@agent-native/agentkit/client";
+import { parseAgentQueuedSubmissionReceipt, } from "@agent-native/agentkit/protocol";
 import { AUTO_CONTINUE_OF_RUN_METADATA_KEY, CONTINUE_OF_RUN_METADATA_KEY, } from "../../agent/auto-continue.js";
 import { RUN_NOT_STARTED_METADATA_KEY } from "../../shared/agent-chat-run-not-started.js";
 import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch, } from "../agent-engine-readiness.js";
@@ -261,6 +262,8 @@ function defaultHttpRuntimeRequest(input) {
         messages: input.turn.messages,
         attachments: input.turn.attachments,
         submissionPayload: input.turn.submissionPayload,
+        options: input.turn.options,
+        references: input.turn.references,
         tools: input.turn.tools,
         model: input.turn.model,
         reasoningEffort: input.turn.reasoningEffort,
@@ -476,6 +479,43 @@ export function createHttpAgentChatRuntime(options) {
                 }
                 throw withTurnId(error, turnId);
             }
+            if (response.status === 202) {
+                let queuedSubmission;
+                try {
+                    if (!response.headers
+                        .get("Content-Type")
+                        ?.toLowerCase()
+                        .includes("application/json")) {
+                        throw new TypeError("Expected a JSON queued submission receipt.");
+                    }
+                    queuedSubmission = parseAgentQueuedSubmissionReceipt(await response.json());
+                    const submission = asRecord(turn.submissionPayload);
+                    const expectedThreadId = summary.threadId ?? sessionId;
+                    if (queuedSubmission.message.threadId !== expectedThreadId ||
+                        (typeof submission?.id === "string" &&
+                            queuedSubmission.message.id !== submission.id)) {
+                        throw new TypeError("The queued submission receipt does not match this session turn.");
+                    }
+                }
+                catch (cause) {
+                    cleanup();
+                    throw withTurnId(Object.assign(new Error(cause instanceof Error
+                        ? `Invalid queued submission response: ${cause.message}`
+                        : "Invalid queued submission response.", { cause }), {
+                        code: "invalid_queued_submission_response",
+                        status: response.status,
+                        retryable: true,
+                    }), turnId);
+                }
+                cleanup();
+                forgetTurnContext(turnId, turn);
+                return {
+                    id: turnId,
+                    sessionId,
+                    queuedSubmission,
+                    events: (async function* () { })(),
+                };
+            }
             const runId = response.headers.get("X-Run-Id") ?? undefined;
             const events = (async function* () {
                 let retryableFailure = false;
@@ -3230,6 +3270,8 @@ export function createAgentNativeChatRuntime(options = {}) {
                 ...(turn.submissionPayload !== undefined
                     ? { submissionPayload: turn.submissionPayload }
                     : {}),
+                ...(turn.references?.length ? { references: turn.references } : {}),
+                ...(turn.options ? { options: turn.options } : {}),
                 ...(turn.queuePromotion
                     ? {
                         queuedMessageId: turn.queuePromotion.messageId,
@@ -3298,6 +3340,7 @@ export function createAgentNativeChatRuntime(options = {}) {
             const turnToContinue = continuation.attachments?.length
                 ? { ...previousTurn, attachments: continuation.attachments }
                 : previousTurn;
+            const { submissionPayload: _submissionPayload, ...continuationTurn } = turnToContinue ?? {};
             const approval = continuation.approval;
             const connection = continuation.connection;
             const messageStateKey = continuation.turnId ?? session.id;
@@ -3314,7 +3357,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                 if (messageState)
                     messageState.message.connectionPending = false;
                 return startTurn({
-                    ...turnToContinue,
+                    ...continuationTurn,
                     prompt: continuation.prompt ??
                         `The ${connection.id} connection is now available. Continue the requested work.`,
                     metadata: {
@@ -3334,7 +3377,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                 if (messageState)
                     messageState.message.approvalPending = false;
                 return startTurn({
-                    ...turnToContinue,
+                    ...continuationTurn,
                     prompt: continuation.prompt,
                     metadata: {
                         ...previousMetadata,
@@ -3376,7 +3419,7 @@ export function createAgentNativeChatRuntime(options = {}) {
             if (messageState)
                 messageState.message.approvalPending = false;
             return startTurn({
-                ...turnToContinue,
+                ...continuationTurn,
                 prompt: continuation.prompt ??
                     "Approved. Go ahead and run the requested action.",
                 metadata: {

package/dist/client/consent.d.ts

@@ -0,0 +1,36 @@
+import { type ConsentCategory, type ConsentChoice, type ConsentRegion } from "../shared/consent.js";
+export type { ConsentCategory, ConsentChoice, ConsentRegion };
+/** The visitor's stored choice, or `null` before they've made one. */
+export declare function getConsentChoice(): ConsentChoice | null;
+/**
+ * Whether this visitor gets the banner: the server's answer from the
+ * request's country, else the browser's time zone. Asked once a session.
+ */
+export declare function resolveConsentRegion(): Promise<ConsentRegion>;
+/**
+ * Whether `category` is allowed right now, on the time zone's guess until the
+ * server answers. Pair it with `whenConsentAllows` and a `revoke` that undoes
+ * whatever this let through.
+ */
+export declare function consentAllowsNow(category: ConsentCategory): boolean;
+export interface WhenConsentAllowsOptions {
+    /**
+     * Run now on the time zone's guess instead of waiting for the server, and
+     * call `revoke` if the server or the visitor then says no. Only for storage
+     * `revoke` can fully undo; a third-party script can't be unloaded.
+     */
+    optimistic?: boolean;
+    revoke?: () => void;
+}
+/**
+ * Run `run` once `category` is allowed: at once outside the consent region,
+ * and inside it when the visitor accepts. A later "reject" calls `revoke`.
+ */
+export declare function whenConsentAllows(category: ConsentCategory, run: () => void, options?: WhenConsentAllowsOptions): void;
+/** Store the visitor's choice for every app on this site, and apply it. */
+export declare function setConsentChoice(choice: ConsentChoice): void;
+/** Reopen the banner so the visitor can change their choice. */
+export declare function openConsentSettings(): void;
+/** Whether the banner should show now, for the banner component. */
+export declare function shouldShowConsentBanner(): boolean;
+export declare function subscribeConsent(listener: () => void): () => void;

package/dist/client/consent.js

@@ -0,0 +1,283 @@
+import { CONSENT_COOKIE_LIFETIME_SECONDS, CONSENT_COOKIE_NAME, CONSENT_PATH, CONSENT_REGION_PATH, consentCookieDomain, isConsentRegionTimeZone, parseConsent, serializeConsent, } from "../shared/consent.js";
+import { agentNativePath } from "./api-path.js";
+import { agentNativeApiDisabledReason } from "./api-surface.js";
+/** Strictly necessary for the banner: which region this session is in. */
+const REGION_STORAGE_KEY = "an_consent_region";
+/**
+ * Scripts that run before this module loads, like the Google tags the server
+ * injects into the page, queue `[category, run]` here.
+ */
+const SCRIPT_QUEUE_KEY = "__AN_CONSENT_QUEUE__";
+// One state per page, however many copies of this module a bundle carries.
+const STATE_KEY = Symbol.for("agent-native.client.consent");
+function state() {
+    const holder = globalThis;
+    return (holder[STATE_KEY] ??= {
+        region: null,
+        regionPromise: null,
+        waiters: [],
+        listeners: new Set(),
+        settingsOpen: false,
+    });
+}
+function readCookie(name) {
+    if (typeof document === "undefined")
+        return null;
+    try {
+        for (const part of document.cookie ? document.cookie.split(";") : []) {
+            const eq = part.indexOf("=");
+            if (eq !== -1 && part.slice(0, eq).trim() === name) {
+                return part.slice(eq + 1).trim();
+            }
+        }
+    }
+    catch {
+        // coercion-ok: a sandboxed iframe can't read cookies, so it holds no
+        // choice and the visitor is asked.
+    }
+    return null;
+}
+/** The visitor's stored choice, or `null` before they've made one. */
+export function getConsentChoice() {
+    return parseConsent(readCookie(CONSENT_COOKIE_NAME));
+}
+function cookieDomain() {
+    const host = typeof window === "undefined" ? "" : window.location.hostname;
+    const domain = consentCookieDomain(host);
+    return domain ? `; domain=${domain}` : "";
+}
+function writeChoiceCookie(choice) {
+    try {
+        document.cookie =
+            `${CONSENT_COOKIE_NAME}=${serializeConsent(choice)}; path=/; ` +
+                `max-age=${CONSENT_COOKIE_LIFETIME_SECONDS}; SameSite=Lax${cookieDomain()}`;
+    }
+    catch {
+        // coercion-ok: a sandboxed iframe can't store the choice; it still
+        // applies to this page.
+    }
+}
+let serverChoiceWrites = Promise.resolve();
+let latestChoice = null;
+/**
+ * Safari keeps a cookie page JavaScript wrote for seven days at most, so the
+ * server writes the choice again for its full year. Writes go one at a time
+ * and only the newest is sent. A response for an older choice still sets that
+ * choice's cookie, so the newest is written back over it at once.
+ */
+function storeChoiceOnServer(choice) {
+    latestChoice = choice;
+    if (agentNativeApiDisabledReason() || typeof fetch !== "function")
+        return;
+    serverChoiceWrites = serverChoiceWrites.then(async () => {
+        if (latestChoice !== choice)
+            return;
+        await fetch(agentNativePath(CONSENT_PATH), {
+            method: "POST",
+            credentials: "same-origin",
+            keepalive: true,
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ choice: serializeConsent(choice) }),
+        }).catch(() => {
+            // coercion-ok: the browser's own copy still holds the choice, for
+            // seven days in Safari; the visitor is asked again after that.
+        });
+        if (latestChoice && latestChoice !== choice) {
+            writeChoiceCookie(latestChoice);
+        }
+    });
+}
+function readCachedRegion() {
+    try {
+        const value = window.sessionStorage.getItem(REGION_STORAGE_KEY);
+        return value === "consent" || value === "none" ? value : null;
+    }
+    catch {
+        // coercion-ok: without session storage the region is asked again.
+        return null;
+    }
+}
+function cacheRegion(region) {
+    try {
+        window.sessionStorage.setItem(REGION_STORAGE_KEY, region);
+    }
+    catch {
+        // coercion-ok: without session storage the region is asked again.
+    }
+}
+function timeZoneRegion() {
+    try {
+        const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        return isConsentRegionTimeZone(timeZone) ? "consent" : "none";
+    }
+    catch {
+        // An unreadable zone could be anywhere, so it gets the banner.
+        return "consent";
+    }
+}
+async function fetchRegion() {
+    if (agentNativeApiDisabledReason() || typeof fetch !== "function") {
+        return timeZoneRegion();
+    }
+    try {
+        const response = await fetch(agentNativePath(CONSENT_REGION_PATH), {
+            credentials: "same-origin",
+        });
+        const body = response.ok
+            ? (await response.json())
+            : {};
+        if (body.region === "consent" || body.region === "none") {
+            return body.region;
+        }
+    }
+    catch {
+        // coercion-ok: with no answer from the server, the time zone decides.
+    }
+    return timeZoneRegion();
+}
+/**
+ * Whether this visitor gets the banner: the server's answer from the
+ * request's country, else the browser's time zone. Asked once a session.
+ */
+export function resolveConsentRegion() {
+    const current = state();
+    if (current.region)
+        return Promise.resolve(current.region);
+    const cached = typeof window === "undefined" ? null : readCachedRegion();
+    if (cached) {
+        current.region = cached;
+        // Another app or tab may have stored a reject since this page's waiters
+        // last looked; let them clear what they kept.
+        settle();
+        notify();
+        return Promise.resolve(cached);
+    }
+    return (current.regionPromise ??= fetchRegion().then((region) => {
+        current.region = region;
+        cacheRegion(region);
+        settle();
+        notify();
+        return region;
+    }));
+}
+/** The best answer available now, without waiting for the server. */
+function regionGuess() {
+    const current = state();
+    return current.region ?? readCachedRegion() ?? timeZoneRegion();
+}
+function allows(category, region) {
+    const choice = getConsentChoice();
+    if (choice)
+        return choice[category];
+    return region === "none";
+}
+/**
+ * Whether `category` is allowed right now, on the time zone's guess until the
+ * server answers. Pair it with `whenConsentAllows` and a `revoke` that undoes
+ * whatever this let through.
+ */
+export function consentAllowsNow(category) {
+    if (typeof window === "undefined")
+        return false;
+    if (!state().region)
+        void resolveConsentRegion();
+    return allows(category, regionGuess());
+}
+function settle() {
+    const region = state().region;
+    for (const waiter of state().waiters) {
+        const allowed = allows(waiter.category, region);
+        if (allowed && !waiter.ran) {
+            waiter.ran = true;
+            isolate(waiter.run);
+        }
+        else if (!allowed && region) {
+            // Also clears what an earlier page stored before the banner existed.
+            waiter.ran = false;
+            if (waiter.revoke)
+                isolate(waiter.revoke);
+        }
+    }
+}
+/**
+ * One callback throwing must not skip the waiters after it, or a later revoke
+ * would never clear what a rejected category stored. Rethrow it on its own task
+ * so it still surfaces.
+ */
+function isolate(callback) {
+    try {
+        callback();
+    }
+    catch (error) {
+        setTimeout(() => {
+            throw error;
+        });
+    }
+}
+function notify() {
+    for (const listener of state().listeners)
+        listener();
+}
+/**
+ * Run `run` once `category` is allowed: at once outside the consent region,
+ * and inside it when the visitor accepts. A later "reject" calls `revoke`.
+ */
+export function whenConsentAllows(category, run, options = {}) {
+    if (typeof window === "undefined")
+        return;
+    const waiter = { category, run, revoke: options.revoke, ran: false };
+    state().waiters.push(waiter);
+    const region = state().region ??
+        readCachedRegion() ??
+        (options.optimistic ? regionGuess() : null);
+    if (allows(category, region)) {
+        waiter.ran = true;
+        isolate(run);
+    }
+    if (!state().region)
+        void resolveConsentRegion();
+}
+/** Store the visitor's choice for every app on this site, and apply it. */
+export function setConsentChoice(choice) {
+    if (typeof document === "undefined")
+        return;
+    writeChoiceCookie(choice);
+    storeChoiceOnServer(choice);
+    state().settingsOpen = false;
+    if (!state().region)
+        state().region = "consent";
+    settle();
+    notify();
+}
+/** Reopen the banner so the visitor can change their choice. */
+export function openConsentSettings() {
+    state().settingsOpen = true;
+    notify();
+}
+/** Whether the banner should show now, for the banner component. */
+export function shouldShowConsentBanner() {
+    const current = state();
+    if (current.settingsOpen)
+        return true;
+    return current.region === "consent" && !getConsentChoice();
+}
+export function subscribeConsent(listener) {
+    state().listeners.add(listener);
+    return () => state().listeners.delete(listener);
+}
+/** Run the scripts the page queued before this module loaded. */
+function drainScriptQueue() {
+    if (typeof window === "undefined")
+        return;
+    const holder = window;
+    const queued = holder[SCRIPT_QUEUE_KEY];
+    const push = (...entries) => {
+        for (const [category, run] of entries)
+            whenConsentAllows(category, run);
+        return 0;
+    };
+    holder[SCRIPT_QUEUE_KEY] = { push };
+    if (Array.isArray(queued))
+        push(...queued);
+}
+drainScriptQueue();

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

@@ -269,6 +269,8 @@ export declare function useResourceSuggestions(params: ListResourceSuggestionsPa
 export declare function useCreateResourceSuggestion(): import("@tanstack/react-query").UseMutationResult<ResourceSuggestion, Error, CreateResourceSuggestionInput, unknown>;
 export declare function useCreateResourceSuggestionProposal(): import("@tanstack/react-query").UseMutationResult<ResourceSuggestionProposalResult, Error, CreateResourceSuggestionProposalInput, unknown>;
 export declare function useDecideResourceSuggestionProposal(): import("@tanstack/react-query").UseMutationResult<ResourceSuggestionProposalResult, Error, DecideResourceSuggestionProposalInput, unknown>;
+/** Shows every listed proposal member as decided until the server answers. */
+export declare function proposalDecisionOverlay(input: DecideResourceSuggestionProposalInput, queryClient: QueryClient): ReviewOptimisticMutation;
 export declare function useDecideResourceSuggestion(): import("@tanstack/react-query").UseMutationResult<{
     suggestion: ResourceSuggestion;
     decision: unknown;

package/dist/client/review/use-review.js

@@ -547,7 +547,34 @@ export function useCreateResourceSuggestionProposal() {
     return useActionMutation("create-resource-suggestion-proposal");
 }
 export function useDecideResourceSuggestionProposal() {
-    return useActionMutation("decide-resource-suggestion-proposal");
+    return useOptimisticReviewMutation("decide-resource-suggestion-proposal", proposalDecisionOverlay);
+}
+/** Shows every listed proposal member as decided until the server answers. */
+export function proposalDecisionOverlay(input, queryClient) {
+    const [first] = input.members;
+    const resource = first && resourceForSuggestion(queryClient, first.id);
+    if (!resource)
+        return noSuggestionOverlay();
+    const memberIds = new Set(input.members.map((member) => member.id));
+    return {
+        action: "list-resource-suggestions",
+        resource,
+        transform: (data, params) => updateSuggestions(data, (suggestions) => suggestions.flatMap((suggestion) => {
+            if (!memberIds.has(suggestion.id))
+                return [suggestion];
+            const next = { ...suggestion, status: input.decision };
+            return matchesSuggestionQuery(params, next) ? [next] : [];
+        })),
+        onSuccess: (result) => (data, params) => {
+            const decided = new Map(result.suggestions.map((suggestion) => [suggestion.id, suggestion]));
+            return updateSuggestions(data, (suggestions) => suggestions.flatMap((suggestion) => {
+                const next = decided.get(suggestion.id);
+                if (!next)
+                    return [suggestion];
+                return matchesSuggestionQuery(params, next) ? [next] : [];
+            }));
+        },
+    };
 }
 export function useDecideResourceSuggestion() {
     return useOptimisticReviewMutation("decide-resource-suggestion", (input, queryClient) => {

package/dist/client/sharing/useResourceAccessGate.d.ts

@@ -30,8 +30,9 @@ export interface ResourceAccessGateOptions {
      * Called once when the status says the viewer can open the resource: either
      * the read that failed should be tried again, or the owner shared it while
      * this screen was open. The status is checked again whenever the window
-     * regains focus, including switching back from another browser window, and
-     * every half minute while the viewer's request is open.
+     * regains focus, including switching back from another browser window,
+     * every half minute while the viewer's request is open, and every 12 seconds
+     * while the resource is in Trash.
      */
     onAccessGranted?: () => void;
 }

package/dist/client/sharing/useResourceAccessGate.js

@@ -4,6 +4,10 @@ import { useActionMutation, useActionQuery } from "../use-action.js";
 // While a request is open, approving it should open the resource without a
 // manual reload, even when the window never loses focus.
 const PENDING_REQUEST_POLL_MS = 30_000;
+// This screen replaces the resource's own view, and with it that view's sync
+// poll, so a restore made elsewhere would otherwise wait for focus or the
+// app-wide idle poll, which backs off to minutes. 12 s is that view's poll.
+const TRASHED_POLL_MS = 12_000;
 function requestFailure(error) {
     const failure = error;
     return {
@@ -24,7 +28,11 @@ export function useResourceAccessGate({ resourceType, resourceId, enabled = true
         enabled,
         refetchOnWindowFocus: "always",
         staleTime: 0,
-        refetchInterval: (current) => current.state.data?.request ? PENDING_REQUEST_POLL_MS : false,
+        refetchInterval: (current) => current.state.data?.state === "trashed"
+            ? TRASHED_POLL_MS
+            : current.state.data?.request
+                ? PENDING_REQUEST_POLL_MS
+                : false,
     });
     const request = useActionMutation("request-resource-access");
     const state = query.data?.state;

package/dist/client/theme-family.d.ts

@@ -0,0 +1,35 @@
+import { type ThemeFamily } from "../appearance/theme-family.js";
+export { DEFAULT_THEME_FAMILY, isThemeFamily, THEME_FAMILY_APP_STATE_KEY, THEME_FAMILY_ATTRIBUTE, THEME_FAMILY_STORAGE_KEY, themeFamilyAppStateKey, themeFamilyStorageKey, type ThemeFamily, } from "../appearance/theme-family.js";
+export declare const THEME_FAMILY_CHANGE_EVENT = "agent-native:theme-family-change";
+export type ThemeFamilyStorageStatus = "valid" | "missing" | "invalid" | "unreadable";
+export type StoredThemeFamily = {
+    status: "valid";
+    family: ThemeFamily;
+} | {
+    status: "missing";
+} | {
+    status: "invalid";
+    value: string;
+} | {
+    status: "unreadable";
+    error: Error;
+};
+export interface ThemeFamilyApplyResult {
+    family: ThemeFamily;
+    storageStatus: "saved" | "unavailable";
+}
+export interface ThemeFamilyPreference {
+    family: ThemeFamily;
+    source: "default" | "user-setting";
+    appId: string | null;
+}
+export declare function readStoredThemeFamily(appId?: string | null): StoredThemeFamily;
+export declare function applyThemeFamily(family: ThemeFamily, appId?: string | null): ThemeFamilyApplyResult;
+export interface ThemeFamilyHook {
+    family: ThemeFamily;
+    status: "loading" | "success" | "error";
+    error?: Error;
+    storageStatus: ThemeFamilyStorageStatus;
+    setFamily: (family: ThemeFamily) => Promise<ThemeFamily>;
+}
+export declare function useThemeFamily(): ThemeFamilyHook;