@abot-ai/runtime 1.6.0 → 1.8.0

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/history-pagination.js

@@ -0,0 +1,111 @@
+import { mergeHistoryPage } from "../lib/history-page-messages.js";
+
+export function canRestoreSnapshotQueue(snapshot, waitingRequestId) {
+  if (!snapshot) return false;
+  if (!waitingRequestId) return true;
+  return (snapshot.requests || []).some((request) => request.requestId === waitingRequestId);
+}
+
+export function createHistoryPagination({ state, dom, client, selectedEnvironmentId, normalizeMessage, onRequests, renderMessages, conversationView, applyReadState, loadLatest, onNewerPage = () => {} }) {
+  let revision = 0;
+  let pending = false;
+  let older = null;
+  let newer = null;
+  let error = "";
+  let scrollRequested = false;
+  let windowEnd;
+  const requestIds = new Set();
+  function reset() {
+    revision += 1; pending = false; older = null; newer = null; error = ""; requestIds.clear();
+    scrollRequested = false;
+    windowEnd = undefined;
+  }
+  function adopt(snapshot) {
+    scrollRequested = false;
+    older = snapshot.nextCursor || null; newer = snapshot.newerCursor || null;
+    windowEnd = snapshot.messages?.length ? normalizeMessage(snapshot.messages.at(-1)) : undefined;
+    for (const request of snapshot.requests || []) requestIds.add(request.requestId);
+  }
+  function refresh(snapshot) {
+    if (newer) return;
+    const first = snapshot.messages?.[0];
+    if (!first) { adopt(snapshot); return; }
+    const overlaps = state.messages.some((message) => String(message.persistedMessageId ?? message.id) === String(first.id) && message.createdAt === first.createdAt);
+    if (!overlaps) { reset(); adopt(snapshot); }
+  }
+  function isCurrent(environmentId, sessionId, version, viewVersion) {
+    if (version !== revision || viewVersion !== state.sessionViewVersion) return false;
+    if (environmentId !== selectedEnvironmentId()) return false;
+    return sessionId === state.currentSessionId;
+  }
+  async function load(direction = "older") {
+    const cursor = direction === "older" ? older : newer;
+    if (pending || !cursor) return;
+    scrollRequested = false;
+    const environmentId = selectedEnvironmentId();
+    const sessionId = state.currentSessionId;
+    const version = revision;
+    const viewVersion = state.sessionViewVersion;
+    pending = true; error = "";
+    if (conversationView.preserveScroll) conversationView.preserveScroll(renderMessages);
+    else renderMessages();
+    try {
+      const snapshot = await client.loadSession(sessionId, environmentId, { cursor });
+      if (!isCurrent(environmentId, sessionId, version, viewVersion)) return;
+      const incoming = (snapshot.messages || []).map(normalizeMessage);
+      const requests = (snapshot.requests || []).filter((request) => !requestIds.has(request.requestId));
+      for (const request of requests) requestIds.add(request.requestId);
+      const merge = () => {
+        mergeHistoryPage(state, incoming, direction, windowEnd);
+        if (direction === "newer" && incoming.length) windowEnd = incoming.at(-1);
+        if (direction === "older") older = snapshot.nextCursor || null;
+        else newer = snapshot.newerCursor || null;
+        onRequests(requests);
+        applyReadState(sessionId, snapshot.readState);
+        pending = false;
+        renderMessages();
+      };
+      if (conversationView.preserveScroll) conversationView.preserveScroll(merge);
+      else merge();
+      if (direction === "newer" && incoming.length) onNewerPage(incoming);
+    } catch (failure) {
+      if (!isCurrent(environmentId, sessionId, version, viewVersion)) return;
+      error = failure.code === "history_cursor_stale" ? "History changed. Reopen this conversation." : "Could not load history. Retry.";
+      if (failure.code === "history_cursor_stale") { older = null; newer = null; }
+    } finally {
+      if (isCurrent(environmentId, sessionId, version, viewVersion)) { pending = false; renderMessages(); }
+    }
+  }
+  function renderControls(root) {
+    if (!root?.ownerDocument) return;
+    for (const [direction, cursor, label] of [["older", older, "Load older messages"], ["newer", newer, "Load newer messages"]]) {
+      if (!cursor) continue;
+      const button = root.ownerDocument.createElement("button");
+      button.type = "button"; button.className = "history-page-button";
+      button.disabled = pending;
+      button.textContent = pending ? "Loading…" : error || label;
+      button.addEventListener("click", () => void load(direction));
+      if (direction === "older") root.prepend(button);
+      else root.append(button);
+    }
+    if (error && !older && !newer) {
+      const note = root.ownerDocument.createElement("p"); note.textContent = error; root.prepend(note);
+    }
+  }
+  // Rendering and target positioning also emit scroll events; only user input can request another page.
+  for (const name of ["wheel", "touchmove", "pointerdown"]) {
+    dom.messagesList?.addEventListener?.(name, () => { scrollRequested = true; }, { passive: true });
+  }
+  dom.messagesList?.addEventListener?.("keydown", (event) => {
+    if (["ArrowUp", "ArrowDown", "PageUp", "PageDown", "Home", "End", " "].includes(event.key)) scrollRequested = true;
+  });
+  dom.messagesList?.addEventListener?.("scroll", () => {
+    if (error || pending || !scrollRequested) return;
+    const root = dom.messagesList;
+    if (root.scrollTop < 60 && older) { scrollRequested = false; void load("older"); return; }
+    if (root.scrollHeight - root.scrollTop - root.clientHeight < 60 && newer) { scrollRequested = false; void load("newer"); }
+  }, { passive: true });
+  const controller = { reset, adopt, refresh, load, renderControls, latest: loadLatest, hasNewer: () => Boolean(newer) };
+  conversationView.setHistoryPager?.(controller);
+  return controller;
+}

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;

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

