@abot-ai/runtime 1.6.0 → 1.8.0

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

@@ -0,0 +1,180 @@
+import { isConfigObject } from "./config-model.js";
+
+export function modelPluginRulesNeedRepair(config) {
+  if (config.plugins === undefined) return false;
+  if (!isConfigObject(config.plugins)) return true;
+  if (config.plugins.deny === undefined) return false;
+  if (!Array.isArray(config.plugins.deny)) return true;
+  return config.plugins.deny.some((value) => typeof value !== "string");
+}
+
+function modelDeniedSelectors(config) {
+  if (modelPluginRulesNeedRepair(config)) return [];
+  return (config.plugins?.deny || []).map((entry) => entry.trim());
+}
+
+// Browser projection of the existing deny contract; Runtime remains its enforcer.
+function selectorMatchesCapability(selector, pluginId, capabilityId) {
+  return (
+    selector === "*" ||
+    selector === pluginId ||
+    selector === capabilityId ||
+    selector === `${pluginId}.${capabilityId}`
+  );
+}
+
+function selectorEscapesModelTarget(plugins, pluginId, capabilityId, selector) {
+  return plugins.some((plugin) =>
+    (plugin.capabilities || []).some((capability) => {
+      if (plugin.id === pluginId && capabilityId === undefined) return false;
+      if (plugin.id === pluginId && capability.id === capabilityId)
+        return false;
+      return selectorMatchesCapability(selector, plugin.id, capability.id);
+    }),
+  );
+}
+
+function modelPluginGlobalBlockReason(plugin) {
+  if (plugin.blockedByGlobalPolicy)
+    return "Blocked by the global plugin policy.";
+  if (plugin.pluginEnabled === false)
+    return "Enable this plugin in global plugin settings first.";
+  if (plugin.state === "disabled")
+    return "No tools are available in global plugin settings.";
+  return "";
+}
+
+function modelPluginControlBlockReason(config, plugin, plugins, denied) {
+  if (modelPluginRulesNeedRepair(config))
+    return "Repair this model's plugin restrictions before changing tools.";
+  if (denied.includes("*"))
+    return "The saved * rule blocks every plugin for this model.";
+  const globalReason = modelPluginGlobalBlockReason(plugin);
+  if (globalReason) return globalReason;
+  if (selectorEscapesModelTarget(plugins, plugin.id, undefined, plugin.id))
+    return "This plugin selector also affects tools in another plugin. Review the saved rules.";
+  return "";
+}
+
+function modelCapabilityControlBlockReason(
+  config,
+  plugin,
+  capability,
+  plugins,
+  denied,
+) {
+  if (modelPluginRulesNeedRepair(config))
+    return "Repair this model's plugin restrictions before changing tools.";
+  if (denied.includes("*"))
+    return "The saved * rule blocks every tool for this model.";
+  if (denied.includes(plugin.id))
+    return "Enable this plugin for the model before changing individual tools.";
+  if (denied.includes(capability.id))
+    return "A shared tool restriction blocks this tool. Review the saved rules.";
+  const globalReason = modelPluginGlobalBlockReason(plugin);
+  if (globalReason) return globalReason;
+  if (capability.enabled !== true)
+    return (
+      capability.blockedReason ||
+      "This tool is unavailable in global plugin settings."
+    );
+  const selector = `${plugin.id}.${capability.id}`;
+  if (selectorEscapesModelTarget(plugins, plugin.id, capability.id, selector))
+    return "This tool selector also affects another tool. Review the saved rules.";
+  return "";
+}
+
+function modelCapabilityIsEnabled(config, plugin, capability, denied) {
+  if (modelPluginRulesNeedRepair(config)) return false;
+  if (modelPluginGlobalBlockReason(plugin)) return false;
+  if (capability.enabled !== true) return false;
+  return !denied.some((selector) =>
+    selectorMatchesCapability(selector, plugin.id, capability.id),
+  );
+}
+
+function modelPluginSelectionState(selectedCount, capabilityCount) {
+  if (selectedCount === 0) return "disabled";
+  if (selectedCount < capabilityCount) return "partial";
+  return "enabled";
+}
+
+export function projectModelPluginSelection(config, plugin, plugins) {
+  const denied = modelDeniedSelectors(config);
+  const capabilities = (plugin.capabilities || []).map((capability) => ({
+    ...capability,
+    enabled: modelCapabilityIsEnabled(config, plugin, capability, denied),
+    blockedReason: modelCapabilityControlBlockReason(
+      config,
+      plugin,
+      capability,
+      plugins,
+      denied,
+    ),
+  }));
+  const selectedCapabilityCount = capabilities.filter(
+    (capability) => capability.enabled,
+  ).length;
+  return {
+    ...plugin,
+    // The parent is configured separately from individual tools and global policy.
+    pluginEnabled:
+      !modelPluginRulesNeedRepair(config) &&
+      !denied.includes("*") &&
+      !denied.includes(plugin.id),
+    capabilities,
+    capabilityCount: capabilities.length,
+    selectedCapabilityCount,
+    state: modelPluginSelectionState(
+      selectedCapabilityCount,
+      capabilities.length,
+    ),
+    controlBlockedReason: modelPluginControlBlockReason(
+      config,
+      plugin,
+      plugins,
+      denied,
+    ),
+  };
+}
+
+function updateExactModelSelector(config, selector, enabled) {
+  const denied = config.plugins?.deny || [];
+  const matches = (entry) => entry.trim() === selector;
+  if (enabled && !denied.some(matches)) return false;
+  if (!enabled && denied.some(matches)) return false;
+  const next = enabled
+    ? denied.filter((entry) => !matches(entry))
+    : [...denied, selector];
+  config.plugins = { ...config.plugins, deny: next };
+  return true;
+}
+
+export function setModelPluginEnabled(config, plugins, pluginId, enabled) {
+  const plugin = plugins.find((entry) => entry.id === pluginId);
+  if (!plugin) return false;
+  const selection = projectModelPluginSelection(config, plugin, plugins);
+  if (selection.controlBlockedReason) return false;
+  return updateExactModelSelector(config, pluginId, enabled);
+}
+
+export function setModelCapabilityEnabled(
+  config,
+  plugins,
+  pluginId,
+  capabilityId,
+  enabled,
+) {
+  const plugin = plugins.find((entry) => entry.id === pluginId);
+  if (!plugin) return false;
+  const selection = projectModelPluginSelection(config, plugin, plugins);
+  const capability = selection.capabilities.find(
+    (entry) => entry.id === capabilityId,
+  );
+  if (!capability || capability.blockedReason) return false;
+  return updateExactModelSelector(
+    config,
+    `${pluginId}.${capabilityId}`,
+    enabled,
+  );
+}

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

