@abot-ai/runtime 1.5.0 → 1.7.0

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

@@ -1,5 +1,5 @@
 /** Pairing is shared by this ABot installation, independent of environments. */
-export function createSystemHostRequests({ requestApi, getConfig }) {
+export function createSystemHostRequests({ requestApi, getConfig, getEnvironmentId }) {
   const supportsSystemHostConnection = () => getConfig()?.backend === "runtime";
 
   async function requestSystemHost(path = "", options) {
@@ -13,9 +13,13 @@ export function createSystemHostRequests({ requestApi, getConfig }) {
 
   return {
     supportsSystemHostConnection,
-    getSystemHostConnection: () => requestSystemHost(),
+    getSystemHostConnection: () => requestSystemHost(`?environment=${encodeURIComponent(getEnvironmentId())}`),
+    requestSystemHostPermissions: (input) =>
+      requestSystemHost("/permissions", { method: "POST", body: JSON.stringify(input) }),
     connectLocalSystemHost: () =>
       requestSystemHost("/connect-local", { method: "POST", body: "{}" }),
+    requestSystemHostStoreConnection: () =>
+      requestSystemHost("/store-connect", { method: "POST", body: "{}" }),
     downloadSystemHostSetup: (platform, options = {}) =>
       requestSystemHost("/setup", {
         method: "POST",

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

@@ -1,7 +1,9 @@
 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";
 import type { ToolApprovalRequests } from "./runtime-web-client/tool-approvals.js";
 import type { ConversationFileClient } from "./runtime-web-client/conversation-files.js";
+import type { AutomationRequests } from "./runtime-web-client/automations.js";
 import type { ModelRemovalInput } from "../../local-runtime/model-removal.js";
 import type { ModelSetupInput } from "../../local-runtime/model-setup-input.js";
 import type { SetupEmbeddingInput } from "../../local-runtime/setup-embedding-input.js";
@@ -83,6 +85,11 @@ export declare function createRuntimeWebClient(options: {
   fetchImpl?: typeof fetch;
   origin?: string;
 }): {
+  supportsSparkChat: SparkChatRequests["supportsSparkChat"];
+  loadSparkChat: SparkChatRequests["loadSparkChat"];
+  configureSparkChat: SparkChatRequests["configureSparkChat"];
+  createSparkHandoffSession: SparkChatRequests["createSparkHandoffSession"];
+  markSparkMessagesRead: SparkChatRequests["markSparkMessagesRead"];
   supportsNotifications: NotificationRequests["supportsNotifications"];
   listNotifications: NotificationRequests["listNotifications"];
   markNotificationsRead: NotificationRequests["markNotificationsRead"];
@@ -92,7 +99,9 @@ export declare function createRuntimeWebClient(options: {
   decideToolApproval: ToolApprovalRequests["decideToolApproval"];
   supportsSystemHostConnection(): boolean;
   getSystemHostConnection(): Promise<Record<string, unknown>>;
+  requestSystemHostPermissions(input: Record<string, unknown>): Promise<Record<string, unknown>>;
   connectLocalSystemHost(): Promise<Record<string, unknown>>;
+  requestSystemHostStoreConnection(): Promise<Record<string, unknown>>;
   downloadSystemHostSetup(
     platform: "windows" | "macos" | "linux",
     options?: { purpose?: "learning" },
@@ -120,6 +129,9 @@ export declare function createRuntimeWebClient(options: {
     environmentId?: string,
   ): Promise<Record<string, unknown>>;
   getRuntimePlugins(environmentId?: string): Promise<Record<string, unknown>>;
+  inspectRuntimePlugin(input: Record<string, unknown>, environmentId?: string): Promise<Record<string, unknown>>;
+  installRuntimePlugin(input: Record<string, unknown>, environmentId?: string): Promise<Record<string, unknown>>;
+  removeRuntimePlugin(input: { pluginId: string }, environmentId?: string): Promise<Record<string, unknown>>;
   setRuntimePlugin(
     input: { pluginId: string; capabilityId?: string; enabled: boolean },
     environmentId?: string,
@@ -128,6 +140,22 @@ export declare function createRuntimeWebClient(options: {
     environmentId?: string,
   ): Promise<Record<string, unknown>>;
   supportsSchedules(): boolean;
+  supportsAutomations: AutomationRequests["supportsAutomations"];
+  listAutomations: AutomationRequests["listAutomations"];
+  createAutomation: AutomationRequests["createAutomation"];
+  getAutomationDraft: AutomationRequests["getAutomationDraft"];
+  mutateAutomationDraft: AutomationRequests["mutateAutomationDraft"];
+  deleteAutomationDraft: AutomationRequests["deleteAutomationDraft"];
+  validateAutomation: AutomationRequests["validateAutomation"];
+  publishAutomation: AutomationRequests["publishAutomation"];
+  setAutomationActive: AutomationRequests["setAutomationActive"];
+  setAutomationPermission: AutomationRequests["setAutomationPermission"];
+  getAutomationCatalog: AutomationRequests["getAutomationCatalog"];
+  startAutomationRun: AutomationRequests["startAutomationRun"];
+  listAutomationRuns: AutomationRequests["listAutomationRuns"];
+  getAutomationRun: AutomationRequests["getAutomationRun"];
+  stopAutomationRun: AutomationRequests["stopAutomationRun"];
+  rerunAutomationRun: AutomationRequests["rerunAutomationRun"];
   listSchedules(environmentId?: string): Promise<{ jobs: SchedulerJob[] }>;
   getSchedule(
     jobId: string,
@@ -193,10 +221,11 @@ export declare function createRuntimeWebClient(options: {
     file: Blob;
   }): Promise<Record<string, unknown>>;
   loadWebConfig(): Promise<Record<string, unknown>>;
-  listSessions(environmentId?: string): Promise<Record<string, unknown>>;
+  listSessions(environmentId?: string, page?: Record<string, unknown>): Promise<Record<string, unknown>>;
   loadSession(
     sessionId: string,
     environmentId?: string,
+    page?: Record<string, unknown>,
   ): Promise<Record<string, unknown>>;
   markSessionRead(options: {
     sessionId: string;
@@ -316,10 +345,6 @@ export declare function createRuntimeWebClient(options: {
     environmentId?: string,
     options?: { signal?: AbortSignal },
   ): Promise<{ ok: true; items: Omit<LearningCandidateRecord, "embedding">[] }>;
-  dismissPassiveLearningProposal(
-    id: string,
-    environmentId?: string,
-  ): Promise<{ ok: true }>;
   listPassiveLearningBatches(
     environmentId?: string,
     options?: { signal?: AbortSignal },

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

@@ -1,10 +1,12 @@
 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";
 import { createSystemHostRequests } from "./runtime-web-client/system-host.js";
 import { toolPermissionRequestError } from "../lib/tool-permission-mode.js";
 import { createConversationFileRequests } from "./runtime-web-client/conversation-files.js";
 import { createConfigurationRequests } from "./runtime-web-client/configuration.js";
 import { createScheduleRequests } from "./runtime-web-client/schedules.js";
+import { createAutomationRequests } from "./runtime-web-client/automations.js";
 import { createLongTermMemoryRequests } from "./runtime-web-client/memory.js";
 import { createPassiveLearningRequests } from "./runtime-web-client/learning.js";
 import { createToolApprovalRequests } from "./runtime-web-client/tool-approvals.js";
@@ -166,17 +168,26 @@ export function createRuntimeWebClient({
       return request("/web-config", "Web configuration");
     },
 
-    listSessions(environmentId = getEnvironmentId()) {
+    listSessions(environmentId = getEnvironmentId(), page) {
+      if (page && getConfig()?.backend === "runtime") return requestApi(
+        `/chat/sessions/page?environment=${environmentQuery(environmentId)}`,
+        { method: "POST", body: JSON.stringify(page) },
+      );
       return requestApi(
         `/chat/sessions?environment=${environmentQuery(environmentId)}`,
       );
     },
 
-    loadSession(sessionId, environmentId = getEnvironmentId()) {
+    loadSession(sessionId, environmentId = getEnvironmentId(), page = {}) {
+      const query = new URLSearchParams({ environment: environmentId });
+      if (getConfig()?.backend === "runtime") {
+        query.set("page", "1");
+        for (const [key, value] of Object.entries(page)) if (value != null) query.set(key, String(value));
+      }
       return requestApi(
         `/chat/sessions/${encodeURIComponent(
           sessionId,
-        )}/messages?environment=${environmentQuery(environmentId)}`,
+        )}/messages?${query}`,
       );
     },
 
@@ -355,7 +366,7 @@ export function createRuntimeWebClient({
       getConfig,
     }),
     ...createConfigurationRequests({ requestApi, environmentQuery }),
-    ...createSystemHostRequests({ requestApi, getConfig }),
+    ...createSystemHostRequests({ requestApi, getConfig, getEnvironmentId }),
     ...longTermMemoryRequests,
     ...createPassiveLearningRequests({
       requestApi,
@@ -363,8 +374,10 @@ export function createRuntimeWebClient({
       environmentQuery,
     }),
     ...createScheduleRequests({ requestApi, getEnvironmentId, getConfig }),
+    ...createAutomationRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createProjectRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createToolApprovalRequests({ requestApi, getEnvironmentId, getConfig }),
     ...createNotificationRequests({ requestApi, getEnvironmentId, getConfig }),
+    ...createSparkChatRequests({ requestApi, getEnvironmentId, getConfig }),
   };
 }

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

@@ -0,0 +1,217 @@
+import { createAppState } from "./app-state.js";
+import { createConversationViewFeature } from "./controllers/conversation-view-feature.js";
+import { createConversationSessionController } from "./controllers/conversation-session-controller.js";
+import { createChatRequestController } from "./controllers/chat-request-controller.js";
+import { createComposerQueueController } from "./controllers/composer-queue-controller.js";
+import { createComposerSubmitController } from "./controllers/composer-submit-controller.js";
+import { createComposerAttachmentsController } from "./controllers/composer-attachments-controller.js";
+import { createRealtimeEventController } from "./controllers/realtime-event-controller.js";
+import { createSteerController } from "./controllers/steer-controller.js";
+import { createToolApprovalController } from "./controllers/tool-approval-controller.js";
+import { createToolApprovalCard } from "./components/tool-approval-card.js";
+import { createComposerActions } from "./components/composer-actions.js";
+import { createSessionComposerQueue } from "./lib/session-composer-queue.js";
+import { normalizeRealtimeMessage } from "./lib/realtime-message.js";
+import { createSparkChatResults } from "./components/spark-chat/results.js";
+import { sparkMessageStatus, sparkWorkingStatus } from "./lib/spark-chat-presentation.js";
+import { createSparkChatEmptyState } from "./components/spark-chat/empty-state.js";
+import { createSparkHandoffActions } from "./components/spark-chat/handoff-actions.js";
+import { createSparkMascotActivity } from "./components/spark-chat/mascot-activity.js";
+
+/** Separate view state, ordinary Runtime conversation mechanisms. */
+export function createSparkChatConversation({
+  dom, client, shell, getEnvironmentId, getConfiguration, isOpen, isConnected,
+  getSubmissionBlock, scrollBehavior, refresh, onReadState, onRender,
+  onOpenSchedule = () => {}, onOpenModelSettings = () => {},
+  sendRealtime, onComposerStateChange = () => {}, storage = localStorage,
+  captureHandoffNavigation, onHandoffOpened,
+}) {
+  const state = createAppState();
+  const sessionQueue = createSessionComposerQueue({ storage });
+  const mascotActivity = createSparkMascotActivity({ state, dom, isConnected });
+  let session;
+  let view;
+  let realtime;
+  let queue;
+  let submit;
+  const status = (text, busy = false) => {
+    dom.messagesList.setAttribute("aria-busy", String(busy));
+    dom.messageStatusRegion.textContent = sparkMessageStatus(text);
+  };
+  const render = () => { view?.render(); mascotActivity.render(); onRender?.(); };
+  const renderActivityStatus = () => { view?.renderActivityStatus(); mascotActivity.render(); };
+  const updateSendState = () => { submit?.updateSendState(); mascotActivity.render(); onComposerStateChange(state.composerSending); };
+  const recordControlEvent = (event) => realtime?.recordControlEvent(event);
+  const getToolPermissionMode = () => getConfiguration()?.toolPermissionMode || "ask";
+  const getModelPreference = () => {
+    const profileId = getConfiguration()?.modelProfileId;
+    return profileId ? { profileId } : undefined;
+  };
+  const scope = () => ({ environmentId: getEnvironmentId(), sessionId: state.currentSessionId });
+  const isScopeCurrent = (candidate) => candidate.environmentId === getEnvironmentId() && candidate.sessionId === state.currentSessionId;
+  const steer = createSteerController({
+    sendRealtime,
+    getScope: () => ({ ...scope(), requestId: state.activeRequestId }),
+    getPendingAttachmentCount: () => state.pendingAttachments.length,
+    onAccepted: (message) => session.insertSteerMessage(message),
+  });
+  const actions = createComposerActions({ dom, onSendNext: () => submit.dispatch("send_next") });
+  const attachments = createComposerAttachmentsController({
+    state, dom, shell, client, selectedEnvironmentId: getEnvironmentId,
+    selectedModelSupportsImageInput: () => getConfiguration()?.supportsImageInput === true,
+    ensureSession: () => session.ensureSession(), onSendStateChange: updateSendState,
+    onControlEvent: recordControlEvent,
+    isComposerAvailable: () => !getSubmissionBlock(), isComposerVisible: isOpen,
+  });
+  const approvals = createToolApprovalController({
+    state, selectedEnvironmentId: getEnvironmentId, sendRealtime,
+    renderMessages: render, recordControlEvent, createCard: createToolApprovalCard,
+  });
+  view = createConversationViewFeature({
+    dom, filePreviewClient: client, getFileEnvironmentId: getEnvironmentId,
+    getFileSessionId: () => state.currentSessionId,
+    preserveMessageHistory: true,
+    createActivityView: createSparkChatResults,
+    statusPresentation: sparkWorkingStatus,
+    statusPlacement: "outside",
+    emptyState: createSparkChatEmptyState({ getConfiguration, onOpenModelSettings }),
+    showReasoning: false,
+    showContextWindow: false,
+    getMessages: () => state.messages,
+    getActiveRequestId: () => state.activeRequestId,
+    isConnected,
+    getActivityForMessage: (message) => ({
+      events: state.events,
+      taskProgress: state.taskProgressByRequest.get(message.requestId) || null,
+      contextWindow: state.contextWindowByRequest.get(message.requestId) || null,
+    }),
+    getPendingApproval: approvals.pendingEvent, getPendingApprovals: approvals.pendingEvents,
+    createApprovalCard: approvals.createCard,
+    copyText: (text) => navigator.clipboard.writeText(text),
+    notify: shell.showToast, resolveAttachmentUrl: attachments.previewUrl,
+    onOpenSchedule, canOpenSchedule: () => client.supportsSchedules?.() === true,
+    scrollBehavior,
+    sparkActions: createSparkHandoffActions({
+      getScope: () => ({ ...scope(), viewVersion: state.sessionViewVersion }), getMessages: () => state.messages,
+      client, captureNavigation: captureHandoffNavigation, onOpened: onHandoffOpened,
+      onChange: render, notify: shell.showToast,
+    }),
+  });
+  // The popup never mutates ordinary conversation selection or browser preferences.
+  const sessionClient = {
+    ...client,
+    async listSessions() { void refresh(); return { sessions: [] }; },
+  };
+  session = createConversationSessionController({
+    state, dom: { ...dom, sessionTitle: document.createElement("span") },
+    client: sessionClient,
+    preferences: { saveSessionIdForEnvironment() {}, sessionIdForEnvironment: () => state.currentSessionId },
+    sessions: {
+      byId: () => ({ title: "ABot SPARK" }), titleOf: (value) => value.title,
+      setCurrentTitle() {}, applyTitle() {}, applyReadState: (_id, readState) => onReadState(readState),
+    },
+    sessionQueue, conversationView: view, selectedEnvironmentId: getEnvironmentId,
+    // Reading belongs to actual visible rows in the popup, never to session activation.
+    isConversationVisible: () => false,
+    clearPendingAttachments() {}, applyConversationChrome() {}, applyModelSelection() {}, renderSessions() {},
+    renderMessages: render, updateComposerSendState: updateSendState, setMessageStatus: status,
+    sendRealtime, handleRealtimeMessage: (message) => realtime.handle(message),
+    recordEvent: (message) => realtime.recordEvent(message), recordControlEvent,
+    reportQueueFailure: (...args) => queue.reportFailure(...args),
+    drainQueuedMessage: (...args) => queue.drain(...args),
+    suspendQueueRecovery: () => queue.suspendRecoveryForNavigation(),
+    recoverBlockedQueue: (...args) => queue.recoverForManualSend(...args),
+    isCurrentComposerScope: isScopeCurrent,
+    createSessionId() { throw new Error("SPARK conversation is not ready yet."); },
+  });
+  const requests = createChatRequestController({
+    state, client, sessionQueue, conversationView: view, conversationSession: session,
+    attachments, currentComposerScope: scope, isCurrentComposerScope: isScopeCurrent,
+    rememberModelSelection() {}, applyConversationChrome() {}, renderSessions() {},
+    renderAttachments: attachments.render, getToolPermissionMode, getModelPreference,
+    clearQueueRecovery: (...args) => queue.clearRecovery(...args),
+    reportQueueFailure: (...args) => queue.reportFailure(...args),
+  });
+  queue = createComposerQueueController({
+    state, dom, queue: sessionQueue, selectedEnvironmentId: getEnvironmentId,
+    getToolPermissionMode, getModelPreference, rememberModelSelection() {}, attachments,
+    updateSendState, postChatMessage: requests.postChatMessage,
+    appendLocalUserMessage: session.appendLocalUserMessage,
+    activateRequestForScope: session.activateRequestForScope,
+    renderMessages: render, setMessageStatus: status, recordControlEvent,
+    resizeComposer: () => submit.resize(),
+  });
+  submit = createComposerSubmitController({
+    state, dom, composerActions: actions, attachments, queue, steer: steer.steer,
+    chatRequests: requests, conversationSession: session,
+    selectedEnvironmentId: getEnvironmentId, setMessageStatus: status,
+    getSubmissionBlock, onSubmissionBlocked: (block) => shell.showToast(block.message || "SPARK is not ready.", "failed"),
+    isComposerVisible: isOpen,
+  });
+  realtime = createRealtimeEventController({
+    state, shell, selectedEnvironmentId: getEnvironmentId,
+    handleSteerAcknowledgement: steer.handleAcknowledgement,
+    shouldAcceptMessage: session.shouldAcceptRealtimeMessage,
+    applySessionReadState: session.applySessionReadState,
+    activeAssistantForRequest: session.activeAssistantForRequest,
+    addOrMergeMessage: session.addOrMergeMessage, normalizeChatMessage: session.normalizeMessage,
+    renderMessages: render, renderContextWindow: view.renderContextWindow,
+    renderActivityStatus,
+    scheduleMessageRender: view.scheduleMessageRender, scheduleThinkingRender: view.scheduleThinkingRender,
+    cancelScheduledMessageRender: view.cancelScheduledMessageRender,
+    cancelScheduledThinkingRender: view.cancelScheduledThinkingRender,
+    markCurrentSessionReadSoon: () => scrollBehavior.scheduleRead(),
+    applySessionTitleUpdate() {}, setMessageActivityStatus: status, updateComposerSendState: updateSendState,
+    drainQueuedComposerMessage: queue.drain, loadSessions: refresh,
+  });
+
+  function handleRealtime(raw) {
+    const message = normalizeRealtimeMessage(raw);
+    const environment = message.environmentId || message.environment;
+    if (environment && environment !== getEnvironmentId()) return;
+    if (message.type === "steer_ack") { steer.handleAcknowledgement(message); return; }
+    if (message.sessionId && message.sessionId !== state.currentSessionId) return;
+    if (!state.currentSessionId) return;
+    if (!message.sessionId && message.requestId && !session.requestBelongsToCurrentView(message.requestId)) return;
+    state.connected = isConnected();
+    realtime.handle(message);
+  }
+  function bind() {
+    view.bind(); actions.bind();
+    dom.composerForm.addEventListener("submit", (event) => { event.preventDefault(); submit.dispatch(); });
+    dom.composerInput.addEventListener("input", () => { submit.resize(); updateSendState(); });
+    dom.composerInput.addEventListener("keydown", (event) => {
+      if (event.key !== "Enter" || event.shiftKey || event.isComposing) return;
+      event.preventDefault(); submit.dispatch();
+    });
+    dom.attachmentButton.addEventListener("click", () => dom.attachmentInput.click());
+    dom.attachmentInput.addEventListener("change", () => {
+      const files = [...dom.attachmentInput.files]; dom.attachmentInput.value = "";
+      void Promise.allSettled(files.map((file) => attachments.upload(file))).then((results) => {
+        for (const result of results) if (result.status === "rejected") shell.showToast(result.reason.message, "failed");
+      });
+    });
+    dom.composerInput.addEventListener("paste", (event) => {
+      const files = [...(event.clipboardData?.files || [])];
+      if (!files.length) return;
+      event.preventDefault();
+      for (const file of files) void attachments.upload(file).catch((error) => shell.showToast(error.message, "failed"));
+    });
+  }
+  return {
+    state, session, view, attachments, render, handleRealtime, bind, queue,
+    prepareEnvironmentChange: () => queue.prepareRecoveryForNavigation(),
+    setAgentMode(mode) { state.agentMode = mode; },
+    update() {
+      state.connected = isConnected();
+      attachments.render(); updateSendState(); renderActivityStatus();
+      if (!state.messages.length) render();
+    },
+    reset() {
+      steer.rejectAll("SPARK environment changed.");
+      attachments.clear(); session.invalidateEnvironmentLoads(); session.clearCurrentSessionView();
+      dom.composerInput.value = "";
+    },
+    status,
+  };
+}

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

@@ -0,0 +1,244 @@
+import { createSparkChatPanel } from "./components/spark-chat/panel.js";
+import { isSparkModelUnavailable } from "./components/spark-chat/empty-state.js";
+import { createSparkChatSettings } from "./components/spark-chat/settings.js";
+import { createSparkChatReading } from "./controllers/spark-chat-reading.js";
+import { createSparkChatNotices } from "./controllers/spark-chat-notices.js";
+import { createSparkChatSync } from "./controllers/spark-chat-sync.js";
+import { createSparkChatConversation } from "./spark-chat-conversation.js";
+import { selectLearningView } from "./components/passive-learning/workspace-view.js";
+import { isWorkspaceChange } from "./lib/workspace-change.js";
+import { reconcileSparkReadState } from "./lib/spark-chat-read-state.js";
+import { resolveSparkMessageTarget } from "./lib/spark-chat-address.js";
+
+export function createSparkChatFeature({ dom, state: appState, client, shell, realtime, getEnvironmentId, onOpenSchedule = () => {}, captureHandoffNavigation }) {
+  const panel = createSparkChatPanel({ launcherAnchor: dom.environmentSelect.closest(".rail-runtime") });
+  let configuration;
+  let readState;
+  let environmentId = "";
+  let available = false;
+  let accessRevision = 0;
+  let sync;
+  let settings;
+  let conversation;
+  let awaitingOpening = false;
+  let restoringOpen = false;
+  function isSparkAvailable() {
+    if (client.supportsSparkChat?.() !== true) return false;
+    return shell.isWorkspaceAvailable("learning");
+  }
+  function canCompleteSparkOpening(scope, revision) {
+    if (!isSparkAvailable()) return false;
+    if (scope !== getEnvironmentId()) return false;
+    return revision === accessRevision;
+  }
+  function hasSparkAccessChanged(nextEnvironment, nextAvailable) {
+    if (environmentId !== nextEnvironment) return true;
+    return available !== nextAvailable;
+  }
+  const getSubmissionBlock = () => {
+    if (!configuration?.sessionId) return { message: "SPARK conversation is loading." };
+    if (isSparkModelUnavailable(configuration)) return { message: "Choose a model under Proactive mode in SPARK settings." };
+    if (!sync?.isReady()) return { message: "SPARK is restoring this conversation." };
+    if (appState.runtimeAvailability?.status !== "ready") return { message: "The Runtime is not ready. Check System settings." };
+    return null;
+  };
+  const reading = createSparkChatReading({
+    dom: panel.dom, client, getEnvironmentId, isOpen: panel.isOpen,
+    getMessages: () => conversation?.state.messages || [],
+    onReadState: applyReadState,
+    onError: (error) => {
+      if (["read_generation_changed", "visible_message_receipt_stale"].includes(error.code)) { void sync.refresh(); return; }
+      conversation.status(`Read status unavailable: ${error.message}`);
+    },
+  });
+  const notices = createSparkChatNotices({ showNotice: panel.showNotice, setUnread: panel.setUnread });
+  function applyReadState(next, receipt) {
+    if (!next) return;
+    readState = reconcileSparkReadState(readState, next, receipt);
+    reading.setReadState(readState);
+    if (awaitingOpening && panel.isOpen()) { reading.open(); awaitingOpening = false; }
+    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);
+    panel.setOpen(false, { focus: false });
+  }
+  function openModelSettings() {
+    if (!shell.activateWorkspace("learning")) return;
+    selectLearningView(dom.learningRoot, "settings", true);
+    dom.learningRoot.querySelector('[data-learning-setting="proactiveModelProfileId"]')?.focus();
+    panel.setOpen(false, { focus: false });
+  }
+  conversation = createSparkChatConversation({
+    dom: panel.dom, client, shell, getEnvironmentId,
+    getConfiguration: () => configuration, isOpen: panel.isOpen,
+    isConnected: () => appState.connected,
+    getSubmissionBlock, scrollBehavior: reading,
+    onOpenSchedule, onOpenModelSettings: openModelSettings,
+    captureHandoffNavigation, onHandoffOpened: () => panel.setOpen(false),
+    refresh: () => sync?.refresh(), onReadState: applyReadState,
+    sendRealtime: realtime.send,
+    onComposerStateChange: (sending) => sync?.composerChanged(sending),
+  });
+  sync = createSparkChatSync({
+    client, getEnvironmentId, conversation, isAvailable: isSparkAvailable,
+    onConfiguration: (next) => {
+      const changedModel = configuration?.modelProfileId !== next.modelProfileId;
+      configuration = next; settings?.render(next, getEnvironmentId());
+      if (changedModel) conversation.attachments.removeUnsupportedImages();
+    },
+    onReadState: applyReadState,
+    onSnapshot: (snapshot, _readState, options) => notices.reconcile(snapshot, readState, options),
+    onHistoryReset() {
+      conversation.reset(); reading.reset(); notices.reset(); readState = undefined;
+      panel.hideNotice(); awaitingOpening = panel.isOpen();
+    },
+    onError: (error) => conversation.status(`SPARK unavailable: ${error.message}`),
+  });
+  settings = createSparkChatSettings({
+    root: dom.learningRoot, getWebConfig: () => appState.config,
+    getAgentMode: () => conversation.state.agentMode,
+    onAgentModeChange: (mode) => conversation.setAgentMode(mode),
+    onSave: async (toolPermissionMode) => {
+      const scope = getEnvironmentId();
+      const result = await client.configureSparkChat({ toolPermissionMode }, scope);
+      if (scope !== getEnvironmentId()) return;
+      configuration = { ...configuration, ...result }; settings.render(configuration, scope); conversation.update();
+    },
+    onClear: async () => {
+      if (!configuration?.sessionId) return;
+      const scope = getEnvironmentId();
+      await client.clearSessionMessages(configuration.sessionId, scope);
+      if (scope !== getEnvironmentId()) return;
+      conversation.reset(); reading.reset(); notices.reset(); readState = undefined;
+      sync.reset(); panel.hideNotice();
+      await sync.refresh({ wait: true });
+    },
+    onOpen: () => void open(),
+    onResetPosition: () => panel.resetPosition(),
+    onOpenModelSettings: openModelSettings,
+  });
+  panel.dom.settingsButton.addEventListener("click", openSettings);
+  panel.onToggle((opened) => {
+    if (!opened) { conversation.view.closeFilePreview(); return; }
+    if (!isSparkAvailable()) { panel.setOpen(false, { focus: false }); return; }
+    if (!restoringOpen) void open();
+  });
+
+  async function open(messageId, reference) {
+    if (!isSparkAvailable()) return false;
+    const scope = getEnvironmentId();
+    const revision = accessRevision;
+    try { await sync.refresh({ wait: true }); }
+    catch (error) {
+      if (!canCompleteSparkOpening(scope, revision)) return false;
+      shell.showToast(`SPARK could not be opened: ${error.message}`, "failed");
+      return false;
+    }
+    if (!canCompleteSparkOpening(scope, revision)) return false;
+    if (!configuration) return false;
+    const requestedTarget = messageId ?? readState?.unreadMessageIds?.[0];
+    if (!await ensureSparkTargetHistory(requestedTarget, reference, scope, revision)) return false;
+    if (!canCompleteSparkOpening(scope, revision)) return false;
+    const target = resolveSparkMessageTarget(conversation.state.messages, requestedTarget, reference);
+    reading.open(target); restoringOpen = true; panel.setOpen(true); restoringOpen = false;
+    conversation.render(); conversation.update();
+    return true;
+  }
+  async function ensureSparkTargetHistory(target, reference, scope, revision) {
+    if (target == null) return true;
+    if (reference === null) return true;
+    if (resolveSparkMessageTarget(conversation.state.messages, target, reference)) return true;
+    try {
+      await conversation.session.openSession(configuration.sessionId, { preserveCurrentWindow: true, page: {
+        targetMessageId: String(target), targetCreatedAt: reference?.createdAt,
+        targetRequestId: reference?.requestId ?? undefined,
+      } });
+    } catch (error) {
+      if (!canCompleteSparkOpening(scope, revision)) return false;
+      shell.showToast(`SPARK history unavailable: ${error.message}`, "failed");
+      return false;
+    }
+    return canCompleteSparkOpening(scope, revision);
+  }
+  function shouldRestoreUnavailableSparkFocus(nextAvailable) {
+    if (nextAvailable) return false;
+    const home = dom.homeWorkspaceButton;
+    if (!home) return false;
+    if (home.disabled) return false;
+    if (home.hidden) return false;
+    if (home.inert) return false;
+    if (home.closest?.("[hidden], [inert]")) return false;
+    const focused = document.activeElement;
+    if (!focused) return false;
+    if (panel.root?.contains(focused)) return true;
+    return panel.dom.launcherButton?.contains(focused) === true;
+  }
+  function environmentChanged() {
+    const next = getEnvironmentId();
+    const nextAvailable = isSparkAvailable();
+    if (shouldRestoreUnavailableSparkFocus(nextAvailable)) dom.homeWorkspaceButton.focus({ preventScroll: true });
+    panel.setAvailable(nextAvailable);
+    if (!hasSparkAccessChanged(next, nextAvailable)) return;
+    environmentId = next; available = nextAvailable; accessRevision += 1;
+    configuration = undefined; readState = undefined;
+    awaitingOpening = panel.isOpen();
+    sync.reset(); reading.reset(); notices.reset(); conversation.reset(); panel.hideNotice();
+    settings.render(undefined, next);
+    if (isSparkAvailable()) void sync.refresh({ consolidated: true });
+  }
+  function handleRealtime(message) {
+    environmentChanged();
+    if (!isSparkAvailable()) return;
+    const environment = message.environmentId || message.environment;
+    if (environment && environment !== getEnvironmentId()) return;
+    if (message.type === "learning.changed") { sync.modelChanged(); return; }
+    if (isWorkspaceChange(message)) {
+      const sessionId = message.sessionId || message.change?.sessionId;
+      if (!sessionId || sessionId === configuration?.sessionId) void sync.refresh();
+      return;
+    }
+    if (message.sessionId !== configuration?.sessionId) {
+      if (message.sessionId) return;
+      if (!message.requestId && message.type !== "steer_ack" && message.type !== "tool_approval_ack") return;
+    }
+    const unknownRequest = message.requestId && !conversation.session.requestBelongsToCurrentView(message.requestId);
+    if (unknownRequest && message.sessionId === configuration?.sessionId) { void sync.refresh(); return; }
+    conversation.handleRealtime(message);
+    if (["chat_message", "completed", "failed", "chat_read_state"].includes(message.type)) void sync.refresh();
+  }
+  return {
+    open, environmentChanged,
+    prepareEnvironmentChange: conversation.prepareEnvironmentChange,
+    async openSession(sessionId, messageId, reference) {
+      if (!isSparkAvailable()) return false;
+      if (!sessionId) return false;
+      const scope = getEnvironmentId();
+      const revision = accessRevision;
+      try { if (!configuration) await sync.refresh({ wait: true }); }
+      catch (error) {
+        if (!canCompleteSparkOpening(scope, revision)) return false;
+        shell.showToast(`SPARK could not be opened: ${error.message}`, "failed");
+        return true;
+      }
+      if (!canCompleteSparkOpening(scope, revision)) return true;
+      if (sessionId !== configuration?.sessionId) return false;
+      return open(messageId, reference);
+    },
+    bind() {
+      conversation.bind();
+      realtime.subscribeMessages(handleRealtime);
+      realtime.subscribeConnectionChanged?.(() => conversation.update());
+      realtime.subscribeConnected(() => { environmentChanged(); void sync.refresh({ consolidated: true, rehydrate: true }); });
+      dom.environmentSelect.addEventListener("change", () => queueMicrotask(environmentChanged));
+      shell.subscribeRuntimeAvailabilityChange(environmentChanged);
+      shell.subscribeWorkspaceChange(() => { environmentChanged(); if (panel.isOpen()) reading.scheduleRead(); });
+      document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "visible") void sync.refresh({ consolidated: true });
+      });
+      window.addEventListener("focus", () => { conversation.update(); reading.scheduleRead(); });
+    },
+  };
+}

package/dist/src/web-ui/app/spark-mascot.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="150 150 954 954" fill="none">
+  <defs>
+    <linearGradient id="mint" x1="380" y1="250" x2="850" y2="980" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#9bf5e2"/><stop offset="1" stop-color="#91efde"/>
+    </linearGradient>
+  </defs>
+  <path d="M509 185C568 185 634 260 694 355C737 423 774 489 816 538C860 589 914 616 957 645C990 667 1009 679 1009 698C1009 725 988 742 953 760C895 789 848 812 806 849C759 890 731 942 702 994C678 1038 655 1069 624 1069C590 1069 565 1033 543 985C516 926 493 887 446 850C401 814 354 790 302 762C268 744 244 725 244 697C244 671 270 649 308 623C365 584 415 549 445 494C475 440 479 391 469 316C464 281 450 244 460 219C469 195 487 185 509 185Z" fill="url(#mint)"/>
+  <circle cx="540.5" cy="622.5" r="44.5" fill="#00242b"/>
+  <circle cx="713" cy="622.5" r="44.5" fill="#00242b"/>
+  <circle cx="541.5" cy="599.5" r="11.5" fill="#a5fae9"/>
+  <circle cx="711.5" cy="599.5" r="11.5" fill="#a5fae9"/>
+</svg>