@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/web-ui/app/notifications-feature.js

@@ -0,0 +1,95 @@
+import { mountNotificationsDom } from "./components/notifications/dom.js";
+import { createNotificationsWorkspace } from "./components/notifications/workspace.js";
+import { createNotificationsController } from "./controllers/notifications-controller.js";
+import { createNotificationPresence } from "./controllers/notification-presence.js";
+import { createHomeNotificationsEntry } from "./components/notifications/home-entry.js";
+import { notificationSourceUrl } from "./components/notifications/presentation.js";
+
+function isNotificationSummaryWorkspace(workspace) {
+  return ["notifications", "home"].includes(workspace);
+}
+
+export function createNotificationsFeature({ dom, state, client, shell, getEnvironmentId, send }) {
+  mountNotificationsDom(dom);
+  let view;
+  let environmentRevision = 0;
+  const homeEntry = createHomeNotificationsEntry({
+    homePanel: dom.homeWorkspacePanel,
+    onOpen: () => {
+      if (!shell.activateWorkspace("notifications")) return;
+      controller.setFilter("unread");
+    },
+  });
+  const controller = createNotificationsController({
+    client, getEnvironmentId, render: (snapshot) => {
+      view?.render(snapshot);
+      homeEntry.render(snapshot);
+      refreshAvailability();
+    },
+  });
+  const presence = createNotificationPresence({
+    getEnvironmentId,
+    getSessionId: () => state.currentSessionId,
+    getWorkspace: shell.activeWorkspace,
+    isConnected: () => state.connected && client.supportsNotifications(),
+    send,
+  });
+  function canOpenNotificationSource(item) {
+    if (!client.supportsNotifications()) return false;
+    if (item.environmentId !== getEnvironmentId()) return false;
+    return shell.activeWorkspace() === "notifications";
+  }
+  async function openNotificationSource(item) {
+    if (!canOpenNotificationSource(item)) return;
+    const source = notificationSourceUrl(item);
+    if (!source) return;
+    const environmentVersion = environmentRevision;
+    const navigationVersion = shell.navigationRevision();
+    await controller.markRead(item.id, true);
+    if (!canOpenNotificationSource(item)) return;
+    if (environmentVersion !== environmentRevision) return;
+    if (navigationVersion !== shell.navigationRevision()) return;
+    window.location.assign(source);
+  }
+  function refreshAvailability() {
+    const available = client.supportsNotifications();
+    dom.notificationsWorkspaceButton.hidden = !available;
+    dom.notificationsWorkspaceButton.disabled = !available || dom.notificationsWorkspaceButton.dataset.onboardingBlocked === "true";
+    if (available) return;
+    if (shell.activeWorkspace() !== "notifications") return;
+    shell.activateWorkspace("chat", { focus: false });
+  }
+  view = createNotificationsWorkspace({
+    root: dom.notificationsRoot,
+    button: dom.notificationsWorkspaceButton,
+    badge: dom.notificationsBadge,
+    actions: { ...controller, openSource: openNotificationSource },
+  });
+  controller.publish();
+  return {
+    ...controller,
+    refreshAvailability,
+    isWorkspaceAvailable(destination) {
+      if (destination !== "notifications") return true;
+      return client.supportsNotifications();
+    },
+    bind() {
+      presence.bind();
+      document.addEventListener("visibilitychange", controller.visibilityChanged);
+    },
+    presenceChanged: presence.changed,
+    workspaceChanged(workspace) {
+      presence.changed();
+      controller.setActive(isNotificationSummaryWorkspace(workspace));
+    },
+    environmentChanged() {
+      environmentRevision += 1;
+      presence.changed();
+      controller.environmentChanged();
+    },
+    reconnect() {
+      presence.reconnect();
+      void controller.refresh();
+    },
+  };
+}

package/dist/src/web-ui/app/passive-learning-feature.js

