@abot-ai/runtime 1.0.0 → 1.1.0

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

@@ -0,0 +1,109 @@
+import type {
+  SessionComposerAttachmentRef,
+  SessionComposerModelPreference,
+  SessionComposerQueue,
+} from "../lib/session-composer-queue.js";
+
+export type ComposerScope = Readonly<{
+  environmentId: string;
+  sessionId: string;
+}>;
+
+export type ComposerQueueDrainScope = ComposerScope &
+  Readonly<{ terminalRequestId: string }>;
+
+export interface ComposerQueueRecovery {
+  scope: ComposerScope;
+  releaseToken: string;
+}
+
+export interface ComposerQueueMessage {
+  id?: string;
+  role?: string;
+  text?: string;
+  createdAt?: unknown;
+  requestId?: string;
+  streaming?: boolean;
+}
+
+export interface ComposerQueueState {
+  activeRequestId: string;
+  agentMode: string;
+  currentSessionId: string;
+  pendingAttachments: SessionComposerAttachmentRef[];
+  composerQueueDrainingScopes: Set<string>;
+  composerQueueRecoveredReleaseTokens: Set<string>;
+  activeComposerQueueRecovery: ComposerQueueRecovery | null;
+  messages: ComposerQueueMessage[];
+}
+
+export interface ComposerQueueDom {
+  composerInput: {
+    value: string;
+  };
+}
+
+export interface ComposerQueueAttachments {
+  clear(options?: { cleanup?: boolean }): void;
+  invalidateCompletions(): void;
+  render(): void;
+}
+
+export interface ComposerQueuePostChatRequest {
+  text: string;
+  attachments: SessionComposerAttachmentRef[];
+  environmentId: string;
+  sessionId: string;
+  agentMode: string;
+  toolPermissionMode: string;
+  modelPreference: SessionComposerModelPreference | null;
+}
+
+export interface ComposerQueueControlEvent {
+  type: "control";
+  name: string;
+  tone: "failed";
+  summary: string;
+}
+
+export interface ComposerQueueControllerOptions {
+  state: ComposerQueueState;
+  dom: ComposerQueueDom;
+  queue: SessionComposerQueue;
+  selectedEnvironmentId: () => string;
+  getToolPermissionMode: () => string;
+  getModelPreference: () => SessionComposerModelPreference | null;
+  rememberModelSelection: () => void;
+  attachments: ComposerQueueAttachments;
+  updateSendState: () => void;
+  postChatMessage: (request: ComposerQueuePostChatRequest) => Promise<string>;
+  appendLocalUserMessage: (message: {
+    text: string;
+    attachments: SessionComposerAttachmentRef[];
+    requestId: string;
+  }) => void;
+  activateRequestForScope: (scope: ComposerScope, requestId: string) => void;
+  renderMessages: () => void;
+  setMessageStatus: (message: string, busy?: boolean) => void;
+  recordControlEvent: (event: ComposerQueueControlEvent) => void;
+  resizeComposer: () => void;
+}
+
+export interface ComposerQueueController {
+  clearRecovery(scope: ComposerScope): void;
+  currentScope(): ComposerScope;
+  drain(scope: ComposerQueueDrainScope): Promise<void>;
+  enqueue(text: string): Promise<void>;
+  isCurrentDraining(): boolean;
+  isCurrentScope(scope: ComposerScope): boolean;
+  queuedCount(): number;
+  recoverForManualSend(scope: ComposerScope): boolean;
+  reportFailure(scope: ComposerScope, summary: string): void;
+  restoreText(text: string, scope: ComposerScope): void;
+  scopeKey(scope: ComposerScope): string;
+  suspendRecoveryForNavigation(): boolean;
+}
+
+export declare function createComposerQueueController(
+  options: ComposerQueueControllerOptions,
+): ComposerQueueController;

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

