@abot-ai/runtime 1.3.0 → 1.4.0

package/dist/src/web-ui/local-runtime/setup-embedding-provider.js

@@ -0,0 +1,114 @@
+import { buildProviderConfig } from "../../../scripts/runtime-setup-files.js";
+import { createFileLongTermMemoryOnboardingConfigRepository } from "../../runtime/adapters/long-term-memory/onboarding-config-repository.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
+import { assertRuntimeSetupCredentialFile, hasRuntimeSetupCredential, readRuntimeSetupCredential, persistRuntimeSetupCredentials, } from "./runtime-setup-credentials.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+import { hasProviderCredentialBinding, isolatedProviderCredentialName, } from "./provider-credential-identity.js";
+function readProviderMap(models) {
+    if (!isRecord(models))
+        return {};
+    return isRecord(models.providers) ? models.providers : {};
+}
+function hasRequestedEmbeddingAdapter(provider, adapter) {
+    if (!isRecord(provider))
+        return false;
+    return provider.type === adapter;
+}
+function resolveSetupEmbeddingProviderId(providers, input) {
+    if (input.providerId)
+        return input.providerId;
+    const adapter = input.provider;
+    if (!Object.hasOwn(providers, adapter))
+        return adapter;
+    if (hasRequestedEmbeddingAdapter(providers[adapter], adapter))
+        return adapter;
+    let suffix = 2;
+    while (Object.hasOwn(providers, `${adapter}-${suffix}`))
+        suffix += 1;
+    return `${adapter}-${suffix}`;
+}
+function needsIsolatedEmbeddingCredential(existing, input, providerId) {
+    if (isRecord(existing))
+        return false;
+    if (input.provider !== "openai")
+        return false;
+    return providerId !== input.provider;
+}
+function resolveIsolatedEmbeddingCredentialName(providers, providerId) {
+    const apiKeyEnv = isolatedProviderCredentialName(providerId);
+    if (hasProviderCredentialBinding(providers, apiKeyEnv))
+        throw new RuntimeSetupError("embedding_credential_conflict", "The new connection's credential name is already used by another provider. Its settings were preserved.", 409);
+    return apiKeyEnv;
+}
+function embeddingCredentialToSave(rootDir, apiKeyEnv, input, isolated) {
+    if (input.apiKey)
+        return input.apiKey;
+    if (!isolated)
+        return undefined;
+    if (readRuntimeSetupCredential(rootDir, apiKeyEnv))
+        return undefined;
+    return readRuntimeSetupCredential(rootDir) || undefined;
+}
+function requirePreservedProviderSettings(provider, input) {
+    if (input.provider && provider.type !== input.provider) {
+        throw new RuntimeSetupError("embedding_provider_conflict", "That provider ID already uses another adapter. Its settings were preserved.", 409);
+    }
+    if (input.baseUrl && input.baseUrl !== provider.baseUrl) {
+        throw new RuntimeSetupError("embedding_provider_conflict", "That provider already uses another address. Choose its saved connection or edit it in Settings.", 409);
+    }
+    if (input.apiKey && provider.type !== "openai") {
+        throw new RuntimeSetupError("invalid_embedding_credential", "Only an OpenAI connection accepts an API key here.");
+    }
+}
+/** Adds only the requested provider; chat profiles and existing provider settings stay intact. */
+export async function prepareSetupEmbeddingProvider(options, input) {
+    const repository = createFileLongTermMemoryOnboardingConfigRepository(options);
+    const snapshot = await repository.read();
+    const providers = readProviderMap(snapshot.config.models);
+    const providerId = resolveSetupEmbeddingProviderId(providers, input);
+    const existing = providers[providerId];
+    if (input.providerId && !isRecord(existing)) {
+        throw new RuntimeSetupError("embedding_provider_not_configured", "Choose a configured provider or add an OpenAI or Ollama connection.", 404);
+    }
+    const provider = isRecord(existing)
+        ? existing
+        : buildProviderConfig(input.provider, input.baseUrl);
+    const isolatedCredential = needsIsolatedEmbeddingCredential(existing, input, providerId);
+    if (isolatedCredential)
+        provider.apiKeyEnv = resolveIsolatedEmbeddingCredentialName(providers, providerId);
+    requirePreservedProviderSettings(provider, input);
+    const models = isRecord(snapshot.config.models) ? snapshot.config.models : {};
+    const candidate = {
+        ...snapshot.config,
+        models: { ...models, providers: { ...providers, [providerId]: provider } },
+    };
+    validateRuntimeConfigFile(candidate, snapshot.path);
+    const apiKeyEnv = typeof provider.apiKeyEnv === "string"
+        ? provider.apiKeyEnv
+        : "OPENAI_API_KEY";
+    if (provider.type === "openai") {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(apiKeyEnv)) {
+            throw new RuntimeSetupError("invalid_embedding_credential_environment", "The configured credential environment name is invalid. Its settings were preserved.");
+        }
+        await assertRuntimeSetupCredentialFile(options.rootDir);
+        const apiKey = embeddingCredentialToSave(options.rootDir, apiKeyEnv, input, isolatedCredential);
+        if (!apiKey &&
+            !(await hasRuntimeSetupCredential(options.rootDir, apiKeyEnv))) {
+            throw new RuntimeSetupError("embedding_credential_required", "Enter an OpenAI API key for the embedding connection.");
+        }
+        await persistRuntimeSetupCredentials({
+            rootDir: options.rootDir,
+            configPath: snapshot.path,
+            apiKey,
+            apiKeyEnv,
+            preserveExistingCredential: true,
+        });
+    }
+    if (!isRecord(existing))
+        await repository.write(candidate, snapshot.config);
+    return {
+        providerId,
+        savedProvider: { id: providerId, type: provider.type },
+    };
+}