@@ -0,0 +1,98 @@
+import { createMacCollectionConsent } from "./components/passive-learning/macos-collection-consent.js";
+import { createPassiveLearningController } from "./controllers/passive-learning-controller.js";
+import { createPassiveLearningHome } from "./components/passive-learning/home.js";
+import { createPassiveLearningMemory } from "./components/passive-learning/memory.js";
+import { selectLearningView } from "./components/passive-learning/workspace-view.js";
+import { createProposalNotifications } from "./components/passive-learning/proposal-notifications.js";
+import { visibleProposalSnapshot } from "./components/passive-learning/proposal-read-state.js";
+
+export function createPassiveLearningFeature({
+  client,
+  getEnvironmentId,
+  learningRoot,
+  openLearning,
+  showActivityMemories,
+  openComputerAccess,
+  openSession = () => {},
+  activateChat = () => true,
+  onChange = () => {},
+}) {
+  let home;
+  let memory;
+  let sessionSnapshot;
+  let collectionConsent;
+  function renderViews(snapshot) {
+    collectionConsent?.update(snapshot);
+    const visibleSnapshot = visibleProposalSnapshot(snapshot, sessionSnapshot);
+    home?.render(visibleSnapshot);
+    memory?.render(visibleSnapshot);
+  }
+  async function openConversation(sessionId, environmentId) {
+    if (environmentId !== getEnvironmentId()) return false;
+    if (activateChat() === false) return false;
+    await openSession(sessionId);
+    return true;
+  }
+  const controller = createPassiveLearningController({
+    client,
+    getEnvironmentId,
+    openSession: openConversation,
+    render: (snapshot) => {
+      renderViews(snapshot);
+      onChange();
+    },
+  });
+  collectionConsent = createMacCollectionConsent({
+    actions: controller,
+    container: learningRoot,
+  });
+  const actions = { ...controller, configure: collectionConsent.configure };
+  home = createPassiveLearningHome({
+    actions,
+    openLearning,
+    openComputerAccess,
+    openSetup: () => {
+      if (openLearning() === false) return;
+      if (learningRoot) selectLearningView(learningRoot, "settings");
+    },
+  });
+  memory = createPassiveLearningMemory({
+    actions,
+    showActivityMemories,
+    openComputerAccess,
+  });
+  memory.mount(learningRoot);
+  const notifications = createProposalNotifications({
+    getEnvironmentId,
+    openSession: openConversation,
+  });
+  return Object.freeze({
+    ...actions,
+    setWorkspace(workspace) {
+      collectionConsent.cancel();
+      controller.setWorkspace(workspace);
+    },
+    handleRealtime(message) {
+      if (message?.type === "system-host.changed") collectionConsent.cancel();
+      notifications.handleRealtime(message);
+      controller.handleRealtime(message);
+    },
+    environmentChanged() {
+      collectionConsent.cancel();
+      sessionSnapshot = undefined;
+      notifications.environmentChanged();
+      controller.environmentChanged();
+    },
+    updateSessions(snapshot) {
+      if (snapshot.environmentId !== getEnvironmentId()) return;
+      sessionSnapshot = snapshot;
+      renderViews(controller.snapshot());
+    },
+    mountHome: (root) => {
+      home.mount(root);
+      home.render(
+        visibleProposalSnapshot(controller.snapshot(), sessionSnapshot),
+      );
+    },
+  });
+}

package/dist/src/web-ui/app/projects-feature.js

@@ -1,3 +1,4 @@
+import { escapeHtml } from "./lib/text-format.js";
 import { createProjectsController } from "./controllers/projects-controller.js";
 import { createProjectCreation } from "./components/project-creation.js";
 import { renderProjectSessionGroups } from "./components/project-session-groups.js";
