@abot-ai/runtime 1.7.0 → 1.8.0

package/dist/src/web-ui/app/controllers/conversation-navigation-intent.js

@@ -0,0 +1,15 @@
+/** Session opens and New conversation share the latest navigation intent. */
+export function beginConversationNavigation(state) {
+  const revision = (state.conversationNavigationRevision ?? 0) + 1;
+  state.conversationNavigationRevision = revision;
+  return () => state.conversationNavigationRevision === revision;
+}
+
+/** The selector may name a target whose recovered drafts are not saved yet. */
+export function canNavigateConversation(state) {
+  return hasCommittedConversationEnvironment(state);
+}
+
+export function hasCommittedConversationEnvironment(state) {
+  return state.environmentChangePending !== true;
+}

package/dist/src/web-ui/app/controllers/conversation-request-hydration.js

@@ -15,6 +15,15 @@ function isQueuedTerminalRequest(request, queued) {
   if (textOf(request.requestId) !== queued?.waitForRequestId) return false;
   return request.status === "completed" || request.status === "failed";
 }
+function mergeRefreshedRequests(previous, fresh) {
+  // A latest-page fetch includes every active request. Keep metadata for the
+  // displayed historical page, but never revive an older active projection.
+  const requests = new Map(previous
+    .filter((request) => !isStreamingRequest(request) && request.status !== "awaiting_approval")
+    .map((request) => [request.requestId, request]));
+  for (const request of fresh) requests.set(request.requestId, request);
+  return [...requests.values()];
+}
 function requestsForEventRestoration(requests, streamingRequestIds, appendEvents) {
   if (!appendEvents) return requests;
   // Existing live rows already contain received tokens. Resume their events only after lastSeq.
@@ -35,6 +44,14 @@ export function createConversationRequestHydration({
   async function restore(requests, { appendEvents = false } = {}) {
     const scope = { environmentId: selectedEnvironmentId(), sessionId: state.currentSessionId };
     const viewVersion = state.sessionViewVersion;
+    await sessionQueue.refresh?.();
+    if (!isCurrentHydration(scope, viewVersion)) return false;
+    const waitingRequestId = sessionQueue.peek(scope)?.waitForRequestId;
+    if (!canRestoreSnapshotQueue({ requests }, waitingRequestId)) {
+      const snapshot = await client.loadSession(scope.sessionId, scope.environmentId, { waitingRequestId });
+      if (!isCurrentHydration(scope, viewVersion)) return false;
+      requests = mergeRefreshedRequests(requests, snapshot.requests || []);
+    }
     for (const message of state.messages) {
       if (!isBindableResponse(message)) continue;
       state.requestMessages.set(message.requestId, message.id);
@@ -45,13 +62,6 @@ export function createConversationRequestHydration({
     const streamingRequestIds = new Set(requests
       .filter(isStreamingRequest)
       .map((request) => textOf(request.requestId)));
-    if (streamingRequestIds.size === 1) {
-      const [streamingRequestId] = streamingRequestIds;
-      try { sessionQueue.rebindBlocked(scope, streamingRequestId); }
-      catch (error) {
-        reportQueueFailure(scope, `The active request was restored, but the remaining Send next queue is paused: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
     state.activeRequestId = [...streamingRequestIds][0] || "";
     updateComposerSendState();
     for (const requestId of streamingRequestIds) activeAssistantForRequest(requestId);
@@ -64,7 +74,8 @@ export function createConversationRequestHydration({
       resumeRequest(requestId);
     }
     if (state.activeRequestId) { renderMessages(); return true; }
-    recoverBlockedQueue(scope);
+    await recoverBlockedQueue(scope);
+    if (!isCurrentHydration(scope, viewVersion)) return false;
     const queued = sessionQueue.peek(scope);
     const terminal = requests.find((request) => isQueuedTerminalRequest(request, queued));
     if (terminal) await drainQueuedMessage({ ...scope, terminalRequestId: terminal.requestId, cancelled: isStoppedRequest(terminal) });
@@ -73,15 +84,7 @@ export function createConversationRequestHydration({
     return true;
   }
   async function rehydrate(requests) {
-    const scope = { environmentId: selectedEnvironmentId(), sessionId: state.currentSessionId };
-    const viewVersion = state.sessionViewVersion;
-    const waitingRequestId = sessionQueue.peek(scope)?.waitForRequestId;
-    if (!canRestoreSnapshotQueue({ requests }, waitingRequestId)) {
-      const snapshot = await client.loadSession(scope.sessionId, scope.environmentId, { waitingRequestId });
-      if (!isCurrentHydration(scope, viewVersion)) return false;
-      requests = snapshot.requests || [];
-    }
-    subscribeSession(scope.sessionId);
+    subscribeSession(state.currentSessionId);
     return restore(requests, { appendEvents: true });
   }
   return { restore, rehydrate };

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

@@ -86,7 +86,6 @@ export interface ConversationSessionControllerOptions {
   };
   conversationView: { reset(): void };
   selectedEnvironmentId(): string;
-  clearPendingAttachments(): void;
   applyConversationChrome(): void;
   applyModelSelection(): void;
   renderSessions(): void;
@@ -137,7 +136,7 @@ export declare function createConversationSessionController(
     text: string;
     attachments: unknown[];
     requestId?: string;
-  }): void;
+  }): () => void;
   appendRequestError(error: unknown): void;
   applySessionReadState(sessionId: string, readState: unknown): void;
   applySessionTitleUpdate(sessionId: string, title: unknown): void;

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

@@ -1,3 +1,4 @@
+import { beginConversationNavigation, canNavigateConversation } from "./conversation-navigation-intent.js";
 import {
   captureContextReplayScope,
   bindContextReplayEvents,
@@ -58,7 +59,6 @@ export function createConversationSessionController({
   sessionQueue,
   conversationView,
   selectedEnvironmentId,
-  clearPendingAttachments,
   applyConversationChrome,
   applyModelSelection,
   renderSessions,
@@ -95,6 +95,7 @@ export function createConversationSessionController({
     listPagination.invalidate();
     history.reset();
     sessionRestoreRevision += 1;
+    beginConversationNavigation(state);
     state.sessions = [];
     onSessionListState({ status: "loading", sessions: [] });
     renderSessions();
@@ -166,7 +167,6 @@ export function createConversationSessionController({
     state.taskProgressByRequest.clear();
     state.contextWindowByRequest.clear();
     state.activeRequestId = "";
-    state.composerSending = false;
     conversationView.reset();
     state.submittedToolApprovalIds.clear();
     state.requestMessages.clear();
@@ -178,9 +178,10 @@ export function createConversationSessionController({
   }
 
   function clearCurrentSessionView() {
+    sessionRestoreRevision += 1;
+    beginConversationNavigation(state);
     state.currentSessionId = "";
     state.messages = [];
-    clearPendingAttachments();
     resetLiveRequestView();
     dom.sessionTitle.textContent = "New conversation";
     applyConversationChrome();
@@ -189,7 +190,6 @@ export function createConversationSessionController({
 
   function clearSessionMessagesView() {
     state.messages = [];
-    clearPendingAttachments();
     resetLiveRequestView();
     applyConversationChrome();
     renderMessages();
@@ -411,34 +411,52 @@ export function createConversationSessionController({
     sessionId,
     { isRouteCurrent, commitRouteNavigation, snapshot, page, preserveCurrentWindow = false } = {},
   ) {
+    if (!canNavigateConversation(state)) {
+      setMessageStatus("Wait for the environment change to finish before opening a conversation.");
+      return false;
+    }
+    sessionRestoreRevision += 1;
+    const isCurrentOpen = beginConversationNavigation(state);
     const routeOwned = typeof commitRouteNavigation === "function";
     const loadBeforeReset = routeOwned || preserveCurrentWindow;
     let payload;
     const pageOptions = { ...page, waitingRequestId: sessionQueue.peek({ environmentId: selectedEnvironmentId(), sessionId })?.waitForRequestId };
-    const prefetched = canRestoreSnapshotQueue(snapshot, pageOptions.waitingRequestId) ? snapshot : undefined;
+    let prefetched = canRestoreSnapshotQueue(snapshot, pageOptions.waitingRequestId) ? snapshot : undefined;
     if (loadBeforeReset) {
       const environmentId = selectedEnvironmentId();
       const viewVersion = state.sessionViewVersion;
       const currentSessionId = state.currentSessionId;
       payload = prefetched ?? await client.loadSession(sessionId, environmentId, pageOptions);
-      if (environmentId !== selectedEnvironmentId()) return;
-      if (viewVersion !== state.sessionViewVersion) return;
-      if (currentSessionId !== state.currentSessionId) return;
-      if (routeOwned && isRouteCurrent?.() !== true) return;
+      if (!isCurrentOpen()) return false;
+      if (environmentId !== selectedEnvironmentId()) return false;
+      if (viewVersion !== state.sessionViewVersion) return false;
+      if (currentSessionId !== state.currentSessionId) return false;
+      if (routeOwned && isRouteCurrent?.() !== true) return false;
     }
-    if (
-      state.currentSessionId &&
-      state.currentSessionId !== sessionId &&
-      !suspendQueueRecovery()
-    ) {
-      return;
+    if (state.currentSessionId) {
+      const previousSessionId = state.currentSessionId;
+      const environmentId = selectedEnvironmentId();
+      const canSuspendRecovery = () => {
+        if (!canNavigateConversation(state)) return false;
+        if (!isCurrentOpen()) return false;
+        if (selectedEnvironmentId() !== environmentId) return false;
+        if (state.currentSessionId !== previousSessionId) return false;
+        if (routeOwned && isRouteCurrent?.() !== true) return false;
+        return true;
+      };
+      let prepared = suspendQueueRecovery(canSuspendRecovery);
+      if (typeof prepared?.then === "function") {
+        prepared = await prepared;
+        payload = undefined;
+        prefetched = undefined;
+      }
+      if (!prepared || !canSuspendRecovery()) return false;
     }
-    if (routeOwned && commitRouteNavigation() !== true) return;
+    if (routeOwned && commitRouteNavigation() !== true) return false;
     const viewVersion = state.sessionViewVersion + 1;
     state.currentSessionId = sessionId;
     preferences.saveSessionIdForEnvironment(selectedEnvironmentId(), sessionId);
     state.messages = [];
-    clearPendingAttachments();
     resetLiveRequestView();
     state.sessionViewVersion = viewVersion;
     sessions.setCurrentTitle(
@@ -450,14 +468,15 @@ export function createConversationSessionController({
     renderMessages();
     subscribeSession(sessionId);
 
-    if (!loadBeforeReset) {
+    if (!payload) {
       payload = prefetched ?? await client.loadSession(sessionId, selectedEnvironmentId(), pageOptions);
     }
     if (
+      !isCurrentOpen() ||
       state.currentSessionId !== sessionId ||
       state.sessionViewVersion !== viewVersion
     ) {
-      return;
+      return false;
     }
     history.adopt(payload);
     const rawMessages = Array.isArray(payload.messages) ? payload.messages : [];
@@ -468,8 +487,9 @@ export function createConversationSessionController({
     sessions.applyTitle(sessionId, payload.title);
     sessions.applyReadState(sessionId, payload.readState);
     const requests = Array.isArray(payload.requests) ? payload.requests : [];
-    if (!await requestHydration.restore(requests)) return;
+    if (!await requestHydration.restore(requests)) return false;
     markDisplayedMessagesReadSoon(displayedPage);
+    return true;
   }
 
   function ensureSession() {
@@ -486,7 +506,7 @@ export function createConversationSessionController({
   }
 
   function appendLocalUserMessage({ text, attachments, requestId = "" }) {
-    state.messages.push({
+    const message = {
       id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
       role: "user",
       text,
@@ -494,8 +514,15 @@ export function createConversationSessionController({
       requestId,
       streaming: false,
       attachments,
-    });
+    };
+    state.messages.push(message);
     renderMessages();
+    return () => {
+      const index = state.messages.indexOf(message);
+      if (index < 0) return;
+      state.messages.splice(index, 1);
+      renderMessages();
+    };
   }
 
   function insertSteerMessage({ steerId, requestId, text }) {

package/dist/src/web-ui/app/controllers/conversation-workspace-activation.js

@@ -0,0 +1,27 @@
+import { canNavigateConversation } from "./conversation-navigation-intent.js";
+
+/** Navigation commits only after the recovered draft is saved for the same view. */
+export function createConversationWorkspaceActivation({ state, shell, composerQueue, selectedEnvironmentId }) {
+  return async () => {
+    if (!canNavigateConversation(state)) {
+      shell.showToast?.("Wait for the environment change to finish before opening a conversation.", "neutral");
+      return false;
+    }
+    const environment = selectedEnvironmentId();
+    const session = state.currentSessionId;
+    const version = state.sessionViewVersion;
+    const navigationRevision = shell.navigationRevision?.();
+    const recovery = await composerQueue.prepareRecoveryForNavigation();
+    if (!recovery || recovery.canCommit?.() === false) return false;
+    if (!canNavigateConversation(state)) return false;
+    const hasCurrentWorkspaceNavigation = navigationRevision === shell.navigationRevision?.();
+    if (!hasCurrentWorkspaceNavigation) return false;
+    if (environment !== selectedEnvironmentId()) return false;
+    if (session !== state.currentSessionId) return false;
+    if (version !== state.sessionViewVersion) return false;
+    const activate = shell.prepareWorkspaceActivation("chat", { focus: false });
+    if (!activate) return false;
+    recovery();
+    return activate() !== false;
+  };
+}

package/dist/src/web-ui/app/controllers/daily-memory-review.js

@@ -94,11 +94,11 @@ export function createDailyMemoryReview({ client, getEnvironmentId, preferences,
     return request;
   }
 
-  function markOffered() {
+  async function markOffered() {
     if (!items.length || environment !== getEnvironmentId()) return false;
     const day = localReviewDay(now());
     if (preferences.wasOffered(environment, day)) return false;
-    preferences.markOffered(environment, day);
+    await preferences.markOffered(environment, day);
     return true;
   }
 
@@ -109,25 +109,24 @@ export function createDailyMemoryReview({ client, getEnvironmentId, preferences,
     const target = environment;
     const operation = revision;
     error = "";
-    if (action === "delete") {
-      busy = true;
-      publish();
-      try {
+    busy = true;
+    publish();
+    try {
+      if (action === "delete") {
         const result = await client.deleteLongTermMemory({ environmentId: target, id: record.id });
         if (!isCurrent(operation, target)) return false;
         if (result?.deleted !== true) throw new Error("Delete not confirmed");
-      } catch {
-        if (isCurrent(operation, target)) error = "This memory could not be deleted. Try again, or keep it for now.";
-        return false;
-      } finally {
-        if (isCurrent(operation, target)) { busy = false; publish(); }
       }
+      if (action === "keep") await preferences.markReviewed(target, record);
+      if (!isCurrent(operation, target)) return false;
+      index += 1;
+      return true;
+    } catch {
+      if (isCurrent(operation, target)) error = "Your review could not be completed. Reload before continuing.";
+      return false;
+    } finally {
+      if (isCurrent(operation, target)) { busy = false; publish(); }
     }
-    if (!isCurrent(operation, target)) return false;
-    preferences.markReviewed(target, record);
-    index += 1;
-    publish();
-    return true;
   }
 
   return {

package/dist/src/web-ui/app/controllers/environment-transition.js

@@ -0,0 +1,126 @@
+/** Owns the active window environment. Its saved default is an independent preference. */
+export function createEnvironmentTransition({ state, dom, actions, prepareQueueRecovery, onNavigationChange, onFailure = () => {} }) {
+  let revision = 0;
+  let changing = false;
+  let notifying = false;
+  let prepareAdditional = () => true;
+  let refreshAdditional = () => {};
+  function refreshSubmissionState() {
+    actions.refreshComposerSubmissionState?.();
+    refreshAdditional();
+  }
+  let committedEnvironment = dom.environmentSelect.value;
+
+  function notifySubscribers() {
+    const ChangeEvent = dom.environmentSelect.ownerDocument?.defaultView?.Event ?? Event;
+    notifying = true;
+    try { dom.environmentSelect.dispatchEvent(new ChangeEvent("change")); }
+    finally { notifying = false; }
+  }
+
+  function hasCurrentEnvironmentSelection(operation, target) {
+    if (operation !== revision) return false;
+    return dom.environmentSelect.value === target;
+  }
+
+  async function changeEnvironment(target, { restoreSession = true, notifyEnvironmentChange = true, commitEnvironmentOptions } = {}) {
+    const operation = ++revision;
+    const previous = committedEnvironment;
+    let committed = false;
+    const restoreSelection = () => {
+      dom.environmentSelect.value = previous;
+      state.agentPickerOpen = false;
+      actions.renderAgentPicker();
+    };
+    changing = true;
+    state.environmentChangePending = true;
+    try {
+      // Consumers read the selector, so expose only the committed environment.
+      dom.environmentSelect.value = previous;
+      refreshSubmissionState();
+      if (target === previous) { restoreSelection(); return true; }
+      let preparedAdditional = prepareAdditional();
+      if (isPendingPreparation(preparedAdditional)) {
+        preparedAdditional = await preparedAdditional;
+      }
+      if (!hasCurrentEnvironmentSelection(operation, previous)) return false;
+      if (environmentChangeWasDeclined(preparedAdditional)) { restoreSelection(); return false; }
+      let preparedQueue = prepareQueueRecovery();
+      if (isPendingPreparation(preparedQueue)) {
+        preparedQueue = await preparedQueue;
+      }
+      if (!hasCurrentEnvironmentSelection(operation, previous)) return false;
+      if (environmentChangeWasDeclined(preparedQueue)) { restoreSelection(); return false; }
+      if (!canCommitEnvironmentPreparations([preparedAdditional, preparedQueue, commitEnvironmentOptions])) { restoreSelection(); return false; }
+      const preparedConfig = actions.beforeEnvironmentChange
+        ? actions.beforeEnvironmentChange({ from: previous, to: target }) : true;
+      if (environmentChangeWasDeclined(preparedConfig)) { restoreSelection(); return false; }
+      if (!hasCurrentEnvironmentSelection(operation, previous)) return false;
+      if (!canCommitEnvironmentPreparations([preparedAdditional, preparedQueue, preparedConfig, commitEnvironmentOptions])) { restoreSelection(); return false; }
+      if (typeof preparedAdditional === "function") preparedAdditional();
+      if (typeof preparedQueue === "function") preparedQueue();
+      if (typeof preparedConfig === "function") preparedConfig();
+      commitEnvironmentOptions?.();
+      actions.invalidateSessionLoads?.();
+      committedEnvironment = target;
+      dom.environmentSelect.value = target;
+      committed = true;
+      state.agentPickerOpen = false;
+      actions.renderAgentPicker();
+      state.environmentChangePending = false;
+      state.currentSessionId = "";
+      state.messages = [];
+      actions.resetLiveRequestView();
+      dom.sessionTitle.textContent = "New conversation";
+      actions.applyConversationChrome();
+      actions.renderMessages();
+      // Persistence errors are visible but never roll back an already committed route.
+      try { void Promise.resolve(actions.saveEnvironmentId(target)).catch(onFailure); }
+      catch (error) { onFailure(error); }
+      const loading = Promise.allSettled([
+        actions.loadModels(), actions.loadAgentMode(),
+        actions.loadRuntimeConfig({ protectUnsaved: false, clearBeforeLoad: true }),
+      ]);
+      if (notifyEnvironmentChange) notifySubscribers();
+      await loading;
+      if (!hasCurrentEnvironmentSelection(operation, target)) return false;
+      if (restoreSession) await actions.restoreLastSession();
+      return hasCurrentEnvironmentSelection(operation, target);
+    } catch (error) {
+      const currentEnvironment = committed ? target : previous;
+      if (!hasCurrentEnvironmentSelection(operation, currentEnvironment)) return false;
+      if (!committed) restoreSelection();
+      onFailure(error);
+      return committed;
+    } finally {
+      if (operation === revision) {
+        changing = false;
+        state.environmentChangePending = false;
+        refreshSubmissionState();
+        onNavigationChange();
+      }
+    }
+  }
+
+  function onSelectChange(event) {
+    if (notifying) return;
+    const target = dom.environmentSelect.value;
+    // The transition emits one event when the environment actually commits.
+    event.stopImmediatePropagation();
+    void changeEnvironment(target);
+  }
+
+  return {
+    changeEnvironment, onSelectChange,
+    initializeEnvironment: () => { committedEnvironment = dom.environmentSelect.value; },
+    setEnvironmentChangePreparation: (prepare, refresh = () => {}) => { prepareAdditional = prepare; refreshAdditional = refresh; },
+    isEnvironmentChanging: () => changing,
+  };
+}
+
+function isPendingPreparation(value) { return typeof value?.then === "function"; }
+export function environmentChangeWasDeclined(value) { return value === false || value === null; }
+
+function canCommitEnvironmentPreparations(preparations) {
+  return preparations.every((prepared) => prepared?.canCommit?.() !== false);
+}

package/dist/src/web-ui/app/controllers/environment-workspace-preparation.js

@@ -0,0 +1,18 @@
+import { environmentChangeWasDeclined } from "./environment-transition.js";
+
+/** Discard configuration and schedule drafts only after both preparations remain current. */
+export function prepareEnvironmentWorkspaceChanges(schedules, configuration) {
+  const schedule = schedules.prepareEnvironmentChange();
+  if (environmentChangeWasDeclined(schedule)) return null;
+  const config = configuration.prepareDiscardChanges("change environment");
+  if (environmentChangeWasDeclined(config)) return null;
+  const commit = () => {
+    if (typeof schedule === "function") schedule();
+    if (typeof config === "function") config();
+  };
+  commit.canCommit = () => {
+    if (schedule?.canCommit?.() === false) return false;
+    return config?.canCommit?.() !== false;
+  };
+  return commit;
+}

package/dist/src/web-ui/app/controllers/home-composer-feature.d.ts

@@ -1,40 +1,18 @@
-import type {
-  ComposerAttachmentsClient,
-  ComposerAttachmentControlEvent,
-  ComposerAttachmentsController,
-  ComposerAttachmentsShell,
-  ComposerUploadFile,
-} from "./composer-attachments-controller.js";
-import type {
-  ComposerSubmissionBlock,
-  ComposerSubmitActions,
-  ComposerSubmitController,
-} from "./composer-submit-controller.js";
-import type {
-  ComposerWorkspaceController,
-  HomeComposerDraft,
-} from "./composer-workspace-controller.js";
+import type { ComposerFeature, ComposerSurface, ComposerSurfaceDom } from "./composer-feature.js";
+import type { ComposerWorkspaceController, ComposerWorkspaceDom } from "./composer-workspace-controller.js";
+import type { ComposerUploadFile } from "./composer-attachments-controller.js";
+import type { ComposerScope } from "./composer-drafts.js";
+import type { ComposerSubmitController } from "./composer-submit-controller.js";
 
-export declare function createHomeComposerFeature(options: {
-  workspace: ComposerWorkspaceController;
-  shell: ComposerAttachmentsShell;
-  client: ComposerAttachmentsClient;
-  composerActions: ComposerSubmitActions;
-  selectedEnvironmentId(): string;
-  selectedModelSupportsImageInput(): boolean;
-  isComposerAvailable?(): boolean;
-  getSubmissionBlock?(): ComposerSubmissionBlock | null;
-  onSubmissionBlocked?(block: ComposerSubmissionBlock): void;
-  onControlEvent(event: ComposerAttachmentControlEvent): void;
-  onStateChange(): void;
-  activateHomeSession(draft: HomeComposerDraft): boolean | void;
-  sendMessage(text: string): Promise<void>;
-}): {
-  attachments: ComposerAttachmentsController;
-  submit: ComposerSubmitController;
+export interface HomeComposerFeature extends ComposerSurface {
   setWorkspace(destination: string): void;
   environmentChanged(): void;
-  dispatch(): void;
+  dispatch(): ReturnType<ComposerSubmitController["dispatch"]>;
   upload(file: ComposerUploadFile): Promise<void>;
-  render(): void;
-};
+}
+export declare function createHomeComposerFeature<T extends ComposerWorkspaceDom & ComposerSurfaceDom>(options: {
+  workspace: ComposerWorkspaceController<T>;
+  composer: Pick<ComposerFeature, "createSurface">;
+  selectedModelSupportsImageInput(): boolean;
+  activateHomeSession(scope: ComposerScope): boolean | Promise<boolean>;
+}): HomeComposerFeature;