@abot-ai/runtime 1.9.0 → 2.0.0

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

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

@@ -1,3 +1,4 @@
+import { planNewLlamaEmbeddingProvider, commitLlamaEmbeddingProvider, } from "./setup-embedding-llamacpp.js";
 import { buildProviderConfig } from "../../../scripts/runtime-setup-files.js";
 import { createFileLongTermMemoryOnboardingConfigRepository } from "../../runtime/adapters/long-term-memory/onboarding-config-repository.js";
 import { isRecord } from "../../runtime/config/utils.js";
@@ -57,8 +58,10 @@ function requirePreservedProviderSettings(provider, input) {
     if (input.baseUrl && input.baseUrl !== provider.baseUrl) {
         throw new RuntimeSetupError("embedding_provider_conflict", "That provider already uses another address. Choose its saved connection or edit it in Settings.", 409);
     }
-    if (input.apiKey && provider.type !== "openai") {
-        throw new RuntimeSetupError("invalid_embedding_credential", "Only an OpenAI connection accepts an API key here.");
+    if (input.apiKey &&
+        provider.type !== "openai" &&
+        provider.type !== "llamacpp") {
+        throw new RuntimeSetupError("invalid_embedding_credential", "This connection does not support an API key.");
     }
 }
 /** Adds only the requested provider; chat profiles and existing provider settings stay intact. */
@@ -66,14 +69,19 @@ export async function prepareSetupEmbeddingProvider(options, input) {
     const repository = createFileLongTermMemoryOnboardingConfigRepository(options);
     const snapshot = await repository.read();
     const providers = readProviderMap(snapshot.config.models);
-    const providerId = resolveSetupEmbeddingProviderId(providers, input);
+    const llamaConnection = input.provider === "llamacpp"
+        ? planNewLlamaEmbeddingProvider(providers, input)
+        : undefined;
+    const providerId = llamaConnection?.providerId ??
+        resolveSetupEmbeddingProviderId(providers, input);
     const existing = providers[providerId];
     if (input.providerId && !isRecord(existing)) {
-        throw new RuntimeSetupError("embedding_provider_not_configured", "Choose a configured provider or add an OpenAI or Ollama connection.", 404);
+        throw new RuntimeSetupError("embedding_provider_not_configured", "Choose a configured provider or add an OpenAI, Ollama or llama.cpp connection.", 404);
     }
-    const provider = isRecord(existing)
-        ? existing
-        : buildProviderConfig(input.provider, input.baseUrl);
+    const provider = llamaConnection?.provider ??
+        (isRecord(existing)
+            ? existing
+            : buildProviderConfig(input.provider, input.baseUrl));
     const isolatedCredential = needsIsolatedEmbeddingCredential(existing, input, providerId);
     if (isolatedCredential)
         provider.apiKeyEnv = resolveIsolatedEmbeddingCredentialName(providers, providerId);
@@ -105,8 +113,14 @@ export async function prepareSetupEmbeddingProvider(options, input) {
             preserveExistingCredential: true,
         });
     }
