@abot-ai/runtime 1.8.1 → 2.0.0

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;

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

@@ -1,3 +1,4 @@
+import { requiresProviderCredential } from "./runtime-setup-auth.js";
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { buildRuntimeModelConfiguration } from "../../runtime/config/builders.js";
@@ -43,18 +44,21 @@ export function configuredSetupModel(source) {
     const provider = policy?.providers?.[profile.provider];
     if (!provider)
         return undefined;
-    const apiKeyEnv = provider.apiKeyEnv?.trim() || "OPENAI_API_KEY";
+    const apiKeyEnv = provider.apiKeyEnv?.trim() || (provider.type === "openai" ? "OPENAI_API_KEY" : undefined);
     return {
         provider: provider.type,
         model: profile.model,
         contextWindowTokens: profile.contextWindowTokens,
+        supportsThinking: profile.supportsThinking,
+        reasoningBudget: profile.generation?.reasoningBudget,
+        requiresApiKey: requiresProviderCredential(provider),
         apiKeyEnv,
         baseUrl: configuredSetupBaseUrl(provider.baseUrl),
     };
 }
 export function requiresConfiguredCredential(source, rootDir) {
     const model = configuredSetupModel(source);
-    if (model?.provider !== "openai")
+    if (!model?.requiresApiKey)
         return false;
     return !readRuntimeSetupCredential(rootDir, model.apiKeyEnv);
 }

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

