@abot-ai/runtime 1.0.0 → 1.2.0

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

@@ -0,0 +1,271 @@
+import { textOf } from "../../lib/text-format.js";
+import {
+  CONFIG_CATEGORIES,
+  resolveModelExecutionRoute,
+} from "./config-model.js";
+
+export function createConfigWorkspaceEvents({
+  state,
+  dom,
+  eventTarget,
+  activateCategory,
+  applyRawDraft,
+  changeRawFile,
+  configFileKey,
+  confirmDiscardChanges,
+  dashboardIsBusy,
+  deleteConfigPathValue,
+  findConfigFile,
+  hasUnsavedChanges,
+  loadRuntimeConfig,
+  mutateConfigFile,
+  parseConfigInputValue,
+  parseConfigPath,
+  pruneEmptyExecutionConfig,
+  renderConfigDashboard,
+  resetConfigFile,
+  saveConfigFile,
+  saveRawDraft,
+  selectedRawConfigFile,
+  setConfigPathValue,
+  setWorkspaceStatus,
+  syncDirtyPresentation,
+}) {
+  function configFieldUsesChangeEvent(element) {
+    return element.matches("select, input[type=checkbox]");
+  }
+
+  function applyConfigFieldValue(config, element, path, value) {
+    if (value !== undefined && value !== "") {
+      setConfigPathValue(config, path, value);
+      return;
+    }
+    deleteConfigPathValue(config, path);
+    if (element.dataset.valueType !== "execution-policy") return;
+    pruneEmptyExecutionConfig(config);
+  }
+
+  function syncExecutionRouteDescription(select) {
+    if (select.dataset.valueType !== "execution-policy") return;
+    const route = resolveModelExecutionRoute(select.value);
+    const container = select.closest("[data-config-execution-route]");
+    const label = container?.querySelector(
+      "[data-config-execution-route-label]",
+    );
+    const description = container?.querySelector(
+      "[data-config-execution-route-copy]",
+    );
+    if (label) label.textContent = route.label;
+    if (description) description.textContent = route.description;
+  }
+
+  function handleFieldMutation(element) {
+    const action = element.dataset.configAction;
+    const path = parseConfigPath(element.dataset.path);
+    const file = findConfigFile(element.dataset.kind, element.dataset.id);
+    if (!file) return;
+    const value =
+      action === "step-value"
+        ? element.value
+        : parseConfigInputValue(element, file, path);
+    mutateConfigFile(element.dataset.kind, element.dataset.id, (config) =>
+      applyConfigFieldValue(config, element, path, value),
+    );
+    syncExecutionRouteDescription(element);
+  }
+
+  function handleDashboardInput(event) {
+    if (dashboardIsBusy()) return;
+    const element = event.target?.closest?.("[data-config-action]");
+    if (!element || element.dataset.configAction !== "field") return;
+    if (configFieldUsesChangeEvent(element)) return;
+    handleFieldMutation(element);
+  }
+
+  function handleDashboardChange(event) {
+    if (dashboardIsBusy()) return;
+    const element = event.target;
+    if (element?.id === "configRawFileSelect") {
+      changeRawFile(element.value, element);
+      return;
+    }
+    const actionElement = element?.closest?.("[data-config-action]");
+    if (!actionElement) return;
+    const action = actionElement.dataset.configAction;
+    if (action === "step-value") {
+      handleFieldMutation(actionElement);
+      return;
+    }
+    if (action === "field" && configFieldUsesChangeEvent(actionElement)) {
+      handleFieldMutation(actionElement);
+    }
+  }
+
+  function handleCategoryKeydown(event, element) {
+    const keys = ["ArrowLeft", "ArrowRight", "Home", "End"];
+    if (!keys.includes(event.key)) return;
+    event.preventDefault();
+    const currentIndex = CONFIG_CATEGORIES.indexOf(
+      element.dataset.configCategory,
+    );
+    let nextIndex = currentIndex;
+    if (event.key === "Home") nextIndex = 0;
+    if (event.key === "End") nextIndex = CONFIG_CATEGORIES.length - 1;
+    if (event.key === "ArrowLeft") {
+      nextIndex =
+        (currentIndex - 1 + CONFIG_CATEGORIES.length) %
+        CONFIG_CATEGORIES.length;
+    }
+    if (event.key === "ArrowRight") {
+      nextIndex = (currentIndex + 1) % CONFIG_CATEGORIES.length;
+    }
+    activateCategory(CONFIG_CATEGORIES[nextIndex], { focus: true });
+  }
+
+  function handleDashboardKeydown(event) {
+    if (dashboardIsBusy()) return;
+    const element = event.target?.closest?.("[data-config-category]");
+    if (element) handleCategoryKeydown(event, element);
+  }
+
+  function handleDashboardToggle(event) {
+    const details = event.target;
+    if (details?.id === "configRawPanel") {
+      state.rawPanelOpen = details.open;
+      return;
+    }
+    const key = details?.dataset?.calibrationKey;
+    if (!key) return;
+    if (details.open) state.expandedCalibrationKeys.add(key);
+    else state.expandedCalibrationKeys.delete(key);
+  }
+
+  function stepMappingIsComplete(step, profile) {
+    return Boolean(step && profile);
+  }
+
+  function handleAddStepAction(element, kind, id) {
+    const row = element.closest(".config-add-row");
+    const step = textOf(
+      row?.querySelector("[data-new-step-key]")?.value,
+    ).trim();
+    const profile = textOf(
+      row?.querySelector("[data-new-step-value]")?.value,
+    ).trim();
+    if (!stepMappingIsComplete(step, profile)) return;
+    const path = parseConfigPath(element.dataset.path);
+    mutateConfigFile(
+      kind,
+      id,
+      (config) => setConfigPathValue(config, [...path, step], profile),
+      { rerender: true },
+    );
+  }
+
+  function handleAddCalibrationAction(element, kind, id) {
+    const row = element.closest(".config-add-row");
+    const step = textOf(
+      row?.querySelector("[data-new-calibration-key]")?.value,
+    ).trim();
+    if (!step) return;
+    const file = findConfigFile(kind, id);
+    if (!file) return;
+    state.expandedCalibrationKeys.add(`${configFileKey(file)}:${step}`);
+    mutateConfigFile(
+      kind,
+      id,
+      (config) =>
+        setConfigPathValue(config, ["calibration", step], {
+          generation: {},
+          context: {},
+        }),
+      { rerender: true },
+    );
+  }
+
+  function handleDashboardClick(event) {
+    if (dashboardIsBusy()) return;
+    const element = event.target?.closest?.("[data-config-action]");
+    if (!element) return;
+    const action = element.dataset.configAction;
+    const kind = element.dataset.kind;
+    const id = element.dataset.id;
+    if (action === "select-category") {
+      activateCategory(element.dataset.configCategory || "memory");
+      return;
+    }
+    if (action === "select-model") {
+      state.selectedConfigModelId = element.dataset.modelId || "";
+      renderConfigDashboard();
+      return;
+    }
+    if (action === "save-file") {
+      void saveConfigFile(kind, id).catch(() => {});
+      return;
+    }
+    if (action === "reset-file") {
+      resetConfigFile(kind, id);
+      return;
+    }
+    if (action === "apply-raw") {
+      applyRawDraft();
+      return;
+    }
+    if (action === "save-raw") {
+      void saveRawDraft().catch(() => {});
+      return;
+    }
+    if (action === "delete-path") {
+      const path = parseConfigPath(element.dataset.path);
+      mutateConfigFile(
+        kind,
+        id,
+        (config) => deleteConfigPathValue(config, path),
+        { rerender: true },
+      );
+      return;
+    }
+    if (action === "add-step") {
+      handleAddStepAction(element, kind, id);
+      return;
+    }
+    if (action === "add-calibration") {
+      handleAddCalibrationAction(element, kind, id);
+    }
+  }
+
+  function handleRawEditorInput(event) {
+    if (event.target?.id !== "configRawEditor") return;
+    const file = selectedRawConfigFile();
+    if (!file) return;
+    state.rawDraftsByKey.set(configFileKey(file), event.target.value);
+    state.savedKeys.delete(configFileKey(file));
+    setWorkspaceStatus("");
+    syncDirtyPresentation();
+  }
+
+  function handleBeforeUnload(event) {
+    if (!hasUnsavedChanges()) return;
+    event.preventDefault();
+    event.returnValue = "";
+  }
+
+  function bind() {
+    if (state.bound) return;
+    state.bound = true;
+    dom.refreshConfigButton.addEventListener("click", () => {
+      if (dashboardIsBusy()) return;
+      if (!confirmDiscardChanges("refresh configuration")) return;
+      void loadRuntimeConfig({ protectUnsaved: false });
+    });
+    dom.configDashboard.addEventListener("click", handleDashboardClick);
+    dom.configDashboard.addEventListener("input", handleDashboardInput);
+    dom.configDashboard.addEventListener("input", handleRawEditorInput);
+    dom.configDashboard.addEventListener("change", handleDashboardChange);
+    dom.configDashboard.addEventListener("keydown", handleDashboardKeydown);
+    dom.configDashboard.addEventListener("toggle", handleDashboardToggle, true);
+    eventTarget.addEventListener?.("beforeunload", handleBeforeUnload);
+  }
+
+  return { bind };
+}

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

