kiku-agent 1.3.2 → 1.3.4

package/server/web-chat/routes/engineRoute.js

@@ -0,0 +1,270 @@
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+import { isTrustedRequest } from '../core/urlGuard.js';
+import {
+  getPersistedModelLoadSettings,
+  savePersistedModelLoadSettings,
+  getActiveLocalEngine,
+  setActiveLocalEngine,
+  withSettingsWriteQueue,
+} from '../../agent/config.js';
+import {
+  checkEngineCompatibility,
+  getEnginesHealth,
+  loadModelOnEngine,
+  unloadModelFromEngine,
+  stopEngine,
+} from '../../agent/engineService.js';
+import { clearLmStudioProbeCache, probeLmStudioRuntime } from '../../agent/lmStudioWakeup.js';
+import { ensureModelContextFollow, parseAutoContextFlag } from '../../agent/autoContext.js';
+
+export async function handleEngineStatusRoute(req, res) {
+  try {
+    const health = await getEnginesHealth();
+    sendJson(res, 200, {
+      status: 'ok',
+      activeEngine: getActiveLocalEngine(),
+      ...health,
+      modelLoad: getPersistedModelLoadSettings(),
+    });
+  } catch (err) {
+    sendError(res, 500, `Failed to retrieve engine status: ${err.message}`);
+  }
+}
+
+export async function handleEngineLoadRoute(req, res) {
+  if (!isTrustedRequest(req)) {
+    return sendError(res, 403, 'Engine model loading requires local access');
+  }
+
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+
+  const engine = String(body.engine || getActiveLocalEngine() || 'lms').toLowerCase().trim();
+  const compat = checkEngineCompatibility(engine);
+  if (!compat.supported) {
+    return sendJson(res, 200, {
+      status: 'error',
+      engine,
+      message: compat.reason,
+      compatibility: compat,
+    });
+  }
+
+  const model = typeof body.model === 'string' && body.model.trim()
+    ? body.model.trim()
+    : (engine === 'vllm' ? 'google/gemma-4-e4b' : 'google/gemma-4-e4b');
+
+  if (!/^[A-Za-z0-9._\-/: ]{1,200}$/.test(model)) {
+    return sendError(res, 400, `Invalid model id "${model.slice(0, 50)}"`);
+  }
+
+  
+  const persistUpdate = { activeEngine: engine };
+  if (engine === 'lms') {
+    const gpu = body.gpuOffload !== undefined ? body.gpuOffload : (body.nGpuLayers !== undefined ? body.nGpuLayers : undefined);
+    const threads = body.cpuThreads !== undefined ? body.cpuThreads : (body.threads !== undefined ? body.threads : undefined);
+    const ctx = body.contextLength !== undefined ? Number(body.contextLength) : undefined;
+    if (gpu !== undefined) persistUpdate.gpuOffload = gpu;
+    if (threads !== undefined) persistUpdate.cpuThreads = threads;
+    if (ctx !== undefined) persistUpdate.contextLength = ctx;
+    if (body.splitMode !== undefined) persistUpdate.splitMode = body.splitMode;
+    if (body.tensorSplit !== undefined) persistUpdate.tensorSplit = body.tensorSplit;
+    if (body.mainGpu !== undefined) persistUpdate.mainGpu = body.mainGpu;
+    if (body.flashAttn !== undefined) persistUpdate.flashAttn = body.flashAttn;
+    if (body.batchSize !== undefined) persistUpdate.batchSize = body.batchSize;
+    if (body.ubatchSize !== undefined) persistUpdate.ubatchSize = body.ubatchSize;
+    if (body.kvCacheDtype !== undefined) persistUpdate.kvCacheDtype = body.kvCacheDtype;
+    if (body.htMode !== undefined) persistUpdate.htMode = body.htMode;
+    if (body.hyperThreadingMode !== undefined) persistUpdate.htMode = body.hyperThreadingMode;
+  } else if (engine === 'vllm') {
+    persistUpdate.vllm = {};
+    if (body.gpuMemoryUtilization !== undefined) persistUpdate.vllm.gpuMemoryUtilization = Number(body.gpuMemoryUtilization);
+    if (body.maxModelLen !== undefined) persistUpdate.vllm.maxModelLen = body.maxModelLen;
+    if (body.tensorParallelSize !== undefined) persistUpdate.vllm.tensorParallelSize = Number(body.tensorParallelSize);
+    if (body.dtype !== undefined) persistUpdate.vllm.dtype = body.dtype;
+    if (body.enforceEager !== undefined) persistUpdate.vllm.enforceEager = Boolean(body.enforceEager);
+    if (body.kvCacheDtype !== undefined) persistUpdate.vllm.kvCacheDtype = body.kvCacheDtype;
+  }
+
+  await withSettingsWriteQueue(() => savePersistedModelLoadSettings(persistUpdate));
+  const currentSettings = getPersistedModelLoadSettings();
+
+  const autoFollow = engine === 'lms'
+    && parseAutoContextFlag(body.autoContext, currentSettings.autoContext ?? true);
+
+  try {
+    clearLmStudioProbeCache();
+
+    if (autoFollow) {
+      const resolvedGpu = body.gpuOffload !== undefined ? body.gpuOffload : currentSettings.gpuOffload;
+      const resolvedThreads = body.cpuThreads !== undefined ? body.cpuThreads : currentSettings.cpuThreads;
+      const resolvedCtx = body.contextLength !== undefined ? body.contextLength : currentSettings.contextLength;
+      const follow = await ensureModelContextFollow({
+        model,
+        requestedContext: resolvedCtx,
+        probeFn: () => probeLmStudioRuntime('http://127.0.0.1:1234/v1', { timeoutMs: 2000, bypassCache: true }),
+        loadFn: ({ contextLength }) => loadModelOnEngine(engine, model, {
+          ...body,
+          quiet: true,
+          gpuOffload: resolvedGpu,
+          cpuThreads: resolvedThreads,
+          htMode: body.htMode !== undefined ? body.htMode : currentSettings.htMode,
+          contextLength: contextLength ?? resolvedCtx,
+        }),
+        unloadFn: () => unloadModelFromEngine('lms', model),
+      });
+
+      if (!follow.ok) {
+        return sendJson(res, 200, {
+          status: 'error',
+          engine,
+          message: follow.reason || `Failed to load model on ${compat.name}`,
+          compatibility: compat,
+          followApplied: false,
+          followReason: follow.followReason || null,
+        });
+      }
+
+      const finalCtx = follow.loadedContextLength || follow.followContext || null;
+      if (finalCtx) {
+        await withSettingsWriteQueue(() => savePersistedModelLoadSettings({ contextLength: finalCtx }));
+      }
+      const refreshedSettings = getPersistedModelLoadSettings();
+      return sendJson(res, 200, {
+        status: 'ok',
+        engine,
+        message: follow.reloadedForFollow
+          ? `Model "${model}" reloaded with context ${Number(finalCtx).toLocaleString()} (model max ${follow.modelMaxContextLength ? Number(follow.modelMaxContextLength).toLocaleString() : 'unknown'})`
+          : `${compat.name} is online and model is loaded`,
+        awakened: Boolean(follow.performedLoad),
+        modelLoaded: true,
+        loadedModel: model,
+        loadedContextLength: follow.loadedContextLength || null,
+        modelMaxContextLength: follow.modelMaxContextLength || null,
+        followContext: follow.followContext || null,
+        followZone: follow.followZone || null,
+        followApplied: true,
+        followReason: follow.followReason || null,
+        compatibility: compat,
+        modelLoad: refreshedSettings,
+      });
+    }
+
+    const result = await loadModelOnEngine(engine, model, {
+      ...body,
+      quiet: true,
+      gpuOffload: body.gpuOffload !== undefined ? body.gpuOffload : currentSettings.gpuOffload,
+      cpuThreads: body.cpuThreads !== undefined ? body.cpuThreads : currentSettings.cpuThreads,
+      htMode: body.htMode !== undefined ? body.htMode : currentSettings.htMode,
+      contextLength: body.contextLength !== undefined ? body.contextLength : currentSettings.contextLength,
+      gpuMemoryUtilization: body.gpuMemoryUtilization !== undefined ? body.gpuMemoryUtilization : currentSettings.vllm.gpuMemoryUtilization,
+      maxModelLen: body.maxModelLen !== undefined ? body.maxModelLen : currentSettings.vllm.maxModelLen,
+      tensorParallelSize: body.tensorParallelSize !== undefined ? body.tensorParallelSize : currentSettings.vllm.tensorParallelSize,
+      dtype: body.dtype !== undefined ? body.dtype : currentSettings.vllm.dtype,
+      enforceEager: body.enforceEager !== undefined ? body.enforceEager : currentSettings.vllm.enforceEager,
+      kvCacheDtype: body.kvCacheDtype !== undefined ? body.kvCacheDtype : currentSettings.vllm.kvCacheDtype,
+    });
+
+    if (!result.ok) {
+      return sendJson(res, 200, {
+        status: 'error',
+        engine,
+        message: result.reason || `Failed to load model on ${compat.name}`,
+        compatibility: compat,
+      });
+    }
+
+    const stateProbe = engine === 'lms'
+      ? await probeLmStudioRuntime('http://127.0.0.1:1234/v1', { timeoutMs: 2000, bypassCache: true }).catch(() => null)
+      : null;
+    sendJson(res, 200, {
+      status: 'ok',
+      engine,
+      message: result.awakened
+        ? `Model "${model}" successfully loaded on ${compat.name}`
+        : `${compat.name} is online and model is loaded`,
+      awakened: Boolean(result.awakened),
+      modelLoaded: Boolean(result.modelLoaded),
+      loadedModel: result.loadedModel || model,
+      loadedContextLength: stateProbe?.loadedContextLength || null,
+      modelMaxContextLength: stateProbe?.modelMaxContextLength || null,
+      followContext: null,
+      followApplied: false,
+      followReason: 'auto-follow-disabled',
+      compatibility: compat,
+      modelLoad: currentSettings,
+    });
+  } catch (err) {
+    sendError(res, 500, `Engine load failed: ${err.message}`);
+  }
+}
+
+export async function handleEngineSettingsRoute(req, res) {
+  if (req.method === 'GET') {
+    return sendJson(res, 200, {
+      status: 'ok',
+      activeEngine: getActiveLocalEngine(),
+      modelLoad: getPersistedModelLoadSettings(),
+    });
+  }
+
+  if (!isTrustedRequest(req)) {
+    return sendError(res, 403, 'Changing engine settings requires local access');
+  }
+
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+
+  const saved = await withSettingsWriteQueue(() => savePersistedModelLoadSettings(body));
+  sendJson(res, 200, {
+    status: 'ok',
+    activeEngine: getActiveLocalEngine(),
+    modelLoad: saved,
+  });
+}
+
+export async function handleEngineStopRoute(req, res) {
+  if (!isTrustedRequest(req)) {
+    return sendError(res, 403, 'Stopping engine requires local access');
+  }
+
+  let body = {};
+  try {
+    body = await parseJsonBody(req);
+  } catch {}
+
+  const engine = String(body.engine || getActiveLocalEngine() || 'vllm').toLowerCase().trim();
+  const stopRes = await stopEngine(engine, body);
+  sendJson(res, 200, {
+    status: 'ok',
+    ...stopRes,
+  });
+}
+
+export async function handleEngineUnloadRoute(req, res) {
+  if (!isTrustedRequest(req)) {
+    return sendError(res, 403, 'Unloading engine model requires local access');
+  }
+
+  let body = {};
+  try {
+    body = await parseJsonBody(req);
+  } catch {}
+
+  const engine = String(body.engine || getActiveLocalEngine() || 'lms').toLowerCase().trim();
+  const model = body.model || null;
+  const unloadRes = await unloadModelFromEngine(engine, model, body);
+  sendJson(res, 200, {
+    status: unloadRes.ok ? 'ok' : 'error',
+    ...unloadRes,
+  });
+}
+