@@ -4,17 +4,26 @@ export declare class RuntimeSetupRoutes {
     private readonly service;
     constructor(service: RuntimeSetupService);
     status(): Promise<{
-        providers: {
+        providers: ({
             id: string;
             label: string;
+            description: string;
             requiresApiKey: boolean;
             credentialConfigured: boolean;
-        }[];
+        } | {
+            id: string;
+            label: string;
+            requiresApiKey: boolean;
+            credentialConfigured: boolean;
+            description?: undefined;
+        })[];
         existingModel?: {
             baseUrl?: string | undefined;
             provider: string;
             model: string;
             contextWindowTokens: number | undefined;
+            supportsThinking: boolean | undefined;
+            reasoningBudget: import("../../shared/model-reasoning.js").ModelReasoningBudget | undefined;
         } | undefined;
         defaultContextWindowTokens: number;
         editableConnection?: {

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

@@ -1,3 +1,4 @@
+import { withHttpRequestAbortSignal } from "./request-abort.js";
 import { assertConfigMutationRequest, ConfigMutationRequestError, } from "./config-mutation-request.js";
 import { readBody, readJsonBody, sendJson } from "./http.js";
 import { RuntimeSetupError } from "./runtime-setup-input.js";
@@ -14,11 +15,11 @@ export class RuntimeSetupRoutes {
         return this.service.finalize(connectionRevision);
     }
     async handle(params) {
-        if (params.route !== "runtime/setup")
+        if (!["runtime/setup", "runtime/setup/connection"].includes(params.route))
             return false;
         params.response.setHeader("cache-control", "no-store");
         try {
-            if (params.method === "GET") {
+            if (params.method === "GET" && params.route === "runtime/setup") {
                 sendJson(params.response, 200, {
                     ok: true,
                     setup: await this.service.status(),
@@ -34,6 +35,14 @@ export class RuntimeSetupRoutes {
             }
             assertConfigMutationRequest(params.request);
             const body = readJsonBody(await readBody(params.request, { maxBytes: 16_384 }));
+            if (params.route === "runtime/setup/connection") {
+                const connection = await withHttpRequestAbortSignal({
+                    request: params.request, response: params.response, reason: "model_connection_inspection_aborted",
+                    run: (signal) => this.service.inspectConnection(body, signal),
+                });
+                sendJson(params.response, 200, { ok: true, connection });
+                return true;
+            }
             sendJson(params.response, 200, {
                 ok: true,
                 ...(await this.service.save(body)),

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

@@ -1,3 +1,4 @@
+import { resolveRuntimeSetupCredentialEnvironment } from "./runtime-setup-auth.js";
 import { createRuntimeSetupDraft, } from "./runtime-setup-draft.js";
 import { withConfigFileTransaction, readConfigFileSnapshot, } from "../../runtime/adapters/config-file-transaction.js";
 import { validateRuntimeSetupPlan } from "./runtime-setup-validation.js";
@@ -103,7 +104,7 @@ async function saveRuntimeSetupScaffold(params, transaction) {
     const configDirectory = dirname(params.configPath);
     const models = configMap(params.source.config.models);
     const providers = configMap(models.providers);
-    const provider = buildProviderConfig(params.input.provider, params.input.baseUrl);
+    const provider = buildProviderConfig(params.input.provider, params.input.baseUrl, resolveRuntimeSetupCredentialEnvironment(params.input.provider, providers[params.input.provider], params.input.apiKey));
     const ownedProviders = await recoverSetupProviderOwnership(params.source, params.recoveringDraft ? params.recoveryDraft : undefined, transaction.path);
     const existingProvider = providers[params.input.provider];
     requireCompatibleProvider(existingProvider, provider, Object.hasOwn(ownedProviders, params.input.provider));
@@ -134,7 +135,7 @@ async function saveRuntimeSetupScaffold(params, transaction) {
         ...runnerModels,
         defaults: { ...configMap(runnerModels.defaults), profileId: "default" },
     };
-    const modelConfig = buildModelConfig(modelTemplate, params.input.provider, params.input.model, params.input.contextWindowTokens);
+    const modelConfig = buildModelConfig(modelTemplate, params.input.provider, params.input.model, params.input.contextWindowTokens, params.input);
     const rebasedRunner = rebaseRunnerInstructions(runnerTemplate, (file) => relative(dirname(runnerPath), join(params.rootDir, file)));
     const runnerFiles = await planRunnerFile(runnerPath, rebasedRunner);
     const plannedFiles = [

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

@@ -11,17 +11,26 @@ export declare class RuntimeSetupService {
     constructor(options: RuntimeSetupServiceOptions);
     private source;
     status(): Promise<{
-        providers: {
+        providers: ({
             id: string;
             label: string;
+            description: string;
             requiresApiKey: boolean;
             credentialConfigured: boolean;
-        }[];
+        } | {
+            id: string;
+            label: string;
+            requiresApiKey: boolean;
+            credentialConfigured: boolean;
+            description?: undefined;
+        })[];
         existingModel?: {
             baseUrl?: string | undefined;
             provider: string;
             model: string;
             contextWindowTokens: number | undefined;
+            supportsThinking: boolean | undefined;
+            reasoningBudget: import("../../shared/model-reasoning.js").ModelReasoningBudget | undefined;
         } | undefined;
         defaultContextWindowTokens: number;
         editableConnection?: {
@@ -32,20 +41,32 @@ export declare class RuntimeSetupService {
         status: "required" | "ready";
         configExists: boolean;
     }>;
+    inspectConnection(body: Record<string, unknown>, signal: AbortSignal): Promise<{
+        models: readonly string[];
+    }>;
     finalize(connectionRevision?: string): Promise<boolean>;
     save(body: Record<string, unknown> | null): Promise<{
         setup: {
-            providers: {
+            providers: ({
+                id: string;
+                label: string;
+                description: string;
+                requiresApiKey: boolean;
+                credentialConfigured: boolean;
+            } | {
                 id: string;
                 label: string;
                 requiresApiKey: boolean;
                 credentialConfigured: boolean;
-            }[];
+                description?: undefined;
+            })[];
             existingModel?: {
                 baseUrl?: string | undefined;
                 provider: string;
                 model: string;
                 contextWindowTokens: number | undefined;
+                supportsThinking: boolean | undefined;
+                reasoningBudget: import("../../shared/model-reasoning.js").ModelReasoningBudget | undefined;
             } | undefined;
             defaultContextWindowTokens: number;
             editableConnection?: {

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

@@ -1,3 +1,5 @@
+import { inspectModelSetupConnection } from "./model-connection-inspection.js";
+import { resolveRuntimeSetupCredentialEnvironment } from "./runtime-setup-auth.js";
 import { requireRuntimeSetupEditSettled } from "./runtime-setup-edit-recovery.js";
 import { readDefaultContextWindowTokens } from "../../../scripts/runtime-setup-files.js";
 import { initializeConfiguredRuntimeDirectories } from "../../../scripts/runtime-setup-directories.js";
@@ -51,6 +53,8 @@ export class RuntimeSetupService {
                         provider: existingModel.provider,
                         model: existingModel.model,
                         contextWindowTokens: existingModel.contextWindowTokens,
+                        supportsThinking: existingModel.supportsThinking,
+                        reasoningBudget: existingModel.reasoningBudget,
                         ...(existingModel.baseUrl
                             ? { baseUrl: existingModel.baseUrl }
                             : {}),
@@ -58,6 +62,14 @@ export class RuntimeSetupService {
                 }
                 : {}),
             providers: [
+                {
+                    id: "llamacpp",
+                    label: "llama.cpp",
+                    description: "A separately running llama-server with token reasoning controls",
+                    requiresApiKey: existingModel?.provider === "llamacpp" && existingModel.requiresApiKey,
+                    credentialConfigured: existingModel?.provider === "llamacpp" && Boolean(existingModel.apiKeyEnv) &&
+                        await hasRuntimeSetupCredential(this.options.rootDir, existingModel.apiKeyEnv),
+                },
                 {
                     id: "ollama",
                     label: "Ollama",
@@ -68,11 +80,14 @@ export class RuntimeSetupService {
                     id: "openai",
                     label: "OpenAI",
                     requiresApiKey: true,
-                    credentialConfigured: await hasRuntimeSetupCredential(this.options.rootDir, existingModel?.apiKeyEnv),
+                    credentialConfigured: await hasRuntimeSetupCredential(this.options.rootDir, existingModel?.provider === "openai" ? existingModel.apiKeyEnv : undefined),
                 },
             ],
         };
     }
+    async inspectConnection(body, signal) {
+        return inspectModelSetupConnection({ rootDir: this.options.rootDir, configPath: this.source().path }, body, signal);
+    }
     async finalize(connectionRevision) {
         return withFileLock(join(this.options.rootDir, ".runtime-setup.lock"), async () => {
             const source = this.source();
@@ -117,16 +132,11 @@ export class RuntimeSetupService {
             }
             const requestedProviders = setupConfigMap(setupConfigMap(source.config.models).providers);
             const requestedProvider = setupConfigMap(requestedProviders[input.provider]);
-            let apiKeyEnv = existingModel?.apiKeyEnv;
-            if (editingDraft)
-                apiKeyEnv =
-                    typeof requestedProvider.apiKeyEnv === "string"
-                        ? requestedProvider.apiKeyEnv
-                        : undefined;
+            const apiKeyEnv = resolveRuntimeSetupCredentialEnvironment(input.provider, requestedProvider, input.apiKey);
             const hasCredential = input.apiKey ||
                 (await hasRuntimeSetupCredential(this.options.rootDir, apiKeyEnv));
-            if (input.provider === "openai" && !hasCredential) {
-                throw new RuntimeSetupError("setup_credential_required", "Enter your OpenAI API key to finish setup.");
+            if ((input.provider === "openai" || apiKeyEnv !== undefined) && !hasCredential) {
+                throw new RuntimeSetupError("setup_credential_required", "Enter the API key for this connection to finish setup.");
             }
             const configuredPath = this.options.getConfigPath();
             const shouldUseLocalConfig = !source.exists && !configuredPath;

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

@@ -1,6 +1,8 @@
 export type SetupEmbeddingInput = Readonly<{
     providerId?: string;
-    provider?: "openai" | "ollama";
+    provider?: "openai" | "ollama" | "llamacpp";
+    newProviderId?: string;
+    useApiKey?: boolean;
     model: string;
     baseUrl?: string;
     apiKey?: string;

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

@@ -15,7 +15,7 @@ function hasOneProviderSelection(providerId, provider) {
     return provider !== undefined;
 }
 function isSupportedProvider(provider) {
-    return provider === "openai" || provider === "ollama";
+    return (provider === "openai" || provider === "ollama" || provider === "llamacpp");
 }
 function isUsableModelIdentifier(model) {
     if (!model || model.length > 256)
@@ -30,7 +30,15 @@ function isSafeCredential(apiKey) {
     return !/[\u0000-\u0020\u007f'"`]/u.test(apiKey);
 }
 export function parseSetupEmbeddingInput(body) {
-    const allowed = ["providerId", "provider", "model", "baseUrl", "apiKey"];
+    const allowed = [
+        "providerId",
+        "provider",
+        "model",
+        "baseUrl",
+        "apiKey",
+        "newProviderId",
+        "useApiKey",
+    ];
     if (Object.keys(body).some((key) => !allowed.includes(key))) {
         throw new RuntimeSetupError("invalid_embedding_input", "The embedding update contains unsupported fields.");
     }
@@ -40,8 +48,9 @@ export function parseSetupEmbeddingInput(body) {
         throw new RuntimeSetupError("invalid_embedding_provider", "Choose one configured provider or one provider type.");
     }
     if (provider && !isSupportedProvider(provider)) {
-        throw new RuntimeSetupError("invalid_embedding_provider", "Choose OpenAI or Ollama when adding a provider.");
+        throw new RuntimeSetupError("invalid_embedding_provider", "Choose OpenAI, Ollama or llama.cpp when adding a provider.");
     }
+    const newConnection = parseNewLlamaEmbeddingConnection(body, provider);
     const model = optionalInputString(body, "model");
     if (!isUsableModelIdentifier(model)) {
         throw new RuntimeSetupError("invalid_embedding_model", "Enter a model ID without spaces or control characters.");
@@ -51,8 +60,8 @@ export function parseSetupEmbeddingInput(body) {
         throw new RuntimeSetupError("invalid_embedding_credential", "The API key contains unsupported characters.");
     }
     const address = optionalInputString(body, "baseUrl");
-    if (address && provider !== "ollama") {
-        throw new RuntimeSetupError("invalid_embedding_address", "An address can be supplied when adding an Ollama provider.");
+    if (address && provider !== "ollama" && provider !== "llamacpp") {
+        throw new RuntimeSetupError("invalid_embedding_address", "An address can be supplied when adding an Ollama or llama.cpp provider.");
     }
     let baseUrl;
     try {
@@ -63,9 +72,32 @@ export function parseSetupEmbeddingInput(body) {
     }
     return {
         ...(providerId ? { providerId } : {}),
-        ...(provider ? { provider: provider } : {}),
+        ...(provider
+            ? { provider: provider }
+            : {}),
+        ...newConnection,
         model,
         ...(baseUrl ? { baseUrl } : {}),
         ...(apiKey ? { apiKey } : {}),
     };
 }
+function parseNewLlamaEmbeddingConnection(body, provider) {
+    const newProviderId = optionalInputString(body, "newProviderId");
+    const useApiKey = body.useApiKey;
+    const hasConnectionIntent = newProviderId !== undefined || useApiKey !== undefined;
+    if (provider !== "llamacpp" && hasConnectionIntent)
+        throw new RuntimeSetupError("invalid_embedding_input", "New connection identity and authentication apply only to a new llama.cpp connection.");
+    if (provider !== "llamacpp")
+        return {};
+    const hasValidNewProviderId = typeof newProviderId === "string" &&
+        newProviderId.length <= 128 &&
+        /^[A-Za-z][A-Za-z0-9._-]*$/u.test(newProviderId) &&
+        !["__proto__", "prototype", "constructor"].includes(newProviderId);
+    if (!hasValidNewProviderId)
+        throw new RuntimeSetupError("invalid_embedding_provider", "Enter a connection ID starting with a letter and containing only letters, numbers, dots, underscores or hyphens.");
+    if (useApiKey !== undefined && typeof useApiKey !== "boolean")
+        throw new RuntimeSetupError("invalid_embedding_input", "The API key choice must be true or false.");
+    if (useApiKey === false && body.apiKey !== undefined)
+        throw new RuntimeSetupError("invalid_embedding_credential", "The API key conflicts with the no-authentication choice.");
+    return { newProviderId, ...(useApiKey !== undefined ? { useApiKey } : {}) };
+}

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

@@ -0,0 +1,11 @@
+import type { SetupEmbeddingInput } from "./setup-embedding-input.js";
+/** A new embedding server has its own explicit, replayable connection identity. */
+export declare function planNewLlamaEmbeddingProvider(providers: Record<string, unknown>, input: SetupEmbeddingInput): {
+    providerId: string;
+    provider: Record<string, unknown>;
+};
+/** A saved llama.cpp connection keeps its existing optional authentication binding. */
+export declare function commitLlamaEmbeddingProvider(options: {
+    rootDir: string;
+    configPath: string;
+}, provider: Record<string, unknown>, input: SetupEmbeddingInput, commit: () => Promise<unknown>): Promise<void>;

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

@@ -0,0 +1,53 @@
+import { buildProviderConfig } from "../../../scripts/runtime-setup-files.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { hasProviderCredentialBinding, isolatedProviderCredentialName, } from "./provider-credential-identity.js";
+import { requiresProviderCredential } from "./runtime-setup-auth.js";
+import { assertRuntimeSetupCredentialFile, hasRuntimeSetupCredential, commitRuntimeSetupCredentials, } from "./runtime-setup-credentials.js";
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+/** A new embedding server has its own explicit, replayable connection identity. */
+export function planNewLlamaEmbeddingProvider(providers, input) {
+    const providerId = input.newProviderId;
+    const useApiKey = input.useApiKey === true || Boolean(input.apiKey);
+    const apiKeyEnv = useApiKey
+        ? isolatedProviderCredentialName(providerId)
+        : undefined;
+    const provider = buildProviderConfig("llamacpp", input.baseUrl, apiKeyEnv);
+    const existing = providers[providerId];
+    if (existing !== undefined) {
+        requireMatchingLlamaEmbeddingConnection(existing, provider);
+        return { providerId, provider: existing };
+    }
+    if (apiKeyEnv && hasProviderCredentialBinding(providers, apiKeyEnv))
+        throw new RuntimeSetupError("embedding_credential_conflict", "This connection's credential name is already used by another provider. Choose another connection ID.", 409);
+    return { providerId, provider };
+}
+function requireMatchingLlamaEmbeddingConnection(existing, requested) {
+    if (isRecord(existing) &&
+        existing.type === requested.type &&
+        existing.baseUrl === requested.baseUrl &&
+        existing.apiKeyEnv === requested.apiKeyEnv)
+        return;
+    throw new RuntimeSetupError("embedding_provider_conflict", "That connection ID already has different settings. Choose its saved connection or use another ID. Existing settings were preserved.", 409);
+}
+/** A saved llama.cpp connection keeps its existing optional authentication binding. */
+export async function commitLlamaEmbeddingProvider(options, provider, input, commit) {
+    if (!requiresProviderCredential(provider)) {
+        if (input.apiKey)
+            throw new RuntimeSetupError("invalid_embedding_credential", "This saved connection has no API key binding. Add a separate connection to use authentication.");
+        await commit();
+        return;
+    }
+    const apiKeyEnv = provider.apiKeyEnv;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(apiKeyEnv))
+        throw new RuntimeSetupError("invalid_embedding_credential_environment", "The configured credential environment name is invalid. Its settings were preserved.");
+    await assertRuntimeSetupCredentialFile(options.rootDir);
+    if (!input.apiKey &&
+        !(await hasRuntimeSetupCredential(options.rootDir, apiKeyEnv)))
+        throw new RuntimeSetupError("embedding_credential_required", "Enter the API key for this llama.cpp connection.");
+    await commitRuntimeSetupCredentials({
+        ...options,
+        apiKeyEnv,
+        apiKey: input.apiKey,
+        preserveExistingCredential: true,
+    }, commit);
+}