@khanglvm/llm-router 2.3.0 → 2.3.2

package/src/node/web-console-server.js

@@ -17,7 +17,7 @@ import {
 } from "./local-server-settings.js";
 import { appendActivityLogEntry, clearActivityLogFile, createActivityLogEntry, readActivityLogEntries, resolveActivityLogPath } from "./activity-log.js";
 import { listListeningPids, reclaimPort } from "./port-reclaim.js";
-import { probeProvider, probeProviderEndpointMatrix } from "./provider-probe.js";
+import { probeProvider, probeProviderEndpointMatrix, probeFreeTierModels } from "./provider-probe.js";
 import { installStartup, startupStatus, stopStartup, uninstallStartup } from "./startup-manager.js";
 import { WEB_CONSOLE_CSS, renderWebConsoleHtml } from "./web-console-assets.js";
 import {
@@ -48,11 +48,28 @@ import {
   unpatchFactoryDroidSettingsFile
 } from "./coding-tool-config.js";
 import { loginSubscription } from "../runtime/subscription-provider.js";
+import {
+  ollamaCheckConnection,
+  ollamaListModels,
+  ollamaListRunning,
+  ollamaShowModel,
+  ollamaLoadModel,
+  ollamaUnloadModel,
+  ollamaPinModel,
+  ollamaSetKeepAlive,
+  ollamaPullModel,
+  ollamaDeleteModel
+} from "./ollama-client.js";
+import { estimateMaxContext, estimateModelVram, formatBytes } from "./ollama-hardware.js";
+import { detectOllamaInstallation, installOllama, startOllamaServer, stopOllamaServer, isOllamaRunning } from "./ollama-install.js";
 import {
   CONFIG_VERSION,
   DEFAULT_MODEL_ALIAS_ID,
   DEFAULT_PROVIDER_USER_AGENT,
+  OLLAMA_KEEP_ALIVE_PATTERN,
+  OLLAMA_PROVIDER_TYPE,
   configHasProvider,
+  normalizeOllamaConfig,
   normalizeRuntimeConfig,
   resolveProviderApiKey,
   validateRuntimeConfig
@@ -710,10 +727,11 @@ async function readConfigState(configPath) {
   if (!rawText.trim()) rawText = buildDefaultConfigRawText();
 
   let parseError = "";
+  let rawConfig = null;
   let normalizedConfig = null;
   try {
-    const parsed = rawText.trim() ? JSON.parse(rawText) : {};
-    normalizedConfig = normalizeRuntimeConfig(parsed, { migrateToVersion: CONFIG_VERSION });
+    rawConfig = rawText.trim() ? JSON.parse(rawText) : {};
+    normalizedConfig = normalizeRuntimeConfig(rawConfig, { migrateToVersion: CONFIG_VERSION });
   } catch (error) {
     parseError = error instanceof Error ? error.message : String(error);
   }
@@ -728,6 +746,7 @@ async function readConfigState(configPath) {
 
   return {
     rawText,
+    rawConfig,
     normalizedConfig,
     parseError,
     summary
@@ -1154,6 +1173,17 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     return normalizeClaudeBindingsInput(bindings);
   }
 
+  function normalizeFactoryDroidBindingState(bindings = {}) {
+    const source = bindings && typeof bindings === "object" && !Array.isArray(bindings) ? bindings : {};
+    return {
+      defaultModel: String(source.defaultModel || "").trim(),
+      missionOrchestratorModel: String(source.missionOrchestratorModel || source.missionModel || "").trim(),
+      missionWorkerModel: String(source.missionWorkerModel || source.missionModel || "").trim(),
+      missionValidatorModel: String(source.missionValidatorModel || source.missionModel || "").trim(),
+      reasoningEffort: normalizeFactoryDroidReasoningEffort(source.reasoningEffort)
+    };
+  }
+
   function areCodexBindingsEqual(left = {}, right = {}) {
     const normalizedLeft = normalizeCodexBindingState(left);
     const normalizedRight = normalizeCodexBindingState(right);
@@ -1174,6 +1204,18 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     );
   }
 
+  function areFactoryDroidBindingsEqual(left = {}, right = {}) {
+    const normalizedLeft = normalizeFactoryDroidBindingState(left);
+    const normalizedRight = normalizeFactoryDroidBindingState(right);
+    return (
+      normalizedLeft.defaultModel === normalizedRight.defaultModel
+      && normalizedLeft.missionOrchestratorModel === normalizedRight.missionOrchestratorModel
+      && normalizedLeft.missionWorkerModel === normalizedRight.missionWorkerModel
+      && normalizedLeft.missionValidatorModel === normalizedRight.missionValidatorModel
+      && normalizedLeft.reasoningEffort === normalizedRight.reasoningEffort
+    );
+  }
+
   function reconcileManagedRouteBinding(ref, rewriteContext) {
     return rewriteManagedRouteRef(ref, rewriteContext);
   }
@@ -1213,6 +1255,23 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     };
   }
 
+  function reconcileFactoryDroidBindingsForConfig(bindings = {}, previousConfig = {}, nextConfig = {}) {
+    const currentBindings = normalizeFactoryDroidBindingState(bindings);
+    const rewriteContext = buildManagedRouteRewriteContext(previousConfig, nextConfig);
+    const nextDefaultModel = reconcileManagedRouteBinding(currentBindings.defaultModel, rewriteContext)
+      || pickDefaultManagedRoute(nextConfig);
+    return {
+      defaultModel: nextDefaultModel,
+      missionOrchestratorModel: reconcileManagedRouteBinding(currentBindings.missionOrchestratorModel, rewriteContext)
+        || nextDefaultModel,
+      missionWorkerModel: reconcileManagedRouteBinding(currentBindings.missionWorkerModel, rewriteContext)
+        || nextDefaultModel,
+      missionValidatorModel: reconcileManagedRouteBinding(currentBindings.missionValidatorModel, rewriteContext)
+        || nextDefaultModel,
+      reasoningEffort: currentBindings.reasoningEffort
+    };
+  }
+
   async function readCodexCliGlobalRoutingState(settings = {}, config = null) {
     const endpointUrl = buildAmpClientEndpointUrl(settings);
     const apiKey = String(config?.masterKey || "").trim();
@@ -1445,8 +1504,12 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         backupExists: false,
         routedViaRouter: false,
         configuredBaseUrl: "",
+        configuredProvider: "",
         bindings: {
           defaultModel: "",
+          missionOrchestratorModel: "",
+          missionWorkerModel: "",
+          missionValidatorModel: "",
           reasoningEffort: ""
         },
         endpointUrl,
@@ -1471,8 +1534,6 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
       && (previousEndpointUrl !== nextEndpointUrl || previousMasterKey !== nextMasterKey)
     );
 
-    if (!endpointOrKeyChanged) return false;
-
     const routingState = await readFactoryDroidGlobalRoutingState(previousSettings, previousConfig);
     if (routingState.error) {
       addLog("warn", "Factory Droid route check failed.", routingState.error);
@@ -1481,13 +1542,22 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     if (!routingState.routedViaRouter) return false;
 
     try {
+      const currentBindings = normalizeFactoryDroidBindingState(routingState.bindings);
+      const bindings = reconcileFactoryDroidBindingsForConfig(currentBindings, previousConfig, nextConfig);
+      const bindingsChanged = !areFactoryDroidBindingsEqual(currentBindings, bindings);
+      if (!endpointOrKeyChanged && !bindingsChanged) return false;
+
       await patchFactoryDroidSettingsFile({
         endpointUrl: nextEndpointUrl,
         apiKey: nextMasterKey,
-        bindings: routingState.bindings,
+        bindings,
         captureBackup: false
       });
-      addLog("info", "Updated Factory Droid route to match the local router.", buildFactoryDroidEndpointUrl(nextSettings));
+      if (endpointOrKeyChanged) {
+        addLog("info", "Updated Factory Droid route to match the local router.", buildFactoryDroidEndpointUrl(nextSettings));
+      } else {
+        addLog("info", "Updated Factory Droid bindings to match the saved router config.", bindings.defaultModel || "Default");
+      }
       return true;
     } catch (error) {
       addLog("warn", "Factory Droid route update failed.", error instanceof Error ? error.message : String(error));
@@ -2081,6 +2151,19 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     const previousConfigState = await readConfigState(configPath);
     const previousConfig = previousConfigState.normalizedConfig || buildDefaultConfigObject();
     const previousLocalServer = getConfigLocalServer(previousConfigState);
+
+    // Safeguard: preserve existing top-level keys absent from the incoming config.
+    // This prevents partial writes (e.g. from scoped Ollama endpoints) from wiping
+    // unrelated config sections like masterKey, modelAliases, amp, metadata, etc.
+    const previousRaw = previousConfigState.rawConfig;
+    if (previousRaw && typeof previousRaw === "object" && parsed && typeof parsed === "object") {
+      for (const key of Object.keys(previousRaw)) {
+        if (!(key in parsed)) {
+          parsed[key] = previousRaw[key];
+        }
+      }
+    }
+
     ignoreConfigWatchUntil = Date.now() + 800;
     const savedConfig = await writeConfigFile(parsed, configPath, { migrateToVersion: CONFIG_VERSION });
     resolveActivityLogSnapshot(savedConfig);
@@ -2201,6 +2284,12 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     const claudeCodeGlobal = await readClaudeCodeGlobalRoutingState(configLocalServer, configState.normalizedConfig);
     const factoryDroidGlobal = await readFactoryDroidGlobalRoutingState(configLocalServer, configState.normalizedConfig);
     const webSearch = await readWebSearchState(configState.normalizedConfig).catch(() => null);
+    const ollamaConfig = configState.normalizedConfig?.ollama;
+    const ollamaBaseUrl = ollamaConfig?.baseUrl || "http://localhost:11434";
+    const ollamaInstallation = detectOllamaInstallation();
+    const ollamaState = ollamaInstallation.installed
+      ? await ollamaCheckConnection(ollamaBaseUrl).catch(() => ({ ok: false }))
+      : { ok: false };
 
     return {
       web: {
@@ -2231,6 +2320,14 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         claudeCode: claudeCodeGlobal,
         factoryDroid: factoryDroidGlobal
       },
+      ollama: {
+        installed: ollamaInstallation.installed,
+        connected: ollamaState.ok === true,
+        baseUrl: ollamaBaseUrl,
+        enabled: ollamaConfig?.enabled === true,
+        version: ollamaInstallation.version || null,
+        path: ollamaInstallation.path || null
+      },
       defaults: {
         providerUserAgent: DEFAULT_PROVIDER_USER_AGENT
       },
@@ -2489,6 +2586,8 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
           nextSettings: persistedLocalServer.savedSettings
         });
       }
+      // Non-blocking: preload Ollama models after router start
+      preloadOllamaModels(configState.normalizedConfig).catch(() => {});
       return {
         message: restart ? "Router restarted." : "Router started.",
         snapshot: await buildSnapshot()
@@ -2501,6 +2600,29 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     }
   }
 
