@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/notifications/contracts.js

@@ -3,6 +3,12 @@ export class NotificationInputError extends Error {
 export function defaultNotificationPreferences() {
     return {
         desktopEnabled: true,
-        kinds: { reply: true, failure: true, approval: true, proposal: true },
+        kinds: {
+            reply: true,
+            failure: true,
+            approval: true,
+            proposal: true,
+            automation: true,
+        },
     };
 }

package/dist/src/web-ui/notifications/conversation-source.d.ts

@@ -0,0 +1,6 @@
+import type { SessionRecord } from "../../sessions/types.js";
+export type NotificationSession = Partial<Pick<SessionRecord, "kind" | "messages" | "requests">> & {
+    automationOrigin?: unknown;
+};
+/** Navigation follows the stored session kind; titles never identify SPARK. */
+export declare function conversationNotificationSource(environmentId: string, sessionId: string, event: Record<string, unknown>, persisted?: NotificationSession | null): string;

package/dist/src/web-ui/notifications/conversation-source.js

@@ -0,0 +1,26 @@
+import { isSparkSession } from "../../sessions/spark-session.js";
+import { toSnapshotMessage } from "../../sessions/record/projection.js";
+/** Navigation follows the stored session kind; titles never identify SPARK. */
+export function conversationNotificationSource(environmentId, sessionId, event, persisted) {
+    const parameters = new URLSearchParams({ environment: environmentId, session: sessionId });
+    if (!persisted || !isSparkSession(persisted))
+        return `/chat?${parameters}`;
+    parameters.delete("session");
+    parameters.set("spark", "1");
+    const proposal = event.event;
+    const message = [...(persisted.messages ?? [])].reverse().find((item) => {
+        if (item.role !== "assistant")
+            return false;
+        if (proposal?.type === "proposal_delivered")
+            return item.initiative?.proposalId === proposal.proposalId;
+        return typeof event.requestId === "string" && item.requestId === event.requestId;
+    });
+    if (message) {
+        const reference = toSnapshotMessage(sessionId, message, persisted.requests ?? []);
+        parameters.set("message", String(reference.id));
+        parameters.set("messageCreatedAt", String(reference.createdAt));
+        if (reference.requestId)
+            parameters.set("request", reference.requestId);
+    }
+    return `/home?${parameters}`;
+}

package/dist/src/web-ui/notifications/event-fields.d.ts

@@ -0,0 +1,3 @@
+export declare function eventText(value: unknown): string;
+export declare function hasNotificationIdentity(value: string): boolean;
+export declare function notificationBody(value: string): string;

package/dist/src/web-ui/notifications/event-fields.js

@@ -0,0 +1,12 @@
+export function eventText(value) {
+    return typeof value === "string" ? value : "";
+}
+export function hasNotificationIdentity(value) {
+    if (!value.trim() || value.length > 512)
+        return false;
+    return !/[\u0000-\u001f\u007f]/u.test(value);
+}
+export function notificationBody(value) {
+    const readable = value.replace(/[\u0000-\u001f\u007f]/gu, " ");
+    return [...readable.replace(/\s+/gu, " ").trim()].slice(0, 600).join("");
+}

package/dist/src/web-ui/notifications/event-projection.d.ts

@@ -1,3 +1,4 @@
 import type { WebNotification } from "./contracts.js";
+import { type NotificationSession } from "./conversation-source.js";
 /** Observe committed client output; replay and progress never create new records. */
-export declare function projectNotificationEvent(event: Record<string, unknown>, now: number): WebNotification | undefined;
+export declare function projectNotificationEvent(event: Record<string, unknown>, now: number, persistedSession?: NotificationSession | null): WebNotification | undefined;

package/dist/src/web-ui/notifications/event-projection.js

@@ -1,16 +1,9 @@
 import { createHash } from "node:crypto";
-function eventText(value) {
-    return typeof value === "string" ? value : "";
-}
-function hasNotificationIdentity(value) {
-    if (!value.trim() || value.length > 512)
-        return false;
-    return !/[\u0000-\u001f\u007f]/u.test(value);
-}
-function notificationBody(value) {
-    const readable = value.replace(/[\u0000-\u001f\u007f]/gu, " ");
-    return [...readable.replace(/\s+/gu, " ").trim()].slice(0, 600).join("");
-}
+import { isSparkSession } from "../../sessions/spark-session.js";
+import { hasAutomationSessionOrigin } from "../../sessions/automation-session-origin.js";
+import { projectAutomationRunNotificationEvent } from "./automation-event-projection.js";
+import { eventText, hasNotificationIdentity, notificationBody } from "./event-fields.js";
+import { conversationNotificationSource } from "./conversation-source.js";
 function stoppedResponse(event) {
     const details = event.details;
     if (!details || typeof details !== "object" || Array.isArray(details))
@@ -22,6 +15,13 @@ function isCancelledRequestEvent(event) {
         return true;
     return event.error === "request_cancelled";
 }
+function isAutomationChildReply(event, persistedSession) {
+    if (event.type !== "completed")
+        return false;
+    if (!persistedSession)
+        return false;
+    return hasAutomationSessionOrigin(persistedSession);
+}
 function failedNotification(event) {
     const sessionId = eventText(event.sessionId);
     const key = eventText(event.requestId);
@@ -84,14 +84,19 @@ function readNotificationEvent(event) {
         kind: "proposal",
         key: eventText(proposal.proposalId),
         sessionId: eventText(proposal.sessionId),
-        title: "New Co-worker suggestion",
-        body: "Co-worker has a new suggestion for you. Open the conversation to review it.",
+        title: "New SPARK suggestion",
+        body: "SPARK has a new suggestion for you. Open the conversation to review it.",
     };
 }
 /** Observe committed client output; replay and progress never create new records. */
-export function projectNotificationEvent(event, now) {
+export function projectNotificationEvent(event, now, persistedSession) {
     if (event.sessionDeleted === true)
         return;
+    if (isAutomationChildReply(event, persistedSession))
+        return;
+    const automation = projectAutomationRunNotificationEvent(event, now);
+    if (automation)
+        return automation;
     const environmentId = eventText(event.environment) || eventText(event.environmentId);
     if (!hasNotificationIdentity(environmentId))
         return;
@@ -105,10 +110,6 @@ export function projectNotificationEvent(event, now) {
     const id = createHash("sha256")
         .update(JSON.stringify([environmentId, projected.kind, projected.key]))
         .digest("hex");
-    const parameters = new URLSearchParams({
-        environment: environmentId,
-        session: projected.sessionId,
-    });
     const requestId = eventText(event.requestId);
     return {
         id,
@@ -119,8 +120,9 @@ export function projectNotificationEvent(event, now) {
         readAt: null,
         environmentId,
         sessionId: projected.sessionId,
+        ...(persistedSession && isSparkSession(persistedSession) ? { sessionKind: "spark" } : {}),
         ...(hasNotificationIdentity(requestId) ? { requestId } : {}),
-        sourceUrl: `/chat?${parameters}`,
+        sourceUrl: conversationNotificationSource(environmentId, projected.sessionId, event, persistedSession),
         delivery: { status: "pending" },
     };
 }

package/dist/src/web-ui/notifications/service.js

@@ -1,3 +1,5 @@
+import { assertValidSessionId } from "../../sessions/record/rules.js";
+import { loadSessionFile } from "../../sessions/session-store.js";
 import { NotificationDeliveryQueue } from "./delivery-queue.js";
 import { projectNotificationEvent } from "./event-projection.js";
 import { WebNotificationStore, notificationStorePath } from "./store.js";
@@ -6,6 +8,20 @@ function isSuppressedReply(item, options) {
         return false;
     return options.isViewing(item.environmentId, item.sessionId);
 }
+function hasValidPersistedSessionReference(sessionId) {
+    try {
+        assertValidSessionId(sessionId);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isCompletedConversationNotification(event, item) {
+    if (event.type !== "completed")
+        return false;
+    return item.kind !== "automation";
+}
 function permitsDesktopNotification(preferences, item) {
     if (!preferences.desktopEnabled)
         return false;
@@ -51,13 +67,28 @@ export class WebNotificationService {
     observe(event) {
         if (this.abort.signal.aborted)
             return;
-        const item = projectNotificationEvent(event, this.now());
+        const observedAt = this.now();
+        const item = projectNotificationEvent(event, observedAt);
         if (!item || isSuppressedReply(item, this.options))
             return;
         if (!this.hasEnvironment(item.environmentId))
             return;
+        if (item.kind !== "automation" &&
+            !hasValidPersistedSessionReference(item.sessionId))
+            return;
         this.queue = this.queue
-            .then(() => this.record(item))
+            .then(async () => {
+            if (item.kind === "automation")
+                return this.record(item);
+            const { sessionsDir } = this.options.environment(item.environmentId).services.config.paths;
+            const persisted = await loadSessionFile(sessionsDir, item.sessionId);
+            const hasPersistedConversation = persisted !== null;
+            if (!hasPersistedConversation && isCompletedConversationNotification(event, item))
+                return;
+            const projected = projectNotificationEvent(event, observedAt, persisted);
+            if (projected)
+                await this.record(projected);
+        })
             .catch((error) => this.reportFailure(item.environmentId, error));
     }
     async record(item) {

package/dist/src/web-ui/notifications/storage-schema.js

@@ -1,3 +1,4 @@
+import { SPARK_SESSION_ID } from "../../sessions/spark-session.js";
 export function isNotificationRecord(value) {
     if (value === null)
         return false;
@@ -40,12 +41,40 @@ export function isNotificationPreferences(value) {
         return false;
     if (!isNotificationRecord(value.kinds))
         return false;
-    const kinds = ["reply", "failure", "approval", "proposal"];
+    const kinds = ["reply", "failure", "approval", "proposal", "automation"];
     const preferences = value.kinds;
     if (!hasOnlyNotificationFields(preferences, kinds))
         return false;
     return kinds.every((kind) => typeof preferences[kind] === "boolean");
 }
+function normalizeStoredNotificationPreferences(value) {
+    if (isNotificationPreferences(value))
+        return value;
+    if (!isNotificationRecord(value))
+        return null;
+    if (!hasOnlyNotificationFields(value, ["desktopEnabled", "kinds"]))
+        return null;
+    if (typeof value.desktopEnabled !== "boolean")
+        return null;
+    if (!isNotificationRecord(value.kinds))
+        return null;
+    const kinds = value.kinds;
+    const legacyKinds = ["reply", "failure", "approval", "proposal"];
+    if (!hasOnlyNotificationFields(kinds, legacyKinds))
+        return null;
+    if (!legacyKinds.every((kind) => typeof kinds[kind] === "boolean"))
+        return null;
+    return {
+        desktopEnabled: value.desktopEnabled,
+        kinds: {
+            reply: kinds.reply,
+            failure: kinds.failure,
+            approval: kinds.approval,
+            proposal: kinds.proposal,
+            automation: true,
+        },
+    };
+}
 export function isNotificationDelivery(value) {
     if (!isNotificationRecord(value))
         return false;
@@ -67,28 +96,97 @@ export function isNotificationDelivery(value) {
         return true;
     return isNotificationText(value.error, 4096);
 }
+function sparkNotificationSourceTarget(value, source) {
+    if (value.sessionKind !== "spark")
+        return null;
+    if (value.sessionId !== SPARK_SESSION_ID)
+        return null;
+    const parameters = {
+        environment: value.environmentId,
+        spark: "1",
+    };
+    const message = source.get("message");
+    const createdAt = source.get("messageCreatedAt");
+    const request = source.get("request");
+    if (message === null && createdAt === null && request === null)
+        return { path: "/home", parameters };
+    if (!isNotificationIdentifier(message))
+        return null;
+    if (createdAt === null || !isNotificationTimestamp(Number(createdAt)))
+        return null;
+    if (String(Number(createdAt)) !== createdAt)
+        return null;
+    parameters.message = message;
+    parameters.messageCreatedAt = createdAt;
+    if (request !== (value.requestId ?? null))
+        return null;
+    if (request !== null)
+        parameters.request = request;
+    return { path: "/home", parameters };
+}
+function notificationSourceTarget(value, source) {
+    if (value.kind === "automation") {
+        if (!isNotificationIdentifier(value.automationId))
+            return null;
+        if (!isNotificationIdentifier(value.runId))
+            return null;
+        if (value.sessionId !== undefined)
+            return null;
+        if (value.sessionKind !== undefined)
+            return null;
+        if (value.requestId !== undefined)
+            return null;
+        return {
+            path: "/automations",
+            parameters: {
+                environment: value.environmentId,
+                automation: value.automationId,
+                run: value.runId,
+            },
+        };
+    }
+    if (!isNotificationIdentifier(value.sessionId))
+        return null;
+    if (value.automationId !== undefined)
+        return null;
+    if (value.runId !== undefined)
+        return null;
+    if (value.requestId !== undefined && !isNotificationIdentifier(value.requestId))
+        return null;
+    if (value.sessionKind !== undefined)
+        return sparkNotificationSourceTarget(value, source);
+    return {
+        path: "/chat",
+        parameters: {
+            environment: value.environmentId,
+            session: value.sessionId,
+        },
+    };
+}
 function hasBoundNotificationSource(value) {
     if (typeof value.sourceUrl !== "string")
         return false;
-    if (!value.sourceUrl.startsWith("/chat?"))
-        return false;
     try {
         const url = new URL(value.sourceUrl, "http://notification.local");
-        if (url.origin !== "http://notification.local")
-            return false;
-        if (url.pathname !== "/chat")
+        const target = notificationSourceTarget(value, url.searchParams);
+        if (!target)
             return false;
-        if (url.hash)
+        if (!value.sourceUrl.startsWith(`${target.path}?`))
             return false;
-        if (url.searchParams.get("environment") !== value.environmentId)
-            return false;
-        if (url.searchParams.get("session") !== value.sessionId)
+        if (url.origin !== "http://notification.local")
             return false;
-        if (url.searchParams.getAll("environment").length !== 1)
+        if (url.pathname !== target.path)
             return false;
-        if (url.searchParams.getAll("session").length !== 1)
+        if (url.hash)
             return false;
-        return [...url.searchParams.keys()].every((key) => ["environment", "session"].includes(key));
+        const expectedKeys = Object.keys(target.parameters);
+        for (const key of expectedKeys) {
+            if (url.searchParams.getAll(key).length !== 1)
+                return false;
+            if (url.searchParams.get(key) !== target.parameters[key])
+                return false;
+        }
+        return [...url.searchParams.keys()].every((key) => expectedKeys.includes(key));
     }
     catch {
         return false;
@@ -106,7 +204,10 @@ export function isWebNotification(value, environmentId) {
         "readAt",
         "environmentId",
         "sessionId",
+        "sessionKind",
         "requestId",
+        "automationId",
+        "runId",
         "sourceUrl",
         "delivery",
     ];
@@ -116,7 +217,7 @@ export function isWebNotification(value, environmentId) {
         return false;
     if (typeof value.kind !== "string")
         return false;
-    if (!["reply", "failure", "approval", "proposal"].includes(value.kind))
+    if (!["reply", "failure", "approval", "proposal", "automation"].includes(value.kind))
         return false;
     if (!isNotificationText(value.title, 1024))
         return false;
@@ -130,11 +231,6 @@ export function isWebNotification(value, environmentId) {
         return false;
     if (value.environmentId !== environmentId)
         return false;
-    if (!isNotificationIdentifier(value.sessionId))
-        return false;
-    if (value.requestId !== undefined &&
-        !isNotificationIdentifier(value.requestId))
-        return false;
     if (!hasBoundNotificationSource(value))
         return false;
     return isNotificationDelivery(value.delivery);
@@ -154,7 +250,8 @@ export function decodeNotificationState(raw, environmentId) {
         "preferences",
     ]))
         throw new Error("Unexpected notification storage fields.");
-    if (!isNotificationPreferences(value.preferences))
+    const preferences = normalizeStoredNotificationPreferences(value.preferences);
+    if (!preferences)
         throw new Error("Invalid notification preferences.");
     if (!Array.isArray(value.items))
         throw new Error("Invalid notification history.");
@@ -166,5 +263,5 @@ export function decodeNotificationState(raw, environmentId) {
             throw new Error("Duplicate stored notification.");
         seen.add(item.id);
     }
-    return value;
+    return { ...value, preferences };
 }

package/dist/src/web-ui/plugin-capability-selection.js

@@ -1,9 +1,11 @@
-import { isPluginToolSelected, normalizePluginSelection, } from "../runtime/plugins/selection.js";
+import { isPluginToolSelected, isPluginDisabledById, normalizePluginSelection, } from "../runtime/plugins/selection.js";
 export function pluginParentBlockReason(pluginId, selection) {
     if (!selection.enabled)
         return "Plugins are disabled globally.";
     if (selection.deny.includes("*"))
         return "The global deny rule blocks all plugins.";
+    if (isPluginDisabledById(pluginId, selection))
+        return "Enable this plugin before changing its capabilities.";
     if (selection.deny.includes(pluginId))
         return "Enable this plugin before changing its capabilities.";
     return undefined;
@@ -25,6 +27,7 @@ function isCapabilityAllowed(params) {
             ...params.current,
             enabled: true,
             deny: [],
+            disabledPluginIds: [],
         }),
     });
 }

package/dist/src/web-ui/plugin-configuration-input.d.ts

@@ -0,0 +1,12 @@
+import type { PluginConfigurationDeclaration } from "../runtime/plugins/configuration-context.js";
+import { type PluginLocalConfiguration } from "../runtime/plugins/configuration-store.js";
+export declare function parsePluginConfigurationUpdate(input: unknown, declaration: PluginConfigurationDeclaration, previous?: PluginLocalConfiguration): {
+    revision: string;
+    configuration: {
+        settings: Record<string, unknown>;
+        secrets: Record<string, {
+            env: string;
+            value: string | null;
+        }>;
+    };
+};

package/dist/src/web-ui/plugin-configuration-input.js

@@ -0,0 +1,68 @@
+import { clearRetainedPluginSecrets, requireRetainedSecretClearedBeforeReplacement, } from "./plugin-configuration-retained-secrets.js";
+import { pluginSettingMatchesDefault } from "../runtime/plugins/configuration-settings.js";
+import { isRecord } from "../runtime/config/utils.js";
+import { PluginConfigurationError, } from "../runtime/plugins/configuration-store.js";
+function invalidConfiguration(message) {
+    throw new PluginConfigurationError("invalid_plugin_configuration", message);
+}
+function parseSettings(input, declaration) {
+    if (!isRecord(input))
+        return invalidConfiguration("Plugin settings must be an object.");
+    const defaults = declaration.settings?.defaults ?? {};
+    for (const [name, value] of Object.entries(input)) {
+        if (!Object.hasOwn(defaults, name))
+            return invalidConfiguration("Only declared plugin settings can be edited.");
+        if (!pluginSettingMatchesDefault(value, defaults[name]))
+            return invalidConfiguration(`The value for ${name} must match its default type.`);
+    }
+    return input;
+}
+function parseSecretChanges(input, declaration, previous) {
+    if (!isRecord(input))
+        return invalidConfiguration("Plugin secrets must be an object.");
+    const declarations = declaration.secrets ?? {};
+    const changes = Object.entries(input).map(([name, change]) => {
+        if (!Object.hasOwn(declarations, name))
+            return invalidConfiguration("Only declared plugin secrets can be edited.");
+        requireRetainedSecretClearedBeforeReplacement(name, declaration, previous);
+        if (!isRecord(change))
+            return invalidConfiguration("Choose how to update each secret.");
+        if (change.action === "clear") {
+            if (Object.keys(change).length !== 1)
+                return invalidConfiguration("Clear accepts no secret value.");
+            return [name, { env: declarations[name].env, value: null }];
+        }
+        if (change.action !== "set")
+            return invalidConfiguration("A secret change must be set or clear; omit it to keep the current value.");
+        if (Object.keys(change).some((key) => !["action", "value"].includes(key)))
+            return invalidConfiguration("Unsupported secret change.");
+        if (typeof change.value !== "string" || !change.value.trim())
+            return invalidConfiguration("Enter a non-empty secret or explicitly clear it.");
+        return [
+            name,
+            { env: declarations[name].env, value: change.value },
+        ];
+    });
+    return { ...previous?.secrets, ...Object.fromEntries(changes) };
+}
+export function parsePluginConfigurationUpdate(input, declaration, previous) {
+    if (!isRecord(input))
+        return invalidConfiguration("Reload plugin configuration before saving.");
+    if (Object.keys(input).some((key) => !["revision", "settings", "secrets", "clearRetainedSecrets"].includes(key)))
+        return invalidConfiguration("Unsupported plugin configuration fields.");
+    if (typeof input.revision !== "string" || !input.revision)
+        return invalidConfiguration("Reload plugin configuration before saving.");
+    if (Buffer.byteLength(JSON.stringify(input)) > 128 * 1024)
+        return invalidConfiguration("Plugin configuration is too large.");
+    const kept = {
+        settings: previous?.settings ?? {},
+        secrets: clearRetainedPluginSecrets(input.clearRetainedSecrets, declaration, previous),
+    };
+    return {
+        revision: input.revision,
+        configuration: {
+            settings: parseSettings(input.settings, declaration),
+            secrets: parseSecretChanges(input.secrets ?? {}, declaration, kept),
+        },
+    };
+}

package/dist/src/web-ui/plugin-configuration-retained-secrets.d.ts

@@ -0,0 +1,9 @@
+import type { PluginConfigurationDeclaration } from "../runtime/plugins/configuration-context.js";
+import { type PluginLocalConfiguration } from "../runtime/plugins/configuration-store.js";
+export declare function retainedPluginSecrets(declaration: PluginConfigurationDeclaration, local?: PluginLocalConfiguration): {
+    name: string;
+    env: string;
+    configured: boolean;
+}[];
+export declare function clearRetainedPluginSecrets(input: unknown, declaration: PluginConfigurationDeclaration, previous?: PluginLocalConfiguration): PluginLocalConfiguration["secrets"];
+export declare function requireRetainedSecretClearedBeforeReplacement(name: string, declaration: PluginConfigurationDeclaration, previous?: PluginLocalConfiguration): void;

package/dist/src/web-ui/plugin-configuration-retained-secrets.js

@@ -0,0 +1,48 @@
+import { isRecord } from "../runtime/config/utils.js";
+import { PluginConfigurationError, } from "../runtime/plugins/configuration-store.js";
+function isDeclaredSecretBinding(declaration, name, env) {
+    const secrets = declaration.secrets ?? {};
+    if (!Object.hasOwn(secrets, name))
+        return false;
+    return secrets[name].env === env;
+}
+export function retainedPluginSecrets(declaration, local) {
+    return Object.entries(local?.secrets ?? {})
+        .filter(([name, saved]) => !isDeclaredSecretBinding(declaration, name, saved.env))
+        .map(([name, saved]) => ({
+        name,
+        env: saved.env,
+        configured: Boolean(saved.value?.trim()),
+    }));
+}
+function invalidRetainedSecretChange(message) {
+    throw new PluginConfigurationError("invalid_plugin_configuration", message);
+}
+export function clearRetainedPluginSecrets(input, declaration, previous) {
+    const kept = { ...previous?.secrets };
+    if (input === undefined)
+        return kept;
+    if (!Array.isArray(input))
+        return invalidRetainedSecretChange("Choose which unused saved keys to delete.");
+    for (const entry of input) {
+        if (!isRecord(entry))
+            return invalidRetainedSecretChange("Choose an unused saved key to delete.");
+        if (Object.keys(entry).some((key) => !["name", "env"].includes(key)))
+            return invalidRetainedSecretChange("An unused key removal accepts only its name and environment binding.");
+        if (typeof entry.name !== "string" || typeof entry.env !== "string")
+            return invalidRetainedSecretChange("An unused key removal requires its name and environment binding.");
+        if (!Object.hasOwn(kept, entry.name) || kept[entry.name].env !== entry.env)
+            return invalidRetainedSecretChange("The unused saved key changed. Reload the form before deleting it.");
+        if (isDeclaredSecretBinding(declaration, entry.name, entry.env))
+            return invalidRetainedSecretChange("Use the declared key's Clear value action to clear it.");
+        delete kept[entry.name];
+    }
+    return kept;
+}
+export function requireRetainedSecretClearedBeforeReplacement(name, declaration, previous) {
+    if (!previous || !Object.hasOwn(previous.secrets, name))
+        return;
+    if (isDeclaredSecretBinding(declaration, name, previous.secrets[name].env))
+        return;
+    throw new PluginConfigurationError("invalid_plugin_configuration", `Delete the unused saved key ${name} explicitly before configuring its new environment binding.`);
+}

package/dist/src/web-ui/plugin-configuration-service.d.ts

@@ -0,0 +1,52 @@
+import type { ConfigFileTransaction } from "../runtime/adapters/config-file-transaction.js";
+import type { PluginManagementOptions } from "./plugin-management-service.js";
+export declare function getRuntimePluginConfiguration(options: PluginManagementOptions, pluginId: string): {
+    pluginId: string;
+    revision: string;
+    scope: "installation";
+    defaults: Readonly<Record<string, unknown>>;
+    settings: Record<string, unknown>;
+    settingOverrides: string[];
+    retainedSecrets: {
+        name: string;
+        env: string;
+        configured: boolean;
+    }[];
+    secrets: {
+        name: string;
+        env: string;
+        required: boolean;
+        configured: boolean;
+        locallyConfigured: boolean;
+    }[];
+};
+/** Configuration and package selection commit under the same locks as Apply. */
+export declare function saveRuntimePluginConfiguration<T>(options: PluginManagementOptions, params: {
+    pluginId: string;
+    input: unknown;
+    transaction?: ConfigFileTransaction;
+    installation?: boolean;
+    commit?: () => Promise<T>;
+}): Promise<{
+    result: Awaited<T> | undefined;
+    configuration: {
+        pluginId: string;
+        revision: string;
+        scope: "installation";
+        defaults: Readonly<Record<string, unknown>>;
+        settings: Record<string, unknown>;
+        settingOverrides: string[];
+        retainedSecrets: {
+            name: string;
+            env: string;
+            configured: boolean;
+        }[];
+        secrets: {
+            name: string;
+            env: string;
+            required: boolean;
+            configured: boolean;
+            locallyConfigured: boolean;
+        }[];
+    };
+}>;