@abot-ai/runtime 1.2.0 → 1.3.0

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

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

@@ -0,0 +1,119 @@
+import { createComposerAttachmentsController } from "./composer-attachments-controller.js";
+import { createComposerSubmitController } from "./composer-submit-controller.js";
+
+export function createHomeComposerFeature({
+  workspace,
+  shell,
+  client,
+  composerActions,
+  selectedEnvironmentId,
+  selectedModelSupportsImageInput,
+  isComposerAvailable,
+  getSubmissionBlock,
+  onSubmissionBlocked,
+  onControlEvent,
+  onStateChange,
+  activateHomeSession,
+  sendMessage,
+}) {
+  const attachments = createComposerAttachmentsController({
+    state: workspace.homeState,
+    dom: workspace.homeDom,
+    shell,
+    client,
+    selectedEnvironmentId,
+    selectedModelSupportsImageInput,
+    ensureSession: workspace.ensureHomeSession,
+    isComposerAvailable,
+    isComposerVisible: workspace.isHome,
+    onSendStateChange: onStateChange,
+    onControlEvent,
+  });
+
+  async function sendHomeMessage(text) {
+    const draft = workspace.takeHomeDraft(text);
+    let activated = false;
+    try {
+      activated = activateHomeSession(draft) !== false;
+    } catch (error) {
+      workspace.restoreHomeDraft(draft);
+      attachments.render();
+      throw error;
+    }
+    if (!activated) {
+      workspace.restoreHomeDraft(draft);
+      attachments.render();
+      return;
+    }
+    await sendMessage(text);
+  }
+
+  function reportRequestError(error) {
+    onControlEvent({
+      type: "control",
+      name: "Message could not be sent",
+      tone: "failed",
+      summary: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  const submit = createComposerSubmitController({
+    state: workspace.homeState,
+    dom: workspace.homeDom,
+    composerActions,
+    attachments,
+    queue: {
+      isCurrentDraining: () => false,
+      queuedCount: () => 0,
+    },
+    chatRequests: { sendMessage: sendHomeMessage },
+    conversationSession: { appendRequestError: reportRequestError },
+    selectedEnvironmentId,
+    setMessageStatus: () => {},
+    getSubmissionBlock,
+    onSubmissionBlocked,
+    isComposerVisible: workspace.isHome,
+  });
+
+  function environmentChanged() {
+    if (workspace.homeState.environmentId === selectedEnvironmentId()) return;
+    attachments.clear();
+    workspace.resetHomeDraft();
+    if (workspace.isHome()) workspace.ensureHomeSession();
+  }
+
+  function render() {
+    workspace.syncChatDraft();
+    environmentChanged();
+    if (!workspace.isHome()) return;
+    attachments.render();
+    submit.resize();
+    submit.updateSendState();
+  }
+
+  function setWorkspace(destination) {
+    environmentChanged();
+    workspace.setWorkspace(destination);
+    render();
+  }
+
+  function dispatch() {
+    environmentChanged();
+    submit.dispatch("send");
+  }
+
+  async function upload(file) {
+    environmentChanged();
+    await attachments.upload(file);
+  }
+
+  return {
+    attachments,
+    submit,
+    setWorkspace,
+    environmentChanged,
+    dispatch,
+    upload,
+    render,
+  };
+}

package/dist/src/web-ui/app/controllers/home-conversation-activation.js

@@ -0,0 +1,37 @@
+export function createHomeConversationActivation({
+  state,
+  shell,
+  conversationSession,
+  composerQueue,
+  preferences,
+  selectedEnvironmentId,
+  renderSessions,
+  renderMessages,
+  applyModelSelection,
+  setCurrentTitle,
+  updateComposerSendState,
+}) {
+  return function activateHomeConversation(draft) {
+    if (draft.environmentId !== selectedEnvironmentId()) return false;
+    const activateChat = shell.prepareWorkspaceActivation("chat", {
+      focus: false,
+    });
+    if (!activateChat) return false;
+    if (!composerQueue.suspendRecoveryForNavigation()) return false;
+    if (!activateChat()) return false;
+    conversationSession.clearCurrentSessionView();
+    state.currentSessionId = draft.sessionId;
+    state.pendingAttachments = draft.attachments;
+    preferences.saveSessionIdForEnvironment(
+      draft.environmentId,
+      draft.sessionId,
+    );
+    setCurrentTitle(draft.sessionId);
+    applyModelSelection();
+    conversationSession.subscribeSession(draft.sessionId);
+    updateComposerSendState();
+    renderSessions();
+    renderMessages();
+    return true;
+  };
+}

package/dist/src/web-ui/app/controllers/realtime-event-controller.d.ts

@@ -27,6 +27,7 @@ export interface RealtimeEventControllerOptions {
   ): ConversationSessionMessage;
   renderMessages(): void;
   renderContextWindow?(): void;
+  renderActivityStatus?(): void;
   scheduleMessageRender(): void;
   scheduleThinkingRender(): void;
   cancelScheduledMessageRender(): void;