@abot-ai/runtime 1.4.0 → 1.5.0

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

@@ -37,12 +37,29 @@ export function latestHealthEvent(details) {
   )[0];
 }
 
-export function createOperationsController({ dom, client }) {
-  return {
+export function createOperationsController({ dom, client, getEnvironmentId = () => undefined }) {
+  let statusRevision = 0;
+  let logsRevision = 0;
+  let displayedEnvironment = getEnvironmentId();
+  function isCurrentOperationsRead(environmentId, revision, currentRevision) {
+    if (environmentId !== getEnvironmentId()) return false;
+    return revision === currentRevision;
+  }
+  const controller = {
+    environmentChanged() {
+      const environmentId = getEnvironmentId();
+      if (displayedEnvironment === environmentId) return;
+      displayedEnvironment = environmentId;
+      void controller.loadRuntimeStatus();
+      void controller.loadRuntimeLogs();
+    },
     async loadRuntimeStatus() {
+      const environmentId = getEnvironmentId();
+      const revision = ++statusRevision;
       dom.runtimeStatus.textContent = "Loading...";
       try {
-        const payload = await client.getRuntimeStatus();
+        const payload = await client.getRuntimeStatus(environmentId);
+        if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
         const status = payload.status || {};
         dom.runtimeStatus.innerHTML = `
           <div class="runtime-grid">
@@ -54,6 +71,7 @@ export function createOperationsController({ dom, client }) {
           </div>
         `;
       } catch (error) {
+        if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
         dom.runtimeStatus.innerHTML = `<span class="error-text">${escapeHtml(
           error instanceof Error ? error.message : String(error),
         )}</span>`;
@@ -61,9 +79,12 @@ export function createOperationsController({ dom, client }) {
     },
 
     async loadRuntimeLogs() {
+      const environmentId = getEnvironmentId();
+      const revision = ++logsRevision;
       dom.runtimeLogs.textContent = "Loading...";
       try {
-        const payload = await client.getRuntimeLogs(100);
+        const payload = await client.getRuntimeLogs(100, environmentId);
+        if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
         const lines = Array.isArray(payload.log?.lines)
           ? payload.log.lines
           : [];
@@ -71,6 +92,7 @@ export function createOperationsController({ dom, client }) {
           ? lines.join("\n")
           : "No runtime log lines returned.";
       } catch (error) {
+        if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
         dom.runtimeLogs.textContent =
           error instanceof Error ? error.message : String(error);
       }
@@ -134,4 +156,5 @@ export function createOperationsController({ dom, client }) {
       }
     },
   };
+  return controller;
 }

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

@@ -0,0 +1,458 @@
+import { createEventRefresh } from "../lib/event-refresh.js";
+import { learningFailureCopy } from "../components/passive-learning/failure-copy.js";
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function learningActionErrorMessage(error) {
+  const message = errorMessage(error);
+  const explanation = learningFailureCopy(message);
+  return explanation.code ? explanation.message : message;
+}
+
+function hasLearningStatus(result) {
+  return (
+    result?.status?.preferences?.enabled === true ||
+    result?.status?.preferences?.enabled === false
+  );
+}
+
+export function createPassiveLearningController({
+  client,
+  getEnvironmentId,
+  render,
+  openSession = () => {},
+  isVisible = () => document.visibilityState === "visible",
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  const state = {
+    status: null,
+    hostConnection: null,
+    hostConnectionKey: "",
+    batches: [],
+    candidates: [],
+    candidateError: "",
+    loadingCandidates: false,
+    proposalError: "",
+    dismissingProposalId: "",
+    selectedBatch: null,
+    selectedBatchId: "",
+    models: [],
+    statusError: "",
+    batchError: "",
+    detailError: "",
+    modelsError: "",
+    loadingStatus: false,
+    loadingBatches: false,
+    loadingDetail: false,
+    saving: false,
+    restartingCollection: false,
+  };
+  let environmentId = getEnvironmentId();
+  let workspace = "";
+  let revision = 0;
+  let detailRevision = 0;
+  let stale = true;
+  let modelsStale = true;
+  let environmentEpoch = 0;
+
+  const learningActive = () => workspace === "learning";
+  const homeActive = () => workspace === "home";
+  const canRefresh = () => (learningActive() || homeActive()) && isVisible();
+  const snapshot = () => ({
+    ...state,
+    environmentId,
+    learningActive: learningActive(),
+    homeActive: homeActive(),
+  });
+  const publish = () => render(snapshot());
+  const currentRead = (readEnvironmentId, readRevision) =>
+    readRevision === revision && readEnvironmentId === getEnvironmentId();
+
+  async function readCurrentState() {
+    stale = false;
+    const readEnvironmentId = getEnvironmentId();
+    const readRevision = ++revision;
+    const includeBatches = learningActive();
+    const includeModels = includeBatches && modelsStale;
+    const includeCandidates =
+      includeBatches &&
+      typeof client.listPassiveLearningCandidates === "function";
+    state.loadingStatus = state.status === null;
+    state.loadingBatches = includeBatches && state.batches.length === 0;
+    state.loadingCandidates =
+      includeCandidates && state.candidates.length === 0;
+    publish();
+    const [statusRead, batchRead, modelRead, candidateRead] =
+      await Promise.allSettled([
+        client.loadPassiveLearning(readEnvironmentId),
+        includeBatches
+          ? client.listPassiveLearningBatches(readEnvironmentId)
+          : Promise.resolve(null),
+        includeModels
+          ? client.listModels(readEnvironmentId)
+          : Promise.resolve(null),
+        includeCandidates
+          ? client.listPassiveLearningCandidates(readEnvironmentId)
+          : Promise.resolve(null),
+      ]);
+    if (!currentRead(readEnvironmentId, readRevision)) return;
+    if (includeCandidates) {
+      if (
+        candidateRead.status === "fulfilled" &&
+        Array.isArray(candidateRead.value?.items)
+      ) {
+        state.candidates = candidateRead.value.items;
+        state.candidateError = "";
+      } else {
+        state.candidateError =
+          candidateRead.status === "rejected"
+            ? errorMessage(candidateRead.reason)
+            : "Candidates are unavailable.";
+      }
+    }
+    let changedSelectedBatch = false;
+    if (
+      statusRead.status === "fulfilled" &&
+      hasLearningStatus(statusRead.value)
+    ) {
+      state.status = statusRead.value.status;
+      state.statusError = "";
+    } else {
+      state.statusError =
+        statusRead.status === "rejected"
+          ? errorMessage(statusRead.reason)
+          : "Learning status is unavailable.";
+    }
+    if (includeBatches) {
+      if (
+        batchRead.status === "fulfilled" &&
+        Array.isArray(batchRead.value?.items)
+      ) {
+        const selectedId = state.selectedBatchId;
+        const previous = state.batches.find((batch) => batch.id === selectedId);
+        const next = batchRead.value.items.find(
+          (batch) => batch.id === selectedId,
+        );
+        const summaryKey = (batch) =>
+          JSON.stringify([
+            batch?.status,
+            batch?.reason,
+            batch?.completedAt,
+            batch?.observationCount,
+            batch?.recordIds,
+            batch?.candidateIds,
+          ]);
+        changedSelectedBatch = Boolean(
+          selectedId && next && summaryKey(previous) !== summaryKey(next),
+        );
+        if (selectedId && !next) void selectBatch("");
+        state.batches = batchRead.value.items;
+        state.batchError = "";
+      } else {
+        state.batchError =
+          batchRead.status === "rejected"
+            ? errorMessage(batchRead.reason)
+            : "Recent batches are unavailable.";
+      }
+    }
+    if (includeModels) {
+      if (
+        modelRead.status === "fulfilled" &&
+        Array.isArray(modelRead.value?.profiles)
+      ) {
+        state.models = modelRead.value.profiles;
+        state.modelsError = "";
+        modelsStale = false;
+      } else {
+        state.modelsError =
+          modelRead.status === "rejected"
+            ? errorMessage(modelRead.reason)
+            : "Model choices are unavailable.";
+      }
+    }
+    const hostState = JSON.stringify([
+      state.status?.deviceId,
+      state.status?.state,
+    ]);
+    if (includeModels || state.hostConnectionKey !== hostState) {
+      try {
+        const host = await client.getSystemHostConnection?.();
+        if (!currentRead(readEnvironmentId, readRevision)) return;
+        state.hostConnection = host ?? null;
+        state.hostConnectionKey = hostState;
+      } catch {
+        if (!currentRead(readEnvironmentId, readRevision)) return;
+        state.hostConnection = null;
+      }
+    }
+    state.loadingStatus = false;
+    state.loadingBatches = false;
+    state.loadingCandidates = false;
+    publish();
+    if (changedSelectedBatch) void selectBatch(state.selectedBatchId);
+  }
+
+  const eventRefresh = createEventRefresh({
+    canRefresh,
+    refresh: readCurrentState,
+    setTimer,
+    clearTimer,
+  });
+
+  function maybeRefresh() {
+    if (!canRefresh() || !stale) return;
+    void eventRefresh.run();
+  }
+
+  function markStale() {
+    stale = true;
+    maybeRefresh();
+  }
+
+  function resetEnvironment() {
+    eventRefresh.cancel();
+    revision += 1;
+    detailRevision += 1;
+    environmentEpoch += 1;
+    environmentId = getEnvironmentId();
+    Object.assign(state, {
+      status: null,
+      hostConnection: null,
+      hostConnectionKey: "",
+      batches: [],
+      candidates: [],
+      candidateError: "",
+      loadingCandidates: false,
+      proposalError: "",
+      dismissingProposalId: "",
+      selectedBatch: null,
+      selectedBatchId: "",
+      models: [],
+      statusError: "",
+      batchError: "",
+      detailError: "",
+      modelsError: "",
+      loadingStatus: false,
+      loadingBatches: false,
+      loadingDetail: false,
+      saving: false,
+      restartingCollection: false,
+    });
+    stale = true;
+    modelsStale = true;
+    publish();
+    maybeRefresh();
+  }
+
+  async function selectBatch(id) {
+    const readEnvironmentId = getEnvironmentId();
+    const readRevision = ++detailRevision;
+    state.selectedBatchId = id;
+    state.selectedBatch = null;
+    state.detailError = "";
+    state.loadingDetail = Boolean(id);
+    publish();
+    if (!id) return;
+    try {
+      const result = await client.loadPassiveLearningBatch(
+        id,
+        readEnvironmentId,
+      );
+      if (
+        readRevision !== detailRevision ||
+        readEnvironmentId !== getEnvironmentId()
+      )
+        return;
+      if (!result?.batch || result.batch.id !== id)
+        throw new Error("Batch details are unavailable.");
+      state.selectedBatch = result.batch;
+    } catch (error) {
+      if (
+        readRevision !== detailRevision ||
+        readEnvironmentId !== getEnvironmentId()
+      )
+        return;
+      state.detailError = errorMessage(error);
+    } finally {
+      if (
+        readRevision === detailRevision &&
+        readEnvironmentId === getEnvironmentId()
+      ) {
+        state.loadingDetail = false;
+        publish();
+      }
+    }
+  }
+
+  async function mutateLearningState(mutate, failureMessage) {
+    if (state.saving) return;
+    const mutationEnvironmentId = getEnvironmentId();
+    const epoch = environmentEpoch;
+    const mutationCurrent = () =>
+      epoch === environmentEpoch &&
+      mutationEnvironmentId === getEnvironmentId();
+    state.saving = true;
+    state.statusError = "";
+    publish();
+    try {
+      const result = await mutate(mutationEnvironmentId);
+      if (!mutationCurrent()) return;
+      if (!hasLearningStatus(result)) throw new Error(failureMessage);
+      state.status = result.status;
+      markStale();
+      return result.status;
+    } catch (error) {
+      if (mutationCurrent()) state.statusError = learningActionErrorMessage(error);
+    } finally {
+      if (mutationCurrent()) {
+        state.saving = false;
+        publish();
+      }
+    }
+  }
+
+  function canRestartCollection() {
+    if (state.saving || state.loadingStatus) return false;
+    if (state.restartingCollection) return false;
+    if (environmentId !== getEnvironmentId()) return false;
+    return typeof client.restartPassiveLearningCollection === "function";
+  }
+
+  async function restartCollection() {
+    if (!canRestartCollection()) return;
+    const epoch = environmentEpoch;
+    const targetEnvironment = environmentId;
+    state.restartingCollection = true;
+    try {
+      return await mutateLearningState(
+        (id) => client.restartPassiveLearningCollection(id),
+        "Collection restart was not confirmed.",
+      );
+    } finally {
+      const hasCurrentRestart = epoch === environmentEpoch && targetEnvironment === getEnvironmentId();
+      if (hasCurrentRestart) {
+        state.restartingCollection = false;
+        publish();
+      }
+    }
+  }
+
+  function findDeliveredProposal(id) {
+    return state.status?.proactive?.proposals?.find(
+      (proposal) =>
+        proposal.id === id &&
+        ["delivered", "dismissed"].includes(proposal.status),
+    );
+  }
+
+  async function openProposal(id) {
+    const proposal = findDeliveredProposal(id);
+    if (!proposal || environmentId !== getEnvironmentId()) return;
+    const epoch = environmentEpoch;
+    state.proposalError = "";
+    try {
+      await openSession(proposal.sessionId, environmentId);
+    } catch (error) {
+      if (epoch !== environmentEpoch) return;
+      state.proposalError = errorMessage(error);
+      publish();
+    }
+  }
+
+  async function dismissProposal(id) {
+    if (state.dismissingProposalId || !findDeliveredProposal(id)) return;
+    const targetEnvironment = getEnvironmentId();
+    if (environmentId !== targetEnvironment) return;
+    const epoch = environmentEpoch;
+    state.dismissingProposalId = id;
+    state.proposalError = "";
+    publish();
+    try {
+      const result = await client.dismissPassiveLearningProposal(
+        id,
+        targetEnvironment,
+      );
+      if (
+        epoch !== environmentEpoch ||
+        targetEnvironment !== getEnvironmentId()
+      )
+        return;
+      if (result?.ok !== true)
+        throw new Error("Suggestion dismissal was not confirmed.");
+      markStale();
+    } catch (error) {
+      if (
+        epoch === environmentEpoch &&
+        targetEnvironment === getEnvironmentId()
+      )
+        state.proposalError = errorMessage(error);
+    } finally {
+      if (
+        epoch === environmentEpoch &&
+        targetEnvironment === getEnvironmentId()
+      ) {
+        state.dismissingProposalId = "";
+        publish();
+      }
+    }
+  }
+
+  return Object.freeze({
+    snapshot,
+    publish,
+    restartCollection,
+    configure: (preferences) =>
+      mutateLearningState(
+        (id) => client.configurePassiveLearning(preferences, id),
+        "Learning configuration was not confirmed.",
+      ),
+    clearPending: () =>
+      mutateLearningState(
+        (id) => client.clearPassiveLearningPending(id),
+        "Pending activity deletion was not confirmed.",
+      ),
+    selectBatch,
+    openProposal,
+    dismissProposal,
+    refresh: () => {
+      stale = true;
+      modelsStale = true;
+      return eventRefresh.run();
+    },
+    reconnect: () => {
+      state.hostConnectionKey = "";
+      markStale();
+    },
+    visibilityChanged: maybeRefresh,
+    handleRealtime(message) {
+      if (message?.type === "system-host.changed") {
+        revision += 1;
+        state.hostConnectionKey = "";
+        stale = true;
+        eventRefresh.schedule();
+        return;
+      }
+      if (message?.type !== "learning.changed") return;
+      if (message.environmentId !== getEnvironmentId()) return;
+      stale = true;
+      eventRefresh.schedule();
+    },
+    setWorkspace(nextWorkspace) {
+      const wasLearningActive = learningActive();
+      const wasHomeActive = homeActive();
+      workspace = nextWorkspace;
+      if (!wasLearningActive && learningActive()) modelsStale = true;
+      if (
+        (!wasLearningActive && learningActive()) ||
+        (!wasHomeActive && homeActive())
+      )
+        stale = true;
+      publish();
+      maybeRefresh();
+    },
+    environmentChanged: resetEnvironment,
+  });
+}

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

@@ -32,7 +32,6 @@ export interface RealtimeEventControllerOptions {
   scheduleThinkingRender(): void;
   cancelScheduledMessageRender(): void;
   cancelScheduledThinkingRender(): void;
-  forgetThinkingDisclosure(messageId: string): void;
   markCurrentSessionReadSoon(): void;
   applySessionTitleUpdate(sessionId: unknown, title: unknown): void;
   setMessageActivityStatus(message: string): void;
@@ -41,6 +40,7 @@ export interface RealtimeEventControllerOptions {
     environmentId: string;
     sessionId: string;
     terminalRequestId: string;
+    cancelled?: boolean;
   }): void | Promise<void>;
   loadSessions(): void | Promise<unknown>;
 }

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

@@ -1,4 +1,8 @@
 import { createScheduleRealtimeController } from "./schedule-realtime.js";
+import {
+  isStopResult,
+  stoppedResponseText,
+} from "../lib/request-stop-state.js";
 import { isMatchingActiveRequest } from "../ui-behavior.js";
 import {
   eventKeyFor,
@@ -13,6 +17,8 @@ import { reduceTaskProgress } from "../lib/task-progress.js";
 import { projectWebSourceEvent } from "../lib/web-source-event.js";
 import { projectToolActivityEvent } from "../lib/tool-activity-event.js";
 import { canReplaceContextWindowEvidence } from "../lib/context-window-snapshot-order.js";
+import { isWorkspaceChange } from "../lib/workspace-change.js";
+import { createRequestLifecycleController } from "./request-lifecycle-controller.js";
 
 export { normalizeRealtimeMessage } from "../lib/realtime-message.js";
 export { taskStatusClass } from "../lib/task-progress.js";
@@ -60,7 +66,6 @@ export function createRealtimeEventController({
   scheduleThinkingRender,
   cancelScheduledMessageRender,
   cancelScheduledThinkingRender,
-  forgetThinkingDisclosure,
   markCurrentSessionReadSoon,
   applySessionTitleUpdate,
   setMessageActivityStatus,
@@ -68,6 +73,18 @@ export function createRealtimeEventController({
   drainQueuedComposerMessage,
   loadSessions,
 }) {
+  const lifecycleController = createRequestLifecycleController({
+    state,
+    addOrMergeMessage,
+    normalizeChatMessage,
+    activeAssistantForRequest,
+    updateComposerSendState,
+    renderMessages,
+    setMessageActivityStatus,
+    markCurrentSessionReadSoon,
+    cancelScheduledMessageRender,
+    cancelScheduledThinkingRender,
+  });
   const scheduleRealtime = createScheduleRealtimeController({
     state,
     selectedEnvironmentId,
@@ -83,7 +100,13 @@ export function createRealtimeEventController({
 
   function trackSeq(message) {
     if (message.requestId && typeof message.seqNo === "number") {
-      state.lastSeqByRequest.set(message.requestId, message.seqNo);
+      state.lastSeqByRequest.set(
+        message.requestId,
+        Math.max(
+          state.lastSeqByRequest.get(message.requestId) || 0,
+          message.seqNo,
+        ),
+      );
     }
   }
 
@@ -254,6 +277,10 @@ export function createRealtimeEventController({
   }
 
   function recordEvent(message) {
+    if (isWorkspaceChange(message)) {
+      trackSeq(message);
+      return;
+    }
     const requestId = textOf(message.requestId) || state.activeRequestId;
     const eventSequence = hasOriginalEventSequence(message.eventSequence)
       ? message.eventSequence
@@ -381,15 +408,33 @@ export function createRealtimeEventController({
       environmentId,
       sessionId,
       terminalRequestId: requestId,
+      cancelled: isStopResult(message),
     });
   }
 
   function handle(rawMessage) {
     const message = normalizeRealtimeMessage(rawMessage);
+    if (message.type === "tool_approval_ack") {
+      if (!message.accepted) {
+        state.submittedToolApprovalIds.delete(message.approvalId);
+        recordControlEvent({
+          name: "Approval unavailable",
+          tone: "failed",
+          summary:
+            "The decision could not be saved. Refresh the conversation and try again.",
+        });
+        renderMessages();
+      }
+      return;
+    }
     if (message.type === "steer_ack" && handleSteerAcknowledgement(message))
       return;
     if (scheduleRealtime.handle(message)) return;
     if (!shouldAcceptMessage(message)) return;
+    if (lifecycleController.handle(message)) {
+      recordEvent(message);
+      return;
+    }
     if (message.type === "chat_read_state") {
       applySessionReadState(message.sessionId, message.readState || message);
       return;
@@ -446,7 +491,6 @@ export function createRealtimeEventController({
         const assistant = activeAssistantForRequest(requestId);
         assistant.streaming = false;
         if (message.output) assistant.text = textOf(message.output);
-        forgetThinkingDisclosure(assistant.id);
       }
       cancelScheduledMessageRender();
       recordEvent(message);
@@ -466,13 +510,16 @@ export function createRealtimeEventController({
       if (requestId) {
         const assistant = activeAssistantForRequest(requestId);
         assistant.streaming = false;
-        assistant.text = textOf(message.error, "Request failed.");
-        forgetThinkingDisclosure(assistant.id);
+        assistant.text = isStopResult(message)
+          ? stoppedResponseText(assistant.text, message)
+          : textOf(message.error, "Request failed.");
       }
       recordEvent(message);
       cancelScheduledThinkingRender();
       renderMessages();
-      setMessageActivityStatus("ABot request failed.");
+      setMessageActivityStatus(
+        isStopResult(message) ? "Response stopped." : "ABot request failed.",
+      );
       settleTerminal(message, terminalRequestId);
       return;
     }

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

@@ -0,0 +1,12 @@
+export declare function createRequestLifecycleController(options: {
+  state: Record<string, any>;
+  addOrMergeMessage(message: any): void;
+  normalizeChatMessage(message: any): any;
+  activeAssistantForRequest(requestId: string): { streaming: boolean };
+  updateComposerSendState(): void;
+  renderMessages(): void;
+  setMessageActivityStatus(message: string): void;
+  markCurrentSessionReadSoon(): void;
+  cancelScheduledMessageRender(): void;
+  cancelScheduledThinkingRender(): void;
+}): { handle(message: Record<string, unknown>): boolean };