@@ -0,0 +1,77 @@
+import type { ComposerScope } from "./composer-queue-controller.js";
+
+export interface ComposerSubmissionBlock {
+  code: string;
+  message: string;
+}
+
+export interface ComposerSubmitState {
+  activeRequestId: string;
+  pendingAttachments: readonly unknown[];
+  composerSending: boolean;
+  currentSessionId: string;
+}
+
+export interface ComposerSubmitDom {
+  composerInput: {
+    value: string;
+    scrollHeight: number;
+    style: { height: string };
+    focus(): void;
+  };
+}
+
+export interface ComposerSubmitActions {
+  primaryAction(): string;
+  render(options: {
+    activeRequestId: string;
+    attachmentCount: number;
+    busy: boolean;
+    disabled: boolean;
+    queuedCount: number;
+  }): void;
+}
+
+export interface ComposerSubmitAttachments {
+  activeUploadCount(): number;
+}
+
+export interface ComposerSubmitQueue {
+  enqueue(text: string): Promise<void>;
+  isCurrentDraining(): boolean;
+  queuedCount(): number;
+  restoreText(text: string, scope: ComposerScope): void;
+}
+
+export interface ComposerSubmitChatRequests {
+  sendMessage(text: string): Promise<void>;
+}
+
+export interface ComposerSubmitConversationSession {
+  appendRequestError(error: unknown): void;
+}
+
+export interface ComposerSubmitControllerOptions {
+  state: ComposerSubmitState;
+  dom: ComposerSubmitDom;
+  composerActions: ComposerSubmitActions;
+  attachments: ComposerSubmitAttachments;
+  queue: ComposerSubmitQueue;
+  steer: (text: string) => Promise<void>;
+  chatRequests: ComposerSubmitChatRequests;
+  conversationSession: ComposerSubmitConversationSession;
+  selectedEnvironmentId: () => string;
+  setMessageStatus: (message: string, busy?: boolean) => void;
+  getSubmissionBlock?: () => ComposerSubmissionBlock | null;
+  onSubmissionBlocked?: (block: ComposerSubmissionBlock) => void;
+}
+
+export interface ComposerSubmitController {
+  dispatch(requestedAction?: string): void;
+  resize(): void;
+  updateSendState(): void;
+}
+
+export declare function createComposerSubmitController(
+  options: ComposerSubmitControllerOptions,
+): ComposerSubmitController;

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

