@agent-native/core 0.214.0 → 0.217.0

package/dist/client/session-replay.js

@@ -3,6 +3,7 @@ import { resolveLaneEndpoint } from "../shared/environment-lanes.js";
 import { loadOptionalPeer, OptionalPeerDependencyError, } from "../shared/optional-peer.js";
 import { isSyntheticTrafficValue } from "../shared/test-traffic.js";
 import { getOrCreateAnalyticsAnonymousId, getOrCreateAnalyticsSessionId, } from "./analytics-session.js";
+import { whenConsentAllows } from "./consent.js";
 import { replayEndpointFromAnalyticsEndpoint } from "./session-replay-endpoint.js";
 import { SESSION_REPLAY_BLOCK_ATTRIBUTE, SESSION_REPLAY_MASK_ATTRIBUTE, } from "./session-replay-privacy.js";
 import { decideReplayQuotaResponse, parseRetryAfterSeconds, } from "./session-replay-quota.js";
@@ -1173,6 +1174,8 @@ function isDefinitiveReplayUploadClientError(status) {
 }
 const MAX_TRANSIENT_REPLAY_CLIENT_FAILURES = 3;
 const REPLAY_UPLOAD_TIMEOUT_MS = 15_000;
+// Uploads in flight, so a consent reject can abort them.
+const activeReplayUploads = new Set();
 function startReplayUploadTimeout() {
     const controller = typeof AbortController === "undefined" ? undefined : new AbortController();
     let rejectTimeout;
@@ -1186,11 +1189,17 @@ function startReplayUploadTimeout() {
         controller?.abort();
         rejectTimeout(timeoutError);
     }, REPLAY_UPLOAD_TIMEOUT_MS);
