@abot-ai/runtime 1.9.0 → 2.0.0

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);

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

@@ -7,11 +7,12 @@ export declare class ModelSetupService {
     private sourceOptions;
     catalog(): 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/pending-tool-approvals.js

@@ -86,7 +86,10 @@ export class PendingToolApprovals {
         const active = this.activeRequest(decision.requestId);
         if (!canResolvePendingApproval(pending, active, decision))
             return false;
-        pending.resolve({ approved: decision.approved });
+        pending.resolve({
+            approved: decision.approved,
+            ...(decision.reason !== undefined ? { reason: decision.reason } : {}),
+        });
         return true;
     }
     resolveRealtime(message) {

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

@@ -13,8 +13,11 @@ function isProjectSessionCreation(segments) {
         return false;
     return segments[2] === "sessions";
 }
+function isProjectDeletion(segments) {
+    return segments.length === 2;
+}
 function isProjectMutationRequest(method) {
-    return method === "POST";
+    return ["POST", "DELETE"].includes(method);
 }
 function acceptProjectRequest(request) {
     if (!isProjectMutationRequest(request.method))
@@ -64,7 +67,12 @@ export class ProjectRoutes {
     async dispatch(request, service) {
         const { method, segments, body, response } = request;
         if (method === "GET" && isProjectCollection(segments)) {
-            sendJson(response, 200, { ok: true, projects: await service.list() });
+            sendJson(response, 200, { ok: true, ...(await service.catalog()) });
+            return;
+        }
+        if (method === "DELETE" && isProjectDeletion(segments)) {
+            await service.delete(segments[1]);
+            sendJson(response, 200, { ok: true });
             return;
         }
         if (method === "POST" && isProjectCollection(segments)) {

package/dist/src/web-ui/local-runtime/request-execution.js

@@ -101,6 +101,7 @@ export class LocalRequestExecution {
             text,
             agentMode: body.agentMode,
             modelPreference: body.modelPreference,
+            reasoningPreference: body.reasoningPreference,
             toolPermissionMode: body.toolPermissionMode,
             attachments: Array.isArray(body.attachments) ? body.attachments : [],
         };

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

@@ -0,0 +1,2 @@
+export declare function resolveRuntimeSetupCredentialEnvironment(provider: string, savedProvider: unknown, apiKey?: string): string | undefined;
+export declare function requiresProviderCredential(provider: unknown): boolean;

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

@@ -0,0 +1,20 @@
+import { isolatedProviderCredentialName } from "./provider-credential-identity.js";
+import { isRecord } from "../../runtime/config/utils.js";
+export function resolveRuntimeSetupCredentialEnvironment(provider, savedProvider, apiKey) {
+    if (provider === "ollama")
+        return undefined;
+    if (isRecord(savedProvider) && typeof savedProvider.apiKeyEnv === "string")
+        return savedProvider.apiKeyEnv;
+    if (provider === "openai")
+        return "OPENAI_API_KEY";
+    if (provider === "llamacpp" && apiKey)
+        return isolatedProviderCredentialName(provider);
+    return undefined;
+}
+export function requiresProviderCredential(provider) {
+    if (!isRecord(provider))
+        return false;
+    if (provider.type === "openai")
+        return true;
+    return provider.type === "llamacpp" && typeof provider.apiKeyEnv === "string";
+}

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

@@ -1,3 +1,4 @@
+import { resolveRuntimeSetupCredentialEnvironment } from "./runtime-setup-auth.js";
 import { commitRuntimeSetupEdit } from "./runtime-setup-edit-transaction.js";
 import { withPlannedRuntimeSetupCredentials, } from "./runtime-setup-credentials.js";
 import { randomUUID } from "node:crypto";
@@ -32,7 +33,7 @@ export async function editRuntimeSetupConnection(params) {
             const models = setupConfigMap(source.config.models);
             const providers = setupConfigMap(models.providers);
             const providerId = params.input.provider;
-            const provider = buildProviderConfig(providerId, params.input.baseUrl);
+            const provider = buildProviderConfig(providerId, params.input.baseUrl, resolveRuntimeSetupCredentialEnvironment(providerId, providers[providerId], params.input.apiKey));
             const existing = providers[providerId];
             const owned = Object.hasOwn(params.draft.ownedProviders, providerId);
             preserveExistingProvider(existing, provider, owned);
@@ -48,7 +49,7 @@ export async function editRuntimeSetupConnection(params) {
                 params.draft.modelConfig.contextWindowTokens;
             const modelConfig = buildModelConfig(modelTemplate, providerId, params.input.model, typeof contextWindowTokens === "number"
                 ? contextWindowTokens
-                : undefined);
+                : undefined, params.input);
             const memory = setupConfigMap(source.config.longTermMemory);
             const retained = retainSetupConnectionProviders({
                 providers,

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

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import { readRuntimeSetupCredential } from "./runtime-setup-credentials.js";
 /** A revisionless retry can fill a missing credential, never edit its connection. */
 export function canCompleteMissingRuntimeSetupCredential(existing, input, rootDir) {
@@ -5,7 +6,7 @@ export function canCompleteMissingRuntimeSetupCredential(existing, input, rootDi
         return false;
     if (input.connectionRevision !== undefined)
         return false;
-    if (existing.provider !== "openai")
+    if (!existing.requiresApiKey)
         return false;
     if (input.provider !== existing.provider)
         return false;
@@ -14,6 +15,10 @@ export function canCompleteMissingRuntimeSetupCredential(existing, input, rootDi
     const requestedContext = input.contextWindowTokens ?? existing.contextWindowTokens;
     if (requestedContext !== existing.contextWindowTokens)
         return false;
+    if (input.supportsThinking !== undefined && input.supportsThinking !== existing.supportsThinking)
+        return false;
+    if (input.reasoningBudget !== undefined && !isDeepStrictEqual(input.reasoningBudget, existing.reasoningBudget))
+        return false;
     // Both projections already normalize addresses to origins.
     if ((existing.baseUrl ?? "") !== (input.baseUrl ?? ""))
         return false;

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

@@ -1,10 +1,11 @@
+import { type SetupModelOptions } from "../../../scripts/runtime-setup-model-options.js";
 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";
+export type RuntimeSetupInput = SetupModelOptions & Readonly<{
+    provider: "openai" | "ollama" | "llamacpp";
     model: string;
     contextWindowTokens?: number;
     baseUrl?: string;

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

@@ -1,4 +1,6 @@
 import { parseBaseUrl, parseContextWindowTokens, } from "../../../scripts/runtime-setup-files.js";
+import { parseSetupModelOptions } from "../../../scripts/runtime-setup-model-options.js";
+import { defaultProviderAddress, supportsProviderAddress } from "../../../scripts/runtime-setup-provider-options.js";
 export class RuntimeSetupError extends Error {
     code;
     statusCode;
@@ -42,10 +44,19 @@ export function parseRuntimeSetupInput(body) {
     catch {
         throw new RuntimeSetupError("invalid_context_window", "Context window must be a positive whole number of tokens.");
     }
+    let modelOptions;
+    try {
+        modelOptions = parseSetupModelOptions(body ?? {});
+    }
+    catch (error) {
+        throw new RuntimeSetupError("invalid_setup_reasoning", error.message);
+    }
     const provider = readSetupString(body?.provider);
-    if (provider !== "openai" && provider !== "ollama") {
-        throw new RuntimeSetupError("invalid_setup_provider", "Choose OpenAI or Ollama.");
+    if (provider !== "openai" && provider !== "ollama" && provider !== "llamacpp") {
+        throw new RuntimeSetupError("invalid_setup_provider", "Choose OpenAI, Ollama or llama.cpp.");
     }
+    if (modelOptions.reasoningBudget && provider !== "llamacpp")
+        throw new RuntimeSetupError("invalid_setup_reasoning", "A token reasoning budget requires llama.cpp.");
     const model = readSetupString(body?.model);
     if (!isUsableModelIdentifier(model)) {
         throw new RuntimeSetupError("invalid_setup_model", "Enter a model ID without spaces or control characters.");
@@ -59,18 +70,19 @@ export function parseRuntimeSetupInput(body) {
     }
     const requestedBaseUrl = readSetupString(body?.baseUrl);
     if (provider === "openai" && requestedBaseUrl) {
-        throw new RuntimeSetupError("unexpected_setup_base_url", "A custom address is available for Ollama.");
+        throw new RuntimeSetupError("unexpected_setup_base_url", "A custom address is available for Ollama or llama.cpp.");
     }
     let baseUrl;
-    if (provider === "ollama") {
+    if (supportsProviderAddress(provider)) {
         try {
-            baseUrl = parseBaseUrl(requestedBaseUrl || "http://127.0.0.1:11434");
+            baseUrl = parseBaseUrl(requestedBaseUrl || defaultProviderAddress(provider));
         }
         catch {
             throw new RuntimeSetupError("invalid_setup_base_url", "Enter an HTTP or HTTPS origin without a path or credentials.");
         }
     }
     return {
+        ...modelOptions,
         provider,
         model,
         ...(contextWindowTokens !== undefined ? { contextWindowTokens } : {}),

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

@@ -5,7 +5,10 @@ export declare function configuredSetupModel(source: InspectedRuntimeConfigFile)
     provider: string;
     model: string;
     contextWindowTokens: number | undefined;
-    apiKeyEnv: string;
+    supportsThinking: boolean | undefined;
+    reasoningBudget: import("../../shared/model-reasoning.js").ModelReasoningBudget | undefined;
+    requiresApiKey: boolean;
+    apiKeyEnv: string | undefined;
     baseUrl: string | undefined;
 } | undefined;
 export declare function requiresConfiguredCredential(source: InspectedRuntimeConfigFile, rootDir: string): boolean;