package/dist/src/web-ui/local-runtime/setup-embedding-routes.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { SetupEmbeddingService } from "./setup-embedding-service.js";
+export declare class SetupEmbeddingRoutes {
+    private readonly service;
+    constructor(service: SetupEmbeddingService);
+    handle(params: {
+        method: string;
+        route: string;
+        request: IncomingMessage;
+        response: ServerResponse;
+    }): Promise<boolean>;
+}

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

@@ -0,0 +1,53 @@
+import { assertConfigMutationRequest, ConfigMutationRequestError, } from "./config-mutation-request.js";
+import { readBody, readJsonBody, sendJson } from "./http.js";
+import { withHttpRequestAbortSignal } from "./request-abort.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+import { SetupEmbeddingFailure, } from "./setup-embedding-service.js";
+export class SetupEmbeddingRoutes {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    async handle(params) {
+        if (params.route !== "runtime/setup/embedding")
+            return false;
+        params.response.setHeader("cache-control", "no-store");
+        try {
+            if (params.method !== "POST") {
+                sendJson(params.response, 405, {
+                    ok: false,
+                    error: "method_not_allowed",
+                });
+                return true;
+            }
+            assertConfigMutationRequest(params.request);
+            const body = readJsonBody(await readBody(params.request, { maxBytes: 16_384 }));
+            const result = await withHttpRequestAbortSignal({
+                request: params.request,
+                response: params.response,
+                reason: "embedding_setup_aborted",
+                run: (signal) => this.service.enable(body, signal),
+            });
+            sendJson(params.response, 200, { ok: true, ...result });
+        }
+        catch (error) {
+            const known = error instanceof RuntimeSetupError ||
+                error instanceof ConfigMutationRequestError ||
+                error instanceof SetupEmbeddingFailure;
+            sendJson(params.response, known ? error.statusCode : 400, {
+                ok: false,
+                error: error instanceof RuntimeSetupError
+                    ? error.code
+                    : "embedding_setup_failed",
+                message: known
+                    ? error.message
+                    : "Embedding setup could not be completed. Check the connection and model, then try again.",
+                providerSaved: error instanceof SetupEmbeddingFailure && error.providerSaved,
+                ...(error instanceof SetupEmbeddingFailure && error.savedProvider
+                    ? { savedProvider: error.savedProvider }
+                    : {}),
+            });
+        }
+        return true;
+    }
+}

