@abot-ai/runtime 1.2.0 → 1.3.0

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

@@ -15,6 +15,8 @@ export function createWorkspaceShell({
   viewport = window,
   documentRoot = document,
   beforeWorkspaceChange = () => true,
+  isWorkspaceAvailable = () => true,
+  onWorkspaceChange = () => {},
 }) {
   const shellState = {
     ...createInitialWorkspaceShellState(),
@@ -38,6 +40,7 @@ export function createWorkspaceShell({
   }
 
   function setCurrentPage(button, active) {
+    if (!button) return;
     if (active) {
       button.setAttribute("aria-current", "page");
       return;
@@ -46,12 +49,21 @@ export function createWorkspaceShell({
   }
 
   function syncShell() {
+    const homeWorkspace = shellState.workspace === "home";
     const chatWorkspace = shellState.workspace === "chat";
     const configWorkspace = shellState.workspace === "config";
+    const schedulesWorkspace = shellState.workspace === "schedules";
     const sessions = sidebarLayout();
     const showSessionsToggle = chatWorkspace && !sessions.docked;
 
     dom.app.classList.toggle("config-workspace", configWorkspace);
+    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);
 
@@ -64,6 +76,14 @@ export function createWorkspaceShell({
       configWorkspace ? "false" : "true",
     );
 
+    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(
@@ -82,7 +102,9 @@ export function createWorkspaceShell({
     dom.closeSessionsButton.hidden = sessions.docked;
 
     setCurrentPage(dom.chatWorkspaceButton, chatWorkspace);
+    setCurrentPage(dom.homeWorkspaceButton, homeWorkspace);
     setCurrentPage(dom.configWorkspaceButton, configWorkspace);
+    setCurrentPage(dom.schedulesWorkspaceButton, schedulesWorkspace);
 
     dom.panelBackdrop.classList.toggle("visible", sessions.drawerOpen);
     dom.panelBackdrop.tabIndex = sessions.drawerOpen ? 0 : -1;
@@ -118,8 +140,10 @@ export function createWorkspaceShell({
 
   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) {
@@ -134,6 +158,7 @@ export function createWorkspaceShell({
 
   function prepareWorkspaceTransition(destination) {
     const nextWorkspace = normalizeWorkspaceDestination(destination);
+    if (!isWorkspaceAvailable(nextWorkspace)) return null;
     if (nextWorkspace === shellState.workspace) {
       return { nextWorkspace, commitBeforeChange: () => {} };
     }
@@ -150,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;
@@ -157,12 +183,21 @@ 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(() => {
         if (shellState.workspace !== nextWorkspace) return;
-        dom.closeConfigWorkspaceButton.focus();
+        const closeButton =
+          nextWorkspace === "schedules"
+            ? dom.closeSchedulesWorkspaceButton
+            : dom.closeConfigWorkspaceButton;
+        closeButton?.focus();
       });
       return true;
     }
@@ -198,6 +233,7 @@ export function createWorkspaceShell({
     const useDrawer = open && sidebarViewport?.matches !== true;
     shellState.activeSheet = useDrawer ? "sessions" : "";
     syncShell();
+    onWorkspaceChange("chat");
 
     if (options.focus === false) return true;
     if (open) {
@@ -235,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;
@@ -244,12 +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.configWorkspaceButton.addEventListener("click", () => {
       activateWorkspace("config");
     });
+    dom.schedulesWorkspaceButton?.addEventListener("click", () =>
+      activateWorkspace("schedules"),
+    );
+    dom.closeSchedulesWorkspaceButton?.addEventListener("click", () =>
+      activateWorkspace("chat"),
+    );
     dom.closeConfigWorkspaceButton.addEventListener("click", () => {
       activateWorkspace("chat");
     });
@@ -273,6 +318,7 @@ export function createWorkspaceShell({
   }
 
   return {
+    activeWorkspace: () => shellState.workspace,
     activateOperationsTab: operationsSection.activateTab,
     activateWorkspace,
     bind,

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

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

@@ -0,0 +1,180 @@
+import { createWebSessionId } from "../lib/text-format.js";
+
+export function createComposerWorkspaceController({
+  state,
+  dom,
+  homeComposerHost,
+  homeSetupHost,
+  selectedEnvironmentId,
+  createSessionId = createWebSessionId,
+}) {
+  const surfaces = [{
+    element: dom.composerForm,
+    homeHost: homeComposerHost,
+    chatHost: dom.composerForm.parentElement,
+    nextSibling: dom.composerForm.nextSibling,
+  }];
+  if (homeSetupHost && dom.runtimeSetupGuide) {
+    surfaces.push({
+      element: dom.runtimeSetupGuide,
+      homeHost: homeSetupHost,
+      chatHost: dom.runtimeSetupGuide.parentElement,
+      nextSibling: dom.runtimeSetupGuide.nextSibling,
+    });
+  }
+  const chatDrafts = new Map();
+  const homeState = {
+    currentSessionId: "",
+    activeRequestId: "",
+    pendingAttachments: [],
+    pendingAttachmentUploadCounts: new Map(),
+    composerAttachmentGeneration: 0,
+    composerSending: false,
+    environmentId: selectedEnvironmentId(),
+    text: "",
+  };
+  let workspace = "chat";
+  let displayedSource = "chat";
+  let displayedChatKey = currentChatKey();
+
+  function currentChatKey() {
+    return JSON.stringify([selectedEnvironmentId(), state.currentSessionId]);
+  }
+
+  function saveDisplayedText() {
+    if (displayedSource === "home") {
+      homeState.text = dom.composerInput.value;
+      return;
+    }
+    chatDrafts.set(displayedChatKey, dom.composerInput.value);
+  }
+
+  function isHome() {
+    return workspace === "home";
+  }
+
+  function isChatVisible() {
+    return workspace === "chat";
+  }
+
+  function isCurrentChatInputDisplayed() {
+    if (displayedSource !== "chat") return false;
+    return displayedChatKey === currentChatKey();
+  }
+
+  function createInputSurface(source) {
+    const parkedStyle = { height: "" };
+    const isDisplayed = () =>
+      source === "home"
+        ? displayedSource === "home"
+        : isCurrentChatInputDisplayed();
+    const isVisible = () => source === "home" ? isHome() : isChatVisible();
+    return {
+      get value() {
+        if (isDisplayed()) return dom.composerInput.value;
+        if (source === "home") return homeState.text;
+        return chatDrafts.get(currentChatKey()) || "";
+      },
+      set value(value) {
+        if (source === "home") homeState.text = value;
+        else chatDrafts.set(currentChatKey(), value);
+        if (isDisplayed()) dom.composerInput.value = value;
+      },
+      get style() {
+        return isDisplayed() ? dom.composerInput.style : parkedStyle;
+      },
+      get scrollHeight() {
+        return isDisplayed() ? dom.composerInput.scrollHeight : 0;
+      },
+      focus() {
+        if (!isVisible()) return;
+        if (isDisplayed()) dom.composerInput.focus();
+      },
+    };
+  }
+
+  function ensureHomeSession() {
+    if (!homeState.currentSessionId) {
+      homeState.currentSessionId = createSessionId();
+    }
+    return homeState.currentSessionId;
+  }
+
+  function moveWorkspaceSurface(surface) {
+    if (isHome()) {
+      surface.homeHost.appendChild(surface.element);
+      return;
+    }
+    const nextSibling = surface.nextSibling?.parentElement === surface.chatHost
+      ? surface.nextSibling
+      : null;
+    surface.chatHost.insertBefore(surface.element, nextSibling);
+  }
+
+  function setWorkspace(nextWorkspace) {
+    saveDisplayedText();
+    workspace = nextWorkspace;
+    displayedSource = isHome() ? "home" : "chat";
+    displayedChatKey = currentChatKey();
+    dom.composerInput.value = isHome()
+      ? homeState.text
+      : chatDrafts.get(displayedChatKey) || "";
+    if (isHome()) ensureHomeSession();
+    for (const surface of surfaces) moveWorkspaceSurface(surface);
+  }
+
+  function syncChatDraft() {
+    if (displayedSource !== "chat") return;
+    if (isCurrentChatInputDisplayed()) return;
+    setWorkspace(workspace);
+  }
+
+  function resetHomeDraft() {
+    homeState.currentSessionId = "";
+    homeState.composerSending = false;
+    homeState.pendingAttachments = [];
+    homeState.composerAttachmentGeneration += 1;
+    homeState.pendingAttachmentUploadCounts.clear();
+    homeState.environmentId = selectedEnvironmentId();
+    homeState.text = "";
+    if (displayedSource === "home") dom.composerInput.value = "";
+  }
+
+  function takeHomeDraft(text) {
+    const draft = {
+      sessionId: ensureHomeSession(),
+      environmentId: homeState.environmentId,
+      text,
+      attachments: [...homeState.pendingAttachments],
+    };
+    resetHomeDraft();
+    return draft;
+  }
+
+  function restoreHomeDraft(draft) {
+    homeState.currentSessionId = draft.sessionId;
+    homeState.environmentId = draft.environmentId;
+    homeState.pendingAttachments = draft.attachments;
+    homeState.text = draft.text;
+    if (displayedSource === "home") dom.composerInput.value = draft.text;
+  }
+
+  function composerSessionId() {
+    return isHome() ? ensureHomeSession() : state.currentSessionId;
+  }
+
+  return {
+    chatDom: { ...dom, composerInput: createInputSurface("chat") },
+    homeDom: { ...dom, composerInput: createInputSurface("home") },
+    homeState,
+    setWorkspace,
+    isHome,
+    isChatVisible,
+    composerSessionId,
+    ensureHomeSession,
+    resetHomeDraft,
+    takeHomeDraft,
+    restoreHomeDraft,
+    syncChatDraft,
+  };
+}

package/dist/src/web-ui/app/controllers/conversation-read-state-controller.d.ts

@@ -0,0 +1,23 @@
+import type {
+  ConversationSessionClient,
+  ConversationSessionState,
+} from "./conversation-session-controller.js";
+
+export interface ConversationReadStateControllerOptions {
+  state: Pick<
+    ConversationSessionState,
+    "currentSessionId" | "sessionViewVersion" | "messages"
+  >;
+  client: Pick<ConversationSessionClient, "markSessionRead">;
+  selectedEnvironmentId(): string;
+  applyReadState(sessionId: string, readState: unknown): void;
+  recordControlEvent(event: Record<string, unknown>): void;
+  isConversationVisible?(): boolean;
+  scheduleTask?(callback: () => void): unknown;
+}
+
+export declare function createConversationReadStateController(
+  options: ConversationReadStateControllerOptions,
+): {
+  markCurrentSessionReadSoon(): void;
+};