@abot-ai/runtime 1.4.0 → 1.5.0

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

@@ -0,0 +1,59 @@
+import {
+  rememberRequestLifecycle,
+  removeStreamingPlaceholder,
+} from "../lib/request-lifecycle-view.js";
+
+export function createRequestLifecycleController(options) {
+  const {
+    state,
+    addOrMergeMessage,
+    normalizeChatMessage,
+    activeAssistantForRequest,
+    updateComposerSendState,
+    renderMessages,
+    setMessageActivityStatus,
+    markCurrentSessionReadSoon,
+    cancelScheduledMessageRender,
+    cancelScheduledThinkingRender,
+  } = options;
+
+  function handle(message) {
+    if (message.name !== "request.lifecycle.changed") return false;
+    const lifecycle = message.lifecycle;
+    if (!rememberRequestLifecycle(state, lifecycle)) return true;
+    const requestId = lifecycle.requestId;
+    const waiting = lifecycle.status === "awaiting_approval";
+    if (waiting) removeStreamingPlaceholder(state, requestId);
+    if (message.message)
+      addOrMergeMessage(normalizeChatMessage(message.message));
+    if (lifecycle.status === "streaming") {
+      state.activeRequestId = requestId;
+      activeAssistantForRequest(requestId).streaming = true;
+      setMessageActivityStatus("ABot is working.");
+    } else {
+      for (const entry of state.messages) {
+        if (entry.requestId === requestId) entry.streaming = false;
+        if (
+          entry.requestId === requestId &&
+          entry.approvalRequest?.state === "pending" &&
+          !waiting
+        ) {
+          entry.approvalRequest = {
+            ...entry.approvalRequest,
+            state: "cancelled",
+          };
+        }
+      }
+      if (waiting && state.activeRequestId === requestId)
+        state.activeRequestId = "";
+      cancelScheduledMessageRender();
+      cancelScheduledThinkingRender();
+      if (waiting) setMessageActivityStatus("Waiting for your approval.");
+      markCurrentSessionReadSoon();
+    }
+    updateComposerSendState();
+    renderMessages();
+    return true;
+  }
+  return { handle };
+}

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

