@abot-ai/runtime 1.0.0 → 1.1.0

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

@@ -0,0 +1,177 @@
+export type AgentMode = "auto" | "fast" | "reasoning" | "deep";
+export type ToolPermissionMode = "ask" | "full_access";
+
+export declare function normalizeAgentMode(mode: unknown): AgentMode;
+export declare function normalizeToolPermissionMode(
+  value: unknown,
+): ToolPermissionMode;
+
+export interface RuntimeSelectionOptionSurface {
+  readonly value: string;
+  readonly textContent: string | null;
+}
+
+export interface RuntimeSelectionOptionCollection extends Iterable<RuntimeSelectionOptionSurface> {
+  readonly length: number;
+  readonly [index: number]: RuntimeSelectionOptionSurface | undefined;
+}
+
+export interface RuntimeSelectionEnvironmentSelectSurface {
+  value: string;
+  innerHTML: string;
+  readonly options: RuntimeSelectionOptionCollection;
+  append(option: unknown): unknown;
+}
+
+export interface RuntimeSelectionModelSelectSurface {
+  value: string;
+  innerHTML: string;
+  disabled: boolean;
+  readonly options: RuntimeSelectionOptionCollection;
+  appendChild(option: unknown): unknown;
+}
+
+export interface RuntimeSelectionClassListSurface {
+  toggle(token: string, force?: boolean): unknown;
+}
+
+export interface RuntimeSelectionPickerButtonSurface {
+  hidden: boolean;
+  innerHTML: string;
+  title: string;
+  readonly classList: RuntimeSelectionClassListSurface;
+  setAttribute(name: string, value: string): void;
+}
+
+export interface RuntimeSelectionControlButtonSurface {
+  innerHTML: string;
+  title: string;
+  disabled: boolean;
+  readonly classList: RuntimeSelectionClassListSurface;
+  setAttribute(name: string, value: string): void;
+  focus(): void;
+}
+
+export interface RuntimeSelectionAgentModeButtonSurface {
+  innerHTML: string;
+  disabled: boolean;
+  readonly classList: RuntimeSelectionClassListSurface;
+  setAttribute(name: string, value: string): void;
+  focus(): void;
+}
+
+export interface RuntimeSelectionPickerMenuSurface {
+  hidden: boolean;
+  innerHTML: string;
+  readonly classList: RuntimeSelectionClassListSurface;
+}
+
+export interface RuntimeSelectionControlMenuSurface extends RuntimeSelectionPickerMenuSurface {
+  setAttribute(name: string, value: string): void;
+  querySelectorAll(selector: string): Iterable<Element>;
+}
+
+export interface RuntimeSelectionControllerDependencies {
+  readonly state: {
+    config: Readonly<{
+      environments?: readonly Readonly<{
+        id?: unknown;
+        label?: unknown;
+      }>[];
+      defaultEnvironmentId?: unknown;
+    }> | null;
+    pinnedSessionIds: readonly string[];
+    sessionModes: Record<string, Record<string, unknown>>;
+    sessionModels: Record<string, unknown>;
+    lastModelByEnvironment: Record<string, unknown>;
+    agentMode: AgentMode;
+    supportedAgentModes: AgentMode[];
+    agentModeMenuOpen: boolean;
+    permissionModeMenuOpen: boolean;
+    agentPickerOpen: boolean;
+    modelProfiles: Array<
+      Record<string, unknown> & {
+        id: string;
+        label?: string;
+        provider?: string;
+        supportsImageInput?: boolean;
+        capabilities?: Readonly<{
+          inputModalities?: readonly unknown[];
+        }>;
+      }
+    >;
+    defaultModelProfileId: string;
+    currentSessionId: string;
+  };
+  readonly dom: Readonly<{
+    environmentSelect: RuntimeSelectionEnvironmentSelectSurface;
+    modelSelect: RuntimeSelectionModelSelectSurface;
+    agentPickerButton: RuntimeSelectionPickerButtonSurface;
+    agentPickerMenu: RuntimeSelectionPickerMenuSurface;
+    permissionModeButton: RuntimeSelectionControlButtonSurface;
+    permissionModeMenu: RuntimeSelectionControlMenuSurface;
+    agentModeButton: RuntimeSelectionAgentModeButtonSurface;
+    agentModeMenu: RuntimeSelectionControlMenuSurface;
+  }>;
+  readonly preferences: Readonly<{
+    loadPinnedSessions(): string[];
+    loadSessionModes(
+      normalize: (value: unknown) => ToolPermissionMode,
+    ): Record<string, Record<string, unknown>>;
+    saveSessionModes(modes: Record<string, Record<string, unknown>>): void;
+    loadModelPreferences(): {
+      sessionModels: Record<string, unknown>;
+      lastModelByEnvironment: Record<string, unknown>;
+    };
+    saveModelPreferences(
+      sessionModels: Record<string, unknown>,
+      lastModelByEnvironment: Record<string, unknown>,
+    ): void;
+  }>;
+  readonly modelSelector: Readonly<{
+    sync(): void;
+  }>;
+  readonly client: Readonly<{
+    getAgentMode(environmentId: string): Promise<Record<string, unknown>>;
+    setAgentMode(
+      mode: AgentMode,
+      environmentId: string,
+    ): Promise<Record<string, unknown>>;
+    listModels(environmentId: string): Promise<Record<string, unknown>>;
+  }>;
+  readonly recordControlEvent: (event: {
+    type: "control";
+    name: string;
+    tone: "failed";
+    summary: string;
+  }) => void;
+  readonly onAttachmentPolicyChange: () => void;
+  readonly onModelCatalogLoading?: () => void;
+  readonly onModelCatalogLoaded?: (payload: Record<string, unknown>) => void;
+  readonly onModelCatalogUnavailable?: (error: unknown) => void;
+}
+
+export declare function createRuntimeSelectionController(
+  options: RuntimeSelectionControllerDependencies,
+): {
+  applyModelSelection(): void;
+  clearSessionMode(sessionId: string): void;
+  configuredEnvironmentOptions(): Array<{ value: string; label: string }>;
+  currentToolPermissionMode(): ToolPermissionMode;
+  environmentOptions(): Array<{ value: string; label: string }>;
+  loadAgentMode(): Promise<boolean>;
+  loadModels(): Promise<boolean>;
+  loadPreferences(): void;
+  rememberModelSelection(): void;
+  renderAgentMode(): void;
+  renderAgentPicker(): void;
+  renderEnvironmentOptions(): void;
+  renderModels(): void;
+  renderPermissionMode(): void;
+  saveModelPreferences(): void;
+  selectedEnvironmentId(): string;
+  selectedModelPreference(): Record<string, unknown> | null;
+  selectedModelSupportsImageInput(): boolean;
+  setAgentMode(mode: AgentMode): Promise<boolean>;
+  setToolPermissionMode(mode: ToolPermissionMode): void;
+};

