@abot-ai/runtime 1.0.0 → 1.2.0

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,58 @@
+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;
+  renderContextWindow?(): 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/realtime-event-controller.js

@@ -4,25 +4,33 @@ import {
   eventTone,
   formatEventDetail,
   formatEventLabel,
-  getPlanItemPayload,
-  getPlanPayload,
-  getRecord,
   isLowValueActivityEvent,
 } from "../lib/event-presentation.js";
 import { textOf } from "../lib/text-format.js";
 import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
+import { reduceTaskProgress } from "../lib/task-progress.js";
+import { projectWebSourceEvent } from "../lib/web-source-event.js";
 
 export { normalizeRealtimeMessage } from "../lib/realtime-message.js";
+export { taskStatusClass } from "../lib/task-progress.js";
 
-export function taskStatusClass(status) {
-  const normalized = textOf(status).trim().toLowerCase();
-  if (normalized === "done" || normalized === "completed") return "done";
-  if (normalized === "in_progress" || normalized === "active") {
-    return "active";
-  }
-  if (normalized === "blocked" || normalized === "failed") return "failed";
-  if (normalized === "superseded") return "muted";
-  return "pending";
+function hasOriginalEventSequence(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+function hasRecordedOriginalEvent(events, requestId, eventSequence) {
+  if (eventSequence === undefined) return false;
+  return events.some(
+    (event) =>
+      event.requestId === requestId && event.eventSequence === eventSequence,
+  );
+}
+
+function canMergeUnsequencedActivity(previous, key, eventSequence, webSources) {
+  if (eventSequence !== undefined) return false;
+  if (webSources || previous?.webSources) return false;
+  if (!previous?.key || previous.key !== key) return false;
+  return !hasOriginalEventSequence(previous.eventSequence);
 }
 
 export function createRealtimeEventController({
@@ -36,6 +44,7 @@ export function createRealtimeEventController({
   addOrMergeMessage,
   normalizeChatMessage,
   renderMessages,
+  renderContextWindow = () => {},
   scheduleMessageRender,
   scheduleThinkingRender,
   cancelScheduledMessageRender,
@@ -54,76 +63,12 @@ export function createRealtimeEventController({
     }
   }
 
-  function mergeTaskProgressItem(items, nextItem) {
-    const normalizedTitle = nextItem.title.trim().toLowerCase();
-    const normalizedId = nextItem.id.trim();
-    const existingIndex = items.findIndex((item) => {
-      if (normalizedId && item.id === normalizedId) return true;
-      return item.title.trim().toLowerCase() === normalizedTitle;
-    });
-    if (existingIndex < 0) {
-      items.push(nextItem);
-      return;
-    }
-    items[existingIndex] = {
-      ...items[existingIndex],
-      ...nextItem,
-      id: nextItem.id || items[existingIndex].id,
-      title: nextItem.title || items[existingIndex].title,
-      status: nextItem.status || items[existingIndex].status,
-    };
-  }
-
   function updateTaskProgress(message) {
-    const plan = getPlanPayload(message);
-    const item = getPlanItemPayload(message);
-    const snapshot = getRecord(message.progressSnapshot);
-    const planningSignal =
-      Boolean(plan || item || snapshot) ||
-      textOf(message.name).startsWith("Planner ") ||
-      textOf(message.name).startsWith("Development progress:");
-    if (!planningSignal) return;
-    const requestId = textOf(message.requestId) || state.activeRequestId;
-    if (!requestId) return;
-    const current = state.taskProgressByRequest.get(requestId) || {
-      requestId,
-      summary: "",
-      total: 0,
-      completed: 0,
-      requestSatisfaction: "",
-      items: [],
-      hasSignal: false,
-    };
-    const next = {
-      ...current,
-      requestId,
-      summary:
-        plan?.summary || textOf(snapshot?.summary) || current.summary || "",
-      total: plan?.total ?? current.total,
-      completed: plan?.completed ?? current.completed,
-      requestSatisfaction:
-        textOf(snapshot?.requestSatisfaction) || current.requestSatisfaction,
-      items: [...current.items],
-      hasSignal: true,
-    };
-    for (const planItem of plan?.items || [])
-      mergeTaskProgressItem(next.items, planItem);
-    if (item) mergeTaskProgressItem(next.items, item);
-    if (!next.summary && Array.isArray(snapshot?.requestedWork)) {
-      next.summary =
-        snapshot.requestedWork.map(textOf).filter(Boolean)[0] || "";
-    }
-    if (!next.total && next.items.length > 0) next.total = next.items.length;
-    if (next.items.length > 0) {
-      next.completed = Math.max(
-        next.completed,
-        next.items.filter((entry) => entry.status === "done").length,
-      );
-    }
-    next.activeItem =
-      next.items.find((entry) => taskStatusClass(entry.status) === "active")
-        ?.title || "";
-    state.taskProgressByRequest.set(requestId, next);
+    const requestId = textOf(message.requestId);
+    const current = state.taskProgressByRequest.get(requestId);
+    const next = reduceTaskProgress(current, message);
+    if (next && next !== current)
+      state.taskProgressByRequest.set(requestId, next);
   }
 
   function updateContextWindow(message) {
@@ -195,7 +140,7 @@ export function createRealtimeEventController({
         lastCompaction,
         pendingCompaction: lastCompaction ? null : current.pendingCompaction,
       });
-      return;
+      return true;
     }
     if (eventName === "context.window.provider_usage") {
       state.contextWindowByRequest.set(requestId, {
@@ -211,19 +156,21 @@ export function createRealtimeEventController({
           totalTokens: Number(message.totalTokens),
         },
       });
-      return;
+      return true;
     }
     if (eventName === "context.compaction.started") {
       state.contextWindowByRequest.set(requestId, {
         ...current,
         requestId,
         pendingCompaction: {
-          beforePercent: Number.isFinite(Number(message.beforeUsedContextPercent))
+          beforePercent: Number.isFinite(
+            Number(message.beforeUsedContextPercent),
+          )
             ? Number(message.beforeUsedContextPercent)
             : current.snapshot?.usedContextPercent,
         },
       });
-      return;
+      return true;
     }
     if (eventName === "context.compaction.completed") {
       const beforePercent = Number(message.beforeUsedContextPercent);
@@ -237,7 +184,7 @@ export function createRealtimeEventController({
             ? { beforePercent, afterPercent }
             : current.lastCompaction,
       });
-      return;
+      return true;
     }
     if (eventName === "context.compaction.failed") {
       state.contextWindowByRequest.set(requestId, {
@@ -245,12 +192,22 @@ export function createRealtimeEventController({
         requestId,
         pendingCompaction: null,
       });
+      return true;
     }
   }
 
   function recordEvent(message) {
+    const requestId = textOf(message.requestId) || state.activeRequestId;
+    const eventSequence = hasOriginalEventSequence(message.eventSequence)
+      ? message.eventSequence
+      : undefined;
+    if (hasRecordedOriginalEvent(state.events, requestId, eventSequence)) {
+      trackSeq(message);
+      return;
+    }
     updateTaskProgress(message);
-    updateContextWindow(message);
+    const contextWindowUpdated = updateContextWindow(message);
+    if (contextWindowUpdated) renderContextWindow();
     const eventName = textOf(message.name || message.rawType || message.type);
     if (isLowValueActivityEvent(message)) {
       trackSeq(message);
@@ -259,10 +216,14 @@ export function createRealtimeEventController({
     const name = formatEventLabel(message);
     const summary = formatEventDetail(message);
     const tone = eventTone(message);
-    const key = eventKeyFor(message, name, tone);
-    const requestId = textOf(message.requestId) || state.activeRequestId;
+    const stage = textOf(message.stage);
+    const phase = textOf(message.phase);
+    const key = eventKeyFor({ ...message, requestId }, name, tone);
+    const webSources = projectWebSourceEvent(message);
     const lastEvent = state.events[state.events.length - 1];
-    if (lastEvent?.key && lastEvent.key === key) {
+    if (
+      canMergeUnsequencedActivity(lastEvent, key, eventSequence, webSources)
+    ) {
       lastEvent.count = (lastEvent.count || 1) + 1;
       lastEvent.summary = summary;
       lastEvent.updatedAt = Date.now();
@@ -278,15 +239,19 @@ export function createRealtimeEventController({
         count: 1,
         lastSeqNo:
           typeof message.seqNo === "number" ? message.seqNo : undefined,
+        eventSequence,
         updatedAt: Date.now(),
         type: message.type,
         rawType: message.rawType,
         eventName,
+        stage,
+        phase,
         name,
         summary,
         tone,
         tool: textOf(message.tool),
         approvalId: textOf(message.approvalId),
+        ...(webSources ? { webSources } : {}),
         payload: {
           plan: message.plan,
           item: message.item,

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;
+};

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;
+};