@abot-ai/runtime 1.7.0 → 1.8.0

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/passive-learning-controller.js

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

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

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

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

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

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

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

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

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