kiku-agent 1.3.2 → 1.3.4

package/server/agent/tests/cpuMetrics.test.js

@@ -0,0 +1,101 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { getCpuMetrics, resolveOptimalThreadBudget, clearCpuMetricsCache } from '../cpuMetrics.js';
+import { resolveParallelSlotBudget, buildLmsLoadArgs } from '../lmStudioWakeup.js';
+import { normalizeModelLoadSettings } from '../config.js';
+
+test('getCpuMetrics detects CPU topology and returns structured hardware metrics', async () => {
+  clearCpuMetricsCache();
+  const metrics = await getCpuMetrics();
+  assert.ok(metrics, 'Metrics object must be defined');
+  assert.ok(typeof metrics.model === 'string' && metrics.model.length > 0, 'CPU model must be non-empty string');
+  assert.ok(Number.isFinite(metrics.physicalCores) && metrics.physicalCores >= 1, 'Physical cores must be >= 1');
+  assert.ok(Number.isFinite(metrics.logicalCores) && metrics.logicalCores >= metrics.physicalCores, 'Logical cores must be >= physical cores');
+  assert.equal(typeof metrics.hyperThreading, 'boolean');
+  assert.ok(Number.isFinite(metrics.smtMultiplier) && metrics.smtMultiplier >= 1);
+  assert.ok(typeof metrics.statusText === 'string');
+  assert.ok(metrics.recommendedComputeThreads >= 1);
+});
+
+test('resolveOptimalThreadBudget calculates thread counts for physical, smt, auto, and custom modes', () => {
+  const mockCpu = {
+    physicalCores: 6,
+    logicalCores: 12,
+    hyperThreading: true,
+  };
+
+  const phys = resolveOptimalThreadBudget({ mode: 'physical', cpuInfo: mockCpu });
+  assert.equal(phys.threads, 6);
+  assert.equal(phys.mode, 'physical');
+  assert.match(phys.explanation, /physical cores/i);
+
+  const smt = resolveOptimalThreadBudget({ mode: 'smt', cpuInfo: mockCpu });
+  assert.equal(smt.threads, 12);
+  assert.equal(smt.mode, 'smt');
+  assert.match(smt.explanation, /logical threads/i);
+
+  const autoDefault = resolveOptimalThreadBudget({ mode: 'auto', cpuInfo: mockCpu });
+  assert.equal(autoDefault.threads, 6);
+  assert.equal(autoDefault.mode, 'auto');
+
+  const autoWithReq = resolveOptimalThreadBudget({ mode: 'auto', requested: 8, cpuInfo: mockCpu });
+  assert.equal(autoWithReq.threads, 8);
+  assert.equal(autoWithReq.mode, 'custom');
+
+  const custom = resolveOptimalThreadBudget({ mode: 'custom', requested: 4, cpuInfo: mockCpu });
+  assert.equal(custom.threads, 4);
+  assert.equal(custom.mode, 'custom');
+});
+
+test('resolveParallelSlotBudget enforces physical core ceiling when htMode is physical', () => {
+  const budgetPhysical = resolveParallelSlotBudget(12, 12, { htMode: 'physical', physicalCores: 6 });
+  assert.equal(budgetPhysical.value, 6);
+  assert.equal(budgetPhysical.ceiling, 6);
+  assert.equal(budgetPhysical.capped, true);
+
+  const budgetSmt = resolveParallelSlotBudget(12, 12, { htMode: 'smt', physicalCores: 6 });
+  assert.equal(budgetSmt.value, 12);
+  assert.equal(budgetSmt.ceiling, 12);
+  assert.equal(budgetSmt.capped, false);
+
+  const budgetAuto = resolveParallelSlotBudget(8, 12, { htMode: 'auto', physicalCores: 6 });
+  assert.equal(budgetAuto.value, 8);
+  assert.equal(budgetAuto.ceiling, 12);
+});
+
+test('buildLmsLoadArgs applies HT-aware parallel allocation flags', () => {
+  const argsPhys = buildLmsLoadArgs('test-model', {
+    cpuThreads: 12,
+    availableCpus: 12,
+    physicalCores: 6,
+    htMode: 'physical'
+  });
+  assert.ok(argsPhys.includes('--parallel'));
+  assert.equal(argsPhys[argsPhys.indexOf('--parallel') + 1], '6');
+
+  const argsSmt = buildLmsLoadArgs('test-model', {
+    cpuThreads: 12,
+    availableCpus: 12,
+    physicalCores: 6,
+    htMode: 'smt'
+  });
+  assert.ok(argsSmt.includes('--parallel'));
+  assert.equal(argsSmt[argsSmt.indexOf('--parallel') + 1], '12');
+});
+
+test('normalizeModelLoadSettings persists and validates htMode', () => {
+  const def = normalizeModelLoadSettings({});
+  assert.equal(def.htMode, 'auto');
+
+  const phys = normalizeModelLoadSettings({ htMode: 'physical' });
+  assert.equal(phys.htMode, 'physical');
+
+  const smt = normalizeModelLoadSettings({ htMode: 'smt' });
+  assert.equal(smt.htMode, 'smt');
+
+  const allAlias = normalizeModelLoadSettings({ htMode: 'all' });
+  assert.equal(allAlias.htMode, 'smt');
+
+  const invalid = normalizeModelLoadSettings({ htMode: 'invalid_mode' });
+  assert.equal(invalid.htMode, 'auto');
+});

