@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/web-ui/client-state/preferences.js

@@ -1,11 +1,13 @@
+import { isColorPaletteId, PALETTE_PREFERENCE_KEY } from "../app/lib/color-palettes.js";
+import { isNavigationMode, NAVIGATION_PREFERENCE_KEY } from "../app/lib/navigation-display.js";
 import { isDeepStrictEqual } from "node:util";
 import { ClientStateError } from "./contracts.js";
 import { assertPreferenceShape, isPreferenceObject as isObject } from "./preference-shapes.js";
-const scalarKeys = new Set(["abot-web.environmentId", "abot-web.lastToolPermissionMode"]);
+const scalarKeys = new Set(["abot-web.environmentId", "abot-web.lastToolPermissionMode", PALETTE_PREFERENCE_KEY, NAVIGATION_PREFERENCE_KEY]);
 const jsonKeys = new Set([
     "abot-web.pinnedSessions", "abot-web.currentSessionByEnvironment", "abot-web.sessionModes",
     "abot-web.sessionModels", "abot-web.lastModelByEnvironment", "abot-web.sessionSidebarByEnvironment",
-    "abot.spark.launcher.position.v1",
+    "abot.spark.launcher.position.v1", "abot-web.reasoningPreferences",
 ]);
 const modes = new Set(["ask", "full_access", "full_plus"]);
 function assertBoundedJson(value, depth = 0) {
@@ -32,6 +34,10 @@ export function decodePreference(key, value) {
     if (scalarKeys.has(key)) {
         if (key.endsWith("lastToolPermissionMode") && !modes.has(value))
             throw new ClientStateError("invalid_preferences", "Select Ask, Full or Full+.");
+        if (key === PALETTE_PREFERENCE_KEY && !isColorPaletteId(value))
+            throw new ClientStateError("invalid_preferences", "Select a supported color palette.");
+        if (key === NAVIGATION_PREFERENCE_KEY && !isNavigationMode(value))
+            throw new ClientStateError("invalid_preferences", "Select icons only or icons and text.");
         return value;
     }
     let decoded;

package/dist/src/web-ui/client-state/reasoning-preference-shape.d.ts

@@ -0,0 +1 @@
+export declare function isReasoningPreferenceMap(value: unknown): boolean;

package/dist/src/web-ui/client-state/reasoning-preference-shape.js

@@ -0,0 +1,18 @@
+import { isReasoningPreference } from "../app/lib/reasoning-preference.js";
+export function isReasoningPreferenceMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return Object.entries(value).every(([key, preference]) => {
+        if (!isReasoningPreference(preference))
+            return false;
+        try {
+            const scope = JSON.parse(key);
+            return Array.isArray(scope) && key === JSON.stringify(scope) && scope.length === 3
+                && typeof scope[0] === "string" && Boolean(scope[0].trim())
+                && typeof scope[1] === "string" && scope[2] === preference.profileId;
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/dist/src/web-ui/client-state/store.js

@@ -7,6 +7,7 @@ import { replacePreparedSessionFile } from "../../sessions/prepared-session-repl
 import { isPersistedStore } from "../app/lib/session-composer-queue.js";
 import { ClientStateError, emptyClientState } from "./contracts.js";
 import { decodePreference } from "./preferences.js";
+import { serializeClientStateTransaction } from "./transaction-order.js";
 const maxStateBytes = 8 * 1024 * 1024;
 function decodeState(raw) {
     const state = JSON.parse(raw);
@@ -74,7 +75,7 @@ export class WebClientStateStore {
                 this.initialization = undefined;
             throw error;
         }
-        return withFileLock(join(this.directory, "state.lock"), async () => {
+        return serializeClientStateTransaction(this.path, () => withFileLock(join(this.directory, "state.lock"), async () => {
             const state = await this.load();
             const before = JSON.stringify(state);
             const result = operation(state);
@@ -83,6 +84,6 @@ export class WebClientStateStore {
                 await this.save(state);
             }
             return { result, state };
-        });
+        }));
     }
 }

package/dist/src/web-ui/client-state/transaction-order.d.ts

@@ -0,0 +1,2 @@
+/** Order this process's callers before they contend for the cross-process file lock. */
+export declare function serializeClientStateTransaction<T>(path: string, operation: () => Promise<T>): Promise<T>;

package/dist/src/web-ui/client-state/transaction-order.js

@@ -0,0 +1,18 @@
+const pendingTransactions = new Map();
+/** Order this process's callers before they contend for the cross-process file lock. */
+export async function serializeClientStateTransaction(path, operation) {
+    const previous = pendingTransactions.get(path) ?? Promise.resolve();
+    // Report each failure to its own caller without blocking later transactions.
+    const pending = previous.catch(() => undefined).then(operation);
+    pendingTransactions.set(path, pending);
+    try {
+        return await pending;
+    }
+    finally {
+        if (isCurrentTransactionTail(path, pending))
+            pendingTransactions.delete(path);
+    }
+}
+function isCurrentTransactionTail(path, pending) {
+    return pendingTransactions.get(path) === pending;
+}

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

@@ -12,7 +12,9 @@ export declare class LocalRuntimeApiRouter {
     private readonly setup;
     private readonly modelSetup;
     private readonly setupEmbedding;
+    private readonly memoryConnection;
     private readonly plugins;
+    private readonly skillManagement;
     private readonly memoryManagement;
     private readonly memoryOnboarding;
     private readonly schedules;

package/dist/src/web-ui/local-runtime/api-router.js

@@ -1,3 +1,4 @@
+import { PersonalSkillManagementRoutes } from "./skill-management-routes.js";
 import { ProjectRoutes } from "./project-routes.js";
 import { cancelWebRequest } from "./request-cancellation-route.js";
 import { ConversationFileRoutes } from "./conversation-file-routes.js";
@@ -6,6 +7,7 @@ import { ModelSetupRoutes } from "./model-setup-routes.js";
 import { ModelSetupService } from "./model-setup-service.js";
 import { SetupEmbeddingRoutes } from "./setup-embedding-routes.js";
 import { SetupEmbeddingService } from "./setup-embedding-service.js";
+import { MemoryEmbeddingConnectionService } from "./memory-embedding-connection-service.js";
 import { RuntimeSetupRoutes } from "./runtime-setup-routes.js";
 import { RuntimeSetupService } from "./runtime-setup-service.js";
 import { applyAndCompleteRuntimeSetup, pendingRuntimeSetupCatalog, } from "./runtime-setup-completion.js";
@@ -44,7 +46,9 @@ export class LocalRuntimeApiRouter {
     setup;
     modelSetup;
     setupEmbedding;
+    memoryConnection;
     plugins;
+    skillManagement;
     memoryManagement;
     memoryOnboarding;
     schedules;
@@ -86,6 +90,11 @@ export class LocalRuntimeApiRouter {
             getConfigPath: () => options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE,
             providerAdapters: options.providerAdapters,
         }));
+        this.memoryConnection = new SetupEmbeddingRoutes(new MemoryEmbeddingConnectionService({
+            rootDir: options.rootDir ?? process.cwd(),
+            getConfigPath: () => options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE,
+            providerAdapters: options.providerAdapters,
+        }), "runtime/memory/connection");
         this.plugins = new PluginManagementRoutes({
             rootDir: options.rootDir ?? process.cwd(),
             requireMutationIdle: () => this.environments.requirePluginMutationIdle(this.requests.healthDetails().length > 0),
@@ -104,6 +113,7 @@ export class LocalRuntimeApiRouter {
             providerAdapters: options.providerAdapters,
             configPath: options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE,
         }));
+        this.skillManagement = new PersonalSkillManagementRoutes((id) => this.environments.get(id).services.personalSkills);
         this.memoryManagement = new LongTermMemoryManagementRoutes((environmentId) => this.environments.get(environmentId).services.longTermMemory);
     }
     async applyWhenRequestsIdle(expectedRevision) {
@@ -152,6 +162,10 @@ export class LocalRuntimeApiRouter {
             response: res,
         }))
             return;
+        if (await this.memoryConnection.handle({
+            method, route, request: req, response: res,
+        }))
+            return;
         if (method === "PUT" &&
             ["runtime/plugins", "runtime/config/dashboard/file"].includes(route)) {
             if (!acceptConfigMutationRequest(req, res))
@@ -251,6 +265,10 @@ export class LocalRuntimeApiRouter {
         })) {
             return;
         }
+        if (await this.skillManagement.handle({
+            method, segments, body, environmentId, request: req, response: res,
+        }))
+            return;
         if (await this.memoryManagement.handle({
             method,
             route,

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

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { AutomationPublicationError } from "../../runtime/automations/publication.js";
 import { acceptConfigMutationRequest } from "./config-mutation-request.js";
 import { sendJson } from "./http.js";
+import { readAutomationRunPage } from "./automation-run-page.js";
 function requiredRevision(value) {
     if (!Number.isSafeInteger(value) || Number(value) < 1)
         throw new Error("automation_revision_required");
@@ -182,7 +183,7 @@ export class AutomationRoutes {
         }
         if (action === "runs" && method === "GET") {
             sendJson(response, 200, { ok: true,
-                runs: await service.listRuns(automationId, { limit: 100 }),
+                ...await readAutomationRunPage(service, automationId, request.url.searchParams),
             });
             return;
         }

package/dist/src/web-ui/local-runtime/automation-run-page.d.ts

@@ -0,0 +1,5 @@
+import type { AutomationService } from "../../runtime/automations/service.js";
+export declare function readAutomationRunPage(service: Pick<AutomationService, "listRuns">, automationId: string, params: URLSearchParams): Promise<{
+    runs: import("../../runtime/index.js").SchedulerAutomationRun[];
+    nextCursor: string | null;
+}>;

package/dist/src/web-ui/local-runtime/automation-run-page.js

@@ -0,0 +1,26 @@
+import { parseSchedulerRunFilters } from "../../runtime/scheduler/run-list-filter.js";
+export async function readAutomationRunPage(service, automationId, params) {
+    const limit = requireAutomationRunPageLimit(params.get("limit"));
+    const cursor = params.get("cursor") ?? undefined;
+    const filters = parseSchedulerRunFilters({
+        status: params.get("status") ?? undefined,
+        from: params.get("from") ?? undefined,
+        to: params.get("to") ?? undefined,
+    });
+    // Select metadata in the owner before loading or serializing run payloads.
+    const page = await service.listRuns(automationId, { ...filters, cursor, limit: limit + 1 });
+    const runs = page.slice(0, limit);
+    return { runs, nextCursor: page.length > limit ? runs.at(-1).id : null };
+}
+function requireAutomationRunPageLimit(value) {
+    if (value === null)
+        return 50;
+    const limit = Number(value);
+    if (!Number.isSafeInteger(limit))
+        throw new Error("scheduler_run_page_limit_invalid");
+    if (limit < 1)
+        throw new Error("scheduler_run_page_limit_invalid");
+    if (limit > 100)
+        throw new Error("scheduler_run_page_limit_invalid");
+    return limit;
+}

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

@@ -0,0 +1,7 @@
+import { type SetupEmbeddingInput } from "./setup-embedding-input.js";
+export type MemoryEmbeddingConnectionInput = SetupEmbeddingInput & Readonly<{
+    profileId?: string;
+    emitClientEvents?: boolean;
+}>;
+/** Settings keep their existing memory options while sharing provider validation. */
+export declare function parseMemoryEmbeddingConnectionInput(body: Record<string, unknown>): MemoryEmbeddingConnectionInput;

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

@@ -0,0 +1,22 @@
+import { parseSetupEmbeddingInput, } from "./setup-embedding-input.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+import { readEmbeddingProfileId } from "../../runtime/long-term-memory/onboarding/embedding-profile-id.js";
+/** Settings keep their existing memory options while sharing provider validation. */
+export function parseMemoryEmbeddingConnectionInput(body) {
+    const { profileId, emitClientEvents, ...connection } = body;
+    const hasUnsupportedProfileId = profileId !== undefined && typeof profileId !== "string";
+    if (hasUnsupportedProfileId)
+        throw new RuntimeSetupError("invalid_embedding_profile", "Enter a valid embedding profile ID.");
+    const hasUnsupportedMemoryEvents = emitClientEvents !== undefined && typeof emitClientEvents !== "boolean";
+    if (hasUnsupportedMemoryEvents)
+        throw new RuntimeSetupError("invalid_memory_events", "The memory events choice must be true or false.");
+    const input = parseSetupEmbeddingInput(connection);
+    const requestedProfileId = profileId?.trim();
+    return {
+        ...input,
+        ...(requestedProfileId
+            ? { profileId: readEmbeddingProfileId(requestedProfileId) }
+            : {}),
+        ...(emitClientEvents === undefined ? {} : { emitClientEvents }),
+    };
+}

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

@@ -0,0 +1,20 @@
+import type { ModelProviderAdapterRegistry } from "../../model-gateway/index.js";
+/** Adds an embedding connection without applying onboarding's plugin policy. */
+export declare class MemoryEmbeddingConnectionService {
+    private readonly options;
+    constructor(options: {
+        rootDir: string;
+        getConfigPath: () => string | undefined;
+        providerAdapters: ModelProviderAdapterRegistry;
+    });
+    enable(body: Record<string, unknown>, abortSignal: AbortSignal): Promise<Readonly<{
+        status: import("../../runtime/index.js").LongTermMemoryOnboardingStatus;
+        restartRequired: boolean;
+        configPath: string;
+        backupPath?: string;
+        probe?: Readonly<{
+            modelFingerprint: string;
+            dimensions: number;
+        }>;
+    }>>;
+}

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

@@ -0,0 +1,47 @@
+import { createLocalLongTermMemoryOnboardingService } from "../../runtime/adapters/long-term-memory/onboarding-service.js";
+import { parseMemoryEmbeddingConnectionInput } from "./memory-embedding-connection-input.js";
+import { prepareSetupEmbeddingProvider, } from "./setup-embedding-provider.js";
+import { SetupEmbeddingFailure } from "./setup-embedding-service.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+/** Adds an embedding connection without applying onboarding's plugin policy. */
+export class MemoryEmbeddingConnectionService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async enable(body, abortSignal) {
+        const input = parseMemoryEmbeddingConnectionInput(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 current = await service.status();
+            return await service.enable({
+                providerId: prepared.providerId,
+                model: input.model,
+                profileId: input.profileId ?? current.profileId,
+                emitClientEvents: input.emitClientEvents ?? current.emitClientEvents,
+                abortSignal,
+            });
+        }
+        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."
+                : "The embedding connection could not be saved. Memory settings were not changed.";
+            throw new SetupEmbeddingFailure(providerSaved, 400, message, savedProvider);
+        }
+    }
+}

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

@@ -63,6 +63,38 @@ export class LongTermMemoryOnboardingRoutes {
             sendJson(params.response, 200, { ok: true, ...result });
             return true;
         }
+        if (params.method === "POST" && params.route === "runtime/memory/profiles") {
+            if (!acceptConfigMutationRequest(params.request, params.response))
+                return true;
+            const result = await withHttpRequestAbortSignal({
+                request: params.request,
+                response: params.response,
+                reason: "memory_profile_save_request_aborted",
+                run: (abortSignal) => this.currentService().saveProfile({
+                    providerId: getString(params.body?.providerId),
+                    model: getString(params.body?.model),
+                    label: getString(params.body?.label),
+                    abortSignal,
+                }),
+            });
+            sendJson(params.response, 200, { ok: true, ...result });
+            return true;
+        }
+        if (params.method === "DELETE" && params.route === "runtime/memory/profiles") {
+            if (!acceptConfigMutationRequest(params.request, params.response))
+                return true;
+            const result = await withHttpRequestAbortSignal({
+                request: params.request,
+                response: params.response,
+                reason: "memory_profile_remove_request_aborted",
+                run: (abortSignal) => this.currentService().removeProfile({
+                    profileId: getString(params.body?.profileId),
+                    abortSignal,
+                }),
+            });
+            sendJson(params.response, 200, { ok: true, ...result });
+            return true;
+        }
         if (params.method === "POST" && params.route === "runtime/memory/disable") {
             if (!acceptConfigMutationRequest(params.request, params.response))
                 return true;

package/dist/src/web-ui/local-runtime/model-connection-inspection.d.ts

@@ -0,0 +1,7 @@
+/** Explicit inspection reads metadata only and never saves settings or invokes a model. */
+export declare function inspectModelSetupConnection(options: {
+    rootDir: string;
+    configPath?: string;
+}, body: Record<string, unknown>, signal: AbortSignal): Promise<{
+    models: readonly string[];
+}>;

package/dist/src/web-ui/local-runtime/model-connection-inspection.js

@@ -0,0 +1,48 @@
+import { parseBaseUrl } from "../../../scripts/runtime-setup-files.js";
+import { inspectLlamaCppConnection } from "../../model-gateway/providers/llamacpp/connection.js";
+import { inspectRuntimeConfigFileWithMeta } from "../../runtime/config/loader.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+import { readRuntimeSetupCredential } from "./runtime-setup-credentials.js";
+function inputText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function requiresSafeInspectionCredential(value) {
+    if (value.length <= 4096 && !/[\u0000-\u0020\u007f'"`]/u.test(value))
+        return;
+    throw new RuntimeSetupError("invalid_connection_credential", "The API key contains unsupported characters.");
+}
+/** Explicit inspection reads metadata only and never saves settings or invokes a model. */
+export async function inspectModelSetupConnection(options, body, signal) {
+    const source = inspectRuntimeConfigFileWithMeta(options.rootDir, options.configPath);
+    const models = isRecord(source.config.models) ? source.config.models : {};
+    const providers = isRecord(models.providers) ? models.providers : {};
+    const providerId = inputText(body.providerId);
+    const configured = providers[providerId || "llamacpp"];
+    const saved = isRecord(configured) ? configured : undefined;
+    if (providerId && saved?.type !== "llamacpp")
+        throw new RuntimeSetupError("unsupported_connection_inspection", "Choose a saved llama.cpp connection.");
+    if (!providerId && body.provider !== "llamacpp")
+        throw new RuntimeSetupError("unsupported_connection_inspection", "Connection inspection is available for llama.cpp.");
+    let baseUrl;
+    try {
+        baseUrl = parseBaseUrl(inputText(providerId ? saved?.baseUrl : body.baseUrl));
+    }
+    catch {
+        throw new RuntimeSetupError("invalid_connection_address", "Enter an HTTP or HTTPS origin without a path or credentials.");
+    }
+    const suppliedKey = inputText(body.apiKey);
+    requiresSafeInspectionCredential(suppliedKey);
+    const canReuseSavedCredential = saved?.type === "llamacpp" && saved.baseUrl === baseUrl;
+    const apiKeyEnv = canReuseSavedCredential && typeof saved.apiKeyEnv === "string"
+        ? saved.apiKeyEnv : undefined;
+    const apiKey = suppliedKey || (apiKeyEnv ? readRuntimeSetupCredential(options.rootDir, apiKeyEnv) : "");
+    if (apiKeyEnv && !apiKey)
+        throw new RuntimeSetupError("connection_credential_required", "Enter the API key configured for this connection.");
+    try {
+        return await inspectLlamaCppConnection({ baseUrl, ...(apiKey ? { apiKey } : {}), signal });
+    }
+    catch {
+        throw new RuntimeSetupError("model_connection_unavailable", "Could not inspect this llama.cpp server. Check its address, authentication and whether its model is loaded.", 502);
+    }
+}

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

@@ -6,11 +6,12 @@ export declare function readModelSetupSource(options: ModelSetupOptions): import
 export declare function modelConfigMap(value: unknown): Record<string, unknown>;
 export declare function getModelSetupCatalog(options: ModelSetupOptions): Promise<{
     providers: {
+        credentialConfigured: boolean;
+        supportsOptionalApiKey?: boolean | undefined;
         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

@@ -1,3 +1,4 @@
+import { requiresProviderCredential } from "./runtime-setup-auth.js";
 import { readDefaultContextWindowTokens } from "../../../scripts/runtime-setup-files.js";
 import { getConfigDashboardSnapshot } from "../config-dashboard-backend.js";
 import { inspectRuntimeConfigFileWithMeta } from "../../runtime/config/loader.js";
@@ -21,7 +22,7 @@ export async function getModelSetupCatalog(options) {
     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 requiresApiKey = requiresProviderCredential(provider);
         const apiKeyEnv = typeof provider.apiKeyEnv === "string"
             ? provider.apiKeyEnv
             : "OPENAI_API_KEY";
@@ -30,6 +31,7 @@ export async function getModelSetupCatalog(options) {
             type,
             label: id,
             requiresApiKey,
+            ...(type === "llamacpp" ? { supportsOptionalApiKey: true } : {}),
             credentialConfigured: requiresApiKey &&
                 (await hasRuntimeSetupCredential(options.rootDir, apiKeyEnv)),
         };

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

@@ -3,7 +3,7 @@ import { buildModelConfig, readJsonObject, resolveRuntimePackageRoot, } from "..
 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),
+        ...buildModelConfig(template, String(provider.config.type), input.model, input.contextWindowTokens, input),
         provider: provider.id,
     };
 }

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

@@ -1,9 +1,12 @@
+import { type SetupModelOptions } from "../../../scripts/runtime-setup-model-options.js";
 export type NewModelProvider = Readonly<{
     id: string;
-    type: "openai" | "ollama";
+    type: "openai" | "ollama" | "llamacpp";
+    apiKeyEnv?: string;
+    useApiKey?: boolean;
     baseUrl?: string;
 }>;
-export type ModelSetupInput = Readonly<{
+export type ModelSetupInput = SetupModelOptions & Readonly<{
     profileId: string;
     model: string;
     contextWindowTokens?: number;

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

@@ -1,5 +1,7 @@
 import { parseRuntimeModelProfileId } from "../../../scripts/runtime-model-addition.js";
 import { parseBaseUrl, parseContextWindowTokens, } from "../../../scripts/runtime-setup-files.js";
+import { parseSetupModelOptions } from "../../../scripts/runtime-setup-model-options.js";
+import { supportsProviderAddress, parseProviderCredentialEnvironment } from "../../../scripts/runtime-setup-provider-options.js";
 import { isRecord } from "../../runtime/config/utils.js";
 export class ModelSetupError extends Error {
     code;
@@ -51,14 +53,14 @@ function requirePortableModelProfileId(value) {
 function readNewProvider(value) {
     if (!isRecord(value))
         throw new ModelSetupError("invalid_model_provider", "Choose a configured provider or add a new provider.");
-    requireAllowedFields(value, ["id", "type", "baseUrl"]);
+    requireAllowedFields(value, ["id", "type", "baseUrl", "apiKeyEnv", "useApiKey"]);
     const id = requireIdentifier(inputString(value, "id"), "provider");
     const type = inputString(value, "type");
-    if (type !== "openai" && type !== "ollama")
-        throw new ModelSetupError("invalid_model_provider", "A new provider must use OpenAI or Ollama.");
+    if (type !== "openai" && type !== "ollama" && type !== "llamacpp")
+        throw new ModelSetupError("invalid_model_provider", "A new provider must use OpenAI, Ollama or llama.cpp.");
     const address = inputString(value, "baseUrl", true);
-    if (address && type !== "ollama")
-        throw new ModelSetupError("invalid_model_address", "A custom address is available for a new Ollama provider.");
+    if (address && !supportsProviderAddress(type))
+        throw new ModelSetupError("invalid_model_address", "A custom address is available for a new Ollama or llama.cpp provider.");
     let baseUrl;
     try {
         baseUrl = address ? parseBaseUrl(address) : undefined;
@@ -66,7 +68,18 @@ function readNewProvider(value) {
     catch {
         throw new ModelSetupError("invalid_model_address", "Enter an HTTP or HTTPS origin without a path or credentials.");
     }
-    return { id, type, ...(baseUrl ? { baseUrl } : {}) };
+    if (value.useApiKey !== undefined && (type !== "llamacpp" || typeof value.useApiKey !== "boolean"))
+        throw new ModelSetupError("invalid_model_credential", "An optional API key choice is available for llama.cpp.");
+    let apiKeyEnv;
+    try {
+        apiKeyEnv = parseProviderCredentialEnvironment(value.apiKeyEnv);
+    }
+    catch (error) {
+        throw new ModelSetupError("invalid_model_credential", error.message);
+    }
+    if (apiKeyEnv && type !== "llamacpp")
+        throw new ModelSetupError("invalid_model_credential", "A custom key environment is available for llama.cpp.");
+    return { id, type, ...(baseUrl ? { baseUrl } : {}), ...(apiKeyEnv ? { apiKeyEnv } : {}), ...(value.useApiKey !== undefined ? { useApiKey: value.useApiKey } : {}) };
 }
 function requireModelIdentifier(model) {
     if (model.length > 256 || /[\u0000-\u0020\u007f]/u.test(model))
@@ -83,10 +96,19 @@ export function parseModelSetupInput(body) {
         "profileId",
         "model",
         "contextWindowTokens",
+        "supportsThinking",
+        "reasoningBudget",
         "providerId",
         "newProvider",
         "apiKey",
     ]);
+    let modelOptions;
+    try {
+        modelOptions = parseSetupModelOptions(body);
+    }
+    catch (error) {
+        throw new ModelSetupError("invalid_model_reasoning", error.message);
+    }
     const profileId = requirePortableModelProfileId(inputString(body, "profileId"));
     let contextWindowTokens;
     try {
@@ -107,6 +129,7 @@ export function parseModelSetupInput(body) {
         ? { providerId }
         : { newProvider: readNewProvider(body.newProvider) };
     return {
+        ...modelOptions,
         profileId,
         model,
         ...(contextWindowTokens !== undefined ? { contextWindowTokens } : {}),

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

@@ -1,6 +1,6 @@
 import { type ModelSetupInput, type NewModelProvider } from "./model-setup-input.js";
 import type { ModelSetupOptions } from "./model-setup-catalog.js";
-export declare function buildNewModelProvider(selection: NewModelProvider): {
+export declare function buildNewModelProvider(selection: NewModelProvider, apiKey?: string): {
     id: string;
     config: import("../../../scripts/runtime-setup-files.js").JsonObject;
 };

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

@@ -1,11 +1,14 @@
+import { requiresProviderCredential } from "./runtime-setup-auth.js";
 import { RuntimeSetupError } from "./runtime-setup-input.js";
 import { hasProviderCredentialBinding, isolatedProviderCredentialName, } from "./provider-credential-identity.js";
 import { buildProviderConfig } from "../../../scripts/runtime-setup-files.js";
 import { isRecord } from "../../runtime/config/utils.js";
 import { readRuntimeSetupCredential, assertRuntimeSetupCredentialFile, persistRuntimeSetupCredentials, } from "./runtime-setup-credentials.js";
 import { ModelSetupError, } from "./model-setup-input.js";
-export function buildNewModelProvider(selection) {
-    const config = buildProviderConfig(selection.type, selection.baseUrl);
+export function buildNewModelProvider(selection, apiKey) {
+    const apiKeyEnv = selection.apiKeyEnv ??
+        (selection.type === "llamacpp" && (apiKey || selection.useApiKey) ? isolatedProviderCredentialName(selection.id) : undefined);
+    const config = buildProviderConfig(selection.type, selection.baseUrl, apiKeyEnv);
     const needsIsolatedCredentialBinding = selection.type === "openai";
     if (needsIsolatedCredentialBinding)
         config.apiKeyEnv = isolatedProviderCredentialName(selection.id);
@@ -23,7 +26,7 @@ export function planModelProvider(providers, input) {
     const selection = input.newProvider;
     if (Object.hasOwn(providers, selection.id))
         throw new ModelSetupError("model_provider_exists", "That provider ID already exists. Choose its saved connection or use another ID.", 409);
-    const provider = buildNewModelProvider(selection);
+    const provider = buildNewModelProvider(selection, input.apiKey);
     const apiKeyEnv = provider.config.apiKeyEnv;
     const hasNewProviderCredentialCollision = typeof apiKeyEnv === "string" &&
         hasProviderCredentialBinding(providers, apiKeyEnv);
@@ -32,10 +35,10 @@ export function planModelProvider(providers, input) {
     return provider;
 }
 export async function prepareModelCredential(options, provider, apiKey) {
-    const requiresApiKey = provider.type === "openai";
+    const requiresApiKey = requiresProviderCredential(provider);
     if (!requiresApiKey) {
         if (apiKey)
-            throw new ModelSetupError("invalid_model_credential", "Only an OpenAI connection accepts an API key here.");
+            throw new ModelSetupError("invalid_model_credential", "This connection does not have an API key binding.");
         return undefined;
     }
     const apiKeyEnv = typeof provider.apiKeyEnv === "string"
@@ -46,7 +49,7 @@ export async function prepareModelCredential(options, provider, apiKey) {
     if (savedKey && apiKey && savedKey !== apiKey)
         throw new ModelSetupError("credential_already_configured", "That provider already has a saved API key. Its credential was preserved.", 409);
     if (!savedKey && !apiKey)
-        throw new ModelSetupError("model_credential_required", "Enter an API key for this OpenAI connection.");
+        throw new ModelSetupError("model_credential_required", "Enter an API key for this connection.");
     return { apiKeyEnv, ...(savedKey ? {} : { apiKey }) };
 }
 export async function saveModelCredential(options, credential) {

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

@@ -12,7 +12,10 @@ function rejectModelProfileCollision() {
 function committedRetryProvider(providers, input) {
     if (input.providerId !== undefined)
         return planModelProvider(providers, input);
-    return buildNewModelProvider(input.newProvider);
+    const saved = modelConfigMap(providers[input.newProvider.id]);
+    const apiKeyEnv = input.newProvider.apiKeyEnv ??
+        (saved.type === "llamacpp" && typeof saved.apiKeyEnv === "string" ? saved.apiKeyEnv : undefined);
+    return buildNewModelProvider({ ...input.newProvider, ...(apiKeyEnv ? { apiKeyEnv } : {}) }, input.apiKey);
 }
 async function requireUnchangedRetryConfiguration(options, expectedRevision) {
     const current = await readConfigFileSnapshot(options.configPath);