@abot-ai/runtime 1.5.0 → 1.7.0

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

@@ -0,0 +1,227 @@
+import { randomUUID } from "node:crypto";
+import { AutomationPublicationError } from "../../runtime/automations/publication.js";
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { sendJson } from "./http.js";
+function requiredRevision(value) {
+    if (!Number.isSafeInteger(value) || Number(value) < 1)
+        throw new Error("automation_revision_required");
+    return Number(value);
+}
+function optionalGrantRevision(value) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0)
+        throw new Error("automation_grant_revision_required");
+    return Number(value);
+}
+function requiredIdempotencyKey(value) {
+    if (typeof value !== "string" || value.length < 8 || value.length > 128)
+        throw new Error("automation_idempotency_key_required");
+    return value;
+}
+function operationRefs(value) {
+    if (!Array.isArray(value) || value.length > 64)
+        throw new Error("automation_grant_invalid");
+    return value.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            throw new Error("automation_grant_invalid");
+        const operation = item;
+        if (typeof operation.toolName !== "string" ||
+            typeof operation.operationId !== "string" ||
+            !Number.isSafeInteger(operation.contractVersion))
+            throw new Error("automation_grant_invalid");
+        return {
+            toolName: operation.toolName,
+            operationId: operation.operationId,
+            contractVersion: Number(operation.contractVersion),
+        };
+    });
+}
+function sendAutomationError(response, error) {
+    if (error instanceof AutomationPublicationError) {
+        sendJson(response, 422, {
+            ok: false, error: "automation_graph_invalid", issues: error.issues,
+        });
+        return;
+    }
+    const code = error instanceof Error ? error.message : "automation_request_failed";
+    const status = code.includes("not_found") ? 404 :
+        code.includes("revision_conflict") ? 409 :
+            code === "automation_draft_published" || code === "automation_archived" ||
+                code === "automation_run_active" || code === "automation_not_published" ? 409 :
+                code.includes("unavailable") || code.includes("locked") ? 409 :
+                    code === "automation_revision_required" ? 428 : 400;
+    sendJson(response, status, { ok: false, error: code, message: code });
+}
+export class AutomationRoutes {
+    resolveEnvironment;
+    constructor(resolveEnvironment) {
+        this.resolveEnvironment = resolveEnvironment;
+    }
+    async handle(request) {
+        if (request.segments[0] !== "automations" &&
+            request.segments[0] !== "automation-runs")
+            return false;
+        if (request.method !== "GET" && request.method !== "HEAD" &&
+            !acceptConfigMutationRequest(request.request, request.response))
+            return true;
+        try {
+            const environment = this.resolveEnvironment(request.environmentId);
+            await environment.start();
+            const service = environment.services.automations;
+            if (!service)
+                throw new Error("automation_unavailable");
+            if (request.segments[0] === "automations")
+                await this.handleDefinition(request, service);
+            else
+                await this.handleRun(request, service);
+        }
+        catch (error) {
+            sendAutomationError(request.response, error);
+        }
+        return true;
+    }
+    async handleDefinition(request, service) {
+        const { method, segments, body, response } = request;
+        const [, automationId, action] = segments;
+        if (segments.length === 1) {
+            if (method === "GET")
+                sendJson(response, 200, { ok: true, automations: await service.list() });
+            else if (method === "POST") {
+                const title = typeof body?.title === "string" ? body.title : "ABot Automation";
+                if (body?.templateId !== undefined && typeof body.templateId !== "string")
+                    throw new Error("automation_template_unavailable");
+                sendJson(response, 201, { ok: true, draft: await service.create(title, body?.templateId) });
+            }
+            else
+                this.methodNotAllowed(response, "GET, POST");
+            return;
+        }
+        if (automationId === "catalog" && segments.length === 2 && method === "GET") {
+            const selectedId = request.url.searchParams.get("automation") ?? "";
+            sendJson(response, 200, { ok: true, ...await service.catalog(selectedId) });
+            return;
+        }
+        if (!automationId || segments.length > 3) {
+            sendJson(response, 404, { ok: false, error: "not_found" });
+            return;
+        }
+        if (action === "draft") {
+            if (method === "GET") {
+                const draft = await service.getDraft(automationId);
+                if (!draft)
+                    throw new Error("automation_not_found");
+                sendJson(response, 200, {
+                    ok: true, draft, grant: await service.getGrant(automationId),
+                    validation: await service.validate(automationId),
+                    publishedDefinition: await service.getPublishedDefinition(automationId),
+                });
+            }
+            else if (method === "PATCH") {
+                sendJson(response, 200, { ok: true,
+                    draft: await service.updateDraft(automationId, requiredRevision(body?.expectedRevision), body?.mutation),
+                });
+            }
+            else if (method === "DELETE") {
+                await service.deleteDraft(automationId, requiredRevision(body?.expectedRevision));
+                sendJson(response, 200, { ok: true });
+            }
+            else
+                this.methodNotAllowed(response, "GET, PATCH, DELETE");
+            return;
+        }
+        if (action === "agents" && method === "POST") {
+            sendJson(response, 201, { ok: true,
+                agent: await service.saveAgentFromDraft({
+                    automationId,
+                    nodeId: typeof body?.nodeId === "string" ? body.nodeId : "",
+                    expectedDraftRevision: requiredRevision(body?.expectedRevision),
+                }),
+            });
+            return;
+        }
+        if (action === "validate" && method === "POST") {
+            sendJson(response, 200, { ok: true, issues: await service.validate(automationId) });
+            return;
+        }
+        if (action === "permission" && method === "PUT") {
+            const mode = body?.mode;
+            if (mode !== "full_access" && mode !== "full_plus")
+                throw new Error("automation_grant_invalid");
+            sendJson(response, 200, { ok: true, grant: await service.replaceGrant({
+                    automationId,
+                    expectedGrantRevision: optionalGrantRevision(body?.expectedGrantRevision),
+                    mode,
+                    operations: operationRefs(body?.operations),
+                    actionId: randomUUID(),
+                }) });
+            return;
+        }
+        if (action === "publish" && method === "POST") {
+            const published = await service.publish(automationId, requiredRevision(body?.expectedRevision));
+            sendJson(response, 200, { ok: true, ...published });
+            return;
+        }
+        if ((action === "archive" || action === "restore") && method === "POST") {
+            sendJson(response, 200, { ok: true,
+                draft: await service[action](automationId, requiredRevision(body?.expectedRevision)),
+            });
+            return;
+        }
+        if (action === "activate" && method === "POST") {
+            sendJson(response, 200, { ok: true, job: await service.activate(automationId) });
+            return;
+        }
+        if (action === "pause" && method === "POST") {
+            sendJson(response, 200, { ok: true, job: await service.pause(automationId) });
+            return;
+        }
+        if (action === "run" && method === "POST") {
+            sendJson(response, 200, { ok: true,
+                run: await service.runNow(automationId, requiredIdempotencyKey(body?.idempotencyKey)),
+            });
+            return;
+        }
+        if (action === "runs" && method === "GET") {
+            sendJson(response, 200, { ok: true,
+                runs: await service.listRuns(automationId, { limit: 100 }),
+            });
+            return;
+        }
+        sendJson(response, 404, { ok: false, error: "not_found" });
+    }
+    async handleRun(request, service) {
+        const { method, segments, response } = request;
+        const [, runId, action, nodeId] = segments;
+        if (!runId || segments.length > 4) {
+            sendJson(response, 404, { ok: false, error: "not_found" });
+            return;
+        }
+        if (!action && segments.length === 2 && method === "GET") {
+            response.setHeader("cache-control", "private, no-store");
+            sendJson(response, 200, { ok: true, run: await service.getRun(runId) });
+            return;
+        }
+        if (action === "steps" && nodeId && segments.length === 4 && method === "GET") {
+            response.setHeader("cache-control", "private, no-store");
+            sendJson(response, 200, { ok: true, evidence: await service.getStepEvidence(runId, nodeId, request.url.searchParams.get("full") === "1") });
+            return;
+        }
+        if (action === "stop" && segments.length === 3 && method === "POST") {
+            await service.stopRun(runId);
+            sendJson(response, 200, { ok: true, run: await service.getRun(runId) });
+            return;
+        }
+        if (action === "rerun" && segments.length === 3 && method === "POST") {
+            if (request.body?.confirmed !== true)
+                throw new Error("automation_rerun_confirmation_required");
+            sendJson(response, 200, { ok: true,
+                run: await service.rerun(runId, requiredIdempotencyKey(request.body.idempotencyKey), true),
+            });
+            return;
+        }
+        sendJson(response, 404, { ok: false, error: "not_found" });
+    }
+    methodNotAllowed(response, allow) {
+        response.setHeader("allow", allow);
+        sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+    }
+}

