@abot-ai/runtime 1.2.0 → 1.3.0

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

@@ -0,0 +1,421 @@
+import {
+  canManageSchedule,
+  matchesScheduleFilter,
+  scheduleErrorMessage,
+} from "../lib/schedule-presentation.js";
+
+export function createSchedulesController({
+  client,
+  getEnvironmentId,
+  render,
+  openConversation,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  const state = {
+    environmentId: "",
+    jobs: [],
+    sessions: [],
+    models: [],
+    defaultModelProfileId: "",
+    selectedId: "",
+    runs: [],
+    runsCursor: null,
+    runsNextCursor: null,
+    runsPreviousCursors: [],
+    query: "",
+    filter: "current",
+    loading: false,
+    loadingRuns: false,
+    mutation: "",
+    error: "",
+    detailError: "",
+    editor: null,
+  };
+  let active = false;
+  let loadRevision = 0;
+  let detailRevision = 0;
+  let selectionRevision = 0;
+  let pendingDetailRead = null;
+  let pollTimer;
+  const publish = () => render({ ...state });
+  const isCurrentEnvironment = (environmentId) =>
+    environmentId === getEnvironmentId();
+  const hasCurrentListRead = (revision, environmentId) =>
+    revision === loadRevision && isCurrentEnvironment(environmentId);
+  const hasCurrentDetailRead = (revision, environmentId, jobId) =>
+    revision === detailRevision &&
+    isCurrentEnvironment(environmentId) &&
+    state.selectedId === jobId;
+
+  function resetRunPages() {
+    Object.assign(state, {
+      runs: [],
+      runsCursor: null,
+      runsNextCursor: null,
+      runsPreviousCursors: [],
+    });
+  }
+
+  function selectJobIdentity(jobId) {
+    if (state.selectedId !== jobId) resetRunPages();
+    state.selectedId = jobId;
+  }
+
+  function isVisibleJob(job) {
+    return matchesScheduleFilter(
+      job,
+      state.query,
+      state.filter,
+      state.sessions,
+    );
+  }
+
+  function firstVisibleJob() {
+    return state.jobs.find(isVisibleJob);
+  }
+
+  function hasLoadedJob(jobId) {
+    return state.jobs.some((job) => job.id === jobId);
+  }
+
+  function hasVisibleSelection(selected) {
+    if (!selected) return false;
+    return isVisibleJob(selected);
+  }
+
+  function hasPendingDetailRead(jobId, environmentId) {
+    if (!pendingDetailRead) return false;
+    if (pendingDetailRead.revision !== detailRevision) return false;
+    if (pendingDetailRead.environmentId !== environmentId) return false;
+    if (pendingDetailRead.jobId !== jobId) return false;
+    return pendingDetailRead.cursor === state.runsCursor;
+  }
+
+  function shouldShowHistoryLoading(background) {
+    if (!background) return true;
+    return state.runs.length === 0;
+  }
+
+  function shouldOpenEntryEditor(
+    openFirstEditor,
+    environmentChanged,
+    targetJobId,
+    readSelectionRevision,
+  ) {
+    if (readSelectionRevision !== selectionRevision) return false;
+    if (targetJobId) return false;
+    if (state.editor) return false;
+    if (state.mutation) return false;
+    if (!active) return false;
+    if (openFirstEditor) return true;
+    return environmentChanged;
+  }
+
+  function canRestoreRequestedJob(targetJobId, readSelectionRevision) {
+    if (!targetJobId) return false;
+    return readSelectionRevision === selectionRevision;
+  }
+
+  function shouldPreserveMissingSelection(selected, readSelectionRevision) {
+    if (selected) return false;
+    return readSelectionRevision === selectionRevision;
+  }
+
+  function openEntryScheduleEditor() {
+    const job = firstVisibleJob();
+    selectJobIdentity(job?.id || "");
+    if (!canManageSchedule(job)) return;
+    state.editor = { job, environmentId: getEnvironmentId() };
+  }
+
+  function reconcileLoadedSelection(
+    openEditor,
+    targetJobId,
+    readSelectionRevision,
+  ) {
+    if (canRestoreRequestedJob(targetJobId, readSelectionRevision)) {
+      selectJobIdentity(targetJobId);
+      return;
+    }
+    if (state.editor) return;
+    if (openEditor) {
+      openEntryScheduleEditor();
+      return;
+    }
+    const selected = state.jobs.find((job) => job.id === state.selectedId);
+    if (shouldPreserveMissingSelection(selected, readSelectionRevision)) return;
+    if (hasVisibleSelection(selected)) return;
+    selectJobIdentity(firstVisibleJob()?.id || "");
+  }
+
+  function scheduleRefresh() {
+    clearTimer(pollTimer);
+    if (!active) return;
+    pollTimer = setTimer(() => {
+      if (state.mutation) {
+        scheduleRefresh();
+        return;
+      }
+      void load({ background: true });
+    }, 5000);
+  }
+
+  async function load({
+    background = false,
+    openFirstEditor = false,
+    targetJobId = "",
+  } = {}) {
+    const environmentId = getEnvironmentId();
+    const revision = ++loadRevision;
+    const readSelectionRevision = selectionRevision;
+    const environmentChanged = state.environmentId !== environmentId;
+    if (environmentChanged) {
+      Object.assign(state, {
+        environmentId,
+        jobs: [],
+        sessions: [],
+        models: [],
+        selectedId: "",
+        query: "",
+        filter: targetJobId ? "all" : "current",
+        runs: [],
+        editor: null,
+        error: "",
+        detailError: "",
+      });
+      resetRunPages();
+      detailRevision += 1;
+    }
+    state.loading = !background;
+    if (!background) publish();
+    try {
+      const [jobs, sessions, models] = await Promise.all([
+        client.listSchedules(environmentId),
+        client.listSessions(environmentId),
+        client.listModels(environmentId),
+      ]);
+      if (!hasCurrentListRead(revision, environmentId)) return;
+      state.jobs = jobs.jobs || [];
+      state.sessions = sessions.sessions || [];
+      state.models = models.profiles || [];
+      state.defaultModelProfileId = models.defaultProfileId || "";
+      state.error = "";
+      reconcileLoadedSelection(
+        shouldOpenEntryEditor(
+          openFirstEditor,
+          environmentChanged,
+          targetJobId,
+          readSelectionRevision,
+        ),
+        targetJobId,
+        readSelectionRevision,
+      );
+      if (state.selectedId)
+        void select(state.selectedId, {
+          background: true,
+          reusePendingRead: background,
+        });
+    } catch (error) {
+      if (!hasCurrentListRead(revision, environmentId)) return;
+      state.error = scheduleErrorMessage(error);
+    } finally {
+      if (hasCurrentListRead(revision, environmentId)) {
+        state.loading = false;
+        publish();
+        scheduleRefresh();
+      }
+    }
+  }
+
+  async function select(
+    jobId,
+    { background = false, reusePendingRead = background } = {},
+  ) {
+    const environmentId = getEnvironmentId();
+    if (reusePendingRead && hasPendingDetailRead(jobId, environmentId)) return;
+    if (!background) selectionRevision += 1;
+    const revision = ++detailRevision;
+    selectJobIdentity(jobId);
+    state.loadingRuns = shouldShowHistoryLoading(background);
+    state.detailError = "";
+    if (!hasLoadedJob(jobId)) {
+      resetRunPages();
+      state.loadingRuns = false;
+      publish();
+      return;
+    }
+    const read = { revision, environmentId, jobId, cursor: state.runsCursor };
+    pendingDetailRead = read;
+    if (!background) publish();
+    try {
+      const result = await client.listScheduleRuns(jobId, environmentId, {
+        cursor: read.cursor ?? undefined,
+      });
+      if (!hasCurrentDetailRead(revision, environmentId, jobId)) return;
+      state.runs = result.runs || [];
+      state.runsNextCursor = result.nextCursor ?? null;
+    } catch (error) {
+      if (!hasCurrentDetailRead(revision, environmentId, jobId)) return;
+      state.detailError = scheduleErrorMessage(error);
+    } finally {
+      if (pendingDetailRead === read) pendingDetailRead = null;
+      if (hasCurrentDetailRead(revision, environmentId, jobId)) {
+        state.loadingRuns = false;
+        publish();
+      }
+    }
+  }
+
+  async function moveRunPage(cursor, previousCursors) {
+    state.runsCursor = cursor;
+    state.runsPreviousCursors = previousCursors;
+    state.runsNextCursor = null;
+    state.runs = [];
+    await select(state.selectedId);
+  }
+
+  async function olderRuns() {
+    if (state.loadingRuns || !state.runsNextCursor) return;
+    await moveRunPage(state.runsNextCursor, [
+      ...state.runsPreviousCursors,
+      state.runsCursor,
+    ]);
+  }
+
+  async function newerRuns() {
+    if (state.loadingRuns || !state.runsPreviousCursors.length) return;
+    const previous = [...state.runsPreviousCursors];
+    await moveRunPage(previous.pop(), previous);
+  }
+
+  async function latestRuns() {
+    if (state.loadingRuns || state.runsCursor === null) return;
+    await moveRunPage(null, []);
+  }
+
+  function beginEdit(jobId = "", initialValues = null) {
+    selectionRevision += 1;
+    state.editor = {
+      job: state.jobs.find((job) => job.id === jobId) || null,
+      environmentId: getEnvironmentId(),
+      initialValues,
+    };
+    publish();
+  }
+
+  function cancelEdit() {
+    selectionRevision += 1;
+    state.editor = null;
+    publish();
+    scheduleRefresh();
+  }
+
+  async function save(input) {
+    const editor = state.editor;
+    if (!editor || !isCurrentEnvironment(editor.environmentId))
+      throw new Error("The environment changed. Reopen the schedule editor.");
+    state.mutation = "save";
+    try {
+      const result = editor.job
+        ? await client.updateSchedule(
+            editor.job.id,
+            input,
+            editor.environmentId,
+          )
+        : await client.createSchedule(input, editor.environmentId);
+      if (!isCurrentEnvironment(editor.environmentId)) return;
+      state.editor = null;
+      selectJobIdentity(result.job.id);
+      await load();
+    } finally {
+      state.mutation = "";
+      publish();
+    }
+  }
+
+  async function action(jobId, actionName) {
+    if (state.mutation) return;
+    const environmentId = getEnvironmentId();
+    state.mutation = actionName;
+    state.error = "";
+    publish();
+    try {
+      await client.scheduleAction(jobId, actionName, environmentId);
+      if (isCurrentEnvironment(environmentId)) await load();
+    } catch (error) {
+      if (isCurrentEnvironment(environmentId))
+        state.error = scheduleErrorMessage(error);
+    } finally {
+      state.mutation = "";
+      publish();
+    }
+  }
+
+  async function openJob(jobId) {
+    selectionRevision += 1;
+    Object.assign(state, { query: "", filter: "all", editor: null });
+    selectJobIdentity(jobId);
+    await load({ targetJobId: jobId });
+  }
+
+  async function openCreate(initialValues = {}) {
+    const environmentId = getEnvironmentId();
+    const revision = ++selectionRevision;
+    await load();
+    if (!isCurrentEnvironment(environmentId)) return;
+    if (revision !== selectionRevision) return;
+    if (state.error) return;
+    beginEdit("", {
+      ...initialValues,
+      modelProfileId: initialValues.modelProfileId || state.defaultModelProfileId,
+    });
+  }
+
+  async function filter(query, filter) {
+    selectionRevision += 1;
+    Object.assign(state, { query, filter });
+    if (state.editor) {
+      publish();
+      return;
+    }
+    const selected = state.jobs.find((job) => job.id === state.selectedId);
+    if (hasVisibleSelection(selected)) {
+      publish();
+      return;
+    }
+    const job = firstVisibleJob();
+    await select(job?.id || "");
+  }
+
+  return {
+    load,
+    select,
+    olderRuns,
+    newerRuns,
+    latestRuns,
+    beginEdit,
+    cancelEdit,
+    save,
+    action,
+    openJob,
+    openCreate,
+    snapshot: () => ({ ...state }),
+    filter,
+    setActive(value) {
+      const entering = value && !active;
+      active = value;
+      if (active) {
+        void load({ openFirstEditor: entering });
+        return;
+      }
+      loadRevision += 1;
+      detailRevision += 1;
+      state.loading = false;
+      state.loadingRuns = false;
+      clearTimer(pollTimer);
+    },
+    openConversation: (sessionId, requestId) =>
+      openConversation(sessionId, requestId),
+  };
+}

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

@@ -1,3 +1,8 @@
+import {
+  isOlderSessionReadState,
+  isSessionReadStateUnavailable,
+  mergeSessionReadStateUpdate,
+} from "../lib/session-read-state.js";
 import { matchesSessionQuery } from "../ui-behavior.js";
 import { escapeAttribute, escapeHtml, textOf } from "../lib/text-format.js";
 import { getNumber } from "../lib/event-presentation.js";
@@ -81,7 +86,10 @@ export function createSessionController({
       const pinned = isPinned(sessionId);
       const busy = state.busySessionIds.has(sessionId);
       const unreadCount = getNumber(session.unreadCount, 0);
-      const hasUnread = session.hasUnread === true || unreadCount > 0;
+      const unreadUnavailable = isSessionReadStateUnavailable(session);
+      const hasUnread = unreadUnavailable
+        ? false
+        : session.hasUnread === true || unreadCount > 0;
       const item = document.createElement("div");
       item.className = `session-item ${
         session.id === state.currentSessionId ? "active" : ""
@@ -92,6 +100,7 @@ export function createSessionController({
         <button class="session-open-button" type="button" title="${escapeAttribute(titleOf(session))}">
           <div class="session-title-row">
             <div class="session-title" dir="auto">${escapeHtml(titleOf(session))}</div>
+            ${unreadUnavailable ? '<span class="session-unread-badge" title="Unread status unavailable" aria-label="Unread status unavailable">?</span>' : ""}
             ${
               hasUnread
                 ? `<span class="session-unread-badge" title="${escapeAttribute(
@@ -175,12 +184,20 @@ export function createSessionController({
   }
 
   function applyReadState(sessionId, readState) {
-    const value = readState && typeof readState === "object" ? readState : {};
-    const normalizedSessionId = textOf(value.sessionId || sessionId);
+    const incoming =
+      readState && typeof readState === "object" ? readState : {};
+    const normalizedSessionId = textOf(incoming.sessionId || sessionId);
     if (!normalizedSessionId) return false;
+    const known = byId(normalizedSessionId);
+    if (isOlderSessionReadState(incoming, known)) return false;
+    const value = mergeSessionReadStateUpdate(incoming, known);
+    const unreadUnavailable = isSessionReadStateUnavailable(value);
     const unreadCount = getNumber(value.unreadCount, 0);
     const normalized = {
       sessionId: normalizedSessionId,
+      readStateStatus: unreadUnavailable
+        ? "unavailable"
+        : value.readStateStatus,
       lastReadMessageId: textOf(value.lastReadMessageId),
       lastReadAt: value.lastReadAt || null,
       unreadCount,
@@ -188,6 +205,15 @@ export function createSessionController({
       latestMessageId: textOf(value.latestMessageId),
       latestAssistantMessageId: textOf(value.latestAssistantMessageId),
     };
+    if (unreadUnavailable) {
+      for (const field of [
+        "lastReadMessageId",
+        "lastReadAt",
+        "unreadCount",
+        "hasUnread",
+      ])
+        normalized[field] = value[field] ?? null;
+    }
     let changed = false;
     state.sessions = state.sessions.map((session) => {
       if (textOf(session.id) !== normalized.sessionId) return session;
@@ -195,6 +221,7 @@ export function createSessionController({
       return {
         ...session,
         readState: normalized,
+        readStateStatus: normalized.readStateStatus,
         unreadCount: normalized.unreadCount,
         hasUnread: normalized.hasUnread,
         lastReadMessageId: normalized.lastReadMessageId,

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

@@ -0,0 +1,44 @@
+import { createDashboardWorkspace } from "./components/dashboard/workspace.js";
+import { createDashboardController } from "./controllers/dashboard-controller.js";
+import { dashboardJobInitialValues } from "./lib/dashboard-job-templates.js";
+
+export function createDashboardFeature({
+  dom, state, client, shell, schedules, selectedEnvironmentId,
+  loadSessions, openSession, isComposerAvailable,
+}) {
+  let view;
+  const controller = createDashboardController({
+    client, getEnvironmentId: selectedEnvironmentId,
+    getSessions: () => state.sessions, loadSessions,
+    render: (snapshot) => view?.render({ ...snapshot, composerAvailable: isComposerAvailable() }),
+  });
+  view = createDashboardWorkspace({
+    root: dom.homeDashboardRoot,
+    actions: {
+      attach: () => dom.attachmentButton.click(),
+      createJob: (templateId) => schedules.createJob(dashboardJobInitialValues(templateId, dom.modelSelect.value)),
+      continueConversation: () => shell.setSessionsDrawerOpen(true),
+      openConfiguration: () => shell.activateWorkspace("config"),
+      openJobs: () => shell.activateWorkspace("schedules"),
+      refresh: controller.refresh,
+      openConversation: async (sessionId, requestId) => {
+        if (!shell.activateWorkspace("chat")) return;
+        try {
+          await openSession(sessionId);
+          if (state.currentSessionId !== sessionId) return;
+          if (!requestId) return;
+          requestAnimationFrame(() => {
+            const message = [...dom.messagesList.querySelectorAll("[data-request-id]")]
+              .find((node) => node.dataset.requestId === requestId);
+            message?.scrollIntoView({ block: "center", behavior: "smooth" });
+          });
+        } catch (error) {
+          shell.showToast(error instanceof Error ? error.message : String(error), "failed");
+        }
+      },
+    },
+  });
+  controller.publish();
+  document.addEventListener("visibilitychange", controller.visibilityChanged);
+  return { ...controller, composerHost: view.composerHost, setupHost: view.setupHost };
+}

package/dist/src/web-ui/app/index.html

@@ -25,13 +25,18 @@
           <span class="rail-button-label">Chats</span>
         </button>
         <div class="rail-actions">
+          <button id="homeWorkspaceButton" class="rail-button" type="button"
+            aria-label="Open home dashboard" aria-controls="homeWorkspacePanel"
+            aria-current="page" title="Home">
+            <svg viewBox="0 0 24 24" aria-hidden="true"><path d="m3 10 9-7 9 7M5 9v12h5v-7h4v7h5V9" /></svg>
+            <span class="rail-button-label">Home</span>
+          </button>
           <button
             id="chatWorkspaceButton"
             class="rail-button"
             type="button"
             aria-label="Open chat workspace"
             aria-controls="chatWorkspace"
-            aria-current="page"
             title="Chat"
           >
             <svg viewBox="0 0 24 24" aria-hidden="true">
@@ -52,6 +57,22 @@
             </svg>
             <span class="rail-button-label">New</span>
           </button>
+          <button
+            id="schedulesWorkspaceButton"
+            hidden
+            disabled
+            class="rail-button"
+            type="button"
+            aria-label="Open schedules workspace"
+            aria-controls="schedulesWorkspacePanel"
+            title="Schedules"
+          >
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <circle cx="12" cy="12" r="8" />
+              <path d="M12 7v5l3 2" />
+            </svg>
+            <span class="rail-button-label">Schedules</span>
+          </button>
           <button
             id="configWorkspaceButton"
             class="rail-button"
@@ -104,6 +125,11 @@
         </div>
       </nav>
 
+      <section id="homeWorkspacePanel" class="home-workspace-panel" aria-label="Home dashboard">
+        <header class="home-workspace-header"><h1>Home</h1></header>
+        <div id="homeDashboardRoot"></div>
+      </section>
+
       <aside
         id="sessionsPanel"
         class="sessions-panel workspace-sheet sessions-sheet"
@@ -359,6 +385,32 @@
         </div>
       </main>
 
+      <section
+        id="schedulesWorkspacePanel"
+        class="workspace-page-panel schedules-workspace-panel"
+        aria-labelledby="schedulesWorkspaceTitle"
+        hidden
+      >
+        <header class="workspace-page-header">
+          <div class="workspace-page-heading">
+            <p class="eyebrow">Automations</p>
+            <h2 id="schedulesWorkspaceTitle">Schedules</h2>
+            <p>Tasks that return to the conversation, right on time.</p>
+          </div>
+          <button
+            id="closeSchedulesWorkspaceButton"
+            class="workspace-page-back"
+            type="button"
+          >
+            Back to chat
+          </button>
+        </header>
+        <div
+          id="schedulesRoot"
+          class="workspace-page-body schedules-workspace-body"
+        ></div>
+      </section>
+
       <section
         id="configWorkspacePanel"
         class="workspace-page-panel config-workspace-panel"

package/dist/src/web-ui/app/lib/composer-submission-scope.d.ts

@@ -0,0 +1,21 @@
+export interface ComposerSubmissionView {
+  currentSessionId: string;
+  sessionViewVersion?: number;
+}
+
+export interface ComposerSubmissionScope {
+  environmentId: string;
+  sessionId: string;
+  viewVersion: number | undefined;
+}
+
+export declare function captureComposerSubmissionScope(
+  state: ComposerSubmissionView,
+  environmentId: string,
+): ComposerSubmissionScope;
+
+export declare function isCurrentComposerSubmissionScope(
+  scope: ComposerSubmissionScope,
+  state: ComposerSubmissionView,
+  environmentId: string,
+): boolean;

package/dist/src/web-ui/app/lib/composer-submission-scope.js

@@ -0,0 +1,13 @@
+export function captureComposerSubmissionScope(state, environmentId) {
+  return {
+    environmentId,
+    sessionId: state.currentSessionId,
+    viewVersion: state.sessionViewVersion,
+  };
+}
+
+export function isCurrentComposerSubmissionScope(scope, state, environmentId) {
+  if (scope.environmentId !== environmentId) return false;
+  if (scope.sessionId !== state.currentSessionId) return false;
+  return scope.viewVersion === state.sessionViewVersion;
+}

package/dist/src/web-ui/app/lib/context-window-snapshot-order.d.ts

@@ -0,0 +1,15 @@
+interface ContextWindowSequence {
+  eventSequence?: unknown;
+  seqNo?: unknown;
+  lastSeqNo?: unknown;
+}
+
+export declare function canReplaceContextWindowEvidence(
+  previous: ContextWindowSequence | null | undefined,
+  incoming: ContextWindowSequence,
+): boolean;
+
+export declare function isEventAfterContextWindowSnapshot(
+  snapshot: ContextWindowSequence,
+  event: ContextWindowSequence,
+): boolean;