@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/web-ui/app/components/runtime-setup/embedding.js

@@ -0,0 +1,284 @@
+import { applySavedEmbeddingProviderReceipt } from "./embedding-provider-receipt.js";
+import { textOf } from "../../lib/text-format.js";
+import { renderEmbeddingSetup } from "./embedding-rendering.js";
+import {
+  DEFAULT_OLLAMA_BASE_URL,
+  validateRuntimeSetupBaseUrl,
+  validateRuntimeSetupModelId,
+} from "./validation.js";
+
+export function createEmbeddingSetupStep({
+  container,
+  getEnvironmentId,
+  getPreferredProvider = () => "",
+  loadStatus,
+  discoverModels,
+  saveEmbedding,
+  onChange,
+  onComplete,
+}) {
+  const state = {
+    status: null,
+    providers: [],
+    provider: "",
+    model: "",
+    baseUrl: DEFAULT_OLLAMA_BASE_URL,
+    models: [],
+    busy: false,
+    loaded: false,
+    error: "",
+    message: "",
+  };
+  let loadedConnectionProvider = "";
+  let preferConnectionProvider = false;
+  let generation = 0;
+  const isCurrentEmbeddingOperation = (revision, environment) =>
+    revision === generation && environment === getEnvironmentId();
+  const selectedProvider = () =>
+    state.providers.find((entry) => entry.id === state.provider);
+  const selectedProviderType = () =>
+    selectedProvider()?.type || state.provider.replace("new:", "");
+  const hasUnchangedEmbeddingSelection = () =>
+    state.status?.enabled === true &&
+    state.provider === state.status.providerId &&
+    state.model.trim() === state.status.model;
+
+  function clearSecret() {
+    const input = container.querySelector(
+      '[data-runtime-setup-field="embedding-key"]',
+    );
+    if (input) input.value = "";
+  }
+
+  function reset() {
+    generation += 1;
+    loadedConnectionProvider = "";
+    preferConnectionProvider = false;
+    clearSecret();
+    Object.assign(state, {
+      status: null,
+      providers: [],
+      provider: "",
+      model: "",
+      baseUrl: DEFAULT_OLLAMA_BASE_URL,
+      models: [],
+      busy: false,
+      loaded: false,
+      error: "",
+      message: "",
+    });
+  }
+
+  function invalidateConnection() {
+    const { provider, model, baseUrl } = state;
+    const connectionProviderChanged =
+      loadedConnectionProvider !== getPreferredProvider();
+    reset();
+    preferConnectionProvider = connectionProviderChanged;
+    state.baseUrl = baseUrl;
+    if (connectionProviderChanged) return;
+    Object.assign(state, { provider, model });
+  }
+
+  function retainedEmbeddingProvider() {
+    const configured = selectedProvider();
+    if (configured) return configured.id;
+    const isNewProviderChoice = ["new:openai", "new:ollama"].includes(
+      state.provider,
+    );
+    if (!isNewProviderChoice) return "";
+    const hasConfiguredType = state.providers.some(
+      (provider) => provider.type === state.provider.slice(4),
+    );
+    if (hasConfiguredType) return "";
+    return state.provider;
+  }
+
+  function initialEmbeddingProvider(connectionProvider) {
+    const retained = retainedEmbeddingProvider();
+    if (retained) return retained;
+    const saved = state.providers.find(
+      (provider) => provider.id === state.status.providerId,
+    );
+    const preserveSavedProvider = saved && !preferConnectionProvider;
+    if (preserveSavedProvider) return saved.id;
+    const matching = state.providers.filter(
+      (provider) => provider.type === connectionProvider,
+    );
+    const preferred =
+      matching.find((provider) => provider.id === connectionProvider) ||
+      matching[0];
+    if (preferred) return preferred.id;
+    return saved?.id || state.providers[0]?.id || "new:openai";
+  }
+
+  async function run(request, apply, failure, onFailure = () => {}) {
+    const revision = ++generation;
+    const environment = getEnvironmentId();
+    state.busy = true;
+    state.error = "";
+    clearSecret();
+    onChange();
+    try {
+      const payload = await request();
+      if (!isCurrentEmbeddingOperation(revision, environment)) return false;
+      apply(payload);
+      return true;
+    } catch (error) {
+      if (!isCurrentEmbeddingOperation(revision, environment)) return false;
+      onFailure(error?.payload);
+      const message = textOf(error?.payload?.message, failure);
+      state.error =
+        error?.payload?.providerSaved === true
+          ? `${message} The provider connection was saved; memory is unchanged.`
+          : message;
+      return false;
+    } finally {
+      if (isCurrentEmbeddingOperation(revision, environment)) {
+        state.busy = false;
+        clearSecret();
+        onChange();
+      }
+    }
+  }
+
+  async function load() {
+    if (state.loaded || state.busy) return;
+    const connectionProvider = getPreferredProvider();
+    await run(
+      loadStatus,
+      (payload) => {
+        state.status = payload.status || {};
+        state.providers = state.status.providers || [];
+        const hasRetainedProvider = Boolean(retainedEmbeddingProvider());
+        state.provider = initialEmbeddingProvider(connectionProvider);
+        const restoreSavedModel =
+          !hasRetainedProvider && state.provider === state.status.providerId;
+        if (restoreSavedModel) state.model = state.status.model || "";
+        loadedConnectionProvider = connectionProvider;
+        preferConnectionProvider = false;
+        state.loaded = true;
+      },
+      "Could not load embedding options. Try again or set this up later.",
+    );
+  }
+
+  async function discover() {
+    if (state.busy || !selectedProvider()) return;
+    await run(
+      () => discoverModels(state.provider),
+      (payload) => {
+        state.models = Array.isArray(payload.catalog?.models)
+          ? payload.catalog.models
+          : [];
+        state.message =
+          payload.catalog?.supported === true
+            ? `${state.models.length} installed models found. Choose an embedding model.`
+            : "This provider does not list models. Enter an embedding model ID.";
+      },
+      "Could not discover models. You can enter an embedding model ID manually.",
+    );
+  }
+
+  function apiKeyValue() {
+    if (selectedProviderType() !== "openai") return "";
+    return textOf(
+      container.querySelector('[data-runtime-setup-field="embedding-key"]')
+        ?.value,
+    ).trim();
+  }
+
+  function primaryLabel() {
+    return hasUnchangedEmbeddingSelection() && !apiKeyValue()
+      ? "Continue"
+      : "Test and save";
+  }
+
+  async function submit() {
+    if (state.busy || !state.loaded) return;
+    const apiKey = apiKeyValue();
+    if (hasUnchangedEmbeddingSelection() && !apiKey) return onComplete();
+    const model = validateRuntimeSetupModelId(state.model);
+    if (!model.valid) {
+      state.error = "Enter an embedding model ID, or skip this step for now.";
+      onChange();
+      return;
+    }
+    const input = selectedProvider()
+      ? { providerId: state.provider, model: model.value }
+      : { provider: selectedProviderType(), model: model.value };
+    if (!selectedProvider() && selectedProviderType() === "ollama") {
+      const address = validateRuntimeSetupBaseUrl(state.baseUrl);
+      if (!address.valid) {
+        state.error = address.message;
+        onChange();
+        return;
+      }
+      input.baseUrl = address.value;
+    }
+    if (selectedProviderType() === "openai" && apiKey) input.apiKey = apiKey;
+    const providerSelection = {
+      type: selectedProviderType(),
+      providerId: input.providerId,
+    };
+    let saved = false;
+    try {
+      saved = await run(
+        () => saveEmbedding(input),
+        (payload) => {
+          if (payload.status?.enabled !== true)
+            throw new Error("Embedding configuration unavailable");
+          state.status = payload.status || {};
+          state.providers = state.status.providers || state.providers;
+          state.provider = state.status.providerId || state.provider;
+          state.model = state.status.model || state.model;
+          state.message = "Embedding check passed. Memory is configured.";
+        },
+        "Embedding check failed. Check the provider, model and connection details, then try again.",
+        (payload) =>
+          applySavedEmbeddingProviderReceipt(state, payload, providerSelection),
+      );
+    } finally {
+      delete input.apiKey;
+    }
+    if (saved) onComplete();
+  }
+
+  function input(field, value) {
+    if (state.busy) return;
+    if (field === "embedding-model") state.model = value;
+    if (field === "embedding-url") state.baseUrl = value;
+    const action = container.querySelector(
+      '.runtime-setup-action[type="submit"]',
+    );
+    if (action) action.textContent = primaryLabel();
+  }
+
+  function change(field, value) {
+    if (state.busy || field !== "embedding-provider") return;
+    clearSecret();
+    state.provider = value;
+    state.models = [];
+    state.message = "";
+    state.error = "";
+    onChange();
+  }
+
+  return {
+    state,
+    clearSecret,
+    reset,
+    invalidateConnection,
+    load,
+    submit,
+    input,
+    change,
+    markup: () =>
+      renderEmbeddingSetup(state, selectedProviderType(), selectedProvider()),
+    primaryLabel,
+    click: (action) => {
+      if (action === "embedding-discover") void discover();
+      if (action === "embedding-reload") void load();
+    },
+  };
+}

