@abot-ai/runtime 1.2.0 → 1.3.1

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

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

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

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

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

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

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

@@ -1,3 +1,4 @@
+import { createScheduleRealtimeController } from "./schedule-realtime.js";
 import { isMatchingActiveRequest } from "../ui-behavior.js";
 import {
   eventKeyFor,
@@ -10,6 +11,8 @@ 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";
@@ -26,9 +29,16 @@ function hasRecordedOriginalEvent(events, requestId, eventSequence) {
   );
 }
 
-function canMergeUnsequencedActivity(previous, key, eventSequence, webSources) {
+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);
 }
@@ -45,6 +55,7 @@ export function createRealtimeEventController({
   normalizeChatMessage,
   renderMessages,
   renderContextWindow = () => {},
+  renderActivityStatus = () => {},
   scheduleMessageRender,
   scheduleThinkingRender,
   cancelScheduledMessageRender,
@@ -57,6 +68,19 @@ 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);
@@ -81,6 +105,7 @@ export function createRealtimeEventController({
       providerUsage: null,
       pendingCompaction: null,
       lastCompaction: null,
+      lastCompactionEvent: null,
     };
     if (eventName === "context.window.snapshot") {
       const contextWindowTokens = Number(message.contextWindowTokens);
@@ -97,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),
@@ -143,10 +171,14 @@ export function createRealtimeEventController({
       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),
@@ -159,9 +191,18 @@ export function createRealtimeEventController({
       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),
@@ -173,11 +214,19 @@ export function createRealtimeEventController({
       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)
@@ -187,9 +236,17 @@ export function createRealtimeEventController({
       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;
@@ -207,7 +264,10 @@ export function createRealtimeEventController({
     }
     updateTaskProgress(message);
     const contextWindowUpdated = updateContextWindow(message);
-    if (contextWindowUpdated) renderContextWindow();
+    if (contextWindowUpdated) {
+      renderContextWindow();
+      renderActivityStatus();
+    }
     const eventName = textOf(message.name || message.rawType || message.type);
     if (isLowValueActivityEvent(message)) {
       trackSeq(message);
@@ -220,9 +280,16 @@ export function createRealtimeEventController({
     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 (
-      canMergeUnsequencedActivity(lastEvent, key, eventSequence, webSources)
+      canMergeUnsequencedActivity(
+        lastEvent,
+        key,
+        eventSequence,
+        webSources,
+        toolActivity,
+      )
     ) {
       lastEvent.count = (lastEvent.count || 1) + 1;
       lastEvent.summary = summary;
@@ -252,6 +319,7 @@ export function createRealtimeEventController({
         tool: textOf(message.tool),
         approvalId: textOf(message.approvalId),
         ...(webSources ? { webSources } : {}),
+        ...(toolActivity ? { toolActivity } : {}),
         payload: {
           plan: message.plan,
           item: message.item,
@@ -263,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();
   }
@@ -316,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);
@@ -377,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",

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

@@ -0,0 +1,118 @@
+import { normalizeScheduleReference } from "../lib/schedule-message.js";
+import { textOf } from "../lib/text-format.js";
+
+export function isScheduleTriggerForConversation(
+  message,
+  sessionId,
+  environmentId,
+) {
+  if (!sessionId || message.sessionId !== sessionId) return false;
+  return isScheduleTriggerInEnvironment(message, environmentId);
+}
+
+function isScheduleTriggerInEnvironment(message, environmentId) {
+  if (!textOf(message.sessionId)) return false;
+  if (textOf(message.environment || message.environmentId) !== environmentId)
+    return false;
+  if (!textOf(message.requestId) || !textOf(message.messageId)) return false;
+  return Boolean(normalizeScheduleReference(message.schedule));
+}
+
+export function createScheduleRealtimeController({
+  state,
+  selectedEnvironmentId,
+  addOrMergeMessage,
+  normalizeChatMessage,
+  activeAssistantForRequest,
+  renderMessages,
+  updateComposerSendState,
+  setMessageActivityStatus,
+  trackSeq,
+  loadSessions,
+}) {
+  const scheduledRequests = new Map();
+
+  function hasRecordedTrigger(message) {
+    return (state.messages || []).some(
+      (item) => item.schedule?.runId === message.schedule.runId,
+    );
+  }
+
+  function hasDifferentActiveRequest(requestId) {
+    if (!state.activeRequestId) return false;
+    return state.activeRequestId !== requestId;
+  }
+
+  function isForegroundScheduledRequest(message) {
+    if (message.sessionId !== state.currentSessionId) return false;
+    return message.requestId === state.activeRequestId;
+  }
+
+  function scheduledTerminalScope(message) {
+    const tracked = scheduledRequests.get(message.requestId);
+    if (tracked) return tracked;
+    if (message.requestOrigin !== "schedule") return undefined;
+    const environmentId = textOf(message.environment || message.environmentId);
+    if (!environmentId.trim()) return undefined;
+    if (!textOf(message.requestId).trim()) return undefined;
+    if (!textOf(message.sessionId).trim()) return undefined;
+    return { sessionId: message.sessionId, environmentId };
+  }
+
+  function handleScheduledTerminal(message) {
+    if (message.type !== "completed" && message.type !== "failed") return false;
+    const scope = scheduledTerminalScope(message);
+    if (!scope) return message.requestOrigin === "schedule";
+    if (message.sessionId !== scope.sessionId) return true;
+    const environmentId =
+      textOf(message.environment || message.environmentId) ||
+      scope.environmentId;
+    if (environmentId !== scope.environmentId) return true;
+    scheduledRequests.delete(message.requestId);
+    if (environmentId !== selectedEnvironmentId()) return true;
+    if (message.sessionDeleted === true) return true;
+    if (isForegroundScheduledRequest(message)) return false;
+    void loadSessions();
+    return true;
+  }
+
+  function handle(message) {
+    if (handleScheduledTerminal(message)) return true;
+    if (message.type !== "event" || message.name !== "schedule.triggered")
+      return false;
+    if (!isScheduleTriggerInEnvironment(message, selectedEnvironmentId()))
+      return true;
+    if (message.sessionDeleted === true) return true;
+    scheduledRequests.set(message.requestId, {
+      sessionId: message.sessionId,
+      environmentId: selectedEnvironmentId(),
+    });
+    if (hasRecordedTrigger(message)) return true;
+    if (
+      !isScheduleTriggerForConversation(
+        message,
+        state.currentSessionId,
+        selectedEnvironmentId(),
+      )
+    )
+      return true;
+    if (hasDifferentActiveRequest(message.requestId)) return true;
+    const userMessage = normalizeChatMessage({
+      id: message.messageId,
+      role: "user",
+      requestId: message.requestId,
+      text: message.text,
+      createdAt: message.createdAt,
+      schedule: message.schedule,
+    });
+    addOrMergeMessage(userMessage);
+    state.activeRequestId = message.requestId;
+    activeAssistantForRequest(message.requestId);
+    trackSeq(message);
+    renderMessages();
+    updateComposerSendState();
+    setMessageActivityStatus("Scheduled task is running.", true);
+    return true;
+  }
+  return { handle };
+}