@@ -0,0 +1,114 @@
+/** Model-scoped disclosures and keyboard position survive draft redraws. */
+export function createModelPluginViewState(root) {
+  const expandedSections = new Set();
+  const expandedPlugins = new Set();
+  const expandedRetainedRules = new Set();
+  let pendingFocus = null;
+  const detailSelector =
+    "details[data-model-plugin-section], details[data-model-plugin-details], details[data-model-plugin-retained]";
+  const controlSelector =
+    '[data-config-action="model-plugin-enabled"], [data-config-action="model-plugin-capability-enabled"], [data-model-plugin-section] > summary, [data-model-plugin-details] > summary, [data-model-plugin-retained] > summary';
+
+  function disclosureTarget(details) {
+    const data = details?.dataset;
+    if (!data) return null;
+    if (data.modelPluginSection)
+      return {
+        kind: "section",
+        set: expandedSections,
+        key: data.modelPluginSection,
+      };
+    if (data.modelPluginDetails)
+      return {
+        kind: "plugin",
+        set: expandedPlugins,
+        key: JSON.stringify([data.modelId, data.modelPluginDetails]),
+      };
+    if (data.modelPluginRetained)
+      return {
+        kind: "rules",
+        set: expandedRetainedRules,
+        key: data.modelPluginRetained,
+      };
+    return null;
+  }
+
+  function remember(details) {
+    if (details?.isConnected === false) return;
+    const target = disclosureTarget(details);
+    if (!target) return;
+    if (details.open) {
+      target.set.add(target.key);
+      return;
+    }
+    target.set.delete(target.key);
+  }
+
+  function controlKey(element) {
+    const data = element?.dataset;
+    if (!data) return null;
+    if (data.configAction === "model-plugin-enabled")
+      return JSON.stringify(["plugin", data.id, data.pluginId]);
+    if (data.configAction === "model-plugin-capability-enabled")
+      return JSON.stringify([
+        "capability",
+        data.id,
+        data.pluginId,
+        data.capabilityId,
+      ]);
+    if (element.tagName !== "SUMMARY") return null;
+    const details = element.parentElement;
+    const target = disclosureTarget(details);
+    if (!target) return null;
+    return JSON.stringify(["disclosure", target.kind, target.key]);
+  }
+
+  function capture() {
+    for (const details of root.querySelectorAll(detailSelector))
+      remember(details);
+    const active = root.ownerDocument?.activeElement;
+    const key = root.contains?.(active) ? controlKey(active) : null;
+    const viewport = key ? root.closest?.(".config-workspace-body") : null;
+    pendingFocus = key
+      ? { key, viewport, scrollTop: viewport?.scrollTop || 0 }
+      : null;
+  }
+
+  function canRestoreControlFocus(target) {
+    if (!target || target.isConnected === false || target.disabled)
+      return false;
+    if (target.closest?.("[hidden], [inert]")) return false;
+    if (target.getClientRects?.().length === 0) return false;
+    return true;
+  }
+
+  function restore() {
+    const focus = pendingFocus;
+    pendingFocus = null;
+    if (!focus) return;
+    const target = [...root.querySelectorAll(controlSelector)].find(
+      (element) => controlKey(element) === focus.key,
+    );
+    if (!canRestoreControlFocus(target)) return;
+    target.focus?.({ preventScroll: true });
+    if (focus.viewport && focus.viewport.isConnected !== false)
+      focus.viewport.scrollTop = focus.scrollTop;
+  }
+
+  function reset() {
+    expandedSections.clear();
+    expandedPlugins.clear();
+    expandedRetainedRules.clear();
+    pendingFocus = null;
+  }
+
+  return {
+    expandedSections,
+    expandedPlugins,
+    expandedRetainedRules,
+    remember,
+    capture,
+    restore,
+    reset,
+  };
+}

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

