@abot-ai/runtime 1.3.1 → 1.4.0

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

@@ -0,0 +1,40 @@
+import { setupConfigMap } from "./runtime-setup-draft.js";
+function selectedEnabledEmbeddingProvider(config) {
+    const memory = setupConfigMap(config.longTermMemory);
+    if (memory.enabled !== true)
+        return undefined;
+    if (typeof memory.embeddingProfileId !== "string")
+        return undefined;
+    const models = setupConfigMap(config.models);
+    const profiles = setupConfigMap(models.embeddingProfiles);
+    const profileId = memory.embeddingProfileId.trim();
+    const provider = setupConfigMap(profiles[profileId]).provider;
+    if (typeof provider !== "string")
+        return undefined;
+    return provider.trim() || undefined;
+}
+function openAICredentialBinding(provider) {
+    if (provider.type !== "openai")
+        return undefined;
+    const configured = typeof provider.apiKeyEnv === "string" ? provider.apiKeyEnv.trim() : "";
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(configured))
+        return "OPENAI_API_KEY";
+    return configured;
+}
+/** Credentials may be shared by provider aliases; addresses belong to one provider. */
+export function shouldInvalidateSetupEmbedding(params) {
+    const selectedProviderId = selectedEnabledEmbeddingProvider(params.config);
+    if (!selectedProviderId)
+        return false;
+    if (selectedProviderId === params.providerId)
+        return params.providerChanged || params.credentialChanged;
+    if (!params.credentialChanged)
+        return false;
+    const changedBinding = openAICredentialBinding(params.provider);
+    if (!changedBinding)
+        return false;
+    const models = setupConfigMap(params.config.models);
+    const providers = setupConfigMap(models.providers);
+    const selectedProvider = setupConfigMap(providers[selectedProviderId]);
+    return openAICredentialBinding(selectedProvider) === changedBinding;
+}

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

@@ -0,0 +1 @@
+export declare function replaceRuntimeSetupEnvironmentAssignment(raw: string, key: string, value: string): string;

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

