@abot-ai/runtime 1.3.1 → 1.5.0

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

@@ -1,6 +1,13 @@
+import { createModelSetupWizard } from "./components/model-setup/wizard.js";
+import { createRuntimeConfigActivation } from "./components/runtime-config-activation.js";
+import { createPluginManager } from "./components/plugins/manager.js";
+import { createComputerAccessFeature } from "./computer-access-feature.js";
+import { createHomeGuidance } from "./components/home-guidance/home-guidance.js";
 import { createConfigWorkspace } from "./components/config-workspace.js";
+import { createModelRemovalController } from "./components/config-workspace/model-removal.js";
 import { createLongTermMemorySetup } from "./components/long-term-memory-setup.js";
 import { createLongTermMemoryManager } from "./components/long-term-memory/manager.js";
+import { createMemoryWorkspace } from "./components/long-term-memory/workspace.js";
 import { createLongTermMemoryController } from "./controllers/long-term-memory/controller.js";
 
 export function createConfigurationFeature({
@@ -8,8 +15,16 @@ export function createConfigurationFeature({
   runtimeClient,
   selectedEnvironmentId,
   recordControlEvent,
+  onNavigationChange = () => {},
+  onConfigurationApplied = async () => {},
+  onConfigurationSettled = () => true,
+  getLearningSnapshot = () => null,
+  isRuntimeReady = () => true,
 }) {
   let configWorkspace;
+  let activation;
+  let modelSetup;
+  let modelRemoval;
   const longTermMemorySetup = createLongTermMemorySetup({
     getEnvironmentId: selectedEnvironmentId,
     loadStatus: (environmentId) =>
@@ -19,13 +34,19 @@ export function createConfigurationFeature({
         environmentId,
         providerId,
       }),
-    enableMemory: (input, environmentId) =>
-      runtimeClient.enableLongTermMemory({
+    enableMemory: async (input, environmentId) => {
+      const result = await runtimeClient.enableLongTermMemory({
         environmentId,
         ...input,
-      }),
-    disableMemory: (environmentId) =>
-      runtimeClient.disableLongTermMemory(environmentId),
+      });
+      activation?.markPending();
+      return result;
+    },
+    disableMemory: async (environmentId) => {
+      const result = await runtimeClient.disableLongTermMemory(environmentId);
+      activation?.markPending();
+      return result;
+    },
     recordControlEvent,
     beginRuntimeMutation: () =>
       configWorkspace?.beginExternalRuntimeMutation() ?? false,
@@ -44,8 +65,60 @@ export function createConfigurationFeature({
   longTermMemoryManager = createLongTermMemoryManager({
     actions: longTermMemoryController,
   });
+  longTermMemorySetup.mount(dom.memorySetupRoot);
+  longTermMemoryManager.mount(dom.memoryManagementRoot);
+  const memoryWorkspace = createMemoryWorkspace({
+    root: dom.memoryWorkspacePanel,
+  });
 
+  const pluginManager = createPluginManager({
+    getEnvironmentId: selectedEnvironmentId,
+    onConfigurationSaved: () => activation?.markPending(),
+    loadPlugins: () => runtimeClient.getRuntimePlugins(),
+    setPlugin: (input) => runtimeClient.setRuntimePlugin(input),
+    beginRuntimeMutation: (subject) =>
+      configWorkspace?.beginExternalRuntimeMutation(subject) ?? false,
+    refreshRuntimeConfig: (failurePrefix) =>
+      configWorkspace?.refreshAfterExternalRuntimeMutation(failurePrefix) ??
+      Promise.resolve(false),
+    endRuntimeMutation: () => configWorkspace?.endExternalRuntimeMutation(),
+    recordControlEvent,
+  });
+
+  let homeSetupSuggestion;
+  const computerAccess = createComputerAccessFeature({
+    dom,
+    runtimeClient,
+    onChange: () => homeSetupSuggestion?.render(),
+  });
+  homeSetupSuggestion = createHomeGuidance({
+    container: dom.homeDashboardRoot?.querySelector(".home-workspace-content"),
+    homeRegion: dom.homeWorkspacePanel,
+    client: runtimeClient,
+    getEnvironmentId: selectedEnvironmentId,
+    getLearningSnapshot,
+    isRuntimeReady,
+    // Computer access is permanently visible above the Home suggestions.
+    getConnectionState: () => null,
+    supportsConnection: () => false,
+    refreshConnection: () => {},
+    onOpen: (id) => {
+      if (id === "coworker") return dom.learningWorkspaceButton?.click();
+      if (id === "memory") {
+        dom.memoryWorkspaceButton?.click();
+        if (dom.memoryWorkspacePanel?.hidden === false)
+          memoryWorkspace.activate("setup");
+        return;
+      }
+      dom.pluginsWorkspaceButton?.click();
+    },
+  });
   configWorkspace = createConfigWorkspace({
+    onNavigationChange,
+    onRemoveModel: (model) => {
+      if (modelSetup?.isOpen()) return;
+      return modelRemoval.remove(model);
+    },
     dom: {
       refreshConfigButton: dom.refreshConfigButton,
       configStatus: dom.configStatus,
@@ -53,14 +126,30 @@ export function createConfigurationFeature({
     },
     loadDashboard: () =>
       runtimeClient.loadConfigDashboard(selectedEnvironmentId()),
-    saveFile: ({ kind, id, config }) =>
-      runtimeClient.saveConfigFile({
+    saveFile: async ({ kind, id, config, expectedRevision }) => {
+      const result = await runtimeClient.saveConfigFile({
         environmentId: selectedEnvironmentId(),
         kind,
         id,
         config,
-      }),
+        expectedRevision,
+      });
+      activation?.markPending();
+      return result;
+    },
+    onAddModel: async (options) => {
+      if (modelSetup?.isOpen()) return;
+      if (!configWorkspace.beginExternalRuntimeMutation("model setup")) return;
+      configWorkspace.endExternalRuntimeMutation();
+      try {
+        await modelSetup.open(options);
+      } catch {
+        dom.configStatus.textContent =
+          "Model setup could not be opened. Try again.";
+      }
+    },
     memorySetup: longTermMemorySetup,
+    pluginManagement: pluginManager,
     memoryManagement: {
       load: () => longTermMemoryController.load(),
       mount: (root) => longTermMemoryManager.mount(root),
@@ -68,5 +157,94 @@ export function createConfigurationFeature({
     recordControlEvent,
   });
 
-  return configWorkspace;
+  activation = createRuntimeConfigActivation({
+    onAppliedSettled: () => onConfigurationSettled(),
+    root: dom.configDashboard.parentElement,
+    getWorkspace: () => configWorkspace,
+    apply: () =>
+      runtimeClient.applyRuntimeConfiguration(selectedEnvironmentId()),
+    getEnvironmentId: selectedEnvironmentId,
+    refresh: async () => {
+      const refreshed = await configWorkspace.load({ protectUnsaved: false });
+      if (refreshed) pluginManager.markApplied?.();
+      await onConfigurationApplied();
+      return refreshed;
+    },
+  });
+  modelRemoval = createModelRemovalController({
+    removeModel: (input, environmentId) =>
+      runtimeClient.removeRuntimeModel(input, environmentId),
+    loadDashboard: (environmentId) =>
+      runtimeClient.loadConfigDashboard(environmentId, { settled: true }),
+    getEnvironmentId: selectedEnvironmentId,
+    beginRuntimeMutation: (subject) =>
+      configWorkspace.beginExternalRuntimeMutation(subject),
+    endRuntimeMutation: () => configWorkspace.endExternalRuntimeMutation(),
+    refreshRuntimeConfig: (prefix) =>
+      configWorkspace.refreshAfterExternalRuntimeMutation(prefix),
+    onSaved: () => activation.markPending(),
+    setStatus: (...args) => configWorkspace.setStatus(...args),
+  });
+  modelSetup = createModelSetupWizard({
+    root: dom.configDashboard.parentElement,
+    getEnvironmentId: selectedEnvironmentId,
+    loadSetup: () => runtimeClient.loadModelSetup(selectedEnvironmentId()),
+    saveModel: (input) =>
+      runtimeClient.addRuntimeModel(input, selectedEnvironmentId()),
+    applySetup: () =>
+      runtimeClient.applyRuntimeConfiguration(selectedEnvironmentId()),
+    beginRuntimeMutation: () =>
+      configWorkspace.beginExternalRuntimeMutation("model setup"),
+    endRuntimeMutation: () => configWorkspace.endExternalRuntimeMutation(),
+    onSaved: () => activation.markPending(),
+    onDeferred: async (model) => {
+      const refreshed =
+        await configWorkspace.refreshAfterExternalRuntimeMutation(
+          "Model saved; refresh required",
+        );
+      if (!refreshed) return false;
+      return configWorkspace.selectModel(model.profileId);
+    },
+    onComplete: async (model) => {
+      activation.markApplied();
+      try {
+        const refreshed =
+          await configWorkspace.refreshAfterExternalRuntimeMutation(
+            "Model added; refresh required",
+          );
+        if (!refreshed) return false;
+        const memoryRefreshed = await longTermMemorySetup.load();
+        if (!memoryRefreshed) return false;
+        pluginManager.markApplied?.();
+        return configWorkspace.selectModel(model.profileId);
+      } finally {
+        await onConfigurationApplied();
+      }
+    },
+    onClosed: ({ completed }) => {
+      if (completed) configWorkspace.focusSelectedModel();
+      onConfigurationSettled();
+    },
+  });
+
+  const prepareDiscardChanges = configWorkspace.prepareDiscardChanges;
+  return {
+    ...configWorkspace,
+    openComputerSetup: computerAccess.open,
+    refreshComputerAccess: computerAccess.load,
+    renderHomeGuidance: () => homeSetupSuggestion.render(),
+    showActivityMemories: () => {
+      memoryWorkspace.activate("memories");
+      void longTermMemoryController.setOriginFilter("passive_observation");
+      longTermMemoryManager.focus();
+    },
+    prepareDiscardChanges: (...args) => {
+      if (modelSetup.isOpen()) {
+        dom.configStatus.textContent =
+          "Finish or cancel model setup before leaving configuration.";
+        return null;
+      }
+      return prepareDiscardChanges(...args);
+    },
+  };
 }

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

@@ -12,7 +12,87 @@ export function createAppEventBindings({
   composerActions,
   actions,
   documentRoot = document,
+  onSessionCreated = () => {},
+  onNavigationChange = () => {},
 }) {
+  let environmentChangeRevision = 0;
+  let environmentChanging = false;
+
+  async function changeEnvironment(
+    nextEnvironmentId,
+    { restoreSession = true, notifyEnvironmentChange = true } = {},
+  ) {
+    const previousEnvironmentId = actions.savedEnvironmentId?.() || "";
+    const recoveryEnvironmentId =
+      state.activeComposerQueueRecovery?.scope.environmentId ?? "";
+    const restoreEnvironmentSelection = () => {
+      dom.environmentSelect.value =
+        previousEnvironmentId || recoveryEnvironmentId;
+      state.agentPickerOpen = false;
+      actions.renderAgentPicker();
+    };
+    if (nextEnvironmentId === previousEnvironmentId) {
+      state.agentPickerOpen = false;
+      actions.renderAgentPicker();
+      return true;
+    }
+    dom.environmentSelect.value = nextEnvironmentId;
+    const preparedEnvironmentChange = actions.beforeEnvironmentChange
+      ? actions.beforeEnvironmentChange({
+          from: previousEnvironmentId,
+          to: nextEnvironmentId,
+        })
+      : true;
+    if (environmentChangeWasDeclined(preparedEnvironmentChange)) {
+      restoreEnvironmentSelection();
+      return false;
+    }
+    if (!actions.suspendQueueRecovery()) {
+      restoreEnvironmentSelection();
+      return false;
+    }
+    const revision = ++environmentChangeRevision;
+    environmentChanging = true;
+    if (typeof preparedEnvironmentChange === "function")
+      preparedEnvironmentChange();
+    actions.invalidateSessionLoads?.();
+    state.agentPickerOpen = false;
+    actions.renderAgentPicker();
+    actions.saveEnvironmentId(nextEnvironmentId);
+    state.currentSessionId = "";
+    state.messages = [];
+    actions.clearAttachments();
+    actions.resetLiveRequestView();
+    dom.sessionTitle.textContent = "New conversation";
+    actions.applyConversationChrome();
+    actions.renderMessages();
+    try {
+      const loading = Promise.allSettled([
+        actions.loadModels(),
+        actions.loadAgentMode(),
+        actions.loadRuntimeConfig({
+          protectUnsaved: false,
+          clearBeforeLoad: true,
+        }),
+      ]);
+      if (notifyEnvironmentChange) {
+        const ChangeEvent =
+          dom.environmentSelect.ownerDocument?.defaultView?.Event ?? Event;
+        dom.environmentSelect.dispatchEvent(new ChangeEvent("change"));
+      }
+      await loading;
+      if (revision !== environmentChangeRevision) return false;
+      if (dom.environmentSelect.value !== nextEnvironmentId) return false;
+      if (restoreSession) await actions.restoreLastSession();
+      return dom.environmentSelect.value === nextEnvironmentId;
+    } finally {
+      if (revision === environmentChangeRevision) {
+        environmentChanging = false;
+        onNavigationChange();
+      }
+    }
+  }
+
   function bind() {
     dom.sessionSearchInput.addEventListener("input", () => {
       state.sessionQuery = dom.sessionSearchInput.value;
@@ -31,6 +111,7 @@ export function createAppEventBindings({
       if (!actions.suspendQueueRecovery()) return;
       if (preparedWorkspaceActivation() === false) return;
       state.currentSessionId = createWebSessionId();
+      onSessionCreated(state.currentSessionId);
       actions.saveSessionId(
         actions.selectedEnvironmentId(),
         state.currentSessionId,
@@ -48,63 +129,9 @@ export function createAppEventBindings({
       dom.composerInput.focus();
     });
     dom.environmentSelect.addEventListener("change", () => {
-      const previousEnvironmentId = actions.savedEnvironmentId?.() || "";
-      const nextEnvironmentId = dom.environmentSelect.value;
-      const recoveryEnvironmentId =
-        state.activeComposerQueueRecovery?.scope.environmentId ?? "";
-      const restoreEnvironmentSelection = () => {
-        dom.environmentSelect.value =
-          previousEnvironmentId || recoveryEnvironmentId;
-        state.agentPickerOpen = false;
-        actions.renderAgentPicker();
-      };
-      if (nextEnvironmentId === previousEnvironmentId) {
-        state.agentPickerOpen = false;
-        actions.renderAgentPicker();
-        return;
-      }
-      const preparedEnvironmentChange = actions.beforeEnvironmentChange
-        ? actions.beforeEnvironmentChange({
-            from: previousEnvironmentId,
-            to: nextEnvironmentId,
-          })
-        : true;
-      if (
-        preparedEnvironmentChange === false ||
-        preparedEnvironmentChange === null
-      ) {
-        restoreEnvironmentSelection();
-        return;
-      }
-      if (!actions.suspendQueueRecovery()) {
-        restoreEnvironmentSelection();
-        return;
-      }
-      if (typeof preparedEnvironmentChange === "function") {
-        preparedEnvironmentChange();
-      }
-      actions.invalidateSessionLoads?.();
-      state.agentPickerOpen = false;
-      actions.renderAgentPicker();
-      actions.saveEnvironmentId(nextEnvironmentId);
-      state.currentSessionId = "";
-      state.messages = [];
-      actions.clearAttachments();
-      actions.resetLiveRequestView();
-      dom.sessionTitle.textContent = "New conversation";
-      actions.applyConversationChrome();
-      actions.renderMessages();
-      void (async () => {
-        await Promise.allSettled([
-          actions.loadModels(),
-          actions.loadAgentMode(),
-          actions.loadRuntimeConfig({
-            protectUnsaved: false,
-            clearBeforeLoad: true,
-          }),
-        ]);
-        await actions.restoreLastSession();
-      })();
+      void changeEnvironment(dom.environmentSelect.value, {
+        notifyEnvironmentChange: false,
+      });
     });
     dom.agentPickerButton.addEventListener("click", (event) => {
       event.stopPropagation();
@@ -313,5 +340,14 @@ export function createAppEventBindings({
     );
   }
 
-  return { bind };
+  return {
+    bind,
+    changeEnvironment,
+    isEnvironmentChanging: () => environmentChanging,
+  };
+}
+
+function environmentChangeWasDeclined(preparedChange) {
+  if (preparedChange === false) return true;
+  return preparedChange === null;
 }

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

@@ -75,5 +75,5 @@ export function createChatRequestController({
     conversationSession.activateRequestForScope(scope, requestId);
   }
 
-  return { postChatMessage, sendMessage };
+  return { postChatMessage, sendMessage, stopRequest: (scope) => client.stopChatRequest(scope) };
 }

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

@@ -10,7 +10,7 @@ export type ComposerScope = Readonly<{
 }>;
 
 export type ComposerQueueDrainScope = ComposerScope &
-  Readonly<{ terminalRequestId: string }>;
+  Readonly<{ terminalRequestId: string; cancelled?: boolean }>;
 
 export interface ComposerQueueRecovery {
   scope: ComposerScope;
@@ -62,7 +62,7 @@ export interface ComposerQueuePostChatRequest {
 export interface ComposerQueueControlEvent {
   type: "control";
   name: string;
-  tone: "failed";
+  tone: "failed" | "neutral";
   summary: string;
 }
 

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

@@ -54,7 +54,7 @@ export function createComposerQueueController({
     attachments.render();
   }
 
-  function reportFailure(scope, summary) {
+  function reportFailure(scope, summary, tone = "failed") {
     if (!isCurrentScope(scope)) return;
     state.messages.push({
       id: `queue-error-${Date.now()}`,
@@ -69,7 +69,7 @@ export function createComposerQueueController({
     recordControlEvent({
       type: "control",
       name: "Send next queue paused",
-      tone: "failed",
+      tone,
       summary,
     });
   }
@@ -99,7 +99,7 @@ export function createComposerQueueController({
     state.activeComposerQueueRecovery = null;
   }
 
-  async function drain({ environmentId, sessionId, terminalRequestId }) {
+  async function drain({ environmentId, sessionId, terminalRequestId, cancelled = false }) {
     const scope = { environmentId, sessionId };
     const key = scopeKey(scope);
     if (state.composerQueueDrainingScopes.has(key)) return;
@@ -124,6 +124,12 @@ export function createComposerQueueController({
       if (isCurrentScope(scope)) updateSendState();
       return;
     }
+    if (cancelled) {
+      state.composerQueueDrainingScopes.delete(key);
+      recoverForManualSend(scope, "Response stopped. The next queued message is back in the composer; send it when you are ready to continue.", "neutral");
+      if (isCurrentScope(scope)) updateSendState();
+      return;
+    }
     updateSendState();
     const { item, releaseToken } = released;
     let requestId;
@@ -224,7 +230,7 @@ export function createComposerQueueController({
     return true;
   }
 
-  function recoverForManualSend(scope) {
+  function recoverForManualSend(scope, message = "Send next is paused. The queued message was restored to the composer for review and will not be sent automatically.", tone = "neutral") {
     let blockedRelease;
     try {
       blockedRelease = queue.getBlockedRelease(scope);
@@ -251,7 +257,8 @@ export function createComposerQueueController({
     };
     reportFailure(
       scope,
-      "A queued message could not be confirmed after the interruption. It was restored to the composer for review and will not be sent automatically.",
+      message,
+      tone,
     );
     return true;
   }

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

@@ -0,0 +1,9 @@
+export declare function createComposerStopController(options: {
+  state: Record<string, any>;
+  selectedEnvironmentId(): string;
+  stopRequest(
+    scope: Record<string, unknown>,
+  ): Promise<{ accepted: boolean; reason?: string }>;
+  updateSendState(): void;
+  setMessageStatus(message: string, pending?: boolean): void;
+}): { stop(): Promise<void>; isStopping(): boolean };

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

@@ -0,0 +1,64 @@
+import { waitingRequest } from "../lib/request-lifecycle-view.js";
+
+export function createComposerStopController({
+  state,
+  selectedEnvironmentId,
+  stopRequest,
+  updateSendState,
+  setMessageStatus,
+}) {
+  let pendingKey = "";
+  const requestId = () =>
+    state.activeRequestId || waitingRequest(state)?.requestId || "";
+  const currentKey = () =>
+    JSON.stringify([
+      selectedEnvironmentId(),
+      state.currentSessionId,
+      requestId(),
+    ]);
+  const isStopping = () => Boolean(requestId()) && pendingKey === currentKey();
+
+  async function stop() {
+    if (!requestId() || isStopping()) return;
+    const waiting = waitingRequest(state);
+    const scope = {
+      environmentId: selectedEnvironmentId(),
+      sessionId: state.currentSessionId,
+      requestId: requestId(),
+      ...(waiting?.wait && waiting.requestId === requestId()
+        ? {
+            generation: waiting.generation,
+            waitId: waiting.wait.waitId,
+            revision: waiting.revision,
+            commandId: `cancel:${waiting.generation}:${waiting.wait.waitId}`,
+          }
+        : {}),
+    };
+    const key = currentKey();
+    pendingKey = key;
+    updateSendState();
+    setMessageStatus("Stopping…", true);
+    try {
+      const receipt = await stopRequest(scope);
+      if (currentKey() !== key) return;
+      if (!receipt?.accepted)
+        throw new Error(
+          receipt?.reason === "request_not_active"
+            ? "This request has already ended. Waiting for its final status."
+            : "The request could not be stopped. Try again.",
+        );
+      // Keep the request active until its canonical terminal event arrives.
+    } catch (error) {
+      if (pendingKey === key) pendingKey = "";
+      if (currentKey() === key)
+        setMessageStatus(
+          error instanceof Error
+            ? error.message
+            : "Could not stop the request.",
+        );
+    } finally {
+      if (currentKey() === key) updateSendState();
+    }
+  }
+  return { stop, isStopping };
+}

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

@@ -26,6 +26,8 @@ export interface ComposerSubmitActions {
   primaryAction(): string;
   render(options: {
     activeRequestId: string;
+    stopping?: boolean;
+    onStop?: () => void;
     attachmentCount: number;
     busy: boolean;
     disabled: boolean;
@@ -46,6 +48,7 @@ export interface ComposerSubmitQueue {
 
 export interface ComposerSubmitChatRequests {
   sendMessage(text: string): Promise<void>;
+  stopRequest?(scope: ComposerScope & { requestId: string }): Promise<{ accepted: boolean; reason?: string }>;
 }
 
 export interface ComposerSubmitConversationSession {
@@ -69,6 +72,7 @@ export interface ComposerSubmitControllerOptions {
 }
 
 export interface ComposerSubmitController {
+  stop(): false | Promise<void>;
   dispatch(requestedAction?: string): void;
   resize(): void;
   updateSendState(): void;