+  async function preloadOllamaModels(config) {
+    const ollamaConfig = config?.ollama;
+    if (!ollamaConfig?.enabled) return;
+    const autoLoadModels = ollamaConfig.autoLoadModels || [];
+    if (!autoLoadModels.length) return;
+    const baseUrl = ollamaConfig.baseUrl || "http://localhost:11434";
+    const connected = await ollamaCheckConnection(baseUrl);
+    if (!connected.ok) {
+      addLog("info", "Ollama not reachable, skipping model preload.");
+      return;
+    }
+    for (const modelId of autoLoadModels) {
+      const keepAlive = ollamaConfig.managedModels?.[modelId]?.keepAlive
+        || ollamaConfig.defaultKeepAlive || "5m";
+      const result = await ollamaLoadModel(baseUrl, modelId, keepAlive).catch(() => ({ ok: false }));
+      if (result.ok) {
+        addLog("info", `Ollama: Preloaded ${modelId} (${Math.round(result.loadDurationMs || 0)}ms).`);
+      } else {
+        addLog("warn", `Ollama: Failed to preload ${modelId}.`);
+      }
+    }
+  }
+
   async function shutdown(reason = "web-console-closed") {
     if (closePromise) return closePromise;
     closing = true;
@@ -2812,6 +2934,31 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         return;
       }
 