@@ -0,0 +1,195 @@
+import { textOf } from "../../lib/text-format.js";
+import {
+  cloneConfig,
+  formattedConfig,
+  isConfigObject,
+} from "./config-model.js";
+
+export function createConfigWorkspaceMutations({
+  state,
+  dom,
+  confirmDiscard,
+  recordControlEvent,
+  captureBaselines,
+  configFileEntries,
+  configFileKey,
+  dirtyFiles,
+  ensureRawSelection,
+  findConfigFile,
+  hasRawDraftChanges,
+  rawDraftFor,
+  renderConfigDashboard,
+  selectedRawConfigFile,
+  setWorkspaceStatus,
+  syncDirtyPresentation,
+}) {
+  function mutateConfigFile(kind, id, mutator, options = {}) {
+    const file = findConfigFile(kind, id);
+    if (!file) return;
+    const key = configFileKey(file);
+    const shouldFollowStructuredConfig = !hasRawDraftChanges(file);
+    mutator(file.config);
+    state.savedKeys.delete(key);
+    if (shouldFollowStructuredConfig) {
+      state.rawDraftsByKey.set(key, formattedConfig(file.config));
+    }
+    if (options.rerender) {
+      renderConfigDashboard();
+      return;
+    }
+    syncDirtyPresentation({ syncRawEditor: shouldFollowStructuredConfig });
+  }
+
+  function resetConfigFile(kind, id) {
+    const file = findConfigFile(kind, id);
+    if (!file) return;
+    const key = configFileKey(file);
+    const baseline = state.baselinesByKey.get(key);
+    if (!baseline) return;
+    file.config = cloneConfig(baseline);
+    state.rawDraftsByKey.set(key, formattedConfig(baseline));
+    state.savedKeys.delete(key);
+    renderConfigDashboard();
+  }
+
+  function discardAllChanges() {
+    for (const file of configFileEntries()) {
+      const key = configFileKey(file);
+      const baseline = state.baselinesByKey.get(key);
+      if (!baseline) continue;
+      file.config = cloneConfig(baseline);
+      state.rawDraftsByKey.set(key, formattedConfig(baseline));
+    }
+    state.savedKeys.clear();
+    renderConfigDashboard();
+  }
+
+  function prepareDiscardChanges(reason = "leave configuration") {
+    if (state.externalRuntimeMutationInFlight) {
+      setWorkspaceStatus(
+        `Wait for the current Runtime update before you ${reason}.`,
+        "error-text",
+      );
+      return null;
+    }
+    if (state.savingKeys.size > 0) {
+      setWorkspaceStatus(
+        `Wait for the current save before you ${reason}.`,
+        "error-text",
+      );
+      return null;
+    }
+    const changed = dirtyFiles();
+    if (!changed.length) return () => {};
+    const count = changed.length;
+    const confirmed = confirmDiscard(
+      `Discard unsaved changes in ${count} config ${
+        count === 1 ? "file" : "files"
+      } and ${reason}?`,
+    );
+    if (!confirmed) return null;
+    return discardAllChanges;
+  }
+
+  function confirmDiscardChanges(reason = "leave configuration") {
+    const discardChanges = prepareDiscardChanges(reason);
+    if (!discardChanges) return false;
+    discardChanges();
+    return true;
+  }
+
+  function replaceDashboard(payload) {
+    state.configDashboard = payload.dashboard || null;
+    captureBaselines();
+    const models = state.configDashboard?.files?.models || [];
+    if (!models.some((model) => model.id === state.selectedConfigModelId)) {
+      state.selectedConfigModelId = models[0]?.id || "";
+    }
+    ensureRawSelection();
+    renderConfigDashboard();
+  }
+
+  function clearDashboardSnapshot() {
+    state.configDashboard = null;
+    state.baselinesByKey.clear();
+    state.rawDraftsByKey.clear();
+    state.savedKeys.clear();
+    state.selectedRawConfigKey = "";
+    dom.configDashboard.innerHTML = "";
+  }
+
+  function parseRawDraft(file) {
+    const editor = dom.configDashboard.querySelector("#configRawEditor");
+    const draft = editor?.value ?? rawDraftFor(file);
+    const parsed = JSON.parse(draft);
+    if (!isConfigObject(parsed)) {
+      throw new Error("Raw config must be a JSON object");
+    }
+    return parsed;
+  }
+
+  function reportInvalidRaw(error) {
+    const summary = error instanceof Error ? error.message : String(error);
+    setWorkspaceStatus(`Raw JSON: ${summary}`, "error-text");
+    recordControlEvent({
+      type: "control",
+      name: "Raw config invalid",
+      tone: "failed",
+      summary,
+    });
+  }
+
+  function applyRawDraft() {
+    const file = selectedRawConfigFile();
+    if (!file) return null;
+    try {
+      const parsed = parseRawDraft(file);
+      file.config = parsed;
+      const key = configFileKey(file);
+      state.rawDraftsByKey.set(key, formattedConfig(parsed));
+      state.savedKeys.delete(key);
+      setWorkspaceStatus("");
+      renderConfigDashboard();
+      return file;
+    } catch (error) {
+      reportInvalidRaw(error);
+      return null;
+    }
+  }
+
+  function keepOrDiscardCurrentRawDraft(currentFile, select) {
+    if (!currentFile || !hasRawDraftChanges(currentFile)) return true;
+    const confirmed = confirmDiscard(
+      `Discard the unapplied raw draft for ${textOf(
+        currentFile.label || currentFile.id,
+      )}?`,
+    );
+    if (!confirmed) {
+      select.value = state.selectedRawConfigKey;
+      return false;
+    }
+    state.rawDraftsByKey.set(
+      configFileKey(currentFile),
+      formattedConfig(currentFile.config),
+    );
+    return true;
+  }
+
+  function changeRawFile(nextKey, select) {
+    const currentFile = selectedRawConfigFile();
+    if (!keepOrDiscardCurrentRawDraft(currentFile, select)) return;
+    state.selectedRawConfigKey = nextKey;
+    syncDirtyPresentation({ syncRawEditor: true });
+  }
+
+  return {
+    applyRawDraft,
+    changeRawFile,
+    clearDashboardSnapshot,
+    confirmDiscardChanges,
+    mutateConfigFile,
+    prepareDiscardChanges,
+    replaceDashboard,
+    resetConfigFile,
+  };
+}

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