package/dist/src/web-ui/app/controllers/runtime-selection-controller.js

@@ -56,6 +56,14 @@ export function createRuntimeSelectionController({
   onModelCatalogLoaded = () => {},
   onModelCatalogUnavailable = () => {},
 }) {
+  let agentModeLoadRevision = 0;
+  const agentModeMutationRevisions = new Map();
+  let agentModeMutationInFlight = false;
+  let modelCatalogLoadRevision = 0;
+
+  const agentModeMutationRevisionFor = (environmentId) =>
+    agentModeMutationRevisions.get(environmentId) || 0;
+
   function configuredEnvironmentOptions() {
     const raw = Array.isArray(state.config?.environments)
       ? state.config.environments
@@ -277,6 +285,7 @@ export function createRuntimeSelectionController({
 
   function renderAgentMode() {
     const meta = agentModeMeta(state.agentMode);
+    dom.agentModeButton.disabled = agentModeMutationInFlight;
     dom.agentModeButton.innerHTML = `
       <span class="agent-mode-icon">${escapeHtml(meta.icon)}</span>
       <span>${escapeHtml(meta.label)}</span>`;
@@ -295,7 +304,7 @@ export function createRuntimeSelectionController({
         return `
           <button class="agent-mode-option ${selected ? "selected" : ""}" type="button"
             role="menuitemradio" aria-checked="${selected ? "true" : "false"}"
-            tabindex="${selected ? "0" : "-1"}" data-mode="${escapeAttribute(mode)}">
+            tabindex="${selected ? "0" : "-1"}" data-mode="${escapeAttribute(mode)}" ${agentModeMutationInFlight ? "disabled" : ""}>
             <span class="agent-mode-option-icon">${escapeHtml(item.icon)}</span>
             <span><strong>${escapeHtml(item.label)}</strong><small>${escapeHtml(item.description)}</small></span>
           </button>`;
@@ -312,42 +321,85 @@ export function createRuntimeSelectionController({
   }
 
   async function loadAgentMode() {
+    const revision = ++agentModeLoadRevision;
+    const environmentId = selectedEnvironmentId();
+    const mutationRevision = agentModeMutationRevisionFor(environmentId);
     renderAgentMode();
     try {
-      const payload = await client.getAgentMode(selectedEnvironmentId());
+      const payload = await client.getAgentMode(environmentId);
+      if (
+        revision !== agentModeLoadRevision ||
+        mutationRevision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
       state.agentMode = normalizeAgentMode(payload.mode);
       state.supportedAgentModes = Array.isArray(payload.supportedModes)
         ? payload.supportedModes.map(normalizeAgentMode)
         : state.supportedAgentModes;
       renderAgentMode();
+      return true;
     } catch {
+      if (
+        revision !== agentModeLoadRevision ||
+        mutationRevision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
       state.agentMode = "reasoning";
       renderAgentMode();
+      return false;
     }
   }
 
   async function setAgentMode(mode) {
+    if (agentModeMutationInFlight) return false;
+    agentModeMutationInFlight = true;
+    const environmentId = selectedEnvironmentId();
+    const revision = agentModeMutationRevisionFor(environmentId) + 1;
+    agentModeMutationRevisions.set(environmentId, revision);
+    const loadRevisionAtStart = ++agentModeLoadRevision;
     const previousMode = state.agentMode;
-    state.agentMode = normalizeAgentMode(mode);
+    const requestedMode = normalizeAgentMode(mode);
+    state.agentMode = requestedMode;
     state.agentModeMenuOpen = false;
     renderAgentMode();
     dom.agentModeButton.focus();
     try {
-      const payload = await client.setAgentMode(
-        state.agentMode,
-        selectedEnvironmentId(),
-      );
+      const payload = await client.setAgentMode(requestedMode, environmentId);
+      if (
+        revision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
+      agentModeLoadRevision += 1;
       state.agentMode = normalizeAgentMode(payload.mode);
       renderAgentMode();
+      return true;
     } catch (error) {
-      state.agentMode = previousMode;
-      renderAgentMode();
+      if (
+        revision !== agentModeMutationRevisionFor(environmentId) ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
+      if (agentModeLoadRevision === loadRevisionAtStart) {
+        state.agentMode = previousMode;
+        renderAgentMode();
+      }
       recordControlEvent({
         type: "control",
         name: "Reasoning mode update failed",
         tone: "failed",
         summary: error instanceof Error ? error.message : String(error),
       });
+      return false;
+    } finally {
+      agentModeMutationInFlight = false;
+      renderAgentMode();
     }
   }
 
@@ -375,23 +427,38 @@ export function createRuntimeSelectionController({
   }
 
   async function loadModels() {
+    const revision = ++modelCatalogLoadRevision;
+    const environmentId = selectedEnvironmentId();
     onModelCatalogLoading();
     let payload = null;
     try {
-      payload = await client.listModels(selectedEnvironmentId());
+      payload = await client.listModels(environmentId);
+      if (
+        revision !== modelCatalogLoadRevision ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
       state.defaultModelProfileId = textOf(payload.defaultProfileId);
       state.modelProfiles = Array.isArray(payload.profiles)
         ? payload.profiles
         : [];
     } catch (error) {
+      if (
+        revision !== modelCatalogLoadRevision ||
+        environmentId !== selectedEnvironmentId()
+      ) {
+        return false;
+      }
       state.defaultModelProfileId = "";
       state.modelProfiles = [];
       renderModels();
       onModelCatalogUnavailable(error);
-      return;
+      return false;
     }
     renderModels();
     onModelCatalogLoaded(payload);
+    return true;
   }
 
   return {

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

@@ -0,0 +1,28 @@
+import type {
+  ToolApprovalCardOptions,
+  ToolApprovalEvent,
+} from "../components/tool-approval-card.js";
+
+export interface ToolApprovalControllerState {
+  connected: boolean;
+  events: ToolApprovalEvent[];
+  submittedToolApprovalIds: Set<string>;
+}
+
+export interface ToolApprovalControllerOptions {
+  state: ToolApprovalControllerState;
+  selectedEnvironmentId(): string;
+  sendRealtime(message: Record<string, unknown>): unknown;
+  renderMessages(): void;
+  recordControlEvent(event: Record<string, unknown>): void;
+  createCard(options: ToolApprovalCardOptions): HTMLElement;
+}
+
+export declare function createToolApprovalController(
+  options: ToolApprovalControllerOptions,
+): {
+  createCard(event: ToolApprovalEvent | undefined): HTMLElement;
+  isPending(event: ToolApprovalEvent | undefined): boolean;
+  pendingEvent(): ToolApprovalEvent | undefined;
+  submit(approvalId: string, approved: boolean): boolean;
+};

package/dist/src/web-ui/app/index.html

@@ -463,7 +463,13 @@
             <p>Review and edit runtime configuration with explicit saves.</p>
           </div>
           <div class="toolbar-actions">
-            <button id="refreshConfigButton" type="button">Refresh</button>
+            <button
+              id="refreshConfigButton"
+              type="button"
+              aria-label="Refresh configuration"
+            >
+              Refresh
+            </button>
             <button
               id="closeConfigWorkspaceButton"
               class="workspace-page-back config-workspace-back"
@@ -475,21 +481,13 @@
           </div>
         </header>
         <div class="workspace-page-body config-workspace-body">
-          <div id="configStatus" class="runtime-card"></div>
+          <div
+            id="configStatus"
+            class="config-workspace-status"
+            role="status"
+            aria-live="polite"
+          ></div>
           <div id="configDashboard" class="config-dashboard"></div>
-          <details class="config-raw-panel">
-            <summary>Raw JSON</summary>
-            <div class="config-raw-toolbar">
-              <select id="configRawFileSelect" title="Config file"></select
-              ><button id="configApplyRawButton" type="button">Apply</button
-              ><button id="configSaveRawButton" type="button">Save</button>
-            </div>
-            <textarea
-              id="configRawEditor"
-              class="config-view"
-              spellcheck="false"
-            ></textarea>
-          </details>
         </div>
       </section>
 

package/dist/src/web-ui/app/services/runtime-web-client/memory.js

@@ -0,0 +1,127 @@
+export function createLongTermMemoryRequests({
+  requestApi,
+  getEnvironmentId,
+  environmentQuery,
+}) {
+  return Object.freeze({
+    loadLongTermMemoryStatus(environmentId = getEnvironmentId()) {
+      return requestApi(
+        `/runtime/memory?environment=${environmentQuery(environmentId)}`,
+      );
+    },
+
+    discoverLongTermMemoryModels({
+      environmentId = getEnvironmentId(),
+      providerId,
+    }) {
+      return requestApi(
+        `/runtime/memory/models?environment=${environmentQuery(
+          environmentId,
+        )}&provider=${encodeURIComponent(providerId)}`,
+      );
+    },
+
+    enableLongTermMemory({
+      environmentId = getEnvironmentId(),
+      providerId,
+      model,
+      profileId,
+      emitClientEvents,
+    }) {
+      return requestApi("/runtime/memory/enable", {
+        method: "POST",
+        body: JSON.stringify({
+          environment: environmentId,
+          providerId,
+          model,
+          profileId,
+          emitClientEvents,
+        }),
+      });
+    },
+
+    disableLongTermMemory(environmentId = getEnvironmentId()) {
+      return requestApi("/runtime/memory/disable", {
+        method: "POST",
+        body: JSON.stringify({ environment: environmentId }),
+      });
+    },
+
+    listLongTermMemories({
+      environmentId = getEnvironmentId(),
+      limit = 20,
+      offset = 0,
+      signal,
+    } = {}) {
+      return requestApi(
+        memoryRecordsPath({ environmentId, limit, offset }),
+        signal ? { signal } : {},
+      );
+    },
+
+    searchLongTermMemories({
+      environmentId = getEnvironmentId(),
+      query,
+      limit = 20,
+      offset = 0,
+      signal,
+    }) {
+      return requestApi(
+        memoryRecordsPath({ environmentId, limit, offset, query }),
+        signal ? { signal } : {},
+      );
+    },
+
+    createLongTermMemory({
+      environmentId = getEnvironmentId(),
+      content,
+      tags,
+    }) {
+      return requestApi("/runtime/memory/records", {
+        method: "POST",
+        body: JSON.stringify({ environment: environmentId, content, tags }),
+      });
+    },
+
+    updateLongTermMemory({
+      environmentId = getEnvironmentId(),
+      id,
+      content,
+      tags,
+      expectedUpdatedAt,
+    }) {
+      return requestApi(`/runtime/memory/records/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          environment: environmentId,
+          content,
+          tags,
+          expectedUpdatedAt,
+        }),
+      });
+    },
+
+    deleteLongTermMemory({ environmentId = getEnvironmentId(), id }) {
+      return requestApi(
+        `/runtime/memory/records/${encodeURIComponent(
+          id,
+        )}?environment=${environmentQuery(environmentId)}`,
+        { method: "DELETE" },
+      );
+    },
+  });
+}
+
+function memoryRecordsPath({ environmentId, limit, offset, query }) {
+  const params = new URLSearchParams({
+    environment: environmentId,
+    limit: String(limit),
+    offset: String(offset),
+  });
+  if (query !== undefined) params.set("q", query);
+  const route =
+    query === undefined
+      ? "/runtime/memory/records"
+      : "/runtime/memory/records/search";
+  return `${route}?${params}`;
+}

package/dist/src/web-ui/app/services/runtime-web-client.d.ts

@@ -3,6 +3,44 @@ export declare function parseJsonResponseText(
   context: string,
 ): Record<string, unknown>;
 
+export declare class RuntimeWebClientError extends Error {
+  readonly status: number | undefined;
+  readonly code: string | undefined;
+  readonly payload: unknown;
+
+  constructor(
+    message: string,
+    options?: {
+      status?: number;
+      code?: string;
+      payload?: unknown;
+    },
+  );
+}
+
+export type LongTermMemoryRecord = Readonly<{
+  id: string;
+  content: string;
+  tags: readonly string[];
+  origin: string;
+  createdAt: string;
+  updatedAt: string;
+  [key: string]: unknown;
+}>;
+
+export type LongTermMemoryPage = Readonly<{
+  items: readonly LongTermMemoryRecord[];
+  total: number;
+  status?: Readonly<{
+    enabled: boolean;
+    available: boolean;
+  }>;
+}>;
+
+export type LongTermMemoryRecordResponse = Readonly<{
+  record: LongTermMemoryRecord;
+}>;
+
 export type RuntimeAvailability =
   | { status: "ready" }
   | {
@@ -93,4 +131,50 @@ export declare function createRuntimeWebClient(options: {
     id: string;
     config: unknown;
   }): Promise<Record<string, unknown>>;
+  loadLongTermMemoryStatus(
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
+  discoverLongTermMemoryModels(options: {
+    environmentId?: string;
+    providerId: string;
+  }): Promise<Record<string, unknown>>;
+  enableLongTermMemory(options: {
+    environmentId?: string;
+    providerId: string;
+    model: string;
+    profileId?: string;
+    emitClientEvents: boolean;
+  }): Promise<Record<string, unknown>>;
+  disableLongTermMemory(
+    environmentId?: string,
+  ): 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<LongTermMemoryRecordResponse>;
+  updateLongTermMemory(options: {
+    environmentId?: string;
+    id: string;
+    content: string;
+    tags: readonly string[];
+    expectedUpdatedAt: string;
+  }): Promise<LongTermMemoryRecordResponse>;
+  deleteLongTermMemory(options: {
+    environmentId?: string;
+    id: string;
+  }): Promise<Record<string, unknown>>;
 };

package/dist/src/web-ui/app/services/runtime-web-client.js

@@ -1,3 +1,5 @@
+import { createLongTermMemoryRequests } from "./runtime-web-client/memory.js";
+
 export function parseJsonResponseText(text, context) {
   if (!text.trim()) return {};
   try {
@@ -8,6 +10,16 @@ export function parseJsonResponseText(text, context) {
   }
 }
 
+export class RuntimeWebClientError extends Error {
+  constructor(message, { status, code, payload } = {}) {
+    super(message);
+    this.name = "RuntimeWebClientError";
+    this.status = status;
+    this.code = code;
+    this.payload = payload;
+  }
+}
+
 export function createRuntimeWebClient({
   getConfig,
   getEnvironmentId,
@@ -57,13 +69,25 @@ export function createRuntimeWebClient({
     });
     const data = parseJsonResponseText(await response.text(), context);
     if (!response.ok) {
-      throw new Error(data.message || data.error || `HTTP ${response.status}`);
+      throw new RuntimeWebClientError(
+        data.message || data.error || `HTTP ${response.status}`,
+        {
+          status: response.status,
+          code: typeof data.error === "string" ? data.error : "",
+          payload: data,
+        },
+      );
     }
     return data;
   }
 
   const requestApi = (path, options = {}) =>
     request(resolveApiPath(path), path, options);
+  const longTermMemoryRequests = createLongTermMemoryRequests({
+    requestApi,
+    getEnvironmentId,
+    environmentQuery,
+  });
 
   return {
     getRuntimeStatus() {
@@ -266,5 +290,7 @@ export function createRuntimeWebClient({
         }),
       });
     },
+
+    ...longTermMemoryRequests,
   };
 }