@abot-ai/runtime 1.1.0 → 1.3.0

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

@@ -26,6 +26,8 @@ export interface RealtimeEventControllerOptions {
     message: RealtimeEventRecord,
   ): ConversationSessionMessage;
   renderMessages(): void;
+  renderContextWindow?(): void;
+  renderActivityStatus?(): void;
   scheduleMessageRender(): void;
   scheduleThinkingRender(): void;
   cancelScheduledMessageRender(): void;

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

@@ -1,28 +1,46 @@
+import { createScheduleRealtimeController } from "./schedule-realtime.js";
 import { isMatchingActiveRequest } from "../ui-behavior.js";
 import {
   eventKeyFor,
   eventTone,
   formatEventDetail,
   formatEventLabel,
-  getPlanItemPayload,
-  getPlanPayload,
-  getRecord,
   isLowValueActivityEvent,
 } from "../lib/event-presentation.js";
 import { textOf } from "../lib/text-format.js";
 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";
 
 export { normalizeRealtimeMessage } from "../lib/realtime-message.js";
+export { taskStatusClass } from "../lib/task-progress.js";
 
-export function taskStatusClass(status) {
-  const normalized = textOf(status).trim().toLowerCase();
-  if (normalized === "done" || normalized === "completed") return "done";
-  if (normalized === "in_progress" || normalized === "active") {
-    return "active";
-  }
-  if (normalized === "blocked" || normalized === "failed") return "failed";
-  if (normalized === "superseded") return "muted";
-  return "pending";
+function hasOriginalEventSequence(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+function hasRecordedOriginalEvent(events, requestId, eventSequence) {
+  if (eventSequence === undefined) return false;
+  return events.some(
+    (event) =>
+      event.requestId === requestId && event.eventSequence === eventSequence,
+  );
+}
+
+function canMergeUnsequencedActivity(
+  previous,
+  key,
+  eventSequence,
+  webSources,
+  toolActivity,
+) {
+  if (eventSequence !== undefined) return false;
+  if (webSources || previous?.webSources) return false;
+  if (toolActivity || previous?.toolActivity) return false;
+  if (!previous?.key || previous.key !== key) return false;
+  return !hasOriginalEventSequence(previous.eventSequence);
 }
 
 export function createRealtimeEventController({
@@ -36,6 +54,8 @@ export function createRealtimeEventController({
   addOrMergeMessage,
   normalizeChatMessage,
   renderMessages,
+  renderContextWindow = () => {},
+  renderActivityStatus = () => {},
   scheduleMessageRender,
   scheduleThinkingRender,
   cancelScheduledMessageRender,
@@ -48,82 +68,31 @@ export function createRealtimeEventController({
   drainQueuedComposerMessage,
   loadSessions,
 }) {
+  const scheduleRealtime = createScheduleRealtimeController({
+    state,
+    selectedEnvironmentId,
+    addOrMergeMessage,
+    normalizeChatMessage,
+    activeAssistantForRequest,
+    renderMessages,
+    updateComposerSendState,
+    setMessageActivityStatus,
+    trackSeq,
+    loadSessions,
+  });
+
   function trackSeq(message) {
     if (message.requestId && typeof message.seqNo === "number") {
       state.lastSeqByRequest.set(message.requestId, message.seqNo);
     }
   }
 
-  function mergeTaskProgressItem(items, nextItem) {
-    const normalizedTitle = nextItem.title.trim().toLowerCase();
-    const normalizedId = nextItem.id.trim();
-    const existingIndex = items.findIndex((item) => {
-      if (normalizedId && item.id === normalizedId) return true;
-      return item.title.trim().toLowerCase() === normalizedTitle;
-    });
-    if (existingIndex < 0) {
-      items.push(nextItem);
-      return;
-    }
-    items[existingIndex] = {
-      ...items[existingIndex],
-      ...nextItem,
-      id: nextItem.id || items[existingIndex].id,
-      title: nextItem.title || items[existingIndex].title,
-      status: nextItem.status || items[existingIndex].status,
-    };
-  }
-
   function updateTaskProgress(message) {
-    const plan = getPlanPayload(message);
-    const item = getPlanItemPayload(message);
-    const snapshot = getRecord(message.progressSnapshot);
-    const planningSignal =
-      Boolean(plan || item || snapshot) ||
-      textOf(message.name).startsWith("Planner ") ||
-      textOf(message.name).startsWith("Development progress:");
-    if (!planningSignal) return;
-    const requestId = textOf(message.requestId) || state.activeRequestId;
-    if (!requestId) return;
-    const current = state.taskProgressByRequest.get(requestId) || {
-      requestId,
-      summary: "",
-      total: 0,
-      completed: 0,
-      requestSatisfaction: "",
-      items: [],
-      hasSignal: false,
-    };
-    const next = {
-      ...current,
-      requestId,
-      summary:
-        plan?.summary || textOf(snapshot?.summary) || current.summary || "",
-      total: plan?.total ?? current.total,
-      completed: plan?.completed ?? current.completed,
-      requestSatisfaction:
-        textOf(snapshot?.requestSatisfaction) || current.requestSatisfaction,
-      items: [...current.items],
-      hasSignal: true,
-    };
-    for (const planItem of plan?.items || [])
-      mergeTaskProgressItem(next.items, planItem);
-    if (item) mergeTaskProgressItem(next.items, item);
-    if (!next.summary && Array.isArray(snapshot?.requestedWork)) {
-      next.summary =
-        snapshot.requestedWork.map(textOf).filter(Boolean)[0] || "";
-    }
-    if (!next.total && next.items.length > 0) next.total = next.items.length;
-    if (next.items.length > 0) {
-      next.completed = Math.max(
-        next.completed,
-        next.items.filter((entry) => entry.status === "done").length,
-      );
-    }
-    next.activeItem =
-      next.items.find((entry) => taskStatusClass(entry.status) === "active")
-        ?.title || "";
-    state.taskProgressByRequest.set(requestId, next);
+    const requestId = textOf(message.requestId);
+    const current = state.taskProgressByRequest.get(requestId);
+    const next = reduceTaskProgress(current, message);
+    if (next && next !== current)
+      state.taskProgressByRequest.set(requestId, next);
   }
 
   function updateContextWindow(message) {
@@ -136,6 +105,7 @@ export function createRealtimeEventController({
       providerUsage: null,
       pendingCompaction: null,
       lastCompaction: null,
+      lastCompactionEvent: null,
     };
     if (eventName === "context.window.snapshot") {
       const contextWindowTokens = Number(message.contextWindowTokens);
@@ -152,8 +122,11 @@ export function createRealtimeEventController({
         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),
@@ -195,13 +168,17 @@ export function createRealtimeEventController({
         lastCompaction,
         pendingCompaction: lastCompaction ? null : current.pendingCompaction,
       });
-      return;
+      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),
@@ -211,46 +188,86 @@ export function createRealtimeEventController({
           totalTokens: Number(message.totalTokens),
         },
       });
-      return;
+      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))
+          beforePercent: Number.isFinite(
+            Number(message.beforeUsedContextPercent),
+          )
             ? Number(message.beforeUsedContextPercent)
             : current.snapshot?.usedContextPercent,
         },
       });
-      return;
+      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;
+      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;
     }
   }
 
   function recordEvent(message) {
+    const requestId = textOf(message.requestId) || state.activeRequestId;
+    const eventSequence = hasOriginalEventSequence(message.eventSequence)
+      ? message.eventSequence
+      : undefined;
+    if (hasRecordedOriginalEvent(state.events, requestId, eventSequence)) {
+      trackSeq(message);
+      return;
+    }
     updateTaskProgress(message);
-    updateContextWindow(message);
+    const contextWindowUpdated = updateContextWindow(message);
+    if (contextWindowUpdated) {
+      renderContextWindow();
+      renderActivityStatus();
+    }
     const eventName = textOf(message.name || message.rawType || message.type);
     if (isLowValueActivityEvent(message)) {
       trackSeq(message);
@@ -259,10 +276,21 @@ export function createRealtimeEventController({
     const name = formatEventLabel(message);
     const summary = formatEventDetail(message);
     const tone = eventTone(message);
-    const key = eventKeyFor(message, name, tone);
-    const requestId = textOf(message.requestId) || state.activeRequestId;
+    const stage = textOf(message.stage);
+    const phase = textOf(message.phase);
+    const key = eventKeyFor({ ...message, requestId }, name, tone);
+    const webSources = projectWebSourceEvent(message);
+    const toolActivity = projectToolActivityEvent(message);
     const lastEvent = state.events[state.events.length - 1];
-    if (lastEvent?.key && lastEvent.key === key) {
+    if (
+      canMergeUnsequencedActivity(
+        lastEvent,
+        key,
+        eventSequence,
+        webSources,
+        toolActivity,
+      )
+    ) {
       lastEvent.count = (lastEvent.count || 1) + 1;
       lastEvent.summary = summary;
       lastEvent.updatedAt = Date.now();
@@ -278,15 +306,20 @@ export function createRealtimeEventController({
         count: 1,
         lastSeqNo:
           typeof message.seqNo === "number" ? message.seqNo : undefined,
+        eventSequence,
         updatedAt: Date.now(),
         type: message.type,
         rawType: message.rawType,
         eventName,
+        stage,
+        phase,
         name,
         summary,
         tone,
         tool: textOf(message.tool),
         approvalId: textOf(message.approvalId),
+        ...(webSources ? { webSources } : {}),
+        ...(toolActivity ? { toolActivity } : {}),
         payload: {
           plan: message.plan,
           item: message.item,
@@ -298,6 +331,7 @@ export function createRealtimeEventController({
       state.events.splice(0, state.events.length - 1_200);
     }
     trackSeq(message);
+    renderActivityStatus();
     scheduleMessageRender();
     if (eventName.startsWith("tool.approval.")) renderMessages();
   }
@@ -351,6 +385,7 @@ export function createRealtimeEventController({
     const message = normalizeRealtimeMessage(rawMessage);
     if (message.type === "steer_ack" && handleSteerAcknowledgement(message))
       return;
+    if (scheduleRealtime.handle(message)) return;
     if (!shouldAcceptMessage(message)) return;
     if (message.type === "chat_read_state") {
       applySessionReadState(message.sessionId, message.readState || message);
@@ -412,6 +447,7 @@ export function createRealtimeEventController({
       }
       cancelScheduledMessageRender();
       recordEvent(message);
+      renderActivityStatus();
       cancelScheduledThinkingRender();
       renderMessages();
       setMessageActivityStatus("ABot response completed.");

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

@@ -146,6 +146,7 @@ export interface RuntimeSelectionControllerDependencies {
     summary: string;
   }) => void;
   readonly onAttachmentPolicyChange: () => void;
+  readonly getComposerSessionId?: () => string;
   readonly onModelCatalogLoading?: () => void;
   readonly onModelCatalogLoaded?: (payload: Record<string, unknown>) => void;
   readonly onModelCatalogUnavailable?: (error: unknown) => void;
@@ -171,7 +172,7 @@ export declare function createRuntimeSelectionController(
   saveModelPreferences(): void;
   selectedEnvironmentId(): string;
   selectedModelPreference(): Record<string, unknown> | null;
-  selectedModelSupportsImageInput(): boolean;
+  selectedModelSupportsImageInput(profileId?: string): boolean;
   setAgentMode(mode: AgentMode): Promise<boolean>;
   setToolPermissionMode(mode: ToolPermissionMode): void;
 };

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

@@ -52,6 +52,7 @@ export function createRuntimeSelectionController({
   client,
   recordControlEvent,
   onAttachmentPolicyChange,
+  getComposerSessionId = () => state.currentSessionId,
   onModelCatalogLoading = () => {},
   onModelCatalogLoaded = () => {},
   onModelCatalogUnavailable = () => {},
@@ -144,12 +145,12 @@ export function createRuntimeSelectionController({
 
   const selectedModelPreference = () =>
     dom.modelSelect.value ? { profileId: dom.modelSelect.value } : null;
-  const selectedModelProfile = () =>
+  const selectedModelProfile = (profileId = dom.modelSelect.value) =>
     state.modelProfiles.find(
-      (profile) => profile.id === textOf(dom.modelSelect.value),
+      (profile) => profile.id === textOf(profileId),
     ) || null;
-  function selectedModelSupportsImageInput() {
-    const profile = selectedModelProfile();
+  function selectedModelSupportsImageInput(profileId = dom.modelSelect.value) {
+    const profile = selectedModelProfile(profileId);
     if (typeof profile?.supportsImageInput === "boolean")
       return profile.supportsImageInput;
     const inputModalities = profile?.capabilities?.inputModalities;
@@ -176,7 +177,7 @@ export function createRuntimeSelectionController({
       state.lastModelByEnvironment,
     );
   const preferredModel = () =>
-    textOf(state.sessionModels[state.currentSessionId]) ||
+    textOf(state.sessionModels[getComposerSessionId()]) ||
     textOf(state.lastModelByEnvironment[selectedEnvironmentId()]);
 
   function applyModelSelection() {
@@ -201,8 +202,8 @@ export function createRuntimeSelectionController({
     const profileId = textOf(dom.modelSelect.value);
     if (!profileId) return;
     state.lastModelByEnvironment[selectedEnvironmentId()] = profileId;
-    if (state.currentSessionId)
-      state.sessionModels[state.currentSessionId] = profileId;
+    if (getComposerSessionId())
+      state.sessionModels[getComposerSessionId()] = profileId;
     saveModelPreferences();
   }
 
@@ -212,8 +213,8 @@ export function createRuntimeSelectionController({
   };
   const currentToolPermissionMode = () =>
     normalizeToolPermissionMode(
-      state.currentSessionId
-        ? sessionModeFor(state.currentSessionId).toolPermissionMode
+      getComposerSessionId()
+        ? sessionModeFor(getComposerSessionId()).toolPermissionMode
         : undefined,
     );
 
@@ -224,13 +225,13 @@ export function createRuntimeSelectionController({
   }
 
   function setToolPermissionMode(mode) {
-    if (!state.currentSessionId) return;
+    if (!getComposerSessionId()) return;
     const normalized = normalizeToolPermissionMode(mode);
     if (normalized === "full_access")
-      delete state.sessionModes[state.currentSessionId];
+      delete state.sessionModes[getComposerSessionId()];
     else {
-      state.sessionModes[state.currentSessionId] = {
-        ...sessionModeFor(state.currentSessionId),
+      state.sessionModes[getComposerSessionId()] = {
+        ...sessionModeFor(getComposerSessionId()),
         toolPermissionMode: normalized,
         savedAt: Date.now(),
       };
@@ -246,7 +247,7 @@ export function createRuntimeSelectionController({
     const meta = permissionMeta(mode);
     dom.permissionModeButton.innerHTML = `<span class="permission-mode-label">${escapeHtml(meta.label)}</span>`;
     dom.permissionModeButton.title = meta.title;
-    dom.permissionModeButton.disabled = !state.currentSessionId;
+    dom.permissionModeButton.disabled = !getComposerSessionId();
     dom.permissionModeButton.classList.toggle("full", mode === "full_access");
     dom.permissionModeButton.classList.toggle(
       "open",
@@ -285,6 +286,8 @@ export function createRuntimeSelectionController({
 
   function renderAgentMode() {
     const meta = agentModeMeta(state.agentMode);
+    dom.agentModeButton.title = `Reasoning depth: ${meta.label}`;
+    dom.agentModeButton.setAttribute("aria-label", `Reasoning depth: ${meta.label}`);
     dom.agentModeButton.disabled = agentModeMutationInFlight;
     dom.agentModeButton.innerHTML = `
       <span class="agent-mode-icon">${escapeHtml(meta.icon)}</span>