@@ -0,0 +1,247 @@
+import { textOf } from "../../lib/text-format.js";
+import {
+  cloneConfig,
+  modelContextWindowValidationError,
+  runtimeConfigGraphChanged,
+} from "./config-model.js";
+
+export function createConfigWorkspacePersistence({
+  state,
+  dom,
+  loadDashboard,
+  saveFile,
+  memorySetup,
+  memoryManagement,
+  recordControlEvent,
+  applyRawDraft,
+  baselineFor,
+  clearDashboardSnapshot,
+  configFileKey,
+  confirmDiscardChanges,
+  dashboardIsBusy,
+  dirtyFiles,
+  findConfigFile,
+  hasRawDraftChanges,
+  hasUnsavedChanges,
+  isFileDirty,
+  replaceDashboard,
+  setWorkspaceStatus,
+  syncDashboardInteractivity,
+  syncDirtyPresentation,
+}) {
+  function configLoadIsStale(loadGeneration) {
+    return loadGeneration !== state.loadGeneration;
+  }
+
+  function finishCurrentConfigLoad(loadGeneration) {
+    if (configLoadIsStale(loadGeneration)) return;
+    state.loading = false;
+    syncDashboardInteractivity();
+  }
+
+  function externalRuntimeMutationBlockReason() {
+    if (hasUnsavedChanges()) {
+      return "Save or reset configuration changes before changing Runtime memory settings.";
+    }
+    if (dashboardIsBusy() || state.savingKeys.size > 0) {
+      return "Wait for the current configuration operation before changing Runtime memory settings.";
+    }
+    return "";
+  }
+
+  function canonicalRefreshFailurePrefix(kind) {
+    return kind === "runtime"
+      ? "Runtime saved; refresh required"
+      : "Config saved; refresh required";
+  }
+
+  function canonicalDashboardRefreshOptions(kind) {
+    return {
+      protectUnsaved: false,
+      failurePrefix: canonicalRefreshFailurePrefix(kind),
+    };
+  }
+
+  function recordCanonicalRefreshFailure(refreshed) {
+    if (refreshed) return;
+    recordControlEvent({
+      type: "control",
+      name: "Config refresh required",
+      tone: "failed",
+      summary: textOf(dom.configStatus.textContent),
+    });
+  }
+
+  async function loadRuntimeConfig(options = {}) {
+    const protectUnsaved = options.protectUnsaved !== false;
+    if (protectUnsaved && !confirmDiscardChanges("refresh configuration")) {
+      return false;
+    }
+    if (options.clearBeforeLoad === true) {
+      clearDashboardSnapshot();
+    }
+    const loadGeneration = ++state.loadGeneration;
+    state.loading = true;
+    setWorkspaceStatus("Loading…");
+    syncDashboardInteractivity();
+    try {
+      const payload = await loadDashboard();
+      if (configLoadIsStale(loadGeneration)) return false;
+      replaceDashboard(payload);
+      const memoryLoads = [memoryManagement.load()];
+      if (options.loadMemorySetup !== false) {
+        memoryLoads.unshift(memorySetup.load());
+      }
+      const memoryResults = await Promise.allSettled(memoryLoads);
+      if (configLoadIsStale(loadGeneration)) return false;
+      const memoryFailure = memoryResults.find(
+        (result) => result.status === "rejected",
+      );
+      if (memoryFailure?.status === "rejected") {
+        const summary =
+          memoryFailure.reason instanceof Error
+            ? memoryFailure.reason.message
+            : String(memoryFailure.reason);
+        setWorkspaceStatus(
+          `Configuration loaded; memory controls unavailable: ${summary}`,
+          "error-text",
+        );
+      } else {
+        setWorkspaceStatus("");
+      }
+      return true;
+    } catch (error) {
+      if (configLoadIsStale(loadGeneration)) return false;
+      const failurePrefix = textOf(options.failurePrefix).trim();
+      const summary = error instanceof Error ? error.message : String(error);
+      setWorkspaceStatus(
+        failurePrefix ? `${failurePrefix}: ${summary}` : summary,
+        "error-text",
+      );
+      if (!state.configDashboard) {
+        dom.configDashboard.innerHTML = "";
+      }
+      return false;
+    } finally {
+      finishCurrentConfigLoad(loadGeneration);
+    }
+  }
+
+  function beginExternalRuntimeMutation() {
+    const blockReason = externalRuntimeMutationBlockReason();
+    if (blockReason) {
+      setWorkspaceStatus(blockReason, "error-text");
+      return false;
+    }
+    state.externalRuntimeMutationInFlight = true;
+    syncDashboardInteractivity();
+    return true;
+  }
+
+  async function refreshAfterExternalRuntimeMutation() {
+    if (!state.externalRuntimeMutationInFlight) return false;
+    return loadRuntimeConfig({
+      protectUnsaved: false,
+      clearBeforeLoad: true,
+      loadMemorySetup: false,
+      failurePrefix: "Memory updated; refresh required",
+    });
+  }
+
+  function endExternalRuntimeMutation() {
+    state.externalRuntimeMutationInFlight = false;
+    syncDashboardInteractivity();
+  }
+
+  async function saveConfigFile(kind, id) {
+    const file = findConfigFile(kind, id);
+    if (!file || !isFileDirty(file)) return;
+    const key = configFileKey(file);
+    const configToSave = cloneConfig(file.config);
+    const contextWindowError =
+      file.kind === "model"
+        ? modelContextWindowValidationError(configToSave)
+        : "";
+    if (contextWindowError) {
+      setWorkspaceStatus(contextWindowError, "error-text");
+      return false;
+    }
+    const refreshRuntimeGraph =
+      kind === "runtime" &&
+      runtimeConfigGraphChanged(baselineFor(file), configToSave);
+    const refreshCanonicalDashboard =
+      refreshRuntimeGraph || file.source?.type === "inlineModelProfile";
+    const rawDraftWasPending = hasRawDraftChanges(file);
+    if (refreshCanonicalDashboard && rawDraftWasPending) {
+      setWorkspaceStatus(
+        "Apply or reset the current raw draft before saving Runtime-linked configuration.",
+        "error-text",
+      );
+      return false;
+    }
+    const dirtyLinkedFiles = refreshCanonicalDashboard
+      ? dirtyFiles().filter((entry) => configFileKey(entry) !== key)
+      : [];
+    if (dirtyLinkedFiles.length > 0) {
+      setWorkspaceStatus(
+        "Save or reset linked config changes before updating Runtime-linked configuration.",
+        "error-text",
+      );
+      return false;
+    }
+    state.savingKeys.add(key);
+    state.canonicalRefreshInFlight = refreshCanonicalDashboard;
+    syncDashboardInteractivity();
+    syncDirtyPresentation();
+    try {
+      const result = await saveFile({ kind, id, config: configToSave });
+      state.baselinesByKey.set(key, cloneConfig(configToSave));
+      state.savedKeys.add(key);
+      recordControlEvent({
+        type: "control",
+        name: "Config saved",
+        tone: "done",
+        summary: result?.backupPath
+          ? `backup: ${result.backupPath}`
+          : "restart required",
+      });
+      if (refreshCanonicalDashboard) {
+        clearDashboardSnapshot();
+        const refreshed = await loadRuntimeConfig(
+          canonicalDashboardRefreshOptions(kind),
+        );
+        recordCanonicalRefreshFailure(refreshed);
+        return refreshed;
+      }
+      return true;
+    } catch (error) {
+      recordControlEvent({
+        type: "control",
+        name: "Config save failed",
+        tone: "failed",
+        summary: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    } finally {
+      state.savingKeys.delete(key);
+      state.canonicalRefreshInFlight = false;
+      syncDashboardInteractivity();
+      syncDirtyPresentation({ syncRawEditor: !rawDraftWasPending });
+    }
+  }
+
+  async function saveRawDraft() {
+    const file = applyRawDraft();
+    if (!file) return;
+    await saveConfigFile(file.kind, file.id);
+  }
+
+  return {
+    beginExternalRuntimeMutation,
+    endExternalRuntimeMutation,
+    loadRuntimeConfig,
+    refreshAfterExternalRuntimeMutation,
+    saveConfigFile,
+    saveRawDraft,
+  };
+}