@abot-ai/runtime 1.8.1 → 2.0.0

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.d.ts

@@ -6,6 +6,14 @@ export type AutomationDraftResponse = Readonly<{
   validation?: Record<string, unknown> | null;
 }>;
 
+export type AutomationRunHistoryQuery = Readonly<{
+  limit?: number;
+  cursor?: string;
+  status?: string;
+  from?: string;
+  to?: string;
+}>;
+
 export type AutomationRequests = Readonly<{
   supportsAutomations(): boolean;
   listAutomations(environmentId?: string): Promise<{ automations: Record<string, unknown>[] }>;
@@ -22,7 +30,7 @@ export type AutomationRequests = Readonly<{
   setAutomationPermission(automationId: string, input: { expectedGrantRevision: number; mode: "full_access" | "full_plus"; operations: OperationRef[] }, environmentId?: string): Promise<Record<string, unknown>>;
   getAutomationCatalog(automationId: string, environmentId?: string): Promise<Record<string, unknown>>;
   startAutomationRun(automationId: string, idempotencyKey: string, environmentId?: string): Promise<Record<string, unknown>>;
-  listAutomationRuns(automationId: string, environmentId?: string): Promise<Record<string, unknown>>;
+  listAutomationRuns(automationId: string, environmentId?: string, query?: AutomationRunHistoryQuery): Promise<Record<string, unknown>>;
   getAutomationRun(runId: string, environmentId?: string): Promise<Record<string, unknown>>;
   getAutomationStepEvidence(runId: string, nodeId: string, environmentId?: string, full?: boolean): Promise<Record<string, unknown>>;
   stopAutomationRun(runId: string, environmentId?: string): Promise<Record<string, unknown>>;

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

@@ -14,6 +14,14 @@ export function createAutomationRequests({ requestApi, getEnvironmentId, getConf
   const post = (url, input) => requestAutomation(url, {
     method: "POST", body: JSON.stringify(input),
   });
+  const historyPath = (automationId, environmentId, query) => {
+    const params = new URLSearchParams();
+    for (const key of ["limit", "cursor", "status", "from", "to"])
+      if (query[key] !== undefined && query[key] !== null && query[key] !== "")
+        params.set(key, String(query[key]));
+    const suffix = params.size ? `&${params}` : "";
+    return `${path(`/${encodeURIComponent(automationId)}/runs`, environmentId)}${suffix}`;
+  };
   return {
     supportsAutomations,
     listAutomations: (environmentId) => requestAutomation(path("", environmentId)),
@@ -52,15 +60,17 @@ 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 }),
-    listAutomationRuns: (automationId, environmentId) =>
-      requestAutomation(path(`/${encodeURIComponent(automationId)}/runs`, environmentId)),
+    listAutomationRuns: (automationId, environmentId, query = {}) =>
+      requestAutomation(historyPath(automationId, environmentId, query)),
     getAutomationRun: (runId, environmentId) => requestAutomation(runPath(runId, environmentId)),
     getAutomationStepEvidence: (runId, nodeId, environmentId, full = false) => requestAutomation(
       `/automation-runs/${encodeURIComponent(runId)}/steps/${encodeURIComponent(nodeId)}?environment=${encodeURIComponent(environmentId || getEnvironmentId())}${full ? "&full=1" : ""}`),

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/skills.js

@@ -0,0 +1,23 @@
+export function createSkillRequests({ requestApi, getEnvironmentId, getConfig }) {
+  const supportsSkills = () => getConfig()?.backend === "runtime";
+  const path = (suffix, environmentId) =>
+    `/runtime/skills${suffix}?environment=${encodeURIComponent(environmentId)}`;
+  function request(suffix, environmentId, options) {
+    if (!supportsSkills()) throw new Error("Skills require the local Runtime backend.");
+    return requestApi(path(suffix, environmentId), options);
+  }
+  const identity = (id) => `/${encodeURIComponent(id)}`;
+  return {
+    supportsSkills,
+    createPersonalSkill: ({ name, description, content }, environmentId = getEnvironmentId()) =>
+      request("", environmentId, { method: "POST", body: JSON.stringify({ name, description, content }) }),
+    listPersonalSkills: (environmentId = getEnvironmentId()) => request("", environmentId),
+    readPersonalSkill: (id, environmentId = getEnvironmentId()) => request(identity(id), environmentId),
+    updatePersonalSkill: (id, content, expectedRevision, environmentId = getEnvironmentId()) =>
+      request(identity(id), environmentId, { method: "PATCH", body: JSON.stringify({ content, expectedRevision }) }),
+    archivePersonalSkill: (id, expectedRevision, environmentId = getEnvironmentId()) =>
+      request(`${identity(id)}/archive`, environmentId, { method: "POST", body: JSON.stringify({ expectedRevision }) }),
+    restorePersonalSkill: (id, expectedRevision, environmentId = getEnvironmentId()) =>
+      request(`${identity(id)}/restore`, environmentId, { method: "POST", body: JSON.stringify({ expectedRevision }) }),
+  };
+}

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

@@ -1,3 +1,4 @@
+import { createSkillRequests } from "./runtime-web-client/skills.js";
 import { createNotificationRequests } from "./runtime-web-client/notifications.js";
 import { createSparkChatRequests } from "./runtime-web-client/spark-chat.js";
 import { createProjectRequests } from "./runtime-web-client/projects.js";
@@ -299,6 +300,7 @@ export function createRuntimeWebClient({
       agentMode,
       toolPermissionMode,
       modelPreference,
+      reasoningPreference,
     }) {
       const permissionError = toolPermissionRequestError(
         toolPermissionMode,
@@ -319,6 +321,7 @@ export function createRuntimeWebClient({
           toolPermissionMode,
           attachments,
           ...(modelPreference ? { modelPreference } : {}),
+          ...(reasoningPreference !== undefined ? { reasoningPreference } : {}),
         }),
       });
       const requestId =
@@ -380,6 +383,7 @@ export function createRuntimeWebClient({
     ...createProjectRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createToolApprovalRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createNotificationRequests({ requestApi, getEnvironmentId, getConfig }),
+    ...createSkillRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createSparkChatRequests({ requestApi, getEnvironmentId, getConfig }),
   };
 }

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

@@ -0,0 +1,35 @@
+import { createSkillsController } from "./controllers/skills-controller.js";
+import { mountSkillsWorkspace, createSkillsWorkspace } from "./components/skills/workspace.js";
+
+export function createSkillsFeature({ dom, client, shell, getEnvironmentId,
+  documentRoot = document, viewport = window }) {
+  mountSkillsWorkspace(dom, documentRoot);
+  let view;
+  const controller = createSkillsController({ client, getEnvironmentId,
+    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;
+    return controller.prepareLeave();
+  });
+  shell.subscribeWorkspaceChange((workspace) => controller.setActive(workspace === "skills"));
+  function bind() {
+    // Bind after the canonical transition: rejected raw changes never clear drafts.
+    dom.environmentSelect.addEventListener("change", () => controller.environmentChanged());
+    viewport.addEventListener("beforeunload", (event) => {
+      if (!controller.isDirty()) return;
+      event.preventDefault();
+      event.returnValue = "";
+    });
+  }
+  function refreshAvailability() {
+    const available = client.supportsSkills();
+    dom.skillsWorkspaceButton.hidden = !available;
+    dom.skillsWorkspaceButton.disabled = !available || dom.skillsWorkspaceButton.dataset.onboardingBlocked === "true";
+    if (!available) controller.setActive(false);
+  }
+  shell.subscribeRuntimeAvailabilityChange(refreshAvailability);
+  return { bind, refreshAvailability, prepareEnvironmentChange: controller.prepareLeave,
+    isWorkspaceAvailable: (destination) => destination !== "skills" || client.supportsSkills() };
+}

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();

package/dist/src/web-ui/app/styles/01-color-palettes.css

@@ -0,0 +1,90 @@
+:root[data-palette="midnight"] {
+  --bg: #090b10;
+  --panel: #10131b;
+  --panel-solid: #10131b;
+  --panel-raised: #202735;
+  --text: #e1e7f1;
+  --text-strong: #f3f6fc;
+  --muted: #a5b1c5;
+  --muted-2: #8e9ab0;
+  --line: #2a3343;
+  --line-strong: #414f65;
+  --accent: #97bdff;
+  --accent-strong: #bed6ff;
+  --green: #8dd5b2;
+  --amber: #e8c386;
+  --danger: #f59aa4;
+  --scrollbar-thumb: rgba(165, 177, 197, .28);
+  --scrollbar-thumb-active: rgba(165, 177, 197, .48);
+}
+
+:root[data-palette="graphite"] {
+  --bg: #101012;
+  --panel: #18181c;
+  --panel-solid: #18181c;
+  --panel-raised: #2a2a32;
+  --text: #e7e5ed;
+  --text-strong: #f6f4fa;
+  --muted: #b4aebf;
+  --muted-2: #9b94a8;
+  --line: #37333f;
+  --line-strong: #51495e;
+  --accent: #c4b5ed;
+  --accent-strong: #ded2ff;
+  --green: #99cbb1;
+  --amber: #dfbe8f;
+  --danger: #ed9ca9;
+  --scrollbar-thumb: rgba(180, 174, 191, .28);
+  --scrollbar-thumb-active: rgba(180, 174, 191, .48);
+}
+
+:root[data-palette="charcoal"] {
+  --bg: #0d0d0d;
+  --panel: #151515;
+  --panel-solid: #151515;
+  --panel-raised: #252525;
+  --text: #dedede;
+  --text-strong: #f2f2f2;
+  --muted: #a7a7a7;
+  --muted-2: #909090;
+  --line: #2d2d2d;
+  --line-strong: #454545;
+  --accent: #c7c7c7;
+  --accent-strong: #e5e5e5;
+  --scrollbar-thumb: rgba(167, 167, 167, .28);
+  --scrollbar-thumb-active: rgba(167, 167, 167, .48);
+}
+
+:root[data-palette="onyx"] {
+  --bg: #070707;
+  --panel: #101010;
+  --panel-solid: #101010;
+  --panel-raised: #242424;
+  --text: #e5e5e5;
+  --text-strong: #ffffff;
+  --muted: #ababab;
+  --muted-2: #919191;
+  --line: #292929;
+  --line-strong: #444444;
+  --accent: #d4d4d4;
+  --accent-strong: #ffffff;
+  --scrollbar-thumb: rgba(170, 170, 170, .28);
+  --scrollbar-thumb-active: rgba(170, 170, 170, .48);
+}
+
+:root[data-palette="sand"] {
+  --bg: #080b0e;
+  --panel: #101519;
+  --panel-solid: #101519;
+  --panel-raised: #20282e;
+  --text: #dce2e6;
+  --text-strong: #f3f6f8;
+  --muted: #a3aeb7;
+  --muted-2: #8c99a3;
+  --line: #283139;
+  --line-strong: #414e58;
+  --accent: #b5c6d2;
+  --accent-strong: #d7e3eb;
+  --scrollbar-thumb: rgba(163, 174, 183, .28);
+  --scrollbar-thumb-active: rgba(163, 174, 183, .48);
+}

package/dist/src/web-ui/app/styles/11-product-links.css

@@ -24,7 +24,11 @@
 
 @media (min-width: 761px) {
   .workspace-brand {
-    flex-direction: column;
-    gap: 1px;
+    flex-direction: row;
+    gap: 7px;
+  }
+  .workspace-brand .product-site-link {
+    font-size: 10px;
+    line-height: 14px;
   }
 }