@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/web-ui/app/components/workspace-shell.js

@@ -2,49 +2,73 @@ import {
   createInitialWorkspaceShellState,
   normalizeWorkspaceDestination,
   toggleWorkspaceSheet,
-  wrappedIndex,
 } from "../ui-behavior.js";
 import { textOf } from "../lib/text-format.js";
+import {
+  CONVERSATION_SIDEBAR_MEDIA_QUERY,
+  resolveConversationSidebarLayout,
+} from "./conversation-sidebar-layout.js";
+import { createOperationsSection } from "./operations-section.js";
 
 export function createWorkspaceShell({
   dom,
   viewport = window,
   documentRoot = document,
   beforeWorkspaceChange = () => true,
+  isWorkspaceAvailable = () => true,
+  onWorkspaceChange = () => {},
 }) {
   const shellState = {
     ...createInitialWorkspaceShellState(),
-    activeOperationsTab: "runtime",
     toastTimer: 0,
     bound: false,
   };
+  const sidebarViewport = viewport.matchMedia?.(
+    CONVERSATION_SIDEBAR_MEDIA_QUERY,
+  );
+  const operationsSection = createOperationsSection({
+    buttons: dom.operationsTabButtons,
+    pages: dom.operationsTabPages,
+  });
+
+  function sidebarLayout() {
+    return resolveConversationSidebarLayout(
+      shellState.workspace,
+      shellState.activeSheet,
+      sidebarViewport?.matches === true,
+    );
+  }
 
   function setCurrentPage(button, active) {
+    if (!button) return;
     if (active) {
       button.setAttribute("aria-current", "page");
-    } else {
-      button.removeAttribute("aria-current");
+      return;
     }
+    button.removeAttribute("aria-current");
   }
 
   function syncShell() {
+    const homeWorkspace = shellState.workspace === "home";
     const chatWorkspace = shellState.workspace === "chat";
-    const operationsWorkspace = shellState.workspace === "operations";
     const configWorkspace = shellState.workspace === "config";
-    const sessionsOpen = chatWorkspace && shellState.activeSheet === "sessions";
+    const schedulesWorkspace = shellState.workspace === "schedules";
+    const sessions = sidebarLayout();
+    const showSessionsToggle = chatWorkspace && !sessions.docked;
 
-    dom.app.classList.toggle("operations-workspace", operationsWorkspace);
     dom.app.classList.toggle("config-workspace", configWorkspace);
-    dom.app.classList.toggle("sessions-open", sessionsOpen);
+    dom.app.classList.toggle("home-workspace", homeWorkspace);
+    if (dom.homeWorkspacePanel) {
+      dom.homeWorkspacePanel.hidden = !homeWorkspace;
+      dom.homeWorkspacePanel.inert = !homeWorkspace;
+      dom.homeWorkspacePanel.setAttribute("aria-hidden", String(!homeWorkspace));
+    }
+    dom.app.classList.toggle("schedules-workspace", schedulesWorkspace);
+    dom.app.classList.toggle("sessions-open", sessions.drawerOpen);
+    dom.app.classList.toggle("sessions-docked", sessions.docked);
 
     dom.chatPanel.hidden = !chatWorkspace;
-    dom.chatPanel.inert = !chatWorkspace || sessionsOpen;
-    dom.operationsWorkspacePanel.hidden = !operationsWorkspace;
-    dom.operationsWorkspacePanel.inert = !operationsWorkspace;
-    dom.operationsWorkspacePanel.setAttribute(
-      "aria-hidden",
-      operationsWorkspace ? "false" : "true",
-    );
+    dom.chatPanel.inert = !chatWorkspace || sessions.drawerOpen;
     dom.configWorkspacePanel.hidden = !configWorkspace;
     dom.configWorkspacePanel.inert = !configWorkspace;
     dom.configWorkspacePanel.setAttribute(
@@ -52,41 +76,89 @@ export function createWorkspaceShell({
       configWorkspace ? "false" : "true",
     );
 
-    dom.sessionsPanel.hidden = !sessionsOpen;
-    dom.sessionsPanel.inert = !sessionsOpen;
+    if (dom.schedulesWorkspacePanel) {
+      dom.schedulesWorkspacePanel.hidden = !schedulesWorkspace;
+      dom.schedulesWorkspacePanel.inert = !schedulesWorkspace;
+      dom.schedulesWorkspacePanel.setAttribute(
+        "aria-hidden",
+        String(!schedulesWorkspace),
+      );
+    }
+    dom.sessionsPanel.hidden = !sessions.visible;
+    dom.sessionsPanel.inert = !sessions.visible;
     dom.sessionsPanel.setAttribute(
       "aria-hidden",
-      sessionsOpen ? "false" : "true",
+      sessions.visible ? "false" : "true",
     );
     dom.sessionsToggleButton.setAttribute(
       "aria-expanded",
-      sessionsOpen ? "true" : "false",
+      sessions.visible ? "true" : "false",
     );
     dom.sessionsToggleButton.setAttribute(
       "aria-label",
-      sessionsOpen ? "Close conversations" : "Open conversations",
+      sessions.drawerOpen ? "Close conversations" : "Open conversations",
     );
+    dom.sessionsToggleButton.hidden = !showSessionsToggle;
+    dom.closeSessionsButton.hidden = sessions.docked;
 
     setCurrentPage(dom.chatWorkspaceButton, chatWorkspace);
-    setCurrentPage(dom.operationsWorkspaceButton, operationsWorkspace);
+    setCurrentPage(dom.homeWorkspaceButton, homeWorkspace);
     setCurrentPage(dom.configWorkspaceButton, configWorkspace);
+    setCurrentPage(dom.schedulesWorkspaceButton, schedulesWorkspace);
 
-    dom.panelBackdrop.classList.toggle("visible", sessionsOpen);
-    dom.panelBackdrop.tabIndex = sessionsOpen ? 0 : -1;
+    dom.panelBackdrop.classList.toggle("visible", sessions.drawerOpen);
+    dom.panelBackdrop.tabIndex = sessions.drawerOpen ? 0 : -1;
     dom.panelBackdrop.setAttribute(
       "aria-hidden",
-      sessionsOpen ? "false" : "true",
+      sessions.drawerOpen ? "false" : "true",
     );
   }
 
-  function workspaceBackButton(destination) {
-    return destination === "operations"
-      ? dom.closeOperationsWorkspaceButton
-      : dom.closeConfigWorkspaceButton;
+  function focusVisibleSessionsControl() {
+    const sessions = sidebarLayout();
+    if (!sessions.visible) return;
+    if (sessions.drawerOpen) {
+      dom.closeSessionsButton.focus();
+      return;
+    }
+    const sidebarControl = dom.sessionSearchInput ?? dom.refreshSessionsButton;
+    (sidebarControl ?? dom.chatWorkspaceButton).focus();
+  }
+
+  function sidebarFocusNeedsRestoration(activeElement, sessions) {
+    if (!activeElement) return false;
+    if (activeElement === dom.sessionsToggleButton) {
+      return dom.sessionsToggleButton.hidden;
+    }
+    if (activeElement === dom.closeSessionsButton) {
+      return dom.closeSessionsButton.hidden;
+    }
+    if (activeElement === dom.panelBackdrop) return !sessions.drawerOpen;
+    if (sessions.visible) return false;
+    return Boolean(activeElement.closest?.(".sessions-panel"));
+  }
+
+  function syncSidebarViewport() {
+    const activeElement = documentRoot.activeElement;
+    const wasSessionsDrawerOpen = shellState.activeSheet === "sessions";
+    shellState.activeSheet = "";
+    syncShell();
+    if (wasSessionsDrawerOpen) onWorkspaceChange(shellState.workspace);
+    const sessions = sidebarLayout();
+    if (!sidebarFocusNeedsRestoration(activeElement, sessions)) return;
+    if (sessions.docked) {
+      focusVisibleSessionsControl();
+      return;
+    }
+    const visibleNavigationButton = dom.sessionsToggleButton.hidden
+      ? dom.chatWorkspaceButton
+      : dom.sessionsToggleButton;
+    visibleNavigationButton.focus();
   }
 
   function prepareWorkspaceTransition(destination) {
     const nextWorkspace = normalizeWorkspaceDestination(destination);
+    if (!isWorkspaceAvailable(nextWorkspace)) return null;
     if (nextWorkspace === shellState.workspace) {
       return { nextWorkspace, commitBeforeChange: () => {} };
     }
@@ -103,6 +175,7 @@ export function createWorkspaceShell({
   }
 
   function commitWorkspaceActivation(preparedTransition, options = {}) {
+    if (!isWorkspaceAvailable(preparedTransition.nextWorkspace)) return false;
     preparedTransition.commitBeforeChange();
     const nextWorkspace = preparedTransition.nextWorkspace;
     const previousWorkspace = shellState.workspace;
@@ -110,12 +183,22 @@ export function createWorkspaceShell({
     shellState.workspace = nextWorkspace;
     shellState.activeSheet = "";
     syncShell();
+    onWorkspaceChange(nextWorkspace);
 
     if (options.focus === false) return true;
+    if (nextWorkspace === "home") {
+      dom.composerInput?.focus();
+      return true;
+    }
     if (nextWorkspace !== "chat") {
-      viewport.requestAnimationFrame(() =>
-        workspaceBackButton(nextWorkspace)?.focus(),
-      );
+      viewport.requestAnimationFrame(() => {
+        if (shellState.workspace !== nextWorkspace) return;
+        const closeButton =
+          nextWorkspace === "schedules"
+            ? dom.closeSchedulesWorkspaceButton
+            : dom.closeConfigWorkspaceButton;
+        closeButton?.focus();
+      });
       return true;
     }
     if (previousWorkspace !== "chat" || previousSheet) {
@@ -147,12 +230,14 @@ export function createWorkspaceShell({
     preparedTransition.commitBeforeChange();
     const wasOpen = shellState.activeSheet === "sessions";
     shellState.workspace = "chat";
-    shellState.activeSheet = open ? "sessions" : "";
+    const useDrawer = open && sidebarViewport?.matches !== true;
+    shellState.activeSheet = useDrawer ? "sessions" : "";
     syncShell();
+    onWorkspaceChange("chat");
 
     if (options.focus === false) return true;
     if (open) {
-      viewport.requestAnimationFrame(() => dom.closeSessionsButton?.focus());
+      viewport.requestAnimationFrame(focusVisibleSessionsControl);
       return true;
     }
     if (
@@ -172,26 +257,6 @@ export function createWorkspaceShell({
     });
   }
 
-  function activateOperationsTab(tabName) {
-    const availableTabs = new Set(
-      dom.operationsTabButtons.map((button) => textOf(button.dataset.tab)),
-    );
-    const normalized = textOf(tabName, "runtime") || "runtime";
-    const nextTab = availableTabs.has(normalized) ? normalized : "runtime";
-    shellState.activeOperationsTab = nextTab;
-    for (const button of dom.operationsTabButtons) {
-      const active = button.dataset.tab === nextTab;
-      button.classList.toggle("active", active);
-      button.setAttribute("aria-selected", active ? "true" : "false");
-      button.tabIndex = active ? 0 : -1;
-    }
-    for (const page of dom.operationsTabPages) {
-      const active = page.id === `${nextTab}Tab`;
-      page.classList.toggle("active", active);
-      page.hidden = !active;
-    }
-  }
-
   function showToast(message, tone = "") {
     viewport.clearTimeout(shellState.toastTimer);
     dom.toastRegion.textContent = textOf(message);
@@ -206,7 +271,7 @@ export function createWorkspaceShell({
       setSessionsDrawerOpen(false, { restoreFocus: true });
       return true;
     }
-    if (shellState.workspace !== "chat") {
+    if (["config", "schedules"].includes(shellState.workspace)) {
       return activateWorkspace("chat");
     }
     return false;
@@ -215,18 +280,21 @@ export function createWorkspaceShell({
   function bind() {
     if (shellState.bound) return;
     shellState.bound = true;
+    dom.homeWorkspaceButton?.addEventListener("click", () => {
+      activateWorkspace("home");
+    });
     dom.chatWorkspaceButton.addEventListener("click", () => {
       activateWorkspace("chat");
     });
-    dom.operationsWorkspaceButton.addEventListener("click", () => {
-      activateWorkspace("operations");
-    });
     dom.configWorkspaceButton.addEventListener("click", () => {
       activateWorkspace("config");
     });
-    dom.closeOperationsWorkspaceButton.addEventListener("click", () => {
-      activateWorkspace("chat");
-    });
+    dom.schedulesWorkspaceButton?.addEventListener("click", () =>
+      activateWorkspace("schedules"),
+    );
+    dom.closeSchedulesWorkspaceButton?.addEventListener("click", () =>
+      activateWorkspace("chat"),
+    );
     dom.closeConfigWorkspaceButton.addEventListener("click", () => {
       activateWorkspace("chat");
     });
@@ -239,33 +307,19 @@ export function createWorkspaceShell({
         setSessionsDrawerOpen(false, { restoreFocus: true });
       }
     });
-    for (const button of dom.operationsTabButtons) {
-      button.addEventListener("click", () => {
-        activateOperationsTab(button.dataset.tab);
-      });
-      button.addEventListener("keydown", (event) => {
-        if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
-        event.preventDefault();
-        const currentIndex = dom.operationsTabButtons.indexOf(button);
-        const delta = event.key === "ArrowRight" ? 1 : -1;
-        const next =
-          dom.operationsTabButtons[
-            wrappedIndex(currentIndex, delta, dom.operationsTabButtons.length)
-          ];
-        next?.focus();
-        activateOperationsTab(next?.dataset.tab);
-      });
-    }
+    sidebarViewport?.addEventListener("change", syncSidebarViewport);
+    operationsSection.bind();
   }
 
   function load() {
     Object.assign(shellState, createInitialWorkspaceShellState());
-    activateOperationsTab("runtime");
+    operationsSection.activateTab("runtime");
     syncShell();
   }
 
   return {
-    activateOperationsTab,
+    activeWorkspace: () => shellState.workspace,
+    activateOperationsTab: operationsSection.activateTab,
     activateWorkspace,
     bind,
     closeOverlaysOnEscape,

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

@@ -0,0 +1,72 @@
+import { createConfigWorkspace } from "./components/config-workspace.js";
+import { createLongTermMemorySetup } from "./components/long-term-memory-setup.js";
+import { createLongTermMemoryManager } from "./components/long-term-memory/manager.js";
+import { createLongTermMemoryController } from "./controllers/long-term-memory/controller.js";
+
+export function createConfigurationFeature({
+  dom,
+  runtimeClient,
+  selectedEnvironmentId,
+  recordControlEvent,
+}) {
+  let configWorkspace;
+  const longTermMemorySetup = createLongTermMemorySetup({
+    getEnvironmentId: selectedEnvironmentId,
+    loadStatus: (environmentId) =>
+      runtimeClient.loadLongTermMemoryStatus(environmentId),
+    discoverModels: (providerId, environmentId) =>
+      runtimeClient.discoverLongTermMemoryModels({
+        environmentId,
+        providerId,
+      }),
+    enableMemory: (input, environmentId) =>
+      runtimeClient.enableLongTermMemory({
+        environmentId,
+        ...input,
+      }),
+    disableMemory: (environmentId) =>
+      runtimeClient.disableLongTermMemory(environmentId),
+    recordControlEvent,
+    beginRuntimeMutation: () =>
+      configWorkspace?.beginExternalRuntimeMutation() ?? false,
+    refreshRuntimeConfig: () =>
+      configWorkspace?.refreshAfterExternalRuntimeMutation() ??
+      Promise.resolve(false),
+    endRuntimeMutation: () => configWorkspace?.endExternalRuntimeMutation(),
+  });
+
+  let longTermMemoryManager;
+  const longTermMemoryController = createLongTermMemoryController({
+    client: runtimeClient,
+    getEnvironmentId: selectedEnvironmentId,
+    render: (snapshot) => longTermMemoryManager?.render(snapshot),
+  });
+  longTermMemoryManager = createLongTermMemoryManager({
+    actions: longTermMemoryController,
+  });
+
+  configWorkspace = createConfigWorkspace({
+    dom: {
+      refreshConfigButton: dom.refreshConfigButton,
+      configStatus: dom.configStatus,
+      configDashboard: dom.configDashboard,
+    },
+    loadDashboard: () =>
+      runtimeClient.loadConfigDashboard(selectedEnvironmentId()),
+    saveFile: ({ kind, id, config }) =>
+      runtimeClient.saveConfigFile({
+        environmentId: selectedEnvironmentId(),
+        kind,
+        id,
+        config,
+      }),
+    memorySetup: longTermMemorySetup,
+    memoryManagement: {
+      load: () => longTermMemoryController.load(),
+      mount: (root) => longTermMemoryManager.mount(root),
+    },
+    recordControlEvent,
+  });
+
+  return configWorkspace;
+}

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

@@ -72,6 +72,7 @@ export interface ComposerAttachmentsControllerOptions {
   onSendStateChange: () => void;
   onControlEvent: (event: ComposerAttachmentControlEvent) => void;
   isComposerAvailable?: () => boolean;
+  isComposerVisible?: () => boolean;
 }
 
 export interface ComposerAttachmentsController {

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

@@ -15,6 +15,7 @@ export function createComposerAttachmentsController({
   onSendStateChange,
   onControlEvent,
   isComposerAvailable = () => true,
+  isComposerVisible = () => true,
 }) {
   function attachmentSessionId(attachment) {
     const explicitSessionId = textOf(attachment.sessionId).trim();
@@ -108,6 +109,7 @@ export function createComposerAttachmentsController({
   }
 
   function render() {
+    if (!isComposerVisible()) return;
     const available = isComposerAvailable();
     dom.attachmentButton.disabled = !available;
     dom.attachmentButton.title = !available
@@ -164,6 +166,14 @@ export function createComposerAttachmentsController({
     if (options.cleanup !== false) cleanup(attachments);
   }
 
+  function canRetainUploadedAttachment(scope) {
+    if (state.currentSessionId !== scope.sessionId) return false;
+    if (selectedEnvironmentId() !== scope.environmentId) return false;
+    if (state.composerAttachmentGeneration !== scope.generation) return false;
+    if (!scope.imageAttachment) return true;
+    return selectedModelSupportsImageInput();
+  }
+
   async function upload(file) {
     if (!isComposerAvailable()) {
       throw new Error("Configure a provider and model before attaching files.");
@@ -196,12 +206,13 @@ export function createComposerAttachmentsController({
         sessionId: uploadSessionId,
         environment: uploadEnvironmentId,
       };
-      if (
-        state.currentSessionId !== uploadSessionId ||
-        selectedEnvironmentId() !== uploadEnvironmentId ||
-        state.composerAttachmentGeneration !== uploadGeneration ||
-        (imageAttachment && !selectedModelSupportsImageInput())
-      ) {
+      const uploadScope = {
+        sessionId: uploadSessionId,
+        environmentId: uploadEnvironmentId,
+        generation: uploadGeneration,
+        imageAttachment,
+      };
+      if (!canRetainUploadedAttachment(uploadScope)) {
         void deletePending(attachment);
         return;
       }

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

@@ -10,6 +10,7 @@ export interface ComposerSubmitState {
   pendingAttachments: readonly unknown[];
   composerSending: boolean;
   currentSessionId: string;
+  sessionViewVersion?: number;
 }
 
 export interface ComposerSubmitDom {
@@ -64,6 +65,7 @@ export interface ComposerSubmitControllerOptions {
   setMessageStatus: (message: string, busy?: boolean) => void;
   getSubmissionBlock?: () => ComposerSubmissionBlock | null;
   onSubmissionBlocked?: (block: ComposerSubmissionBlock) => void;
+  isComposerVisible?: () => boolean;
 }
 
 export interface ComposerSubmitController {

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

@@ -1,3 +1,4 @@
+import { captureComposerSubmissionScope, isCurrentComposerSubmissionScope } from "../lib/composer-submission-scope.js";
 import { resolveComposerPrimaryAction } from "../ui-behavior.js";
 
 export function createComposerSubmitController({
@@ -13,8 +14,10 @@ export function createComposerSubmitController({
   setMessageStatus,
   getSubmissionBlock = () => null,
   onSubmissionBlocked = () => {},
+  isComposerVisible = () => true,
 }) {
   function resize() {
+    if (!isComposerVisible()) return;
     dom.composerInput.style.height = "auto";
     dom.composerInput.style.height = `${Math.min(
       dom.composerInput.scrollHeight,
@@ -23,6 +26,7 @@ export function createComposerSubmitController({
   }
 
   function updateSendState() {
+    if (!isComposerVisible()) return;
     const queueDraining = queue.isCurrentDraining();
     const submissionBlock = getSubmissionBlock();
     composerActions.render({
@@ -40,6 +44,7 @@ export function createComposerSubmitController({
   }
 
   function dispatch(requestedAction = "") {
+    if (!isComposerVisible()) return;
     const text = dom.composerInput.value.trim();
     const submissionBlock = getSubmissionBlock();
     if (text && submissionBlock) {
@@ -84,8 +89,15 @@ export function createComposerSubmitController({
         : action === "send_next"
           ? queue.enqueue(text)
           : chatRequests.sendMessage(text);
+    const completionScope = captureComposerSubmissionScope(
+      state, selectedEnvironmentId(),
+    );
+    const isSubmissionForCurrentComposerView = () => isCurrentComposerSubmissionScope(
+      completionScope, state, selectedEnvironmentId(),
+    );
     void operation
       .then(() => {
+        if (!isSubmissionForCurrentComposerView()) return;
         if (action === "steer") {
           setMessageStatus("Update accepted. ABot is working.", true);
         } else if (action === "send_next") {
@@ -93,14 +105,16 @@ export function createComposerSubmitController({
         }
       })
       .catch((error) => {
+        if (!isSubmissionForCurrentComposerView()) return;
         if (action !== "send") queue.restoreText(text, submissionScope);
         conversationSession.appendRequestError(error);
         setMessageStatus("ABot request failed.");
       })
       .finally(() => {
+        if (!isSubmissionForCurrentComposerView()) return;
         state.composerSending = false;
         updateSendState();
-        dom.composerInput.focus();
+        if (isComposerVisible()) dom.composerInput.focus();
       });
   }
 

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

@@ -0,0 +1,58 @@
+export function createComposerSurfaceController({
+  workspace,
+  getHomeComposer,
+  getChatAttachments,
+  getChatSubmit,
+  rememberModelSelection,
+  showToast,
+}) {
+  function activeSubmit() {
+    return workspace.isHome() ? getHomeComposer()?.submit : getChatSubmit();
+  }
+  function activeAttachments() {
+    return workspace.isHome()
+      ? getHomeComposer()?.attachments
+      : getChatAttachments();
+  }
+  return {
+    renderAttachmentComposer() {
+      if (workspace.isHome()) {
+        getHomeComposer()?.render();
+        return;
+      }
+      getChatAttachments().render();
+    },
+    removeUnsupportedPendingImages() {
+      activeAttachments()?.removeUnsupportedImages();
+    },
+    updateComposerSendState() {
+      workspace.syncChatDraft();
+      activeSubmit()?.updateSendState();
+    },
+    resizeComposerInput() {
+      activeSubmit()?.resize();
+    },
+    async uploadComposerAttachment(file) {
+      if (!workspace.isHome()) {
+        await getChatAttachments().upload(file);
+        return;
+      }
+      try {
+        await getHomeComposer().upload(file);
+      } catch (error) {
+        showToast(
+          error instanceof Error ? error.message : String(error),
+          "failed",
+        );
+      }
+    },
+    dispatchComposerMessage(requestedAction = "") {
+      if (!workspace.isHome()) {
+        getChatSubmit().dispatch(requestedAction);
+        return;
+      }
+      rememberModelSelection();
+      getHomeComposer().dispatch();
+    },
+  };
+}

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

@@ -0,0 +1,53 @@
+import type {
+  ComposerAttachment,
+  ComposerAttachmentsState,
+} from "./composer-attachments-controller.js";
+import type {
+  ComposerSubmitDom,
+  ComposerSubmitState,
+} from "./composer-submit-controller.js";
+
+export interface ComposerWorkspaceDom extends ComposerSubmitDom {
+  composerForm: HTMLElement;
+  runtimeSetupGuide?: HTMLElement;
+  [name: string]: unknown;
+}
+
+export type HomeComposerState = ComposerAttachmentsState &
+  ComposerSubmitState & {
+    environmentId: string;
+    text: string;
+  };
+
+export interface HomeComposerDraft {
+  sessionId: string;
+  environmentId: string;
+  text: string;
+  attachments: ComposerAttachment[];
+}
+
+export interface ComposerWorkspaceController<T extends ComposerWorkspaceDom = ComposerWorkspaceDom> {
+  chatDom: Omit<T, "composerInput"> & ComposerSubmitDom;
+  homeDom: Omit<T, "composerInput"> & ComposerSubmitDom;
+  homeState: HomeComposerState;
+  setWorkspace(workspace: string): void;
+  isHome(): boolean;
+  isChatVisible(): boolean;
+  composerSessionId(): string;
+  ensureHomeSession(): string;
+  resetHomeDraft(): void;
+  takeHomeDraft(text: string): HomeComposerDraft;
+  restoreHomeDraft(draft: HomeComposerDraft): void;
+  syncChatDraft(): void;
+}
+
+export declare function createComposerWorkspaceController<T extends ComposerWorkspaceDom>(
+  options: {
+    state: Pick<ComposerSubmitState, "currentSessionId">;
+    dom: T;
+    homeComposerHost: HTMLElement;
+    homeSetupHost?: HTMLElement;
+    selectedEnvironmentId(): string;
+    createSessionId?(): string;
+  },
+): ComposerWorkspaceController<T>;