@abot-ai/runtime 1.0.0 → 1.1.0

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;

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

@@ -0,0 +1,61 @@
+export function lastPageOffset(total, pageSize) {
+  return Math.max(
+    0,
+    Math.floor((Math.max(1, total) - 1) / pageSize) * pageSize,
+  );
+}
+
+export function previousPageOffsetAfterDelete(state) {
+  const remaining = Math.max(0, state.total - 1);
+  return state.offset >= remaining && state.offset > 0
+    ? Math.max(0, state.offset - state.limit)
+    : state.offset;
+}
+
+export function canUseMemoryEmbeddings(state) {
+  return state.enabled === true && state.available === true;
+}
+
+export function unavailableMemoryActionMessage(action) {
+  return `Enable an available embedding model to ${action} memories.`;
+}
+
+export function isMemoryConflictError(error) {
+  return (
+    error?.code === "long_term_memory_management_conflict" ||
+    error?.status === 409
+  );
+}
+
+export function isMemoryMissingError(error) {
+  return (
+    error?.code === "long_term_memory_management_not_found" ||
+    error?.status === 404
+  );
+}
+
+export function isAbortError(error) {
+  return error?.name === "AbortError";
+}
+
+export function managementErrorMessage(error) {
+  const messages = {
+    long_term_memory_disabled:
+      "Long-term memory is disabled. Existing memories remain available to view or delete.",
+    long_term_memory_unavailable:
+      "The embedding provider is unavailable. Existing memories remain available to view or delete.",
+    long_term_memory_management_conflict:
+      "This memory changed elsewhere. The latest stored version has been reloaded.",
+    long_term_memory_management_duplicate:
+      "An identical memory already exists.",
+    long_term_memory_management_input_invalid:
+      "Enter valid memory content and tags.",
+    long_term_memory_management_not_found: "This memory no longer exists.",
+    long_term_memory_management_sensitive_data:
+      "This memory may contain a password, key, token, or other sensitive data and was not saved.",
+  };
+  return (
+    messages[error?.code] ||
+    (error instanceof Error ? error.message : String(error))
+  );
+}

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

@@ -0,0 +1,85 @@
+import { lastPageOffset, previousPageOffsetAfterDelete } from "./policy.js";
+
+export function createLongTermMemoryState(pageSize) {
+  return {
+    enabled: null,
+    available: null,
+    items: [],
+    total: 0,
+    offset: 0,
+    limit: pageSize,
+    query: "",
+    loading: false,
+    mutation: "",
+    message: "",
+    error: "",
+    editor: null,
+  };
+}
+
+export function snapshotLongTermMemoryState(state) {
+  const editorDraft = state.editor?.draft
+    ? Object.freeze({
+        ...state.editor.draft,
+        tags: Object.freeze([...state.editor.draft.tags]),
+      })
+    : null;
+  return Object.freeze({
+    ...state,
+    items: Object.freeze([...state.items]),
+    editor: state.editor
+      ? Object.freeze({
+          ...state.editor,
+          ...(editorDraft ? { draft: editorDraft } : {}),
+        })
+      : null,
+  });
+}
+
+export function applyMemoryRecords(state, payload) {
+  state.items = Array.isArray(payload?.items) ? payload.items : [];
+  state.total = Number.isSafeInteger(payload?.total) ? payload.total : 0;
+  if (!payload?.status) return;
+  state.enabled = payload.status.enabled === true;
+  state.available = payload.status.available === true;
+}
+
+export function applyMemoryAvailabilityFailure(state, error) {
+  if (error?.code === "long_term_memory_disabled") {
+    state.enabled = false;
+    return;
+  }
+  if (error?.code === "long_term_memory_unavailable") {
+    state.available = false;
+  }
+}
+
+export function applyCreatedMemory(state, record) {
+  const wasBrowsingList = state.query === "";
+  const previousOffset = state.offset;
+  state.query = "";
+  state.total += 1;
+  state.offset = lastPageOffset(state.total, state.limit);
+  const staysOnCurrentPage = wasBrowsingList && previousOffset === state.offset;
+  if (!record) state.items = [];
+  else if (staysOnCurrentPage) state.items = [...state.items, record];
+  else state.items = [record];
+}
+
+export function applyUpdatedMemory(state, record) {
+  if (!record) return;
+  state.items = state.items.map((item) =>
+    item.id === record.id ? record : item,
+  );
+}
+
+export function applyDeletedMemory(state, recordId) {
+  state.offset = previousPageOffsetAfterDelete(state);
+  state.total = Math.max(0, state.total - 1);
+  state.items = state.items.filter((record) => record.id !== recordId);
+}
+
+export function clearMemoryFeedback(state) {
+  state.message = "";
+  state.error = "";
+}

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

