@abot-ai/runtime 1.5.0 → 1.6.0

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

@@ -5,6 +5,7 @@ function errorMessage(error) {
 export function createProjectsController({
   client,
   getEnvironmentId,
+  isRuntimeReady = () => true,
   getConversationRevision,
   prepareConversation,
   openSession,
@@ -15,6 +16,7 @@ export function createProjectsController({
 }) {
   let revision = 0;
   let currentEnvironment = getEnvironmentId();
+  let runtimeReady = isRuntimeReady();
   let browseRevision = 0;
   let listRevision = 0;
   let activationRevision = 0;
@@ -27,8 +29,16 @@ export function createProjectsController({
   };
   const snapshot = () => state;
   const publish = () => onChange(snapshot());
-  const isCurrentEnvironment = (environmentId, token) =>
-    environmentId === getEnvironmentId() && token === revision;
+  function canUseProjects() {
+    if (!isRuntimeReady()) return false;
+    return client.supportsProjects();
+  }
+
+  function isCurrentEnvironment(environmentId, token) {
+    if (!canUseProjects()) return false;
+    if (environmentId !== getEnvironmentId()) return false;
+    return token === revision;
+  }
   const hasCurrentDraft = (environmentId, token, draft) =>
     isCurrentEnvironment(environmentId, token) && state.draft === draft;
 
@@ -38,6 +48,7 @@ export function createProjectsController({
   }
 
   function canApplyFolderListing(environmentId, token, draft) {
+    if (!canUseProjects()) return false;
     if (state.draft !== draft) return false;
     if (token !== browseRevision) return false;
     if (!draft.pickerOpen) return false;
@@ -50,12 +61,14 @@ export function createProjectsController({
   }
 
   function canCreateProject(draft) {
+    if (!canUseProjects()) return false;
     if (!canEditProjectDraft(draft)) return false;
     if (draft.pickerOpen) return false;
     return !draft.loading;
   }
 
   function canBrowseProjectFolders(draft) {
+    if (!canUseProjects()) return false;
     if (!canEditProjectDraft(draft)) return false;
     return draft.pickerOpen;
   }
@@ -72,17 +85,17 @@ export function createProjectsController({
   }
 
   async function load() {
+    synchronizeProjectRuntime();
     const environmentId = getEnvironmentId();
-    currentEnvironment = environmentId;
     const token = revision;
     const listToken = ++listRevision;
-    state = { ...state, loading: true, error: "" };
-    publish();
-    if (!client.supportsProjects()) {
-      state = { ...state, projects: [], loading: false };
+    if (!canUseProjects()) {
+      state = { ...state, projects: [], loading: false, error: "" };
       publish();
       return;
     }
+    state = { ...state, loading: true, error: "" };
+    publish();
     try {
       const result = await client.listProjects(environmentId);
       if (!canApplyProjectList(environmentId, token, listToken)) return;
@@ -131,6 +144,7 @@ export function createProjectsController({
   }
 
   function openFolderPicker() {
+    if (!canUseProjects()) return Promise.resolve();
     const draft = state.draft;
     if (!canEditProjectDraft(draft)) return Promise.resolve();
     draft.pickerOpen = true;
@@ -156,6 +170,7 @@ export function createProjectsController({
   }
 
   function openCreate() {
+    if (!canUseProjects()) return;
     activationRevision += 1;
     state = {
       ...state,
@@ -213,6 +228,7 @@ export function createProjectsController({
   }
 
   async function newConversation(projectId) {
+    if (!canUseProjects()) return;
     if (state.busyProjectId) return;
     if (!prepareConversation()) return;
     const environmentId = getEnvironmentId();
@@ -244,27 +260,46 @@ export function createProjectsController({
     }
   }
 
-  function environmentChanged() {
-    if (currentEnvironment === getEnvironmentId()) return Promise.resolve();
-    currentEnvironment = getEnvironmentId();
+  function retainedProjectDraft(environmentChanged) {
+    if (environmentChanged) return null;
+    if (!state.draft) return null;
+    return { ...state.draft, loading: false, saving: false, error: "",
+      pickerOpen: false, listing: null };
+  }
+
+  function hasProjectRuntimeChanged(environmentId, ready) {
+    if (currentEnvironment !== environmentId) return true;
+    return runtimeReady !== ready;
+  }
+
+  function synchronizeProjectRuntime() {
+    const environmentId = getEnvironmentId();
+    const ready = isRuntimeReady();
+    const environmentChanged = currentEnvironment !== environmentId;
+    if (!hasProjectRuntimeChanged(environmentId, ready)) return false;
+    const draft = retainedProjectDraft(environmentChanged);
+    currentEnvironment = environmentId;
+    runtimeReady = ready;
     revision += 1;
     listRevision += 1;
     browseRevision += 1;
-    state = {
-      projects: [],
-      loading: false,
-      error: "",
-      draft: null,
-      busyProjectId: "",
-    };
+    activationRevision += 1;
+    state = { projects: [], loading: false, error: "", draft, busyProjectId: "" };
     publish();
+    return true;
+  }
+
+  function runtimeAvailabilityChanged() {
+    if (!synchronizeProjectRuntime()) return Promise.resolve();
+    if (!canUseProjects()) return Promise.resolve();
     return load();
   }
 
   return {
     snapshot,
     load,
-    environmentChanged,
+    environmentChanged: runtimeAvailabilityChanged,
+    runtimeAvailabilityChanged,
     openCreate,
     closeCreate,
     updateDraft,

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

@@ -16,9 +16,15 @@ import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
 import { reduceTaskProgress } from "../lib/task-progress.js";
 import { projectWebSourceEvent } from "../lib/web-source-event.js";
 import { projectToolActivityEvent } from "../lib/tool-activity-event.js";
-import { canReplaceContextWindowEvidence } from "../lib/context-window-snapshot-order.js";
+import {
+  contextEvidenceScope,
+  contextEvidenceOrder,
+  reduceContextWindowEvidence,
+  synchronizeContextRequestLifecycle,
+} from "../lib/context-window-state.js";
 import { isWorkspaceChange } from "../lib/workspace-change.js";
 import { createRequestLifecycleController } from "./request-lifecycle-controller.js";
+import { ownsToolApprovalAcknowledgement } from "../lib/tool-approval-acknowledgement.js";
 
 export { normalizeRealtimeMessage } from "../lib/realtime-message.js";
 export { taskStatusClass } from "../lib/task-progress.js";
@@ -75,6 +81,12 @@ export function createRealtimeEventController({
 }) {
   const lifecycleController = createRequestLifecycleController({
     state,
+    onAcceptedLifecycle: (message) =>
+      synchronizeContextRequestLifecycle(
+        state,
+        message,
+        selectedEnvironmentId(),
+      ),
     addOrMergeMessage,
     normalizeChatMessage,
     activeAssistantForRequest,
@@ -119,161 +131,17 @@ export function createRealtimeEventController({
   }
 
   function updateContextWindow(message) {
-    const eventName = textOf(message.name || message.rawType);
-    const requestId = textOf(message.requestId) || state.activeRequestId;
-    if (!requestId) return;
-    const current = state.contextWindowByRequest.get(requestId) || {
+    const requestId = textOf(message.requestId);
+    const current = state.contextWindowByRequest.get(requestId);
+    const scope = contextEvidenceScope(
+      state,
+      selectedEnvironmentId(),
       requestId,
-      snapshot: null,
-      providerUsage: null,
-      pendingCompaction: null,
-      lastCompaction: null,
-      lastCompactionEvent: null,
-    };
-    if (eventName === "context.window.snapshot") {
-      const contextWindowTokens = Number(message.contextWindowTokens);
-      const estimatedInputTokens = Number(message.estimatedInputTokens);
-      const usedContextPercent = Number(message.usedContextPercent);
-      const remainingContextTokens = Number(message.remainingContextTokens);
-      if (
-        !Number.isFinite(contextWindowTokens) ||
-        contextWindowTokens <= 0 ||
-        !Number.isFinite(estimatedInputTokens) ||
-        estimatedInputTokens < 0 ||
-        !Number.isFinite(usedContextPercent)
-      ) {
-        return;
-      }
-      const previous = current.snapshot;
-      if (!canReplaceContextWindowEvidence(previous, message)) return;
-      const snapshot = {
-        requestId,
-        eventSequence: message.eventSequence,
-        seqNo: message.seqNo,
-        invocationId: textOf(message.invocationId),
-        modelStep: textOf(message.modelStep),
-        profileId: textOf(message.profileId),
-        provider: textOf(message.provider),
-        model: textOf(message.model),
-        measurement: textOf(message.measurement, "estimated"),
-        source: textOf(message.source, "runtime_token_estimator"),
-        admissionOutcome: textOf(message.admissionOutcome),
-        contextWindowTokens,
-        estimatedInputTokens,
-        remainingContextTokens: Number.isFinite(remainingContextTokens)
-          ? remainingContextTokens
-          : Math.max(0, contextWindowTokens - estimatedInputTokens),
-        usedContextPercent,
-        remainingContextPercent: Number(message.remainingContextPercent),
-        compactionTriggerPercent: Number(message.compactionTriggerPercent),
-        outputReserveTokens: Number(message.outputReserveTokens),
-        safetyReserveTokens: Number(message.safetyReserveTokens),
-        attachmentReserveTokens: Number(message.attachmentReserveTokens),
-        formatReserveTokens: Number(message.formatReserveTokens),
-      };
-      let lastCompaction = current.lastCompaction;
-      if (
-        current.pendingCompaction &&
-        previous?.profileId === snapshot.profileId &&
-        snapshot.usedContextPercent < previous.usedContextPercent
-      ) {
-        lastCompaction = {
-          beforePercent:
-            current.pendingCompaction.beforePercent ??
-            previous.usedContextPercent,
-          afterPercent: snapshot.usedContextPercent,
-        };
-      }
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        snapshot,
-        lastCompaction,
-        pendingCompaction: lastCompaction ? null : current.pendingCompaction,
-      });
-      return true;
-    }
-    if (eventName === "context.window.provider_usage") {
-      if (!canReplaceContextWindowEvidence(current.providerUsage, message))
-        return;
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        providerUsage: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-          invocationId: textOf(message.invocationId),
-          modelStep: textOf(message.modelStep),
-          profileId: textOf(message.profileId),
-          source: textOf(message.source, "provider_reported"),
-          inputTokens: Number(message.inputTokens),
-          outputTokens: Number(message.outputTokens),
-          totalTokens: Number(message.totalTokens),
-        },
-      });
-      return true;
-    }
-    if (eventName === "context.compaction.started") {
-      if (
-        !canReplaceContextWindowEvidence(current.lastCompactionEvent, message)
-      )
-        return;
-      if (!canReplaceContextWindowEvidence(current.snapshot, message)) return;
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        lastCompactionEvent: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-        },
-        pendingCompaction: {
-          beforePercent: Number.isFinite(
-            Number(message.beforeUsedContextPercent),
-          )
-            ? Number(message.beforeUsedContextPercent)
-            : current.snapshot?.usedContextPercent,
-        },
-      });
-      return true;
-    }
-    if (eventName === "context.compaction.completed") {
-      if (
-        !canReplaceContextWindowEvidence(current.lastCompactionEvent, message)
-      )
-        return;
-      const beforePercent = Number(message.beforeUsedContextPercent);
-      const afterPercent = Number(message.afterUsedContextPercent);
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        lastCompactionEvent: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-        },
-        pendingCompaction: null,
-        lastCompaction:
-          Number.isFinite(beforePercent) && Number.isFinite(afterPercent)
-            ? { beforePercent, afterPercent }
-            : current.lastCompaction,
-      });
-      return true;
-    }
-    if (eventName === "context.compaction.failed") {
-      if (
-        !canReplaceContextWindowEvidence(current.lastCompactionEvent, message)
-      )
-        return;
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        lastCompactionEvent: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-        },
-        pendingCompaction: null,
-      });
-      return true;
-    }
+    );
+    const next = reduceContextWindowEvidence(current, message, scope);
+    if (!next || next === current) return false;
+    state.contextWindowByRequest.set(requestId, next);
+    return true;
   }
 
   function recordEvent(message) {
@@ -285,16 +153,16 @@ export function createRealtimeEventController({
     const eventSequence = hasOriginalEventSequence(message.eventSequence)
       ? message.eventSequence
       : undefined;
-    if (hasRecordedOriginalEvent(state.events, requestId, eventSequence)) {
-      trackSeq(message);
-      return;
-    }
-    updateTaskProgress(message);
     const contextWindowUpdated = updateContextWindow(message);
     if (contextWindowUpdated) {
       renderContextWindow();
       renderActivityStatus();
     }
+    if (hasRecordedOriginalEvent(state.events, requestId, eventSequence)) {
+      trackSeq(message);
+      return;
+    }
+    updateTaskProgress(message);
     const eventName = textOf(message.name || message.rawType || message.type);
     if (isLowValueActivityEvent(message)) {
       trackSeq(message);
@@ -308,6 +176,10 @@ export function createRealtimeEventController({
     const key = eventKeyFor({ ...message, requestId }, name, tone);
     const webSources = projectWebSourceEvent(message);
     const toolActivity = projectToolActivityEvent(message);
+    const contextOrder = contextEvidenceOrder(
+      message,
+      contextEvidenceScope(state, selectedEnvironmentId(), requestId),
+    );
     const lastEvent = state.events[state.events.length - 1];
     if (
       canMergeUnsequencedActivity(
@@ -321,6 +193,7 @@ export function createRealtimeEventController({
       lastEvent.count = (lastEvent.count || 1) + 1;
       lastEvent.summary = summary;
       lastEvent.updatedAt = Date.now();
+      Object.assign(lastEvent, contextOrder);
       if (typeof message.seqNo === "number")
         lastEvent.lastSeqNo = message.seqNo;
       lastEvent.eventName = eventName || lastEvent.eventName;
@@ -334,6 +207,7 @@ export function createRealtimeEventController({
         lastSeqNo:
           typeof message.seqNo === "number" ? message.seqNo : undefined,
         eventSequence,
+        ...contextOrder,
         updatedAt: Date.now(),
         type: message.type,
         rawType: message.rawType,
@@ -415,6 +289,14 @@ export function createRealtimeEventController({
   function handle(rawMessage) {
     const message = normalizeRealtimeMessage(rawMessage);
     if (message.type === "tool_approval_ack") {
+      if (
+        !ownsToolApprovalAcknowledgement(
+          message,
+          state,
+          selectedEnvironmentId(),
+        )
+      )
+        return;
       if (!message.accepted) {
         state.submittedToolApprovalIds.delete(message.approvalId);
         recordControlEvent({

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

@@ -6,6 +6,7 @@ import {
 export function createRequestLifecycleController(options) {
   const {
     state,
+    onAcceptedLifecycle = () => {},
     addOrMergeMessage,
     normalizeChatMessage,
     activeAssistantForRequest,
@@ -21,6 +22,7 @@ export function createRequestLifecycleController(options) {
     if (message.name !== "request.lifecycle.changed") return false;
     const lifecycle = message.lifecycle;
     if (!rememberRequestLifecycle(state, lifecycle)) return true;
+    onAcceptedLifecycle(message);
     const requestId = lifecycle.requestId;
     const waiting = lifecycle.status === "awaiting_approval";
     if (waiting) removeStreamingPlaceholder(state, requestId);

package/dist/src/web-ui/app/controllers/runtime-onboarding-controller.d.ts

@@ -9,7 +9,10 @@ export interface RuntimeOnboardingControllerDependencies {
     runtimeAvailability: RuntimeAvailability;
   };
   readonly guide: Readonly<{
-    bind(options?: { onCheckAgain?: () => void | Promise<void> }): void;
+    bind(options?: {
+      onCheckAgain?: () => void | Promise<void>;
+      onApplied?: () => void | Promise<void>;
+    }): void;
     focusAction(): void;
     render(setup: RuntimeAvailability): void;
   }>;

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

@@ -44,9 +44,10 @@ export function createRuntimeOnboardingController({
   onStateChange = () => {},
 }) {
   let checkPromise = null;
+  let checkRevision = 0;
 
   function bind() {
-    guide.bind({ onCheckAgain: checkAgain });
+    guide.bind({ onCheckAgain: checkAgain, onApplied: startCatalogCheck });
     render();
   }
 
@@ -95,11 +96,21 @@ export function createRuntimeOnboardingController({
     if (checkPromise || state.runtimeAvailability?.status === "checking") {
       return checkPromise || Promise.resolve();
     }
+    return startCatalogCheck();
+  }
+
+  function startCatalogCheck() {
+    const revision = ++checkRevision;
+    const availability = state.runtimeAvailability;
     const run = Promise.resolve()
       .then(() => reloadModels())
-      .catch((error) => catalogUnavailable(error));
+      .catch((error) => {
+        if (revision !== checkRevision) return;
+        if (availability !== state.runtimeAvailability) return;
+        catalogUnavailable(error);
+      });
     checkPromise = run.finally(() => {
-      checkPromise = null;
+      if (revision === checkRevision) checkPromise = null;
     });
     return checkPromise;
   }

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

@@ -1,6 +1,5 @@
 import { createEventRefresh } from "../lib/event-refresh.js";
 import {
-  canManageSchedule,
   matchesScheduleFilter,
   scheduleErrorMessage,
 } from "../lib/schedule-presentation.js";
@@ -120,8 +119,8 @@ export function createSchedulesController({
     return !historySettled;
   }
 
-  function shouldOpenEntryEditor(
-    openFirstEditor,
+  function shouldSelectEntryJob(
+    selectFirstJob,
     environmentChanged,
     targetJobId,
     readSelectionRevision,
@@ -131,7 +130,7 @@ export function createSchedulesController({
     if (state.editor) return false;
     if (state.mutation) return false;
     if (!active) return false;
-    if (openFirstEditor) return true;
+    if (selectFirstJob) return true;
     return environmentChanged;
   }
 
@@ -145,15 +144,8 @@ export function createSchedulesController({
     return readSelectionRevision === selectionRevision;
   }
 
-  function openEntryScheduleEditor() {
-    const job = firstVisibleJob();
-    selectJobIdentity(job?.id || "");
-    if (!canManageSchedule(job)) return;
-    state.editor = { job, environmentId: getEnvironmentId() };
-  }
-
   function reconcileLoadedSelection(
-    openEditor,
+    selectEntryJob,
     targetJobId,
     readSelectionRevision,
   ) {
@@ -162,8 +154,8 @@ export function createSchedulesController({
       return;
     }
     if (state.editor) return;
-    if (openEditor) {
-      openEntryScheduleEditor();
+    if (selectEntryJob) {
+      selectJobIdentity(firstVisibleJob()?.id || "");
       return;
     }
     const selected = state.jobs.find((job) => job.id === state.selectedId);
@@ -217,7 +209,7 @@ export function createSchedulesController({
 
   async function load({
     background = false,
-    openFirstEditor = false,
+    selectFirstJob = false,
     targetJobId = "",
     waitForHistory = false,
   } = {}) {
@@ -258,8 +250,8 @@ export function createSchedulesController({
       state.defaultModelProfileId = models.defaultProfileId || "";
       state.error = "";
       reconcileLoadedSelection(
-        shouldOpenEntryEditor(
-          openFirstEditor,
+        shouldSelectEntryJob(
+          selectFirstJob,
           environmentChanged,
           targetJobId,
           readSelectionRevision,
@@ -425,7 +417,7 @@ export function createSchedulesController({
     selectionRevision += 1;
     Object.assign(state, { query: "", filter: scheduleEntryFilter(jobId), editor: null });
     selectJobIdentity(jobId, { routeNavigation: true });
-    await load({ targetJobId: jobId });
+    await load({ targetJobId: jobId, selectFirstJob: !jobId });
   }
 
   async function openCreate(initialValues = {}) {
@@ -483,7 +475,7 @@ export function createSchedulesController({
       eventRefresh.cancel();
       nextRefreshOptions = null;
       if (active) {
-        void refresh({ background: !entering, openFirstEditor: entering });
+        void refresh({ background: !entering, selectFirstJob: entering });
         return;
       }
       loadRevision += 1;

package/dist/src/web-ui/app/controllers/spark-chat-notices.js

@@ -0,0 +1,34 @@
+function persistedAssistantMessages(snapshot) {
+  return (snapshot?.messages || []).filter((message) => message.role === "assistant" && message.id != null);
+}
+function messageIdentity(message) { return JSON.stringify([String(message.id), message.createdAt, message.requestId || null]); }
+
+export function createSparkChatNotices({ showNotice, setUnread, isVisible = () => document.visibilityState === "visible" }) {
+  let initialized = false;
+  let seen = new Set();
+  let deferredCount = 0;
+  function reconcile(snapshot, readState, { consolidated = false } = {}) {
+    const messages = persistedAssistantMessages(snapshot);
+    const fresh = messages.filter((message) => !seen.has(messageIdentity(message)));
+    seen = new Set(messages.map(messageIdentity));
+    const count = Number(readState?.unreadCount) || 0;
+    if (Number.isFinite(readState?.unreadCount)) setUnread(count);
+    if (!isVisible()) {
+      deferredCount = count;
+      initialized = true;
+      return;
+    }
+    if (!initialized || consolidated || deferredCount) {
+      initialized = true;
+      deferredCount = 0;
+      if (count) showNotice(`${count} unread ${count === 1 ? "message" : "messages"}`);
+      return;
+    }
+    if (!fresh.length) return;
+    for (const message of fresh) showNotice(String(message.text || message.content || "").slice(0, 350));
+  }
+  return {
+    reconcile,
+    reset() { initialized = false; seen.clear(); deferredCount = 0; setUnread(0); },
+  };
+}