+    if (controller)
+        activeReplayUploads.add(controller);
     return {
         signal: controller?.signal,
         promise,
         didTimeout: () => timedOut,
-        done: () => clearTimeout(timer),
+        done: () => {
+            clearTimeout(timer);
+            if (controller)
+                activeReplayUploads.delete(controller);
+        },
     };
 }
 function isTransientReplayUploadClientError(status) {
@@ -1543,6 +1552,13 @@ export async function flushSessionReplay(reason = "manual") {
     const state = getState();
     if (!state.options)
         return;
+    if (replayConsentWithdrawn) {
+        // An upload in flight at the reject can put its batch back; drop it.
+        discardWithdrawnReplay(state);
+        for (const resolve of state.pendingFlushWaiters.splice(0))
+            resolve();
+        return;
+    }
     if (replayUploadsParked(state, Date.now()))
         return;
     if (state.pendingReplayUpload) {
@@ -1586,6 +1602,9 @@ export async function flushSessionReplay(reason = "manual") {
         return;
     }
     state.flushing = true;
+    // A reject while this upload is in flight withdraws its events for good,
+    // even if the visitor accepts again before it settles.
+    const consentGeneration = replayConsentGeneration;
     let uploaded = false;
     let reservedSequence = false;
     let splitRejectedBatch = false;
@@ -1609,6 +1628,9 @@ export async function flushSessionReplay(reason = "manual") {
         // between; it is queued as the pending reason.
         const outcome = await sendReplayUpload(state.options, payload.body, {
             beforeUpload: (keepalive) => {
+                // Compression can take long enough for a reject to land first.
+                if (consentGeneration !== replayConsentGeneration)
+                    return "defer";
                 const pendingReason = state.pendingFlushReason;
                 if (!keepalive &&
                     (isPageLeaveReplayFlushReason(reason) ||
@@ -1622,7 +1644,9 @@ export async function flushSessionReplay(reason = "manual") {
             },
         });
         if (outcome === "deferred") {
-            restoreReplayEvents(state, events);
+            if (consentGeneration === replayConsentGeneration) {
+                restoreReplayEvents(state, events);
+            }
         }
         else {
             state.automaticConflictRestartAttempted = false;
@@ -1686,7 +1710,10 @@ export async function flushSessionReplay(reason = "manual") {
                         quotaDecision?.kind === "stop") &&
                     !splitBatch &&
                     !isUnsplittableOversizedBatch;
-            if (splitBatch) {
+            if (consentGeneration !== replayConsentGeneration) {
+                // Withdrawn while in flight; nothing goes back on the queue.
+            }
+            else if (splitBatch) {
                 state.retryBatches.unshift(...splitBatch);
                 splitRejectedBatch = true;
             }
@@ -1811,10 +1838,18 @@ export async function flushSessionReplay(reason = "manual") {
         if (shouldRestartAfterConflict) {
             state.automaticConflictRestartAttempted = true;
         }
+        // The stop forgets the caller's start; a recovered recording keeps it,
+        // so a reject and a later accept can bring it back.
+        const consentStartOptions = replayAllowedOptions;
         await stopSessionReplay("upload-rejected");
         let restartResult = null;
         if (shouldRestartAfterConflict && rejectedOptions) {
             restartResult = await restartSessionReplayWithFreshIdentity(state, rejectedOptions, payload.sessionId);
+            if (restartResult.started)
+                replayAllowedOptions = consentStartOptions;
+            // A reject during the recovery leaves the start for the next accept.
+            if (!replayConsentGranted)
+                replayAwaitingConsent ??= consentStartOptions;
         }
         const details = {
             status: definitiveClientErrorStatus,
@@ -1861,6 +1896,16 @@ async function restartSessionReplayWithFreshIdentityInternal(state, options, ses
     if (options.shouldStart && !options.shouldStart()) {
         return { started: false, reason: "disabled", sessionId, sampled: true };
     }
+    // Recovery restarts without going through startSessionReplay, so a reject
+    // that landed while the old recording stopped must still hold here.
+    if (!replayConsentGranted) {
+        return {
+            started: false,
+            reason: "consent-required",
+            sessionId,
+            sampled: true,
+        };
+    }
     const initialProperties = replayExtraProperties(options);
     if (options.requireSignedInUser && !replayUserEmail(initialProperties)) {
         return {
@@ -2687,6 +2732,81 @@ function installCaptureInterceptors(state) {
         }
     };
 }
+let replayConsentWatched = false;
+let replayConsentGranted = false;
+let replayConsentWithdrawn = false;
+let replayConsentGeneration = 0;
+let replayAllowedOptions = null;
+function discardWithdrawnReplay(state) {
+    for (const upload of activeReplayUploads)
+        upload.abort();
+    activeReplayUploads.clear();
+    state.queue = [];
+    state.queuedBytes = 0;
+    state.retryBatches = [];
+    state.pendingFlushReason = null;
+    for (const resolve of state.pendingFlushWaiters.splice(0))
+        resolve();
+}
+let replayAwaitingConsent = null;
+let replayCallerStops = 0;
+/**
+ * Replay waits for analytics consent where the banner applies, without the
+ * time zone's early guess: a recording that already uploaded can't be undone.
+ * A start asked for before the answer runs once consent arrives.
+ */
+function replayConsentAllows(options) {
+    if (!replayConsentWatched) {
+        replayConsentWatched = true;
+        whenConsentAllows("performance", () => {
+            replayConsentGranted = true;
+            // What an upload in flight at the reject put back stays withdrawn.
+            if (replayConsentWithdrawn)
+                discardWithdrawnReplay(getState());
+            replayConsentWithdrawn = false;
+            const waiting = replayAwaitingConsent;
+            replayAwaitingConsent = null;
+            if (!waiting)
+                return;
+            // A reject during the last start cancels it, and an accept that
+            // quickly gets that canceled start back; ask once more after it.
+            const stops = replayCallerStops;
+            void startSessionReplay(waiting).then((result) => {
+                if (!result.started &&
+                    replayConsentGranted &&
+                    !getState().active &&
+                    replayCallerStops === stops) {
+                    void startSessionReplay(waiting);
+                }
+            });
+        }, {
+            // The region's first answer revokes before any choice, so a start
+            // asked for earlier keeps waiting for an accept.
+            revoke: () => {
+                const wasGranted = replayConsentGranted;
+                replayConsentGranted = false;
+                if (!wasGranted) {
+                    // A replay id an earlier page stored never carries past a reject.
+                    const storedReplayId = readStoredReplaySession()?.replayId;
+                    if (storedReplayId)
+                        removeStoredReplaySession(storedReplayId);
+                    return;
+                }
+                replayConsentWithdrawn = true;
+                replayConsentGeneration += 1;
+                // A fresh accept on this page records again, under a new identity.
+                replayAwaitingConsent = replayAllowedOptions ?? replayAwaitingConsent;
+                void stopSessionReplay("consent-revoked");
+            },
+        });
+    }
+    if (replayConsentGranted) {
+        replayAllowedOptions = options;
+        return true;
+    }
+    replayAwaitingConsent = options;
+    return false;
+}
 export async function startSessionReplay(options = {}) {
     if (isSyntheticBrowserTraffic()) {
         return { started: false, reason: "disabled" };
@@ -2702,6 +2822,9 @@ export async function startSessionReplay(options = {}) {
     const normalized = normalizeOptions(options);
     if (!normalized)
         return { started: false, reason: "missing-public-key" };
+    if (!replayConsentAllows(options)) {
+        return { started: false, reason: "consent-required" };
+    }
     const sessionId = getOrCreateAnalyticsSessionId();
     if (!sessionId)
         return { started: false, reason: "missing-session-id" };
@@ -2965,6 +3088,19 @@ export async function stopSessionReplay(reason = "manual") {
     if (reason !== "pagehide-persisted") {
         state.bfcacheRestored = false;
     }
+    if (reason === "consent-revoked") {
+        // Also when recording already stopped: a later accept starts afresh.
+        const storedReplayId = state.replayId ?? readStoredReplaySession()?.replayId;
+        discardWithdrawnReplay(state);
+        if (storedReplayId)
+            removeStoredReplaySession(storedReplayId);
+    }
+    else if (reason !== "upload-timeout") {
+        // Any other stop is final: a later accept doesn't bring it back.
+        replayAwaitingConsent = null;
+        replayAllowedOptions = null;
+        replayCallerStops += 1;
+    }
     if (!state.active) {
         if (authClearedReplayId)
             removeStoredReplaySession(authClearedReplayId);
@@ -3024,6 +3160,9 @@ export async function stopSessionReplay(reason = "manual") {
         // best-effort cleanup
     }
     state.broadcastChannel = null;
+    // A reject withdraws what is still buffered, so it is never uploaded.
+    if (reason === "consent-revoked")
+        return;
     const sequenceBeforeFinalFlush = state.sequence;
     try {
         await flushSessionReplay(reason);

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/use-chat-thread-list.d.ts

@@ -6,6 +6,8 @@ export interface UseChatThreadListOptions {
     pageSize?: number;
     scope?: ChatThreadScope | null;
     includeExternal?: boolean;
+    /** Include archived threads. Defaults to false. */
+    includeArchived?: boolean;
     /** Search text. Empty lists the whole set. */
     query?: string;
     /** When false nothing is fetched and the list is empty. Defaults to true. */

package/dist/client/use-chat-thread-list.js

@@ -48,7 +48,7 @@ function createListState(identity, enabled) {
  * rather than collapsing to the first page.
  */
 export function useChatThreadList(options) {
-    const { ownership, includeExternal = false, enabled = true, refreshOnThreadUpdates = true, } = options;
+    const { ownership, includeExternal = false, includeArchived = false, enabled = true, refreshOnThreadUpdates = true, } = options;
     const apiUrl = options.apiUrl ?? agentNativePath("/_agent-native/agent-chat");
     const pageSize = resolvePageSize(options.pageSize);
     const query = options.query?.trim() ?? "";
@@ -62,6 +62,7 @@ export function useChatThreadList(options) {
         scopeId,
         pageSize,
         includeExternal,
+        includeArchived,
         enabled,
     ]);
     const [stored, setState] = useState(() => createListState(identity, enabled));
@@ -89,6 +90,7 @@ export function useChatThreadList(options) {
         query,
         ownership,
         includeExternal,
+        includeArchived,
         scope: scopeType && scopeId ? { type: scopeType, id: scopeId } : null,
     }).then((result) => {
         if (result.hasMore === undefined) {
@@ -100,7 +102,15 @@ export function useChatThreadList(options) {
             throw new ChatThreadListError("Chat history response reported more threads but returned none.");
         }
         return { threads: result.threads, hasMore: result.hasMore };
-    }), [apiUrl, includeExternal, ownership, query, scopeId, scopeType]);
+    }), [
+        apiUrl,
+        includeArchived,
+        includeExternal,
+        ownership,
+        query,
+        scopeId,
+        scopeType,
+    ]);
     // Reload the first `window` server rows, one capped page at a time, and swap
     // them in only once every page has arrived. A failure part-way leaves the
     // rows and offset already on screen untouched.

package/dist/client/use-chat-threads.d.ts

@@ -98,6 +98,7 @@ export interface ChatThreadListPageRequest {
     query?: string;
     ownership?: ChatThreadOwnership;
     includeExternal?: boolean;
+    includeArchived?: boolean;
     scope?: ChatThreadScope | null;
 }
 /** A listed thread as the server returns it: ownership metadata always present. */

package/dist/client/use-chat-threads.js

@@ -120,6 +120,8 @@ async function requestChatThreadListPage(request) {
     }
     if (request.includeExternal)
         params.set("includeExternal", "1");
+    if (request.includeArchived)
+        params.set("includeArchived", "1");
     appendChatThreadScopeParams(params, request.scope);
     const search = params.toString();
     const res = await fetch(`${apiUrl}/threads${search ? `?${search}` : ""}`);

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

@@ -1,5 +1,5 @@
 export type WorkspaceConnectionCapability = "search" | "import" | "messages" | "meetings" | "crm" | "code" | "docs";
-export type WorkspaceConnectionTemplateUse = "analytics" | "brain" | "calendar" | "clips" | "content" | "crm" | "design" | "dispatch" | "factory" | "forms" | "mail" | "slides";
+export type WorkspaceConnectionTemplateUse = "analytics" | "brain" | "calendar" | "clips" | "content" | "crm" | "design" | "dispatch" | "factory" | "forms" | "mail" | "slides" | "slides-2";
 export type WorkspaceConnectionProviderId = "slack" | "github" | "figma" | "notion" | "gmail" | "google_calendar" | "google_drive" | "bigquery" | "google_docs" | "google_sheets" | "google_slides" | "hubspot" | "salesforce" | "jira" | "sentry" | "granola" | "clips" | "dbt" | "sigma" | "anthropic-managed-agents" | "generic";
 export interface WorkspaceConnectionCredentialKey {
     key: string;
@@ -84,7 +84,7 @@ export declare const WORKSPACE_CONNECTION_PROVIDERS: readonly [{
         readonly scopes: readonly ["current_user:read", "file_content:read", "file_metadata:read", "projects:read"];
     };
     readonly capabilities: readonly ["search", "import", "docs"];
-    readonly recommendedTemplateUses: readonly ["brain", "design", "slides", "content"];
+    readonly recommendedTemplateUses: readonly ["brain", "design", "slides", "slides-2", "content"];
 }, {
     readonly id: "notion";
     readonly label: "Notion";
@@ -184,7 +184,7 @@ export declare const WORKSPACE_CONNECTION_PROVIDERS: readonly [{
         readonly required: true;
     }];
     readonly capabilities: readonly ["search", "import", "docs"];
-    readonly recommendedTemplateUses: readonly ["brain", "content", "slides", "dispatch", "analytics"];
+    readonly recommendedTemplateUses: readonly ["brain", "content", "slides", "slides-2", "dispatch", "analytics"];
     readonly oauth: {
         authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth";
         tokenUrl: "https://oauth2.googleapis.com/token";
@@ -207,7 +207,7 @@ export declare const WORKSPACE_CONNECTION_PROVIDERS: readonly [{
         readonly required: true;
     }];
     readonly capabilities: readonly ["search", "import", "docs"];
-    readonly recommendedTemplateUses: readonly ["brain", "content", "slides", "dispatch"];
+    readonly recommendedTemplateUses: readonly ["brain", "content", "slides", "slides-2", "dispatch"];
     readonly oauth: {
         authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth";
         tokenUrl: "https://oauth2.googleapis.com/token";
@@ -253,7 +253,7 @@ export declare const WORKSPACE_CONNECTION_PROVIDERS: readonly [{
         readonly required: true;
     }];
     readonly capabilities: readonly ["search", "import", "docs"];
-    readonly recommendedTemplateUses: readonly ["brain", "content", "slides", "dispatch"];
+    readonly recommendedTemplateUses: readonly ["brain", "content", "slides", "slides-2", "dispatch"];
     readonly oauth: {
         authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth";
         tokenUrl: "https://oauth2.googleapis.com/token";

package/dist/connections/catalog.js

@@ -92,7 +92,13 @@ export const WORKSPACE_CONNECTION_PROVIDERS = [
             ],
         },
         capabilities: ["search", "import", "docs"],
-        recommendedTemplateUses: ["brain", "design", "slides", "content"],
+        recommendedTemplateUses: [
+            "brain",
+            "design",
+            "slides",
+            "slides-2",
+            "content",
+        ],
     }),
     defineWorkspaceConnectionProvider({
         id: "notion",
@@ -161,6 +167,7 @@ export const WORKSPACE_CONNECTION_PROVIDERS = [
             "brain",
             "content",
             "slides",
+            "slides-2",
             "dispatch",
             "analytics",
         ],
@@ -176,7 +183,13 @@ export const WORKSPACE_CONNECTION_PROVIDERS = [
         description: "Google Docs files for source material, document search, and agent-assisted writing workflows.",
         credentialKeys: GOOGLE_CREDENTIAL_KEYS,
         capabilities: ["search", "import", "docs"],
-        recommendedTemplateUses: ["brain", "content", "slides", "dispatch"],
+        recommendedTemplateUses: [
+            "brain",
+            "content",
+            "slides",
+            "slides-2",
+            "dispatch",
+        ],
         oauth: googleOAuth([
             ...GOOGLE_IDENTITY_SCOPES,
             "https://www.googleapis.com/auth/documents.readonly",
@@ -197,7 +210,13 @@ export const WORKSPACE_CONNECTION_PROVIDERS = [
         description: "Google Slides presentations for reference imports, visual context, and presentation workflows.",
         credentialKeys: GOOGLE_CREDENTIAL_KEYS,
         capabilities: ["search", "import", "docs"],
-        recommendedTemplateUses: ["brain", "content", "slides", "dispatch"],
+        recommendedTemplateUses: [
+            "brain",
+            "content",
+            "slides",
+            "slides-2",
+            "dispatch",
+        ],
         oauth: googleOAuth([
             ...GOOGLE_IDENTITY_SCOPES,
             "https://www.googleapis.com/auth/presentations.readonly",