@abot-ai/runtime 1.6.0 → 1.8.0

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

@@ -1,5 +1,7 @@
 import { escapeHtml, formatTime, shortId, textOf } from "../lib/text-format.js";
-import { getNumber } from "../lib/event-presentation.js";
+import { formatDurationMs, latestHealthEvent, projectOperationsSummary } from "../components/operations-summary.js";
+
+export { formatDurationMs, latestHealthEvent } from "../components/operations-summary.js";
 
 function renderRuntimeRows(rows) {
   return `
@@ -18,34 +20,27 @@ function renderRuntimeRows(rows) {
   `;
 }
 
-export function formatDurationMs(value) {
-  const ms = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(ms) || ms < 0) return "-";
-  const seconds = Math.round(ms / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 90) return `${minutes}m`;
-  const hours = Math.round(minutes / 60);
-  if (hours < 48) return `${hours}h`;
-  return `${Math.round(hours / 24)}d`;
-}
-
-export function latestHealthEvent(details) {
-  return [...details].sort(
-    (left, right) =>
-      getNumber(right.lastEventAt, 0) - getNumber(left.lastEventAt, 0),
-  )[0];
-}
-
-export function createOperationsController({ dom, client, getEnvironmentId = () => undefined }) {
+export function createOperationsController({ dom, client, getEnvironmentId = () => undefined, onSummaryChange = () => {} }) {
   let statusRevision = 0;
   let logsRevision = 0;
+  let healthRevision = 0;
   let displayedEnvironment = getEnvironmentId();
+  const reads = { runtime: { phase: "idle" }, logs: { phase: "idle" }, health: { phase: "idle" } };
+  function updateSummaryRead(tab, read) {
+    reads[tab] = read;
+    onSummaryChange();
+  }
   function isCurrentOperationsRead(environmentId, revision, currentRevision) {
     if (environmentId !== getEnvironmentId()) return false;
     return revision === currentRevision;
   }
+  function isCurrentHealthRead(revision) {
+    return revision === healthRevision;
+  }
   const controller = {
+    summary(tab) {
+      return projectOperationsSummary(tab, reads, getEnvironmentId());
+    },
     environmentChanged() {
       const environmentId = getEnvironmentId();
       if (displayedEnvironment === environmentId) return;
@@ -57,6 +52,7 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
       const environmentId = getEnvironmentId();
       const revision = ++statusRevision;
       dom.runtimeStatus.textContent = "Loading...";
+      updateSummaryRead("runtime", { phase: "loading", environmentId });
       try {
         const payload = await client.getRuntimeStatus(environmentId);
         if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
@@ -70,11 +66,13 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
             <div class="runtime-row"><span>Trace</span><strong>${escapeHtml(status.config?.traceFile || "-")}</strong></div>
           </div>
         `;
+        updateSummaryRead("runtime", { phase: "ready", environmentId, payload });
       } catch (error) {
         if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
         dom.runtimeStatus.innerHTML = `<span class="error-text">${escapeHtml(
           error instanceof Error ? error.message : String(error),
         )}</span>`;
+        updateSummaryRead("runtime", { phase: "error", environmentId });
       }
     },
 
@@ -82,6 +80,7 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
       const environmentId = getEnvironmentId();
       const revision = ++logsRevision;
       dom.runtimeLogs.textContent = "Loading...";
+      updateSummaryRead("logs", { phase: "loading", environmentId });
       try {
         const payload = await client.getRuntimeLogs(100, environmentId);
         if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
@@ -91,17 +90,22 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
         dom.runtimeLogs.textContent = lines.length
           ? lines.join("\n")
           : "No runtime log lines returned.";
+        updateSummaryRead("logs", { phase: "ready", environmentId, payload, refreshedAt: Date.now() });
       } catch (error) {
         if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
         dom.runtimeLogs.textContent =
           error instanceof Error ? error.message : String(error);
+        updateSummaryRead("logs", { phase: "error", environmentId });
       }
     },
 
     async loadSystemHealth() {
+      const revision = ++healthRevision;
       dom.healthStatus.textContent = "Loading...";
+      updateSummaryRead("health", { phase: "loading" });
       try {
         const payload = await client.getSystemHealth();
+        if (!isCurrentHealthRead(revision)) return;
         const details = Array.isArray(payload.activeStreamingRequestDetails)
           ? payload.activeStreamingRequestDetails
           : [];
@@ -149,10 +153,13 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
               : '<div class="empty-state compact">No active streaming requests</div>'
           }
         `;
+        updateSummaryRead("health", { phase: "ready", payload });
       } catch (error) {
+        if (!isCurrentHealthRead(revision)) return;
         dom.healthStatus.innerHTML = `<span class="error-text">${escapeHtml(
           error instanceof Error ? error.message : String(error),
         )}</span>`;
+        updateSummaryRead("health", { phase: "error" });
       }
     },
   };

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

@@ -349,11 +349,67 @@ export function createPassiveLearningController({
     resetEnvironment();
   }
 
+  async function refreshCollectionAccess() {
+    if (!isRuntimeReady()) return;
+    const epoch = environmentEpoch;
+    const environment = getEnvironmentId();
+    function collectionReadIsCurrent() {
+      if (!isRuntimeReady() || epoch !== environmentEpoch) return false;
+      return environment === getEnvironmentId();
+    }
+    try {
+      const host = await client.getSystemHostConnection();
+      if (!collectionReadIsCurrent()) return;
+      if (typeof host?.collectionConsent?.accepted !== "boolean")
+        throw new Error("Collection acknowledgment status is unavailable. Refresh and try again.");
+      state.hostConnection = host;
+      publish();
+      return host;
+    } catch (error) {
+      if (!collectionReadIsCurrent()) return;
+      state.statusError = errorMessage(error);
+      publish();
+    }
+  }
+
+  async function acceptCollectionConsent() {
+    if (!isRuntimeReady() || state.saving) return;
+    const epoch = environmentEpoch;
+    const environment = getEnvironmentId();
+    function consentUpdateIsCurrent() {
+      if (!isRuntimeReady() || epoch !== environmentEpoch) return false;
+      return environment === getEnvironmentId();
+    }
+    state.saving = true;
+    state.statusError = "";
+    publish();
+    try {
+      const receipt = await client.acceptSystemHostCollectionConsent();
+      if (!consentUpdateIsCurrent()) return;
+      if (receipt?.collectionConsent?.accepted !== true)
+        throw new Error("Collection acknowledgment was not confirmed.");
+      const host = await refreshCollectionAccess();
+      if (!consentUpdateIsCurrent()) return;
+      if (host?.collectionConsent?.accepted !== true)
+        throw new Error("Collection acknowledgment could not be verified. Refresh and try again.");
+      return host;
+    } catch (error) {
+      if (consentUpdateIsCurrent()) state.statusError = errorMessage(error);
+    } finally {
+      if (consentUpdateIsCurrent()) {
+        state.saving = false;
+        publish();
+      }
+    }
+  }
+
   return Object.freeze({
     snapshot,
     runtimeAvailabilityChanged,
     publish,
     restartCollection,
+    acceptCollectionConsent,
+    refreshCollectionAccess,
     configure: (preferences) =>
       mutateLearningState(
         (id) => client.configurePassiveLearning(preferences, id),

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

@@ -24,7 +24,7 @@ export declare function createProjectsController(options: {
   getEnvironmentId: () => string;
   isRuntimeReady?: () => boolean;
   getConversationRevision: () => string | number;
-  prepareConversation: () => boolean;
+  prepareConversation: () => boolean | Promise<boolean>;
   openSession: (sessionId: string) => Promise<unknown>;
   loadSessions: () => Promise<unknown>;
   onChange: (state: ProjectsControllerState) => void;

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

@@ -230,11 +230,16 @@ export function createProjectsController({
   async function newConversation(projectId) {
     if (!canUseProjects()) return;
     if (state.busyProjectId) return;
-    if (!prepareConversation()) return;
     const environmentId = getEnvironmentId();
     const token = revision;
     const conversationRevision = getConversationRevision();
     const activationToken = ++activationRevision;
+    let prepared = prepareConversation();
+    if (typeof prepared?.then === "function") prepared = await prepared;
+    if (!prepared) return;
+    if (!isCurrentEnvironment(environmentId, token)) return;
+    if (activationToken !== activationRevision) return;
+    if (getConversationRevision() !== conversationRevision) return;
     state = { ...state, busyProjectId: projectId };
     publish();
     try {

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

@@ -0,0 +1,174 @@
+import { escapeAttribute, escapeHtml, textOf } from "../lib/text-format.js";
+import { canChooseReasoning } from "../lib/reasoning-controls.js";
+import { createReasoningOverridePrompt } from "../components/reasoning-override-prompt.js";
+
+export function normalizeAgentMode(mode) {
+  const normalized = textOf(mode).trim().toLowerCase();
+  return ["fast", "reasoning", "deep", "auto"].includes(normalized)
+    ? normalized
+    : "reasoning";
+}
+
+function agentModeMeta(mode) {
+  const modes = {
+    auto: { label: "Auto", description: "Lets the agent choose", icon: "*" },
+    fast: { label: "Fast", description: "Shorter and quicker", icon: "!" },
+    deep: {
+      label: "Deep analysis",
+      description: "More careful responses",
+      icon: "D",
+    },
+    reasoning: {
+      label: "Reasoning",
+      description: "Balanced speed and thinking",
+      icon: "R",
+    },
+  };
+  return modes[normalizeAgentMode(mode)] || modes.reasoning;
+}
+
+export function createReasoningModeController({ state, dom, client, selectedEnvironmentId, selectedModelProfile, reloadModels, recordControlEvent }) {
+  let agentModeLoadRevision = 0;
+  const agentModeMutationRevisions = new Map();
+  let agentModeMutationInFlight = false;
+  const agentModeMutationRevisionFor = (environmentId) =>
+    agentModeMutationRevisions.get(environmentId) || 0;
+  const prompt = createReasoningOverridePrompt({
+    root: dom.agentModeMenu, client, getEnvironmentId: selectedEnvironmentId,
+    getProfile: selectedModelProfile, refreshModels: reloadModels,
+    render: () => renderAgentMode(),
+  });
+  function renderAgentMode() {
+    const allowed = canChooseReasoning(selectedModelProfile());
+    const meta = allowed ? agentModeMeta(state.agentMode) : { label: "Provider default", icon: "—" };
+    dom.agentModeButton.setAttribute("aria-haspopup", allowed ? "menu" : "dialog");
+    dom.agentModeMenu.classList.toggle("reasoning-override-menu", !allowed);
+    dom.agentModeButton.title = `Reasoning depth: ${meta.label}`;
+    dom.agentModeButton.setAttribute("aria-label", `Reasoning depth: ${meta.label}`);
+    dom.agentModeButton.disabled = agentModeMutationInFlight;
+    dom.agentModeButton.innerHTML = `
+      <span class="agent-mode-icon">${escapeHtml(meta.icon)}</span>
+      <span>${escapeHtml(meta.label)}</span>`;
+    dom.agentModeButton.classList.toggle("open", state.agentModeMenuOpen);
+    dom.agentModeButton.setAttribute(
+      "aria-expanded",
+      state.agentModeMenuOpen ? "true" : "false",
+    );
+    dom.agentModeMenu.classList.toggle("open", state.agentModeMenuOpen);
+    dom.agentModeMenu.hidden = !state.agentModeMenuOpen;
+    dom.agentModeMenu.setAttribute("role", allowed ? "menu" : "dialog");
+    dom.agentModeMenu.setAttribute("aria-label", allowed ? "Reasoning depth" : "Enable reasoning controls");
+    if (!allowed) { prompt.render(state.agentModeMenuOpen); return; }
+    const restoreFocus = Boolean(dom.agentModeMenu.contains?.(dom.agentModeMenu.ownerDocument?.activeElement));
+    prompt.reset();
+    dom.agentModeMenu.innerHTML = state.supportedAgentModes
+      .map((mode) => {
+        const item = agentModeMeta(mode);
+        const selected = normalizeAgentMode(mode) === state.agentMode;
+        return `
+          <button class="agent-mode-option ${selected ? "selected" : ""}" type="button"
+            role="menuitemradio" aria-checked="${selected ? "true" : "false"}"
+            tabindex="${selected ? "0" : "-1"}" data-mode="${escapeAttribute(mode)}" ${agentModeMutationInFlight ? "disabled" : ""}>
+            <span class="agent-mode-option-icon">${escapeHtml(item.icon)}</span>
+            <span><strong>${escapeHtml(item.label)}</strong><small>${escapeHtml(item.description)}</small></span>
+          </button>`;
+      })
+      .join("");
+    dom.agentModeMenu
+      .querySelectorAll(".agent-mode-option")
+      .forEach((button) => {
+        button.addEventListener(
+          "click",
+          () => void setAgentMode(button.dataset.mode),
+        );
+      });
+    if (restoreFocus && state.agentModeMenuOpen)
+      dom.agentModeMenu.querySelector?.('[tabindex="0"]')?.focus();
+  }
+
+  async function loadAgentMode() {
+    const revision = ++agentModeLoadRevision;
+    const environmentId = selectedEnvironmentId();
+    const mutationRevision = agentModeMutationRevisionFor(environmentId);
+    renderAgentMode();
+    try {
+      const payload = await client.getAgentMode(environmentId);
+      if (
+        revision !== agentModeLoadRevision ||
+        mutationRevision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
+      state.agentMode = normalizeAgentMode(payload.mode);
+      state.supportedAgentModes = Array.isArray(payload.supportedModes)
+        ? payload.supportedModes.map(normalizeAgentMode)
+        : state.supportedAgentModes;
+      renderAgentMode();
+      return true;
+    } catch {
+      if (
+        revision !== agentModeLoadRevision ||
+        mutationRevision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
+      state.agentMode = "reasoning";
+      renderAgentMode();
+      return false;
+    }
+  }
+
+  async function setAgentMode(mode) {
+    if (agentModeMutationInFlight) return false;
+    if (!canChooseReasoning(selectedModelProfile())) return false;
+    agentModeMutationInFlight = true;
+    const environmentId = selectedEnvironmentId();
+    const revision = agentModeMutationRevisionFor(environmentId) + 1;
+    agentModeMutationRevisions.set(environmentId, revision);
+    const loadRevisionAtStart = ++agentModeLoadRevision;
+    const previousMode = state.agentMode;
+    const requestedMode = normalizeAgentMode(mode);
+    state.agentMode = requestedMode;
+    state.agentModeMenuOpen = false;
+    renderAgentMode();
+    dom.agentModeButton.focus();
+    try {
+      const payload = await client.setAgentMode(requestedMode, environmentId);
+      if (
+        revision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
+      agentModeLoadRevision += 1;
+      state.agentMode = normalizeAgentMode(payload.mode);
+      renderAgentMode();
+      return true;
+    } catch (error) {
+      if (
+        revision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
+      if (agentModeLoadRevision === loadRevisionAtStart) {
+        state.agentMode = previousMode;
+        renderAgentMode();
+      }
+      recordControlEvent({
+        type: "control",
+        name: "Reasoning mode update failed",
+        tone: "failed",
+        summary: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    } finally {
+      agentModeMutationInFlight = false;
+      renderAgentMode();
+    }
+  }
+
+  return { renderAgentMode, loadAgentMode, setAgentMode };
+}

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

@@ -17,6 +17,7 @@ export interface RuntimeOnboardingControllerDependencies {
     render(setup: RuntimeAvailability): void;
   }>;
   readonly reloadModels: () => void | Promise<void>;
+  readonly getEnvironmentId?: () => string;
   readonly setMessageStatus: (message: string) => void;
   readonly onStateChange?: () => void;
 }

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

@@ -40,11 +40,13 @@ export function createRuntimeOnboardingController({
   state,
   guide,
   reloadModels,
+  getEnvironmentId = () => "",
   setMessageStatus,
   onStateChange = () => {},
 }) {
   let checkPromise = null;
   let checkRevision = 0;
+  let catalogEnvironmentId = getEnvironmentId();
 
   function bind() {
     guide.bind({ onCheckAgain: checkAgain, onApplied: startCatalogCheck });
@@ -55,7 +57,16 @@ export function createRuntimeOnboardingController({
     guide.render(state.runtimeAvailability);
   }
 
+  function resetCatalogEnvironment() {
+    const environmentId = getEnvironmentId();
+    if (catalogEnvironmentId === environmentId) return;
+    catalogEnvironmentId = environmentId;
+    state.runtimeAvailability = { status: "loading" };
+    render();
+  }
+
   function beginCatalogLoad() {
+    resetCatalogEnvironment();
     state.runtimeAvailability = {
       status: "checking",
       showGuide: guideWasVisible(state.runtimeAvailability),

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

@@ -1,3 +1,6 @@
+import type { createRuntimeWebClient } from "../services/runtime-web-client.js";
+type ReasoningConfigClient = ReturnType<typeof createRuntimeWebClient>;
+
 export type AgentMode = "auto" | "fast" | "reasoning" | "deep";
 import type { ToolPermissionMode } from "../lib/tool-permission-mode.js";
 export type { ToolPermissionMode } from "../lib/tool-permission-mode.js";
@@ -137,6 +140,9 @@ export interface RuntimeSelectionControllerDependencies {
     sync(): void;
   }>;
   readonly client: Readonly<{
+    loadConfigDashboard?: ReasoningConfigClient["loadConfigDashboard"];
+    saveConfigFile?: ReasoningConfigClient["saveConfigFile"];
+    applyRuntimeConfiguration?: ReasoningConfigClient["applyRuntimeConfiguration"];
     getAgentMode(environmentId: string): Promise<Record<string, unknown>>;
     setAgentMode(
       mode: AgentMode,
@@ -155,6 +161,7 @@ export interface RuntimeSelectionControllerDependencies {
   readonly onModelCatalogLoading?: () => void;
   readonly onModelCatalogLoaded?: (payload: Record<string, unknown>) => void;
   readonly onModelCatalogUnavailable?: (error: unknown) => void;
+  readonly onReasoningConfigurationApplied?: () => Promise<boolean>;
 }
 
 export declare function createRuntimeSelectionController(