@agent-native/core 0.216.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/collab/routes.d.ts

@@ -13,12 +13,12 @@ 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;
     liveCopy: "derived" | "not_derived" | "unchanged";
     liveCopyReason?: string;
+    error?: undefined;
     ok: boolean;
 } | {
     error?: undefined;

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

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

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

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

package/dist/localization/consent-banner-messages.d.ts

@@ -0,0 +1,16 @@
+import { type BuiltinLocaleCode, type LocaleCode } from "./shared.js";
+export interface ConsentBannerMessages {
+    label: string;
+    message: string;
+    privacyPolicy: string;
+    necessary: string;
+    performance: string;
+    targeting: string;
+    rejectAll: string;
+    acceptAll: string;
+    save: string;
+    manage: string;
+    cookieSettings: string;
+}
+export declare const CONSENT_BANNER_MESSAGES: Record<BuiltinLocaleCode, ConsentBannerMessages>;
+export declare function consentBannerMessagesForLocale(locale: LocaleCode): ConsentBannerMessages;

package/dist/localization/consent-banner-messages.js

@@ -0,0 +1,149 @@
+import { DEFAULT_LOCALE, isLocaleCode, } from "./shared.js";
+export const CONSENT_BANNER_MESSAGES = {
+    "en-US": {
+        label: "Cookie preferences",
+        message: "We use cookies to measure how this site is used and which ads bring visitors here.",
+        privacyPolicy: "Privacy policy",
+        necessary: "Strictly necessary",
+        performance: "Analytics",
+        targeting: "Advertising and attribution",
+        rejectAll: "Reject all",
+        acceptAll: "Accept all",
+        save: "Save choices",
+        manage: "Manage settings",
+        cookieSettings: "Cookie settings",
+    },
+    "es-ES": {
+        label: "Preferencias de cookies",
+        message: "Usamos cookies para medir cómo se usa este sitio y qué anuncios traen visitantes.",
+        privacyPolicy: "Política de privacidad",
+        necessary: "Estrictamente necesarias",
+        performance: "Analítica",
+        targeting: "Publicidad y atribución",
+        rejectAll: "Rechazar todas",
+        acceptAll: "Aceptar todas",
+        save: "Guardar selección",
+        manage: "Gestionar ajustes",
+        cookieSettings: "Configuración de cookies",
+    },
+    "fr-FR": {
+        label: "Préférences de cookies",
+        message: "Nous utilisons des cookies pour mesurer l’utilisation de ce site et savoir quelles publicités amènent des visiteurs.",
+        privacyPolicy: "Politique de confidentialité",
+        necessary: "Strictement nécessaires",
+        performance: "Mesure d’audience",
+        targeting: "Publicité et attribution",
+        rejectAll: "Tout refuser",
+        acceptAll: "Tout accepter",
+        save: "Enregistrer mes choix",
+        manage: "Gérer les paramètres",
+        cookieSettings: "Paramètres des cookies",
+    },
+    "de-DE": {
+        label: "Cookie-Einstellungen",
+        message: "Wir verwenden Cookies, um zu messen, wie diese Website genutzt wird und welche Anzeigen Besucher hierher bringen.",
+        privacyPolicy: "Datenschutzerklärung",
+        necessary: "Unbedingt erforderlich",
+        performance: "Analyse",
+        targeting: "Werbung und Attribution",
+        rejectAll: "Alle ablehnen",
+        acceptAll: "Alle akzeptieren",
+        save: "Auswahl speichern",
+        manage: "Einstellungen verwalten",
+        cookieSettings: "Cookie-Einstellungen",
+    },
+    "pt-BR": {
+        label: "Preferências de cookies",
+        message: "Usamos cookies para medir como este site é usado e quais anúncios trazem visitantes.",
+        privacyPolicy: "Política de privacidade",
+        necessary: "Estritamente necessários",
+        performance: "Análise",
+        targeting: "Publicidade e atribuição",
+        rejectAll: "Rejeitar todos",
+        acceptAll: "Aceitar todos",
+        save: "Salvar escolhas",
+        manage: "Gerenciar configurações",
+        cookieSettings: "Configurações de cookies",
+    },
+    "ja-JP": {
+        label: "Cookie の設定",
+        message: "このサイトの利用状況と、どの広告から訪問者が来ているかを測定するために Cookie を使用しています。",
+        privacyPolicy: "プライバシーポリシー",
+        necessary: "必須",
+        performance: "分析",
+        targeting: "広告とアトリビューション",
+        rejectAll: "すべて拒否",
+        acceptAll: "すべて許可",
+        save: "選択を保存",
+        manage: "設定を管理",
+        cookieSettings: "Cookie の設定",
+    },
+    "ko-KR": {
+        label: "쿠키 환경설정",
+        message: "이 사이트의 이용 방식과 방문자를 데려오는 광고를 측정하기 위해 쿠키를 사용합니다.",
+        privacyPolicy: "개인정보 처리방침",
+        necessary: "필수",
+        performance: "분석",
+        targeting: "광고 및 어트리뷰션",
+        rejectAll: "모두 거부",
+        acceptAll: "모두 허용",
+        save: "선택 저장",
+        manage: "설정 관리",
+        cookieSettings: "쿠키 설정",
+    },
+    "zh-CN": {
+        label: "Cookie 偏好设置",
+        message: "我们使用 Cookie 来衡量本网站的使用情况，以及哪些广告带来了访客。",
+        privacyPolicy: "隐私政策",
+        necessary: "绝对必要",
+        performance: "分析",
+        targeting: "广告与归因",
+        rejectAll: "全部拒绝",
+        acceptAll: "全部接受",
+        save: "保存选择",
+        manage: "管理设置",
+        cookieSettings: "Cookie 设置",
+    },
+    "zh-TW": {
+        label: "Cookie 偏好設定",
+        message: "我們使用 Cookie 來衡量本網站的使用情況，以及哪些廣告帶來了訪客。",
+        privacyPolicy: "隱私權政策",
+        necessary: "絕對必要",
+        performance: "分析",
+        targeting: "廣告與歸因",
+        rejectAll: "全部拒絕",
+        acceptAll: "全部接受",
+        save: "儲存選擇",
+        manage: "管理設定",
+        cookieSettings: "Cookie 設定",
+    },
+    "hi-IN": {
+        label: "कुकी प्राथमिकताएँ",
+        message: "हम यह मापने के लिए कुकी का उपयोग करते हैं कि यह साइट कैसे उपयोग होती है और कौन-से विज्ञापन विज़िटर लाते हैं।",
+        privacyPolicy: "गोपनीयता नीति",
+        necessary: "पूरी तरह आवश्यक",
+        performance: "एनालिटिक्स",
+        targeting: "विज्ञापन और एट्रिब्यूशन",
+        rejectAll: "सभी अस्वीकार करें",
+        acceptAll: "सभी स्वीकार करें",
+        save: "विकल्प सहेजें",
+        manage: "सेटिंग प्रबंधित करें",
+        cookieSettings: "कुकी सेटिंग",
+    },
+    "ar-SA": {
+        label: "تفضيلات ملفات تعريف الارتباط",
+        message: "نستخدم ملفات تعريف الارتباط لقياس كيفية استخدام هذا الموقع والإعلانات التي تجلب الزوار إليه.",
+        privacyPolicy: "سياسة الخصوصية",
+        necessary: "ضرورية للغاية",
+        performance: "التحليلات",
+        targeting: "الإعلانات والإسناد",
+        rejectAll: "رفض الكل",
+        acceptAll: "قبول الكل",
+        save: "حفظ الاختيارات",
+        manage: "إدارة الإعدادات",
+        cookieSettings: "إعدادات ملفات تعريف الارتباط",
+    },
+};
+export function consentBannerMessagesForLocale(locale) {
+    return CONSENT_BANNER_MESSAGES[isLocaleCode(locale) ? locale : DEFAULT_LOCALE];
+}

package/dist/localization/core-messages.js

@@ -1,4 +1,5 @@
 import { agentResourcePackMessagesForLocale } from "./agent-resources-messages.js";
+import { consentBannerMessagesForLocale } from "./consent-banner-messages.js";
 import * as englishSupplementalMessages from "./core-messages/supplemental/en-US.js";
 import { environmentBadgeMessagesForLocale } from "./environment-badge-messages.js";
 import { iconPickerMessagesForLocale } from "./icon-picker-messages.js";
@@ -90,6 +91,7 @@ export async function loadCoreMessagesForLocale(locale) {
     const supplementalMessages = await supplementalLoader();
     return {
         agentResources: agentResourcePackMessagesForLocale(locale),
+        consentBanner: consentBannerMessagesForLocale(locale),
         environmentBadge: environmentBadgeMessagesForLocale(locale),
         iconPicker: iconPickerMessagesForLocale(locale),
         settings: {
@@ -100,6 +102,7 @@ export async function loadCoreMessagesForLocale(locale) {
 }
 const englishCoreMessages = {
     agentResources: agentResourcePackMessagesForLocale(DEFAULT_LOCALE),
+    consentBanner: consentBannerMessagesForLocale(DEFAULT_LOCALE),
     environmentBadge: englishSupplementalMessages.environmentBadgeMessages,
     iconPicker: iconPickerMessagesForLocale(DEFAULT_LOCALE),
     settings: {
@@ -112,6 +115,7 @@ export function coreMessagesForLocale(locale) {
         return englishCoreMessages;
     }
     return {
+        consentBanner: consentBannerMessagesForLocale(locale),
         environmentBadge: environmentBadgeMessagesForLocale(locale),
     };
 }

package/dist/localization/default-messages.d.ts

@@ -110,6 +110,7 @@ declare const messages: {
             chatgptPlanUsageUnavailable: string;
         };
     };
+    consentBanner: import("./consent-banner-messages.js").ConsentBannerMessages;
     environmentBadge: import("./environment-badge-messages.js").EnvironmentBadgeMessages;
     workspaceFile: {
         download: string;

package/dist/localization/default-messages.js

@@ -1,4 +1,5 @@
 import { PASSWORD_MIN_LENGTH_MESSAGE } from "../shared/password-policy.js";
+import { CONSENT_BANNER_MESSAGES } from "./consent-banner-messages.js";
 import { environmentBadgeMessages } from "./core-messages/supplemental/en-US.js";
 import { ICON_PICKER_MESSAGES } from "./icon-picker-messages.js";
 const messages = {
@@ -33,6 +34,7 @@ const messages = {
             chatgptPlanUsageUnavailable: "OpenAI couldn’t check this ChatGPT plan’s usage limit. Check ChatGPT usage or try another model.",
         },
     },
+    consentBanner: CONSENT_BANNER_MESSAGES["en-US"],
     environmentBadge: environmentBadgeMessages,
     workspaceFile: {
         download: "Download",

package/dist/mcp/screen-memory-stdio.d.ts

@@ -140,13 +140,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
         required?: undefined;
     };
@@ -171,13 +171,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
         required?: undefined;
     };
@@ -196,13 +196,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
         required?: undefined;
     };
@@ -231,13 +231,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
     };
 } | {
@@ -260,12 +260,12 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
     };
 } | {
@@ -317,7 +317,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -337,6 +336,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 type: string;
             };
             requestId?: undefined;
+            count?: undefined;
         };
     };
 } | {
@@ -352,7 +352,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -361,6 +360,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             requestId: {
                 type: string;
             };
+            count?: undefined;
         };
     };
 })[];

package/dist/notifications/routes.d.ts

@@ -1,13 +1,13 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
     updated?: undefined;
-    error?: undefined;
     ok?: undefined;
+    error?: undefined;
 } | {
     count?: undefined;
     updated: number;
-    error?: undefined;
     ok?: undefined;
+    error?: undefined;
 } | {
     count?: undefined;
     updated?: undefined;

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;
 } | {
+    ok?: undefined;
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     error?: undefined;
-    ok?: undefined;
 } | {
+    ok?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
     error?: undefined;
-    ok?: 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;
 } | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;