@abot-ai/runtime 1.1.0 → 1.3.0

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

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

@@ -0,0 +1,82 @@
+import { textOf } from "../lib/text-format.js";
+
+function latestDisplayedAssistant(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index].role === "assistant") return messages[index];
+  }
+  return null;
+}
+
+function displayedAssistantReadBoundary(messages) {
+  const message = latestDisplayedAssistant(messages);
+  if (!message) return null;
+  if (message.streaming === true) return null;
+  const numericId = Number(textOf(message.id).replace(/^msg-/, ""));
+  const hasPersistedMessageId = Number.isSafeInteger(numericId) && numericId > 0;
+  if (hasPersistedMessageId) return { readThroughMessageId: numericId };
+  const requestId = textOf(message.requestId).trim();
+  if (!requestId) return null;
+  return {
+    readThroughMessageId: null,
+    readThroughRequestId: requestId,
+  };
+}
+
+export function createConversationReadStateController({
+  state,
+  client,
+  selectedEnvironmentId,
+  applyReadState,
+  recordControlEvent,
+  isConversationVisible = () => true,
+  scheduleTask = (callback) => window.setTimeout(callback, 0),
+}) {
+  function isCurrentReadScope(scope) {
+    if (selectedEnvironmentId() !== scope.environmentId) return false;
+    if (state.currentSessionId !== scope.sessionId) return false;
+    return state.sessionViewVersion === scope.viewVersion;
+  }
+
+  function canMarkConversationRead(scope) {
+    if (!scope.sessionId) return false;
+    if (!isConversationVisible()) return false;
+    return isCurrentReadScope(scope);
+  }
+
+  async function markSessionRead(scope, boundary) {
+    try {
+      const result = await client.markSessionRead({
+        sessionId: scope.sessionId,
+        environmentId: scope.environmentId,
+        ...boundary,
+      });
+      if (selectedEnvironmentId() !== scope.environmentId) return;
+      applyReadState(scope.sessionId, result.readState);
+    } catch (error) {
+      if (selectedEnvironmentId() !== scope.environmentId) return;
+      recordControlEvent({
+        type: "control",
+        name: "Read state update failed",
+        tone: "failed",
+        summary: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  function markCurrentSessionReadSoon() {
+    const scope = {
+      environmentId: selectedEnvironmentId(),
+      sessionId: state.currentSessionId,
+      viewVersion: state.sessionViewVersion,
+    };
+    if (!canMarkConversationRead(scope)) return;
+    const boundary = displayedAssistantReadBoundary(state.messages);
+    if (!boundary) return;
+    scheduleTask(() => {
+      if (!canMarkConversationRead(scope)) return;
+      void markSessionRead(scope, boundary);
+    });
+  }
+
+  return { markCurrentSessionReadSoon };
+}

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

@@ -27,6 +27,7 @@ export type ConversationSessionScope = Readonly<{
 export interface ConversationSessionState {
   currentSessionId: string;
   activeRequestId: string;
+  composerSending?: boolean;
   sessionViewVersion: number;
   messages: ConversationSessionMessage[];
   events: Array<Record<string, unknown>>;
@@ -43,6 +44,7 @@ export interface ConversationSessionClient {
     sessionId: string;
     environmentId: string;
     readThroughMessageId: number | null;
+    readThroughRequestId?: string;
   }): Promise<Record<string, unknown>>;
   listSessions(environmentId: string): Promise<Record<string, unknown>>;
   loadSession(
@@ -102,6 +104,12 @@ export interface ConversationSessionControllerOptions {
   suspendQueueRecovery(): boolean;
   recoverBlockedQueue(scope: ConversationSessionScope): unknown;
   isCurrentComposerScope(scope: ConversationSessionScope): boolean;
+  isConversationVisible?(): boolean;
+  onSessionListState?(value: {
+    status: "loading" | "ready" | "error";
+    sessions: ConversationSession[];
+    error?: string;
+  }): void;
   scheduleTask?(callback: () => void): unknown;
   createSessionId?(): string;
 }

package/dist/src/web-ui/app/controllers/conversation-session-controller.js

@@ -1,3 +1,6 @@
+import { mergeSessionListReadState } from "../lib/session-read-state.js";
+import { createConversationReadStateController } from "./conversation-read-state-controller.js";
+import { normalizeScheduleReference } from "../lib/schedule-message.js";
 import { createWebSessionId, escapeHtml, textOf } from "../lib/text-format.js";
 import { insertRequestUserMessageBeforeAssistant } from "../ui-behavior.js";
 import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
@@ -12,6 +15,7 @@ export function normalizeConversationMessage(raw, fallbackIndex = 0) {
     createdAt: message?.createdAt || Date.now(),
     requestId: textOf(message?.requestId),
     streaming: false,
+    schedule: normalizeScheduleReference(message?.schedule),
     events: Array.isArray(message?.events)
       ? message.events.map((event) => textOf(event)).filter(Boolean)
       : [],
@@ -46,6 +50,8 @@ export function createConversationSessionController({
   suspendQueueRecovery,
   recoverBlockedQueue,
   isCurrentComposerScope,
+  isConversationVisible = () => true,
+  onSessionListState = () => {},
   scheduleTask = (callback) => window.setTimeout(callback, 0),
   createSessionId = createWebSessionId,
 }) {
@@ -58,6 +64,7 @@ export function createConversationSessionController({
     sessionListRevision += 1;
     sessionRestoreRevision += 1;
     state.sessions = [];
+    onSessionListState({ status: "loading", sessions: [] });
     renderSessions();
   }
 
@@ -65,44 +72,15 @@ export function createConversationSessionController({
     return normalizeConversationMessage(raw, state.messages.length);
   }
 
-  function latestAssistantMessageId() {
-    let latest = 0;
-    for (const message of state.messages) {
-      if (message.role !== "assistant") continue;
-      const numericId = Number(textOf(message.id).replace(/^msg-/, ""));
-      if (Number.isFinite(numericId)) {
-        latest = Math.max(latest, Math.floor(numericId));
-      }
-    }
-    return latest > 0 ? latest : null;
-  }
-
-  async function markSessionRead(sessionId, readThroughMessageId = null) {
-    if (!sessionId) return;
-    const result = await client.markSessionRead({
-      sessionId,
-      environmentId: selectedEnvironmentId(),
-      readThroughMessageId,
-    });
-    sessions.applyReadState(sessionId, result.readState);
-  }
-
-  function markCurrentSessionReadSoon() {
-    const sessionId = state.currentSessionId;
-    if (!sessionId) return;
-    const readThroughMessageId = latestAssistantMessageId();
-    scheduleTask(() => {
-      if (state.currentSessionId !== sessionId) return;
-      void markSessionRead(sessionId, readThroughMessageId).catch((error) => {
-        recordControlEvent({
-          type: "control",
-          name: "Read state update failed",
-          tone: "failed",
-          summary: error instanceof Error ? error.message : String(error),
-        });
-      });
-    });
-  }
+  const { markCurrentSessionReadSoon } = createConversationReadStateController({
+    state,
+    client,
+    selectedEnvironmentId,
+    applyReadState: sessions.applyReadState,
+    recordControlEvent,
+    isConversationVisible,
+    scheduleTask,
+  });
 
   function addOrMergeMessage(message) {
     const id = textOf(message.id);
@@ -158,6 +136,7 @@ export function createConversationSessionController({
     state.taskProgressByRequest.clear();
     state.contextWindowByRequest.clear();
     state.activeRequestId = "";
+    state.composerSending = false;
     conversationView.reset();
     state.submittedToolApprovalIds.clear();
     state.requestMessages.clear();
@@ -353,6 +332,7 @@ export function createConversationSessionController({
     const environmentRevision = environmentLoadRevision;
     const requestRevision = ++sessionListRevision;
     const environmentId = selectedEnvironmentId();
+    onSessionListState({ status: "loading", sessions: state.sessions });
     try {
       const payload = await client.listSessions(environmentId);
       if (
@@ -362,7 +342,11 @@ export function createConversationSessionController({
       ) {
         return [];
       }
-      state.sessions = Array.isArray(payload.sessions) ? payload.sessions : [];
+      state.sessions = mergeSessionListReadState(
+        Array.isArray(payload.sessions) ? payload.sessions : [],
+        state.sessions,
+      );
+      onSessionListState({ status: "ready", sessions: state.sessions });
       renderSessions();
       return state.sessions;
     } catch (error) {
@@ -373,6 +357,11 @@ export function createConversationSessionController({
       ) {
         return [];
       }
+      onSessionListState({
+        status: "error",
+        sessions: state.sessions,
+        error: error instanceof Error ? error.message : String(error),
+      });
       dom.sessionsList.innerHTML = `<div class="empty-state error-text">${escapeHtml(
         error instanceof Error ? error.message : String(error),
       )}</div>`;

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

@@ -0,0 +1,127 @@
+export function createDashboardController({
+  client,
+  getEnvironmentId,
+  getSessions,
+  loadSessions,
+  render,
+  isVisible = () => document.visibilityState === "visible",
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  const state = {
+    runs: [],
+    loadingActivity: true,
+    activityError: "",
+    loadingSessions: true,
+    sessionsError: "",
+  };
+  let active = false;
+  let ready = false;
+  let environmentId = "";
+  let sessionsEnvironmentId = "";
+  let revision = 0;
+  let timer;
+
+  function snapshot() {
+    const sessions =
+      sessionsEnvironmentId === getEnvironmentId() ? getSessions() : [];
+    return {
+      ...state,
+      sessions,
+      supportsSchedules: client.supportsSchedules(),
+    };
+  }
+  const publish = () => render(snapshot());
+  function hasCurrentActivityRead(readRevision, readEnvironmentId) {
+    if (readRevision !== revision) return false;
+    return readEnvironmentId === getEnvironmentId();
+  }
+  function canRefresh() {
+    if (!ready) return false;
+    if (!active) return false;
+    return isVisible();
+  }
+  function scheduleRefresh() {
+    clearTimer(timer);
+    if (!canRefresh()) return;
+    timer = setTimer(() => void refresh(), 10000);
+  }
+  async function refreshActivity() {
+    const readEnvironmentId = getEnvironmentId();
+    const readRevision = ++revision;
+    const environmentChanged = environmentId !== readEnvironmentId;
+    environmentId = readEnvironmentId;
+    if (environmentChanged) state.runs = [];
+    state.loadingActivity = state.runs.length === 0;
+    state.activityError = "";
+    publish();
+    if (!client.supportsSchedules()) {
+      state.runs = [];
+      state.loadingActivity = false;
+      publish();
+      return;
+    }
+    try {
+      const result = await client.listRecentScheduleRuns(readEnvironmentId, {
+        limit: 8,
+      });
+      if (!hasCurrentActivityRead(readRevision, readEnvironmentId)) return;
+      state.runs = result.runs || [];
+    } catch (error) {
+      if (!hasCurrentActivityRead(readRevision, readEnvironmentId)) return;
+      state.activityError =
+        error instanceof Error ? error.message : String(error);
+    } finally {
+      if (hasCurrentActivityRead(readRevision, readEnvironmentId)) {
+        state.loadingActivity = false;
+        publish();
+      }
+    }
+  }
+  async function refresh() {
+    if (!canRefresh()) return;
+    clearTimer(timer);
+    await Promise.allSettled([loadSessions(), refreshActivity()]);
+    scheduleRefresh();
+  }
+  return {
+    snapshot,
+    publish,
+    refresh,
+    setReady() {
+      ready = true;
+      void refresh();
+    },
+    setActive(value) {
+      const entering = value && !active;
+      active = value;
+      clearTimer(timer);
+      if (entering) void refresh();
+    },
+    sessionsChanged(status = {}) {
+      if (status.environmentId && status.environmentId !== getEnvironmentId())
+        return;
+      if (status.status === "ready") sessionsEnvironmentId = getEnvironmentId();
+      state.loadingSessions = status.status === "loading";
+      state.sessionsError = status.error || "";
+      publish();
+    },
+    environmentChanged() {
+      revision += 1;
+      sessionsEnvironmentId = "";
+      Object.assign(state, {
+        runs: [],
+        activityError: "",
+        sessionsError: "",
+        loadingActivity: true,
+        loadingSessions: true,
+      });
+      publish();
+      void refresh();
+    },
+    visibilityChanged() {
+      clearTimer(timer);
+      if (canRefresh()) void refresh();
+    },
+  };
+}

package/dist/src/web-ui/app/controllers/home-composer-feature.d.ts

@@ -0,0 +1,40 @@
+import type {
+  ComposerAttachmentsClient,
+  ComposerAttachmentControlEvent,
+  ComposerAttachmentsController,
+  ComposerAttachmentsShell,
+  ComposerUploadFile,
+} from "./composer-attachments-controller.js";
+import type {
+  ComposerSubmissionBlock,
+  ComposerSubmitActions,
+  ComposerSubmitController,
+} from "./composer-submit-controller.js";
+import type {
+  ComposerWorkspaceController,
+  HomeComposerDraft,
+} from "./composer-workspace-controller.js";
+
+export declare function createHomeComposerFeature(options: {
+  workspace: ComposerWorkspaceController;
+  shell: ComposerAttachmentsShell;
+  client: ComposerAttachmentsClient;
+  composerActions: ComposerSubmitActions;
+  selectedEnvironmentId(): string;
+  selectedModelSupportsImageInput(): boolean;
+  isComposerAvailable?(): boolean;
+  getSubmissionBlock?(): ComposerSubmissionBlock | null;
+  onSubmissionBlocked?(block: ComposerSubmissionBlock): void;
+  onControlEvent(event: ComposerAttachmentControlEvent): void;
+  onStateChange(): void;
+  activateHomeSession(draft: HomeComposerDraft): boolean | void;
+  sendMessage(text: string): Promise<void>;
+}): {
+  attachments: ComposerAttachmentsController;
+  submit: ComposerSubmitController;
+  setWorkspace(destination: string): void;
+  environmentChanged(): void;
+  dispatch(): void;
+  upload(file: ComposerUploadFile): Promise<void>;
+  render(): void;
+};