@abot-ai/runtime 1.0.0 → 1.1.0

package/dist/src/web-ui/app/app.js

@@ -3,6 +3,8 @@ import { createConfigWorkspace } from "./components/config-workspace.js";
 import { createComposerActions } from "./components/composer-actions.js";
 import { createModelSelector } from "./components/model-selector.js";
 import { createRuntimeSetupGuide } from "./components/runtime-setup-guide.js";
+import { createLongTermMemorySetup } from "./components/long-term-memory-setup.js";
+import { createLongTermMemoryManager } from "./components/long-term-memory/manager.js";
 import { createSessionActionsMenu } from "./components/session-actions-menu.js";
 import { createToolApprovalCard } from "./components/tool-approval-card.js";
 import { textOf } from "./lib/text-format.js";
@@ -24,6 +26,7 @@ import { createConversationSessionController } from "./controllers/conversation-
 import { createChatRequestController } from "./controllers/chat-request-controller.js";
 import { createToolApprovalController } from "./controllers/tool-approval-controller.js";
 import { createComposerSubmitController } from "./controllers/composer-submit-controller.js";
+import { createLongTermMemoryController } from "./controllers/long-term-memory/controller.js";
 
 const state = {
   config: null,
@@ -123,10 +126,6 @@ const dom = {
   refreshConfigButton: document.getElementById("refreshConfigButton"),
   configStatus: document.getElementById("configStatus"),
   configDashboard: document.getElementById("configDashboard"),
-  configRawFileSelect: document.getElementById("configRawFileSelect"),
-  configApplyRawButton: document.getElementById("configApplyRawButton"),
-  configSaveRawButton: document.getElementById("configSaveRawButton"),
-  configRawEditor: document.getElementById("configRawEditor"),
   panelBackdrop: document.getElementById("panelBackdrop"),
   toastRegion: document.getElementById("toastRegion"),
   operationsTabButtons: [
@@ -146,6 +145,7 @@ let composerQueueController;
 let composerSubmitController;
 let realtimeEvents;
 let conversationView;
+let configWorkspace;
 const operationsController = createOperationsController({
   dom,
   client: runtimeClient,
@@ -190,6 +190,11 @@ const steerController = createSteerController({
 
 const shell = createWorkspaceShell({
   dom,
+  beforeWorkspaceChange: ({ from, to }) => {
+    if (from !== "config" || to === "config") return true;
+    if (!configWorkspace) return true;
+    return configWorkspace.prepareDiscardChanges("leave configuration");
+  },
 });
 const runtimeSetupGuide = createRuntimeSetupGuide({
   container: dom.runtimeSetupGuide,
@@ -422,6 +427,7 @@ const appEventBindings = createAppEventBindings({
     saveSessionId: saveSessionIdForEnvironment,
     selectedEnvironmentId,
     rememberModelSelection: rememberCurrentModelSelection,
+    invalidateSessionLoads: conversationSession.invalidateEnvironmentLoads,
     clearAttachments: clearPendingAttachments,
     resetLiveRequestView: conversationSession.resetLiveRequestView,
     setCurrentSessionTitle,
@@ -429,10 +435,13 @@ const appEventBindings = createAppEventBindings({
     subscribeSession,
     renderMessages,
     renderAgentPicker,
+    savedEnvironmentId,
+    beforeEnvironmentChange: () =>
+      configWorkspace.prepareDiscardChanges("change environment"),
     saveEnvironmentId,
     loadModels,
     loadAgentMode,
-    loadRuntimeConfig: () => loadRuntimeConfig(),
+    loadRuntimeConfig: (options) => loadRuntimeConfig(options),
     restoreLastSession,
     configuredEnvironmentOptions,
     removeUnsupportedImages: removeUnsupportedPendingImages,
@@ -449,15 +458,46 @@ const appEventBindings = createAppEventBindings({
   },
 });
 
-const configWorkspace = createConfigWorkspace({
+const longTermMemorySetup = createLongTermMemorySetup({
+  getEnvironmentId: selectedEnvironmentId,
+  loadStatus: (environmentId) =>
+    runtimeClient.loadLongTermMemoryStatus(environmentId),
+  discoverModels: (providerId, environmentId) =>
+    runtimeClient.discoverLongTermMemoryModels({
+      environmentId,
+      providerId,
+    }),
+  enableMemory: (input, environmentId) =>
+    runtimeClient.enableLongTermMemory({
+      environmentId,
+      ...input,
+    }),
+  disableMemory: (environmentId) =>
+    runtimeClient.disableLongTermMemory(environmentId),
+  recordControlEvent,
+  beginRuntimeMutation: () =>
+    configWorkspace?.beginExternalRuntimeMutation() ?? false,
+  refreshRuntimeConfig: () =>
+    configWorkspace?.refreshAfterExternalRuntimeMutation() ??
+    Promise.resolve(false),
+  endRuntimeMutation: () => configWorkspace?.endExternalRuntimeMutation(),
+});
+
+let longTermMemoryManager;
+const longTermMemoryController = createLongTermMemoryController({
+  client: runtimeClient,
+  getEnvironmentId: selectedEnvironmentId,
+  render: (snapshot) => longTermMemoryManager?.render(snapshot),
+});
+longTermMemoryManager = createLongTermMemoryManager({
+  actions: longTermMemoryController,
+});
+
+configWorkspace = createConfigWorkspace({
   dom: {
     refreshConfigButton: dom.refreshConfigButton,
     configStatus: dom.configStatus,
     configDashboard: dom.configDashboard,
-    configRawFileSelect: dom.configRawFileSelect,
-    configApplyRawButton: dom.configApplyRawButton,
-    configSaveRawButton: dom.configSaveRawButton,
-    configRawEditor: dom.configRawEditor,
   },
   loadDashboard: () =>
     runtimeClient.loadConfigDashboard(selectedEnvironmentId()),
@@ -468,10 +508,15 @@ const configWorkspace = createConfigWorkspace({
       id,
       config,
     }),
+  memorySetup: longTermMemorySetup,
+  memoryManagement: {
+    load: () => longTermMemoryController.load(),
+    mount: (root) => longTermMemoryManager.mount(root),
+  },
   recordControlEvent,
 });
 
-const loadRuntimeConfig = () => configWorkspace.load();
+const loadRuntimeConfig = (options) => configWorkspace.load(options);
 
 function setConnectionLabel(text, isError = false) {
   dom.connectionLabel.textContent = text;

package/dist/src/web-ui/app/components/config-workspace/config-model.js

@@ -0,0 +1,320 @@
+import { textOf } from "../../lib/text-format.js";
+
+export const CONFIG_CATEGORIES = ["memory", "pipeline", "models", "advanced"];
+
+const DEFAULT_MODEL_EXECUTION_POLICY = "supervisor-worker-v1";
+
+export const MODEL_EXECUTION_ROUTES = Object.freeze({
+  "supervisor-worker-v1": Object.freeze({
+    label: "Supervisor",
+    description:
+      "Coordinates the request and may answer directly or delegate planning, execution, and review to specialist roles. Tools run through a Worker.",
+  }),
+  "execution-agent-v1": Object.freeze({
+    label: "Execution Agent",
+    description:
+      "Handles the request end to end and can run tools directly. It may consult a Planner or Auditor while remaining responsible for execution and the final response.",
+  }),
+});
+
+export function isConfigObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function cloneConfig(value) {
+  return JSON.parse(JSON.stringify(isConfigObject(value) ? value : {}));
+}
+
+function normalizeConfigForComparison(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeConfigForComparison);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort((left, right) => left.localeCompare(right))
+        .map((key) => [key, normalizeConfigForComparison(value[key])]),
+    );
+  }
+  return value;
+}
+
+export function configValuesEqual(left, right) {
+  return (
+    JSON.stringify(normalizeConfigForComparison(left)) ===
+    JSON.stringify(normalizeConfigForComparison(right))
+  );
+}
+
+export function rawConfigDraftHasChanges(draft, config) {
+  try {
+    const parsed = JSON.parse(textOf(draft));
+    return !isConfigObject(parsed) || !configValuesEqual(parsed, config);
+  } catch {
+    return true;
+  }
+}
+
+export function runtimeConfigGraphChanged(baseline, nextConfig) {
+  return !configValuesEqual(
+    {
+      models: baseline?.models,
+      requestRunner: baseline?.requestRunner,
+    },
+    {
+      models: nextConfig?.models,
+      requestRunner: nextConfig?.requestRunner,
+    },
+  );
+}
+
+function configDeclaresModelContextWindow(config) {
+  return (
+    isConfigObject(config) &&
+    Object.prototype.hasOwnProperty.call(config, "contextWindowTokens")
+  );
+}
+
+function modelContextWindowIsPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+export function modelContextWindowValidationError(config) {
+  if (!configDeclaresModelContextWindow(config)) return "";
+  return modelContextWindowIsPositiveSafeInteger(config.contextWindowTokens)
+    ? ""
+    : "Context window must be a positive integer within the safe numeric range before this model can be saved.";
+}
+
+export function resolveModelExecutionRoute(policy) {
+  const configuredPolicy = textOf(policy).trim();
+  const resolvedPolicy = configuredPolicy || DEFAULT_MODEL_EXECUTION_POLICY;
+  const route = MODEL_EXECUTION_ROUTES[resolvedPolicy];
+  return {
+    policy: resolvedPolicy,
+    label: route?.label || "Unsupported route",
+    description:
+      route?.description ||
+      `${resolvedPolicy} is not supported by this Runtime. Choose a supported route before saving.`,
+    implicit: configuredPolicy.length === 0,
+    supported: Boolean(route),
+  };
+}
+
+export function executionPolicyValueForConfig(selectedPolicy, baselinePolicy) {
+  const policy = resolveModelExecutionRoute(selectedPolicy).policy;
+  const baselineUsesImplicitDefault =
+    textOf(baselinePolicy).trim().length === 0;
+  return policy === DEFAULT_MODEL_EXECUTION_POLICY &&
+    baselineUsesImplicitDefault
+    ? undefined
+    : policy;
+}
+
+export function formattedConfig(config) {
+  return JSON.stringify(isConfigObject(config) ? config : {}, null, 2);
+}
+
+export function createConfigWorkspaceModel() {
+  const state = {
+    configDashboard: null,
+    baselinesByKey: new Map(),
+    rawDraftsByKey: new Map(),
+    savingKeys: new Set(),
+    savedKeys: new Set(),
+    expandedCalibrationKeys: new Set(),
+    selectedConfigModelId: "",
+    selectedRawConfigKey: "",
+    activeCategory: "memory",
+    rawPanelOpen: false,
+    loadGeneration: 0,
+    loading: false,
+    canonicalRefreshInFlight: false,
+    externalRuntimeMutationInFlight: false,
+    bound: false,
+  };
+
+  function configFileKey(file) {
+    return `${textOf(file?.kind)}:${textOf(file?.id)}`;
+  }
+
+  function configFileEntries() {
+    const files = state.configDashboard?.files;
+    if (!files) return [];
+    return [
+      files.runtime,
+      files.requestRunner,
+      ...(Array.isArray(files.models) ? files.models : []),
+    ].filter(Boolean);
+  }
+
+  function configFileMatchesIdentity(file, kind, id) {
+    return file.kind === kind && (!id || file.id === id);
+  }
+
+  function findConfigFile(kind, id = "") {
+    return configFileEntries().find((file) =>
+      configFileMatchesIdentity(file, kind, id),
+    );
+  }
+
+  function findConfigFileByKey(key) {
+    return configFileEntries().find((file) => configFileKey(file) === key);
+  }
+
+  function captureBaselines() {
+    state.baselinesByKey.clear();
+    state.rawDraftsByKey.clear();
+    state.savedKeys.clear();
+    for (const file of configFileEntries()) {
+      const key = configFileKey(file);
+      state.baselinesByKey.set(key, cloneConfig(file.config));
+      state.rawDraftsByKey.set(key, formattedConfig(file.config));
+    }
+  }
+
+  function baselineFor(file) {
+    return state.baselinesByKey.get(configFileKey(file));
+  }
+
+  function isFileDirty(file) {
+    const baseline = baselineFor(file);
+    return baseline ? !configValuesEqual(file.config, baseline) : false;
+  }
+
+  function rawDraftFor(file) {
+    const key = configFileKey(file);
+    return state.rawDraftsByKey.has(key)
+      ? state.rawDraftsByKey.get(key)
+      : formattedConfig(file.config);
+  }
+
+  function hasRawDraftChanges(file) {
+    return rawConfigDraftHasChanges(rawDraftFor(file), file.config);
+  }
+
+  function hasPendingFileChanges(file) {
+    return isFileDirty(file) || hasRawDraftChanges(file);
+  }
+
+  function dirtyFiles() {
+    return configFileEntries().filter(hasPendingFileChanges);
+  }
+
+  function hasUnsavedChanges() {
+    return dirtyFiles().length > 0;
+  }
+
+  function dashboardIsBusy() {
+    return (
+      state.loading ||
+      state.canonicalRefreshInFlight ||
+      state.externalRuntimeMutationInFlight
+    );
+  }
+
+  function getConfigPathValue(config, path) {
+    let current = config;
+    for (const key of path) {
+      if (!current || typeof current !== "object") return undefined;
+      current = current[key];
+    }
+    return current;
+  }
+
+  function setConfigPathValue(config, path, value) {
+    let current = config;
+    for (let index = 0; index < path.length - 1; index += 1) {
+      const key = path[index];
+      if (!current[key] || typeof current[key] !== "object") {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    current[path[path.length - 1]] = value;
+  }
+
+  function deleteConfigPathValue(config, path) {
+    let current = config;
+    for (let index = 0; index < path.length - 1; index += 1) {
+      const key = path[index];
+      if (!current?.[key] || typeof current[key] !== "object") return;
+      current = current[key];
+    }
+    delete current[path[path.length - 1]];
+  }
+
+  function pruneEmptyExecutionConfig(config) {
+    if (
+      isConfigObject(config.execution) &&
+      Object.keys(config.execution).length === 0
+    ) {
+      delete config.execution;
+    }
+  }
+
+  function parseConfigPath(value) {
+    try {
+      const parsed = JSON.parse(textOf(value));
+      return Array.isArray(parsed) ? parsed.map(textOf) : [];
+    } catch {
+      return [];
+    }
+  }
+
+  function parseNumericConfigInputValue(input) {
+    if (input.value.trim() === "") return undefined;
+    const value = Number(input.value);
+    return Number.isFinite(value) ? value : undefined;
+  }
+
+  function parseConfigInputValue(input, file, path) {
+    const type = input.dataset.valueType || "string";
+    if (type === "boolean") return input.checked;
+    if (type === "number") return parseNumericConfigInputValue(input);
+    if (type === "execution-policy") {
+      return executionPolicyValueForConfig(
+        input.value,
+        getConfigPathValue(baselineFor(file), path),
+      );
+    }
+    return input.value;
+  }
+
+  function ensureRawSelection(files = configFileEntries()) {
+    if (
+      !files.some((file) => configFileKey(file) === state.selectedRawConfigKey)
+    ) {
+      state.selectedRawConfigKey = files[0] ? configFileKey(files[0]) : "";
+    }
+  }
+
+  function selectedRawConfigFile() {
+    return findConfigFileByKey(state.selectedRawConfigKey);
+  }
+
+  return {
+    state,
+    baselineFor,
+    captureBaselines,
+    configFileEntries,
+    configFileKey,
+    dashboardIsBusy,
+    deleteConfigPathValue,
+    dirtyFiles,
+    ensureRawSelection,
+    findConfigFile,
+    findConfigFileByKey,
+    getConfigPathValue,
+    hasPendingFileChanges,
+    hasRawDraftChanges,
+    hasUnsavedChanges,
+    isFileDirty,
+    parseConfigInputValue,
+    parseConfigPath,
+    pruneEmptyExecutionConfig,
+    rawDraftFor,
+    selectedRawConfigFile,
+    setConfigPathValue,
+  };
+}

package/dist/src/web-ui/app/components/config-workspace/dashboard-rendering.js

@@ -0,0 +1,155 @@
+import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+
+export function createConfigDashboardRendering({
+  state,
+  configFileEntries,
+  configFileKey,
+  ensureRawSelection,
+  fileStatusText,
+  hasRawDraftChanges,
+  isFileDirty,
+  rawDraftFor,
+  selectedRawConfigFile,
+}) {
+  function rawConfigStatusText(file, rawDraftIsDirty) {
+    if (!file) return "No config files";
+    if (rawDraftIsDirty) return "Draft not applied";
+    return fileStatusText(file);
+  }
+
+  function renderRawConfigPanel() {
+    const files = configFileEntries();
+    ensureRawSelection(files);
+    const file = selectedRawConfigFile();
+    const rawDirty = file ? hasRawDraftChanges(file) : false;
+    const fileDirty = file ? isFileDirty(file) : false;
+    const pending = rawDirty || fileDirty;
+    const saving = file ? state.savingKeys.has(configFileKey(file)) : false;
+    const status = rawConfigStatusText(file, rawDirty);
+    return `
+      <details
+        id="configRawPanel"
+        class="config-raw-panel"
+        ${state.rawPanelOpen ? "open" : ""}
+      >
+        <summary>Raw JSON</summary>
+        <div class="config-raw-toolbar">
+          <label class="config-raw-file-select">
+            <span>Config file</span>
+            <select id="configRawFileSelect" title="Config file" ${
+              file ? "" : "disabled"
+            }>
+              ${files
+                .map(
+                  (item) =>
+                    `<option value="${escapeAttribute(configFileKey(item))}" ${
+                      configFileKey(item) === state.selectedRawConfigKey
+                        ? "selected"
+                        : ""
+                    }>${escapeHtml(item.label)}</option>`,
+                )
+                .join("")}
+            </select>
+          </label>
+          <span
+            class="config-raw-status ${pending ? "dirty" : ""}"
+            role="status"
+            aria-live="polite"
+          >${escapeHtml(status)}</span>
+          <div class="config-file-actions">
+            <button
+              id="configApplyRawButton"
+              type="button"
+              data-config-action="apply-raw"
+              ${rawDirty && !saving ? "" : "disabled"}
+            >Apply draft</button>
+            <button
+              type="button"
+              data-config-action="reset-file"
+              data-kind="${escapeAttribute(file?.kind || "")}"
+              data-id="${escapeAttribute(file?.id || "")}"
+              ${pending && !saving ? "" : "disabled"}
+            >Reset</button>
+            <button
+              id="configSaveRawButton"
+              type="button"
+              data-config-action="save-raw"
+              ${pending && !saving ? "" : "disabled"}
+            >Save file</button>
+          </div>
+        </div>
+        <textarea
+          id="configRawEditor"
+          class="config-view"
+          aria-label="Raw JSON configuration"
+          spellcheck="false"
+          ${file ? "" : "disabled"}
+        >${escapeHtml(file ? rawDraftFor(file) : "")}</textarea>
+      </details>
+    `;
+  }
+
+  function renderConfigMap() {
+    return `
+      <section class="config-section config-files-section">
+        <div class="config-section-header">
+          <div class="config-file-meta">
+            <h3>Config files</h3>
+            <p>Files linked by the active runtime configuration.</p>
+          </div>
+        </div>
+        <div class="config-file-list">
+          ${configFileEntries()
+            .map(
+              (file) => `
+                <div class="config-file-row">
+                  <span>${escapeHtml(file.label)}</span>
+                  <code>${escapeHtml(file.path)}</code>
+                </div>
+              `,
+            )
+            .join("")}
+        </div>
+      </section>
+      ${renderRawConfigPanel()}
+    `;
+  }
+
+  function renderCategoryTab(category, label) {
+    const active = state.activeCategory === category;
+    return `
+      <button
+        id="configCategory${category[0].toUpperCase()}${category.slice(1)}"
+        class="config-category-tab ${active ? "active" : ""}"
+        type="button"
+        role="tab"
+        data-config-action="select-category"
+        data-config-category="${escapeAttribute(category)}"
+        aria-controls="config${category[0].toUpperCase()}${category.slice(1)}Panel"
+        aria-selected="${active ? "true" : "false"}"
+        tabindex="${active ? "0" : "-1"}"
+      >${escapeHtml(label)}</button>
+    `;
+  }
+
+  function renderCategoryPanel(category, content) {
+    const capitalized = `${category[0].toUpperCase()}${category.slice(1)}`;
+    const active = state.activeCategory === category;
+    return `
+      <section
+        id="config${capitalized}Panel"
+        class="config-category-panel ${active ? "active" : ""}"
+        role="tabpanel"
+        aria-labelledby="configCategory${capitalized}"
+        data-config-category-panel="${escapeAttribute(category)}"
+        ${active ? "" : "hidden"}
+      >${content}</section>
+    `;
+  }
+
+  return {
+    renderCategoryPanel,
+    renderCategoryTab,
+    renderConfigMap,
+  };
+}