@abot-ai/runtime 1.9.0 → 2.0.0

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

@@ -6,6 +6,8 @@ import { renderProjectSessionGroups } from "./components/project-session-groups.
 export function createProjectsFeature({
   dom,
   state,
+  preferences,
+  confirmAction,
   client,
   shell,
   selectedEnvironmentId,
@@ -23,6 +25,7 @@ export function createProjectsFeature({
   const expandedProjectSessionIds = new Set();
   const controller = createProjectsController({
     client,
+    confirmAction,
     getEnvironmentId: selectedEnvironmentId,
     isRuntimeReady,
     getConversationRevision: () =>
@@ -76,21 +79,40 @@ export function createProjectsFeature({
 
   function syncProjectGroupEnvironment() {
     const environmentId = selectedEnvironmentId();
-    if (groupEnvironmentId === environmentId) return;
-    groupEnvironmentId = environmentId;
+    if (groupEnvironmentId !== environmentId) {
+      groupEnvironmentId = environmentId;
+      collapsedProjectIds.clear();
+      expandedProjectSessionIds.clear();
+    }
+    const saved = preferences?.loadCollapsedProjectIds?.(environmentId);
+    if (!saved) return;
     collapsedProjectIds.clear();
-    expandedProjectSessionIds.clear();
+    for (const projectId of saved) collapsedProjectIds.add(projectId);
   }
 
-  function rememberProjectGroupCollapse(projectId, collapsed) {
+  async function rememberProjectGroupCollapse(projectId, collapsed) {
     syncProjectGroupEnvironment();
     const isSearchingSessions = Boolean(String(state.sessionQuery ?? "").trim());
     if (isSearchingSessions) return;
-    if (collapsed) {
-      collapsedProjectIds.add(projectId);
-      return;
-    }
     collapsedProjectIds.delete(projectId);
+    if (collapsed) collapsedProjectIds.add(projectId);
+    try {
+      await preferences?.saveCollapsedProjectIds?.(groupEnvironmentId, [...collapsedProjectIds]);
+    } catch {
+      renderSessions();
+      shell.showToast("Could not save project visibility in ABot", "failed");
+    }
+  }
+
+  async function requestProjectDeletion(projectId, projectName) {
+    const environmentId = selectedEnvironmentId();
+    await controller.deleteProject(projectId, projectName);
+    if (selectedEnvironmentId() !== environmentId) return;
+    if (dom.sessionsPanel.hidden) return;
+    const documentRoot = dom.sessionsList.ownerDocument;
+    if (!documentRoot) return;
+    if (documentRoot.activeElement !== documentRoot.body) return;
+    dom.newProjectButton.focus();
   }
 
   function rememberProjectSessionExpansion(projectId, expanded) {
@@ -117,6 +139,7 @@ export function createProjectsFeature({
 
   return {
     load: controller.load,
+    getDeletedProjectIds: controller.getDeletedProjectIds,
     refreshAvailability,
     runtimeAvailabilityChanged() {
       refreshAvailability();
@@ -139,21 +162,28 @@ export function createProjectsFeature({
         root,
         sessions,
         createSessionItem,
+        newProjectButton: dom.newProjectButton,
         ...controller.snapshot(),
+        deletedProjectIds: controller.getDeletedProjectIds(),
         query: state.sessionQuery,
         collapsedProjectIds,
         expandedProjectSessionIds,
         onToggleGroup: rememberProjectGroupCollapse,
         onToggleProjectSessions: rememberProjectSessionExpansion,
         onNewConversation: controller.newConversation,
+        onDeleteProject: requestProjectDeletion,
         onRetry: () => void controller.load(),
       });
       return true;
     },
     bind() {
-      dom.newProjectButton.addEventListener("click", () => {
+      dom.newProjectButton.addEventListener("click", async () => {
         if (!canUseProjects()) return;
-        if (!shell.activateWorkspace("chat", { focus: false })) return;
+        const environmentId = selectedEnvironmentId();
+        const conversationRevision = JSON.stringify([state.currentSessionId, state.sessionViewVersion]);
+        if (!await shell.activateWorkspace("chat", { focus: false })) return;
+        if (environmentId !== selectedEnvironmentId() || !canUseProjects()) return;
+        if (conversationRevision !== JSON.stringify([state.currentSessionId, state.sessionViewVersion])) return;
         shell.setSessionsDrawerOpen(false);
         closeFilePreview();
         controller.openCreate();

package/dist/src/web-ui/app/runtime-onboarding-feature.js

@@ -37,6 +37,7 @@ export function createRuntimeOnboardingFeature({
     return createRuntimeSetupGuide({
       ...common,
       loadSetup: () => runtimeClient.getRuntimeSetup(),
+      inspectConnection: (input) => runtimeClient.inspectModelConnection(input, selectedEnvironmentId()),
       openConfiguration: () => dom.modelsWorkspaceButton?.click(),
       saveSetup: (input) => runtimeClient.saveRuntimeSetup(input),
       applySetup: () =>

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

@@ -19,6 +19,7 @@ export function createSchedulesFeature({
   let view;
   let active = false;
   let navigationRevision = 0;
+  let navigationRequest = 0;
   let runtimeReady = isRuntimeReady();
   const controller = createSchedulesController({
     client,
@@ -56,6 +57,7 @@ export function createSchedulesFeature({
     root: dom.schedulesRoot,
     actions: controller,
     getCurrentSessionId,
+    getEnvironmentId: selectedEnvironmentId,
     getAgentModes,
   });
   view.render(controller.snapshot());
@@ -78,7 +80,7 @@ export function createSchedulesFeature({
       if (destination !== "schedules") return true;
       return client.supportsSchedules();
     },
-    prepareLeave: view.prepareLeave,
+    prepareLeave: view.prepareEnvironmentChange,
     prepareEnvironmentChange: view.prepareEnvironmentChange,
     navigationRevision: () => navigationRevision,
     selectedJobId: () => controller.snapshot().selectedId,
@@ -88,18 +90,39 @@ export function createSchedulesFeature({
     },
     async openJob(jobId) {
       if (!client.supportsSchedules()) return false;
-      if (!view.prepareLeave()) return false;
-      if (!shell.activateWorkspace("schedules")) return false;
+      if (!await commitScheduleNavigation()) return false;
       await controller.openJob(jobId);
       return true;
     },
-    createJob(initialValues) {
+    async createJob(initialValues) {
       if (!client.supportsSchedules()) return;
-      if (!shell.activateWorkspace("schedules")) return;
+      if (!await commitScheduleNavigation()) return;
       void controller.openCreate(initialValues);
     },
   };
 
+  async function commitScheduleNavigation() {
+    const request = ++navigationRequest;
+    const environment = selectedEnvironmentId();
+    const revision = navigationRevision;
+    const workspaceRequest = shell.navigationRequestRevision?.();
+    const preparedDiscard = await view.prepareEnvironmentChange();
+    if (!preparedDiscard) return false;
+    if (!isCurrentScheduleNavigation()) return false;
+    if (workspaceRequest !== shell.navigationRequestRevision?.()) return false;
+    const activate = await shell.prepareWorkspaceActivation("schedules");
+    if (!activate || !isCurrentScheduleNavigation()) return false;
+    if (activate.canCommit?.() === false) return false;
+    if (!preparedDiscard()) return false;
+    return activate();
+    function isCurrentScheduleNavigation() {
+      if (request !== navigationRequest) return false;
+      if (environment !== selectedEnvironmentId()) return false;
+      if (revision !== navigationRevision) return false;
+      return preparedDiscard.canCommit() !== false;
+    }
+  }
+
   function isScheduleSurfaceReady() {
     if (documentRoot?.visibilityState === "hidden") return false;
     return isRuntimeReady();

package/dist/src/web-ui/app/services/client-preferences.d.ts

@@ -1,3 +1,4 @@
+import type { ConversationReasoningPreferences } from "./conversation-reasoning-preferences.js";
 import type { ToolPermissionMode } from "../lib/tool-permission-mode.js";
 
 type PreferenceMap = Record<string, unknown>;
@@ -15,11 +16,13 @@ type PreferenceStorage = {
   snapshot?(): { preferences: Record<string, string> } | null;
 };
 
-export declare function createClientPreferences(storage: PreferenceStorage): {
+export declare function createClientPreferences(storage: PreferenceStorage): ConversationReasoningPreferences & {
   subscribe(listener: () => void): (() => void) | undefined;
   flush(): Promise<void> | undefined;
   loadSessionSidebar(environmentId: string): SessionSidebarPreferences;
   saveSessionSidebar(environmentId: string, value: SessionSidebarPreferences): void | Promise<unknown>;
+  loadCollapsedProjectIds(environmentId: string): string[];
+  saveCollapsedProjectIds(environmentId: string, ids: readonly string[]): void | Promise<unknown>;
   loadPinnedSessions(): string[];
   savePinnedSessions(sessionIds: readonly string[]): void | Promise<unknown>;
   loadSessionModes(normalize: (value: unknown) => ToolPermissionMode): SessionModeMap;

package/dist/src/web-ui/app/services/client-preferences.js

@@ -1,3 +1,4 @@
+import { createConversationReasoningPreferences } from "./conversation-reasoning-preferences.js";
 import { createSessionSidebarPreferences } from "./session-sidebar-preferences.js";
 
 const storageKeys = {
@@ -39,6 +40,7 @@ export function createClientPreferences(storage) {
     subscribe: (listener) => storage.subscribe?.(listener),
     flush: () => storage.flush?.(),
     ...createSessionSidebarPreferences(storage),
+    ...createConversationReasoningPreferences(storage),
     loadPinnedSessions() {
       try {
         const acknowledged = storage.snapshot?.();

package/dist/src/web-ui/app/services/conversation-reasoning-preferences.d.ts

@@ -0,0 +1,11 @@
+import type { ModelReasoningPreference } from "../../../shared/model-reasoning.js";
+export type ReasoningPreferenceScope = { environmentId: string; sessionId?: string };
+export interface ConversationReasoningPreferences {
+  loadReasoningPreference(scope: ReasoningPreferenceScope, profileId: string): ModelReasoningPreference | undefined;
+  saveReasoningPreference(scope: ReasoningPreferenceScope, profileId: string, preference?: ModelReasoningPreference): void | Promise<unknown>;
+}
+export declare const REASONING_PREFERENCES_KEY: string;
+export declare function createConversationReasoningPreferences(storage: {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void | Promise<unknown>;
+}): ConversationReasoningPreferences;

package/dist/src/web-ui/app/services/conversation-reasoning-preferences.js

@@ -0,0 +1,30 @@
+import { isReasoningPreference } from "../lib/reasoning-preference.js";
+
+export const REASONING_PREFERENCES_KEY = "abot-web.reasoningPreferences";
+export function createConversationReasoningPreferences(storage) {
+  const keyFor = (scope, profileId) => JSON.stringify([scope.environmentId, scope.sessionId || "", profileId]);
+  function read() {
+    const raw = storage?.getItem(REASONING_PREFERENCES_KEY);
+    if (!raw) return {};
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid saved thinking preferences.");
+    return value;
+  }
+  return {
+    loadReasoningPreference(scope, profileId) {
+      const value = read()[keyFor(scope, profileId)];
+      if (value === undefined) return undefined;
+      if (!isReasoningPreference(value) || value.profileId !== profileId) throw new Error("Invalid saved thinking preference.");
+      return { ...value };
+    },
+    saveReasoningPreference(scope, profileId, preference) {
+      if (preference !== undefined && (!isReasoningPreference(preference) || preference.profileId !== profileId))
+        throw new Error("Thinking preference must match the selected model.");
+      const values = read();
+      const key = keyFor(scope, profileId);
+      if (preference === undefined) delete values[key];
+      else values[key] = { ...preference };
+      return storage.setItem(REASONING_PREFERENCES_KEY, JSON.stringify(values));
+    },
+  };
+}

package/dist/src/web-ui/app/services/runtime-web-client/automations.js

@@ -60,10 +60,12 @@ export function createAutomationRequests({ requestApi, getEnvironmentId, getConf
         requestAutomation(`${path("/catalog", environmentId)}&automation=${encodeURIComponent(automationId)}`),
         requestAutomation(`/chat/models?environment=${encodeURIComponent(environmentId)}`),
       ]);
-      return { ...catalog, models: (catalog.models || []).map((model) => ({
-        ...model,
-        supportsThinking: modelCatalog.profiles?.find((profile) => profile.id === model.id)?.supportsThinking === true,
-      })) };
+      return { ...catalog, models: (catalog.models || []).map((model) => {
+        const profile = modelCatalog.profiles?.find((item) => item.id === model.id);
+        const { reasoningControls: _authoringControls, ...metadata } = model;
+        return { ...metadata, supportsThinking: profile?.supportsThinking === true,
+          ...(profile?.reasoningControls ? { reasoningControls: profile.reasoningControls } : {}) };
+      }) };
     },
     startAutomationRun: (automationId, idempotencyKey, environmentId) =>
       post(path(`/${encodeURIComponent(automationId)}/run`, environmentId), { idempotencyKey }),

package/dist/src/web-ui/app/services/runtime-web-client/configuration.js

@@ -5,6 +5,11 @@ export function createConfigurationRequests({ requestApi, environmentQuery }) {
     path + "?environment=" + environmentQuery(environmentId);
   return {
     ...createPluginConfigurationRequests({ requestApi, environmentQuery }),
+    inspectModelConnection(input, environmentId) {
+      return requestApi(scoped("/runtime/setup/connection", environmentId), {
+        method: "POST", body: JSON.stringify(input),
+      });
+    },
     getRuntimeSetup(environmentId) {
       return requestApi(scoped("/runtime/setup", environmentId));
     },

package/dist/src/web-ui/app/services/runtime-web-client/memory.js

@@ -41,6 +41,27 @@ export function createLongTermMemoryRequests({
       });
     },
 
+    saveMemoryEmbeddingConnection(input, environmentId = getEnvironmentId()) {
+      return requestApi(
+        `/runtime/memory/connection?environment=${environmentQuery(environmentId)}`,
+        { method: "POST", body: JSON.stringify(input) },
+      );
+    },
+
+    saveMemoryEmbeddingProfile(input, environmentId = getEnvironmentId()) {
+      return requestApi("/runtime/memory/profiles", {
+        method: "POST",
+        body: JSON.stringify({ ...input, environment: environmentId }),
+      });
+    },
+
+    removeMemoryEmbeddingProfile({ profileId }, environmentId = getEnvironmentId()) {
+      return requestApi("/runtime/memory/profiles", {
+        method: "DELETE",
+        body: JSON.stringify({ profileId, environment: environmentId }),
+      });
+    },
+
     disableLongTermMemory(environmentId = getEnvironmentId()) {
       return requestApi("/runtime/memory/disable", {
         method: "POST",

package/dist/src/web-ui/app/services/runtime-web-client/projects.d.ts

@@ -3,9 +3,10 @@ import type { SessionProject } from "../../../../sessions/project-binding.js";
 
 export interface ProjectRequests {
   supportsProjects(): boolean;
-  listProjects(environmentId?: string): Promise<{ projects: readonly RuntimeProject[] }>;
+  listProjects(environmentId?: string): Promise<{ projects: readonly RuntimeProject[]; deletedProjectIds?: readonly string[] }>;
   browseProjectFolders(directory?: string, cursor?: string, environmentId?: string): Promise<ProjectFolderPage>;
   createProject(input: { name: string; directory: string }, environmentId?: string): Promise<{ project: RuntimeProject }>;
+  deleteProject(projectId: string, environmentId?: string): Promise<{ ok: true }>;
   createProjectSession(projectId: string, environmentId?: string): Promise<{
     sessionId: string;
     project: SessionProject;

package/dist/src/web-ui/app/services/runtime-web-client/projects.js

@@ -25,6 +25,10 @@ export function createProjectRequests({
         method: "POST",
         body: JSON.stringify(input),
       }),
+    deleteProject: (projectId, environmentId) =>
+      requestProjects(path("/" + encodeURIComponent(projectId), environmentId), {
+        method: "DELETE", body: "{}",
+      }),
     createProjectSession: (projectId, environmentId) =>
       requestProjects(
         path(`/${encodeURIComponent(projectId)}/sessions`, environmentId),

package/dist/src/web-ui/app/services/runtime-web-client/tool-approvals.js

@@ -41,6 +41,7 @@ export function createToolApprovalRequests({
     requestId,
     approvalId,
     approved,
+    reason,
     generation,
     waitId,
     revision,
@@ -57,6 +58,7 @@ export function createToolApprovalRequests({
           sessionId,
           requestId,
           approved,
+          ...(reason !== undefined ? { reason } : {}),
           ...(waitId ? { generation, waitId, revision, commandId } : {}),
         }),
       },

package/dist/src/web-ui/app/services/runtime-web-client.d.ts

@@ -1,3 +1,4 @@
+import type { MemoryEmbeddingConnectionInput } from "../../local-runtime/memory-embedding-connection-input.js";
 import type { NotificationRequests } from "./runtime-web-client/notifications.js";
 import type { SparkChatRequests } from "./runtime-web-client/spark-chat.js";
 import type { ProjectRequests } from "./runtime-web-client/projects.js";
@@ -114,7 +115,9 @@ export declare function createRuntimeWebClient(options: {
   listProjects: ProjectRequests["listProjects"];
   browseProjectFolders: ProjectRequests["browseProjectFolders"];
   createProject: ProjectRequests["createProject"];
+  deleteProject: ProjectRequests["deleteProject"];
   createProjectSession: ProjectRequests["createProjectSession"];
+  inspectModelConnection(input: Record<string, unknown>, environmentId?: string): Promise<{ connection: { models: readonly string[] } }>;
   getRuntimeSetup(environmentId?: string): Promise<Record<string, unknown>>;
   saveRuntimeSetup(
     input: {
@@ -261,6 +264,7 @@ export declare function createRuntimeWebClient(options: {
     agentMode: string;
     toolPermissionMode: string;
     modelPreference?: Record<string, unknown> | null;
+    reasoningPreference?: import("../../../shared/model-reasoning.js").ModelReasoningPreference;
   }): Promise<string>;
   loadModelSetup(environmentId?: string): Promise<Record<string, unknown>>;
   addRuntimeModel(
@@ -296,6 +300,18 @@ export declare function createRuntimeWebClient(options: {
     profileId?: string;
     emitClientEvents: boolean;
   }): Promise<Record<string, unknown>>;
+  saveMemoryEmbeddingConnection(
+    input: MemoryEmbeddingConnectionInput,
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
+  saveMemoryEmbeddingProfile(
+    input: { providerId: string; model: string; label: string },
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
+  removeMemoryEmbeddingProfile(
+    input: { profileId: string },
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
   disableLongTermMemory(
     environmentId?: string,
   ): Promise<Record<string, unknown>>;

package/dist/src/web-ui/app/services/runtime-web-client.js

@@ -300,6 +300,7 @@ export function createRuntimeWebClient({
       agentMode,
       toolPermissionMode,
       modelPreference,
+      reasoningPreference,
     }) {
       const permissionError = toolPermissionRequestError(
         toolPermissionMode,
@@ -320,6 +321,7 @@ export function createRuntimeWebClient({
           toolPermissionMode,
           attachments,
           ...(modelPreference ? { modelPreference } : {}),
+          ...(reasoningPreference !== undefined ? { reasoningPreference } : {}),
         }),
       });
       const requestId =

package/dist/src/web-ui/app/services/session-sidebar-preferences.js

@@ -1,6 +1,6 @@
 const storageKey = "abot-web.sessionSidebarByEnvironment";
 
-function sessionIds(value) {
+function preferenceIds(value) {
   if (!Array.isArray(value)) return [];
   return [...new Set(value.filter((id) => typeof id === "string" && id))];
 }
@@ -16,27 +16,47 @@ function readEnvironments(storage) {
   }
 }
 
+function saveSidebarPreferenceFields(storage, environmentId, changedFields) {
+  const environments = readEnvironments(storage);
+  const saved = environments[environmentId];
+  const value = {
+    archivedSessionIds: preferenceIds(saved?.archivedSessionIds),
+    orderedSessionIds: preferenceIds(saved?.orderedSessionIds),
+  };
+  if (saved?.collapsedProjectIds !== undefined)
+    value.collapsedProjectIds = preferenceIds(saved.collapsedProjectIds);
+  Object.assign(value, changedFields);
+  Object.defineProperty(environments, environmentId, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  });
+  return storage.setItem(storageKey, JSON.stringify(environments));
+}
+
 export function createSessionSidebarPreferences(storage) {
   return {
     loadSessionSidebar(environmentId) {
       const saved = readEnvironments(storage)[environmentId];
       return {
-        archivedSessionIds: sessionIds(saved?.archivedSessionIds),
-        orderedSessionIds: sessionIds(saved?.orderedSessionIds),
+        archivedSessionIds: preferenceIds(saved?.archivedSessionIds),
+        orderedSessionIds: preferenceIds(saved?.orderedSessionIds),
       };
     },
     saveSessionSidebar(environmentId, value) {
-      const environments = readEnvironments(storage);
-      Object.defineProperty(environments, environmentId, {
-        value: {
-          archivedSessionIds: sessionIds(value.archivedSessionIds),
-          orderedSessionIds: sessionIds(value.orderedSessionIds),
-        },
-        enumerable: true,
-        configurable: true,
-        writable: true,
+      return saveSidebarPreferenceFields(storage, environmentId, {
+        archivedSessionIds: preferenceIds(value.archivedSessionIds),
+        orderedSessionIds: preferenceIds(value.orderedSessionIds),
+      });
+    },
+    loadCollapsedProjectIds(environmentId) {
+      return preferenceIds(readEnvironments(storage)[environmentId]?.collapsedProjectIds);
+    },
+    saveCollapsedProjectIds(environmentId, ids) {
+      return saveSidebarPreferenceFields(storage, environmentId, {
+        collapsedProjectIds: preferenceIds(ids),
       });
-      return storage.setItem(storageKey, JSON.stringify(environments));
     },
   };
 }

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

@@ -6,9 +6,8 @@ export function createSkillsFeature({ dom, client, shell, getEnvironmentId,
   mountSkillsWorkspace(dom, documentRoot);
   let view;
   const controller = createSkillsController({ client, getEnvironmentId,
-    confirmDiscard: (message) => viewport.confirm(message), render: (snapshot) => view?.render(snapshot) });
-  view = createSkillsWorkspace({ root: dom.skillsRoot, actions: controller,
-    confirmArchive: (message) => viewport.confirm(message) });
+    render: (snapshot) => view?.render(snapshot) });
+  view = createSkillsWorkspace({ root: dom.skillsRoot, actions: controller });
   view.render(controller.snapshot());
   shell.addWorkspaceGuard(({ from, to }) => {
     if (from !== "skills" || to === "skills") return true;

package/dist/src/web-ui/app/spark-chat-conversation.js

@@ -1,8 +1,10 @@
+import { canChooseReasoningBudget, isReasoningPreference } from "./lib/reasoning-preference.js";
+import { createConversationReasoningPreferences } from "./services/conversation-reasoning-preferences.js";
 import { canChooseReasoning } from "./lib/reasoning-controls.js";
 import { createComposerFeature } from "./controllers/composer-feature.js";
 import { createComposerDrafts } from "./controllers/composer-drafts.js";
 import { createComposerDraftView } from "./controllers/composer-draft-view.js";
-import { workspaceQueue } from "./services/workspace-state.js";
+import { workspaceQueue, workspaceStorage } from "./services/workspace-state.js";
 import { createAppState } from "./app-state.js";
 import { createConversationViewFeature } from "./controllers/conversation-view-feature.js";
 import { createConversationSessionController } from "./controllers/conversation-session-controller.js";
@@ -27,6 +29,7 @@ export function createSparkChatConversation({
   captureHandoffNavigation, onHandoffOpened,
 }) {
   const state = createAppState();
+  const thinkingPreferences = createConversationReasoningPreferences(workspaceStorage());
   const drafts = createComposerDrafts();
   const draftView = createComposerDraftView({ input: dom.composerInput,
     getDraft: () => drafts.open({ environmentId: getEnvironmentId(), sessionId: state.currentSessionId }), isVisible: isOpen });
@@ -53,6 +56,14 @@ export function createSparkChatConversation({
     return profileId ? { profileId } : undefined;
   };
   const scope = () => ({ environmentId: getEnvironmentId(), sessionId: state.currentSessionId });
+  const reasoningScope = () => ({ environmentId: getEnvironmentId(), sessionId: getConfiguration()?.sessionId || state.currentSessionId });
+  function getReasoningPreference() {
+    const profileId = getConfiguration()?.modelProfileId || "";
+    const preference = thinkingPreferences.loadReasoningPreference(reasoningScope(), profileId);
+    if (preference && !canChooseReasoningBudget(getConfiguration()))
+      throw new Error("SPARK's model no longer supports this thinking override. Choose Profile default.");
+    return preference;
+  }
   const isScopeCurrent = (candidate) => candidate.environmentId === getEnvironmentId() && candidate.sessionId === state.currentSessionId;
   const steer = createSteerController({
     sendRealtime,
@@ -126,7 +137,7 @@ export function createSparkChatConversation({
     state, dom: { ...dom, composerInput: draftView.surface }, shell, client, sessionQueue,
     drafts, getDraft: draftView.current, conversationSession: session, conversationView: view,
     getEnvironmentId, ensureSession: () => session.ensureSession(),
-    getSettings: () => ({ agentMode: state.agentMode, toolPermissionMode: getToolPermissionMode(), modelPreference: getModelPreference() }),
+    getSettings: () => ({ agentMode: state.agentMode, toolPermissionMode: getToolPermissionMode(), modelPreference: getModelPreference(), reasoningPreference: getReasoningPreference() }),
     steer: steer.steer, composerActions: actions,
     selectedModelSupportsImageInput: () => getConfiguration()?.supportsImageInput === true,
     isComposerAvailable: () => !getSubmissionBlock(), getSubmissionBlock,
@@ -189,8 +200,23 @@ export function createSparkChatConversation({
   }
   return {
     state, session, view, attachments, render, handleRealtime, bind, queue,
+    getReasoningPreference: () => thinkingPreferences.loadReasoningPreference(reasoningScope(), getConfiguration()?.modelProfileId || ""),
+    setReasoningPreference(preference) {
+      const profileId = getConfiguration()?.modelProfileId || "";
+      if (preference && (!canChooseReasoningBudget(getConfiguration()) || !isReasoningPreference(preference) || preference.profileId !== profileId))
+        throw new Error("Select a thinking preference supported by SPARK's current model.");
+      return thinkingPreferences.saveReasoningPreference(reasoningScope(), profileId, preference);
+    },
     prepareEnvironmentChange: () => queue.prepareRecoveryForNavigation(),
-    setAgentMode(mode) { if (canChooseReasoning(getConfiguration())) state.agentMode = mode; },
+    async setAgentMode(mode) {
+      if (!canChooseReasoning(getConfiguration())) return;
+      const selectedScope = reasoningScope();
+      const profileId = getConfiguration()?.modelProfileId || "";
+      const preference = thinkingPreferences.loadReasoningPreference(selectedScope, profileId);
+      if (preference?.mode === "off") await thinkingPreferences.saveReasoningPreference(selectedScope, profileId, undefined);
+      if (JSON.stringify(selectedScope) !== JSON.stringify(reasoningScope()) || profileId !== getConfiguration()?.modelProfileId) return;
+      state.agentMode = mode;
+    },
     update() {
       state.connected = isConnected();
       draftView.display(); composer.changed(); updateSendState(); renderActivityStatus();

package/dist/src/web-ui/app/spark-chat-feature.js

@@ -60,16 +60,20 @@ export function createSparkChatFeature({ dom, state: appState, client, shell, re
     if (Number.isFinite(readState.unreadCount)) panel.setUnread(readState.unreadCount);
     if (readState.readStateStatus === "unavailable") conversation.status("Read status is temporarily unavailable.");
   }
-  function openSettings() {
-    if (!shell.activateWorkspace("learning")) return;
-    selectLearningView(dom.learningRoot, "chat", true);
+  async function openLearningSettings(view) {
+    const scope = getEnvironmentId();
+    const revision = accessRevision;
+    const activate = await shell.prepareWorkspaceActivation("learning");
+    if (!activate || !canCompleteSparkOpening(scope, revision)) return false;
+    if (!activate()) return false;
+    selectLearningView(dom.learningRoot, view, true);
     panel.setOpen(false, { focus: false });
+    return true;
   }
-  function openModelSettings() {
-    if (!shell.activateWorkspace("learning")) return;
-    selectLearningView(dom.learningRoot, "settings", true);
+  const openSettings = () => openLearningSettings("chat");
+  async function openModelSettings() {
+    if (!await openLearningSettings("settings")) return;
     dom.learningRoot.querySelector('[data-learning-setting="proactiveModelProfileId"]')?.focus();
-    panel.setOpen(false, { focus: false });
   }
   conversation = createSparkChatConversation({
     dom: panel.dom, client, shell, getEnvironmentId,
@@ -100,6 +104,8 @@ export function createSparkChatFeature({ dom, state: appState, client, shell, re
   settings = createSparkChatSettings({
     root: dom.learningRoot, getWebConfig: () => appState.config,
     getAgentMode: () => conversation.state.agentMode,
+    getReasoningPreference: () => conversation.getReasoningPreference(),
+    onReasoningPreferenceChange: (preference) => conversation.setReasoningPreference(preference),
     onAgentModeChange: (mode) => conversation.setAgentMode(mode),
     onSave: async (toolPermissionMode) => {
       const scope = getEnvironmentId();