package/server/agent/tests/decisionAndSearchEnhancements.test.js

@@ -71,6 +71,38 @@ test('compactToolResultForContext projects essential keys and eliminates decorat
   assert.equal(b.bilibiliSearchUrl, undefined);
 });
 
+test('compactToolResultForContext preserves image evidence links and relevance scores', () => {
+  const longImageUrl = `https://example.com/images/${'a'.repeat(300)}.jpg`;
+  const imageResult = {
+    status: 'success',
+    query: '鞠婧祎 万花世界 路透',
+    normalizedQuery: '鞠婧祎 万花世界 电视剧 路透',
+    count: 1,
+    results: [
+      {
+        title: '鞠婧祎 万花世界 路透照',
+        snippet: 'on-set stills from 万花世界 filming',
+        url: 'https://example.com/article',
+        source: 'Baidu Images',
+        imageUrl: longImageUrl,
+        thumbUrl: longImageUrl,
+        sourcePageUrl: longImageUrl,
+        width: 1080,
+        height: 1440,
+        relevanceScore: 42.5,
+      }
+    ]
+  };
+
+  const compacted = compactToolResultForContext(imageResult, { maxTokens: 60 });
+  assert.equal(compacted.results.length, 1);
+  const item = compacted.results[0];
+  assert.equal(item.imageUrl, longImageUrl);
+  assert.equal(item.thumbUrl, longImageUrl);
+  assert.equal(item.sourcePageUrl, longImageUrl);
+  assert.equal(item.relevanceScore, 42.5);
+});
+
 test('scoreCoverage normalizes Buddhist Era years and minute-second durations', () => {
   const caseBe = {
     groups: [

package/server/agent/tests/edgeCasesScenarios.test.js

@@ -4,6 +4,9 @@ import { sanitizeQuery } from '../sanitizer.js';
 import { DynamicToolRouter } from '../toolRouter.js';
 import { executeTool } from '../tools.js';
 import { ContextCompactor } from '../contextCompactor.js';
+import { KikuAgent } from '../agentCore.js';
+import { handleVerifyRoute } from '../../web-chat/routes/verifyRoute.js';
+import { applyFutureEventGuard } from '../../web-chat/core/futureEventGuard.js';
 
 test('Edge Cases Suite: Sanitizer handles empty, whitespace, and extreme length strings gracefully', () => {
   const emptyRes = sanitizeQuery('');
@@ -47,3 +50,82 @@ test('Edge Cases Suite: ContextCompactor handles empty, malformed, or oversized
   const singleMsg = [{ role: 'user', content: 'Hello' }];
   assert.deepEqual(compactor.compact(singleMsg), singleMsg);
 });
+
+test('Edge Cases Suite: KikuAgent immunizes vision limitation statements from refusal interceptor', async () => {
+  let callCount = 0;
+  const fakeClient = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    chat: async () => {
+      callCount++;
+      return { role: 'assistant', content: 'ฉันเป็นระบบข้อความ ไม่สามารถดูรูปภาพได้โดยตรง จึงไม่มีข้อมูลของภาพนี้' };
+    }
+  };
+  const agent = new KikuAgent({ client: fakeClient, maxIterations: 2 });
+  const result = await agent.run('ช่วยดูรูปนี้ให้หน่อย จวีจิ้งอี\n\n[USER ATTACHMENT: ผู้ใช้ได้แนบรูปภาพจำนวน 1 รูป: "my_photo.jpg" (image/jpeg)]');
+  assert.equal(callCount, 1);
+  assert.ok(result.includes('ไม่สามารถดูรูปภาพ'));
+});
+
+test('Edge Cases Suite: KikuAgent provides graceful fallback for image attachments instead of raw failure', async () => {
+  const fakeClient = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    chat: async () => ({ role: 'assistant', content: '' })
+  };
+  const agent = new KikuAgent({ client: fakeClient, maxIterations: 1 });
+  const result = await agent.run('ดูภาพนี้\n\n[USER ATTACHMENT: ผู้ใช้ได้แนบรูปภาพจำนวน 1 รูป: "unknown.png" (image/png)]');
+  assert.ok(!result.includes('ขออภัยค่ะ ไม่สามารถประมวลผลคำตอบได้'));
+  assert.ok(result.includes('ได้รับรูปภาพเรียบร้อยแล้วค่ะ'));
+});
+
+test('Edge Cases Suite: KikuAgent does not intercept substantive negative answers as refusals', async () => {
+  let callCount = 0;
+  const fakeClient = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    chat: async () => {
+      callCount++;
+      return {
+        role: 'assistant',
+        content: 'จากการตรวจสอบข้อมูลและประวัติการทำงานของจวีจิ้งอี ไม่พบว่ามีประวัติการกระทำความผิดกฎหมายหรือเรื่องอื้อฉาวใดๆ ในวงการบันเทิง เธอเป็นศิลปินและนักแสดงที่มีผลงานซีรีส์อย่าง In Blossom และ The Legend of White Snake อย่างต่อเนื่อง'
+      };
+    }
+  };
+  const agent = new KikuAgent({ client: fakeClient, maxIterations: 2 });
+  const result = await agent.run('จวีจิ้งอีเคยมีประวัติด้านลบหรือทำผิดกฎหมายอะไรไหม');
+  assert.equal(callCount, 1);
+  assert.ok(result.includes('ไม่พบว่ามีประวัติการกระทำความผิด'));
+});
+
+test('Edge Cases Suite: handleVerifyRoute verifies natural language claim using token overlap', async () => {
+  let jsonResponse = null;
+  let status = null;
+  const payload = JSON.stringify({ claim: 'Ju Jingyi starred as Yang Caiwei in the 2024 historical drama In Blossom' });
+  const req = {
+    method: 'POST',
+    url: '/api/verify',
+    headers: { 'content-type': 'application/json' },
+    on: (event, cb) => {
+      if (event === 'data') cb(Buffer.from(payload));
+      if (event === 'end') cb();
+      return req;
+    }
+  };
+  const res = {
+    writeHead: (s) => { status = s; },
+    end: (data) => { jsonResponse = JSON.parse(data); }
+  };
+  await handleVerifyRoute(req, res);
+  assert.equal(status, 200);
+  assert.equal(jsonResponse.verdict, 'PARTIALLY_VERIFIED');
+  assert.ok(jsonResponse.evidence.length > 0);
+});
+
+test('Edge Cases Suite: applyFutureEventGuard preserves confirmed 2026 dates when catalog tools are executed', () => {
+  const answer = 'ซีรีส์เรื่อง 《千香》 (The Eternal Fragrance) มีกำหนดออกอากาศในปี 2026';
+  const guarded = applyFutureEventGuard(answer, { tools: [{ name: 'search_works' }], now: new Date('2024-01-01') });
+  assert.ok(guarded.includes('2026'));
+  assert.ok(!guarded.includes('วันที่ในอนาคตที่ยังไม่ยืนยัน'));
+});
+

package/server/agent/tests/engineService.test.js

@@ -0,0 +1,436 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  checkEngineCompatibility,
+  buildVllmServeArgs,
+  buildVllmExecutionPlan,
+  detectPlatformAndWsl,
+  calculateAutoTensorSplit,
+} from '../engineService.js';
+import {
+  MODEL_LOAD_DEFAULTS,
+  normalizeModelLoadSettings,
+  getActiveLocalEngine,
+  setActiveLocalEngine,
+  getPersistedModelLoadSettings,
+  savePersistedModelLoadSettings,
+} from '../config.js';
+import { routeCommand } from '../commands.js';
+
+test('engine compatibility: LM Studio supports Windows, macOS, and Linux', () => {
+  const win = checkEngineCompatibility('lms', { platform: 'win32', hasWsl: false });
+  assert.equal(win.supported, true);
+  assert.equal(win.engine, 'lms');
+
+  const mac = checkEngineCompatibility('lms', { platform: 'darwin', hasWsl: false });
+  assert.equal(mac.supported, true);
+
+  const linux = checkEngineCompatibility('lms', { platform: 'linux', hasWsl: false });
+  assert.equal(linux.supported, true);
+});
+
+test('engine compatibility: vLLM is enterprise Linux only (supported on Linux and Windows via WSL2, rejected on macOS)', () => {
+  const linux = checkEngineCompatibility('vllm', { platform: 'linux', isWsl: false });
+  assert.equal(linux.supported, true);
+  assert.equal(linux.isEnterprise, true);
+
+  const winWithWsl = checkEngineCompatibility('vllm', { platform: 'win32', hasWsl: true });
+  assert.equal(winWithWsl.supported, true);
+  assert.equal(winWithWsl.viaWsl, true);
+  assert.equal(winWithWsl.isEnterprise, true);
+
+  const winNoWsl = checkEngineCompatibility('vllm', { platform: 'win32', hasWsl: false });
+  assert.equal(winNoWsl.supported, false);
+  assert.equal(winNoWsl.isEnterprise, true);
+  assert.match(winNoWsl.reason, /WSL2/i);
+
+  const mac = checkEngineCompatibility('vllm', { platform: 'darwin', hasWsl: false });
+  assert.equal(mac.supported, false);
+  assert.equal(mac.isEnterprise, true);
+  assert.match(mac.reason, /macOS/i);
+});
+
+test('buildVllmServeArgs constructs CLI options accurately with custom parameters', () => {
+  const args = buildVllmServeArgs('Qwen/Qwen2.5-7B-Instruct', {
+    port: 8000,
+    gpuMemoryUtilization: 0.85,
+    tensorParallelSize: 2,
+    maxModelLen: 8192,
+    dtype: 'bfloat16',
+    enforceEager: true,
+    enablePrefixCaching: true,
+    trustRemoteCode: true,
+  });
+
+  assert.ok(args.includes('serve'));
+  assert.ok(args.includes('Qwen/Qwen2.5-7B-Instruct'));
+  assert.ok(args.includes('--port'));
+  assert.ok(args.includes('8000'));
+  assert.ok(args.includes('--gpu-memory-utilization'));
+  assert.ok(args.includes('0.85'));
+  assert.ok(args.includes('--tensor-parallel-size'));
+  assert.ok(args.includes('2'));
+  assert.ok(args.includes('--max-model-len'));
+  assert.ok(args.includes('8192'));
+  assert.ok(args.includes('--dtype'));
+  assert.ok(args.includes('bfloat16'));
+  assert.ok(args.includes('--enforce-eager'));
+  assert.ok(args.includes('--enable-prefix-caching'));
+  assert.ok(args.includes('--trust-remote-code'));
+});
+
+test('buildVllmExecutionPlan formats command for Windows WSL2 or native Linux', () => {
+  const winPlan = buildVllmExecutionPlan('google/gemma-4-e4b', {
+    platform: 'win32',
+    distro: 'Ubuntu-26.04',
+    gpuMemoryUtilization: 0.9,
+  });
+  assert.equal(winPlan.isWsl, true);
+  assert.equal(winPlan.command, 'wsl.exe');
+  assert.ok(winPlan.args.includes('-d'));
+  assert.ok(winPlan.args.includes('Ubuntu-26.04'));
+  assert.ok(winPlan.displayCommand.includes('wsl -d Ubuntu-26.04'));
+
+  const linuxPlan = buildVllmExecutionPlan('google/gemma-4-e4b', {
+    platform: 'linux',
+    gpuMemoryUtilization: 0.9,
+  });
+  assert.equal(linuxPlan.isWsl, false);
+  assert.equal(linuxPlan.command, 'vllm');
+  assert.ok(linuxPlan.displayCommand.startsWith('vllm serve'));
+});
+
+test('config: normalizeModelLoadSettings and active engine management', () => {
+  const normalized = normalizeModelLoadSettings({
+    activeEngine: 'vllm',
+    gpuOffload: 'max',
+    cpuThreads: 6,
+    gpuMemoryUtilization: 0.88,
+    tensorParallelSize: 2,
+  });
+
+  assert.equal(normalized.activeEngine, 'vllm');
+  assert.equal(normalized.gpuOffload, 'max');
+  assert.equal(normalized.cpuThreads, 6);
+  assert.equal(normalized.vllm.gpuMemoryUtilization, 0.88);
+  assert.equal(normalized.vllm.tensorParallelSize, 2);
+
+  setActiveLocalEngine('vllm');
+  assert.equal(getActiveLocalEngine(), 'vllm');
+  setActiveLocalEngine('lms');
+  assert.equal(getActiveLocalEngine(), 'lms');
+});
+
+test('/model load handles parameter parsing and OS compatibility checks', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    
+    const resInvalid = await routeCommand('/model load test-model --engine unknown', ctx);
+    assert.equal(resInvalid, 'HANDLED');
+    assert.ok(logs.some(l => l.includes('Incompatible') || l.includes('UNKNOWN') || l.includes('unknown')));
+
+   
+    savePersistedModelLoadSettings({ activeEngine: 'lms', gpuOffload: 'max', cpuThreads: 8 });
+    assert.equal(getActiveLocalEngine(), 'lms');
+    const persisted = getPersistedModelLoadSettings();
+    assert.equal(persisted.activeEngine, 'lms');
+    assert.equal(persisted.gpuOffload, 'max');
+    assert.equal(persisted.cpuThreads, 8);
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('/model engine handles inspection, compatibility, and switching', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: {
+      provider: 'lmstudio',
+      providerName: 'LM Studio',
+      model: 'google/gemma-4-e4b',
+      switchProvider: (p, opt) => { ctx.client.provider = p; if (opt?.model) ctx.client.model = opt.model; },
+    },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    const resInspect = await routeCommand('/model engine', ctx);
+    assert.equal(resInspect, 'HANDLED');
+
+    const resSwitchLms = await routeCommand('/model engine lms', ctx);
+    assert.equal(resSwitchLms, 'HANDLED');
+    assert.equal(getActiveLocalEngine(), 'lms');
+
+    const resInvalid = await routeCommand('/model engine invalidEngine123', ctx);
+    assert.equal(resInvalid, 'HANDLED');
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('/model config and /model params inspect, update, and reset parameters', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    const resShow = await routeCommand('/model config', ctx);
+    assert.equal(resShow, 'HANDLED');
+
+    const resUpdate = await routeCommand('/model config --gpu max --threads 8 --mem-util 0.85 --enforce-eager --prefix-caching', ctx);
+    assert.equal(resUpdate, 'HANDLED');
+    const updated = getPersistedModelLoadSettings();
+    assert.equal(updated.gpuOffload, 'max');
+    assert.equal(updated.cpuThreads, 8);
+    assert.equal(updated.vllm.gpuMemoryUtilization, 0.85);
+    assert.equal(updated.vllm.enforceEager, true);
+    assert.equal(updated.vllm.enablePrefixCaching, true);
+
+    const resReset = await routeCommand('/model params --reset', ctx);
+    assert.equal(resReset, 'HANDLED');
+    const resetSettings = getPersistedModelLoadSettings();
+    assert.equal(resetSettings.gpuOffload, 'auto');
+    assert.equal(resetSettings.cpuThreads, 1);
+    assert.equal(resetSettings.contextLength, 32768);
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('/model preset lists curated presets and applies preset', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  let switchedProvider = null;
+  let switchedModel = null;
+  const ctx = {
+    client: {
+      provider: 'lmstudio',
+      providerName: 'LM Studio',
+      model: 'google/gemma-4-e4b',
+      switchProvider: (p, opt) => {
+        switchedProvider = p;
+        if (opt?.model) switchedModel = opt.model;
+      },
+    },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    const resList = await routeCommand('/model preset', ctx);
+    assert.equal(resList, 'HANDLED');
+
+    const resApply = await routeCommand('/model preset gemma4', ctx);
+    assert.equal(resApply, 'HANDLED');
+    assert.equal(switchedProvider, 'lmstudio');
+    assert.equal(switchedModel, 'google/gemma-4-e4b');
+
+    const resUnknown = await routeCommand('/model preset unknown_xyz_preset', ctx);
+    assert.equal(resUnknown, 'HANDLED');
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('/model files discovers installed GGUF models', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    const resFiles = await routeCommand('/model files', ctx);
+    assert.equal(resFiles, 'HANDLED');
+
+    const resGguf = await routeCommand('/model gguf', ctx);
+    assert.equal(resGguf, 'HANDLED');
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('/model inference parameters (temp, topp, ctx, thinking) update settings', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    const resTemp = await routeCommand('/model temp 0.85', ctx);
+    assert.equal(resTemp, 'HANDLED');
+
+    const resTopp = await routeCommand('/model topp 0.90', ctx);
+    assert.equal(resTopp, 'HANDLED');
+
+    const resCtx = await routeCommand('/model ctx 32k', ctx);
+    assert.equal(resCtx, 'HANDLED');
+
+    const resThinking = await routeCommand('/model thinking collapse', ctx);
+    assert.equal(resThinking, 'HANDLED');
+
+    const { getPersistedInferenceSettings } = await import('../config.js');
+    const inf = getPersistedInferenceSettings();
+    assert.equal(inf.temperature, 0.85);
+    assert.equal(inf.topP, 0.90);
+    assert.equal(inf.contextLimit, 32768);
+    assert.equal(inf.thinking, 'collapse');
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('/model status renders enriched engine and inference diagnostics', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: {
+      provider: 'lmstudio',
+      providerName: 'LM Studio',
+      model: 'google/gemma-4-e4b',
+      checkConnection: async () => ({ connected: true, latencyMs: 12, models: ['google/gemma-4-e4b'], activeLoadedModel: 'google/gemma-4-e4b' }),
+    },
+    setIsProcessing: () => {},
+    baseUrl: 'http://127.0.0.1:1234/v1',
+  };
+
+  try {
+    const resStatus = await routeCommand('/model status', ctx);
+    assert.equal(resStatus, 'HANDLED');
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('calculateAutoTensorSplit computes safe ratios across multiple GPUs with headroom deduction', () => {
+  const dualGpus = {
+    gpus: [
+      { index: 0, name: 'RTX 4090', freeGb: 23.5, totalGb: 24 },
+      { index: 1, name: 'RTX 4070', freeGb: 12.0, totalGb: 12 },
+    ]
+  };
+  const split = calculateAutoTensorSplit(dualGpus, 3.5, 0);
+  assert.equal(split.applicable, true);
+  assert.equal(split.tensorSplit, '20,12');
+  assert.deepEqual(split.ratios, [20, 12]);
+  assert.equal(String(split), '20,12');
+
+  const singleGpu = {
+    gpus: [{ index: 0, name: 'RTX 3060', freeGb: 12.0, totalGb: 12 }]
+  };
+  const singleSplit = calculateAutoTensorSplit(singleGpu);
+  assert.equal(singleSplit.applicable, false);
+  assert.equal(singleSplit.tensorSplit, '1');
+});
+
+test('/model minp and /model repeat update inference samplers', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    const resMinP = await routeCommand('/model minp 0.08', ctx);
+    assert.equal(resMinP, 'HANDLED');
+
+    const resRepeat = await routeCommand('/model repeat 1.15', ctx);
+    assert.equal(resRepeat, 'HANDLED');
+
+    const { getPersistedInferenceSettings } = await import('../config.js');
+    const inf = getPersistedInferenceSettings();
+    assert.equal(inf.minP, 0.08);
+    assert.equal(inf.repeatPenalty, 1.15);
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('/model config parses multi-GPU, flash-attention, and batching parameters', async () => {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+
+  const ctx = {
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setIsProcessing: () => {},
+  };
+
+  try {
+    const res = await routeCommand('/model config --split-mode layer --tensor-split 20,12 --main-gpu 0 --fa -b 2048 -ub 512 --ctk q8_0', ctx);
+    assert.equal(res, 'HANDLED');
+
+    const settings = getPersistedModelLoadSettings();
+    assert.equal(settings.splitMode, 'layer');
+    assert.equal(settings.tensorSplit, '20,12');
+    assert.equal(settings.mainGpu, 0);
+    assert.equal(settings.flashAttn, true);
+    assert.equal(settings.batchSize, 2048);
+    assert.equal(settings.ubatchSize, 512);
+    assert.equal(settings.kvCacheDtype, 'q8_0');
+  } finally {
+    console.log = origLog;
+  }
+});
+
+test('LLMClient includes min_p and repeat_penalty in chat completion payload', async () => {
+  const { LLMClient } = await import('../llmClient.js');
+  const client = new LLMClient({ provider: 'lmstudio', baseUrl: 'http://127.0.0.1:1234/v1' });
+
+  let capturedBody = null;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url, options) => {
+    if (url.includes('/chat/completions')) {
+      capturedBody = JSON.parse(options.body);
+      return new Response(JSON.stringify({
+        id: 'chatcmpl-test',
+        choices: [{ message: { role: 'assistant', content: 'hello' } }]
+      }), { status: 200, headers: { 'Content-Type': 'application/json' } });
+    }
+    return originalFetch(url, options);
+  };
+
+  try {
+    await client.chat([{ role: 'user', content: 'test' }], {
+      stream: false,
+      minP: 0.08,
+      repeatPenalty: 1.10,
+    });
+
+    assert.ok(capturedBody);
+    assert.equal(capturedBody.min_p, 0.08);
+    assert.equal(capturedBody.repeat_penalty, 1.10);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});