package/dist/src/web-ui/app/components/runtime-setup/optional-steps.js

@@ -0,0 +1,117 @@
+import { createEmbeddingSetupStep } from "./embedding.js";
+import { createSetupPluginStep } from "./plugins.js";
+import { createSystemHostConnectionManager } from "../system-host/manager.js";
+import { hostSetupIsReady } from "../system-host/rendering.js";
+
+/** Optional setup steps retain their owning services and never apply the Runtime. */
+export function createSetupOptionalSteps({
+  container,
+  getEnvironmentId,
+  getPreferredProvider,
+  loadEmbeddingStatus,
+  discoverEmbeddingModels,
+  saveEmbedding,
+  loadPlugins,
+  setPlugin,
+  loadHostConnection,
+  downloadHostSetup,
+  revokeHostConnection,
+  onChange,
+  goToStep,
+}) {
+  const embedding = createEmbeddingSetupStep({
+    container,
+    getEnvironmentId,
+    getPreferredProvider,
+    loadStatus: loadEmbeddingStatus,
+    discoverModels: discoverEmbeddingModels,
+    saveEmbedding,
+    onChange,
+    onComplete: () => goToStep(3),
+  });
+  const plugins = createSetupPluginStep({
+    container,
+    getEnvironmentId,
+    loadPlugins,
+    setPlugin,
+    onChange,
+  });
+  const computer = loadHostConnection
+    ? createSystemHostConnectionManager({
+        loadConnection: loadHostConnection,
+        downloadSetup: downloadHostSetup,
+        revokeConnection: revokeHostConnection,
+        onChange,
+      })
+    : null;
+  const readyStep = computer ? 5 : 4;
+  function hasFreshComputerReadiness() {
+    if (!computer) return false;
+    if (computer.state.busy || computer.state.statusUnavailable) return false;
+    return hostSetupIsReady(computer.state.snapshot);
+  }
+  function projection(step) {
+    const common = {
+      busy: embedding.state.busy || plugins.state.busy,
+      content: "",
+      canContinue: true,
+      memory: embedding.state.status,
+      plugins: plugins.state.snapshot,
+      hasComputerStep: Boolean(computer),
+      readyStep,
+      computer: hasFreshComputerReadiness() ? computer.state.snapshot : null,
+    };
+    if (step === 2)
+      return {
+        ...common,
+        content: embedding.markup(),
+        canContinue: embedding.state.loaded,
+        primaryLabel: embedding.primaryLabel(),
+      };
+    if (step === 3)
+      return {
+        ...common,
+        content: plugins.markup(),
+        canContinue: plugins.state.loaded && !plugins.state.error,
+      };
+    if (step === 4 && computer)
+      return {
+        ...common,
+        content: `<div data-onboarding-computer>${computer.markup()}</div>`,
+        canContinue: hasFreshComputerReadiness(),
+      };
+    return common;
+  }
+  function load(step) {
+    computer?.setActive(step === 4);
+    if (step === 2) void embedding.load();
+    if (step === 3) void plugins.load();
+  }
+  function afterPaint(step, options) {
+    if (step === 3) plugins.afterPaint(options);
+    if (step === 4)
+      computer?.mount(container.querySelector("[data-onboarding-computer]"));
+  }
+  function reset() {
+    embedding.reset();
+    plugins.reset();
+    computer?.reset();
+  }
+  function canContinueComputer(step) {
+    if (step !== 4) return false;
+    return hasFreshComputerReadiness();
+  }
+  return {
+    embedding,
+    plugins,
+    readyStep,
+    projection,
+    load,
+    afterPaint,
+    reset,
+    canContinueComputer,
+    hasComputerStep: Boolean(computer),
+    hide: () => computer?.setActive(false),
+    dispose: () => computer?.dispose(),
+  };
+}