@@ -16,6 +17,9 @@ export function createProjectsFeature({
 }) {
   let view;
   let wasOpen = false;
+  let groupEnvironmentId = selectedEnvironmentId();
+  const collapsedProjectIds = new Set();
+  const expandedProjectSessionIds = new Set();
   const controller = createProjectsController({
     client,
     getEnvironmentId: selectedEnvironmentId,
@@ -60,10 +64,42 @@ export function createProjectsFeature({
     const hadOpenDraft = Boolean(controller.snapshot().draft);
     const closed = controller.closeCreate();
     if (!hadOpenDraft) return closed;
-    if (closed) dom.newProjectButton.focus();
+    if (!closed) return closed;
+    const focusTarget = dom.sessionsPanel.hidden
+      ? dom.sessionsToggleButton
+      : dom.newProjectButton;
+    focusTarget.focus();
     return closed;
   }
 
+  function syncProjectGroupEnvironment() {
+    const environmentId = selectedEnvironmentId();
+    if (groupEnvironmentId === environmentId) return;
+    groupEnvironmentId = environmentId;
+    collapsedProjectIds.clear();
+    expandedProjectSessionIds.clear();
+  }
+
+  function rememberProjectGroupCollapse(projectId, collapsed) {
+    syncProjectGroupEnvironment();
+    const isSearchingSessions = Boolean(String(state.sessionQuery ?? "").trim());
+    if (isSearchingSessions) return;
+    if (collapsed) {
+      collapsedProjectIds.add(projectId);
+      return;
+    }
+    collapsedProjectIds.delete(projectId);
+  }
+
+  function rememberProjectSessionExpansion(projectId, expanded) {
+    syncProjectGroupEnvironment();
+    if (expanded) {
+      expandedProjectSessionIds.add(projectId);
+      return;
+    }
+    expandedProjectSessionIds.delete(projectId);
+  }
+
   function refreshAvailability() {
     const available = client.supportsProjects();
     dom.newProjectButton.disabled = !available;
@@ -76,12 +112,15 @@ export function createProjectsFeature({
     load: controller.load,
     refreshAvailability,
     renderSessionGroups({ root, sessions, createSessionItem }) {
+      syncProjectGroupEnvironment();
       const project = state.sessions.find(
         (session) => session.id === state.currentSessionId,
       )?.project;
       dom.currentProjectContext.hidden = !project;
-      dom.currentProjectContext.textContent = project
-        ? `${project.name} · ${project.directory}`
+      dom.currentProjectContext.innerHTML = project
+        ? `<bdi class="current-project-name" dir="auto">${escapeHtml(project.name)}</bdi>
+           <span aria-hidden="true">·</span>
+           <bdi class="current-project-path" dir="ltr">${escapeHtml(project.directory)}</bdi>`
         : "";
       dom.currentProjectContext.title = project?.directory || "";
       if (!client.supportsProjects()) return false;
@@ -91,6 +130,10 @@ export function createProjectsFeature({
         createSessionItem,
         ...controller.snapshot(),
         query: state.sessionQuery,
+        collapsedProjectIds,
+        expandedProjectSessionIds,
+        onToggleGroup: rememberProjectGroupCollapse,
+        onToggleProjectSessions: rememberProjectSessionExpansion,
         onNewConversation: controller.newConversation,
         onRetry: () => void controller.load(),
       });
@@ -118,6 +161,7 @@ export function createProjectsFeature({
       });
       dom.environmentSelect.addEventListener("change", () => {
         queueMicrotask(() => {
+          syncProjectGroupEnvironment();
           refreshAvailability();
           void controller.environmentChanged();
         });

package/dist/src/web-ui/app/runtime-onboarding-feature.js

@@ -5,6 +5,7 @@ import { createRuntimeOnboardingController } from "./controllers/runtime-onboard
 
 export function createRuntimeOnboardingFeature({
   dom,
+  shell,
   runtimeClient,
   selectedEnvironmentId,
   state,
@@ -35,7 +36,7 @@ export function createRuntimeOnboardingFeature({
     return createRuntimeSetupGuide({
       ...common,
       loadSetup: () => runtimeClient.getRuntimeSetup(),
-      openConfiguration: () => dom.configWorkspaceButton?.click(),
+      openConfiguration: () => dom.modelsWorkspaceButton?.click(),
       saveSetup: (input) => runtimeClient.saveRuntimeSetup(input),
       applySetup: () =>
         runtimeClient.applyRuntimeConfiguration(selectedEnvironmentId()),
@@ -49,6 +50,8 @@ export function createRuntimeOnboardingFeature({
       loadPlugins: () => runtimeClient.getRuntimePlugins(),
       setPlugin: (input) => runtimeClient.setRuntimePlugin(input),
       loadHostConnection: () => runtimeClient.getSystemHostConnection(),
+      connectLocalHost: () => runtimeClient.connectLocalSystemHost(),
+      createHostPairing: () => runtimeClient.createSystemHostPairing(),
       downloadHostSetup: (platform) =>
         runtimeClient.downloadSystemHostSetup(platform),
       revokeHostConnection: () => runtimeClient.revokeSystemHostConnection(),
@@ -62,6 +65,7 @@ export function createRuntimeOnboardingFeature({
       selectedGuide?.bind(options);
     },
     render(availability) {
+      shell?.runtimeAvailabilityChanged(availability);
       const hasConfiguredBackend = ["runtime", "bridge"].includes(
         state.config?.backend,
       );

package/dist/src/web-ui/app/schedules-feature.js

@@ -9,13 +9,25 @@ export function createSchedulesFeature({
   getCurrentSessionId,
   getAgentModes,
   openSession,
+  onNavigationChange = () => {},
+  documentRoot = globalThis.document,
+  isRuntimeReady = () => true,
 }) {
   let view;
   let active = false;
+  let navigationRevision = 0;
+  let runtimeReady = isRuntimeReady();
   const controller = createSchedulesController({
     client,
     getEnvironmentId: selectedEnvironmentId,
-    render: (snapshot) => view?.render(snapshot),
+    onRouteSelectionChange: () => {
+      navigationRevision += 1;
+    },
+    isVisible: isScheduleSurfaceReady,
+    render: (snapshot) => {
+      view?.render(snapshot);
+      onNavigationChange();
+    },
     openConversation: async (sessionId, requestId) => {
       if (!shell.activateWorkspace("chat")) return;
       if (!sessionId) return;
@@ -49,24 +61,35 @@ export function createSchedulesFeature({
   refreshAvailability();
   dom.environmentSelect.addEventListener("change", () => {
     queueMicrotask(() => {
-      if (active) void controller.load();
+      controller.environmentChanged();
     });
   });
+  documentRoot?.addEventListener(
+    "visibilitychange",
+    controller.visibilityChanged,
+  );
   return {
     refreshAvailability,
+    reconnect: () => void controller.refresh(),
+    runtimeAvailabilityChanged,
+    handleRealtime,
     isWorkspaceAvailable(destination) {
       if (destination !== "schedules") return true;
       return client.supportsSchedules();
     },
     prepareLeave: view.prepareLeave,
+    navigationRevision: () => navigationRevision,
+    selectedJobId: () => controller.snapshot().selectedId,
     setActive(value) {
       active = value && client.supportsSchedules();
       controller.setActive(active);
     },
-    openJob(jobId) {
-      if (!client.supportsSchedules()) return;
-      if (!shell.activateWorkspace("schedules")) return;
-      void controller.openJob(jobId);
+    async openJob(jobId) {
+      if (!client.supportsSchedules()) return false;
+      if (!view.prepareLeave()) return false;
+      if (!shell.activateWorkspace("schedules")) return false;
+      await controller.openJob(jobId);
+      return true;
     },
     createJob(initialValues) {
       if (!client.supportsSchedules()) return;
@@ -75,10 +98,40 @@ export function createSchedulesFeature({
     },
   };
 
+  function isScheduleSurfaceReady() {
+    if (documentRoot?.visibilityState === "hidden") return false;
+    return isRuntimeReady();
+  }
+
+  function runtimeAvailabilityChanged() {
+    const ready = isRuntimeReady();
+    if (ready === runtimeReady) return;
+    runtimeReady = ready;
+    controller.visibilityChanged();
+  }
+
+  function isScheduleResourceChange(message) {
+    if (message.type === "event")
+      return [
+        "scheduler.changed",
+        "session.messages.updated",
+        "session.title.updated",
+      ].includes(message.name);
+    if (message.type !== "workspace_changed") return false;
+    if (!Array.isArray(message.resources)) return false;
+    return message.resources.includes("sessions");
+  }
+
+  function handleRealtime(message) {
+    if (!isScheduleResourceChange(message)) return;
+    if (message.environment !== selectedEnvironmentId()) return;
+    controller.scheduleRefresh();
+  }
+
   function refreshAvailability() {
     const available = client.supportsSchedules();
     dom.schedulesWorkspaceButton.hidden = !available;
-    dom.schedulesWorkspaceButton.disabled = !available;
+    dom.schedulesWorkspaceButton.disabled = !available || dom.schedulesWorkspaceButton.dataset.onboardingBlocked === "true";
     if (available) return;
     controller.setActive(false);
     if (active) shell.activateWorkspace("chat", { focus: false });

package/dist/src/web-ui/app/services/client-preferences.d.ts

@@ -2,10 +2,18 @@ import type { ToolPermissionMode } from "../lib/tool-permission-mode.js";
 
 type PreferenceMap = Record<string, unknown>;
 type SessionModeMap = Record<string, Record<string, unknown>>;
+type SessionSidebarPreferences = {
+  archivedSessionIds: string[];
+  orderedSessionIds: string[];
+};
 
 export declare function createClientPreferences(storage: Pick<
   Storage, "getItem" | "setItem" | "removeItem"
 >): {
+  loadSessionSidebar(environmentId: string): SessionSidebarPreferences;
+  hasKeptSparkConversation(environmentId: string, sessionId: string): boolean;
+  keepSparkConversation(environmentId: string, sessionId: string): void;
+  saveSessionSidebar(environmentId: string, value: SessionSidebarPreferences): void;
   loadPinnedSessions(): string[];
   savePinnedSessions(sessionIds: readonly string[]): void;
   loadSessionModes(normalize: (value: unknown) => ToolPermissionMode): SessionModeMap;

package/dist/src/web-ui/app/services/client-preferences.js

@@ -1,3 +1,6 @@
+import { createSessionSidebarPreferences } from "./session-sidebar-preferences.js";
+import { createSparkConversationPreferences } from "./spark-conversation-preferences.js";
+
 const storageKeys = {
   environmentId: "abot-web.environmentId",
   pinnedSessions: "abot-web.pinnedSessions",
@@ -34,6 +37,8 @@ function restoreSessionMode(value, normalizeToolPermissionMode) {
 
 export function createClientPreferences(storage) {
   return {
+    ...createSessionSidebarPreferences(storage),
+    ...createSparkConversationPreferences(storage),
     loadPinnedSessions() {
       try {
         const raw = storage.getItem(storageKeys.pinnedSessions);

package/dist/src/web-ui/app/services/home-guidance-preferences.js

@@ -0,0 +1,47 @@
+/** Browser-local review receipts only. Memory content never goes into storage. */
+export function createHomeGuidancePreferences(storage) {
+  const key = (environment) => `abot-web.homeGuidance.${encodeURIComponent(environment)}`;
+  const volatile = new Map();
+  function read(environment) {
+    if (volatile.has(environment)) return volatile.get(environment);
+    try {
+      const value = JSON.parse(storage?.getItem(key(environment)) || "null");
+      if (value && typeof value === "object" && !Array.isArray(value)) return {
+        offeredOn: typeof value.offeredOn === "string" ? value.offeredOn : "",
+        dismissed: Array.isArray(value.dismissed) ? value.dismissed.filter((id) => typeof id === "string").slice(-8) : [],
+        reviewed: Array.isArray(value.reviewed) ? value.reviewed.filter((id) => typeof id === "string").slice(-200) : [],
+      };
+    } catch { /* Browser preferences may be unavailable. */ }
+    return volatile.get(environment) || {};
+  }
+  function save(environment, patch) {
+    const value = { ...read(environment), ...patch };
+    try {
+      if (!storage) throw new Error("Storage unavailable");
+      storage.setItem(key(environment), JSON.stringify(value));
+      volatile.delete(environment);
+    } catch { volatile.set(environment, value); }
+  }
+  return {
+    dismissed: (environment) => read(environment).dismissed || [],
+    dismiss(environment, id) {
+      const dismissed = new Set(read(environment).dismissed || []);
+      dismissed.add(id);
+      save(environment, { dismissed: [...dismissed].slice(-8) });
+    },
+    wasOffered: (environment, day) => read(environment).offeredOn === day,
+    markOffered: (environment, day) => save(environment, { offeredOn: day }),
+    hasReviewed(environment, record) {
+      return (read(environment).reviewed || []).includes(`${record.id}:${record.updatedAt}`);
+    },
+    markReviewed(environment, record) {
+      const receipt = `${record.id}:${record.updatedAt}`;
+      const reviewed = (read(environment).reviewed || []).filter((id) => id !== receipt);
+      save(environment, { reviewed: [...reviewed, receipt].slice(-200) });
+    },
+  };
+}
+
+export function localReviewDay(date = new Date()) {
+  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+}

package/dist/src/web-ui/app/services/runtime-web-client/configuration.js

@@ -27,6 +27,12 @@ export function createConfigurationRequests({ requestApi, environmentQuery }) {
         body: JSON.stringify(input),
       });
     },
+    removeRuntimeModel(input, environmentId) {
+      return requestApi(scoped("/runtime/config/models", environmentId), {
+        method: "DELETE",
+        body: JSON.stringify(input),
+      });
+    },
     getRuntimePlugins(environmentId) {
       return requestApi(scoped("/runtime/plugins", environmentId));
     },

package/dist/src/web-ui/app/services/runtime-web-client/learning.js

@@ -0,0 +1,72 @@
+export function createPassiveLearningRequests({
+  requestApi,
+  getEnvironmentId,
+  environmentQuery,
+}) {
+  const environmentPath = (suffix, environmentId) =>
+    `/runtime/learning${suffix}?environment=${environmentQuery(environmentId)}`;
+
+  return Object.freeze({
+    loadPassiveLearning(environmentId = getEnvironmentId(), { signal } = {}) {
+      return requestApi(
+        environmentPath("", environmentId),
+        signal ? { signal } : {},
+      );
+    },
+    configurePassiveLearning(input, environmentId = getEnvironmentId()) {
+      return requestApi("/runtime/learning", {
+        method: "PUT",
+        body: JSON.stringify({ environment: environmentId, ...input }),
+      });
+    },
+    restartPassiveLearningCollection(environmentId = getEnvironmentId()) {
+      return requestApi(environmentPath("/collection/restart", environmentId), {
+        method: "POST",
+        body: "{}",
+      });
+    },
+    clearPassiveLearningPending(environmentId = getEnvironmentId()) {
+      return requestApi(environmentPath("/pending", environmentId), {
+        method: "DELETE",
+        body: "{}",
+      });
+    },
+    listPassiveLearningCandidates(
+      environmentId = getEnvironmentId(),
+      { signal } = {},
+    ) {
+      return requestApi(
+        environmentPath("/candidates", environmentId),
+        signal ? { signal } : {},
+      );
+    },
+    dismissPassiveLearningProposal(id, environmentId = getEnvironmentId()) {
+      return requestApi(
+        environmentPath(`/proposals/${encodeURIComponent(id)}`, environmentId),
+        {
+          method: "DELETE",
+          body: "{}",
+        },
+      );
+    },
+    listPassiveLearningBatches(
+      environmentId = getEnvironmentId(),
+      { signal } = {},
+    ) {
+      return requestApi(
+        environmentPath("/batches", environmentId),
+        signal ? { signal } : {},
+      );
+    },
+    loadPassiveLearningBatch(
+      id,
+      environmentId = getEnvironmentId(),
+      { signal } = {},
+    ) {
+      return requestApi(
+        environmentPath(`/batches/${encodeURIComponent(id)}`, environmentId),
+        signal ? { signal } : {},
+      );
+    },
+  });
+}

package/dist/src/web-ui/app/services/runtime-web-client/memory.js

@@ -51,10 +51,11 @@ export function createLongTermMemoryRequests({
       environmentId = getEnvironmentId(),
       limit = 20,
       offset = 0,
+      origin,
       signal,
     } = {}) {
       return requestApi(
-        memoryRecordsPath({ environmentId, limit, offset }),
+        memoryRecordsPath({ environmentId, limit, offset, origin }),
         signal ? { signal } : {},
       );
     },
@@ -112,13 +113,15 @@ export function createLongTermMemoryRequests({
   });
 }
 
-function memoryRecordsPath({ environmentId, limit, offset, query }) {
+function memoryRecordsPath({ environmentId, limit, offset, query, origin }) {
   const params = new URLSearchParams({
     environment: environmentId,
     limit: String(limit),
     offset: String(offset),
   });
   if (query !== undefined) params.set("q", query);
+  if (query === undefined && origin === "passive_observation")
+    params.set("origin", origin);
   const route =
     query === undefined
       ? "/runtime/memory/records"

package/dist/src/web-ui/app/services/runtime-web-client/notifications.d.ts

@@ -0,0 +1,30 @@
+import type {
+  NotificationDesktopState,
+  NotificationListQuery,
+  NotificationPage,
+  NotificationPreferences,
+  NotificationReadChange,
+  NotificationReadResult,
+} from "../../../notifications/contracts.js";
+
+export interface NotificationRequests {
+  supportsNotifications(): boolean;
+  listNotifications(
+    environmentId?: string,
+    page?: NotificationListQuery,
+  ): Promise<{ ok: true; desktop: NotificationDesktopState } & NotificationPage>;
+  markNotificationsRead(
+    input: NotificationReadChange,
+    environmentId?: string,
+  ): Promise<{ ok: true } & NotificationReadResult>;
+  saveNotificationPreferences(
+    input: NotificationPreferences,
+    environmentId?: string,
+  ): Promise<{ ok: true; preferences: NotificationPreferences }>;
+}
+
+export function createNotificationRequests(options: {
+  requestApi(path: string, options?: RequestInit): Promise<unknown>;
+  getConfig(): Record<string, unknown> | null;
+  getEnvironmentId(): string;
+}): NotificationRequests;