@@ -1,6 +1,7 @@
 import { configRequiresRawRepair } from "./raw-config-repair.js";
 import { escapeAttribute, escapeHtml, textOf } from "../../lib/text-format.js";
 import { isConfigObject } from "./config-model.js";
+import { renderModelPluginPermissions } from "./model-plugin-permissions.js";
 
 function modelListStatus(model, hasImage) {
   if (model.registered === false) return "Not registered";
@@ -15,6 +16,7 @@ function renderModelRegistrationAction(model) {
 }
 
 export function createConfigModelRendering({
+  modelPluginViewState,
   state,
   calibrationProfileLabel,
   configFileKey,
@@ -240,6 +242,7 @@ export function createConfigModelRendering({
           </div>
           ${renderExecutionRoute(model)}
         </div>
+        ${renderModelPluginPermissions(model, state.modelPluginCatalog, modelPluginViewState)}
         <details
           class="config-calibration-section"
           data-calibration-section-key="${escapeAttribute(calibrationSectionKey)}"

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

@@ -0,0 +1,39 @@
+function modelSupportsImageInput(model) {
+  const modalities = model.config?.capabilities?.inputModalities;
+  return Array.isArray(modalities) && modalities.includes("image");
+}
+
+function modelSummaryUnavailableValue(state) {
+  if (state.loading) return "Loading…";
+  if (state.configDashboardError) return "Unavailable";
+  if (!state.configDashboard?.files) return "Not loaded";
+  return null;
+}
+
+function modelChangesLabel(count) {
+  if (count === 0) return "All saved";
+  return `${count} unsaved ${count === 1 ? "model" : "models"}`;
+}
+
+export function modelSummary(state, hasPendingFileChanges) {
+  const labels = ["Registered models", "Providers", "Image input", "Model changes"];
+  const unavailable = modelSummaryUnavailableValue(state);
+  if (unavailable) return {
+    label: "Models summary",
+    items: labels.map((label) => ({ label, value: unavailable })),
+  };
+  const models = Array.isArray(state.configDashboard.files.models)
+    ? state.configDashboard.files.models : [];
+  const registered = models.filter((model) => model.registered === true);
+  const providers = new Set(registered.map((model) => model.config?.provider).filter(Boolean));
+  const pending = models.filter(hasPendingFileChanges).length;
+  return {
+    label: "Models summary",
+    items: [
+      { label: labels[0], value: String(registered.length) },
+      { label: labels[1], value: String(providers.size) },
+      { label: labels[2], value: String(registered.filter(modelSupportsImageInput).length) },
+      { label: labels[3], value: modelChangesLabel(pending), status: true, dirty: pending > 0 },
+    ],
+  };
+}

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

@@ -0,0 +1,30 @@
+import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+
+const renderedSummaries = new WeakMap();
+
+function renderSummaryItems(summary) {
+  return summary.items.map(({ label, value, status, dirty }) => `
+    <div class="config-summary-item">
+      <dt>${escapeHtml(label)}</dt>
+      <dd class="config-summary-value${dirty ? " dirty" : ""}"
+        title="${escapeAttribute(value)}"
+        ${status ? 'data-config-summary-status role="status" aria-live="polite"' : ""}
+      >${escapeHtml(value)}</dd>
+    </div>
+  `).join("");
+}
+
+export function renderConfigurationSummary(summary) {
+  return `<dl class="config-summary" data-config-summary aria-label="${escapeAttribute(summary.label)}">${renderSummaryItems(summary)}</dl>`;
+}
+
+export function syncConfigurationSummary(root, summary) {
+  const element = root.querySelector("[data-config-summary]");
+  if (!element) return;
+  const content = renderSummaryItems(summary);
+  const previous = renderedSummaries.get(element);
+  if (previous?.content === content && previous.label === summary.label) return;
+  element.setAttribute("aria-label", summary.label);
+  element.innerHTML = content;
+  renderedSummaries.set(element, { content, label: summary.label });
+}

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

@@ -1,8 +1,13 @@
 import { rememberCalibrationDisclosure } from "./calibration-disclosure.js";
 import { textOf } from "../../lib/text-format.js";
 import { resolveModelExecutionRoute } from "./config-model.js";
+import {
+  setModelPluginEnabled,
+  setModelCapabilityEnabled,
+} from "./model-plugin-selection.js";
 
 export function createConfigWorkspaceEvents({
+  modelPluginViewState,
   state,
   dom,
   eventTarget,
@@ -91,6 +96,37 @@ export function createConfigWorkspaceEvents({
     const actionElement = element?.closest?.("[data-config-action]");
     if (!actionElement) return;
     const action = actionElement.dataset.configAction;
+    if (action === "model-plugin-enabled") {
+      mutateConfigFile(
+        "model",
+        actionElement.dataset.id,
+        (config) =>
+          setModelPluginEnabled(
+            config,
+            state.modelPluginCatalog?.plugins || [],
+            actionElement.dataset.pluginId,
+            actionElement.checked,
+          ),
+        { rerender: true },
+      );
+      return;
+    }
+    if (action === "model-plugin-capability-enabled") {
+      mutateConfigFile(
+        "model",
+        actionElement.dataset.id,
+        (config) =>
+          setModelCapabilityEnabled(
+            config,
+            state.modelPluginCatalog?.plugins || [],
+            actionElement.dataset.pluginId,
+            actionElement.dataset.capabilityId,
+            actionElement.checked,
+          ),
+        { rerender: true },
+      );
+      return;
+    }
     if (action === "step-value") {
       handleFieldMutation(actionElement);
       return;
@@ -106,6 +142,7 @@ export function createConfigWorkspaceEvents({
       state.rawPanelOpen = details.open;
       return;
     }
+    modelPluginViewState?.remember(details);
     rememberCalibrationDisclosure(state, details);
   }
 

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

@@ -11,6 +11,7 @@ import {
 } from "./config-model.js";
 
 export function createConfigWorkspaceMutations({
+  modelPluginViewState,
   state,
   dom,
   confirmDiscard,
@@ -94,7 +95,7 @@ export function createConfigWorkspaceMutations({
       return null;
     }
     const changed = dirtyFiles();
-    if (!changed.length) return () => {};
+    if (!changed.length) return prepareConfigDiscardCommit(false);
     const count = changed.length;
     const confirmed = confirmDiscard(
       `Discard unsaved changes in ${count} config ${
@@ -102,7 +103,27 @@ export function createConfigWorkspaceMutations({
       } and ${reason}?`,
     );
     if (!confirmed) return null;
-    return discardAllChanges;
+    return prepareConfigDiscardCommit(true);
+  }
+
+  function configDraftFingerprint() {
+    return JSON.stringify(configFileEntries().map((file) => {
+      const key = configFileKey(file);
+      return [key, file.config, state.rawDraftsByKey.get(key), state.baselinesByKey.get(key), state.appliedJsonRepairKeys.has(key)];
+    }));
+  }
+
+  function prepareConfigDiscardCommit(hasChanges) {
+    const dashboard = state.configDashboard;
+    const fingerprint = configDraftFingerprint();
+    const commit = () => { if (hasChanges) discardAllChanges(); };
+    commit.canCommit = () => {
+      if (state.externalRuntimeMutationInFlight) return false;
+      if (state.savingKeys.size > 0) return false;
+      if (state.configDashboard !== dashboard) return false;
+      return configDraftFingerprint() === fingerprint;
+    };
+    return commit;
   }
 
   function confirmDiscardChanges(reason = "leave configuration") {
@@ -125,6 +146,7 @@ export function createConfigWorkspaceMutations({
   }
 
   function clearDashboardSnapshot() {
+    modelPluginViewState?.reset();
     state.configDashboard = null;
     state.baselinesByKey.clear();
     state.rawDraftsByKey.clear();

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

@@ -1,5 +1,6 @@
 import { configRepairSaveIsConfirmed } from "./raw-config-repair.js";
 import { textOf } from "../../lib/text-format.js";
+import { loadModelPluginCatalog } from "./model-plugin-permissions.js";
 import {
   cloneConfig,
   modelContextWindowValidationError,
@@ -10,6 +11,7 @@ export function createConfigWorkspacePersistence({
   state,
   dom,
   loadDashboard,
+  loadModelPlugins,
   saveFile,
   memorySetup,
   memoryManagement,
@@ -84,11 +86,16 @@ export function createConfigWorkspacePersistence({
     }
     const loadGeneration = ++state.loadGeneration;
     state.loading = true;
+    state.configDashboardError = false;
     setWorkspaceStatus("Loading…");
     syncDashboardInteractivity();
     try {
-      const payload = await loadDashboard();
+      const [payload, modelPluginCatalog] = await Promise.all([
+        loadDashboard(),
+        loadModelPluginCatalog(loadModelPlugins),
+      ]);
       if (configLoadIsStale(loadGeneration)) return false;
+      state.modelPluginCatalog = modelPluginCatalog;
       replaceDashboard(payload);
       const memoryLoads = [memoryManagement.load()];
       if (pluginManagement) memoryLoads.push(pluginManagement.load());
@@ -115,6 +122,7 @@ export function createConfigWorkspacePersistence({
       return true;
     } catch (error) {
       if (configLoadIsStale(loadGeneration)) return false;
+      state.configDashboardError = true;
       const failurePrefix = textOf(options.failurePrefix).trim();
       const summary = error instanceof Error ? error.message : String(error);
       setWorkspaceStatus(