@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/local-runtime/environment-registry.js

@@ -1,3 +1,7 @@
+import { requirePluginOwnersIdle } from "./plugin-mutation-admission.js";
+import { ConfigFileConflictError } from "../../runtime/adapters/config-file-transaction.js";
+import { PluginManagementError } from "../plugin-management-service.js";
+import { isPluginToolSelected, normalizePluginSelection, } from "../../runtime/plugins/selection.js";
 import { requiresConfiguredCredential } from "./runtime-setup-provider.js";
 import { applyRuntimeConfiguration } from "./configuration-activation.js";
 import { withConfigurationActivationSource, } from "./configuration-activation-source.js";
@@ -11,6 +15,7 @@ export class RuntimeEnvironmentRegistry {
     options;
     schedulerBindings;
     environments = new Map();
+    gatewayConfigurations = new WeakMap();
     stopped = false;
     desiredEnvironmentIds = new Set();
     applying;
@@ -30,13 +35,35 @@ export class RuntimeEnvironmentRegistry {
             return undefined;
         return this.environments.get(environmentId)?.nativePermissions;
     }
-    applyConfiguration() {
+    requirePluginInactive(pluginId, capabilityIds) {
+        this.requireEnvironmentIntakeOpen();
+        if (this.setupActivationPending || this.environments.size === 0)
+            throw new PluginManagementError("plugin_runtime_unavailable", "Apply Runtime configuration before removing plugins.", 409);
+        for (const environment of this.environments.values()) {
+            const selection = normalizePluginSelection(environment.services.config.plugins);
+            if (environment.getOwnership() !== "owner" ||
+                capabilityIds.some((toolName) => isPluginToolSelected({ pluginId, toolName, selection })))
+                throw new PluginManagementError("plugin_still_active", "The plugin is still available in a Runtime environment. Apply its disable before removing it.", 409);
+        }
+    }
+    requirePluginMutationIdle(hasAcknowledgedRequests = false) {
+        requirePluginOwnersIdle({
+            environments: this.environments.values(),
+            unavailable: this.stopped || this.setupActivationPending,
+            busy: hasAcknowledgedRequests || !!this.applying,
+        });
+    }
+    applyConfiguration(expectedRevision) {
         if (this.stopped)
             return Promise.reject(new Error("web_runtime_stopped"));
-        if (this.applying)
+        if (this.applying) {
+            // A coalesced Apply may have loaded a different revision from this removal.
+            if (expectedRevision !== undefined)
+                return Promise.reject(new ConfigFileConflictError());
             return this.applying;
+        }
         const configPath = inspectRuntimeConfigFileWithMeta(this.options.rootDir ?? process.cwd(), this.options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE).path;
-        const apply = withConfigurationActivationSource(configPath, (prepare) => this.applySavedConfiguration(configPath, prepare));
+        const apply = withConfigurationActivationSource(configPath, (prepare) => this.applySavedConfiguration(configPath, prepare), expectedRevision, this.options.rootDir ?? process.cwd());
         this.applying = apply.finally(() => {
             this.applying = undefined;
         });
@@ -44,6 +71,7 @@ export class RuntimeEnvironmentRegistry {
     }
     applySavedConfiguration(configPath, preparation) {
         const nextEnvironments = this.options.resolveEnvironmentConfig?.(configPath);
+        let appliedGatewayConfigurations;
         return applyRuntimeConfiguration({
             environments: this.environments,
             defaultEnvironmentId: nextEnvironments?.defaultEnvironmentId ??
@@ -51,16 +79,18 @@ export class RuntimeEnvironmentRegistry {
             environmentIds: nextEnvironments?.environments.map(({ id }) => id) ?? [
                 ...this.desiredEnvironmentIds,
             ],
-            createEnvironment: (id) => this.createEnvironment(id, this.loadConfig(id, configPath)),
-            recreateEnvironment: (id, previous) => this.createEnvironment(id, previous.services.config),
+            createEnvironment: (id) => this.createEnvironment(id, this.loadConfig(id, configPath), this.captureGatewayConfiguration(configPath)),
+            recreateEnvironment: (id, previous) => this.createEnvironment(id, previous.services.config, this.gatewayConfigurations.get(previous) ?? null),
             createGatewayRestorePoint: this.options.createRuntimeSetupRestorePoint,
             onRestorationFailure: () => {
                 this.setupActivationPending = true;
             },
             ...preparation,
-            checkGateway: () => this.checkGatewayActivation(configPath),
-            activateGateway: () => this.options.onRuntimeSetup?.(configPath) ??
-                Promise.resolve({ status: "ready" }),
+            checkGateway: () => {
+                appliedGatewayConfigurations = [...this.environments.values()].map((environment) => this.gatewayConfigurations.get(environment) ?? null);
+                return this.checkGatewayActivation(configPath, appliedGatewayConfigurations);
+            },
+            activateGateway: () => this.options.onRuntimeSetup?.(configPath, appliedGatewayConfigurations) ?? Promise.resolve({ status: "ready" }),
             canContinue: () => !this.stopped,
         }).then((result) => {
             if (result.status !== "ready")
@@ -77,9 +107,9 @@ export class RuntimeEnvironmentRegistry {
             return result;
         });
     }
-    checkGatewayActivation(configPath) {
+    checkGatewayActivation(configPath, applied) {
         if (this.options.checkRuntimeSetupActivation)
-            return this.options.checkRuntimeSetupActivation(configPath);
+            return this.options.checkRuntimeSetupActivation(configPath, applied);
         if (this.options.onRuntimeSetup)
             return Promise.resolve({ status: "ready" });
         return Promise.resolve({
@@ -141,10 +171,22 @@ export class RuntimeEnvironmentRegistry {
         this.environments.set(normalized, environment);
         return environment;
     }
-    createEnvironment(environmentId, config = this.loadConfig(environmentId)) {
+    captureGatewayConfiguration(configPath) {
+        try {
+            return (this.options.captureRuntimeSetupConfiguration?.(configPath) ?? null);
+        }
+        catch {
+            // An unavailable gateway snapshot cannot block an otherwise valid Runtime.
+            // Apply still refuses external reuse when any owner's snapshot is unknown.
+            return null;
+        }
+    }
+    createEnvironment(environmentId, config = this.loadConfig(environmentId), gatewayConfiguration = this.captureGatewayConfiguration(this.options.configPath)) {
         const environment = createLocalRuntimeApplication(config, {
             scheduledRequestOptions: this.schedulerBindings.requestOptions,
         });
+        // Capture before startup; restored owners keep their prior immutable snapshot.
+        this.gatewayConfigurations.set(environment, gatewayConfiguration);
         if (this.schedulerBindings.publish) {
             environment.subscribeScheduledEvents(this.schedulerBindings.publish);
         }

package/dist/src/web-ui/local-runtime/history-pagination.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeConfig } from "../../runtime/ports.js";
+import type { SessionSnapshotOptions } from "../../sessions/snapshot.js";
+import type { SessionSnapshot } from "../../sessions/types.js";
+export declare function webPageSize(config: RuntimeConfig): number;
+export declare function historyPageOptions(url: URL | undefined, config: RuntimeConfig): SessionSnapshotOptions;
+/** Compact identities stay between the session service and the read-state owner. */
+export declare function publicHistorySnapshot(snapshot: SessionSnapshot): {
+    kind?: import("../../sessions/spark-session.js").SessionKind;
+    project?: import("../../sessions/project-binding.js").SessionProject;
+    sessionId: string;
+    title: string;
+    messages: import("../../sessions/types.js").SessionSnapshotMessage[];
+    requests: import("../../sessions/types.js").SessionSnapshotRequest[];
+    nextCursor: string | null;
+    newerCursor?: string | null;
+};

package/dist/src/web-ui/local-runtime/history-pagination.js

@@ -0,0 +1,20 @@
+import { DEFAULT_WEB_UI_PAGE_SIZE } from "../../runtime/config/web-ui.js";
+export function webPageSize(config) {
+    return config.webUi?.pageSize ?? DEFAULT_WEB_UI_PAGE_SIZE;
+}
+export function historyPageOptions(url, config) {
+    if (url?.searchParams.get("page") !== "1")
+        return { includeRequests: true };
+    return { includeRequests: true, page: {
+            limit: webPageSize(config), cursor: url.searchParams.get("cursor"),
+            targetMessageId: url.searchParams.get("targetMessageId") ?? undefined,
+            targetCreatedAt: url.searchParams.has("targetCreatedAt") ? Number(url.searchParams.get("targetCreatedAt")) : undefined,
+            targetRequestId: url.searchParams.get("targetRequestId") ?? undefined,
+            waitingRequestId: url.searchParams.get("waitingRequestId") ?? undefined,
+        } };
+}
+/** Compact identities stay between the session service and the read-state owner. */
+export function publicHistorySnapshot(snapshot) {
+    const { messageIndex: _index, ...publicSnapshot } = snapshot;
+    return publicSnapshot;
+}

package/dist/src/web-ui/local-runtime/http.js

@@ -1,3 +1,4 @@
+import { RequestBodyInputError } from "./request-body-error.js";
 export function sendJson(res, statusCode, payload) {
     res.writeHead(statusCode, {
         "content-type": "application/json; charset=utf-8",
@@ -52,9 +53,17 @@ export function getNumber(value) {
 export function readJsonBody(body) {
     if (body.length === 0)
         return {};
-    const parsed = JSON.parse(body.toString("utf8"));
+    let parsed;
+    try {
+        parsed = JSON.parse(body.toString("utf8"));
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        throw new RequestBodyInputError("invalid_json");
+    }
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("JSON object body required");
+        throw new RequestBodyInputError("json_object_required");
     }
     return parsed;
 }

package/dist/src/web-ui/local-runtime/model-context-capacity-error.d.ts

@@ -0,0 +1,14 @@
+import type { ModelContextCapacityIssue } from "../../runtime/config/model-context-capacity.js";
+export type PublicContextWindowIssue = Readonly<{
+    field: "contextWindowTokens";
+    declaredTokens: number;
+    effectiveTokens: number;
+    reservedTokens: number;
+    minimumTokens: number;
+    allocationTokens?: number;
+    environmentId?: string;
+}>;
+export declare function readModelContextCapacityIssue(error: unknown, profileId: string): ModelContextCapacityIssue | undefined;
+export declare function modelContextCapacityMessage(issue: ModelContextCapacityIssue): string;
+/** Project known capacity evidence without exposing config paths or raw issues. */
+export declare function publicContextWindowIssue(issue: ModelContextCapacityIssue, environmentId?: string): PublicContextWindowIssue;

package/dist/src/web-ui/local-runtime/model-context-capacity-error.js

@@ -0,0 +1,28 @@
+import { RuntimeConfigValidationError } from "../../runtime/config/validation.js";
+export function readModelContextCapacityIssue(error, profileId) {
+    if (!(error instanceof RuntimeConfigValidationError))
+        return undefined;
+    return error.capacityIssues.find((issue) => issue.profileId === profileId);
+}
+export function modelContextCapacityMessage(issue) {
+    const capacity = `The effective context window is ${issue.effectiveTokens} tokens, but the configured reserves require more than ${issue.reservedTokens} tokens. Use a model-supported context window of at least ${issue.minimumTokens} tokens or adjust the configured reserves.`;
+    if (issue.allocationTokens === undefined)
+        return capacity;
+    if (issue.allocationTokens >= issue.minimumTokens)
+        return capacity;
+    return `${capacity} The Ollama num_ctx allocation of ${issue.allocationTokens} tokens must also support that window.`;
+}
+/** Project known capacity evidence without exposing config paths or raw issues. */
+export function publicContextWindowIssue(issue, environmentId) {
+    return {
+        field: "contextWindowTokens",
+        declaredTokens: issue.declaredTokens,
+        effectiveTokens: issue.effectiveTokens,
+        reservedTokens: issue.reservedTokens,
+        minimumTokens: issue.minimumTokens,
+        ...(issue.allocationTokens === undefined
+            ? {}
+            : { allocationTokens: issue.allocationTokens }),
+        ...(environmentId === undefined ? {} : { environmentId }),
+    };
+}

package/dist/src/web-ui/local-runtime/model-setup-context-window.d.ts

@@ -0,0 +1,15 @@
+import type { ModelContextCapacityIssue } from "../../runtime/config/model-context-capacity.js";
+import { ModelSetupError } from "./model-setup-input.js";
+import { type PublicContextWindowIssue } from "./model-context-capacity-error.js";
+type ModelSetupContextWindowIssue = PublicContextWindowIssue & Readonly<{
+    profileId: string;
+}>;
+export declare class ModelSetupContextWindowError extends ModelSetupError {
+    readonly contextWindow: ModelSetupContextWindowIssue;
+    constructor(issue: ModelContextCapacityIssue, environmentId?: string);
+}
+export declare function throwModelSetupValidationError(error: unknown, profileId: string | undefined, environmentId?: string): never;
+export declare function modelSetupContextWindowErrorDetails(error: unknown): {
+    contextWindow?: ModelSetupContextWindowIssue;
+};
+export {};

package/dist/src/web-ui/local-runtime/model-setup-context-window.js

@@ -0,0 +1,25 @@
+import { ModelSetupError } from "./model-setup-input.js";
+import { modelContextCapacityMessage, publicContextWindowIssue, readModelContextCapacityIssue, } from "./model-context-capacity-error.js";
+export class ModelSetupContextWindowError extends ModelSetupError {
+    contextWindow;
+    constructor(issue, environmentId) {
+        super("context_window_too_small", modelContextCapacityMessage(issue));
+        this.contextWindow = {
+            ...publicContextWindowIssue(issue, environmentId),
+            profileId: issue.profileId,
+        };
+    }
+}
+export function throwModelSetupValidationError(error, profileId, environmentId) {
+    if (profileId === undefined)
+        throw error;
+    const issue = readModelContextCapacityIssue(error, profileId);
+    if (!issue)
+        throw error;
+    throw new ModelSetupContextWindowError(issue, environmentId);
+}
+export function modelSetupContextWindowErrorDetails(error) {
+    if (!(error instanceof ModelSetupContextWindowError))
+        return {};
+    return { contextWindow: error.contextWindow };
+}

package/dist/src/web-ui/local-runtime/model-setup-routes.js

@@ -1,5 +1,6 @@
 import { assertConfigMutationRequest, ConfigMutationRequestError, } from "./config-mutation-request.js";
 import { readBody, readJsonBody, sendJson } from "./http.js";
+import { modelSetupContextWindowErrorDetails } from "./model-setup-context-window.js";
 import { ModelSetupError } from "./model-setup-input.js";
 export class ModelSetupRoutes {
     service;
@@ -40,6 +41,7 @@ export class ModelSetupRoutes {
                 error instanceof ConfigMutationRequestError;
             sendJson(params.response, known ? error.statusCode : 400, {
                 ok: false,
+                ...modelSetupContextWindowErrorDetails(error),
                 error: error instanceof ModelSetupError ? error.code : "model_setup_failed",
                 message: known
                     ? error.message

package/dist/src/web-ui/local-runtime/model-setup-service.js

@@ -92,14 +92,17 @@ export class ModelSetupService {
             provider: provider.config,
             profile,
         };
-        await validateModelAddition(mergeRuntimeModelAddition(source, addition).config, options);
+        await validateModelAddition(mergeRuntimeModelAddition(source, addition).config, { ...options, modelProfileId: input.profileId });
         const credential = await prepareModelCredential(options, provider.config, input.apiKey);
         return withModelSetupProfile(options, transaction, input.profileId, profile, async (declaration, assertProfileUnchanged) => {
             const candidate = mergeRuntimeModelAddition(source, {
                 ...addition,
                 profile: declaration,
             }).config;
-            await validateModelAddition(candidate, options);
+            await validateModelAddition(candidate, {
+                ...options,
+                modelProfileId: input.profileId,
+            });
             await assertProfileUnchanged();
             await this.commit(options, candidate, transaction, credential, assertProfileUnchanged);
             return modelSetupResult(provider, input);

package/dist/src/web-ui/local-runtime/model-setup-validation.d.ts

@@ -2,5 +2,6 @@
 export declare function validateModelConfigurationChange(config: Record<string, unknown>, options: {
     rootDir: string;
     configPath: string;
+    modelProfileId?: string;
 }): Promise<void>;
 export { validateModelConfigurationChange as validateModelAddition };

package/dist/src/web-ui/local-runtime/model-setup-validation.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { throwModelSetupValidationError } from "./model-setup-context-window.js";
 import { loadRuntimeConfig } from "../../runtime/config.js";
 import { isRecord } from "../../runtime/config/utils.js";
 import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
@@ -19,13 +20,19 @@ export async function validateModelConfigurationChange(config, options) {
             ? Object.keys(environment.profiles)
             : [];
         const environments = profileIds.length ? profileIds : [undefined];
-        for (const profileId of environments)
-            loadRuntimeConfig({
-                rootDir: options.rootDir,
-                configPath: temporary,
-                profileId,
-                env: { ...process.env },
-            });
+        for (const environmentId of environments) {
+            try {
+                loadRuntimeConfig({
+                    rootDir: options.rootDir,
+                    configPath: temporary,
+                    profileId: environmentId,
+                    env: { ...process.env },
+                });
+            }
+            catch (error) {
+                throwModelSetupValidationError(error, options.modelProfileId, environmentId);
+            }
+        }
     }
     finally {
         await rm(temporary, { force: true });

package/dist/src/web-ui/local-runtime/plugin-configuration-routes.d.ts

@@ -0,0 +1,16 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare class PluginConfigurationRoutes {
+    private readonly options;
+    constructor(options: {
+        rootDir: string;
+        requireMutationIdle?: () => void;
+        getConfigPath?: () => string | undefined;
+    });
+    handle(params: {
+        method: string;
+        route: string;
+        body: Record<string, unknown> | null;
+        request?: IncomingMessage;
+        response: ServerResponse;
+    }): Promise<boolean>;
+}

package/dist/src/web-ui/local-runtime/plugin-configuration-routes.js

@@ -0,0 +1,68 @@
+import { PluginConfigurationError } from "../../runtime/plugins/configuration-store.js";
+import { getRuntimePluginConfiguration, saveRuntimePluginConfiguration, } from "../plugin-configuration-service.js";
+import { PluginManagementError } from "../plugin-management-service.js";
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { sendJson } from "./http.js";
+export class PluginConfigurationRoutes {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async handle(params) {
+        const prefix = "runtime/plugins/configuration/";
+        if (!params.route.startsWith(prefix))
+            return false;
+        params.response.setHeader("Cache-Control", "no-store");
+        try {
+            const pluginId = decodeURIComponent(params.route.slice(prefix.length));
+            const options = {
+                ...this.options,
+                configPath: this.options.getConfigPath?.(),
+            };
+            if (params.method === "GET") {
+                sendJson(params.response, 200, {
+                    ok: true,
+                    configuration: getRuntimePluginConfiguration(options, pluginId),
+                });
+                return true;
+            }
+            if (params.method !== "PUT") {
+                sendJson(params.response, 405, {
+                    ok: false,
+                    error: "method_not_allowed",
+                });
+                return true;
+            }
+            if (!params.request) {
+                sendJson(params.response, 403, {
+                    ok: false,
+                    error: "request_origin_required",
+                });
+                return true;
+            }
+            if (!acceptConfigMutationRequest(params.request, params.response))
+                return true;
+            const saved = await saveRuntimePluginConfiguration(options, {
+                pluginId,
+                input: params.body,
+            });
+            sendJson(params.response, 200, {
+                ok: true,
+                configuration: saved.configuration,
+                restartRequired: true,
+            });
+        }
+        catch (error) {
+            const known = error instanceof PluginConfigurationError ||
+                error instanceof PluginManagementError;
+            sendJson(params.response, known ? error.statusCode : 500, {
+                ok: false,
+                error: known ? error.code : "plugin_configuration_failed",
+                message: known
+                    ? error.message
+                    : "Plugin configuration could not be loaded or saved.",
+            });
+        }
+        return true;
+    }
+}

package/dist/src/web-ui/local-runtime/plugin-installation-routes.d.ts

@@ -0,0 +1,16 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare class PluginInstallationRoutes {
+    private readonly options;
+    constructor(options: {
+        rootDir: string;
+        requireMutationIdle?: () => void;
+        getConfigPath?: () => string | undefined;
+    });
+    handle(params: {
+        method: string;
+        route: string;
+        body: Record<string, unknown> | null;
+        request?: IncomingMessage;
+        response: ServerResponse;
+    }): Promise<boolean>;
+}

package/dist/src/web-ui/local-runtime/plugin-installation-routes.js

@@ -0,0 +1,96 @@
+import { projectPluginConfiguration } from "../plugin-configuration-view.js";
+import { saveRuntimePluginConfiguration } from "../plugin-configuration-service.js";
+import { PluginConfigurationError, readPluginConfigurationStore, } from "../../runtime/plugins/configuration-store.js";
+import { PluginInstallError } from "../../plugin-contract/install-source.js";
+import { inspectPluginPackage, installPluginPackage, } from "../../runtime/plugins/installation/service.js";
+import { inspectRuntimeConfigFileWithMeta } from "../../runtime/config/loader.js";
+import { PluginManagementError, setRuntimePluginEnabled, } from "../plugin-management-service.js";
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { sendJson } from "./http.js";
+export class PluginInstallationRoutes {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async handle(params) {
+        if (!["runtime/plugins/inspect", "runtime/plugins/install"].includes(params.route))
+            return false;
+        if (params.method !== "POST") {
+            sendJson(params.response, 405, {
+                ok: false,
+                error: "method_not_allowed",
+            });
+            return true;
+        }
+        if (!params.request) {
+            sendJson(params.response, 403, {
+                ok: false,
+                error: "request_origin_required",
+            });
+            return true;
+        }
+        if (!acceptConfigMutationRequest(params.request, params.response))
+            return true;
+        try {
+            const configPath = this.options.getConfigPath?.();
+            const configuration = inspectRuntimeConfigFileWithMeta(this.options.rootDir, configPath);
+            if (!configuration.exists)
+                throw new PluginInstallError("runtime_setup_required", "Complete Runtime setup before installing plugins.", 409);
+            if (params.route === "runtime/plugins/inspect") {
+                const review = await inspectPluginPackage(this.options.rootDir, params.body);
+                const configuration = projectPluginConfiguration(review.id, {
+                    settings: { defaults: review.settings },
+                    secrets: Object.fromEntries(review.secrets.map(({ name, env, required }) => [
+                        name,
+                        { env, required },
+                    ])),
+                }, readPluginConfigurationStore(this.options.rootDir));
+                sendJson(params.response, 200, {
+                    ok: true,
+                    review: { ...review, configuration },
+                });
+                return true;
+            }
+            this.options.requireMutationIdle?.();
+            const result = await installPluginPackage({
+                requireMutationIdle: this.options.requireMutationIdle,
+                rootDir: this.options.rootDir,
+                configPath: configuration.path,
+                input: params.body,
+                saveSelection: async (pluginId, transaction) => {
+                    const options = {
+                        rootDir: this.options.rootDir,
+                        configPath,
+                        requireMutationIdle: this.options.requireMutationIdle,
+                    };
+                    const saved = await saveRuntimePluginConfiguration(options, {
+                        pluginId,
+                        input: params.body?.configuration,
+                        transaction,
+                        installation: true,
+                        commit: () => setRuntimePluginEnabled(options, { pluginId, enabled: true }, transaction),
+                    });
+                    return saved.result;
+                },
+            });
+            sendJson(params.response, 200, {
+                ok: true,
+                ...result.snapshot,
+                installed: result.installed,
+            });
+        }
+        catch (error) {
+            const known = error instanceof PluginConfigurationError ||
+                error instanceof PluginInstallError ||
+                error instanceof PluginManagementError;
+            sendJson(params.response, known ? error.statusCode : 500, {
+                ok: false,
+                error: known ? error.code : "plugin_installation_failed",
+                message: known
+                    ? error.message
+                    : "The plugin could not be installed. No existing plugin was replaced.",
+            });
+        }
+        return true;
+    }
+}

package/dist/src/web-ui/local-runtime/plugin-management-routes.d.ts

@@ -1,14 +1,21 @@
-import type { ServerResponse } from "node:http";
+import type { PluginRemovalRuntime } from "../plugin-removal-service.js";
+import type { IncomingMessage, ServerResponse } from "node:http";
 export declare class PluginManagementRoutes {
     private readonly options;
+    private readonly configuration;
+    private readonly removal;
+    private readonly installation;
     constructor(options: {
         rootDir: string;
+        requireMutationIdle?: () => void;
+        removalRuntime?: PluginRemovalRuntime;
         getConfigPath?: () => string | undefined;
     });
     handle(params: {
         method: string;
         route: string;
         body: Record<string, unknown> | null;
+        request?: IncomingMessage;
         response: ServerResponse;
     }): Promise<boolean>;
 }

package/dist/src/web-ui/local-runtime/plugin-management-routes.js

@@ -1,16 +1,32 @@
+import { PluginConfigurationRoutes } from "./plugin-configuration-routes.js";
+import { PluginRemovalRoutes } from "./plugin-removal-routes.js";
+import { PluginInstallationRoutes } from "./plugin-installation-routes.js";
 import { getRuntimePluginSnapshot, PluginManagementError, setRuntimePluginEnabled, } from "../plugin-management-service.js";
 import { sendJson } from "./http.js";
 export class PluginManagementRoutes {
     options;
+    configuration;
+    removal;
+    installation;
     constructor(options) {
         this.options = options;
+        this.configuration = new PluginConfigurationRoutes(options);
+        this.removal = new PluginRemovalRoutes(options);
+        this.installation = new PluginInstallationRoutes(options);
     }
     async handle(params) {
+        if (await this.configuration.handle(params))
+            return true;
+        if (await this.installation.handle(params))
+            return true;
+        if (await this.removal.handle(params))
+            return true;
         if (params.route !== "runtime/plugins")
             return false;
         const options = {
             rootDir: this.options.rootDir,
             configPath: this.options.getConfigPath?.(),
+            requireMutationIdle: this.options.requireMutationIdle,
         };
         try {
             if (params.method === "GET") {
@@ -21,6 +37,7 @@ export class PluginManagementRoutes {
                 return true;
             }
             if (params.method === "PUT") {
+                this.options.requireMutationIdle?.();
                 const result = await setRuntimePluginEnabled(options, params.body);
                 sendJson(params.response, 200, { ok: true, ...result });
                 return true;

package/dist/src/web-ui/local-runtime/plugin-mutation-admission.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeEnvironment } from "./contracts.js";
+/** A saved plugin change must not start while any owning Runtime is working. */
+export declare function requirePluginOwnersIdle(options: {
+    environments: Iterable<RuntimeEnvironment>;
+    busy: boolean;
+    unavailable: boolean;
+}): void;

package/dist/src/web-ui/local-runtime/plugin-mutation-admission.js

@@ -0,0 +1,17 @@
+import { PluginManagementError } from "../plugin-management-service.js";
+/** A saved plugin change must not start while any owning Runtime is working. */
+export function requirePluginOwnersIdle(options) {
+    if (options.unavailable)
+        throw new PluginManagementError("plugin_mutation_unavailable", "Apply Runtime configuration before changing plugins.", 409);
+    if (options.busy)
+        throw busyPluginMutation();
+    for (const environment of options.environments) {
+        if (environment.getOwnership() !== "owner")
+            throw new PluginManagementError("plugin_owner_unavailable", "This Web UI cannot verify that the owning Runtime is idle. Open Plugins in the Web UI that owns this Runtime.", 409);
+        if (!environment.isOwnerIdle())
+            throw busyPluginMutation();
+    }
+}
+function busyPluginMutation() {
+    return new PluginManagementError("plugin_runtime_busy", "Your agent is working. Wait for active conversations and Jobs to finish before changing plugins.", 409);
+}