package/server/web-chat/routes/exportRoute.js

@@ -36,7 +36,7 @@ export async function handleExportRoute(req, res) {
       const escaped = String(m.text || m.content || '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
       return `<div style="margin:12px 0;padding:12px;border-radius:8px;background:${m.role === 'user' ? '#e3f2fd' : '#fce4ec'}"><strong>${role}:</strong><br><pre style="white-space:pre-wrap;margin:4px 0 0;font-family:inherit">${escaped}</pre></div>`;
     }).join('\n');
-    const html = `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Kiku Chat Export</title><style>body{font-family:sans-serif;max-width:800px;margin:40px auto;padding:0 20px}h1{color:#e91e63}</style></head><body><h1>🌸 Kiku AI Chat Export</h1><p>Session: ${normSessionId || 'N/A'} | Exported: ${new Date().toLocaleString()}</p><hr>${msgHtml}</body></html>`;
+    const html = `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Kiku Chat Export</title><link rel="stylesheet" href="/fonts/google-sans-official.css"><style>body{font-family:'Google Sans', 'Google Sans Text', 'Product Sans', 'Noto Sans Thai', 'Noto Sans SC', sans-serif;max-width:800px;margin:40px auto;padding:0 20px}h1{color:#e91e63}</style></head><body><h1>🌸 Kiku AI Chat Export</h1><p>Session: ${normSessionId || 'N/A'} | Exported: ${new Date().toLocaleString()}</p><hr>${msgHtml}</body></html>`;
     res.writeHead(200, {
       'Content-Type': 'text/html; charset=utf-8',
       'Content-Disposition': `attachment; filename="${filename}.html"`

package/server/web-chat/routes/lanDiscoveryRoute.js

@@ -1,5 +1,5 @@
 import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
-import { scanLan, mapServerTypeToProvider } from '../../agent/lanDiscovery.js';
+import { scanLan, mapServerTypeToProvider, listLanInterfaces } from '../../agent/lanDiscovery.js';
 import { isPrivateIPv4 } from '../../agent/sanitizer.js';
 import { resolveClientIp, isWebChatAdmin } from '../core/security.js';
 import {
@@ -25,9 +25,12 @@ export async function handleLanDiscoveryRoute(req, res) {
     const urlObj = new URL(req.url, 'http://localhost');
     const subnetsParam = urlObj.searchParams.get('subnets');
     const portsParam = urlObj.searchParams.get('ports');
+    const ifaceParam = urlObj.searchParams.get('iface');
     const options = {};
     if (subnetsParam && subnetsParam.trim()) {
       options.subnets = subnetsParam.split(',').map(s => s.trim()).filter(Boolean);
+    } else if (ifaceParam && ifaceParam.trim()) {
+      options.iface = ifaceParam.trim();
     }
     if (portsParam && portsParam.trim()) {
       options.ports = portsParam.split(',').map(Number).filter(p => Number.isInteger(p) && p >= 1 && p <= 65535);
@@ -39,6 +42,18 @@ export async function handleLanDiscoveryRoute(req, res) {
   }
 }
 
+export async function handleLanInterfacesRoute(req, res) {
+  if (!lanDiscoveryAllowed(req)) {
+    return sendError(res, 403, 'LAN discovery is restricted to the local machine. Set KIKU_ALLOW_REMOTE_LAN_DISCOVERY=true to allow other devices.');
+  }
+  try {
+    const interfaces = await listLanInterfaces({});
+    sendJson(res, 200, { status: 'ok', count: interfaces.length, interfaces });
+  } catch (err) {
+    sendError(res, 500, `Failed to enumerate network interfaces: ${err.message}`);
+  }
+}
+
 export async function handleLanApplyRoute(req, res) {
   if (!lanDiscoveryAllowed(req)) {
     return sendError(res, 403, 'LAN discovery is restricted to the local machine. Set KIKU_ALLOW_REMOTE_LAN_DISCOVERY=true to allow other devices.');
@@ -74,7 +89,7 @@ export async function handleLanApplyRoute(req, res) {
 
   if (currentAgent?.client) {
     try {
-      currentAgent.client.switchProvider(provider, { model: model || undefined, baseUrl });
+      await currentAgent.client.switchProvider(provider, { model: model || undefined, baseUrl });
       setCurrentAgent(currentAgent);
     } catch {}
   }

package/server/web-chat/routes/lmStudioLoadRoute.js

@@ -0,0 +1,172 @@
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+import { isTrustedRequest } from '../core/urlGuard.js';
+import {
+  getPersistedModelLoadSettings,
+  savePersistedModelLoadSettings,
+  withSettingsWriteQueue,
+} from '../../agent/config.js';
+import {
+  wakeUpLmStudio,
+  probeLmStudioRuntime,
+  clearLmStudioProbeCache,
+} from '../../agent/lmStudioWakeup.js';
+import { unloadModelFromEngine } from '../../agent/engineService.js';
+import { ensureModelContextFollow, parseAutoContextFlag } from '../../agent/autoContext.js';
+
+export async function handleLmStudioLoadRoute(req, res) {
+  if (!isTrustedRequest(req)) {
+    return sendError(res, 403, 'LM Studio model loading requires local access');
+  }
+
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+
+  const model = typeof body.model === 'string' && body.model.trim()
+    ? body.model.trim() : 'google/gemma-4-e4b';
+  if (!/^[A-Za-z0-9._\-/: ]{1,200}$/.test(model)) {
+    return sendError(res, 400, `Invalid model id "${model.slice(0, 50)}"`);
+  }
+
+  const gpuOffload = body.gpuOffload !== undefined ? body.gpuOffload : (body.nGpuLayers !== undefined ? body.nGpuLayers : undefined);
+  const cpuThreads = body.cpuThreads !== undefined ? body.cpuThreads : (body.threads !== undefined ? body.threads : undefined);
+  const contextLength = body.contextLength !== undefined ? Number(body.contextLength) : undefined;
+
+  const persist = {};
+  if (gpuOffload !== undefined) persist.gpuOffload = gpuOffload;
+  if (cpuThreads !== undefined) persist.cpuThreads = cpuThreads;
+  if (contextLength !== undefined) persist.contextLength = contextLength;
+  if (body.splitMode !== undefined) persist.splitMode = body.splitMode;
+  if (body.tensorSplit !== undefined) persist.tensorSplit = body.tensorSplit;
+  if (body.mainGpu !== undefined) persist.mainGpu = body.mainGpu;
+  if (body.flashAttn !== undefined) persist.flashAttn = body.flashAttn;
+  if (body.batchSize !== undefined) persist.batchSize = body.batchSize;
+  if (body.ubatchSize !== undefined) persist.ubatchSize = body.ubatchSize;
+  if (body.kvCacheDtype !== undefined) persist.kvCacheDtype = body.kvCacheDtype;
+  if (Object.keys(persist).length > 0) {
+    await withSettingsWriteQueue(() => savePersistedModelLoadSettings(persist));
+  }
+
+  const loadSettings = getPersistedModelLoadSettings();
+  const autoFollow = parseAutoContextFlag(body.autoContext, loadSettings.autoContext ?? true);
+
+  try {
+    clearLmStudioProbeCache();
+
+    if (autoFollow) {
+      const resolvedGpu = gpuOffload !== undefined ? gpuOffload : loadSettings.gpuOffload;
+      const resolvedThreads = cpuThreads !== undefined ? cpuThreads : loadSettings.cpuThreads;
+      const resolvedCtx = contextLength !== undefined ? contextLength : loadSettings.contextLength;
+      const follow = await ensureModelContextFollow({
+        model,
+        requestedContext: resolvedCtx,
+        probeFn: () => probeLmStudioRuntime('http://127.0.0.1:1234/v1', { timeoutMs: 2000, bypassCache: true }),
+        loadFn: ({ contextLength: followCtx }) => wakeUpLmStudio({
+          baseUrl: 'http://127.0.0.1:1234/v1',
+          model,
+          maxWaitMs: 60000,
+          quiet: true,
+          gpuOffload: resolvedGpu,
+          cpuThreads: resolvedThreads,
+          contextLength: followCtx ?? resolvedCtx,
+        }),
+        unloadFn: () => unloadModelFromEngine('lms', model),
+      });
+
+      if (!follow.ok) {
+        return sendJson(res, 200, {
+          status: 'error',
+          message: follow.reason || 'Failed to wake up LM Studio',
+          modelLoad: loadSettings,
+          followApplied: false,
+          followReason: follow.followReason || null,
+        });
+      }
+
+      const finalCtx = follow.loadedContextLength || follow.followContext || null;
+      let refreshedSettings = loadSettings;
+      if (finalCtx) {
+        await withSettingsWriteQueue(() => savePersistedModelLoadSettings({ contextLength: finalCtx }));
+        refreshedSettings = getPersistedModelLoadSettings();
+      }
+      clearLmStudioProbeCache();
+      return sendJson(res, 200, {
+        status: 'ok',
+        message: follow.reloadedForFollow
+          ? `Model "${model}" reloaded with context ${Number(finalCtx).toLocaleString()} (model max ${follow.modelMaxContextLength ? Number(follow.modelMaxContextLength).toLocaleString() : 'unknown'})`
+          : `LM Studio already running with model loaded`,
+        awakened: Boolean(follow.performedLoad),
+        modelLoaded: true,
+        loadedModel: model,
+        loadedContextLength: follow.loadedContextLength || null,
+        modelMaxContextLength: follow.modelMaxContextLength || null,
+        followContext: follow.followContext || null,
+        followZone: follow.followZone || null,
+        followApplied: true,
+        followReason: follow.followReason || null,
+        quantization: null,
+        modelLoad: refreshedSettings,
+      });
+    }
+
+    const result = await wakeUpLmStudio({
+      baseUrl: 'http://127.0.0.1:1234/v1',
+      model,
+      maxWaitMs: 60000,
+      quiet: true,
+      gpuOffload: gpuOffload !== undefined ? gpuOffload : loadSettings.gpuOffload,
+      cpuThreads: cpuThreads !== undefined ? cpuThreads : loadSettings.cpuThreads,
+      contextLength: contextLength !== undefined ? contextLength : loadSettings.contextLength,
+    });
+
+    if (!result.ok) {
+      return sendJson(res, 200, {
+        status: 'error',
+        message: result.reason || 'Failed to wake up LM Studio',
+        modelLoad: loadSettings,
+      });
+    }
+
+    clearLmStudioProbeCache();
+    const probe = await probeLmStudioRuntime('http://127.0.0.1:1234/v1', { timeoutMs: 3000, bypassCache: true }).catch(() => null);
+
+    sendJson(res, 200, {
+      status: 'ok',
+      message: result.awakened
+        ? `Model "${model}" loaded successfully`
+        : `LM Studio already running with model loaded`,
+      awakened: Boolean(result.awakened),
+      modelLoaded: Boolean(result.modelLoaded),
+      loadedModel: probe?.loadedModel || model,
+      loadedContextLength: probe?.loadedContextLength || null,
+      modelMaxContextLength: probe?.modelMaxContextLength || null,
+      followContext: null,
+      followApplied: false,
+      followReason: 'auto-follow-disabled',
+      quantization: probe?.quantization || null,
+      modelLoad: loadSettings,
+    });
+  } catch (err) {
+    sendError(res, 500, `LM Studio load failed: ${err.message}`);
+  }
+}
+
+export async function handleLmStudioLoadSettingsRoute(req, res) {
+  if (req.method === 'GET') {
+    return sendJson(res, 200, { status: 'ok', modelLoad: getPersistedModelLoadSettings() });
+  }
+  if (!isTrustedRequest(req)) {
+    return sendError(res, 403, 'Changing model load settings requires local access');
+  }
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+  const saved = await withSettingsWriteQueue(() => savePersistedModelLoadSettings(body));
+  sendJson(res, 200, { status: 'ok', modelLoad: saved });
+}