@@ -0,0 +1,25 @@
+export declare function formatDurationMs(value: unknown): string;
+export declare function latestHealthEvent(
+  details: readonly Record<string, unknown>[],
+): Record<string, unknown> | undefined;
+
+export interface OperationsControllerDependencies {
+  readonly dom: Readonly<{
+    runtimeStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
+    runtimeLogs: Pick<HTMLElement, "textContent">;
+    healthStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
+  }>;
+  readonly client: Readonly<{
+    getRuntimeStatus(): Promise<Record<string, unknown>>;
+    getRuntimeLogs(lines: number): Promise<Record<string, unknown>>;
+    getSystemHealth(): Promise<Record<string, unknown>>;
+  }>;
+}
+
+export declare function createOperationsController(
+  options: OperationsControllerDependencies,
+): {
+  loadRuntimeStatus(): Promise<void>;
+  loadRuntimeLogs(): Promise<void>;
+  loadSystemHealth(): Promise<void>;
+};

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

@@ -0,0 +1,57 @@
+import type { ConversationSessionMessage } from "./conversation-session-controller.js";
+
+export type RealtimeEventRecord = Record<string, unknown>;
+
+export interface RealtimeEventControllerState {
+  activeRequestId: string;
+  currentSessionId: string;
+  contextWindowByRequest: Map<string, Record<string, unknown>>;
+  taskProgressByRequest: Map<string, Record<string, unknown>>;
+  lastSeqByRequest: Map<string, number>;
+  events: RealtimeEventRecord[];
+}
+
+export interface RealtimeEventControllerOptions {
+  state: RealtimeEventControllerState;
+  shell: {
+    showToast(message: string, tone?: string): void;
+  };
+  selectedEnvironmentId(): string;
+  handleSteerAcknowledgement(message: RealtimeEventRecord): boolean;
+  shouldAcceptMessage(message: RealtimeEventRecord): boolean;
+  applySessionReadState(sessionId: unknown, readState: unknown): void;
+  activeAssistantForRequest(requestId: string): ConversationSessionMessage;
+  addOrMergeMessage(message: ConversationSessionMessage): void;
+  normalizeChatMessage(
+    message: RealtimeEventRecord,
+  ): ConversationSessionMessage;
+  renderMessages(): void;
+  scheduleMessageRender(): void;
+  scheduleThinkingRender(): void;
+  cancelScheduledMessageRender(): void;
+  cancelScheduledThinkingRender(): void;
+  forgetThinkingDisclosure(messageId: string): void;
+  markCurrentSessionReadSoon(): void;
+  applySessionTitleUpdate(sessionId: unknown, title: unknown): void;
+  setMessageActivityStatus(message: string): void;
+  updateComposerSendState(): void;
+  drainQueuedComposerMessage(input: {
+    environmentId: string;
+    sessionId: string;
+    terminalRequestId: string;
+  }): void | Promise<void>;
+  loadSessions(): void | Promise<unknown>;
+}
+
+export declare function normalizeRealtimeMessage(
+  rawMessage: unknown,
+): RealtimeEventRecord;
+export declare function taskStatusClass(status: unknown): string;
+export declare function createRealtimeEventController(
+  options: RealtimeEventControllerOptions,
+): {
+  handle(rawMessage: unknown): void;
+  recordControlEvent(event: RealtimeEventRecord): void;
+  recordEvent(message: RealtimeEventRecord): void;
+  trackSeq(message: RealtimeEventRecord): void;
+};

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

@@ -0,0 +1,32 @@
+export type RuntimeAvailability = Record<string, unknown> & {
+  status: string;
+  message?: string;
+  showGuide?: boolean;
+};
+
+export interface RuntimeOnboardingControllerDependencies {
+  readonly state: {
+    runtimeAvailability: RuntimeAvailability;
+  };
+  readonly guide: Readonly<{
+    bind(options?: { onCheckAgain?: () => void | Promise<void> }): void;
+    focusAction(): void;
+    render(setup: RuntimeAvailability): void;
+  }>;
+  readonly reloadModels: () => void | Promise<void>;
+  readonly setMessageStatus: (message: string) => void;
+  readonly onStateChange?: () => void;
+}
+
+export declare function createRuntimeOnboardingController(
+  options: RuntimeOnboardingControllerDependencies,
+): {
+  applyCatalog(payload: Record<string, unknown>): void;
+  beginCatalogLoad(): void;
+  bind(): void;
+  catalogUnavailable(error: unknown): void;
+  isReady(): boolean;
+  presentSubmissionBlock(block: { message?: string } | null): void;
+  render(): void;
+  submissionBlock(): { code: string; message: string } | null;
+};