+      if (method === "POST" && requestUrl.pathname === "/api/config/probe-free-tier-models") {
+        const body = await readJsonBody(req);
+        const baseUrl = String(body?.baseUrl || "").trim();
+        const apiKeyEnv = String(body?.apiKeyEnv || "").trim();
+        const apiKey = String(body?.apiKey || "").trim();
+        const modelIds = Array.isArray(body?.modelIds) ? body.modelIds.map((id) => String(id || "").trim()).filter(Boolean) : [];
+
+        if (!baseUrl || modelIds.length === 0) {
+          sendJson(res, 400, { error: "baseUrl and at least one modelId are required." });
+          return;
+        }
+
+        try {
+          const finalApiKey = await resolveProbeApiKey(apiKeyEnv, apiKey, { context: "probing free-tier models" });
+          addLog("info", "Probing free-tier model availability.", `${modelIds.length} model(s)`);
+          const result = await probeFreeTierModels({ baseUrl, apiKey: finalApiKey, modelIds, timeoutMs: 6000 });
+          const freeCount = Object.values(result).filter((r) => r?.freeTier === true).length;
+          addLog("success", "Free-tier probe finished.", `${freeCount}/${modelIds.length} model(s) on free tier`);
+          sendJson(res, 200, { result });
+        } catch (error) {
+          sendJson(res, error?.statusCode || 500, { error: error instanceof Error ? error.message : String(error) });
+        }
+        return;
+      }
+
       if (method === "POST" && requestUrl.pathname === "/api/config/litellm-context-lookup") {
         const body = await readJsonBody(req);
         const models = Array.isArray(body?.models) ? body.models.map((entry) => String(entry || "").trim()).filter(Boolean) : [];
@@ -3266,7 +3413,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         const body = await readJsonBody(req);
         const effortLevel = String(body?.effortLevel || body?.thinkingLevel || "").trim();
         if (effortLevel && !normalizeClaudeCodeEffortLevel(effortLevel)) {
-          sendJson(res, 400, { error: `Invalid effort level '${effortLevel}'. Valid values: low, medium, high, max.` });
+          sendJson(res, 400, { error: `Invalid effort level '${effortLevel}'. Valid values: low, medium, high, xhigh, max.` });
           return;
         }
         const result = await patchClaudeCodeEffortLevel({
@@ -3331,6 +3478,9 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
 
         const bindings = {
           defaultModel: String(body?.bindings?.defaultModel || "").trim(),
+          missionOrchestratorModel: String(body?.bindings?.missionOrchestratorModel || body?.bindings?.missionModel || "").trim(),
+          missionWorkerModel: String(body?.bindings?.missionWorkerModel || body?.bindings?.missionModel || "").trim(),
+          missionValidatorModel: String(body?.bindings?.missionValidatorModel || body?.bindings?.missionModel || "").trim(),
           reasoningEffort: normalizeFactoryDroidReasoningEffort(body?.bindings?.reasoningEffort)
         };
         const patchResult = await patchFactoryDroidSettingsFile({
@@ -3378,6 +3528,9 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
 
         const bindings = {
           defaultModel: String(body?.bindings?.defaultModel || "").trim(),
+          missionOrchestratorModel: String(body?.bindings?.missionOrchestratorModel || body?.bindings?.missionModel || "").trim(),
+          missionWorkerModel: String(body?.bindings?.missionWorkerModel || body?.bindings?.missionModel || "").trim(),
+          missionValidatorModel: String(body?.bindings?.missionValidatorModel || body?.bindings?.missionModel || "").trim(),
           reasoningEffort: normalizeFactoryDroidReasoningEffort(body?.bindings?.reasoningEffort)
         };
         const patchResult = await patchFactoryDroidSettingsFile({
@@ -3733,6 +3886,323 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         return;
       }
 
+      // ── Ollama API routes ──────────────────────────────────────────────
+      function resolveOllamaBaseUrl(bodyBaseUrl, configBaseUrl) {
+        const raw = String(bodyBaseUrl || configBaseUrl || "http://localhost:11434").trim().replace(/\/+$/, "");
+        try { const u = new URL(raw); if (u.protocol !== "http:" && u.protocol !== "https:") return null; if (u.hostname !== "localhost" && u.hostname !== "127.0.0.1" && u.hostname !== "::1" && !u.hostname.endsWith(".local")) return null; return u.origin; } catch { return null; }
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/status") {
+        const body = await readJsonBody(req);
+        const configState = await readConfigState(configPath);
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = resolveOllamaBaseUrl(body?.baseUrl, ollamaConfig.baseUrl);
+        if (!baseUrl) { sendJson(res, 400, { error: "Invalid Ollama base URL" }); return; }
+        const installation = detectOllamaInstallation();
+        const connection = installation.installed
+          ? await ollamaCheckConnection(baseUrl)
+          : { ok: false, error: "Ollama not installed" };
+        const running = connection.ok ? await ollamaListRunning(baseUrl) : { ok: false, models: [] };
+        sendJson(res, 200, {
+          installed: installation.installed,
+          version: installation.version,
+          path: installation.path,
+          connected: connection.ok,
+          running: running.models || [],
+          baseUrl
+        });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/models") {
+        const body = await readJsonBody(req);
+        const configState = await readConfigState(configPath);
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = resolveOllamaBaseUrl(body?.baseUrl, ollamaConfig.baseUrl);
+        if (!baseUrl) { sendJson(res, 400, { error: "Invalid Ollama base URL" }); return; }
+        const modelsResult = await ollamaListModels(baseUrl);
+        if (!modelsResult.ok) {
+          sendJson(res, 502, { error: modelsResult.error || "Failed to list Ollama models" });
+          return;
+        }
+        const runningResult = await ollamaListRunning(baseUrl);
+        const runningMap = new Map((runningResult.models || []).map((m) => [m.name, m]));
+        const ollamaProvider = (configState.normalizedConfig?.providers || []).find((p) => p.type === OLLAMA_PROVIDER_TYPE);
+        const routedModelIds = new Set((ollamaProvider?.models || []).map((m) => m.id));
+        const enriched = modelsResult.models.map((model) => {
+          const running = runningMap.get(model.name);
+          const managed = ollamaConfig.managedModels?.[model.name];
+          const hwEstimate = model.contextLength && model.parameterSize
+            ? estimateModelVram(model.parameterSize, model.quantizationLevel, model.contextLength)
+            : null;
+          return {
+            ...model,
+            loaded: !!running,
+            sizeVram: running?.sizeVram || 0,
+            sizeVramFormatted: running?.sizeVram ? formatBytes(running.sizeVram) : "",
+            expiresAt: running?.expiresAt || "",
+            isPinned: running?.isPinned || managed?.pinned || false,
+            processor: running?.processor || "",
+            keepAlive: managed?.keepAlive || ollamaConfig.defaultKeepAlive || "5m",
+            autoLoad: managed?.autoLoad || false,
+            inRouter: routedModelIds.has(model.name),
+            estimatedVram: hwEstimate ? formatBytes(hwEstimate.totalBytes) : "",
+            estimatedVramBytes: hwEstimate?.totalBytes || 0
+          };
+        });
+        sendJson(res, 200, { models: enriched });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/load") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        const configState = await readConfigState(configPath);
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = resolveOllamaBaseUrl(body?.baseUrl, ollamaConfig.baseUrl);
+        if (!baseUrl) { sendJson(res, 400, { error: "Invalid Ollama base URL" }); return; }
+        const keepAlive = body?.keepAlive || ollamaConfig.managedModels?.[model]?.keepAlive || ollamaConfig.defaultKeepAlive || "5m";
+        addLog("info", `Ollama: Loading ${model}…`);
+        const result = await ollamaLoadModel(baseUrl, model, keepAlive);
+        if (result.ok) addLog("success", `Ollama: Loaded ${model} (${Math.round(result.loadDurationMs || 0)}ms).`);
+        else addLog("warn", `Ollama: Failed to load ${model}.`, result.error || "");
+        sendJson(res, result.ok ? 200 : 502, result);
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/unload") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        const configState = await readConfigState(configPath);
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = resolveOllamaBaseUrl(body?.baseUrl, ollamaConfig.baseUrl);
+        if (!baseUrl) { sendJson(res, 400, { error: "Invalid Ollama base URL" }); return; }
+        addLog("info", `Ollama: Unloading ${model}…`);
+        const result = await ollamaUnloadModel(baseUrl, model);
+        if (result.ok) addLog("success", `Ollama: Unloaded ${model}.`);
+        sendJson(res, result.ok ? 200 : 502, result);
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/pin") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        const pinned = body?.pinned === true;
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = resolveOllamaBaseUrl(body?.baseUrl, ollamaConfig.baseUrl);
+        if (!baseUrl) { sendJson(res, 400, { error: "Invalid Ollama base URL" }); return; }
+        const pinResult = pinned
+          ? await ollamaPinModel(baseUrl, model)
+          : await ollamaSetKeepAlive(baseUrl, model, ollamaConfig.managedModels?.[model]?.keepAlive || ollamaConfig.defaultKeepAlive || "5m");
+        if (!pinResult.ok) { sendJson(res, 502, { error: pinResult.error || "Failed to update model pin state" }); return; }
+        const nextOllama = { ...(rawConfig.ollama || {}), managedModels: { ...(rawConfig.ollama?.managedModels || {}) } };
+        nextOllama.managedModels[model] = { ...(nextOllama.managedModels[model] || {}), pinned };
+        await writeAndBroadcastConfig({ ...rawConfig, ollama: nextOllama }, { source: "ollama-pin" });
+        sendJson(res, 200, { ok: true, pinned });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/keep-alive") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        const keepAlive = String(body?.keepAlive || "").trim();
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        if (!OLLAMA_KEEP_ALIVE_PATTERN.test(keepAlive)) { sendJson(res, 400, { error: "Invalid keep_alive value" }); return; }
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = resolveOllamaBaseUrl(body?.baseUrl, ollamaConfig.baseUrl);
+        if (!baseUrl) { sendJson(res, 400, { error: "Invalid Ollama base URL" }); return; }
+        const kaResult = await ollamaSetKeepAlive(baseUrl, model, keepAlive);
+        if (!kaResult.ok) { sendJson(res, 502, { error: kaResult.error || "Failed to update keep-alive" }); return; }
+        const nextOllama = { ...(rawConfig.ollama || {}), managedModels: { ...(rawConfig.ollama?.managedModels || {}) } };
+        nextOllama.managedModels[model] = { ...(nextOllama.managedModels[model] || {}), keepAlive };
+        await writeAndBroadcastConfig({ ...rawConfig, ollama: nextOllama }, { source: "ollama-keep-alive" });
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/sync-router") {
+        const body = await readJsonBody(req);
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = resolveOllamaBaseUrl(body?.baseUrl, ollamaConfig.baseUrl);
+        if (!baseUrl) { sendJson(res, 400, { error: "Invalid Ollama base URL" }); return; }
+        const modelsResult = await ollamaListModels(baseUrl);
+        if (!modelsResult.ok) { sendJson(res, 502, { error: modelsResult.error || "Failed to list Ollama models" }); return; }
+        const modelIds = modelsResult.models.map((m) => m.name);
+        const providers = [...(rawConfig.providers || [])];
+        let ollamaProvider = providers.find((p) => p.type === OLLAMA_PROVIDER_TYPE);
+        const previousModelIds = new Set((ollamaProvider?.models || []).map((m) => typeof m === "string" ? m : m?.id));
+        if (!ollamaProvider) {
+          ollamaProvider = { id: "ollama", name: "Ollama", type: OLLAMA_PROVIDER_TYPE, baseUrl: baseUrl + "/v1", models: [] };
+          providers.push(ollamaProvider);
+        }
+        ollamaProvider.baseUrl = baseUrl + "/v1";
+        ollamaProvider.models = modelIds.map((id) => {
+          const existing = (ollamaProvider.models || []).find((m) => (typeof m === "string" ? m : m?.id) === id);
+          if (existing && typeof existing === "object") return existing;
+          const details = modelsResult.models.find((m) => m.name === id);
+          return { id, contextWindow: details?.contextLength || undefined };
+        });
+        const nextConfig = { ...rawConfig, providers };
+        const { snapshot } = await writeAndBroadcastConfig(nextConfig, { source: "ollama-sync" });
+        const addedCount = modelIds.filter((id) => !previousModelIds.has(id)).length;
+        const removedCount = [...previousModelIds].filter((id) => !modelIds.includes(id)).length;
+        addLog("info", `Ollama: Synced ${modelIds.length} models (${addedCount} added, ${removedCount} removed).`);
+        sendJson(res, 200, { ok: true, modelCount: modelIds.length, addedCount, removedCount });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/add-model") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const ollamaConfig = configState.normalizedConfig?.ollama || {};
+        const baseUrl = (ollamaConfig.baseUrl || "http://localhost:11434").replace(/\/+$/, "");
+        const providers = [...(rawConfig.providers || [])];
+        let ollamaProvider = providers.find((p) => p.type === OLLAMA_PROVIDER_TYPE);
+        if (!ollamaProvider) {
+          ollamaProvider = { id: "ollama", name: "Ollama", type: OLLAMA_PROVIDER_TYPE, baseUrl: baseUrl + "/v1", models: [] };
+          providers.push(ollamaProvider);
+        }
+        const existing = (ollamaProvider.models || []).find((m) => (typeof m === "string" ? m : m?.id) === model);
+        if (existing) { sendJson(res, 200, { ok: true, added: false, reason: "already exists" }); return; }
+        const contextLength = body?.contextLength || undefined;
+        ollamaProvider.models = [...(ollamaProvider.models || []), { id: model, ...(contextLength ? { contextWindow: contextLength } : {}) }];
+        await writeAndBroadcastConfig({ ...rawConfig, providers }, { source: "ollama-add-model" });
+        addLog("info", `Ollama: Added ${model} to router.`);
+        sendJson(res, 200, { ok: true, added: true });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/remove-model") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const providers = [...(rawConfig.providers || [])];
+        const ollamaProvider = providers.find((p) => p.type === OLLAMA_PROVIDER_TYPE);
+        if (!ollamaProvider) { sendJson(res, 200, { ok: true, removed: false }); return; }
+        const before = (ollamaProvider.models || []).length;
+        ollamaProvider.models = (ollamaProvider.models || []).filter((m) => (typeof m === "string" ? m : m?.id) !== model);
+        const removed = ollamaProvider.models.length < before;
+        if (removed) {
+          await writeAndBroadcastConfig({ ...rawConfig, providers }, { source: "ollama-remove-model" });
+          addLog("info", `Ollama: Removed ${model} from router.`);
+        }
+        sendJson(res, 200, { ok: true, removed });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/save-settings") {
+        const body = await readJsonBody(req);
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const nextOllama = { ...(rawConfig.ollama || {}) };
+        if (body?.baseUrl !== undefined) nextOllama.baseUrl = String(body.baseUrl).trim();
+        if (body?.enabled !== undefined) nextOllama.enabled = body.enabled !== false;
+        if (body?.autoConnect !== undefined) nextOllama.autoConnect = body.autoConnect !== false;
+        if (body?.defaultKeepAlive !== undefined && OLLAMA_KEEP_ALIVE_PATTERN.test(String(body.defaultKeepAlive))) {
+          nextOllama.defaultKeepAlive = String(body.defaultKeepAlive);
+        }
+        await writeAndBroadcastConfig({ ...rawConfig, ollama: nextOllama }, { source: "ollama-settings" });
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/auto-load") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        const autoLoad = body?.autoLoad === true;
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const nextOllama = { ...(rawConfig.ollama || {}), managedModels: { ...(rawConfig.ollama?.managedModels || {}) } };
+        nextOllama.managedModels[model] = { ...(nextOllama.managedModels[model] || {}), autoLoad };
+        const autoLoadModels = Object.entries(nextOllama.managedModels)
+          .filter(([, v]) => v?.autoLoad).map(([k]) => k);
+        nextOllama.autoLoadModels = autoLoadModels;
+        await writeAndBroadcastConfig({ ...rawConfig, ollama: nextOllama }, { source: "ollama-auto-load" });
+        sendJson(res, 200, { ok: true, autoLoad });
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/install") {
+        const installation = detectOllamaInstallation();
+        if (installation.installed) {
+          sendJson(res, 200, { ok: true, alreadyInstalled: true, version: installation.version });
+          return;
+        }
+        addLog("info", "Ollama: Starting installation…");
+        const result = await installOllama({
+          onProgress: (event) => pushEvent("ollama-install-progress", event)
+        });
+        if (result.ok && !result.alreadyInstalled) {
+          addLog("success", `Ollama: Installed (${result.version || "unknown"}).`);
+          const started = await startOllamaServer();
+          sendJson(res, 200, { ...result, serverStarted: started.ok });
+          broadcastState();
+        } else if (result.ok) {
+          sendJson(res, 200, result);
+        } else {
+          addLog("error", "Ollama: Installation failed.", result.error || "");
+          sendJson(res, 500, result);
+        }
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/start-server") {
+        const result = await startOllamaServer();
+        if (result.ok) addLog("success", "Ollama: Server started.");
+        else addLog("warn", "Ollama: Failed to start server.", result.error || "");
+        sendJson(res, result.ok ? 200 : 502, result);
+        broadcastState();
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/stop-server") {
+        const result = stopOllamaServer();
+        if (result.ok) addLog("info", "Ollama: Server stopped.");
+        sendJson(res, 200, result);
+        broadcastState();
+        return;
+      }
+
+      if (method === "POST" && requestUrl.pathname === "/api/ollama/context-length") {
+        const body = await readJsonBody(req);
+        const model = String(body?.model || "").trim();
+        const contextLength = Number(body?.contextLength);
+        if (!model) { sendJson(res, 400, { error: "model is required" }); return; }
+        if (!Number.isFinite(contextLength) || contextLength <= 0) { sendJson(res, 400, { error: "contextLength must be a positive number" }); return; }
+        const configState = await readConfigState(configPath);
+        const rawConfig = configState.rawConfig || {};
+        const nextOllama = { ...(rawConfig.ollama || {}), managedModels: { ...(rawConfig.ollama?.managedModels || {}) } };
+        nextOllama.managedModels[model] = { ...(nextOllama.managedModels[model] || {}), contextLength: Math.round(contextLength) };
+        // Also update the provider model entry contextWindow
+        const providers = [...(rawConfig.providers || [])];
+        const ollamaProvider = providers.find((p) => p.type === OLLAMA_PROVIDER_TYPE);
+        if (ollamaProvider) {
+          ollamaProvider.models = (ollamaProvider.models || []).map((m) => {
+            const mid = typeof m === "string" ? m : m?.id;
+            if (mid === model) return { ...(typeof m === "object" ? m : { id: m }), contextWindow: Math.round(contextLength) };
+            return m;
+          });
+        }
+        await writeAndBroadcastConfig({ ...rawConfig, ollama: nextOllama, providers }, { source: "ollama-context-length" });
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
       if (method === "POST" && requestUrl.pathname === "/api/exit") {
         sendJson(res, 200, { ok: true, message: "Closing web console." });
         setTimeout(() => {