package/dist/src/web-ui/local-runtime/configuration-activation-source.d.ts

@@ -4,4 +4,4 @@ export type ConfigurationActivationPreparation = {
     restoreConfiguration(): void;
 };
 /** Cooperating root and linked-file saves wait for activation or restoration to finish. */
-export declare function withConfigurationActivationSource(configPath: string, operation: (preparation: ConfigurationActivationPreparation) => Promise<RuntimeSetupActivation>): Promise<RuntimeSetupActivation>;
+export declare function withConfigurationActivationSource(configPath: string, operation: (preparation: ConfigurationActivationPreparation) => Promise<RuntimeSetupActivation>, expectedRevision?: string, pluginRootDir?: string): Promise<RuntimeSetupActivation>;

package/dist/src/web-ui/local-runtime/configuration-activation-source.js

@@ -1,4 +1,5 @@
-import { withConfigFileTransaction } from "../../runtime/adapters/config-file-transaction.js";
+import { withPluginConfigurationLock } from "../../runtime/plugins/configuration-write.js";
+import { ConfigFileConflictError, withConfigFileTransaction, } from "../../runtime/adapters/config-file-transaction.js";
 import { resolveRequestRunnerConfigReference } from "../../runtime/config/request-runner-config.js";
 import { invalidateRequestRunnerConfig } from "../../runtime/config/runner/loader.js";
 function restoreUnappliedRequestRunner(activation, preparation) {
@@ -7,8 +8,11 @@ function restoreUnappliedRequestRunner(activation, preparation) {
     preparation.restoreConfiguration();
 }
 /** Cooperating root and linked-file saves wait for activation or restoration to finish. */
-export function withConfigurationActivationSource(configPath, operation) {
+export function withConfigurationActivationSource(configPath, operation, expectedRevision, pluginRootDir) {
     return withConfigFileTransaction(configPath, async (transaction) => {
+        if (expectedRevision !== undefined &&
+            transaction.snapshot.revision !== expectedRevision)
+            throw new ConfigFileConflictError();
         const runner = resolveRequestRunnerConfigReference({
             fileConfig: transaction.snapshot.config,
             mainConfigPath: configPath,
@@ -24,7 +28,9 @@ export function withConfigurationActivationSource(configPath, operation) {
             },
         };
         try {
-            const activation = await operation(preparation);
+            const activation = await (pluginRootDir
+                ? withPluginConfigurationLock(pluginRootDir, () => operation(preparation))
+                : operation(preparation));
             restoreUnappliedRequestRunner(activation, preparation);
             return activation;
         }

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

@@ -1,4 +1,4 @@
-import type { RuntimeSetupGatewayRestorePoint } from "../runtime-setup-gateway.js";
+import type { AppliedGatewayConfigurations, RuntimeSetupGatewayRestorePoint } from "../runtime-setup-gateway.js";
 import type { WebUiEnvironmentConfig } from "../environment-config.js";
 import type { RuntimeSetupActivation } from "./runtime-setup-input.js";
 import type { LocalRuntimeApplication } from "../../runtime/local-application.js";
@@ -11,9 +11,10 @@ export type LocalRuntimeBackendOptions = {
     defaultEnvironmentId: string;
     resolveEnvironmentConfig?: (configPath?: string) => WebUiEnvironmentConfig;
     providerAdapters?: ModelProviderAdapterRegistry;
-    onRuntimeSetup?: (configPath: string) => Promise<RuntimeSetupActivation>;
+    captureRuntimeSetupConfiguration?: (configPath?: string) => string | null;
+    onRuntimeSetup?: (configPath: string, applied?: AppliedGatewayConfigurations) => Promise<RuntimeSetupActivation>;
     createRuntimeSetupRestorePoint?: () => RuntimeSetupGatewayRestorePoint;
-    checkRuntimeSetupActivation?: (configPath: string) => Promise<RuntimeSetupActivation>;
+    checkRuntimeSetupActivation?: (configPath: string, applied?: AppliedGatewayConfigurations) => Promise<RuntimeSetupActivation>;
 };
 export type ResolvedLocalRuntimeBackendOptions = Omit<LocalRuntimeBackendOptions, "providerAdapters"> & {
     providerAdapters: ModelProviderAdapterRegistry;

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

@@ -7,6 +7,7 @@ export declare class RuntimeEnvironmentRegistry {
     private readonly options;
     private readonly schedulerBindings;
     private readonly environments;
+    private readonly gatewayConfigurations;
     private stopped;
     private readonly desiredEnvironmentIds;
     private applying;
@@ -19,13 +20,20 @@ export declare class RuntimeEnvironmentRegistry {
         publishLearning?: (environmentId: string, event?: LearningChangedEvent) => void;
     });
     environmentConfig(): WebUiEnvironmentConfig | undefined;
-    applyConfiguration(): Promise<RuntimeSetupActivation>;
+    existingNativePermissions(environmentId: string): Readonly<{
+        status(): Promise<import("../../computer-access/native-permission-contract.js").NativePermissionStatus>;
+        prepare(input: import("../../computer-access/native-permission-contract.js").NativePermissionInput): Promise<import("../../computer-access/native-permission-contract.js").NativePermissionResult>;
+    }> | undefined;
+    requirePluginInactive(pluginId: string, capabilityIds: readonly string[]): void;
+    requirePluginMutationIdle(hasAcknowledgedRequests?: boolean): void;
+    applyConfiguration(expectedRevision?: string): Promise<RuntimeSetupActivation>;
     private applySavedConfiguration;
     private checkGatewayActivation;
     configure(configPath: string): void;
     modelCatalog(environmentId: string): RuntimeModelCatalogState;
     setupRequirement(environmentId: string): RuntimeSetupRequirement | null;
     get(environmentId: string): RuntimeEnvironment;
+    private captureGatewayConfiguration;
     private createEnvironment;
     start(environmentIds: readonly string[]): Promise<void>;
     private startEnvironment;

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;
@@ -25,13 +30,40 @@ export class RuntimeEnvironmentRegistry {
     environmentConfig() {
         return this.configuredEnvironments;
     }
-    applyConfiguration() {
+    existingNativePermissions(environmentId) {
+        if (this.stopped || this.applying)
+            return undefined;
+        return this.environments.get(environmentId)?.nativePermissions;
+    }
+    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;
         });
@@ -39,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 ??
@@ -46,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")
@@ -72,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({
@@ -136,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/learning-notifications.js

@@ -12,7 +12,7 @@ export function createLearningChangeNotifier(realtime) {
             });
         }
         catch {
-            // Persisted conversations and proposal status are fetched on reconnect.
+            // Persisted conversations and learning status are fetched on reconnect.
         }
         if (event)
             notifyWorkspace(environmentId, ["sessions"]);

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

@@ -1,7 +1,6 @@
 import { acceptConfigMutationRequest } from "./config-mutation-request.js";
 import { sendJson } from "./http.js";
 import { readLearningPreferencesInput } from "../../runtime/local-host/learning-preferences-input.js";
-import { isLearningEventId } from "../../runtime/local-host/learning-events.js";
 export class PassiveLearningRoutes {
     resolveService;
     constructor(resolveService) {
@@ -67,25 +66,6 @@ export class PassiveLearningRoutes {
             });
             return;
         }
-        if (input.segments[2] === "proposals") {
-            if (input.method !== "DELETE") {
-                sendLearningMethodNotAllowed(input.response, "DELETE");
-                return;
-            }
-            const id = input.segments[3];
-            if (!isLearningEventId(id)) {
-                sendJson(input.response, 400, {
-                    ok: false,
-                    error: "passive_learning_proposal_invalid",
-                });
-                return;
-            }
-            if (!service.dismissProposal)
-                throw new Error("passive_learning_unavailable");
-            await service.dismissProposal(id);
-            sendJson(input.response, 200, { ok: true });
-            return;
-        }
         if (input.route === "runtime/learning/pending") {
             if (input.method !== "DELETE") {
                 sendLearningMethodNotAllowed(input.response, "DELETE");
@@ -139,8 +119,6 @@ function isLearningRoute(segments) {
         return segments.length === 3;
     if (segments[2] === "candidates")
         return segments.length === 3;
-    if (segments[2] === "proposals")
-        return segments.length === 4;
     if (segments[2] !== "batches")
         return false;
     return segments.length === 3 || segments.length === 4;

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>;
+}