@abot-ai/runtime 1.0.0 → 1.2.0

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;

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

@@ -0,0 +1,302 @@
+import {
+  canUseMemoryEmbeddings,
+  isAbortError,
+  isMemoryConflictError,
+  isMemoryMissingError,
+  managementErrorMessage,
+  unavailableMemoryActionMessage,
+} from "./policy.js";
+import {
+  applyCreatedMemory,
+  applyDeletedMemory,
+  applyMemoryAvailabilityFailure,
+  applyMemoryRecords,
+  applyUpdatedMemory,
+  clearMemoryFeedback,
+  createLongTermMemoryState,
+  snapshotLongTermMemoryState,
+} from "./state.js";
+
+const DEFAULT_PAGE_SIZE = 20;
+
+export function createLongTermMemoryController({
+  client,
+  getEnvironmentId,
+  render,
+  pageSize = DEFAULT_PAGE_SIZE,
+}) {
+  const state = createLongTermMemoryState(pageSize);
+  let readRevision = 0;
+  let activeRead = null;
+
+  function publish() {
+    render(snapshot());
+  }
+
+  function snapshot() {
+    return snapshotLongTermMemoryState(state);
+  }
+
+  async function load() {
+    state.enabled = null;
+    state.available = null;
+    state.items = [];
+    state.total = 0;
+    state.query = "";
+    state.offset = 0;
+    state.mutation = "";
+    state.editor = null;
+    clearMemoryFeedback(state);
+    await loadRecords({ preserveFeedback: true });
+  }
+
+  async function refresh() {
+    await loadRecords({ preserveFeedback: false });
+  }
+
+  async function search(query) {
+    const normalized = String(query ?? "").trim();
+    if (!normalized) {
+      state.query = "";
+      state.offset = 0;
+      await loadRecords({ preserveFeedback: false });
+      return;
+    }
+    if (!canUseMemoryEmbeddings(state)) {
+      state.error = unavailableMemoryActionMessage("search");
+      publish();
+      return;
+    }
+    state.query = normalized;
+    state.offset = 0;
+    await loadRecords({ preserveFeedback: false });
+  }
+
+  async function changePage(direction) {
+    const nextOffset = state.offset + direction * state.limit;
+    if (nextOffset < 0 || nextOffset >= state.total) return;
+    state.offset = nextOffset;
+    await loadRecords({ preserveFeedback: false });
+  }
+
+  function beginCreate() {
+    if (!canUseMemoryEmbeddings(state)) {
+      state.error = unavailableMemoryActionMessage("create");
+      publish();
+      return;
+    }
+    clearMemoryFeedback(state);
+    state.editor = { mode: "create", recordId: "" };
+    publish();
+  }
+
+  function beginEdit(recordId) {
+    if (!canUseMemoryEmbeddings(state)) {
+      state.error = unavailableMemoryActionMessage("edit");
+      publish();
+      return;
+    }
+    if (!findRecord(recordId)) return;
+    clearMemoryFeedback(state);
+    state.editor = { mode: "edit", recordId };
+    publish();
+  }
+
+  function cancelEdit() {
+    state.editor = null;
+    clearMemoryFeedback(state);
+    publish();
+  }
+
+  async function save({ content, tags }) {
+    const editor = state.editor;
+    if (!editor || state.mutation) return;
+    const environmentId = getEnvironmentId();
+    state.editor = {
+      ...editor,
+      draft: { content, tags: [...tags] },
+    };
+    state.mutation = editor.mode;
+    clearMemoryFeedback(state);
+    publish();
+    try {
+      await saveEditor({ editor, environmentId, content, tags });
+    } catch (error) {
+      await handleMutationFailure(error, editor);
+    } finally {
+      finishMutation(environmentId);
+    }
+  }
+
+  async function saveEditor({ editor, environmentId, content, tags }) {
+    if (editor.mode === "create") {
+      await createMemory({ environmentId, content, tags });
+      return;
+    }
+    await updateMemory({
+      environmentId,
+      recordId: editor.recordId,
+      content,
+      tags,
+    });
+  }
+
+  async function createMemory({ environmentId, content, tags }) {
+    const result = await client.createLongTermMemory({
+      environmentId,
+      content,
+      tags,
+    });
+    if (environmentId !== getEnvironmentId()) return;
+    state.editor = null;
+    state.message = "Memory created.";
+    applyCreatedMemory(state, result.record);
+    await loadRecords({ preserveFeedback: true });
+  }
+
+  async function updateMemory({ environmentId, recordId, content, tags }) {
+    const record = findRecord(recordId);
+    if (!record) {
+      state.error = "This memory is no longer in the current list.";
+      return;
+    }
+    const result = await client.updateLongTermMemory({
+      environmentId,
+      id: record.id,
+      content,
+      tags,
+      expectedUpdatedAt: record.updatedAt,
+    });
+    if (environmentId !== getEnvironmentId()) return;
+    state.editor = null;
+    state.message = "Memory updated.";
+    applyUpdatedMemory(state, result.record);
+    await loadRecords({ preserveFeedback: true });
+  }
+
+  async function deleteMemory(recordId) {
+    if (state.mutation || !findRecord(recordId)) return;
+    const environmentId = getEnvironmentId();
+    state.mutation = `delete:${recordId}`;
+    clearMemoryFeedback(state);
+    publish();
+    try {
+      await client.deleteLongTermMemory({ environmentId, id: recordId });
+      await applySuccessfulDelete(environmentId, recordId);
+    } catch (error) {
+      await handleDeleteFailure(error);
+    } finally {
+      finishMutation(environmentId);
+    }
+  }
+
+  async function applySuccessfulDelete(environmentId, recordId) {
+    if (environmentId !== getEnvironmentId()) return;
+    if (state.editor?.recordId === recordId) state.editor = null;
+    state.message = "Memory deleted.";
+    applyDeletedMemory(state, recordId);
+    await loadRecords({ preserveFeedback: true });
+  }
+
+  async function handleDeleteFailure(error) {
+    applyMemoryAvailabilityFailure(state, error);
+    state.error = managementErrorMessage(error);
+    if (isMemoryMissingError(error)) {
+      await loadRecords({ preserveFeedback: true });
+    }
+  }
+
+  async function handleMutationFailure(error, editor) {
+    applyMemoryAvailabilityFailure(state, error);
+    state.error = managementErrorMessage(error);
+    if (!isMemoryConflictError(error) || editor.mode !== "edit") return;
+    state.editor = { mode: "edit", recordId: editor.recordId };
+    await loadRecords({ preserveFeedback: true });
+  }
+
+  async function loadRecords({ preserveFeedback }) {
+    const request = beginRead();
+    if (!preserveFeedback) clearMemoryFeedback(state);
+    state.loading = true;
+    publish();
+    try {
+      const payload = await requestRecords(request);
+      if (!isCurrentRead(request)) return;
+      applyMemoryRecords(state, payload);
+    } catch (error) {
+      if (!isCurrentRead(request) || isAbortError(error)) return;
+      applyMemoryAvailabilityFailure(state, error);
+      state.error = managementErrorMessage(error);
+    } finally {
+      finishRead(request);
+    }
+  }
+
+  function requestRecords(request) {
+    const page = {
+      environmentId: request.environmentId,
+      limit: state.limit,
+      offset: state.offset,
+      signal: request.controller.signal,
+    };
+    return state.query
+      ? client.searchLongTermMemories({ ...page, query: state.query })
+      : client.listLongTermMemories(page);
+  }
+
+  function beginRead() {
+    activeRead?.abort();
+    const request = {
+      revision: ++readRevision,
+      environmentId: getEnvironmentId(),
+      controller: new AbortController(),
+    };
+    activeRead = request.controller;
+    return request;
+  }
+
+  function isCurrentRead(request) {
+    return (
+      request.revision === readRevision &&
+      request.environmentId === getEnvironmentId()
+    );
+  }
+
+  function finishRead(request) {
+    if (!isCurrentRead(request)) return;
+    state.loading = false;
+    activeRead = null;
+    publish();
+  }
+
+  function finishMutation(environmentId) {
+    if (environmentId !== getEnvironmentId()) return;
+    state.mutation = "";
+    publish();
+  }
+
+  function findRecord(recordId) {
+    return state.items.find((record) => record.id === recordId);
+  }
+
+  function dispose() {
+    readRevision += 1;
+    activeRead?.abort();
+    activeRead = null;
+  }
+
+  publish();
+  return Object.freeze({
+    beginCreate,
+    beginEdit,
+    cancelEdit,
+    changePage,
+    deleteMemory,
+    dispose,
+    load,
+    refresh,
+    save,
+    search,
+    snapshot,
+  });
+}

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

@@ -0,0 +1,14 @@
+import type { LongTermMemorySnapshot } from "./controller.js";
+
+export declare function lastPageOffset(total: number, pageSize: number): number;
+export declare function previousPageOffsetAfterDelete(
+  state: Pick<LongTermMemorySnapshot, "total" | "offset" | "limit">,
+): number;
+export declare function canUseMemoryEmbeddings(
+  state: Pick<LongTermMemorySnapshot, "enabled" | "available">,
+): boolean;
+export declare function unavailableMemoryActionMessage(action: string): string;
+export declare function isMemoryConflictError(error: unknown): boolean;
+export declare function isMemoryMissingError(error: unknown): boolean;
+export declare function isAbortError(error: unknown): boolean;
+export declare function managementErrorMessage(error: unknown): string;