@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/web-ui/app/controllers/dashboard-approvals-controller.js

@@ -0,0 +1,141 @@
+function approvalIdentity(approval) {
+  return JSON.stringify([
+    approval.environmentId,
+    approval.sessionId,
+    approval.requestId,
+    approval.approvalId,
+  ]);
+}
+
+export function createDashboardApprovalsController({
+  client,
+  getEnvironmentId,
+  render,
+}) {
+  let approvals = [];
+  let environmentId = "";
+  let loading = true;
+  let settled = false;
+  let error = "";
+  let decisionError = "";
+  let scopeRevision = 0;
+  let readRevision = 0;
+  const submitting = new Set();
+
+  function snapshot() {
+    return {
+      approvals:
+        environmentId === getEnvironmentId()
+          ? approvals.map((approval) => ({
+              ...approval,
+              submitted: submitting.has(approvalIdentity(approval)),
+            }))
+          : [],
+      supportsToolApprovals: client.supportsToolApprovals(),
+      loadingApprovals: loading,
+      approvalsError: error,
+      approvalDecisionError: decisionError,
+    };
+  }
+
+  function hasCurrentScope(scope, revision) {
+    if (scope !== getEnvironmentId()) return false;
+    return revision === scopeRevision;
+  }
+
+  function hasCurrentRead(scope, revision) {
+    if (scope !== getEnvironmentId()) return false;
+    return revision === readRevision;
+  }
+
+  function invalidate() {
+    scopeRevision += 1;
+    readRevision += 1;
+    environmentId = "";
+    approvals = [];
+    loading = true;
+    settled = false;
+    error = "";
+    decisionError = "";
+    submitting.clear();
+  }
+
+  async function refresh() {
+    const scope = getEnvironmentId();
+    if (!hasCurrentScope(environmentId, scopeRevision)) invalidate();
+    const revision = ++readRevision;
+    environmentId = scope;
+    loading = !settled;
+    if (!client.supportsToolApprovals()) {
+      approvals = [];
+      loading = false;
+      settled = true;
+      error = "";
+      render();
+      return;
+    }
+    render();
+    try {
+      const result = await client.listToolApprovals(scope);
+      if (!hasCurrentRead(scope, revision)) return;
+      approvals = result.approvals;
+      error = "";
+    } catch (failure) {
+      if (!hasCurrentRead(scope, revision)) return;
+      error = failure instanceof Error ? failure.message : String(failure);
+    } finally {
+      if (hasCurrentRead(scope, revision)) {
+        loading = false;
+        settled = true;
+        render();
+      }
+    }
+  }
+
+  function canSubmitApproval(approval, identity) {
+    if (!client.supportsToolApprovals()) return false;
+    if (approval.environmentId !== getEnvironmentId()) return false;
+    if (submitting.has(identity)) return false;
+    return approvals.some((pending) => approvalIdentity(pending) === identity);
+  }
+
+  async function submit(approval, approved) {
+    const identity = approvalIdentity(approval);
+    if (!canSubmitApproval(approval, identity)) return false;
+    const scope = approval.environmentId;
+    const revision = scopeRevision;
+    submitting.add(identity);
+    decisionError = "";
+    render();
+    try {
+      await client.decideToolApproval({
+        environmentId: scope,
+        sessionId: approval.sessionId,
+        requestId: approval.requestId,
+        approvalId: approval.approvalId,
+        approved,
+        ...approvalDecisionCommand(approval, approved),
+      });
+      if (!hasCurrentScope(scope, revision)) return true;
+      approvals = approvals.filter(
+        (pending) => approvalIdentity(pending) !== identity,
+      );
+      await refresh();
+      return true;
+    } catch (failure) {
+      if (!hasCurrentScope(scope, revision)) return false;
+      decisionError =
+        failure instanceof Error ? failure.message : String(failure);
+      await refresh();
+      return false;
+    } finally {
+      if (hasCurrentScope(scope, revision)) {
+        submitting.delete(identity);
+        render();
+      }
+    }
+  }
+
+  return { snapshot, refresh, invalidate, submit };
+}
+import { approvalDecisionCommand } from "../lib/approval-decision-command.js";

package/dist/src/web-ui/app/controllers/dashboard-controller.js