@@ -100,10 +100,8 @@ export function createRuntimeSelectionController({
     const selectedOption =
       options.find((option) => option.value === selected) || options[0];
     const label = selectedOption?.label || selected || "Environment";
-    const glyph = label.slice(0, 3).toLocaleUpperCase();
     dom.agentPickerButton.hidden = false;
     dom.agentPickerButton.innerHTML = `
-      <span class="rail-environment-glyph" aria-hidden="true">${escapeHtml(glyph)}</span>
       <span class="rail-button-label">${escapeHtml(label)}</span>
     `;
     dom.agentPickerButton.title = `Environment: ${label}`;

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

@@ -1,16 +1,23 @@
+import { createEventRefresh } from "../lib/event-refresh.js";
 import {
   canManageSchedule,
   matchesScheduleFilter,
   scheduleErrorMessage,
 } from "../lib/schedule-presentation.js";
 
+function scheduleEntryFilter(jobId = "") {
+  return jobId ? "all" : "active";
+}
+
 export function createSchedulesController({
   client,
   getEnvironmentId,
   render,
   openConversation,
+  onRouteSelectionChange = () => {},
   setTimer = setTimeout,
   clearTimer = clearTimeout,
+  isVisible = () => globalThis.document?.visibilityState !== "hidden",
 }) {
   const state = {
     environmentId: "",
@@ -24,7 +31,7 @@ export function createSchedulesController({
     runsNextCursor: null,
     runsPreviousCursors: [],
     query: "",
-    filter: "current",
+    filter: scheduleEntryFilter(),
     loading: false,
     loadingRuns: false,
     mutation: "",
@@ -37,7 +44,19 @@ export function createSchedulesController({
   let detailRevision = 0;
   let selectionRevision = 0;
   let pendingDetailRead = null;
-  let pollTimer;
+  let historySettled = false;
+  let nextRefreshOptions = null;
+  let refreshDeferred = false;
+  const eventRefresh = createEventRefresh({
+    canRefresh: canRefreshVisibleSchedules,
+    refresh: () => {
+      const options = nextRefreshOptions || { background: true };
+      nextRefreshOptions = null;
+      return load({ ...options, waitForHistory: true });
+    },
+    setTimer,
+    clearTimer,
+  });
   const publish = () => render({ ...state });
   const isCurrentEnvironment = (environmentId) =>
     environmentId === getEnvironmentId();
@@ -49,17 +68,21 @@ export function createSchedulesController({
     state.selectedId === jobId;
 
   function resetRunPages() {
+    historySettled = false;
     Object.assign(state, {
       runs: [],
+      detailError: "",
       runsCursor: null,
       runsNextCursor: null,
       runsPreviousCursors: [],
     });
   }
 
-  function selectJobIdentity(jobId) {
-    if (state.selectedId !== jobId) resetRunPages();
+  function selectJobIdentity(jobId, { routeNavigation = false } = {}) {
+    if (state.selectedId === jobId) return;
+    resetRunPages();
     state.selectedId = jobId;
+    if (routeNavigation) onRouteSelectionChange();
   }
 
   function isVisibleJob(job) {
@@ -94,7 +117,7 @@ export function createSchedulesController({
 
   function shouldShowHistoryLoading(background) {
     if (!background) return true;
-    return state.runs.length === 0;
+    return !historySettled;
   }
 
   function shouldOpenEntryEditor(
@@ -149,23 +172,56 @@ export function createSchedulesController({
     selectJobIdentity(firstVisibleJob()?.id || "");
   }
 
+  function canRefreshVisibleSchedules() {
+    if (!active) return false;
+    if (state.mutation) return false;
+    return isVisible();
+  }
+
+  function refresh(options = { background: true }) {
+    if (!nextRefreshOptions) nextRefreshOptions = options;
+    if (state.mutation) {
+      refreshDeferred = true;
+      return Promise.resolve();
+    }
+    return eventRefresh.run();
+  }
+
   function scheduleRefresh() {
-    clearTimer(pollTimer);
-    if (!active) return;
-    pollTimer = setTimer(() => {
-      if (state.mutation) {
-        scheduleRefresh();
-        return;
-      }
-      void load({ background: true });
-    }, 5000);
+    if (state.mutation) {
+      refreshDeferred = true;
+      return;
+    }
+    eventRefresh.schedule();
+  }
+
+  function finishMutation() {
+    state.mutation = "";
+    publish();
+    if (!refreshDeferred) return;
+    refreshDeferred = false;
+    if (canRefreshVisibleSchedules()) void refresh();
+  }
+
+  function visibilityChanged() {
+    eventRefresh.cancel();
+    nextRefreshOptions = null;
+    void refresh();
+  }
+
+  function environmentChanged() {
+    eventRefresh.cancel();
+    nextRefreshOptions = null;
+    void refresh({ background: false });
   }
 
   async function load({
     background = false,
     openFirstEditor = false,
     targetJobId = "",
+    waitForHistory = false,
   } = {}) {
+    let historyRead;
     const environmentId = getEnvironmentId();
     const revision = ++loadRevision;
     const readSelectionRevision = selectionRevision;
@@ -178,7 +234,7 @@ export function createSchedulesController({
         models: [],
         selectedId: "",
         query: "",
-        filter: targetJobId ? "all" : "current",
+        filter: scheduleEntryFilter(targetJobId),
         runs: [],
         editor: null,
         error: "",
@@ -212,7 +268,7 @@ export function createSchedulesController({
         readSelectionRevision,
       );
       if (state.selectedId)
-        void select(state.selectedId, {
+        historyRead = select(state.selectedId, {
           background: true,
           reusePendingRead: background,
         });
@@ -223,9 +279,9 @@ export function createSchedulesController({
       if (hasCurrentListRead(revision, environmentId)) {
         state.loading = false;
         publish();
-        scheduleRefresh();
       }
     }
+    if (waitForHistory) await historyRead;
   }
 
   async function select(
@@ -233,19 +289,31 @@ export function createSchedulesController({
     { background = false, reusePendingRead = background } = {},
   ) {
     const environmentId = getEnvironmentId();
-    if (reusePendingRead && hasPendingDetailRead(jobId, environmentId)) return;
+    if (reusePendingRead && hasPendingDetailRead(jobId, environmentId))
+      return pendingDetailRead.settled;
     if (!background) selectionRevision += 1;
     const revision = ++detailRevision;
-    selectJobIdentity(jobId);
+    const selectionChanged = state.selectedId !== jobId;
+    selectJobIdentity(jobId, { routeNavigation: !background });
     state.loadingRuns = shouldShowHistoryLoading(background);
-    state.detailError = "";
+    if (selectionChanged) state.detailError = "";
     if (!hasLoadedJob(jobId)) {
       resetRunPages();
       state.loadingRuns = false;
       publish();
       return;
     }
-    const read = { revision, environmentId, jobId, cursor: state.runsCursor };
+    let finishRead;
+    const settled = new Promise((resolve) => {
+      finishRead = resolve;
+    });
+    const read = {
+      revision,
+      environmentId,
+      jobId,
+      cursor: state.runsCursor,
+      settled,
+    };
     pendingDetailRead = read;
     if (!background) publish();
     try {
@@ -254,13 +322,16 @@ export function createSchedulesController({
       });
       if (!hasCurrentDetailRead(revision, environmentId, jobId)) return;
       state.runs = result.runs || [];
+      state.detailError = "";
       state.runsNextCursor = result.nextCursor ?? null;
     } catch (error) {
       if (!hasCurrentDetailRead(revision, environmentId, jobId)) return;
       state.detailError = scheduleErrorMessage(error);
     } finally {
+      finishRead();
       if (pendingDetailRead === read) pendingDetailRead = null;
       if (hasCurrentDetailRead(revision, environmentId, jobId)) {
+        historySettled = true;
         state.loadingRuns = false;
         publish();
       }
@@ -268,6 +339,7 @@ export function createSchedulesController({
   }
 
   async function moveRunPage(cursor, previousCursors) {
+    historySettled = false;
     state.runsCursor = cursor;
     state.runsPreviousCursors = previousCursors;
     state.runsNextCursor = null;
@@ -308,7 +380,6 @@ export function createSchedulesController({
     selectionRevision += 1;
     state.editor = null;
     publish();
-    scheduleRefresh();
   }
 
   async function save(input) {
@@ -326,11 +397,10 @@ export function createSchedulesController({
         : await client.createSchedule(input, editor.environmentId);
       if (!isCurrentEnvironment(editor.environmentId)) return;
       state.editor = null;
-      selectJobIdentity(result.job.id);
+      selectJobIdentity(result.job.id, { routeNavigation: true });
       await load();
     } finally {
-      state.mutation = "";
-      publish();
+      finishMutation();
     }
   }
 
@@ -347,15 +417,14 @@ export function createSchedulesController({
       if (isCurrentEnvironment(environmentId))
         state.error = scheduleErrorMessage(error);
     } finally {
-      state.mutation = "";
-      publish();
+      finishMutation();
     }
   }
 
   async function openJob(jobId) {
     selectionRevision += 1;
-    Object.assign(state, { query: "", filter: "all", editor: null });
-    selectJobIdentity(jobId);
+    Object.assign(state, { query: "", filter: scheduleEntryFilter(jobId), editor: null });
+    selectJobIdentity(jobId, { routeNavigation: true });
     await load({ targetJobId: jobId });
   }
 
@@ -368,7 +437,8 @@ export function createSchedulesController({
     if (state.error) return;
     beginEdit("", {
       ...initialValues,
-      modelProfileId: initialValues.modelProfileId || state.defaultModelProfileId,
+      modelProfileId:
+        initialValues.modelProfileId || state.defaultModelProfileId,
     });
   }
 
@@ -401,19 +471,25 @@ export function createSchedulesController({
     openJob,
     openCreate,
     snapshot: () => ({ ...state }),
+    visibilityChanged,
+    environmentChanged,
+    refresh,
+    scheduleRefresh,
     filter,
     setActive(value) {
       const entering = value && !active;
       active = value;
+      refreshDeferred = false;
+      eventRefresh.cancel();
+      nextRefreshOptions = null;
       if (active) {
-        void load({ openFirstEditor: entering });
+        void refresh({ background: !entering, 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

@@ -6,6 +6,7 @@ import {
 import { matchesSessionQuery } from "../ui-behavior.js";
 import { escapeAttribute, escapeHtml, textOf } from "../lib/text-format.js";
 import { getNumber } from "../lib/event-presentation.js";
+import { createSessionSidebarController } from "./session-sidebar-controller.js";
 
 export function createSessionController({
   state,
@@ -22,6 +23,7 @@ export function createSessionController({
   onSaveModelPreferences,
   onReload,
   onControlEvent,
+  onSidebarChange,
   confirmAction = window.confirm.bind(window),
   copyText = (value) => navigator.clipboard.writeText(value),
 }) {
@@ -30,24 +32,13 @@ export function createSessionController({
   const byId = (sessionId) =>
     state.sessions.find((session) => textOf(session.id) === sessionId);
   const isPinned = (sessionId) => state.pinnedSessionIds.includes(sessionId);
-
-  function ordered() {
-    const pinnedOrder = new Map(
-      state.pinnedSessionIds.map((sessionId, index) => [sessionId, index]),
-    );
-    return [...state.sessions].sort((left, right) => {
-      const leftPinned = pinnedOrder.has(left.id);
-      const rightPinned = pinnedOrder.has(right.id);
-      if (leftPinned !== rightPinned) return leftPinned ? -1 : 1;
-      if (leftPinned && rightPinned) {
-        return pinnedOrder.get(left.id) - pinnedOrder.get(right.id);
-      }
-      return 0;
-    });
-  }
+  const sidebar = createSessionSidebarController({
+    state, preferences, selectedEnvironmentId, showToast: shell?.showToast,
+    render: onSidebarChange ?? render, getFilteredSessions: filtered,
+  });
 
   function filtered() {
-    return ordered().filter((session) =>
+    return sidebar.visibleSessions().filter((session) =>
       matchesSessionQuery(
         [
           titleOf(session),
@@ -64,29 +55,7 @@ export function createSessionController({
     dom.sessionsList.innerHTML = "";
     const sessions = filtered();
     dom.sessionsCount.textContent = String(sessions.length);
-    if (renderGroups({ root: dom.sessionsList, sessions, createSessionItem }))
-      return;
-    if (state.sessions.length === 0) {
-      dom.sessionsList.innerHTML = `
-        <div class="empty-state sidebar-empty-state">
-          <strong>No conversations yet</strong>
-          <span>Start a new conversation to keep its history here.</span>
-        </div>
-      `;
-      return;
-    }
-    if (sessions.length === 0) {
-      dom.sessionsList.innerHTML = `
-        <div class="empty-state sidebar-empty-state compact">
-          <strong>No matches</strong>
-          <span>Try a different conversation name or message.</span>
-        </div>
-      `;
-      return;
-    }
-    for (const [sessionIndex, session] of sessions.entries()) {
-      dom.sessionsList.appendChild(createSessionItem(session, sessionIndex));
-    }
+    sidebar.renderSections({ root: dom.sessionsList, sessions, createSessionItem, renderGroups });
   }
 
   function createSessionItem(session, sessionIndex) {
@@ -105,7 +74,7 @@ export function createSessionController({
       hasUnread ? "unread" : ""
     }`;
     item.innerHTML = `
-      <button class="session-open-button" type="button" title="${escapeAttribute(titleOf(session))}">
+      <button id="session-open-${escapeAttribute(encodeURIComponent(sessionId))}" 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>' : ""}
@@ -113,7 +82,7 @@ export function createSessionController({
             hasUnread
               ? `<span class="session-unread-badge" title="${escapeAttribute(
                   `${unreadCount || 1} unread`,
-                )}">${unreadCount > 99 ? "99+" : unreadCount || 1}</span>`
+                )}">${unreadCount > 99 ? "99+" : unreadCount || 1} unread</span>`
               : ""
           }
         </div>
@@ -122,6 +91,9 @@ export function createSessionController({
         <button class="session-menu-button" type="button" title="Session actions" aria-label="Session actions" aria-haspopup="menu" aria-expanded="false" aria-controls="session-menu-${sessionIndex}">•••</button>
         <div id="session-menu-${sessionIndex}" class="session-menu" role="menu" hidden>
           <button class="session-action pin-action" type="button" role="menuitem" tabindex="-1" title="${pinned ? "Unpin session" : "Pin session"}">${pinned ? "Unpin" : "Pin"}</button>
+          <button class="session-action move-up-action" type="button" role="menuitem" tabindex="-1">Move up</button>
+          <button class="session-action move-down-action" type="button" role="menuitem" tabindex="-1">Move down</button>
+          <button class="session-action archive-action" type="button" role="menuitem" tabindex="-1" title="Hide or restore this conversation in this browser and environment">${sidebar.isArchiveView() ? "Restore" : "Archive"}</button>
           <button class="session-action copy-filename-action" type="button" role="menuitem" tabindex="-1" title="Copy session filename">Copy filename</button>
           <button class="session-action clear-action" type="button" role="menuitem" tabindex="-1" title="Reset messages">Reset</button>
           <button class="session-action delete-action" type="button" role="menuitem" tabindex="-1" title="Delete session">Delete</button>
@@ -146,6 +118,7 @@ export function createSessionController({
     item
       .querySelector(".delete-action")
       ?.addEventListener("click", () => void deleteSession(sessionId));
+    sidebar.bindItem(item, session);
     return item;
   }
 
@@ -239,7 +212,7 @@ export function createSessionController({
           session.latestAssistantMessageId,
       };
     });
-    if (changed) render();
+    if (changed) (onSidebarChange ?? render)();
     return changed;
   }
 
@@ -337,6 +310,7 @@ export function createSessionController({
   }
 
   return {
+    archiveSession: (sessionId) => sidebar.archiveSession(sessionId),
     applyReadState,
     applyTitle,
     byId,

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

@@ -0,0 +1,159 @@
+import {
+  canReorderSidebarSessions, moveSidebarSession, orderSidebarSessions, sessionSidebarGroup,
+} from "../lib/session-sidebar-order.js";
+import { createSessionSidebarDrag } from "../components/session-sidebar-drag.js";
+import { renderSessionSidebarSections } from "../components/session-sidebar-sections.js";
+import { filterSessionsByArchiveState } from "../lib/session-archive-visibility.js";
+
+export function createSessionSidebarController({
+  state, preferences, selectedEnvironmentId = () => "", render, showToast, getFilteredSessions,
+}) {
+  let showingArchived = false;
+  let environmentId = selectedEnvironmentId();
+  let sidebarRoot = null;
+
+  function savedPreferences() {
+    const selected = selectedEnvironmentId();
+    if (environmentId !== selected) showingArchived = false;
+    environmentId = selected;
+    return preferences?.loadSessionSidebar?.(environmentId) ?? {
+      archivedSessionIds: [], orderedSessionIds: [],
+    };
+  }
+
+  function orderedSessions() {
+    return orderSidebarSessions(
+      state.sessions, state.pinnedSessionIds, savedPreferences().orderedSessionIds,
+    );
+  }
+
+  function visibleSessions() {
+    const saved = savedPreferences();
+    return filterSessionsByArchiveState(orderedSessions(), saved.archivedSessionIds, showingArchived);
+  }
+
+  function canMoveSidebarSession(sourceId, targetId) {
+    if (showingArchived) return false;
+    const sessions = visibleSessions();
+    return canReorderSidebarSessions(
+      sessions.find((session) => session.id === sourceId),
+      sessions.find((session) => session.id === targetId),
+      state.pinnedSessionIds,
+    );
+  }
+
+  function saveSidebar(value) {
+    try {
+      preferences.saveSessionSidebar(environmentId, value);
+      return true;
+    } catch {
+      showToast?.("Could not save conversation preferences in this browser", "failed");
+      return false;
+    }
+  }
+
+  function move(sourceId, targetId, placement) {
+    if (!canMoveSidebarSession(sourceId, targetId)) return;
+    if (state.pinnedSessionIds.includes(sourceId)) {
+      const pinned = moveSidebarSession(state.pinnedSessionIds, sourceId, targetId, placement);
+      try {
+        preferences.savePinnedSessions(pinned);
+      } catch {
+        showToast?.("Could not save pinned conversation order", "failed");
+        return;
+      }
+      state.pinnedSessionIds = pinned;
+      render();
+      return;
+    }
+    const saved = savedPreferences();
+    saved.orderedSessionIds = moveSidebarSession(
+      orderedSessions().map((session) => session.id), sourceId, targetId, placement,
+    );
+    if (saveSidebar(saved)) render();
+  }
+
+  function moveInDirection(session, direction) {
+    const group = sessionSidebarGroup(session, state.pinnedSessionIds);
+    const siblings = getFilteredSessions().filter(isSessionVisibleInSidebar).filter((candidate) =>
+      sessionSidebarGroup(candidate, state.pinnedSessionIds) === group,
+    );
+    const index = siblings.findIndex((candidate) => candidate.id === session.id);
+    if (index < 0) return;
+    const target = siblings[index + direction];
+    if (!target) return;
+    move(session.id, target.id, direction < 0 ? "before" : "after");
+    document.getElementById(`session-open-${encodeURIComponent(session.id)}`)?.focus();
+  }
+
+  function isSessionVisibleInSidebar(session) {
+    const button = document.getElementById(`session-open-${encodeURIComponent(session.id)}`);
+    if (!sidebarRoot?.contains(button)) return false;
+    for (let node = button; node !== sidebarRoot; node = node.parentElement) {
+      if (node.hidden) return false;
+    }
+    return true;
+  }
+
+  function setSessionArchived(sessionId, archived) {
+    if (!sessionId) return false;
+    const saved = savedPreferences();
+    if (saved.archivedSessionIds.includes(sessionId) === archived) return true;
+    saved.archivedSessionIds = archived
+      ? [...saved.archivedSessionIds, sessionId]
+      : saved.archivedSessionIds.filter((id) => id !== sessionId);
+    if (!saveSidebar(saved)) return false;
+    render();
+    sidebarRoot?.querySelector(".session-archive-toggle")?.focus();
+    showToast?.(archived ? "Conversation archived in this browser" : "Conversation restored");
+    return true;
+  }
+
+  function toggleArchive(sessionId) {
+    const archived = savedPreferences().archivedSessionIds.includes(sessionId);
+    return setSessionArchived(sessionId, !archived);
+  }
+
+  function archiveSession(sessionId) {
+    return setSessionArchived(sessionId, true);
+  }
+
+  const drag = createSessionSidebarDrag({ canMove: canMoveSidebarSession, onMove: move });
+
+  function bindItem(item, session) {
+    item.querySelector(".archive-action")?.addEventListener("click", () => toggleArchive(session.id));
+    const pinAction = item.querySelector(".pin-action");
+    if (pinAction) {
+      pinAction.hidden = showingArchived;
+      pinAction.disabled = showingArchived;
+    }
+    for (const [selector, direction] of [[".move-up-action", -1], [".move-down-action", 1]]) {
+      const button = item.querySelector(selector);
+      if (!button) continue;
+      button.hidden = showingArchived;
+      button.disabled = showingArchived;
+      button.addEventListener("click", () => moveInDirection(session, direction));
+    }
+    if (!showingArchived) drag.bind(item, session.id);
+  }
+
+  function renderSections(options) {
+    sidebarRoot = options.root;
+    drag.reset();
+    const saved = savedPreferences();
+    renderSessionSidebarSections({
+      ...options,
+      archivedCount: filterSessionsByArchiveState(state.sessions, saved.archivedSessionIds, true).length,
+      showingArchived,
+      onToggleArchived: () => {
+        showingArchived = !showingArchived;
+        render();
+        sidebarRoot.querySelector(".session-archive-toggle")?.focus();
+      },
+      isPinned: (id) => !showingArchived && state.pinnedSessionIds.includes(id),
+      hasConversations: state.sessions.length > 0,
+    });
+  }
+
+  return { archiveSession, bindItem, renderSections, visibleSessions, isArchiveView: () => showingArchived };
+}

package/dist/src/web-ui/app/controllers/tool-approval-controller.d.ts

@@ -7,6 +7,8 @@ export interface ToolApprovalControllerState {
   connected: boolean;
   events: ToolApprovalEvent[];
   submittedToolApprovalIds: Set<string>;
+  messages?: Array<Record<string, unknown>>;
+  requestLifecycles?: Map<string, Record<string, unknown>>;
 }
 
 export interface ToolApprovalControllerOptions {
@@ -24,5 +26,6 @@ export declare function createToolApprovalController(
   createCard(event: ToolApprovalEvent | undefined): HTMLElement;
   isPending(event: ToolApprovalEvent | undefined): boolean;
   pendingEvent(): ToolApprovalEvent | undefined;
+  pendingEvents(): ToolApprovalEvent[];
   submit(approvalId: string, approved: boolean): boolean;
 };