package/dist/src/web-ui/app/components/runtime-setup/plugins.js

@@ -0,0 +1,173 @@
+import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+
+function blockReason(plugin, capability) {
+  if (capability?.blockedReason) return capability.blockedReason;
+  if (plugin.blockedByGlobalPolicy)
+    return "Blocked by the global plugin policy.";
+  if (capability && plugin.pluginEnabled === false)
+    return "Enable this plugin to choose individual tools.";
+  return capability?.blockedByPolicy
+    ? "Blocked by an existing plugin policy rule."
+    : "";
+}
+
+function checkbox(plugin, capability, busy) {
+  const reason = blockReason(plugin, capability);
+  const enabled = capability
+    ? capability.enabled === true
+    : plugin.pluginEnabled === true;
+  const id = capability?.id || plugin.id;
+  const description = capability?.description || "";
+  const version =
+    !capability && plugin.version
+      ? `<small class="runtime-plugin-version">v${escapeHtml(plugin.version)}</small>`
+      : "";
+  return `<label class="runtime-plugin-choice${capability ? "" : " runtime-plugin-master"}">
+    <input type="checkbox" data-runtime-plugin-toggle="${escapeAttribute(plugin.id)}" ${capability ? `data-runtime-capability="${escapeAttribute(capability.id)}"` : ""} ${enabled && !reason ? "checked" : ""} ${busy || reason ? "disabled" : ""} />
+    <span><strong>${escapeHtml(id)}</strong>${version}${description ? `<small class="runtime-plugin-description" title="${escapeAttribute(description)}">${escapeHtml(description)}</small>` : ""}${reason ? `<small class="runtime-plugin-block">${escapeHtml(reason)}</small>` : ""}</span>
+  </label>`;
+}
+
+function renderPluginCard(plugin, busy) {
+  const capabilities = plugin.capabilities || [];
+  return `<li class="runtime-plugin-card">
+    ${checkbox(plugin, null, busy)}
+    <p class="runtime-plugin-summary" title="${escapeAttribute(plugin.description || "")}">${escapeHtml(plugin.description || "Installed Runtime plugin.")}</p>
+    <div class="runtime-plugin-tools-heading"><span>Tools</span><span>${plugin.selectedCapabilityCount} of ${capabilities.length} selected</span></div>
+    <ul class="runtime-plugin-capabilities" aria-label="${escapeAttribute(`Tools in ${plugin.id}`)}">${capabilities.map((capability) => `<li>${checkbox(plugin, capability, busy)}</li>`).join("")}</ul>
+  </li>`;
+}
+
+export function createSetupPluginStep({
+  container,
+  getEnvironmentId,
+  loadPlugins,
+  setPlugin,
+  onChange,
+}) {
+  const state = {
+    snapshot: null,
+    loaded: false,
+    busy: false,
+    error: "",
+    message: "",
+  };
+  let generation = 0;
+  let focusTarget = null;
+  const isCurrentPluginOperation = (revision, environment) =>
+    revision === generation && environment === getEnvironmentId();
+
+  function reset() {
+    generation += 1;
+    focusTarget = null;
+    Object.assign(state, {
+      snapshot: null,
+      loaded: false,
+      busy: false,
+      error: "",
+      message: "",
+    });
+  }
+
+  async function load(force = false) {
+    if ((!force && state.loaded) || state.busy) return;
+    const revision = ++generation;
+    const environment = getEnvironmentId();
+    state.busy = true;
+    state.error = "";
+    onChange();
+    try {
+      const snapshot = await loadPlugins();
+      if (!isCurrentPluginOperation(revision, environment)) return;
+      state.snapshot = snapshot;
+      state.loaded = true;
+    } catch {
+      if (isCurrentPluginOperation(revision, environment))
+        state.error = "Could not load plugins. Try again before continuing.";
+    } finally {
+      if (isCurrentPluginOperation(revision, environment)) {
+        state.busy = false;
+        onChange();
+      }
+    }
+  }
+
+  async function toggle(target) {
+    if (state.busy) return;
+    const pluginId = target.dataset.runtimePluginToggle;
+    const capabilityId = target.dataset.runtimeCapability;
+    const plugin = state.snapshot?.plugins?.find(
+      (entry) => entry.id === pluginId,
+    );
+    const capability = capabilityId
+      ? plugin?.capabilities?.find((entry) => entry.id === capabilityId)
+      : null;
+    if (
+      !plugin ||
+      (capabilityId && !capability) ||
+      blockReason(plugin, capability)
+    )
+      return;
+    const enabled = target.checked === true;
+    const revision = ++generation;
+    const environment = getEnvironmentId();
+    focusTarget = { pluginId, capabilityId };
+    state.busy = true;
+    state.error = "";
+    state.message = "";
+    onChange();
+    try {
+      const snapshot = await setPlugin({
+        pluginId,
+        enabled,
+        ...(capabilityId ? { capabilityId } : {}),
+      });
+      if (!isCurrentPluginOperation(revision, environment)) return;
+      state.snapshot = snapshot;
+      state.message =
+        "Selection saved. It will take effect when you finish setup.";
+    } catch {
+      if (isCurrentPluginOperation(revision, environment))
+        state.error =
+          "Could not save this selection. Your previous selection is still shown. Try again.";
+    } finally {
+      if (isCurrentPluginOperation(revision, environment)) {
+        state.busy = false;
+        onChange();
+      }
+    }
+  }
+
+  function markup() {
+    const plugins = state.snapshot?.plugins || [];
+    const globalBlocked =
+      state.snapshot?.selection?.enabled === false ||
+      state.snapshot?.selection?.deny?.includes("*");
+    return `<div class="runtime-setup-plugins">
+      <p class="runtime-setup-feedback">All installed plugins start enabled in a new setup. Turn off anything you do not need.</p>
+      ${globalBlocked ? '<p class="runtime-setup-feedback">An existing global policy blocks plugins. Your saved policy is preserved.</p>' : ""}
+      ${state.error ? `<p class="runtime-setup-feedback error" role="alert">${escapeHtml(state.error)}</p><button type="button" class="runtime-setup-inline-action" data-runtime-setup-action="plugins-reload">Reload selection</button>` : state.message ? `<p class="runtime-setup-feedback" role="status">${escapeHtml(state.message)}</p>` : ""}
+      ${state.busy ? '<p class="runtime-setup-feedback" role="status">Saving or loading plugin selection…</p>' : ""}
+      <ul class="runtime-plugin-list">${plugins.map((plugin) => renderPluginCard(plugin, state.busy)).join("")}</ul>
+      ${state.loaded && !plugins.length ? '<p class="runtime-setup-feedback">No installed plugins found. You can add plugins later.</p>' : ""}
+    </div>`;
+  }
+
+  function afterPaint({ restoreFocus = true } = {}) {
+    for (const input of container.querySelectorAll?.(
+      "[data-runtime-plugin-toggle]",
+    ) || []) {
+      input.addEventListener("change", () => void toggle(input));
+      if (
+        restoreFocus &&
+        !state.busy &&
+        focusTarget?.pluginId === input.dataset.runtimePluginToggle &&
+        focusTarget?.capabilityId === input.dataset.runtimeCapability
+      )
+        input.focus?.({ preventScroll: true });
+    }
+    if (!state.busy) focusTarget = null;
+  }
+
+  return { state, reset, load, markup, afterPaint, toggle };
+}