@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/web-ui/local-runtime/conversation-file-target.js

@@ -0,0 +1,158 @@
+import { constants, fstatSync, lstatSync, realpathSync, statSync, } from "node:fs";
+import { open, realpath, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { createRuntimeToolPathResolver } from "../../runtime/capabilities/runtime-target-path.js";
+import { readFileOutputRootId } from "../../runtime/capabilities/file-output-root-identity.js";
+import { ConversationFileError } from "./conversation-file-format.js";
+function unavailable() {
+    throw new ConversationFileError("conversation_file_unavailable", 404, "This file is no longer available in its original location.");
+}
+function changedRoot() {
+    throw new ConversationFileError("conversation_file_root_changed", 409, "The configured location changed. This earlier file cannot be opened here.");
+}
+function changedFile() {
+    throw new ConversationFileError("conversation_file_changed", 409, "The file changed while it was being read. Open it again to see the current content.");
+}
+async function assertRecordedRootIdentity(receipt, canonicalRoot) {
+    let currentRootId;
+    try {
+        currentRootId = readFileOutputRootId(receipt.location, canonicalRoot);
+    }
+    catch {
+        return changedRoot();
+    }
+    if (currentRootId !== receipt.rootId)
+        changedRoot();
+}
+async function resolveRecordedFile(receipt, paths) {
+    const resolver = createRuntimeToolPathResolver(paths);
+    const options = { allowedLocations: [receipt.location], requirePath: true };
+    let root;
+    try {
+        root = resolver.resolve(receipt.location === "workspace" ? "workspace" : ".", options);
+    }
+    catch {
+        return changedRoot();
+    }
+    await assertRecordedRootIdentity(receipt, root.rootPath);
+    let target;
+    try {
+        target = resolver.resolve(resolve(root.rootPath, receipt.relativePath), options);
+    }
+    catch {
+        return unavailable();
+    }
+    if (target.location !== receipt.location)
+        unavailable();
+    if (target.relativePath !== receipt.relativePath)
+        unavailable();
+    if (target.logicalPath !== receipt.logicalPath)
+        unavailable();
+    if (target.rootPath !== root.rootPath)
+        changedRoot();
+    return target;
+}
+function isContainedFile(root, path) {
+    const value = relative(root, path);
+    if (!value || isAbsolute(value))
+        return false;
+    if (value === "..")
+        return false;
+    return !value.startsWith(".." + sep);
+}
+function sameFileIdentity(left, right) {
+    if (left.dev !== right.dev)
+        return false;
+    return left.ino === right.ino;
+}
+function sameFileVersion(left, right) {
+    if (!sameFileIdentity(left, right))
+        return false;
+    if (left.size !== right.size)
+        return false;
+    if (left.mtimeNs !== right.mtimeNs)
+        return false;
+    return left.ctimeNs === right.ctimeNs;
+}
+async function assertOpenedFileAuthority(target, opened, receipt) {
+    const root = await realpath(target.rootPath);
+    await assertRecordedRootIdentity(receipt, root);
+    const canonicalPath = await realpath(target.absolutePath);
+    if (!isContainedFile(root, canonicalPath))
+        unavailable();
+    const current = await stat(canonicalPath, { bigint: true });
+    if (!current.isFile())
+        unavailable();
+    if (!sameFileIdentity(opened, current))
+        changedFile();
+}
+/** Keeps the recorded file descriptor alive for the complete caller operation. */
+export async function withConversationFileTarget(receipt, paths, action) {
+    let handle;
+    try {
+        const target = await resolveRecordedFile(receipt, paths);
+        if (typeof constants.O_NOFOLLOW !== "number")
+            throw new ConversationFileError("conversation_file_platform_unsupported", 415, "This platform cannot safely open a file preview.");
+        handle = await open(target.absolutePath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        const openedHandle = handle;
+        const before = await handle.stat({ bigint: true });
+        if (!before.isFile())
+            unavailable();
+        if (before.size > BigInt(Number.MAX_SAFE_INTEGER))
+            unavailable();
+        await assertOpenedFileAuthority(target, before, receipt);
+        return await action({
+            target,
+            handle,
+            stats: before,
+            assertCurrent: async () => {
+                const after = await openedHandle.stat({ bigint: true });
+                if (!sameFileVersion(before, after))
+                    changedFile();
+                const currentTarget = await resolveRecordedFile(receipt, paths);
+                if (currentTarget.absolutePath !== target.absolutePath)
+                    unavailable();
+                await assertOpenedFileAuthority(target, after, receipt);
+            },
+            assertCurrentForNativeOpen: () => {
+                assertNativeFileDispatchAuthority(target, openedHandle.fd, before, receipt, paths);
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof ConversationFileError)
+            throw error;
+        return unavailable();
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+/** No await is allowed between this pathname check and native command dispatch. */
+function assertNativeFileDispatchAuthority(target, fd, before, receipt, paths) {
+    const resolver = createRuntimeToolPathResolver(paths);
+    const current = resolver.resolve(target.absolutePath, {
+        allowedLocations: [receipt.location],
+        requirePath: true,
+    });
+    if (current.rootPath !== target.rootPath)
+        changedRoot();
+    if (current.relativePath !== receipt.relativePath)
+        unavailable();
+    const root = realpathSync(current.rootPath);
+    if (readFileOutputRootId(receipt.location, root) !== receipt.rootId)
+        changedRoot();
+    const canonicalPath = realpathSync(current.absolutePath);
+    if (!isContainedFile(root, canonicalPath))
+        unavailable();
+    const opened = fstatSync(fd, { bigint: true });
+    if (!sameFileVersion(before, opened))
+        changedFile();
+    if (!lstatSync(current.absolutePath).isFile())
+        unavailable();
+    const currentFile = statSync(canonicalPath, { bigint: true });
+    if (!currentFile.isFile())
+        unavailable();
+    if (!sameFileVersion(opened, currentFile))
+        changedFile();
+}

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

@@ -1,3 +1,5 @@
+import type { WebUiEnvironmentConfig } from "../environment-config.js";
+import type { RuntimeSetupActivation } from "./runtime-setup-input.js";
 import { type LocalRuntimeApplicationOptions } from "../../runtime/local-application.js";
 import type { LocalRuntimeBackendOptions, RuntimeEnvironment, RuntimeModelCatalogState, RuntimeSetupRequirement } from "./contracts.js";
 export declare class RuntimeEnvironmentRegistry {
@@ -5,17 +7,29 @@ export declare class RuntimeEnvironmentRegistry {
     private readonly schedulerBindings;
     private readonly environments;
     private stopped;
+    private readonly desiredEnvironmentIds;
+    private applying;
+    private setupActivationPending;
     private stopping;
+    private configuredEnvironments;
     constructor(options: LocalRuntimeBackendOptions, schedulerBindings?: {
         requestOptions?: LocalRuntimeApplicationOptions["scheduledRequestOptions"];
         publish?: (event: Record<string, unknown>) => void;
     });
+    environmentConfig(): WebUiEnvironmentConfig | undefined;
+    applyConfiguration(): Promise<RuntimeSetupActivation>;
+    private applySavedConfiguration;
+    private checkGatewayActivation;
+    configure(configPath: string): void;
     modelCatalog(environmentId: string): RuntimeModelCatalogState;
     setupRequirement(environmentId: string): RuntimeSetupRequirement | null;
     get(environmentId: string): RuntimeEnvironment;
+    private createEnvironment;
     start(environmentIds: readonly string[]): Promise<void>;
     private startEnvironment;
     stop(): Promise<void>;
+    private stopAfterConfigurationApplication;
+    private hasStartedEnvironment;
     private requireEnvironmentIntakeOpen;
     profileEnv(environmentId: string): Record<string, string | undefined>;
     private loadConfig;

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

@@ -1,25 +1,121 @@
+import { requiresConfiguredCredential } from "./runtime-setup-provider.js";
+import { applyRuntimeConfiguration } from "./configuration-activation.js";
+import { withConfigurationActivationSource, } from "./configuration-activation-source.js";
 import { createLocalRuntimeApplication, } from "../../runtime/local-application.js";
 import { loadRuntimeConfig } from "../../runtime/config.js";
 import { inspectRuntimeConfigFileWithMeta } from "../../runtime/config/loader.js";
 import { loadRuntimeModelCatalog } from "../../runtime/model/model-catalog.js";
 import { inspectRuntimeSetupRequirement } from "./runtime-availability.js";
+import { readSavedModelCatalog } from "./saved-model-catalog.js";
 export class RuntimeEnvironmentRegistry {
     options;
     schedulerBindings;
     environments = new Map();
     stopped = false;
+    desiredEnvironmentIds = new Set();
+    applying;
+    setupActivationPending = false;
     stopping;
+    configuredEnvironments;
     constructor(options, schedulerBindings = {}) {
         this.options = options;
         this.schedulerBindings = schedulerBindings;
+        this.configuredEnvironments = options.resolveEnvironmentConfig?.(options.configPath);
+    }
+    environmentConfig() {
+        return this.configuredEnvironments;
+    }
+    applyConfiguration() {
+        if (this.stopped)
+            return Promise.reject(new Error("web_runtime_stopped"));
+        if (this.applying)
+            return this.applying;
+        const configPath = inspectRuntimeConfigFileWithMeta(this.options.rootDir ?? process.cwd(), this.options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE).path;
+        const apply = withConfigurationActivationSource(configPath, (prepare) => this.applySavedConfiguration(configPath, prepare));
+        this.applying = apply.finally(() => {
+            this.applying = undefined;
+        });
+        return this.applying;
+    }
+    applySavedConfiguration(configPath, preparation) {
+        const nextEnvironments = this.options.resolveEnvironmentConfig?.(configPath);
+        return applyRuntimeConfiguration({
+            environments: this.environments,
+            defaultEnvironmentId: nextEnvironments?.defaultEnvironmentId ??
+                this.options.defaultEnvironmentId,
+            environmentIds: nextEnvironments?.environments.map(({ id }) => id) ?? [
+                ...this.desiredEnvironmentIds,
+            ],
+            createEnvironment: (id) => this.createEnvironment(id, this.loadConfig(id, configPath)),
+            recreateEnvironment: (id, previous) => this.createEnvironment(id, previous.services.config),
+            createGatewayRestorePoint: this.options.createRuntimeSetupRestorePoint,
+            onRestorationFailure: () => {
+                this.setupActivationPending = true;
+            },
+            ...preparation,
+            checkGateway: () => this.checkGatewayActivation(configPath),
+            activateGateway: () => this.options.onRuntimeSetup?.(configPath) ??
+                Promise.resolve({ status: "ready" }),
+            canContinue: () => !this.stopped,
+        }).then((result) => {
+            if (result.status !== "ready")
+                return result;
+            this.setupActivationPending = false;
+            if (nextEnvironments) {
+                this.configuredEnvironments = nextEnvironments;
+                this.options.defaultEnvironmentId =
+                    nextEnvironments.defaultEnvironmentId;
+                this.desiredEnvironmentIds.clear();
+                for (const { id } of nextEnvironments.environments)
+                    this.desiredEnvironmentIds.add(id);
+            }
+            return result;
+        });
+    }
+    checkGatewayActivation(configPath) {
+        if (this.options.checkRuntimeSetupActivation)
+            return this.options.checkRuntimeSetupActivation(configPath);
+        if (this.options.onRuntimeSetup)
+            return Promise.resolve({ status: "ready" });
+        return Promise.resolve({
+            status: "restart_required",
+            message: "Connection saved. Restart the owning model gateway and Runtime to apply this configuration.",
+        });
+    }
+    configure(configPath) {
+        this.requireEnvironmentIntakeOpen();
+        this.options.configPath = configPath;
+        if (!this.hasStartedEnvironment())
+            this.setupActivationPending = true;
     }
     modelCatalog(environmentId) {
+        if (this.setupActivationPending) {
+            return this.emptyModelCatalog({
+                status: "setup_required",
+                code: "runtime_configuration_required",
+                message: "Your connection is saved. Apply the setup or restart its owning services before starting a conversation.",
+            });
+        }
+        const active = this.environments.get(environmentId || this.options.defaultEnvironmentId);
+        if (active?.getOwnership() !== undefined) {
+            return {
+                ...loadRuntimeModelCatalog(active.services.config),
+                availability: { status: "ready" },
+            };
+        }
         const source = inspectRuntimeConfigFileWithMeta(this.options.rootDir ?? process.cwd(), this.options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE);
         const setupRequirement = inspectRuntimeSetupRequirement(source);
         if (setupRequirement) {
             return this.emptyModelCatalog(setupRequirement);
         }
-        const catalog = loadRuntimeModelCatalog(this.loadConfig(environmentId));
+        if (requiresConfiguredCredential(source, this.options.rootDir ?? process.cwd())) {
+            return this.emptyModelCatalog({
+                status: "setup_required",
+                code: "runtime_configuration_required",
+                message: "The configured OpenAI model needs an API key. Complete the connection in this Web UI.",
+            });
+        }
+        const catalog = readSavedModelCatalog(source, environmentId || this.options.defaultEnvironmentId);
         return {
             ...catalog,
             availability: { status: "ready" },
@@ -32,21 +128,27 @@ export class RuntimeEnvironmentRegistry {
     get(environmentId) {
         this.requireEnvironmentIntakeOpen();
         const normalized = environmentId || this.options.defaultEnvironmentId;
+        this.desiredEnvironmentIds.add(normalized);
         const existing = this.environments.get(normalized);
         if (existing)
             return existing;
-        const config = this.loadConfig(normalized);
+        const environment = this.createEnvironment(normalized);
+        this.environments.set(normalized, environment);
+        return environment;
+    }
+    createEnvironment(environmentId, config = this.loadConfig(environmentId)) {
         const environment = createLocalRuntimeApplication(config, {
             scheduledRequestOptions: this.schedulerBindings.requestOptions,
         });
         if (this.schedulerBindings.publish) {
             environment.subscribeScheduledEvents(this.schedulerBindings.publish);
         }
-        this.environments.set(normalized, environment);
         return environment;
     }
     async start(environmentIds) {
         this.requireEnvironmentIntakeOpen();
+        for (const id of environmentIds)
+            this.desiredEnvironmentIds.add(id);
         await Promise.all(environmentIds.map((id) => this.startEnvironment(id)));
     }
     async startEnvironment(id) {
@@ -63,12 +165,25 @@ export class RuntimeEnvironmentRegistry {
         if (this.stopping)
             return this.stopping;
         this.stopped = true;
-        this.stopping = Promise.all([...this.environments.values()].map(async (environment) => environment.stop())).then(() => undefined);
+        this.stopping = this.stopAfterConfigurationApplication();
         return this.stopping;
     }
+    async stopAfterConfigurationApplication() {
+        // Apply checks the stopped fence after every async handoff; teardown owns final closure.
+        await this.applying?.catch(() => undefined);
+        const stops = await Promise.allSettled([...this.environments.values()].map((environment) => environment.stop()));
+        const failed = stops.find((result) => result.status === "rejected");
+        if (failed?.status === "rejected")
+            throw failed.reason;
+    }
+    hasStartedEnvironment() {
+        return [...this.environments.values()].some((environment) => environment.getOwnership() !== undefined);
+    }
     requireEnvironmentIntakeOpen() {
         if (this.stopped)
             throw new Error("web_runtime_stopped");
+        if (this.applying)
+            throw new Error("Configuration is being applied. Try again shortly.");
     }
     profileEnv(environmentId) {
         return {
@@ -76,10 +191,10 @@ export class RuntimeEnvironmentRegistry {
             LLM_RUNTIME_PROFILE: environmentId || this.options.defaultEnvironmentId,
         };
     }
-    loadConfig(environmentId) {
+    loadConfig(environmentId, configPath = this.options.configPath) {
         return loadRuntimeConfig({
             rootDir: this.options.rootDir,
-            configPath: this.options.configPath,
+            configPath,
             profileId: environmentId || this.options.defaultEnvironmentId,
         });
     }

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

@@ -3,7 +3,8 @@ import type { LongTermMemoryOnboardingService } from "../../runtime/long-term-me
 type JsonBody = Record<string, unknown> | null;
 export declare class LongTermMemoryOnboardingRoutes {
     private readonly service;
-    constructor(service: LongTermMemoryOnboardingService);
+    constructor(service: LongTermMemoryOnboardingService | (() => LongTermMemoryOnboardingService));
+    private currentService;
     handle(params: {
         method: string;
         route: string;

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

@@ -1,3 +1,4 @@
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
 import { getString, sendJson } from "./http.js";
 import { withHttpRequestAbortSignal } from "./request-abort.js";
 export class LongTermMemoryOnboardingRoutes {
@@ -5,6 +6,9 @@ export class LongTermMemoryOnboardingRoutes {
     constructor(service) {
         this.service = service;
     }
+    currentService() {
+        return typeof this.service === "function" ? this.service() : this.service;
+    }
     async handle(params) {
         try {
             return await this.handleKnownRoute(params);
@@ -22,12 +26,11 @@ export class LongTermMemoryOnboardingRoutes {
         if (params.method === "GET" && params.route === "runtime/memory") {
             sendJson(params.response, 200, {
                 ok: true,
-                status: await this.service.status(),
+                status: await this.currentService().status(),
             });
             return true;
         }
-        if (params.method === "GET" &&
-            params.route === "runtime/memory/models") {
+        if (params.method === "GET" && params.route === "runtime/memory/models") {
             const providerId = params.url.searchParams.get("provider") ?? "";
             sendJson(params.response, 200, {
                 ok: true,
@@ -35,18 +38,19 @@ export class LongTermMemoryOnboardingRoutes {
                     request: params.request,
                     response: params.response,
                     reason: "memory_onboarding_discovery_request_aborted",
-                    run: (abortSignal) => this.service.discover({ providerId, abortSignal }),
+                    run: (abortSignal) => this.currentService().discover({ providerId, abortSignal }),
                 }),
             });
             return true;
         }
-        if (params.method === "POST" &&
-            params.route === "runtime/memory/enable") {
+        if (params.method === "POST" && params.route === "runtime/memory/enable") {
+            if (!acceptConfigMutationRequest(params.request, params.response))
+                return true;
             const result = await withHttpRequestAbortSignal({
                 request: params.request,
                 response: params.response,
                 reason: "memory_onboarding_enable_request_aborted",
-                run: (abortSignal) => this.service.enable({
+                run: (abortSignal) => this.currentService().enable({
                     providerId: getString(params.body?.providerId),
                     model: getString(params.body?.model),
                     ...(getString(params.body?.profileId)
@@ -59,11 +63,12 @@ export class LongTermMemoryOnboardingRoutes {
             sendJson(params.response, 200, { ok: true, ...result });
             return true;
         }
-        if (params.method === "POST" &&
-            params.route === "runtime/memory/disable") {
+        if (params.method === "POST" && params.route === "runtime/memory/disable") {
+            if (!acceptConfigMutationRequest(params.request, params.response))
+                return true;
             sendJson(params.response, 200, {
                 ok: true,
-                ...(await this.service.disable()),
+                ...(await this.currentService().disable()),
             });
             return true;
         }

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

@@ -0,0 +1,17 @@
+export type ModelSetupOptions = {
+    rootDir: string;
+    configPath?: string;
+};
+export declare function readModelSetupSource(options: ModelSetupOptions): import("../../runtime/config/loader.js").InspectedRuntimeConfigFile;
+export declare function modelConfigMap(value: unknown): Record<string, unknown>;
+export declare function getModelSetupCatalog(options: ModelSetupOptions): Promise<{
+    providers: {
+        id: string;
+        type: string;
+        label: string;
+        requiresApiKey: boolean;
+        credentialConfigured: boolean;
+    }[];
+    defaultContextWindowTokens: number;
+    profileIds: string[];
+}>;

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

@@ -0,0 +1,45 @@
+import { readDefaultContextWindowTokens } from "../../../scripts/runtime-setup-files.js";
+import { getConfigDashboardSnapshot } from "../config-dashboard-backend.js";
+import { inspectRuntimeConfigFileWithMeta } from "../../runtime/config/loader.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
+import { hasRuntimeSetupCredential } from "./runtime-setup-credentials.js";
+import { ModelSetupError } from "./model-setup-input.js";
+export function readModelSetupSource(options) {
+    const source = inspectRuntimeConfigFileWithMeta(options.rootDir, options.configPath);
+    if (!source.exists)
+        throw new ModelSetupError("runtime_setup_required", "Complete initial setup before adding another model.", 409);
+    validateRuntimeConfigFile(source.config, source.path);
+    return source;
+}
+export function modelConfigMap(value) {
+    return isRecord(value) ? value : {};
+}
+export async function getModelSetupCatalog(options) {
+    const source = readModelSetupSource(options);
+    const models = modelConfigMap(source.config.models);
+    const providers = await Promise.all(Object.entries(modelConfigMap(models.providers)).map(async ([id, value]) => {
+        const provider = modelConfigMap(value);
+        const type = String(provider.type);
+        const requiresApiKey = type === "openai";
+        const apiKeyEnv = typeof provider.apiKeyEnv === "string"
+            ? provider.apiKeyEnv
+            : "OPENAI_API_KEY";
+        return {
+            id,
+            type,
+            label: id,
+            requiresApiKey,
+            credentialConfigured: requiresApiKey &&
+                (await hasRuntimeSetupCredential(options.rootDir, apiKeyEnv)),
+        };
+    }));
+    const dashboard = await getConfigDashboardSnapshot(options);
+    return {
+        providers,
+        defaultContextWindowTokens: await readDefaultContextWindowTokens(),
+        profileIds: [
+            ...new Set(dashboard.files.models.map((profile) => profile.id)),
+        ],
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { ModelSetupInput } from "./model-setup-input.js";
+import type { planModelProvider } from "./model-setup-provider.js";
+type ModelProviderPlan = ReturnType<typeof planModelProvider>;
+export declare function buildModelSetupProfile(provider: ModelProviderPlan, input: ModelSetupInput): Promise<{
+    provider: string;
+}>;
+export declare function modelSetupResult(provider: ModelProviderPlan, input: ModelSetupInput): {
+    model: {
+        profileId: string;
+        providerId: string;
+        provider: string;
+        model: string;
+    };
+    restartRequired: true;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { join } from "node:path";
+import { buildModelConfig, readJsonObject, resolveRuntimePackageRoot, } from "../../../scripts/runtime-setup-files.js";
+export async function buildModelSetupProfile(provider, input) {
+    const template = await readJsonObject(join(resolveRuntimePackageRoot(import.meta.dirname), "examples/models/default.config.json"));
+    return {
+        ...buildModelConfig(template, String(provider.config.type), input.model, input.contextWindowTokens),
+        provider: provider.id,
+    };
+}
+export function modelSetupResult(provider, input) {
+    return {
+        model: {
+            profileId: input.profileId,
+            providerId: provider.id,
+            provider: String(provider.config.type),
+            model: input.model,
+        },
+        restartRequired: true,
+    };
+}

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

@@ -0,0 +1,24 @@
+export type NewModelProvider = Readonly<{
+    id: string;
+    type: "openai" | "ollama";
+    baseUrl?: string;
+}>;
+export type ModelSetupInput = Readonly<{
+    profileId: string;
+    model: string;
+    contextWindowTokens?: number;
+    apiKey?: string;
+}> & (Readonly<{
+    providerId: string;
+    newProvider?: never;
+}> | Readonly<{
+    newProvider: NewModelProvider;
+    providerId?: never;
+}>);
+export declare class ModelSetupError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly credentialSaved: boolean;
+    constructor(code: string, message: string, statusCode?: number, credentialSaved?: boolean);
+}
+export declare function parseModelSetupInput(body: Record<string, unknown>): ModelSetupInput;