@abot-ai/runtime 1.3.1 → 1.4.0

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

@@ -0,0 +1,229 @@
+import { createRuntimeSetupDraft, } from "./runtime-setup-draft.js";
+import { withConfigFileTransaction, readConfigFileSnapshot, } from "../../runtime/adapters/config-file-transaction.js";
+import { validateRuntimeSetupPlan } from "./runtime-setup-validation.js";
+import { planRuntimeSetupModelFile } from "./runtime-setup-model-file.js";
+import { recoverSetupProviderOwnership } from "./runtime-setup-provider-ownership-recovery.js";
+import { retainSetupConnectionProviders } from "./runtime-setup-provider-retention.js";
+import { shouldInvalidateSetupEmbedding } from "./runtime-setup-embedding-invalidation.js";
+import { constants } from "node:fs";
+import { access, copyFile, lstat, mkdir, readFile, rm } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { buildModelConfig, buildProviderConfig, DEFAULT_ROOT_RESPONSE_METHODOLOGY_FILES, isRecord, readJsonObject, resolveRuntimePackageRoot, writeJsonObject, } from "../../../scripts/runtime-setup-files.js";
+import { inspectRuntimeConfigFileWithMeta, } from "../../runtime/config/loader.js";
+import { parseRequestRunnerConfig } from "../../runtime/config/runner/versioned-config.js";
+import { RuntimeSetupError, } from "./runtime-setup-input.js";
+async function removeUnchangedSetupFile(file) {
+    try {
+        const info = await lstat(file.path);
+        if (!info.isFile() || info.isSymbolicLink())
+            return;
+        if ((await readFile(file.path, "utf8")) !== file.expectedContent)
+            return;
+        await rm(file.path, { force: true });
+    }
+    catch {
+        // A changed or inaccessible file belongs to its current owner and is retained.
+    }
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function configMap(value) {
+    return isRecord(value) ? value : {};
+}
+function requireEmptyModelProfiles(source) {
+    const models = configMap(source.config.models);
+    const profiles = configMap(models.profiles);
+    if (Object.keys(profiles).length > 0) {
+        throw new RuntimeSetupError("setup_configuration_exists", "Model profiles already exist. Use configuration settings to change them.", 409);
+    }
+}
+function requireCompatibleProvider(existing, requested, owned) {
+    if (existing === undefined)
+        return;
+    if (owned)
+        return;
+    if (!isDeepStrictEqual(existing, requested)) {
+        throw new RuntimeSetupError("setup_provider_conflict", "This provider already has settings. Preserve or edit them in configuration settings.", 409);
+    }
+}
+async function planRunnerFile(path, template) {
+    if (!(await pathExists(path)))
+        return [{ path, value: template }];
+    const runner = parseRequestRunnerConfig(await readJsonObject(path), path);
+    if (runner.models.defaults.profileId !== "default") {
+        throw new RuntimeSetupError("setup_runner_conflict", "The existing request runner selects another model. Preserve or edit it in configuration settings.", 409);
+    }
+    return [];
+}
+function rebaseRunnerInstructions(runner, target) {
+    const steps = configMap(runner.steps);
+    return {
+        ...runner,
+        steps: Object.fromEntries(Object.entries(steps).map(([id, value]) => {
+            const step = configMap(value);
+            if (!Array.isArray(step.instructionRefs))
+                return [id, value];
+            const refs = step.instructionRefs.map((ref) => target(ref.replace(/^\.\.\//u, "")));
+            return [id, { ...step, instructionRefs: refs }];
+        })),
+    };
+}
+async function restoreSetupScaffoldConfig(transaction, source, candidate) {
+    if (source.exists) {
+        await transaction.write(source.config, { expectedConfig: candidate });
+        return;
+    }
+    const current = await readConfigFileSnapshot(transaction.path);
+    if (current.revision !== transaction.snapshot.revision)
+        throw new RuntimeSetupError("setup_configuration_changed", "Configuration changed while setup was being saved.", 409);
+    await rm(transaction.path, { force: true });
+}
+/** Uses the same package templates and provider/model builders as the CLI. */
+export async function writeRuntimeSetupScaffold(params) {
+    return withConfigFileTransaction(params.configPath, (transaction) => saveRuntimeSetupScaffold(params, transaction));
+}
+async function saveRuntimeSetupScaffold(params, transaction) {
+    requireEmptyModelProfiles(params.source);
+    const templateRoot = resolveRuntimePackageRoot(import.meta.dirname);
+    const [runtimeTemplate, modelTemplate, runnerTemplate] = await Promise.all([
+        readJsonObject(join(templateRoot, "examples/runtime.config.example.json")),
+        readJsonObject(join(templateRoot, "examples/models/default.config.json")),
+        readJsonObject(join(templateRoot, "examples/request-runner.config.example.json")),
+    ]);
+    const configDirectory = dirname(params.configPath);
+    const models = configMap(params.source.config.models);
+    const providers = configMap(models.providers);
+    const provider = buildProviderConfig(params.input.provider, params.input.baseUrl);
+    const ownedProviders = await recoverSetupProviderOwnership(params.source, params.recoveringDraft ? params.recoveryDraft : undefined, transaction.path);
+    const existingProvider = providers[params.input.provider];
+    requireCompatibleProvider(existingProvider, provider, Object.hasOwn(ownedProviders, params.input.provider));
+    const retained = retainSetupConnectionProviders({
+        providers,
+        ownedProviders,
+        embeddingProfiles: models.embeddingProfiles,
+        providerId: params.input.provider,
+        provider,
+    });
+    const embeddingInvalidated = shouldInvalidateSetupEmbedding({
+        config: params.source.config,
+        providerId: params.input.provider,
+        provider,
+        providerChanged: !isDeepStrictEqual(existingProvider, provider),
+        credentialChanged: params.credentialChanged === true,
+    });
+    const memory = configMap(params.source.config.longTermMemory);
+    const runnerSettings = configMap(params.source.config.requestRunner);
+    const runnerRef = typeof runnerSettings.configRef === "string" &&
+        runnerSettings.configRef.trim()
+        ? runnerSettings.configRef
+        : "./request-runner.config.json";
+    const runnerPath = resolve(configDirectory, runnerRef);
+    const modelFile = await planRuntimeSetupModelFile(params.configPath, params.recoveringDraft === true);
+    const runnerModels = configMap(runnerTemplate.models);
+    runnerTemplate.models = {
+        ...runnerModels,
+        defaults: { ...configMap(runnerModels.defaults), profileId: "default" },
+    };
+    const modelConfig = buildModelConfig(modelTemplate, params.input.provider, params.input.model, params.input.contextWindowTokens);
+    const rebasedRunner = rebaseRunnerInstructions(runnerTemplate, (file) => relative(dirname(runnerPath), join(params.rootDir, file)));
+    const runnerFiles = await planRunnerFile(runnerPath, rebasedRunner);
+    const plannedFiles = [
+        { path: modelFile.path, value: modelConfig },
+        ...runnerFiles,
+    ];
+    const runtimeConfig = {
+        ...runtimeTemplate,
+        ...params.source.config,
+        models: {
+            ...models,
+            providers: retained.providers,
+            profiles: { default: { configRef: modelFile.configRef } },
+        },
+        requestRunner: { ...runnerSettings, configRef: runnerRef },
+        ...(embeddingInvalidated
+            ? { longTermMemory: { ...memory, enabled: false } }
+            : {}),
+    };
+    const instructionSources = new Map();
+    for (const file of DEFAULT_ROOT_RESPONSE_METHODOLOGY_FILES) {
+        const existing = join(params.rootDir, file);
+        instructionSources.set(file, (await pathExists(existing)) ? existing : join(templateRoot, file));
+    }
+    await validateRuntimeSetupPlan({
+        rootDir: params.rootDir,
+        config: runtimeConfig,
+        modelConfig,
+        runnerPath,
+        ...(runnerFiles.length
+            ? {
+                runnerConfig: rebaseRunnerInstructions(runnerTemplate, (file) => join(templateRoot, file)),
+            }
+            : {}),
+    });
+    const current = inspectRuntimeConfigFileWithMeta(params.rootDir, params.source.path);
+    if (!isDeepStrictEqual(current, params.source)) {
+        throw new RuntimeSetupError("setup_configuration_changed", "Configuration changed while setup was being saved. Refresh and try again.", 409);
+    }
+    const created = [];
+    let configWritten = false;
+    try {
+        for (const file of plannedFiles) {
+            await mkdir(dirname(file.path), { recursive: true });
+            await writeJsonObject(file.path, file.value, { exclusive: true });
+            created.push({
+                path: file.path,
+                expectedContent: JSON.stringify(file.value, null, 2) + "\n",
+            });
+        }
+        for (const file of DEFAULT_ROOT_RESPONSE_METHODOLOGY_FILES) {
+            const destination = join(params.rootDir, file);
+            if (await pathExists(destination))
+                continue;
+            await mkdir(dirname(destination), { recursive: true });
+            const expectedContent = await readFile(join(templateRoot, file), "utf8");
+            await copyFile(join(templateRoot, file), destination, constants.COPYFILE_EXCL);
+            created.push({ path: destination, expectedContent });
+        }
+        await mkdir(configDirectory, { recursive: true });
+        const beforeCommit = inspectRuntimeConfigFileWithMeta(params.rootDir, params.source.path);
+        if (!isDeepStrictEqual(beforeCommit, params.source)) {
+            throw new RuntimeSetupError("setup_configuration_changed", "Configuration changed while setup was being saved. Refresh and try again.", 409);
+        }
+        const commit = async () => {
+            await transaction.write(runtimeConfig, {
+                expectedConfig: params.source.config,
+            });
+            configWritten = true;
+            return createRuntimeSetupDraft({ config: runtimeConfig, path: params.configPath, exists: true }, providers, params.input.provider, modelConfig, retained.ownedProviders);
+        };
+        const commitWithCredentials = params.commitWithCredentials ??
+            ((operation) => operation());
+        const draft = await commitWithCredentials(commit);
+        return { draft, embeddingInvalidated };
+    }
+    catch (error) {
+        await rollbackScaffoldAfterFailure(error, configWritten, transaction, params.source, runtimeConfig);
+        await Promise.all(created.map(removeUnchangedSetupFile));
+        throw error;
+    }
+}
+async function rollbackScaffoldAfterFailure(error, configWritten, transaction, source, runtimeConfig) {
+    if (!configWritten)
+        return;
+    try {
+        await restoreSetupScaffoldConfig(transaction, source, runtimeConfig);
+    }
+    catch (rollbackError) {
+        throw new AggregateError([error, rollbackError], "Setup failed and its configuration could not be restored.");
+    }
+}

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

@@ -0,0 +1,65 @@
+import { type RuntimeSetupActivation } from "./runtime-setup-input.js";
+export type RuntimeSetupServiceOptions = {
+    rootDir: string;
+    getConfigPath: () => string | undefined;
+    activate: (configPath: string) => Promise<RuntimeSetupActivation>;
+    configure?: (configPath: string) => void;
+};
+export declare class RuntimeSetupService {
+    private readonly options;
+    private savedConfigPath;
+    constructor(options: RuntimeSetupServiceOptions);
+    private source;
+    status(): Promise<{
+        providers: {
+            id: string;
+            label: string;
+            requiresApiKey: boolean;
+            credentialConfigured: boolean;
+        }[];
+        existingModel?: {
+            baseUrl?: string | undefined;
+            provider: string;
+            model: string;
+            contextWindowTokens: number | undefined;
+        } | undefined;
+        defaultContextWindowTokens: number;
+        editableConnection?: {
+            revision: string;
+        } | undefined;
+        recovery?: "configuration" | undefined;
+        message?: string | undefined;
+        status: "required" | "ready";
+        configExists: boolean;
+    }>;
+    finalize(connectionRevision?: string): Promise<boolean>;
+    save(body: Record<string, unknown> | null): Promise<{
+        setup: {
+            providers: {
+                id: string;
+                label: string;
+                requiresApiKey: boolean;
+                credentialConfigured: boolean;
+            }[];
+            existingModel?: {
+                baseUrl?: string | undefined;
+                provider: string;
+                model: string;
+                contextWindowTokens: number | undefined;
+            } | undefined;
+            defaultContextWindowTokens: number;
+            editableConnection?: {
+                revision: string;
+            } | undefined;
+            recovery?: "configuration" | undefined;
+            message?: string | undefined;
+            status: "required" | "ready";
+            configExists: boolean;
+        };
+        activation: Readonly<{
+            status: "ready" | "restart_required";
+            message?: string;
+        }>;
+        embeddingInvalidated: boolean;
+    }>;
+}

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

@@ -0,0 +1,195 @@
+import { readDefaultContextWindowTokens } from "../../../scripts/runtime-setup-files.js";
+import { initializeConfiguredRuntimeDirectories } from "../../../scripts/runtime-setup-directories.js";
+import { configuredSetupModel, requiresConfiguredCredential, } from "./runtime-setup-provider.js";
+import { editRuntimeSetupConnection } from "./runtime-setup-connection-edit.js";
+import { inspectEditableRuntimeSetupDraft, isCurrentRuntimeSetupDraft, readRuntimeSetupDraft, removeRuntimeSetupDraft, setupConfigurationChanged, setupConfigMap, } from "./runtime-setup-draft.js";
+import { mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { inspectRuntimeConfigFileWithMeta } from "../../runtime/config/loader.js";
+import { withFileLock } from "../../runtime/adapters/long-term-memory/file-lock.js";
+import { inspectRuntimeSetupRequirement } from "./runtime-availability.js";
+import { assertRuntimeSetupCredentialFile, hasRuntimeSetupCredential, readRuntimeSetupCredential, persistRuntimeSetupCredentials, commitRuntimeSetupCredentials, } from "./runtime-setup-credentials.js";
+import { RuntimeSetupError, parseRuntimeSetupInput, } from "./runtime-setup-input.js";
+import { writeRuntimeSetupScaffold } from "./runtime-setup-scaffold.js";
+import { inspectRuntimeSetupDraftForSave } from "./runtime-setup-draft-recovery.js";
+import { canCompleteMissingRuntimeSetupCredential } from "./runtime-setup-credential-completion.js";
+export class RuntimeSetupService {
+    options;
+    savedConfigPath;
+    constructor(options) {
+        this.options = options;
+    }
+    source() {
+        return inspectRuntimeConfigFileWithMeta(this.options.rootDir, this.savedConfigPath ?? this.options.getConfigPath());
+    }
+    async status() {
+        const source = this.source();
+        const configRequirement = inspectRuntimeSetupRequirement(source);
+        const existingModel = configRequirement
+            ? undefined
+            : configuredSetupModel(source);
+        const draft = await inspectEditableRuntimeSetupDraft(source);
+        const editable = draft !== undefined;
+        const required = configRequirement ||
+            requiresConfiguredCredential(source, this.options.rootDir);
+        return {
+            status: required ? "required" : "ready",
+            configExists: source.exists,
+            ...(configRequirement?.recovery
+                ? {
+                    recovery: configRequirement.recovery,
+                    message: configRequirement.message,
+                }
+                : {}),
+            ...(editable ? { editableConnection: { revision: draft.revision } } : {}),
+            defaultContextWindowTokens: await readDefaultContextWindowTokens(),
+            ...(existingModel
+                ? {
+                    existingModel: {
+                        provider: existingModel.provider,
+                        model: existingModel.model,
+                        contextWindowTokens: existingModel.contextWindowTokens,
+                        ...(existingModel.baseUrl
+                            ? { baseUrl: existingModel.baseUrl }
+                            : {}),
+                    },
+                }
+                : {}),
+            providers: [
+                {
+                    id: "ollama",
+                    label: "Ollama",
+                    requiresApiKey: false,
+                    credentialConfigured: false,
+                },
+                {
+                    id: "openai",
+                    label: "OpenAI",
+                    requiresApiKey: true,
+                    credentialConfigured: await hasRuntimeSetupCredential(this.options.rootDir, existingModel?.apiKeyEnv),
+                },
+            ],
+        };
+    }
+    async finalize(connectionRevision) {
+        return withFileLock(join(this.options.rootDir, ".runtime-setup.lock"), async () => {
+            const source = this.source();
+            const draft = await readRuntimeSetupDraft(source.path);
+            if (!draft)
+                return connectionRevision === undefined;
+            if (draft.revision !== connectionRevision)
+                return false;
+            if (!(await isCurrentRuntimeSetupDraft(source, draft)))
+                return false;
+            await removeRuntimeSetupDraft(source.path);
+            return true;
+        });
+    }
+    async save(body) {
+        const input = parseRuntimeSetupInput(body);
+        await mkdir(this.options.rootDir, { recursive: true });
+        return withFileLock(join(this.options.rootDir, ".runtime-setup.lock"), async () => {
+            await assertRuntimeSetupCredentialFile(this.options.rootDir);
+            const source = this.source();
+            const requirement = inspectRuntimeSetupRequirement(source);
+            if (requirement?.recovery === "configuration")
+                throw new RuntimeSetupError("setup_configuration_exists", "Existing model profiles need repair in Configuration before setup can continue.", 409);
+            const existingModel = requirement
+                ? undefined
+                : configuredSetupModel(source);
+            const recovery = await inspectRuntimeSetupDraftForSave(source);
+            let draft = recovery.draft;
+            const editingDraft = input.connectionRevision !== undefined;
+            if (editingDraft) {
+                if (!draft || draft.revision !== input.connectionRevision)
+                    throw setupConfigurationChanged();
+                if (!(await isCurrentRuntimeSetupDraft(source, draft)))
+                    throw setupConfigurationChanged();
+            }
+            const canCompleteCredential = !editingDraft &&
+                canCompleteMissingRuntimeSetupCredential(existingModel, input, this.options.rootDir);
+            if (draft && !editingDraft && !canCompleteCredential)
+                throw setupConfigurationChanged();
+            if (existingModel && !editingDraft && !canCompleteCredential) {
+                throw new RuntimeSetupError("setup_configuration_exists", "Model settings already exist. Complete the configured model or use configuration settings.", 409);
+            }
+            const requestedProviders = setupConfigMap(setupConfigMap(source.config.models).providers);
+            const requestedProvider = setupConfigMap(requestedProviders[input.provider]);
+            let apiKeyEnv = existingModel?.apiKeyEnv;
+            if (editingDraft)
+                apiKeyEnv =
+                    typeof requestedProvider.apiKeyEnv === "string"
+                        ? requestedProvider.apiKeyEnv
+                        : undefined;
+            const hasCredential = input.apiKey ||
+                (await hasRuntimeSetupCredential(this.options.rootDir, apiKeyEnv));
+            if (input.provider === "openai" && !hasCredential) {
+                throw new RuntimeSetupError("setup_credential_required", "Enter your OpenAI API key to finish setup.");
+            }
+            const configuredPath = this.options.getConfigPath();
+            const shouldUseLocalConfig = !source.exists && !configuredPath;
+            const configPath = shouldUseLocalConfig
+                ? join(this.options.rootDir, "local/runtime.config.json")
+                : source.path;
+            this.options.configure?.(configPath);
+            let embeddingInvalidated = false;
+            const credentialChanged = Boolean(input.apiKey &&
+                input.apiKey !==
+                    readRuntimeSetupCredential(this.options.rootDir, apiKeyEnv));
+            const credentialWrite = {
+                rootDir: this.options.rootDir,
+                configPath: resolve(configPath),
+                apiKey: input.apiKey,
+                apiKeyEnv,
+                preserveExistingCredential: canCompleteCredential,
+            };
+            let credentialsPersisted = false;
+            const commitScaffoldCredentials = async (commit) => {
+                const saved = await commitRuntimeSetupCredentials(credentialWrite, commit);
+                credentialsPersisted = true;
+                return saved;
+            };
+            if (draft && editingDraft) {
+                const edited = await editRuntimeSetupConnection({
+                    rootDir: this.options.rootDir,
+                    configPath,
+                    draft,
+                    input,
+                    credentialChanged,
+                });
+                draft = edited.draft;
+                embeddingInvalidated = edited.embeddingInvalidated;
+            }
+            if (!draft && !canCompleteCredential) {
+                const needsAtomicRecoveryCredentialCommit = recovery.recoveringDraft && credentialChanged;
+                const saved = await writeRuntimeSetupScaffold({
+                    rootDir: this.options.rootDir,
+                    configPath,
+                    source,
+                    input,
+                    recoveringDraft: recovery.recoveringDraft,
+                    recoveryDraft: recovery.recoveryDraft,
+                    credentialChanged,
+                    ...(needsAtomicRecoveryCredentialCommit
+                        ? { commitWithCredentials: commitScaffoldCredentials }
+                        : {}),
+                });
+                draft = saved.draft;
+                embeddingInvalidated = saved.embeddingInvalidated;
+            }
+            this.savedConfigPath = configPath;
+            if (!credentialsPersisted)
+                await persistRuntimeSetupCredentials(credentialWrite);
+            await initializeConfiguredRuntimeDirectories(this.options.rootDir, configPath);
+            const activation = input.deferActivation
+                ? {
+                    status: "restart_required",
+                    message: "Connection saved. Continue setup before applying the configuration.",
+                }
+                : await this.options.activate(configPath);
+            if (activation.status === "ready" && draft)
+                await removeRuntimeSetupDraft(configPath);
+            return { setup: await this.status(), activation, embeddingInvalidated };
+        });
+    }
+}

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

@@ -0,0 +1,8 @@
+/** Validate complete effective configuration in isolation before replacing local files. */
+export declare function validateRuntimeSetupPlan(params: {
+    rootDir: string;
+    config: Record<string, unknown>;
+    modelConfig: Record<string, unknown>;
+    runnerPath: string;
+    runnerConfig?: Record<string, unknown>;
+}): Promise<void>;

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

@@ -0,0 +1,35 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { loadRuntimeConfig } from "../../runtime/config.js";
+import { isRecord } from "../../runtime/config/utils.js";
+/** Validate complete effective configuration in isolation before replacing local files. */
+export async function validateRuntimeSetupPlan(params) {
+    const staging = await mkdtemp(join(params.rootDir, ".runtime-setup-validation-"));
+    try {
+        const runnerPath = params.runnerConfig
+            ? join(staging, "runner.json")
+            : params.runnerPath;
+        if (params.runnerConfig)
+            await writeFile(runnerPath, JSON.stringify(params.runnerConfig));
+        const models = isRecord(params.config.models) ? params.config.models : {};
+        const stagedConfig = {
+            ...params.config,
+            models: { ...models, profiles: { default: params.modelConfig } },
+            requestRunner: { configRef: runnerPath },
+        };
+        const configPath = join(staging, "runtime.config.json");
+        await writeFile(configPath, JSON.stringify(stagedConfig));
+        const environment = isRecord(params.config.environment)
+            ? params.config.environment
+            : {};
+        const profileIds = isRecord(environment.profiles)
+            ? Object.keys(environment.profiles)
+            : [];
+        const environments = profileIds.length ? profileIds : [undefined];
+        for (const profileId of environments)
+            loadRuntimeConfig({ rootDir: params.rootDir, configPath, profileId });
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}

package/dist/src/web-ui/local-runtime/saved-model-catalog.d.ts

@@ -0,0 +1,3 @@
+import type { InspectedRuntimeConfigFile } from "../../runtime/config/loader.js";
+/** An environment without an active owner previews saved files without changing owner caches. */
+export declare function readSavedModelCatalog(source: InspectedRuntimeConfigFile, environmentId: string): import("../../runtime/model/model-catalog.js").RuntimeModelCatalog;

package/dist/src/web-ui/local-runtime/saved-model-catalog.js

@@ -0,0 +1,20 @@
+import { buildRuntimeModelConfiguration } from "../../runtime/config/builders.js";
+import { resolveRuntimeEnvironmentProfileSelection } from "../../runtime/config/environment.js";
+import { createRequestModelPolicy } from "../../runtime/config/runner/model-policy.js";
+import { projectRuntimeModelCatalog } from "../../runtime/model/model-catalog.js";
+import { readConfiguredSetupRunner } from "./runtime-setup-provider.js";
+/** An environment without an active owner previews saved files without changing owner caches. */
+export function readSavedModelCatalog(source, environmentId) {
+    resolveRuntimeEnvironmentProfileSelection({
+        config: source.config,
+        profileId: environmentId,
+        env: process.env,
+    });
+    const platformPolicy = buildRuntimeModelConfiguration(source.config, {
+        mainConfigPath: source.path,
+    }).modelPolicy;
+    const runnerConfig = readConfiguredSetupRunner(source);
+    if (!runnerConfig)
+        throw new Error("requestRunner.configRef is required");
+    return projectRuntimeModelCatalog(createRequestModelPolicy({ platformPolicy, runnerConfig }));
+}

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

@@ -0,0 +1,8 @@
+export type SetupEmbeddingInput = Readonly<{
+    providerId?: string;
+    provider?: "openai" | "ollama";
+    model: string;
+    baseUrl?: string;
+    apiKey?: string;
+}>;
+export declare function parseSetupEmbeddingInput(body: Record<string, unknown>): SetupEmbeddingInput;

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

@@ -0,0 +1,71 @@
+import { parseBaseUrl } from "../../../scripts/runtime-setup-files.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+function optionalInputString(body, name) {
+    const value = body[name];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !value.trim()) {
+        throw new RuntimeSetupError("invalid_embedding_input", `The ${name} field must be a non-empty string.`);
+    }
+    return value.trim();
+}
+function hasOneProviderSelection(providerId, provider) {
+    if (providerId)
+        return provider === undefined;
+    return provider !== undefined;
+}
+function isSupportedProvider(provider) {
+    return provider === "openai" || provider === "ollama";
+}
+function isUsableModelIdentifier(model) {
+    if (!model || model.length > 256)
+        return false;
+    return !/[\u0000-\u0020\u007f]/u.test(model);
+}
+function isSafeCredential(apiKey) {
+    if (!apiKey)
+        return true;
+    if (apiKey.length > 4096)
+        return false;
+    return !/[\u0000-\u0020\u007f'"`]/u.test(apiKey);
+}
+export function parseSetupEmbeddingInput(body) {
+    const allowed = ["providerId", "provider", "model", "baseUrl", "apiKey"];
+    if (Object.keys(body).some((key) => !allowed.includes(key))) {
+        throw new RuntimeSetupError("invalid_embedding_input", "The embedding update contains unsupported fields.");
+    }
+    const providerId = optionalInputString(body, "providerId");
+    const provider = optionalInputString(body, "provider");
+    if (!hasOneProviderSelection(providerId, provider)) {
+        throw new RuntimeSetupError("invalid_embedding_provider", "Choose one configured provider or one provider type.");
+    }
+    if (provider && !isSupportedProvider(provider)) {
+        throw new RuntimeSetupError("invalid_embedding_provider", "Choose OpenAI or Ollama when adding a provider.");
+    }
+    const model = optionalInputString(body, "model");
+    if (!isUsableModelIdentifier(model)) {
+        throw new RuntimeSetupError("invalid_embedding_model", "Enter a model ID without spaces or control characters.");
+    }
+    const apiKey = optionalInputString(body, "apiKey");
+    if (!isSafeCredential(apiKey)) {
+        throw new RuntimeSetupError("invalid_embedding_credential", "The API key contains unsupported characters.");
+    }
+    const address = optionalInputString(body, "baseUrl");
+    if (address && provider !== "ollama") {
+        throw new RuntimeSetupError("invalid_embedding_address", "An address can be supplied when adding an Ollama provider.");
+    }
+    let baseUrl;
+    try {
+        baseUrl = address ? parseBaseUrl(address) : undefined;
+    }
+    catch {
+        throw new RuntimeSetupError("invalid_embedding_address", "Enter an HTTP or HTTPS origin without a path or credentials.");
+    }
+    return {
+        ...(providerId ? { providerId } : {}),
+        ...(provider ? { provider: provider } : {}),
+        model,
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(apiKey ? { apiKey } : {}),
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { SetupEmbeddingInput } from "./setup-embedding-input.js";
+export type SavedEmbeddingProvider = Readonly<{
+    id: string;
+    type: string;
+}>;
+/** Adds only the requested provider; chat profiles and existing provider settings stay intact. */
+export declare function prepareSetupEmbeddingProvider(options: {
+    rootDir: string;
+    configPath?: string;
+}, input: SetupEmbeddingInput): Promise<{
+    providerId: string;
+    savedProvider: SavedEmbeddingProvider;
+}>;