@@ -0,0 +1,149 @@
+export type ConversationSessionMessage = Record<string, unknown> & {
+  id: string;
+  role: string;
+  text: string;
+  createdAt?: unknown;
+  requestId: string;
+  streaming?: boolean;
+  thinkingText?: string;
+  events?: string[];
+  attachments?: unknown[];
+};
+
+export type ConversationMessage = ConversationSessionMessage & {
+  events: string[];
+  attachments: unknown[];
+};
+
+export type ConversationSession = Record<string, unknown> & {
+  id?: string;
+};
+
+export type ConversationSessionScope = Readonly<{
+  environmentId: string;
+  sessionId: string;
+}>;
+
+export interface ConversationSessionState {
+  currentSessionId: string;
+  activeRequestId: string;
+  sessionViewVersion: number;
+  messages: ConversationSessionMessage[];
+  events: Array<Record<string, unknown>>;
+  taskProgressByRequest: Map<string, Record<string, unknown>>;
+  contextWindowByRequest: Map<string, Record<string, unknown>>;
+  submittedToolApprovalIds: Set<string>;
+  requestMessages: Map<string, string>;
+  lastSeqByRequest: Map<string, number>;
+  sessions: ConversationSession[];
+}
+
+export interface ConversationSessionClient {
+  markSessionRead(options: {
+    sessionId: string;
+    environmentId: string;
+    readThroughMessageId: number | null;
+  }): Promise<Record<string, unknown>>;
+  listSessions(environmentId: string): Promise<Record<string, unknown>>;
+  loadSession(
+    sessionId: string,
+    environmentId: string,
+  ): Promise<Record<string, unknown>>;
+  fetchRequestEvents(options: {
+    requestId: string;
+    afterSeq: number;
+    environmentId: string;
+  }): Promise<unknown[]>;
+}
+
+export interface ConversationSessionControllerOptions {
+  state: ConversationSessionState;
+  dom: {
+    sessionTitle: { textContent: string | null };
+    sessionsList: { innerHTML: string };
+  };
+  client: ConversationSessionClient;
+  preferences: {
+    sessionIdForEnvironment(environmentId: string): string;
+    saveSessionIdForEnvironment(environmentId: string, sessionId: string): void;
+  };
+  sessions: {
+    titleOf(session: ConversationSession | undefined): string;
+    byId(sessionId: string): ConversationSession | undefined;
+    setCurrentTitle(title: string): void;
+    applyTitle(sessionId: string, title: unknown): void;
+    applyReadState(sessionId: string, readState: unknown): void;
+  };
+  sessionQueue: {
+    peek(scope: ConversationSessionScope): Readonly<{
+      waitForRequestId: string;
+    }> | null;
+    rebindBlocked(scope: ConversationSessionScope, requestId: string): unknown;
+  };
+  conversationView: { reset(): void };
+  selectedEnvironmentId(): string;
+  clearPendingAttachments(): void;
+  applyConversationChrome(): void;
+  applyModelSelection(): void;
+  renderSessions(): void;
+  renderMessages(): void;
+  updateComposerSendState(): void;
+  setMessageStatus(message: string): void;
+  sendRealtime(message: Record<string, unknown>): unknown;
+  handleRealtimeMessage(message: Record<string, unknown>): void;
+  recordEvent(event: Record<string, unknown>): void;
+  recordControlEvent(event: Record<string, unknown>): void;
+  reportQueueFailure(scope: ConversationSessionScope, summary: string): void;
+  drainQueuedMessage(
+    input: ConversationSessionScope & {
+      terminalRequestId: unknown;
+    },
+  ): void | Promise<void>;
+  suspendQueueRecovery(): boolean;
+  recoverBlockedQueue(scope: ConversationSessionScope): unknown;
+  isCurrentComposerScope(scope: ConversationSessionScope): boolean;
+  scheduleTask?(callback: () => void): unknown;
+  createSessionId?(): string;
+}
+
+export declare function normalizeConversationMessage(
+  raw: unknown,
+  fallbackIndex?: number,
+): ConversationMessage;
+
+export declare function createConversationSessionController(
+  options: ConversationSessionControllerOptions,
+): {
+  activateRequestForScope(
+    scope: { environmentId: string; sessionId: string },
+    requestId: string,
+  ): void;
+  activeAssistantForRequest(requestId: string): ConversationSessionMessage;
+  addOrMergeMessage(message: ConversationSessionMessage): void;
+  appendLocalUserMessage(input: {
+    text: string;
+    attachments: unknown[];
+    requestId?: string;
+  }): void;
+  appendRequestError(error: unknown): void;
+  applySessionReadState(sessionId: string, readState: unknown): void;
+  applySessionTitleUpdate(sessionId: string, title: unknown): void;
+  clearCurrentSessionView(): void;
+  clearSessionMessagesView(): void;
+  ensureSession(): string;
+  insertSteerMessage(input: {
+    steerId: string;
+    requestId: string;
+    text: string;
+  }): void;
+  invalidateEnvironmentLoads(): void;
+  loadSessions(): Promise<ConversationSession[]>;
+  markCurrentSessionReadSoon(): void;
+  normalizeMessage(raw: unknown): ConversationMessage;
+  openSession(sessionId: string): Promise<void>;
+  requestBelongsToCurrentView(requestId: string): boolean;
+  resetLiveRequestView(): void;
+  restoreLastSession(): Promise<void>;
+  shouldAcceptRealtimeMessage(message: Record<string, unknown>): boolean;
+  subscribeSession(sessionId: string): void;
+};

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