package/dist/src/web-ui/local-runtime/setup-embedding-service.d.ts

@@ -0,0 +1,32 @@
+import type { ModelProviderAdapterRegistry } from "../../model-gateway/index.js";
+import { type SavedEmbeddingProvider } from "./setup-embedding-provider.js";
+export declare class SetupEmbeddingFailure extends Error {
+    readonly providerSaved: boolean;
+    readonly statusCode: number;
+    readonly savedProvider?: SavedEmbeddingProvider | undefined;
+    readonly code = "embedding_setup_failed";
+    constructor(providerSaved: boolean, statusCode: number, message: string, savedProvider?: SavedEmbeddingProvider | undefined);
+}
+export declare class SetupEmbeddingService {
+    private readonly options;
+    constructor(options: {
+        rootDir: string;
+        getConfigPath: () => string | undefined;
+        providerAdapters: ModelProviderAdapterRegistry;
+    });
+    enable(body: Record<string, unknown>, abortSignal: AbortSignal): Promise<{
+        status: Readonly<{
+            enabled: boolean;
+            emitClientEvents: boolean;
+            profileId?: string;
+            providerId?: string;
+            model?: string;
+            providers: readonly import("../../runtime/index.js").LongTermMemoryOnboardingProvider[];
+        }>;
+        probe: Readonly<{
+            modelFingerprint: string;
+            dimensions: number;
+        }> | undefined;
+        restartRequired: boolean;
+    }>;
+}

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

@@ -0,0 +1,59 @@
+import { createLocalLongTermMemoryOnboardingService } from "../../runtime/adapters/long-term-memory/onboarding-service.js";
+import { parseSetupEmbeddingInput } from "./setup-embedding-input.js";
+import { prepareSetupEmbeddingProvider, } from "./setup-embedding-provider.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+export class SetupEmbeddingFailure extends Error {
+    providerSaved;
+    statusCode;
+    savedProvider;
+    code = "embedding_setup_failed";
+    constructor(providerSaved, statusCode, message, savedProvider) {
+        super(message);
+        this.providerSaved = providerSaved;
+        this.statusCode = statusCode;
+        this.savedProvider = savedProvider;
+    }
+}
+export class SetupEmbeddingService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async enable(body, abortSignal) {
+        const input = parseSetupEmbeddingInput(body);
+        abortSignal.throwIfAborted();
+        const options = {
+            rootDir: this.options.rootDir,
+            configPath: this.options.getConfigPath(),
+        };
+        let savedProvider;
+        try {
+            const prepared = await prepareSetupEmbeddingProvider(options, input);
+            savedProvider = prepared.savedProvider;
+            abortSignal.throwIfAborted();
+            const service = createLocalLongTermMemoryOnboardingService({
+                ...options,
+                providerAdapters: this.options.providerAdapters,
+            });
+            const result = await service.enable({
+                providerId: prepared.providerId,
+                model: input.model,
+                abortSignal,
+            });
+            return {
+                status: result.status,
+                probe: result.probe,
+                restartRequired: true,
+            };
+        }
+        catch (error) {
+            if (error instanceof RuntimeSetupError)
+                throw error;
+            const providerSaved = savedProvider !== undefined;
+            const message = providerSaved
+                ? "The provider connection is saved, but the embedding check or memory save failed. Memory settings were not changed. Check the model and try again, or skip this step."
+                : "The embedding connection could not be completed. Completed local settings were kept; memory settings were not changed.";
+            throw new SetupEmbeddingFailure(providerSaved, 400, message, savedProvider);
+        }
+    }
+}

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