-    if (!isRecord(existing))
-        await repository.write(candidate, snapshot.config);
+    const persistProvider = async () => {
+        if (!isRecord(existing))
+            await repository.write(candidate, snapshot.config);
+    };
+    if (provider.type === "llamacpp")
+        await commitLlamaEmbeddingProvider({ rootDir: options.rootDir, configPath: snapshot.path }, provider, input, persistProvider);
+    else
+        await persistProvider();
     return {
         providerId,
         savedProvider: { id: providerId, type: provider.type },

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

@@ -1,8 +1,12 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { SetupEmbeddingService } from "./setup-embedding-service.js";
+import type { LongTermMemoryOnboardingResult } from "../../runtime/long-term-memory/onboarding/contracts.js";
+type EmbeddingConnectionService = {
+    enable(body: Record<string, unknown>, signal: AbortSignal): Promise<Pick<LongTermMemoryOnboardingResult, "status" | "probe" | "restartRequired">>;
+};
 export declare class SetupEmbeddingRoutes {
     private readonly service;
-    constructor(service: SetupEmbeddingService);
+    private readonly route;
+    constructor(service: EmbeddingConnectionService, route?: string);
     handle(params: {
         method: string;
         route: string;
@@ -10,3 +14,4 @@ export declare class SetupEmbeddingRoutes {
         response: ServerResponse;
     }): Promise<boolean>;
 }
+export {};

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

@@ -2,14 +2,16 @@ import { assertConfigMutationRequest, ConfigMutationRequestError, } from "./conf
 import { readBody, readJsonBody, sendJson } from "./http.js";
 import { withHttpRequestAbortSignal } from "./request-abort.js";
 import { RuntimeSetupError } from "./runtime-setup-input.js";
-import { SetupEmbeddingFailure, } from "./setup-embedding-service.js";
+import { SetupEmbeddingFailure } from "./setup-embedding-service.js";
 export class SetupEmbeddingRoutes {
     service;
-    constructor(service) {
+    route;
+    constructor(service, route = "runtime/setup/embedding") {
         this.service = service;
+        this.route = route;
     }
     async handle(params) {
-        if (params.route !== "runtime/setup/embedding")
+        if (params.route !== this.route)
             return false;
         params.response.setHeader("cache-control", "no-store");
         try {

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

@@ -22,6 +22,7 @@ export declare class SetupEmbeddingService {
             providerId?: string;
             model?: string;
             providers: readonly import("../../runtime/index.js").LongTermMemoryOnboardingProvider[];
+            embeddingProfiles: readonly import("../../runtime/index.js").SavedMemoryEmbeddingProfile[];
         }>;
         probe: Readonly<{
             modelFingerprint: string;

package/docs/configuration.md

@@ -83,7 +83,7 @@ Provider configs should reference env var names:
 }
 ```
 
-Ollama and OpenAI adapters are included. A host may register another adapter
+Ollama, OpenAI and llama.cpp adapters are included. See [llama.cpp setup and reasoning budgets](llamacpp.md). A host may register another adapter
 through `@abot-ai/runtime/model-gateway`; its config uses that adapter's `type` and
 may place adapter-owned JSON-safe values under `settings`. Merely naming an
 unknown type never selects a fallback provider.
@@ -610,13 +610,15 @@ The common slots and their first tuning targets are:
 | Context compaction              | `context.compact`                                                                                                                                                     | Structured format and preservation of facts that later steps still require; physical capacity remains profile-owned.                                                                    |
 | Literal tool payloads           | `toolPayload.raw`                                                                                                                                                     | Literal-payload instructions and any intentional provider-native output controls. Verify the produced payload or artifact directly, not the model's description of it.                  |
 
-New OpenAI profiles created through CLI setup or Web onboarding set
-`calibration["context.compact"].timeoutMs` to `300000` (five minutes). This
-profile override takes precedence over the shared 180-second compaction
-default; other steps retain their own timeouts. An explicit template timeout
-is preserved, and existing profiles are not migrated automatically. To apply
-the same setting to an existing GPT profile, add `"timeoutMs": 300000` to its
-`calibration["context.compact"]` object. This does not change reasoning effort.
+New OpenAI profiles created through CLI setup, Web onboarding, or model
+addition set `timeoutMs` to `300000` (five minutes) in both
+`calibration["context.compact"]` and `calibration["toolPayload.raw"]`. These
+profile overrides take precedence over the shared 180-second compaction and
+90-second literal-payload defaults; other steps retain their own timeouts.
+Explicit template timeouts are preserved, and existing profiles are not
+migrated automatically. To apply these settings to an existing GPT profile,
+add `"timeoutMs": 300000` to each of those calibration objects, preserving
+their other fields. This does not change reasoning effort.
 
 `timeoutMs` addresses provider latency only; raising it does not improve model
 reasoning. Top-level `contextWindowTokens` declares the concrete model

package/docs/installation.md

@@ -13,6 +13,7 @@ This guide covers three entry points:
 - TypeScript-capable host project if using the library directly
 - Optional: an installed and running Ollama service for Ollama model profiles
 - Optional: OpenAI API key for OpenAI model profiles
+- Optional: a running llama.cpp server for [llama.cpp model profiles](llamacpp.md)
 
 ## Prepare Ollama (If Selected)
 
@@ -64,12 +65,15 @@ npx abot start
 
 Open [http://127.0.0.1:5177](http://127.0.0.1:5177). The command binds to
 loopback by default. On a fresh installation, the setup wizard lets you select
-OpenAI or Ollama, enter a concrete model ID, and save the connection. OpenAI
+OpenAI, Ollama or llama.cpp, enter a concrete model ID, and save the connection. OpenAI
 accepts the API key directly in the form and stores it privately in the
 consumer's `.env`. The key is not returned to the browser or stored in runtime
 JSON. Existing OpenAI configurations missing a key open the same completion flow.
 
-For Ollama, the server must already be running with the selected model available.
+For Ollama and llama.cpp, the server must already be running with the selected model available.
+Every provider's model registration includes an explicit thinking-support checkbox.
+llama.cpp additionally offers per-segment token budgets and a metadata-only
+connection check; see [llama.cpp setup](llamacpp.md).
 Its address is resolved from the ABot host, even when you use the UI from a phone.
 Continue through the optional **Embedding** step to configure semantic memory,
 or choose to set it up later. **Plugins** starts with all tools selected for a
@@ -93,7 +97,7 @@ managed by a separate process remains under that process's lifecycle; the UI
 reports when saved changes require that owner to restart.
 
 In the Web UI, open **Models → Add model** to add another model.
-Choose a saved provider connection or create a new OpenAI/Ollama connection.
+Choose a saved provider connection or create a new OpenAI/Ollama/llama.cpp connection.
 Each provider card also has an **Add model** shortcut. Review the model, then
 choose **Save and apply**. Saved API keys are reused; existing model profiles and
 the default model are preserved. The added model is selected in the Models list.
@@ -133,8 +137,10 @@ npx abot memory enable --provider <provider-id> --model <embedding-model-id>
 
 ABot does not install or choose the embedding model. The enable command performs
 a real probe, writes config only after it succeeds, and reports that the Runtime
-must be restarted. OpenAI users enter the embedding model id manually; Ollama
-users can discover model ids installed at the configured Ollama endpoint.
+must be restarted. OpenAI and llama.cpp users enter the embedding model id
+manually; Ollama users can discover model ids installed at the configured Ollama
+endpoint. For llama.cpp, use an embedding-enabled server and, if needed, a
+[separate connection from chat](llamacpp.md#embeddings-and-semantic-memory).
 
 See [Passive Long-Term Memory](long-term-memory.md) before enabling persistence.