@@ -0,0 +1,27 @@
+import { parse } from "dotenv";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+function canRoundTripEnvironmentAssignment(assignment, key, value) {
+    if (/[\r\n]/u.test(value))
+        return false;
+    const parsed = parse(assignment);
+    if (Object.keys(parsed).length !== 1)
+        return false;
+    return parsed[key] === value;
+}
+function serializeEnvironmentAssignment(key, value) {
+    // Both startup readers strip these quotes. Single quotes preserve literal \n/\r.
+    for (const quote of ['"', "'"]) {
+        const assignment = `${key}=${quote}${value}${quote}`;
+        if (canRoundTripEnvironmentAssignment(assignment, key, value))
+            return assignment;
+    }
+    throw new RuntimeSetupError("unsupported_setup_environment_value", "A setup value cannot be preserved in the local environment file.", 400);
+}
+export function replaceRuntimeSetupEnvironmentAssignment(raw, key, value) {
+    const assignment = serializeEnvironmentAssignment(key, value);
+    const prefix = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`, "u");
+    const lines = raw.split(/\r?\n/u).filter((line) => !prefix.test(line));
+    while (lines.at(-1) === "")
+        lines.pop();
+    return [...lines, assignment, ""].join("\n");
+}

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

@@ -0,0 +1,19 @@
+export declare class RuntimeSetupError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    constructor(code: string, message: string, statusCode?: number);
+}
+export type RuntimeSetupInput = Readonly<{
+    provider: "openai" | "ollama";
+    model: string;
+    contextWindowTokens?: number;
+    baseUrl?: string;
+    apiKey?: string;
+    deferActivation?: boolean;
+    connectionRevision?: string;
+}>;
+export type RuntimeSetupActivation = Readonly<{
+    status: "ready" | "restart_required";
+    message?: string;
+}>;
+export declare function parseRuntimeSetupInput(body: Record<string, unknown> | null): RuntimeSetupInput;

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

@@ -0,0 +1,82 @@
+import { parseBaseUrl, parseContextWindowTokens, } from "../../../scripts/runtime-setup-files.js";
+export class RuntimeSetupError extends Error {
+    code;
+    statusCode;
+    constructor(code, message, statusCode = 400) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+    }
+}
+function readSetupString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function isUsableModelIdentifier(model) {
+    if (!model)
+        return false;
+    if (model.length > 256)
+        return false;
+    return !/[\u0000-\u0020\u007f]/u.test(model);
+}
+function isSetupConnectionRevision(value) {
+    return /^[a-f0-9-]{36}$/u.test(value);
+}
+function isSafeCredential(value) {
+    if (value.length > 4096)
+        return false;
+    return !/[\u0000-\u0020\u007f'"`]/u.test(value);
+}
+export function parseRuntimeSetupInput(body) {
+    if (body?.deferActivation !== undefined &&
+        typeof body.deferActivation !== "boolean") {
+        throw new RuntimeSetupError("invalid_setup_activation", "The deferred activation option must be true or false.");
+    }
+    const connectionRevision = readSetupString(body?.connectionRevision);
+    if (body?.connectionRevision !== undefined &&
+        !isSetupConnectionRevision(connectionRevision))
+        throw new RuntimeSetupError("invalid_setup_revision", "Refresh setup before editing the connection.");
+    let contextWindowTokens;
+    try {
+        contextWindowTokens = parseContextWindowTokens(body?.contextWindowTokens);
+    }
+    catch {
+        throw new RuntimeSetupError("invalid_context_window", "Context window must be a positive whole number of tokens.");
+    }
+    const provider = readSetupString(body?.provider);
+    if (provider !== "openai" && provider !== "ollama") {
+        throw new RuntimeSetupError("invalid_setup_provider", "Choose OpenAI or Ollama.");
+    }
+    const model = readSetupString(body?.model);
+    if (!isUsableModelIdentifier(model)) {
+        throw new RuntimeSetupError("invalid_setup_model", "Enter a model ID without spaces or control characters.");
+    }
+    const apiKey = readSetupString(body?.apiKey);
+    if (!isSafeCredential(apiKey)) {
+        throw new RuntimeSetupError("invalid_setup_credential", "The API key contains unsupported characters.");
+    }
+    if (provider === "ollama" && apiKey) {
+        throw new RuntimeSetupError("unexpected_setup_credential", "Ollama setup does not use an OpenAI API key.");
+    }
+    const requestedBaseUrl = readSetupString(body?.baseUrl);
+    if (provider === "openai" && requestedBaseUrl) {
+        throw new RuntimeSetupError("unexpected_setup_base_url", "A custom address is available for Ollama.");
+    }
+    let baseUrl;
+    if (provider === "ollama") {
+        try {
+            baseUrl = parseBaseUrl(requestedBaseUrl || "http://127.0.0.1:11434");
+        }
+        catch {
+            throw new RuntimeSetupError("invalid_setup_base_url", "Enter an HTTP or HTTPS origin without a path or credentials.");
+        }
+    }
+    return {
+        provider,
+        model,
+        ...(contextWindowTokens !== undefined ? { contextWindowTokens } : {}),
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(apiKey ? { apiKey } : {}),
+        ...(body?.deferActivation === true ? { deferActivation: true } : {}),
+        ...(connectionRevision ? { connectionRevision } : {}),
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { InspectedRuntimeConfigFile } from "../../runtime/config/loader.js";
+/** Recovery creates its own file instead of reclaiming an orphaned model. */
+export declare function planRuntimeSetupModelFile(configPath: string, recoveringDraft: boolean): Promise<{
+    path: string;
+    configRef: string;
+}>;
+export declare function runtimeSetupDraftModelPath(source: InspectedRuntimeConfigFile): Promise<string | undefined>;

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

@@ -0,0 +1,35 @@
+import { randomUUID } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { canonicalConfigFilePath } from "../../runtime/adapters/config-file-transaction.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+/** Recovery creates its own file instead of reclaiming an orphaned model. */
+export async function planRuntimeSetupModelFile(configPath, recoveringDraft) {
+    const configDirectory = dirname(configPath);
+    const configRef = "./models/default.config.json";
+    const path = resolve(configDirectory, configRef);
+    try {
+        await lstat(path);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return { path, configRef };
+        throw error;
+    }
+    if (!recoveringDraft)
+        throw new RuntimeSetupError("setup_model_file_exists", "The default model file already exists and will be preserved.", 409);
+    const recoveryRef = `./models/setup-${randomUUID()}.config.json`;
+    return { path: resolve(configDirectory, recoveryRef), configRef: recoveryRef };
+}
+export async function runtimeSetupDraftModelPath(source) {
+    const models = source.config.models;
+    if (!isRecord(models) || !isRecord(models.profiles))
+        return undefined;
+    const profile = models.profiles.default;
+    if (!isRecord(profile))
+        return undefined;
+    if (typeof profile.configRef !== "string" || !profile.configRef.trim())
+        return undefined;
+    return canonicalConfigFilePath(resolve(dirname(source.path), profile.configRef.trim()));
+}

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

@@ -0,0 +1,4 @@
+import type { InspectedRuntimeConfigFile } from "../../runtime/config/loader.js";
+import { type RuntimeSetupDraft } from "./runtime-setup-draft.js";
+/** A stale model receipt retains ownership only of unchanged providers at its canonical target. */
+export declare function recoverSetupProviderOwnership(source: InspectedRuntimeConfigFile, draft?: RuntimeSetupDraft, configPath?: string): Promise<Record<string, unknown>>;

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

@@ -0,0 +1,23 @@
+import { isDeepStrictEqual } from "node:util";
+import { canonicalConfigFilePath } from "../../runtime/adapters/config-file-transaction.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { setupConfigMap, } from "./runtime-setup-draft.js";
+function providerStillMatchesReceipt(providers, providerId, ownedProvider) {
+    if (!Object.hasOwn(providers, providerId))
+        return false;
+    if (!isRecord(ownedProvider))
+        return false;
+    return isDeepStrictEqual(providers[providerId], ownedProvider);
+}
+/** A stale model receipt retains ownership only of unchanged providers at its canonical target. */
+export async function recoverSetupProviderOwnership(source, draft, configPath = source.path) {
+    if (!draft)
+        return {};
+    if ((await canonicalConfigFilePath(source.path)) !== draft.configPath)
+        return {};
+    if ((await canonicalConfigFilePath(configPath)) !== draft.configPath)
+        return {};
+    const models = setupConfigMap(source.config.models);
+    const providers = setupConfigMap(models.providers);
+    return Object.fromEntries(Object.entries(draft.ownedProviders).filter(([providerId, provider]) => providerStillMatchesReceipt(providers, providerId, provider)));
+}

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

@@ -0,0 +1,11 @@
+/** The current draft owns the sole chat profile; embeddings may still use its old providers. */
+export declare function retainSetupConnectionProviders(params: {
+    providers: Record<string, unknown>;
+    ownedProviders: Record<string, unknown>;
+    embeddingProfiles: unknown;
+    providerId: string;
+    provider: Record<string, unknown>;
+}): {
+    providers: Record<string, unknown>;
+    ownedProviders: Record<string, unknown>;
+};

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

@@ -0,0 +1,31 @@
+import { setupConfigMap } from "./runtime-setup-draft.js";
+function embeddingReferencesProvider(embeddingProfiles, providerId) {
+    return Object.values(setupConfigMap(embeddingProfiles)).some((profile) => {
+        const provider = setupConfigMap(profile).provider;
+        return typeof provider === "string" && provider.trim() === providerId;
+    });
+}
+function canRemoveAbandonedSetupProvider(providerId, selectedProviderId, embeddingProfiles) {
+    if (providerId === selectedProviderId)
+        return false;
+    return !embeddingReferencesProvider(embeddingProfiles, providerId);
+}
+/** The current draft owns the sole chat profile; embeddings may still use its old providers. */
+export function retainSetupConnectionProviders(params) {
+    const providers = {
+        ...params.providers,
+        [params.providerId]: params.provider,
+    };
+    const ownedProviders = { ...params.ownedProviders };
+    const selectedProviderIsOwned = Object.hasOwn(ownedProviders, params.providerId);
+    const selectedProviderIsNew = !Object.hasOwn(params.providers, params.providerId);
+    if (selectedProviderIsOwned || selectedProviderIsNew)
+        ownedProviders[params.providerId] = params.provider;
+    for (const providerId of Object.keys(ownedProviders)) {
+        if (!canRemoveAbandonedSetupProvider(providerId, params.providerId, params.embeddingProfiles))
+            continue;
+        delete providers[providerId];
+        delete ownedProviders[providerId];
+    }
+    return { providers, ownedProviders };
+}

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

@@ -0,0 +1,11 @@
+import type { InspectedRuntimeConfigFile } from "../../runtime/config/loader.js";
+/** Setup inspects saved files without replacing the running owner's cached runner. */
+export declare function readConfiguredSetupRunner(source: InspectedRuntimeConfigFile): import("../../runtime/config/runner/contracts.js").RequestRunnerConfig | undefined;
+export declare function configuredSetupModel(source: InspectedRuntimeConfigFile): {
+    provider: string;
+    model: string;
+    contextWindowTokens: number | undefined;
+    apiKeyEnv: string;
+    baseUrl: string | undefined;
+} | undefined;
+export declare function requiresConfiguredCredential(source: InspectedRuntimeConfigFile, rootDir: string): boolean;

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

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { buildRuntimeModelConfiguration } from "../../runtime/config/builders.js";
+import { parseRequestRunnerConfig } from "../../runtime/config/runner/versioned-config.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { readRuntimeSetupCredential } from "./runtime-setup-credentials.js";
+function configuredSetupBaseUrl(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        if (url.username || url.password)
+            return undefined;
+        return url.origin;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Setup inspects saved files without replacing the running owner's cached runner. */
+export function readConfiguredSetupRunner(source) {
+    const ref = isRecord(source.config.requestRunner)
+        ? source.config.requestRunner.configRef
+        : undefined;
+    if (typeof ref !== "string" || !ref.trim())
+        return undefined;
+    const path = resolve(dirname(source.path), ref.trim());
+    return parseRequestRunnerConfig(JSON.parse(readFileSync(path, "utf8")), path);
+}
+export function configuredSetupModel(source) {
+    if (!source.exists)
+        return undefined;
+    const policy = buildRuntimeModelConfiguration(source.config, {
+        mainConfigPath: source.path,
+    }).modelPolicy;
+    const defaultId = readConfiguredSetupRunner(source)?.models.defaults.profileId ??
+        policy?.defaults?.profileId;
+    const profile = defaultId
+        ? policy?.profiles?.[defaultId]
+        : Object.values(policy?.profiles ?? {})[0];
+    if (!profile?.provider || !profile.model)
+        return undefined;
+    const provider = policy?.providers?.[profile.provider];
+    if (!provider)
+        return undefined;
+    const apiKeyEnv = provider.apiKeyEnv?.trim() || "OPENAI_API_KEY";
+    return {
+        provider: provider.type,
+        model: profile.model,
+        contextWindowTokens: profile.contextWindowTokens,
+        apiKeyEnv,
+        baseUrl: configuredSetupBaseUrl(provider.baseUrl),
+    };
+}
+export function requiresConfiguredCredential(source, rootDir) {
+    const model = configuredSetupModel(source);
+    if (model?.provider !== "openai")
+        return false;
+    return !readRuntimeSetupCredential(rootDir, model.apiKeyEnv);
+}

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

@@ -0,0 +1,8 @@
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+export declare class MalformedRuntimeSetupReceiptError extends RuntimeSetupError {
+    constructor();
+}
+export declare function runtimeSetupReceiptPath(configPath: string): Promise<string>;
+export declare function readRuntimeSetupReceipt(configPath: string): Promise<string | undefined>;
+/** Receipt storage compares raw bytes so a malformed sidecar can be backed up and replaced. */
+export declare function writeRuntimeSetupReceipt(configPath: string, receipt: object): Promise<void>;

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

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { dirname } from "node:path";
+import { canonicalConfigFilePath } from "../../runtime/adapters/config-file-transaction.js";
+import { withFileLock } from "../../runtime/adapters/long-term-memory/file-lock.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+export class MalformedRuntimeSetupReceiptError extends RuntimeSetupError {
+    constructor() {
+        super("setup_configuration_changed", "The unfinished setup receipt is invalid. Refresh to start setup again.", 409);
+    }
+}
+function receiptFileChanged() {
+    return new RuntimeSetupError("setup_configuration_changed", "The unfinished setup receipt changed. Refresh before saving again.", 409);
+}
+function isMissingReceipt(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function readReceiptFile(path) {
+    try {
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink())
+            throw receiptFileChanged();
+        return { raw: await readFile(path), mode: info.mode & 0o777 };
+    }
+    catch (error) {
+        if (isMissingReceipt(error))
+            return { mode: 0o600 };
+        throw error;
+    }
+}
+export async function runtimeSetupReceiptPath(configPath) {
+    const path = `${await canonicalConfigFilePath(configPath)}.web-setup.json`;
+    await readReceiptFile(path);
+    return path;
+}
+export async function readRuntimeSetupReceipt(configPath) {
+    const path = await runtimeSetupReceiptPath(configPath);
+    return (await readReceiptFile(path)).raw?.toString("utf8");
+}
+async function requireUnchangedReceipt(path, previous) {
+    const current = (await readReceiptFile(path)).raw;
+    if (current === undefined && previous === undefined)
+        return;
+    if (current === undefined)
+        throw receiptFileChanged();
+    if (previous === undefined)
+        throw receiptFileChanged();
+    if (!current.equals(previous))
+        throw receiptFileChanged();
+}
+/** Receipt storage compares raw bytes so a malformed sidecar can be backed up and replaced. */
+export async function writeRuntimeSetupReceipt(configPath, receipt) {
+    const path = await runtimeSetupReceiptPath(configPath);
+    await mkdir(dirname(path), { recursive: true });
+    await withFileLock(`${path}.config.lock`, async () => {
+        const previous = await readReceiptFile(path);
+        const token = randomUUID();
+        const temporary = `${path}.${token}.tmp`;
+        const backup = `${path}.${new Date().toISOString().replace(/[:.]/gu, "-")}.${token}.bak`;
+        try {
+            if (previous.raw !== undefined)
+                await writeFile(backup, previous.raw, {
+                    mode: previous.mode,
+                    flag: "wx",
+                });
+            await writeFile(temporary, JSON.stringify(receipt, null, 2) + "\n", {
+                mode: previous.mode,
+                flag: "wx",
+            });
+            await requireUnchangedReceipt(path, previous.raw);
+            await rename(temporary, path);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    });
+}

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

@@ -0,0 +1,35 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { RuntimeSetupService } from "./runtime-setup-service.js";
+export declare class RuntimeSetupRoutes {
+    private readonly service;
+    constructor(service: RuntimeSetupService);
+    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>;
+    handle(params: {
+        method: string;
+        route: string;
+        request: IncomingMessage;
+        response: ServerResponse;
+    }): Promise<boolean>;
+}

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

@@ -0,0 +1,56 @@
+import { assertConfigMutationRequest, ConfigMutationRequestError, } from "./config-mutation-request.js";
+import { readBody, readJsonBody, sendJson } from "./http.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+export class RuntimeSetupRoutes {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    status() {
+        return this.service.status();
+    }
+    finalize(connectionRevision) {
+        return this.service.finalize(connectionRevision);
+    }
+    async handle(params) {
+        if (params.route !== "runtime/setup")
+            return false;
+        params.response.setHeader("cache-control", "no-store");
+        try {
+            if (params.method === "GET") {
+                sendJson(params.response, 200, {
+                    ok: true,
+                    setup: await this.service.status(),
+                });
+                return true;
+            }
+            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 }));
+            sendJson(params.response, 200, {
+                ok: true,
+                ...(await this.service.save(body)),
+            });
+        }
+        catch (error) {
+            const isPublicError = error instanceof RuntimeSetupError ||
+                error instanceof ConfigMutationRequestError;
+            sendJson(params.response, isPublicError ? error.statusCode : 400, {
+                ok: false,
+                error: error instanceof RuntimeSetupError
+                    ? error.code
+                    : "runtime_setup_failed",
+                message: isPublicError
+                    ? error.message
+                    : "Setup could not be saved. Check the existing configuration and file access, then try again.",
+            });
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { type RuntimeSetupDraft } from "./runtime-setup-draft.js";
+import { type InspectedRuntimeConfigFile } from "../../runtime/config/loader.js";
+import { type RuntimeSetupInput } from "./runtime-setup-input.js";
+/** Uses the same package templates and provider/model builders as the CLI. */
+export declare function writeRuntimeSetupScaffold(params: {
+    rootDir: string;
+    configPath: string;
+    source: InspectedRuntimeConfigFile;
+    input: RuntimeSetupInput;
+    recoveringDraft?: boolean;
+    recoveryDraft?: RuntimeSetupDraft;
+    credentialChanged?: boolean;
+    commitWithCredentials?: (commit: () => Promise<RuntimeSetupDraft>) => Promise<RuntimeSetupDraft>;
+}): Promise<{
+    draft: RuntimeSetupDraft;
+    embeddingInvalidated: boolean;
+}>;