@@ -49,6 +49,18 @@ export function createConversationSessionController({
   scheduleTask = (callback) => window.setTimeout(callback, 0),
   createSessionId = createWebSessionId,
 }) {
+  let environmentLoadRevision = 0;
+  let sessionListRevision = 0;
+  let sessionRestoreRevision = 0;
+
+  function invalidateEnvironmentLoads() {
+    environmentLoadRevision += 1;
+    sessionListRevision += 1;
+    sessionRestoreRevision += 1;
+    state.sessions = [];
+    renderSessions();
+  }
+
   function normalizeMessage(raw) {
     return normalizeConversationMessage(raw, state.messages.length);
   }
@@ -338,12 +350,29 @@ export function createConversationSessionController({
   }
 
   async function loadSessions() {
+    const environmentRevision = environmentLoadRevision;
+    const requestRevision = ++sessionListRevision;
+    const environmentId = selectedEnvironmentId();
     try {
-      const payload = await client.listSessions(selectedEnvironmentId());
+      const payload = await client.listSessions(environmentId);
+      if (
+        environmentRevision !== environmentLoadRevision ||
+        requestRevision !== sessionListRevision ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return [];
+      }
       state.sessions = Array.isArray(payload.sessions) ? payload.sessions : [];
       renderSessions();
       return state.sessions;
     } catch (error) {
+      if (
+        environmentRevision !== environmentLoadRevision ||
+        requestRevision !== sessionListRevision ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return [];
+      }
       dom.sessionsList.innerHTML = `<div class="empty-state error-text">${escapeHtml(
         error instanceof Error ? error.message : String(error),
       )}</div>`;
@@ -352,9 +381,19 @@ export function createConversationSessionController({
   }
 
   async function restoreLastSession() {
-    const availableSessions = await loadSessions();
-    if (availableSessions.length === 0 || state.currentSessionId) return;
+    const environmentRevision = environmentLoadRevision;
+    const restoreRevision = ++sessionRestoreRevision;
     const environmentId = selectedEnvironmentId();
+    const availableSessions = await loadSessions();
+    if (
+      environmentRevision !== environmentLoadRevision ||
+      restoreRevision !== sessionRestoreRevision ||
+      environmentId !== selectedEnvironmentId() ||
+      availableSessions.length === 0 ||
+      state.currentSessionId
+    ) {
+      return;
+    }
     const savedSessionId = preferences.sessionIdForEnvironment(environmentId);
     const targetSession =
       availableSessions.find((session) => session.id === savedSessionId) ||
@@ -543,6 +582,7 @@ export function createConversationSessionController({
     clearSessionMessagesView,
     ensureSession,
     insertSteerMessage,
+    invalidateEnvironmentLoads,
     loadSessions,
     markCurrentSessionReadSoon,
     normalizeMessage,

package/dist/src/web-ui/app/controllers/long-term-memory/controller.d.ts

@@ -0,0 +1,87 @@
+import type {
+  LongTermMemoryPage,
+  LongTermMemoryRecord,
+} from "../../services/runtime-web-client.js";
+
+export type {
+  LongTermMemoryPage,
+  LongTermMemoryRecord,
+} from "../../services/runtime-web-client.js";
+
+export type LongTermMemoryEditor = Readonly<{
+  mode: "create" | "edit";
+  recordId: string;
+  draft?: Readonly<{
+    content: string;
+    tags: readonly string[];
+  }> | null;
+}>;
+
+export type LongTermMemorySnapshot = Readonly<{
+  enabled: boolean | null;
+  available: boolean | null;
+  items: readonly LongTermMemoryRecord[];
+  total: number;
+  offset: number;
+  limit: number;
+  query: string;
+  loading: boolean;
+  mutation: string;
+  message: string;
+  error: string;
+  editor: LongTermMemoryEditor | null;
+}>;
+
+export interface LongTermMemoryClient {
+  loadLongTermMemoryStatus?(): Promise<Record<string, unknown>>;
+  listLongTermMemories(options: {
+    environmentId: string;
+    limit: number;
+    offset: number;
+    signal: AbortSignal;
+  }): Promise<LongTermMemoryPage>;
+  searchLongTermMemories(options: {
+    environmentId: string;
+    query: string;
+    limit: number;
+    offset: number;
+    signal: AbortSignal;
+  }): Promise<LongTermMemoryPage>;
+  createLongTermMemory(options: {
+    environmentId: string;
+    content: string;
+    tags: readonly string[];
+  }): Promise<{ record: LongTermMemoryRecord }>;
+  updateLongTermMemory(options: {
+    environmentId: string;
+    id: string;
+    content: string;
+    tags: readonly string[];
+    expectedUpdatedAt: string;
+  }): Promise<{ record: LongTermMemoryRecord }>;
+  deleteLongTermMemory(options: {
+    environmentId: string;
+    id: string;
+  }): Promise<Record<string, unknown>>;
+}
+
+export interface LongTermMemoryController {
+  beginCreate(): void;
+  beginEdit(recordId: string): void;
+  cancelEdit(): void;
+  changePage(direction: number): Promise<void>;
+  deleteMemory(recordId: string): Promise<void>;
+  dispose(): void;
+  load(): Promise<void>;
+  refresh(): Promise<void>;
+  save(input: { content: string; tags: readonly string[] }): Promise<void>;
+  search(query: string): Promise<void>;
+  snapshot(): LongTermMemorySnapshot;
+}
+
+export declare function createLongTermMemoryController(options: {
+  client: LongTermMemoryClient;
+  getEnvironmentId: () => string;
+  render: (snapshot: LongTermMemorySnapshot) => void;
+  pageSize?: number;
+}): LongTermMemoryController;