@@ -1,119 +1,22 @@
-import { createComposerAttachmentsController } from "./composer-attachments-controller.js";
-import { createComposerSubmitController } from "./composer-submit-controller.js";
-
-export function createHomeComposerFeature({
-  workspace,
-  shell,
-  client,
-  composerActions,
-  selectedEnvironmentId,
-  selectedModelSupportsImageInput,
-  isComposerAvailable,
-  getSubmissionBlock,
-  onSubmissionBlocked,
-  onControlEvent,
-  onStateChange,
-  activateHomeSession,
-  sendMessage,
-}) {
-  const attachments = createComposerAttachmentsController({
-    state: workspace.homeState,
-    dom: workspace.homeDom,
-    shell,
-    client,
-    selectedEnvironmentId,
-    selectedModelSupportsImageInput,
-    ensureSession: workspace.ensureHomeSession,
-    isComposerAvailable,
-    isComposerVisible: workspace.isHome,
-    onSendStateChange: onStateChange,
-    onControlEvent,
-  });
-
-  async function sendHomeMessage(text) {
-    const draft = workspace.takeHomeDraft(text);
-    let activated = false;
-    try {
-      activated = activateHomeSession(draft) !== false;
-    } catch (error) {
-      workspace.restoreHomeDraft(draft);
-      attachments.render();
-      throw error;
-    }
-    if (!activated) {
-      workspace.restoreHomeDraft(draft);
-      attachments.render();
-      return;
-    }
-    await sendMessage(text);
-  }
-
-  function reportRequestError(error) {
-    onControlEvent({
-      type: "control",
-      name: "Message could not be sent",
-      tone: "failed",
-      summary: error instanceof Error ? error.message : String(error),
-    });
-  }
-
-  const submit = createComposerSubmitController({
-    state: workspace.homeState,
-    dom: workspace.homeDom,
-    composerActions,
-    attachments,
-    queue: {
-      isCurrentDraining: () => false,
-      queuedCount: () => 0,
+/** Home is another surface of the shared composer, with navigation before POST. */
+export function createHomeComposerFeature({ workspace, composer, selectedModelSupportsImageInput, activateHomeSession }) {
+  const surface = composer.createSurface({
+    surfaceDom: workspace.homeDom, currentDraft: workspace.homeView.current,
+    ensureDraftSession: workspace.ensureHomeSession, visible: workspace.isHome,
+    supportsImages: selectedModelSupportsImageInput, allowsActiveRequest: false,
+    async prepareSend(payload) {
+      const activated = await activateHomeSession(payload.scope);
+      if (!activated) return false;
+      workspace.finishHomeActivation(payload.scope);
+      return true;
     },
-    chatRequests: { sendMessage: sendHomeMessage },
-    conversationSession: { appendRequestError: reportRequestError },
-    selectedEnvironmentId,
-    setMessageStatus: () => {},
-    getSubmissionBlock,
-    onSubmissionBlocked,
-    isComposerVisible: workspace.isHome,
   });
-
-  function environmentChanged() {
-    if (workspace.homeState.environmentId === selectedEnvironmentId()) return;
-    attachments.clear();
-    workspace.resetHomeDraft();
-    if (workspace.isHome()) workspace.ensureHomeSession();
-  }
-
-  function render() {
-    workspace.syncChatDraft();
-    environmentChanged();
-    if (!workspace.isHome()) return;
-    attachments.render();
-    submit.resize();
-    submit.updateSendState();
-  }
-
-  function setWorkspace(destination) {
-    environmentChanged();
-    workspace.setWorkspace(destination);
-    render();
-  }
-
-  function dispatch() {
-    environmentChanged();
-    submit.dispatch("send");
-  }
-
-  async function upload(file) {
-    environmentChanged();
-    await attachments.upload(file);
-  }
-
+  function render() { workspace.syncChatDraft(); surface.render(); }
   return {
-    attachments,
-    submit,
-    setWorkspace,
-    environmentChanged,
-    dispatch,
-    upload,
-    render,
+    ...surface, render,
+    setWorkspace(destination) { workspace.setWorkspace(destination); render(); },
+    environmentChanged: render,
+    dispatch: () => surface.submit.dispatch("send"),
+    upload: surface.attachments.upload,
   };
 }

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

@@ -1,3 +1,5 @@
+import { createConversationWorkspaceActivation } from "./conversation-workspace-activation.js";
+
 export function createHomeConversationActivation({
   state,
   shell,
@@ -11,17 +13,13 @@ export function createHomeConversationActivation({
   setCurrentTitle,
   updateComposerSendState,
 }) {
-  return function activateHomeConversation(draft) {
+  const activate = createConversationWorkspaceActivation({ state, shell, composerQueue, selectedEnvironmentId });
+  return async function activateHomeConversation(draft) {
+    if (draft.environmentId !== selectedEnvironmentId()) return false;
+    if (!await activate()) return false;
     if (draft.environmentId !== selectedEnvironmentId()) return false;
-    const activateChat = shell.prepareWorkspaceActivation("chat", {
-      focus: false,
-    });
-    if (!activateChat) return false;
-    if (!composerQueue.suspendRecoveryForNavigation()) return false;
-    if (!activateChat()) return false;
     conversationSession.clearCurrentSessionView();
     state.currentSessionId = draft.sessionId;
-    state.pendingAttachments = draft.attachments;
     preferences.saveSessionIdForEnvironment(
       draft.environmentId,
       draft.sessionId,

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

@@ -3,8 +3,19 @@ export declare function latestHealthEvent(
   details: readonly Record<string, unknown>[],
 ): Record<string, unknown> | undefined;
 
+export interface OperationsSummary {
+  readonly label: string;
+  readonly items: readonly {
+    readonly label: string;
+    readonly value: string;
+    readonly dirty?: boolean;
+    readonly status?: boolean;
+  }[];
+}
+
 export interface OperationsControllerDependencies {
   readonly getEnvironmentId?: () => string | undefined;
+  readonly onSummaryChange?: () => void;
   readonly dom: Readonly<{
     runtimeStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
     runtimeLogs: Pick<HTMLElement, "textContent">;
@@ -20,6 +31,7 @@ export interface OperationsControllerDependencies {
 export declare function createOperationsController(
   options: OperationsControllerDependencies,
 ): {
+  summary(tab: string): OperationsSummary;
   environmentChanged(): void;
   loadRuntimeStatus(): Promise<void>;
   loadRuntimeLogs(): Promise<void>;