@abot-ai/runtime 1.3.1 → 1.5.0

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

@@ -1,5 +1,13 @@
-import { captureComposerSubmissionScope, isCurrentComposerSubmissionScope } from "../lib/composer-submission-scope.js";
+import {
+  captureComposerSubmissionScope,
+  isCurrentComposerSubmissionScope,
+} from "../lib/composer-submission-scope.js";
 import { resolveComposerPrimaryAction } from "../ui-behavior.js";
+import { createComposerStopController } from "./composer-stop-controller.js";
+import {
+  hasWaitingApproval,
+  waitingRequest,
+} from "../lib/request-lifecycle-view.js";
 
 export function createComposerSubmitController({
   state,
@@ -16,6 +24,13 @@ export function createComposerSubmitController({
   onSubmissionBlocked = () => {},
   isComposerVisible = () => true,
 }) {
+  const stopping = createComposerStopController({
+    state,
+    selectedEnvironmentId,
+    setMessageStatus,
+    updateSendState,
+    stopRequest: (scope) => chatRequests.stopRequest(scope),
+  });
   function resize() {
     if (!isComposerVisible()) return;
     dom.composerInput.style.height = "auto";
@@ -31,9 +46,16 @@ export function createComposerSubmitController({
     const submissionBlock = getSubmissionBlock();
     composerActions.render({
       activeRequestId: state.activeRequestId,
+      waitingRequestId: waitingRequest(state)?.requestId,
+      stopping: stopping.isStopping(),
+      onStop: () => {
+        if (isComposerVisible()) void stopping.stop();
+      },
       attachmentCount: state.pendingAttachments.length,
       busy: state.composerSending || queueDraining,
       disabled:
+        stopping.isStopping() ||
+        hasWaitingApproval(state) ||
         Boolean(submissionBlock) ||
         !dom.composerInput.value.trim() ||
         state.composerSending ||
@@ -45,6 +67,13 @@ export function createComposerSubmitController({
 
   function dispatch(requestedAction = "") {
     if (!isComposerVisible()) return;
+    if (stopping.isStopping()) return;
+    if (hasWaitingApproval(state)) {
+      setMessageStatus(
+        "Decide or cancel the pending approval before sending a new message.",
+      );
+      return;
+    }
     const text = dom.composerInput.value.trim();
     const submissionBlock = getSubmissionBlock();
     if (text && submissionBlock) {
@@ -90,11 +119,15 @@ export function createComposerSubmitController({
           ? queue.enqueue(text)
           : chatRequests.sendMessage(text);
     const completionScope = captureComposerSubmissionScope(
-      state, selectedEnvironmentId(),
-    );
-    const isSubmissionForCurrentComposerView = () => isCurrentComposerSubmissionScope(
-      completionScope, state, selectedEnvironmentId(),
+      state,
+      selectedEnvironmentId(),
     );
+    const isSubmissionForCurrentComposerView = () =>
+      isCurrentComposerSubmissionScope(
+        completionScope,
+        state,
+        selectedEnvironmentId(),
+      );
     void operation
       .then(() => {
         if (!isSubmissionForCurrentComposerView()) return;
@@ -118,5 +151,10 @@ export function createComposerSubmitController({
       });
   }
 
-  return { dispatch, resize, updateSendState };
+  return {
+    dispatch,
+    resize,
+    updateSendState,
+    stop: () => isComposerVisible() && stopping.stop(),
+  };
 }

package/dist/src/web-ui/app/controllers/composer-workspace-controller.d.ts

@@ -49,5 +49,6 @@ export declare function createComposerWorkspaceController<T extends ComposerWork
     homeSetupHost?: HTMLElement;
     selectedEnvironmentId(): string;
     createSessionId?(): string;
+    onSessionCreated?(sessionId: string): void;
   },
 ): ComposerWorkspaceController<T>;

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

@@ -7,6 +7,7 @@ export function createComposerWorkspaceController({
   homeSetupHost,
   selectedEnvironmentId,
   createSessionId = createWebSessionId,
+  onSessionCreated = () => {},
 }) {
   const surfaces = [{
     element: dom.composerForm,
@@ -94,9 +95,9 @@ export function createComposerWorkspaceController({
   }
 
   function ensureHomeSession() {
-    if (!homeState.currentSessionId) {
-      homeState.currentSessionId = createSessionId();
-    }
+    if (homeState.currentSessionId) return homeState.currentSessionId;
+    homeState.currentSessionId = createSessionId();
+    onSessionCreated(homeState.currentSessionId);
     return homeState.currentSessionId;
   }
 

package/dist/src/web-ui/app/controllers/conversation-file-preview-controller.d.ts

@@ -0,0 +1,24 @@
+import type { FilePreviewViewState } from "../components/conversation-file-preview.js";
+export type { FilePreviewViewState } from "../components/conversation-file-preview.js";
+import type { ConversationFileReference } from "../lib/conversation-file-reference.js";
+import type { ConversationFileClient } from "../services/runtime-web-client/conversation-files.js";
+export interface ConversationFileScope {
+  environmentId: string;
+  sessionId: string;
+  activeRequestId?: string;
+}
+export declare function filePreviewErrorMessage(error: unknown): string;
+export declare function createConversationFilePreviewController(options: {
+  client: ConversationFileClient;
+  getScope: () => ConversationFileScope;
+  render: (state: FilePreviewViewState) => void;
+  AbortControllerImpl?: typeof AbortController;
+}): {
+  open(
+    reference: ConversationFileReference,
+    opener?: HTMLElement,
+  ): Promise<void>;
+  openNative(): Promise<void>;
+  close(options?: { restoreFocus?: boolean }): void;
+  syncScope(): void;
+};

package/dist/src/web-ui/app/controllers/conversation-file-preview-controller.js

@@ -0,0 +1,158 @@
+import { parseConversationFileReference } from "../lib/conversation-file-reference.js";
+
+export function filePreviewErrorMessage(error) {
+  if (error?.status === 404) return "This file is no longer available.";
+  if (error?.status === 403)
+    return "This file is outside the currently allowed folders.";
+  if (error?.code === "conversation_file_changed")
+    return "The file changed while it was being read. Open it again to view its latest contents.";
+  if (error?.code === "conversation_file_root_changed")
+    return "The file location has changed. This recorded action can no longer open it.";
+  if (error?.status === 413) return "This file is too large to preview.";
+  if (error?.status === 415) return "A preview is not available for this file.";
+  return "The file could not be loaded. Try opening it again.";
+}
+
+function hasConversationScope(scope) {
+  if (typeof scope?.environmentId !== "string" || !scope.environmentId)
+    return false;
+  return typeof scope.sessionId === "string" && Boolean(scope.sessionId);
+}
+
+function matchesConversationScope(previous, current) {
+  if (previous.environmentId !== current?.environmentId) return false;
+  return previous.sessionId === current?.sessionId;
+}
+
+function hasNewActiveRequest(previous, current) {
+  if (!current?.activeRequestId) return false;
+  return current.activeRequestId !== previous.activeRequestId;
+}
+
+export function createConversationFilePreviewController({
+  client,
+  getScope,
+  render,
+  AbortControllerImpl = globalThis.AbortController,
+}) {
+  let generation = 0;
+  let selection = null;
+  let cancellation = null;
+  let readyFile = null;
+  let nativeOpening = false;
+
+  function close({ restoreFocus = true } = {}) {
+    generation += 1;
+    cancellation?.abort();
+    cancellation = null;
+    selection = null;
+    readyFile = null;
+    nativeOpening = false;
+    render({ open: false, restoreFocus });
+  }
+
+  function ownsPendingPreview(version, scope) {
+    if (generation !== version || !selection) return false;
+    const current = getScope();
+    if (!matchesConversationScope(scope, current)) return false;
+    return !hasNewActiveRequest(scope, current);
+  }
+
+  async function open(rawReference, opener) {
+    const reference = parseConversationFileReference(rawReference);
+    const scope = { ...getScope() };
+    if (!reference || !hasConversationScope(scope)) return;
+    cancellation?.abort();
+    const version = ++generation;
+    cancellation = new AbortControllerImpl();
+    const input = {
+      environmentId: scope.environmentId,
+      sessionId: scope.sessionId,
+      requestId: reference.requestId,
+      executionId: reference.executionId,
+    };
+    selection = { scope, reference, input, version };
+    readyFile = null;
+    nativeOpening = false;
+    render({
+      open: true,
+      status: "loading",
+      opener,
+      name: reference.output.relativePath.split("/").at(-1),
+    });
+    try {
+      const response = await client.loadConversationFile({
+        ...input,
+        signal: cancellation.signal,
+      });
+      if (!ownsPendingPreview(version, scope)) return;
+      readyFile = response.file;
+      render({
+        open: true,
+        status: "ready",
+        file: response.file,
+        imageUrl:
+          response.file.kind === "image"
+            ? client.conversationFileUrl({ ...input, mode: "content" })
+            : "",
+      });
+    } catch (error) {
+      if (!ownsPendingPreview(version, scope)) return;
+      render({
+        open: true,
+        status: "error",
+        error: filePreviewErrorMessage(error),
+      });
+    }
+  }
+
+  function canOpenSelectedFileOnMac() {
+    if (!selection) return false;
+    if (readyFile?.nativeOpenAvailable !== true) return false;
+    if (typeof client.openConversationFile !== "function") return false;
+    if (nativeOpening) return false;
+    return ownsPendingPreview(selection.version, selection.scope);
+  }
+
+  async function openNative() {
+    if (!canOpenSelectedFileOnMac()) return;
+    const { scope, input, version } = selection;
+    nativeOpening = true;
+    render({ open: true, status: "native", nativeStatus: "opening" });
+    try {
+      await client.openConversationFile({
+        ...input,
+        signal: cancellation.signal,
+      });
+      if (!ownsPendingPreview(version, scope)) return;
+      render({ open: true, status: "native", nativeStatus: "opened" });
+    } catch (error) {
+      if (!ownsPendingPreview(version, scope)) return;
+      const message =
+        error?.status === 404
+          ? "This file is no longer available."
+          : "The file could not be opened on your Mac.";
+      render({
+        open: true,
+        status: "native",
+        nativeStatus: "error",
+        nativeError: message,
+      });
+    } finally {
+      if (ownsPendingPreview(version, scope)) nativeOpening = false;
+    }
+  }
+
+  function syncScope() {
+    if (!selection) return;
+    const current = getScope();
+    if (!matchesConversationScope(selection.scope, current)) {
+      close({ restoreFocus: false });
+      return;
+    }
+    if (hasNewActiveRequest(selection.scope, current))
+      close({ restoreFocus: false });
+  }
+
+  return { open, openNative, close, syncScope };
+}

package/dist/src/web-ui/app/controllers/conversation-file-preview-feature.d.ts

@@ -0,0 +1,19 @@
+import type { ConversationFileReference } from "../lib/conversation-file-reference.js";
+import type { ConversationFileClient } from "../services/runtime-web-client/conversation-files.js";
+import type { ConversationFileScope } from "./conversation-file-preview-controller.js";
+export declare function createConversationFilePreviewFeature(options: {
+  client?: ConversationFileClient;
+  getScope: () => ConversationFileScope;
+  scrollRoot: HTMLElement;
+  documentRoot: Document;
+  viewport: Window;
+}): {
+  canOpen(): boolean;
+  open?: (
+    reference: ConversationFileReference,
+    opener?: HTMLElement,
+  ) => Promise<void>;
+  reset(): void;
+  syncScope(): void;
+  setWorkspace(workspace: string): void;
+};

package/dist/src/web-ui/app/controllers/conversation-file-preview-feature.js

@@ -0,0 +1,63 @@
+import { createConversationFilePreview } from "../components/conversation-file-preview.js";
+import { createConversationFilePreviewController } from "./conversation-file-preview-controller.js";
+
+function hasFilePreviewDependencies(options) {
+  if (!options.client?.loadConversationFile) return false;
+  if (typeof options.getScope !== "function") return false;
+  return Boolean(options.scrollRoot?.parentElement);
+}
+
+function preserveConversationScroll(scrollRoot, change) {
+  const top = scrollRoot.scrollTop;
+  const left = scrollRoot.scrollLeft;
+  const bounds = scrollRoot.getBoundingClientRect();
+  const anchor = [...scrollRoot.querySelectorAll(".message-row")].find(
+    (node) => node.getBoundingClientRect().bottom > bounds.top,
+  );
+  const previousOffset = anchor?.getBoundingClientRect().top;
+  change();
+  if (anchor?.isConnected && previousOffset !== undefined) {
+    scrollRoot.scrollTop =
+      top + anchor.getBoundingClientRect().top - previousOffset;
+    scrollRoot.scrollLeft = left;
+    return;
+  }
+  scrollRoot.scrollTop = top;
+  scrollRoot.scrollLeft = left;
+}
+
+export function createConversationFilePreviewFeature(options) {
+  if (!hasFilePreviewDependencies(options)) {
+    return {
+      open: undefined,
+      canOpen: () => false,
+      reset() {},
+      syncScope() {},
+      setWorkspace() {},
+    };
+  }
+  const { client, getScope, scrollRoot, documentRoot, viewport } = options;
+  const host = scrollRoot.parentElement;
+  const view = createConversationFilePreview({
+    host,
+    documentRoot,
+    viewport,
+    onClose: () => controller.close(),
+    onOpenNative: () => controller.openNative(),
+  });
+  const controller = createConversationFilePreviewController({
+    client,
+    getScope,
+    render: (state) =>
+      preserveConversationScroll(scrollRoot, () => view.render(state)),
+  });
+  return {
+    open: controller.open,
+    canOpen: client.supportsConversationFiles,
+    reset: () => controller.close({ restoreFocus: false }),
+    syncScope: controller.syncScope,
+    setWorkspace(workspace) {
+      if (workspace !== "chat") controller.close({ restoreFocus: false });
+    },
+  };
+}

package/dist/src/web-ui/app/controllers/conversation-read-state-controller.js

@@ -14,6 +14,9 @@ function displayedAssistantReadBoundary(messages) {
   const numericId = Number(textOf(message.id).replace(/^msg-/, ""));
   const hasPersistedMessageId = Number.isSafeInteger(numericId) && numericId > 0;
   if (hasPersistedMessageId) return { readThroughMessageId: numericId };
+  const persistedId = message.persistedMessageId;
+  const hasPersistedStringId = typeof persistedId === "string" && persistedId.length > 0 && persistedId === message.id;
+  if (hasPersistedStringId) return { readThroughMessageId: persistedId };
   const requestId = textOf(message.requestId).trim();
   if (!requestId) return null;
   return {

package/dist/src/web-ui/app/controllers/conversation-session-controller.d.ts

@@ -35,6 +35,7 @@ export interface ConversationSessionState {
   contextWindowByRequest: Map<string, Record<string, unknown>>;
   submittedToolApprovalIds: Set<string>;
   requestMessages: Map<string, string>;
+  requestLifecycles?: Map<string, Record<string, unknown>>;
   lastSeqByRequest: Map<string, number>;
   sessions: ConversationSession[];
 }
@@ -43,7 +44,7 @@ export interface ConversationSessionClient {
   markSessionRead(options: {
     sessionId: string;
     environmentId: string;
-    readThroughMessageId: number | null;
+    readThroughMessageId: number | string | null;
     readThroughRequestId?: string;
   }): Promise<Record<string, unknown>>;
   listSessions(environmentId: string): Promise<Record<string, unknown>>;
@@ -99,6 +100,7 @@ export interface ConversationSessionControllerOptions {
   drainQueuedMessage(
     input: ConversationSessionScope & {
       terminalRequestId: unknown;
+      cancelled?: boolean;
     },
   ): void | Promise<void>;
   suspendQueueRecovery(): boolean;
@@ -112,6 +114,7 @@ export interface ConversationSessionControllerOptions {
   }): void;
   scheduleTask?(callback: () => void): unknown;
   createSessionId?(): string;
+  onSessionCreated?(sessionId: string): void;
 }
 
 export declare function normalizeConversationMessage(
@@ -148,7 +151,13 @@ export declare function createConversationSessionController(
   loadSessions(): Promise<ConversationSession[]>;
   markCurrentSessionReadSoon(): void;
   normalizeMessage(raw: unknown): ConversationMessage;
-  openSession(sessionId: string): Promise<void>;
+  openSession(
+    sessionId: string,
+    options?: {
+      isRouteCurrent(): boolean;
+      commitRouteNavigation(): boolean;
+    },
+  ): Promise<void>;
   requestBelongsToCurrentView(requestId: string): boolean;
   resetLiveRequestView(): void;
   restoreLastSession(): Promise<void>;

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

@@ -4,18 +4,33 @@ import { normalizeScheduleReference } from "../lib/schedule-message.js";
 import { createWebSessionId, escapeHtml, textOf } from "../lib/text-format.js";
 import { insertRequestUserMessageBeforeAssistant } from "../ui-behavior.js";
 import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
+import { sparkProposalId } from "../lib/spark-proposal-message.js";
+import {
+  isStoppedRequest,
+  restoreStoppedResponses,
+} from "../lib/request-stop-state.js";
+import {
+  isApprovalPresentation,
+  requestLifecycles,
+  rememberRequestLifecycle,
+  sameConversationMessage,
+} from "../lib/request-lifecycle-view.js";
 
 export function normalizeConversationMessage(raw, fallbackIndex = 0) {
   const message =
     raw?.message && typeof raw.message === "object" ? raw.message : raw;
   return {
     id: textOf(message?.id) || `local-${fallbackIndex + 1}`,
+    persistedMessageId: message?.id ?? null,
+    kind: textOf(message?.kind),
+    approvalRequest: message?.approvalRequest,
     role: textOf(message?.role, "assistant"),
     text: textOf(message?.text ?? message?.content ?? message?.output),
     createdAt: message?.createdAt || Date.now(),
     requestId: textOf(message?.requestId),
     streaming: false,
     schedule: normalizeScheduleReference(message?.schedule),
+    sparkProposalId: sparkProposalId(message),
     events: Array.isArray(message?.events)
       ? message.events.map((event) => textOf(event)).filter(Boolean)
       : [],
@@ -54,6 +69,7 @@ export function createConversationSessionController({
   onSessionListState = () => {},
   scheduleTask = (callback) => window.setTimeout(callback, 0),
   createSessionId = createWebSessionId,
+  onSessionCreated = () => {},
 }) {
   let environmentLoadRevision = 0;
   let sessionListRevision = 0;
@@ -85,15 +101,9 @@ export function createConversationSessionController({
   function addOrMergeMessage(message) {
     const id = textOf(message.id);
     const requestId = textOf(message.requestId);
-    const existingIndex = state.messages.findIndex((item) => {
-      if (id && item.id === id) return true;
-      return Boolean(
-        requestId &&
-        item.requestId === requestId &&
-        item.role === message.role &&
-        item.role === "assistant",
-      );
-    });
+    const existingIndex = state.messages.findIndex((item) =>
+      sameConversationMessage(item, message),
+    );
     if (existingIndex >= 0) {
       state.messages[existingIndex] = {
         ...state.messages[existingIndex],
@@ -105,7 +115,11 @@ export function createConversationSessionController({
     } else {
       state.messages.push(message);
     }
-    if (requestId && message.role === "assistant") {
+    if (
+      requestId &&
+      message.role === "assistant" &&
+      !isApprovalPresentation(message)
+    ) {
       state.requestMessages.set(requestId, message.id);
     }
   }
@@ -115,7 +129,7 @@ export function createConversationSessionController({
     const existing = state.messages.find(
       (message) => message.id === existingId,
     );
-    if (existing) return existing;
+    if (existing && !isApprovalPresentation(existing)) return existing;
 
     const message = {
       id: `assistant-${requestId}`,
@@ -140,6 +154,7 @@ export function createConversationSessionController({
     conversationView.reset();
     state.submittedToolApprovalIds.clear();
     state.requestMessages.clear();
+    requestLifecycles(state).clear();
     state.sessionViewVersion += 1;
     setMessageStatus("");
     updateComposerSendState();
@@ -167,7 +182,8 @@ export function createConversationSessionController({
   function requestBelongsToCurrentView(requestId) {
     if (!requestId) return true;
     return Boolean(
-      state.activeRequestId && requestId === state.activeRequestId,
+      requestLifecycles(state).has(requestId) ||
+      (state.activeRequestId && requestId === state.activeRequestId),
     );
   }
 
@@ -220,7 +236,9 @@ export function createConversationSessionController({
       if (hydrateRequestIds.has(requestId)) continue;
       const assistant = state.messages.find(
         (message) =>
-          message.role === "assistant" && message.requestId === requestId,
+          message.role === "assistant" &&
+          message.requestId === requestId &&
+          !isApprovalPresentation(message),
       );
       if (assistant) assistant.thinkingText = thinkingText;
     }
@@ -268,6 +286,9 @@ export function createConversationSessionController({
       sessionId,
       environment: selectedEnvironmentId(),
     });
+    const hasActiveRequestInSession =
+      sessionId === state.currentSessionId && Boolean(state.activeRequestId);
+    if (hasActiveRequestInSession) resumeRequest(state.activeRequestId);
   }
 
   function subscribeRequest(requestId) {
@@ -390,7 +411,22 @@ export function createConversationSessionController({
     if (targetSession?.id) await openSession(targetSession.id);
   }
 
-  async function openSession(sessionId) {
+  async function openSession(
+    sessionId,
+    { isRouteCurrent, commitRouteNavigation } = {},
+  ) {
+    const routeOwned = typeof commitRouteNavigation === "function";
+    let payload;
+    if (routeOwned) {
+      const environmentId = selectedEnvironmentId();
+      const viewVersion = state.sessionViewVersion;
+      const currentSessionId = state.currentSessionId;
+      payload = await client.loadSession(sessionId, environmentId);
+      if (environmentId !== selectedEnvironmentId()) return;
+      if (viewVersion !== state.sessionViewVersion) return;
+      if (currentSessionId !== state.currentSessionId) return;
+      if (isRouteCurrent?.() !== true) return;
+    }
     if (
       state.currentSessionId &&
       state.currentSessionId !== sessionId &&
@@ -398,6 +434,7 @@ export function createConversationSessionController({
     ) {
       return;
     }
+    if (routeOwned && commitRouteNavigation() !== true) return;
     const viewVersion = state.sessionViewVersion + 1;
     state.currentSessionId = sessionId;
     preferences.saveSessionIdForEnvironment(selectedEnvironmentId(), sessionId);
@@ -414,10 +451,9 @@ export function createConversationSessionController({
     renderMessages();
     subscribeSession(sessionId);
 
-    const payload = await client.loadSession(
-      sessionId,
-      selectedEnvironmentId(),
-    );
+    if (!routeOwned) {
+      payload = await client.loadSession(sessionId, selectedEnvironmentId());
+    }
     if (
       state.currentSessionId !== sessionId ||
       state.sessionViewVersion !== viewVersion
@@ -432,11 +468,17 @@ export function createConversationSessionController({
     sessions.applyTitle(sessionId, payload.title);
     sessions.applyReadState(sessionId, payload.readState);
     for (const message of state.messages) {
-      if (message.role === "assistant" && message.requestId) {
+      if (
+        message.role === "assistant" &&
+        message.requestId &&
+        !isApprovalPresentation(message)
+      ) {
         state.requestMessages.set(message.requestId, message.id);
       }
     }
     const requests = Array.isArray(payload.requests) ? payload.requests : [];
+    for (const request of requests)
+      rememberRequestLifecycle(state, request.lifecycle);
     applyConversationChrome();
     renderSessions();
     const streamingRequestIds = new Set(
@@ -464,6 +506,7 @@ export function createConversationSessionController({
     for (const requestId of streamingRequestIds) {
       activeAssistantForRequest(requestId);
     }
+    restoreStoppedResponses(state.messages, requests);
     restoreSessionEventState(requests, streamingRequestIds);
     for (const request of requests) {
       if (request.status === "streaming" && request.requestId) {
@@ -492,6 +535,7 @@ export function createConversationSessionController({
         await drainQueuedMessage({
           ...scope,
           terminalRequestId: terminal.requestId,
+          cancelled: isStoppedRequest(terminal),
         });
       }
     }
@@ -502,6 +546,7 @@ export function createConversationSessionController({
   function ensureSession() {
     if (state.currentSessionId) return state.currentSessionId;
     state.currentSessionId = createSessionId();
+    onSessionCreated(state.currentSessionId);
     preferences.saveSessionIdForEnvironment(
       selectedEnvironmentId(),
       state.currentSessionId,