@@ -1,3 +1,6 @@
+import { createEventRefresh } from "../lib/event-refresh.js";
+import { dashboardRefreshResources } from "../lib/workspace-change.js";
+
 export function createDashboardController({
   client,
   getEnvironmentId,
@@ -8,6 +11,7 @@ export function createDashboardController({
   isVisible = () => document.visibilityState === "visible",
   setTimer = setTimeout,
   clearTimer = clearTimeout,
+  approvalData,
 }) {
   const state = {
     runs: [],
@@ -22,7 +26,14 @@ export function createDashboardController({
   let environmentId = "";
   let sessionsEnvironmentId = "";
   let revision = 0;
-  let timer;
+  const pendingResources = new Set();
+  const eventRefresh = createEventRefresh({
+    canRefresh,
+    refresh: readPendingResources,
+    setTimer,
+    clearTimer,
+  });
+  let activitySettled = false;
 
   function snapshot() {
     const sessions =
@@ -31,6 +42,7 @@ export function createDashboardController({
       ...state,
       sessions,
       supportsSchedules: client.supportsSchedules(),
+      ...approvalData?.snapshot(),
     };
   }
   const publish = () => render(snapshot());
@@ -44,23 +56,27 @@ export function createDashboardController({
     if (!active) return false;
     return isVisible();
   }
-  function scheduleRefresh() {
-    clearTimer(timer);
-    if (!canRefresh()) return;
-    timer = setTimer(() => void refresh(), 10000);
+  function cancelRefresh() {
+    eventRefresh.cancel();
+    pendingResources.clear();
   }
   async function refreshActivity() {
     const readEnvironmentId = getEnvironmentId();
     const readRevision = ++revision;
     const environmentChanged = environmentId !== readEnvironmentId;
     environmentId = readEnvironmentId;
-    if (environmentChanged) state.runs = [];
-    state.loadingActivity = state.runs.length === 0;
-    state.activityError = "";
+    if (environmentChanged) {
+      state.runs = [];
+      activitySettled = false;
+      state.activityError = "";
+    }
+    state.loadingActivity = !activitySettled;
     publish();
     if (!client.supportsSchedules()) {
       state.runs = [];
       state.loadingActivity = false;
+      activitySettled = true;
+      state.activityError = "";
       publish();
       return;
     }
@@ -70,6 +86,7 @@ export function createDashboardController({
       });
       if (!hasCurrentActivityRead(readRevision, readEnvironmentId)) return;
       state.runs = result.runs || [];
+      state.activityError = "";
     } catch (error) {
       if (!hasCurrentActivityRead(readRevision, readEnvironmentId)) return;
       state.activityError =
@@ -77,20 +94,39 @@ export function createDashboardController({
     } finally {
       if (hasCurrentActivityRead(readRevision, readEnvironmentId)) {
         state.loadingActivity = false;
+        activitySettled = true;
         publish();
       }
     }
   }
-  async function refresh() {
+  async function readPendingResources() {
+    const resources = [...pendingResources];
+    pendingResources.clear();
+    const readers = {
+      sessions: loadSessions,
+      activity: refreshActivity,
+      approvals: () => approvalData?.refresh(),
+    };
+    await Promise.allSettled(resources.map((resource) => readers[resource]()));
+  }
+  function refresh() {
+    if (!canRefresh()) return Promise.resolve();
+    for (const resource of ["sessions", "activity", "approvals"])
+      pendingResources.add(resource);
+    return eventRefresh.run();
+  }
+  function handleRealtime(message) {
     if (!canRefresh()) return;
-    clearTimer(timer);
-    await Promise.allSettled([loadSessions(), refreshActivity()]);
-    scheduleRefresh();
+    const resources = dashboardRefreshResources(message, getEnvironmentId());
+    if (!resources.length) return;
+    for (const resource of resources) pendingResources.add(resource);
+    eventRefresh.schedule();
   }
   return {
     snapshot,
     publish,
     refresh,
+    handleRealtime,
     runtimeAvailabilityChanged() {
       const available = isRuntimeReady();
       if (runtimeReady === available) {
@@ -99,7 +135,8 @@ export function createDashboardController({
       }
       runtimeReady = available;
       revision += 1;
-      clearTimer(timer);
+      if (!available) approvalData?.invalidate();
+      cancelRefresh();
       state.activityError = "";
       state.sessionsError = "";
       publish();
@@ -112,20 +149,25 @@ export function createDashboardController({
     setActive(value) {
       const entering = value && !active;
       active = value;
-      clearTimer(timer);
+      cancelRefresh();
       if (entering) void refresh();
     },
     sessionsChanged(status = {}) {
       if (status.environmentId && status.environmentId !== getEnvironmentId())
         return;
       if (status.status === "ready") sessionsEnvironmentId = getEnvironmentId();
-      state.loadingSessions = status.status === "loading";
-      state.sessionsError = status.error || "";
+      state.loadingSessions =
+        status.status === "loading" &&
+        sessionsEnvironmentId !== getEnvironmentId();
+      if (status.status !== "loading") state.sessionsError = status.error || "";
       publish();
     },
     environmentChanged() {
+      cancelRefresh();
       revision += 1;
+      approvalData?.invalidate();
       sessionsEnvironmentId = "";
+      activitySettled = false;
       Object.assign(state, {
         runs: [],
         activityError: "",
@@ -137,7 +179,7 @@ export function createDashboardController({
       void refresh();
     },
     visibilityChanged() {
-      clearTimer(timer);
+      cancelRefresh();
       if (canRefresh()) void refresh();
     },
   };

package/dist/src/web-ui/app/controllers/long-term-memory/controller.d.ts

@@ -25,6 +25,7 @@ export type LongTermMemorySnapshot = Readonly<{
   offset: number;
   limit: number;
   query: string;
+  originFilter?: string;
   loading: boolean;
   mutation: string;
   message: string;
@@ -39,6 +40,7 @@ export interface LongTermMemoryClient {
     limit: number;
     offset: number;
     signal: AbortSignal;
+    origin?: "passive_observation";
   }): Promise<LongTermMemoryPage>;
   searchLongTermMemories(options: {
     environmentId: string;
@@ -76,6 +78,7 @@ export interface LongTermMemoryController {
   refresh(): Promise<void>;
   save(input: { content: string; tags: readonly string[] }): Promise<void>;
   search(query: string): Promise<void>;
+  setOriginFilter(origin: "passive_observation" | ""): Promise<void>;
   snapshot(): LongTermMemorySnapshot;
 }
 

package/dist/src/web-ui/app/controllers/long-term-memory/controller.js

@@ -43,6 +43,7 @@ export function createLongTermMemoryController({
     state.items = [];
     state.total = 0;
     state.query = "";
+    state.originFilter = "";
     state.offset = 0;
     state.mutation = "";
     state.editor = null;
@@ -72,6 +73,14 @@ export function createLongTermMemoryController({
     await loadRecords({ preserveFeedback: false });
   }
 
+  async function setOriginFilter(origin) {
+    const next = origin === "passive_observation" ? origin : "";
+    state.originFilter = next;
+    state.query = "";
+    state.offset = 0;
+    await loadRecords({ preserveFeedback: false });
+  }
+
   async function changePage(direction) {
     const nextOffset = state.offset + direction * state.limit;
     if (nextOffset < 0 || nextOffset >= state.total) return;
@@ -241,7 +250,7 @@ export function createLongTermMemoryController({
     };
     return state.query
       ? client.searchLongTermMemories({ ...page, query: state.query })
-      : client.listLongTermMemories(page);
+      : client.listLongTermMemories({ ...page, origin: state.originFilter || undefined });
   }
 
   function beginRead() {
@@ -297,6 +306,7 @@ export function createLongTermMemoryController({
     refresh,
     save,
     search,
+    setOriginFilter,
     snapshot,
   });
 }

package/dist/src/web-ui/app/controllers/long-term-memory/state.js

@@ -9,6 +9,7 @@ export function createLongTermMemoryState(pageSize) {
     offset: 0,
     limit: pageSize,
     query: "",
+    originFilter: "",
     loading: false,
     mutation: "",
     message: "",

package/dist/src/web-ui/app/controllers/notification-presence.js

@@ -0,0 +1,68 @@
+export function createNotificationPresence({
+  getEnvironmentId,
+  getSessionId,
+  getWorkspace,
+  isConnected,
+  send,
+  documentRoot = document,
+  viewport = window,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  let timer;
+  let lastPresence = "";
+  let bound = false;
+  function hasActiveConversation() {
+    if (documentRoot.visibilityState !== "visible") return false;
+    if (!documentRoot.hasFocus()) return false;
+    if (getWorkspace() !== "chat") return false;
+    return Boolean(getSessionId());
+  }
+  function publish(force = false, leaving = false) {
+    if (!isConnected()) {
+      clearTimer(timer);
+      timer = undefined;
+      lastPresence = "";
+      return;
+    }
+    const environment = getEnvironmentId();
+    if (!environment) return;
+    const payload = {
+      type: "notification_presence",
+      environment,
+      sessionId: getSessionId() || "",
+      active: leaving ? false : hasActiveConversation(),
+    };
+    const serialized = JSON.stringify(payload);
+    if (!force && serialized === lastPresence) return;
+    clearTimer(timer);
+    timer = undefined;
+    send(payload);
+    lastPresence = serialized;
+    if (payload.active) timer = setTimer(() => publish(true), 20_000);
+  }
+  const changed = () => publish();
+  const leaving = () => publish(true, true);
+  return {
+    changed,
+    reconnect: () => publish(true),
+    bind() {
+      if (bound) return;
+      bound = true;
+      viewport.addEventListener("focus", changed);
+      viewport.addEventListener("blur", changed);
+      viewport.addEventListener("pagehide", leaving);
+      documentRoot.addEventListener("visibilitychange", changed);
+      publish();
+    },
+    dispose() {
+      leaving();
+      clearTimer(timer);
+      viewport.removeEventListener("focus", changed);
+      viewport.removeEventListener("blur", changed);
+      viewport.removeEventListener("pagehide", leaving);
+      documentRoot.removeEventListener("visibilitychange", changed);
+      bound = false;
+    },
+  };
+}

package/dist/src/web-ui/app/controllers/notifications-controller.js

@@ -0,0 +1,153 @@
+import { createEventRefresh } from "../lib/event-refresh.js";
+import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
+
+export function createNotificationsController({
+  client,
+  getEnvironmentId,
+  render,
+  isVisible = () => document.visibilityState === "visible",
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  const state = {
+    items: [], unreadCount: 0, nextCursor: null, preferences: null,
+    desktop: null, loading: false, busy: false, error: "", filter: "all",
+  };
+  let ready = false;
+  let environmentRevision = 0;
+  let readRevision = 0;
+  const refreshEvents = createEventRefresh({
+    canRefresh: () => ready && isVisible(),
+    refresh: () => refresh(),
+    setTimer, clearTimer,
+  });
+  const snapshot = () => ({ ...state, supported: client.supportsNotifications() });
+  const publish = () => render(snapshot());
+  function isCurrentEnvironment(environment, revision) {
+    if (revision !== environmentRevision) return false;
+    return environment === getEnvironmentId();
+  }
+  function isCurrentRead(environment, environmentVersion, readVersion) {
+    if (!isCurrentEnvironment(environment, environmentVersion)) return false;
+    return readVersion === readRevision;
+  }
+  function hasScopedNotifications(result, environment) {
+    if (!Array.isArray(result?.items)) return false;
+    return result.items.every((item) => item.environmentId === environment);
+  }
+  async function refresh({ append = false } = {}) {
+    if (!ready) return;
+    if (!client.supportsNotifications()) {
+      publish();
+      return;
+    }
+    const environment = getEnvironmentId();
+    const environmentVersion = environmentRevision;
+    const readVersion = ++readRevision;
+    const before = append ? state.nextCursor : undefined;
+    if (append && !before) return;
+    state.loading = true;
+    state.error = "";
+    publish();
+    try {
+      const result = await client.listNotifications(environment, { before });
+      if (!isCurrentRead(environment, environmentVersion, readVersion)) return;
+      if (!hasScopedNotifications(result, environment))
+        throw new Error("The notification history could not be verified. Refresh to try again.");
+      const existing = append ? state.items : [];
+      const seen = new Set(existing.map((item) => item.id));
+      state.items = [...existing, ...result.items.filter((item) => !seen.has(item.id))];
+      state.unreadCount = Math.max(0, Number(result.unreadCount) || 0);
+      state.nextCursor = result.nextCursor || null;
+      state.preferences = result.preferences;
+      state.desktop = result.desktop;
+    } catch (error) {
+      if (!isCurrentRead(environment, environmentVersion, readVersion)) return;
+      state.error = error instanceof Error ? error.message : String(error);
+    } finally {
+      if (isCurrentRead(environment, environmentVersion, readVersion)) {
+        state.loading = false;
+        publish();
+      }
+    }
+  }
+  async function mutate(operation) {
+    if (state.busy) return false;
+    if (!ready || !client.supportsNotifications()) return false;
+    const environment = getEnvironmentId();
+    const version = environmentRevision;
+    readRevision += 1;
+    state.busy = true;
+    state.loading = false;
+    state.error = "";
+    publish();
+    try {
+      await operation(environment);
+      if (!isCurrentEnvironment(environment, version)) return false;
+      await refresh();
+      return isCurrentEnvironment(environment, version);
+    } catch (error) {
+      if (!isCurrentEnvironment(environment, version)) return false;
+      state.error = error instanceof Error ? error.message : String(error);
+      return false;
+    } finally {
+      if (isCurrentEnvironment(environment, version)) {
+        state.busy = false;
+        publish();
+      }
+    }
+  }
+  async function markRead(id, read = true) {
+    const item = state.items.find((candidate) => candidate.id === id);
+    if (!item) return false;
+    if (item.environmentId !== getEnvironmentId()) return false;
+    return mutate((environment) => client.markNotificationsRead({ ids: [id], read }, environment));
+  }
+  return {
+    snapshot, publish, refresh, markRead,
+    loadMore: () => refresh({ append: true }),
+    markAllRead: () => mutate((environment) =>
+      client.markNotificationsRead({ all: true, read: true }, environment)),
+    savePreferences: (preferences) => mutate((environment) =>
+      client.saveNotificationPreferences(preferences, environment)),
+    setFilter(filter) {
+      state.filter = filter === "unread" ? "unread" : "all";
+      publish();
+    },
+    setReady() {
+      ready = true;
+      return refresh();
+    },
+    setActive(active) {
+      if (active) void refresh();
+    },
+    environmentChanged() {
+      environmentRevision += 1;
+      readRevision += 1;
+      refreshEvents.cancel();
+      Object.assign(state, {
+        items: [], unreadCount: 0, nextCursor: null, preferences: null,
+        desktop: null, loading: false, busy: false, error: "",
+      });
+      publish();
+      void refresh();
+    },
+    handleRealtime(rawMessage) {
+      const message = normalizeRealtimeMessage(rawMessage);
+      if (canRefreshNotificationEvent(message, getEnvironmentId()))
+        refreshEvents.schedule();
+    },
+    visibilityChanged() {
+      refreshEvents.cancel();
+      if (isVisible()) void refresh();
+    },
+    dispose: refreshEvents.cancel,
+  };
+}
+
+function canRefreshNotificationEvent(message, environmentId) {
+  if (message.type === "system-host.changed") return true;
+  if (message.type !== "workspace_changed") return false;
+  if ((message.environment || message.environmentId) !== environmentId) return false;
+  return message.resources?.includes("notifications") === true;
+}

package/dist/src/web-ui/app/controllers/operations-controller.d.ts

@@ -4,14 +4,15 @@ export declare function latestHealthEvent(
 ): Record<string, unknown> | undefined;
 
 export interface OperationsControllerDependencies {
+  readonly getEnvironmentId?: () => string | undefined;
   readonly dom: Readonly<{
     runtimeStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
     runtimeLogs: Pick<HTMLElement, "textContent">;
     healthStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
   }>;
   readonly client: Readonly<{
-    getRuntimeStatus(): Promise<Record<string, unknown>>;
-    getRuntimeLogs(lines: number): Promise<Record<string, unknown>>;
+    getRuntimeStatus(environmentId?: string): Promise<Record<string, unknown>>;
+    getRuntimeLogs(lines: number, environmentId?: string): Promise<Record<string, unknown>>;
     getSystemHealth(): Promise<Record<string, unknown>>;
   }>;
 }
@@ -19,6 +20,7 @@ export interface OperationsControllerDependencies {
 export declare function createOperationsController(
   options: OperationsControllerDependencies,
 ): {
+  environmentChanged(): void;
   loadRuntimeStatus(): Promise<void>;
   loadRuntimeLogs(): Promise<void>;
   loadSystemHealth(): Promise<void>;