@@ -12,5 +12,6 @@ export declare class LocalRuntimeWebBackend {
     handleHttp(req: IncomingMessage, res: ServerResponse, pathname: string): Promise<boolean>;
     handleRealtimeConnection(client: WebSocket): void;
     start(environmentIds: readonly string[]): Promise<void>;
+    environmentConfig(): import("./environment-config.js").WebUiEnvironmentConfig | undefined;
     stop(): Promise<void>;
 }

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

@@ -71,6 +71,9 @@ export class LocalRuntimeWebBackend {
         await this.api.initializeSessionReadState(environmentIds);
         await this.environments.start(environmentIds);
     }
+    environmentConfig() {
+        return this.environments.environmentConfig();
+    }
     stop() {
         return this.environments.stop();
     }

package/dist/src/web-ui/plugin-capability-selection.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimePluginConfig } from "../runtime/ports.js";
+import { type PluginSelection } from "../runtime/plugins/selection.js";
+export declare function pluginParentBlockReason(pluginId: string, selection: PluginSelection): string | undefined;
+export declare function capabilityPolicyBlockReason(params: {
+    pluginId: string;
+    capabilityId: string;
+    selection: PluginSelection;
+}): string | undefined;
+export declare function updatePluginCapabilitySelection(params: {
+    current: RuntimePluginConfig;
+    pluginId: string;
+    capabilityId: string;
+    enabled: boolean;
+}): RuntimePluginConfig;

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

@@ -0,0 +1,48 @@
+import { isPluginToolSelected, 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 (selection.deny.includes(pluginId))
+        return "Enable this plugin before changing its capabilities.";
+    return undefined;
+}
+export function capabilityPolicyBlockReason(params) {
+    const parentBlock = pluginParentBlockReason(params.pluginId, params.selection);
+    if (parentBlock)
+        return parentBlock;
+    if (params.selection.deny.includes(params.capabilityId)) {
+        return "A shared capability deny rule blocks this capability. Review the rule in Advanced settings.";
+    }
+    return undefined;
+}
+function isCapabilityAllowed(params) {
+    return isPluginToolSelected({
+        pluginId: params.pluginId,
+        toolName: params.capabilityId,
+        selection: normalizePluginSelection({
+            ...params.current,
+            enabled: true,
+            deny: [],
+        }),
+    });
+}
+function addQualifiedCapabilityDeny(current, qualifiedId) {
+    const deny = [...(current.deny ?? [])];
+    const hasQualifiedDeny = deny.some((entry) => entry.trim() === qualifiedId);
+    if (hasQualifiedDeny)
+        return { ...current, deny };
+    return { ...current, deny: [...deny, qualifiedId] };
+}
+export function updatePluginCapabilitySelection(params) {
+    const qualifiedId = `${params.pluginId}.${params.capabilityId}`;
+    if (!params.enabled) {
+        return addQualifiedCapabilityDeny(params.current, qualifiedId);
+    }
+    const deny = params.current.deny?.filter((entry) => entry.trim() !== qualifiedId);
+    const next = { ...params.current, ...(deny ? { deny } : {}) };
+    if (isCapabilityAllowed(params))
+        return next;
+    return { ...next, allow: [...(params.current.allow ?? []), qualifiedId] };
+}

package/dist/src/web-ui/plugin-management-catalog.d.ts

@@ -0,0 +1,26 @@
+import type { RuntimePluginConfig } from "../runtime/ports.js";
+import type { DiscoveredAgentPluginManifest } from "../runtime/plugins/discovered-manifest.js";
+import { type PluginSelection } from "../runtime/plugins/selection.js";
+export type RuntimePluginCapabilitySnapshot = {
+    id: string;
+    description: string;
+    enabled: boolean;
+    blockedByPolicy: boolean;
+    blockedReason?: string;
+};
+export type RuntimePluginSnapshot = {
+    selection: PluginSelection;
+    plugins: Array<{
+        id: string;
+        description?: string;
+        version?: string;
+        pluginEnabled: boolean;
+        capabilities: RuntimePluginCapabilitySnapshot[];
+        capabilityCount: number;
+        selectedCapabilityCount: number;
+        state: "enabled" | "partial" | "disabled";
+        blockedByGlobalPolicy: boolean;
+    }>;
+    application: "restart_required";
+};
+export declare function projectPluginSnapshot(manifests: readonly DiscoveredAgentPluginManifest[], config: RuntimePluginConfig): RuntimePluginSnapshot;

