@abot-ai/runtime 1.4.0 → 1.5.0

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

@@ -1,4 +1,7 @@
 import { textOf } from "../lib/text-format.js";
+import { requestLifecycles } from "../lib/request-lifecycle-view.js";
+import { approvalDecisionCommand } from "../lib/approval-decision-command.js";
+import { projectToolActivityEvent } from "../lib/tool-activity-event.js";
 
 export function createToolApprovalController({
   state,
@@ -9,6 +12,22 @@ export function createToolApprovalController({
   createCard: createApprovalCard,
 }) {
   function isResolved(approvalId) {
+    for (const lifecycle of requestLifecycles(state).values()) {
+      if (
+        lifecycle.decisionReceipts.some(
+          (receipt) => receipt.approvalId === approvalId,
+        )
+      )
+        return true;
+    }
+    for (const message of state.messages ?? []) {
+      const group = message.approvalRequest;
+      if (group?.state === "pending") continue;
+      if (
+        group?.approvals.some((approval) => approval.approvalId === approvalId)
+      )
+        return true;
+    }
     return state.events.some((event) => {
       const name = textOf(event.eventName || event.name);
       return (
@@ -28,7 +47,36 @@ export function createToolApprovalController({
   }
 
   function pendingEvent() {
-    return [...state.events].reverse().find(isPending);
+    return pendingEvents().at(-1);
+  }
+
+  function pendingEvents() {
+    const pending = new Map(
+      state.events.filter(isPending).map((event) => [event.approvalId, event]),
+    );
+    for (const lifecycle of requestLifecycles(state).values()) {
+      if (lifecycle.status !== "awaiting_approval" || !lifecycle.wait) continue;
+      for (const approval of lifecycle.wait.approvals) {
+        if (isResolved(approval.approvalId)) continue;
+        const event = {
+          ...approval.presentation,
+          type: "event",
+          name: "tool.approval.required",
+          eventName: "tool.approval.required",
+          sessionId: lifecycle.sessionId,
+          requestId: lifecycle.requestId,
+          approvalId: approval.approvalId,
+          generation: lifecycle.generation,
+          waitId: lifecycle.wait.waitId,
+          revision: lifecycle.revision,
+        };
+        pending.set(approval.approvalId, {
+          ...event,
+          toolActivity: projectToolActivityEvent(event),
+        });
+      }
+    }
+    return [...pending.values()];
   }
 
   function submit(approvalId, approved) {
@@ -41,15 +89,28 @@ export function createToolApprovalController({
       });
       return false;
     }
+    const pending = pendingEvents().find(
+      (event) => event.approvalId === approvalId,
+    );
+    if (!pending || state.submittedToolApprovalIds.has(approvalId))
+      return false;
     state.submittedToolApprovalIds.add(approvalId);
-    sendRealtime({
+    const sent = sendRealtime({
       type: "tool_approval_response",
       approvalId,
       approved,
       environment: selectedEnvironmentId(),
+      ...(pending.waitId
+        ? {
+            sessionId: pending.sessionId,
+            requestId: pending.requestId,
+            ...approvalDecisionCommand(pending, approved),
+          }
+        : {}),
     });
+    if (sent === false) state.submittedToolApprovalIds.delete(approvalId);
     renderMessages();
-    return true;
+    return sent !== false;
   }
 
   function createCard(event) {
@@ -60,5 +121,5 @@ export function createToolApprovalController({
     });
   }
 
-  return { createCard, isPending, pendingEvent, submit };
+  return { createCard, isPending, pendingEvent, pendingEvents, submit };
 }

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

@@ -0,0 +1,336 @@
+import {
+  configuredRouteEnvironment,
+  readWorkspaceRoute,
+  workspaceRouteUrl,
+} from "../lib/workspace-route.js";
+import { configurationCategoryForWorkspace } from "../lib/configuration-pages.js";
+
+export function createWorkspaceRouteController({
+  viewport = window,
+  shell,
+  configuration,
+  selection,
+  getEnvironmentId,
+  getSessionId,
+  changeEnvironment,
+  isEnvironmentChanging = () => false,
+  loadSessions,
+  openSession,
+  restoreLastSession,
+  schedules,
+}) {
+  let initialRoute = readWorkspaceRoute(viewport.location);
+  let pendingInitialHistory = null;
+  let ready = false;
+  let applying = false;
+  let syncQueued = false;
+  let bound = false;
+  let historyIndex = existingWorkspaceHistoryIndex(viewport.history.state);
+  let acceptedUrl = "";
+  let restoreQueue = Promise.resolve();
+
+  function currentRoute() {
+    return {
+      workspace: shell.activeWorkspace(),
+      environment: getEnvironmentId(),
+      session: getSessionId(),
+      category: configurationCategoryForWorkspace(shell.activeWorkspace()),
+      tab: shell.activeOperationsTab(),
+      job: schedules.selectedJobId(),
+    };
+  }
+
+  function replaceCurrentUrl() {
+    acceptedUrl = workspaceRouteUrl(currentRoute());
+    viewport.history.replaceState(
+      { ...viewport.history.state, abotWorkspaceIndex: historyIndex },
+      "",
+      acceptedUrl,
+    );
+  }
+
+  function sync({ replace = false } = {}) {
+    if (!ready) return;
+    if (applying) return;
+    if (syncQueued) return;
+    if (isEnvironmentChanging()) return;
+    syncQueued = true;
+    queueMicrotask(() => {
+      syncQueued = false;
+      if (!ready) return;
+      if (applying) return;
+      if (isEnvironmentChanging()) return;
+      const nextUrl = workspaceRouteUrl(currentRoute());
+      if (nextUrl === acceptedUrl) return;
+      if (replace) {
+        replaceCurrentUrl();
+        return;
+      }
+      historyIndex += 1;
+      acceptedUrl = nextUrl;
+      viewport.history.pushState(
+        { abotWorkspaceIndex: historyIndex },
+        "",
+        nextUrl,
+      );
+    });
+  }
+
+  function bootstrapEnvironment(options, saved, fallback) {
+    if (configuredRouteEnvironment(initialRoute.environment, options))
+      return initialRoute.environment;
+    if (configuredRouteEnvironment(saved, options)) return saved;
+    return fallback;
+  }
+
+  function routeEnvironmentIsAvailable(route) {
+    if (!route.environment) return true;
+    return configuredRouteEnvironment(
+      route.environment,
+      selection.environmentOptions(),
+    );
+  }
+
+  function routeWorkspaceIsAvailable(route) {
+    return shell.isWorkspaceAvailable(route.workspace);
+  }
+
+  function routeBackendIsAvailable(route) {
+    return shell.isWorkspaceSupportedByBackend(route.workspace);
+  }
+
+  function routeNavigationRevisions() {
+    return {
+      shell: shell.navigationRevision(),
+      configuration: configuration.navigationRevision(),
+      schedules: schedules.navigationRevision(),
+    };
+  }
+
+  function hasCurrentRouteNavigation(revisions) {
+    if (shell.navigationRevision() !== revisions.shell) return false;
+    if (configuration.navigationRevision() !== revisions.configuration)
+      return false;
+    return schedules.navigationRevision() === revisions.schedules;
+  }
+
+  async function restoreSession(
+    route,
+    initial,
+    environmentId,
+    routeActivationIsCurrent,
+    commitLinkedConversationRoute,
+  ) {
+    if (!routeCarriesConversation(route)) {
+      if (initial) await restoreLastSession();
+      return true;
+    }
+    if (route.session === getSessionId()) return true;
+    const sessions = await loadSessions();
+    if (!routeActivationIsCurrent()) return false;
+    if (environmentId !== getEnvironmentId()) return false;
+    if (!routeSessionIsListed(route, sessions)) {
+      shell.showToast(
+        "This conversation is unavailable in the selected environment.",
+        "failed",
+      );
+      return false;
+    }
+    let routeCommitted = false;
+    await openSession(route.session, {
+      isRouteCurrent: routeActivationIsCurrent,
+      commitRouteNavigation: () => {
+        routeCommitted = commitLinkedConversationRoute();
+        return routeCommitted;
+      },
+    });
+    if (!routeCommitted) return false;
+    if (!routeActivationIsCurrent()) return false;
+    if (environmentId !== getEnvironmentId()) return false;
+    return getSessionId() === route.session;
+  }
+
+  async function applyRoute(route, { initial = false } = {}) {
+    if (!routeEnvironmentIsAvailable(route)) {
+      shell.showToast("This environment is no longer available.", "failed");
+      return false;
+    }
+    if (!routeBackendIsAvailable(route)) {
+      shell.showToast("This workspace is unavailable with the current backend.", "failed");
+      return false;
+    }
+    const navigationRevisions = routeNavigationRevisions();
+    if (routeChangesEnvironment(route, getEnvironmentId())) {
+      if (
+        !(await changeEnvironment(route.environment, { restoreSession: false }))
+      )
+        return false;
+    }
+    if (!hasCurrentRouteNavigation(navigationRevisions)) return false;
+    if (!routeWorkspaceIsAvailable(route)) {
+      shell.showToast(
+        shell.workspaceUnavailableMessage?.() || "This workspace is unavailable with the current backend.",
+        "failed",
+      );
+      return false;
+    }
+    const environmentId = getEnvironmentId();
+    const activate = shell.prepareWorkspaceActivation(route.workspace, {
+      focus: false,
+    });
+    if (!activate) return false;
+    let linkedConversationActivated = false;
+    function routeActivationIsCurrent() {
+      if (!hasCurrentRouteNavigation(navigationRevisions)) return false;
+      if (environmentId !== getEnvironmentId()) return false;
+      return !initialRouteWasSuperseded(initial, pendingInitialHistory);
+    }
+    function commitLinkedConversationRoute() {
+      if (!routeActivationIsCurrent()) return false;
+      if (!activate()) return false;
+      navigationRevisions.shell = shell.navigationRevision();
+      linkedConversationActivated = true;
+      return true;
+    }
+    if (
+      !(await restoreSession(
+        route,
+        initial,
+        environmentId,
+        routeActivationIsCurrent,
+        commitLinkedConversationRoute,
+      ))
+    )
+      return false;
+    if (!routeActivationIsCurrent()) return false;
+    if (!linkedConversationActivated && !activate()) return false;
+    const category = configurationCategoryForWorkspace(route.workspace);
+    if (category) {
+      if (configuration.activateCategory(category) === false)
+        return false;
+    }
+    if (route.workspace === "config") {
+      shell.activateOperationsTab(route.tab || "runtime");
+    }
+    if (route.workspace === "schedules") {
+      return await schedules.openJob(route.job || "");
+    }
+    return true;
+  }
+
+  async function restoreInitial() {
+    applying = true;
+    const requestedHistory = pendingInitialHistory;
+    pendingInitialHistory = null;
+    if (Number.isInteger(requestedHistory?.targetIndex))
+      historyIndex = requestedHistory.targetIndex;
+    try {
+      const route = { ...initialRoute };
+      if (!route.environment) route.environment = getEnvironmentId();
+      // An unknown environment must never resolve a same-named session elsewhere.
+      if (!routeEnvironmentIsAvailable(route)) {
+        route.environment = getEnvironmentId();
+        route.session = "";
+        route.job = "";
+      }
+      await applyRoute(route, { initial: true });
+    } catch (error) {
+      shell.showToast(
+        error instanceof Error ? error.message : String(error),
+        "failed",
+      );
+    } finally {
+      applying = false;
+      ready = true;
+      replaceCurrentUrl();
+    }
+    const pending = pendingInitialHistory;
+    pendingInitialHistory = null;
+    if (pending) await restoreHistory(pending.route, pending.targetIndex);
+  }
+
+  function restoreHistoryUrl(targetIndex) {
+    if (canReturnToAcceptedHistoryEntry(targetIndex, historyIndex)) {
+      viewport.history.go(historyIndex - targetIndex);
+      return;
+    }
+    replaceCurrentUrl();
+  }
+
+  async function restoreHistory(route, targetIndex) {
+    if (workspaceRouteUrl(route) === acceptedUrl) {
+      if (Number.isInteger(targetIndex)) historyIndex = targetIndex;
+      return;
+    }
+    applying = true;
+    let accepted = false;
+    try {
+      accepted = await applyRoute(route);
+    } catch (error) {
+      shell.showToast(
+        error instanceof Error ? error.message : String(error),
+        "failed",
+      );
+    } finally {
+      applying = false;
+    }
+    if (isEnvironmentChanging()) return;
+    if (!accepted) {
+      const unchanged = workspaceRouteUrl(currentRoute()) === acceptedUrl;
+      if (unchanged) {
+        restoreHistoryUrl(targetIndex);
+        return;
+      }
+    }
+    if (Number.isInteger(targetIndex)) historyIndex = targetIndex;
+    replaceCurrentUrl();
+  }
+
+  function bind() {
+    if (bound) return;
+    bound = true;
+    viewport.addEventListener("popstate", (event) => {
+      const route = readWorkspaceRoute(viewport.location);
+      const targetIndex = event.state?.abotWorkspaceIndex;
+      if (!ready) {
+        initialRoute = route;
+        pendingInitialHistory = { route, targetIndex };
+        return;
+      }
+      restoreQueue = restoreQueue.then(() =>
+        restoreHistory(route, targetIndex),
+      );
+    });
+  }
+
+  return { bind, bootstrapEnvironment, restoreInitial, sync };
+}
+
+function canReturnToAcceptedHistoryEntry(targetIndex, currentIndex) {
+  if (!Number.isInteger(targetIndex)) return false;
+  return targetIndex !== currentIndex;
+}
+
+function routeCarriesConversation(route) {
+  if (route.workspace !== "chat") return false;
+  return Boolean(route.session);
+}
+
+function existingWorkspaceHistoryIndex(state) {
+  if (!Number.isInteger(state?.abotWorkspaceIndex)) return 0;
+  return state.abotWorkspaceIndex;
+}
+
+function routeChangesEnvironment(route, selectedEnvironment) {
+  if (!route.environment) return false;
+  return route.environment !== selectedEnvironment;
+}
+
+function routeSessionIsListed(route, sessions) {
+  return sessions.some((session) => session.id === route.session);
+}
+
+function initialRouteWasSuperseded(initial, pendingHistory) {
+  if (!initial) return false;
+  return Boolean(pendingHistory);
+}

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

@@ -1,10 +1,13 @@
 import { createDashboardWorkspace } from "./components/dashboard/workspace.js";
 import { createDashboardController } from "./controllers/dashboard-controller.js";
+import { createDashboardApprovalsController } from "./controllers/dashboard-approvals-controller.js";
 import { dashboardJobInitialValues } from "./lib/dashboard-job-templates.js";
+import { filterSessionsByArchiveState } from "./lib/session-archive-visibility.js";
 
 export function createDashboardFeature({
   dom,
   state,
+  preferences,
   client,
   shell,
   schedules,
@@ -12,29 +15,41 @@ export function createDashboardFeature({
   loadSessions,
   openSession,
   isComposerAvailable,
+  passiveLearning,
 }) {
   let view;
-  const controller = createDashboardController({
+  let controller;
+  const approvals = createDashboardApprovalsController({
+    client,
+    getEnvironmentId: selectedEnvironmentId,
+    render: () => controller?.publish(),
+  });
+  controller = createDashboardController({
     client,
     getEnvironmentId: selectedEnvironmentId,
     getSessions: () => state.sessions,
     loadSessions,
     isRuntimeReady: isComposerAvailable,
-    render: (snapshot) =>
-      view?.render({ ...snapshot, composerAvailable: isComposerAvailable() }),
+    approvalData: approvals,
+    render: (snapshot) => {
+      passiveLearning?.updateSessions?.({ environmentId: selectedEnvironmentId(), sessions: snapshot.sessions });
+      const sessions = filterSessionsByArchiveState(snapshot.sessions,
+        preferences?.loadSessionSidebar?.(selectedEnvironmentId())?.archivedSessionIds);
+      view?.render({ ...snapshot, sessions, composerAvailable: isComposerAvailable() });
+    },
   });
   view = createDashboardWorkspace({
     root: dom.homeDashboardRoot,
+    passiveLearning,
     actions: {
-      attach: () => dom.attachmentButton.click(),
       createJob: (templateId) =>
         schedules.createJob(
           dashboardJobInitialValues(templateId, dom.modelSelect.value),
         ),
       continueConversation: () => shell.setSessionsDrawerOpen(true),
-      openConfiguration: () => shell.activateWorkspace("config"),
       openJobs: () => shell.activateWorkspace("schedules"),
       refresh: controller.refresh,
+      decideApproval: approvals.submit,
       openConversation: async (sessionId, requestId) => {
         if (!shell.activateWorkspace("chat")) return;
         try {

package/dist/src/web-ui/app/favicon.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <style>
+    .a { fill: #071011; }
+    .b { fill: #087f64; }
+    @media (prefers-color-scheme: dark) {
+      .a { fill: #eafffb; }
+      .b { fill: #33f2bd; }
+    }
+  </style>
+  <path class="a" fill-rule="evenodd" d="M2 54 15 10h8l13 44h-9l-2.6-10H13.2l-2.5 10H2Zm13.5-18h6.7L19 22.5 15.5 36Z"/>
+  <path class="b" fill-rule="evenodd" d="M31 10h14c9.5 0 15 3.7 15 11 0 5-2.8 8.5-7.7 10 6.4 1.3 9.7 5.1 9.7 10.8C62 50 55.8 54 44.8 54H31V10Zm9 7.5v10h4.5c4.2 0 6.5-1.6 6.5-5s-2.3-5-6.5-5H40ZM40 35v11.5h5.3c5 0 7.4-1.8 7.4-5.7 0-3.8-2.4-5.8-7.4-5.8H40Z"/>
+</svg>