package/dist/src/web-ui/plugin-management-catalog.js

@@ -0,0 +1,56 @@
+import { ABOT_RUNTIME_EXTENSION } from "../plugin-contract/manifest.js";
+import { isPluginToolSelected, normalizePluginSelection, } from "../runtime/plugins/selection.js";
+import { capabilityPolicyBlockReason, pluginParentBlockReason, } from "./plugin-capability-selection.js";
+function pluginState(selectedCount, capabilityCount) {
+    if (selectedCount === 0)
+        return "disabled";
+    if (selectedCount < capabilityCount)
+        return "partial";
+    return "enabled";
+}
+function isPluginSelectionGloballyBlocked(selection) {
+    if (!selection.enabled)
+        return true;
+    return selection.deny.includes("*");
+}
+function projectPluginCapabilities(plugin, selection) {
+    const pluginId = plugin.manifest.name;
+    return Object.entries(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities).map(([id, capability]) => {
+        const blockedReason = capabilityPolicyBlockReason({
+            pluginId,
+            capabilityId: id,
+            selection,
+        });
+        return {
+            id,
+            description: capability.description,
+            enabled: isPluginToolSelected({ pluginId, toolName: id, selection }),
+            blockedByPolicy: blockedReason !== undefined,
+            ...(blockedReason ? { blockedReason } : {}),
+        };
+    });
+}
+export function projectPluginSnapshot(manifests, config) {
+    const selection = normalizePluginSelection(config);
+    return {
+        selection,
+        plugins: manifests.map((plugin) => {
+            const manifest = plugin.manifest;
+            const capabilities = projectPluginCapabilities(plugin, selection);
+            const capabilityCount = capabilities.length;
+            const selectedCapabilityCount = capabilities.filter((capability) => capability.enabled).length;
+            return {
+                id: manifest.name,
+                ...(manifest.description ? { description: manifest.description } : {}),
+                ...(manifest.version ? { version: manifest.version } : {}),
+                pluginEnabled: pluginParentBlockReason(manifest.name, selection) === undefined,
+                capabilities,
+                capabilityCount,
+                selectedCapabilityCount,
+                state: pluginState(selectedCapabilityCount, capabilityCount),
+                blockedByGlobalPolicy: isPluginSelectionGloballyBlocked(selection),
+            };
+        }),
+        application: "restart_required",
+    };
+}

package/dist/src/web-ui/plugin-management-selection.d.ts

@@ -0,0 +1,16 @@
+import type { DiscoveredAgentPluginManifest } from "../runtime/plugins/discovered-manifest.js";
+import type { RuntimePluginConfig } from "../runtime/ports.js";
+export declare function updatePluginSelection(params: {
+    current: RuntimePluginConfig;
+    pluginId: string;
+    capabilityIds: readonly string[];
+    capabilityId?: string;
+    enabled: boolean;
+}): RuntimePluginConfig;
+export declare function pluginSelectionEscapesRequestedScope(params: {
+    manifests: readonly DiscoveredAgentPluginManifest[];
+    pluginId: string;
+    capabilityId?: string;
+    before: RuntimePluginConfig;
+    after: RuntimePluginConfig;
+}): boolean;

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

@@ -0,0 +1,71 @@
+import { ABOT_RUNTIME_EXTENSION } from "../plugin-contract/manifest.js";
+import { updatePluginCapabilitySelection } from "./plugin-capability-selection.js";
+import { isPluginToolSelected, normalizePluginSelection, } from "../runtime/plugins/selection.js";
+export function updatePluginSelection(params) {
+    if (params.capabilityId !== undefined) {
+        return updatePluginCapabilitySelection({
+            ...params,
+            capabilityId: params.capabilityId,
+        });
+    }
+    const { current, pluginId } = params;
+    if (!params.enabled) {
+        const deny = [...(current.deny ?? [])];
+        if (!deny.some((id) => id.trim() === pluginId))
+            deny.push(pluginId);
+        return { ...current, deny };
+    }
+    const deny = current.deny?.filter((id) => id.trim() !== pluginId);
+    const next = { ...current, ...(deny ? { deny } : {}) };
+    if (hasAllowedPluginCapability(params))
+        return next;
+    return { ...next, allow: [...(current.allow ?? []), pluginId] };
+}
+function hasAllowedPluginCapability(params) {
+    const selection = normalizePluginSelection({
+        ...params.current,
+        enabled: true,
+        deny: [],
+    });
+    return params.capabilityIds.some((toolName) => isPluginToolSelected({ pluginId: params.pluginId, toolName, selection }));
+}
+function isRequestedSelectionTarget(params, pluginId, capabilityId) {
+    if (params.pluginId !== pluginId)
+        return false;
+    if (params.capabilityId === undefined)
+        return true;
+    return params.capabilityId === capabilityId;
+}
+function changedSelectionEntries(before, after) {
+    return ["allow", "deny"].flatMap((key) => {
+        const policy = key;
+        const removed = before[policy].filter((entry) => !after[policy].includes(entry));
+        const added = after[policy].filter((entry) => !before[policy].includes(entry));
+        return [...removed, ...added];
+    });
+}
+function selectorMatchesOtherCapability(params) {
+    return params.changedEntries.some((entry) => isPluginToolSelected({
+        pluginId: params.pluginId,
+        toolName: params.toolName,
+        selection: { enabled: true, allow: [entry], deny: [] },
+    }));
+}
+export function pluginSelectionEscapesRequestedScope(params) {
+    const before = normalizePluginSelection(params.before);
+    const after = normalizePluginSelection(params.after);
+    const changedEntries = changedSelectionEntries(before, after);
+    return params.manifests.some((plugin) => {
+        const pluginId = plugin.manifest.name;
+        const capabilityIds = Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities);
+        return capabilityIds.some((toolName) => {
+            if (isRequestedSelectionTarget(params, pluginId, toolName))
+                return false;
+            if (selectorMatchesOtherCapability({ changedEntries, pluginId, toolName })) {
+                return true;
+            }
+            return (isPluginToolSelected({ pluginId, toolName, selection: before }) !==
+                isPluginToolSelected({ pluginId, toolName, selection: after }));
+        });
+    });
+}

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

@@ -0,0 +1,29 @@
+import { type RuntimePluginSnapshot } from "./plugin-management-catalog.js";
+export type { RuntimePluginSnapshot } from "./plugin-management-catalog.js";
+export type PluginManagementOptions = {
+    rootDir: string;
+    configPath?: string;
+};
+export declare class PluginManagementError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    constructor(code: string, message: string, statusCode?: number);
+}
+export declare function getRuntimePluginSnapshot(options: PluginManagementOptions): RuntimePluginSnapshot;
+export declare function setRuntimePluginEnabled(options: PluginManagementOptions, input: unknown): Promise<{
+    backupPath?: string | undefined;
+    restartRequired: boolean;
+    selection: import("../runtime/plugins/selection.js").PluginSelection;
+    plugins: Array<{
+        id: string;
+        description?: string;
+        version?: string;
+        pluginEnabled: boolean;
+        capabilities: import("./plugin-management-catalog.js").RuntimePluginCapabilitySnapshot[];
+        capabilityCount: number;
+        selectedCapabilityCount: number;
+        state: "enabled" | "partial" | "disabled";
+        blockedByGlobalPolicy: boolean;
+    }>;
+    application: "restart_required";
+}>;