kiku-agent 1.3.1 → 1.3.3

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

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

@@ -0,0 +1,94 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { unloadModelFromEngine } from '../engineService.js';
+import { unloadLmStudioModel } from '../lmStudioWakeup.js';
+import { handleEngineUnloadRoute } from '../../web-chat/routes/engineRoute.js';
+
+describe('Local Inference Engine Unload Pipeline', () => {
+  test('unloadLmStudioModel handles unreachable LM Studio server gracefully', async () => {
+    const res = await unloadLmStudioModel('test-model', {
+      baseUrl: 'http://127.0.0.1:59999/v1',
+      timeoutMs: 500
+    });
+    assert.ok(typeof res.ok === 'boolean');
+    assert.equal(res.engine, 'lms');
+    assert.ok(res.message);
+  });
+
+  test('unloadModelFromEngine routes to lms engine gracefully', async () => {
+    const res = await unloadModelFromEngine('lms', 'google/gemma-4-e4b', {
+      baseUrl: 'http://127.0.0.1:59999/v1',
+      timeoutMs: 500
+    });
+    assert.ok(typeof res.ok === 'boolean');
+    assert.equal(res.engine, 'lms');
+  });
+
+  test('unloadModelFromEngine stops vllm engine background process', async () => {
+    const res = await unloadModelFromEngine('vllm', 'google/gemma-4-e4b');
+    assert.equal(res.ok, true);
+    assert.equal(res.engine, 'vllm');
+    assert.equal(res.unloaded, true);
+    assert.ok(res.message.includes('vLLM'));
+  });
+
+  test('unloadModelFromEngine rejects unknown engine gracefully', async () => {
+    const res = await unloadModelFromEngine('unknown_custom_engine', 'some-model');
+    assert.equal(res.ok, false);
+    assert.ok(res.message.includes('Unsupported engine'));
+  });
+
+  test('handleEngineUnloadRoute handles valid POST request and returns json', async () => {
+    const payloadStr = JSON.stringify({
+      engine: 'vllm',
+      model: 'google/gemma-4-e4b'
+    });
+
+    const mockReq = {
+      method: 'POST',
+      url: '/api/engine/unload',
+      headers: { 'content-type': 'application/json' },
+      socket: { remoteAddress: '127.0.0.1' },
+      on(event, handler) {
+        if (event === 'data') {
+          process.nextTick(() => handler(Buffer.from(payloadStr)));
+        } else if (event === 'end') {
+          process.nextTick(() => handler());
+        }
+        return this;
+      }
+    };
+
+    let statusCode = 0;
+    let headers = {};
+    let responseBody = '';
+
+    const mockRes = {
+      writeHead(code, head) {
+        statusCode = code;
+        headers = head || {};
+      },
+      end(payload) {
+        responseBody = payload;
+      }
+    };
+
+    await handleEngineUnloadRoute(mockReq, mockRes);
+
+    assert.equal(statusCode, 200);
+    assert.ok(headers['Content-Type']?.includes('application/json'));
+    const parsed = JSON.parse(responseBody);
+    assert.equal(parsed.status, 'ok');
+    assert.equal(parsed.engine, 'vllm');
+    assert.ok(parsed.message);
+  });
+
+  test('unloadLmStudioModel handles gguf filename and unloads matched loaded model instance', async () => {
+    const res = await unloadLmStudioModel('gemma-4-E4B-it-Q4_K_M.gguf', {
+      baseUrl: 'http://127.0.0.1:59999/v1',
+      timeoutMs: 300
+    });
+    assert.ok(typeof res.ok === 'boolean');
+    assert.equal(res.engine, 'lms');
+  });
+});

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

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { executeTool, toolHandlers } from '../tools.js';
+import { getMcpToolNames, handleToolCall } from '../../mcp/tools.js';
+import { readResource, resourceDefinitions } from '../../mcp/resources.js';
+
+import * as thaiCatalog from '../../../src/data/industryIndexData.js';
+import * as mcpCatalog from '../../mcp/data/industryIndex.js';
+
+test('dual catalog integrity: src/data/industryIndexData.js and server/mcp/data/industryIndex.js share identical export keys', () => {
+  const thaiKeys = Object.keys(thaiCatalog).sort();
+  const mcpKeys = Object.keys(mcpCatalog).sort();
+
+  assert.deepEqual(thaiKeys, mcpKeys, 'Export keys must match across both catalog copies');
+  assert.ok(thaiCatalog.platformsCatalog.length === 9, 'Must contain all 9 third-party big data platforms');
+  assert.ok(mcpCatalog.platformsCatalog.length === 9, 'MCP catalog must contain all 9 platforms');
+
+  const thaiIds = thaiCatalog.platformsCatalog.map(p => p.id).sort();
+  const mcpIds = mcpCatalog.platformsCatalog.map(p => p.id).sort();
+  assert.deepEqual(thaiIds, mcpIds, 'Platform IDs must match 1:1 between Thai and MCP catalogs');
+
+  const expectedPlatforms = [
+    'vlinkage', 'datawin', 'guduo',
+    'yunhe', 'maoyan', 'dengta',
+    'weibo', 'douban', 'xiaohongshu'
+  ].sort();
+  assert.deepEqual(thaiIds, expectedPlatforms, 'All 9 required platforms must be present');
+});
+
+test('get_entertainment_metrics returns all platforms by default with Ju Jingyi benchmarks', async () => {
+  const res = await executeTool('get_entertainment_metrics');
+  assert.equal(res.status, 'success');
+  assert.equal(res.totalPlatforms, 9);
+  assert.ok(Array.isArray(res.platforms));
+  assert.ok(res.platforms.length === 9);
+  assert.ok(Array.isArray(res.dramaBenchmarks));
+  assert.ok(res.dramaBenchmarks.length >= 4);
+  assert.ok(res.artistOverview);
+  assert.equal(res.artistOverview.nameCn, '鞠婧祎');
+  assert.ok(res.socialBuzzOverview);
+});
+
+test('get_entertainment_metrics filters by specific platform ID', async () => {
+  const resYunhe = await executeTool('get_entertainment_metrics', { platform: 'yunhe' });
+  assert.equal(resYunhe.status, 'success');
+  assert.equal(resYunhe.totalPlatforms, 1);
+  assert.equal(resYunhe.platforms[0].id, 'yunhe');
+  assert.equal(resYunhe.platforms[0].officialDomain, 'enlightent.cn');
+  assert.ok(resYunhe.platforms[0].industryRoleTh.includes('Effective Views') || resYunhe.platforms[0].industryRoleTh.includes('正片有效播放'));
+
+  const resVlinkage = await executeTool('get_entertainment_metrics', { platform: 'vlinkage' });
+  assert.equal(resVlinkage.status, 'success');
+  assert.equal(resVlinkage.platforms[0].id, 'vlinkage');
+
+  const resDatawin = await executeTool('get_entertainment_metrics', { platform: 'datawin' });
+  assert.equal(resDatawin.status, 'success');
+  assert.equal(resDatawin.platforms[0].id, 'datawin');
+});
+
+test('get_entertainment_metrics filters by category pillar', async () => {
+  const resStreaming = await executeTool('get_entertainment_metrics', { category: 'streaming_boxoffice' });
+  assert.equal(resStreaming.status, 'success');
+  assert.equal(resStreaming.totalPlatforms, 3);
+  const ids = resStreaming.platforms.map(p => p.id).sort();
+  assert.deepEqual(ids, ['dengta', 'maoyan', 'yunhe']);
+
+  const resActorDrama = await executeTool('get_entertainment_metrics', { category: 'actor_drama_index' });
+  assert.equal(resActorDrama.status, 'success');
+  assert.equal(resActorDrama.totalPlatforms, 3);
+  const actorIds = resActorDrama.platforms.map(p => p.id).sort();
+  assert.deepEqual(actorIds, ['datawin', 'guduo', 'vlinkage']);
+
+  const resSocial = await executeTool('get_entertainment_metrics', { category: 'social_commercial' });
+  assert.equal(resSocial.status, 'success');
+  assert.equal(resSocial.totalPlatforms, 3);
+  const socialIds = resSocial.platforms.map(p => p.id).sort();
+  assert.deepEqual(socialIds, ['douban', 'weibo', 'xiaohongshu']);
+});
+
+test('get_entertainment_metrics filters by query keywords (e.g. In Blossom or aesthetics)', async () => {
+  const res = await executeTool('get_entertainment_metrics', { query: 'In Blossom' });
+  assert.equal(res.status, 'success');
+  assert.ok(res.dramaBenchmarks.some(b => b.titleEn === 'In Blossom'));
+
+  const resAesthetic = await executeTool('get_entertainment_metrics', { query: '美学' });
+  assert.equal(resAesthetic.status, 'success');
+  assert.ok(resAesthetic.platforms.some(p => p.id === 'xiaohongshu'));
+});
+
+test('get_industry_index alias works identically', async () => {
+  const res = await executeTool('get_industry_index', { platform: 'maoyan' });
+  assert.equal(res.status, 'success');
+  assert.equal(res.platforms[0].id, 'maoyan');
+  assert.equal(res.platforms[0].nameCn, '猫眼专业版');
+});
+
+test('MCP server exposes get_entertainment_metrics and get_industry_index as public tools', () => {
+  const mcpToolNames = getMcpToolNames();
+  assert.ok(mcpToolNames.includes('get_entertainment_metrics'));
+  assert.ok(mcpToolNames.includes('get_industry_index'));
+});
+
+test('MCP server can execute get_entertainment_metrics over tool calling protocol', async () => {
+  const result = await handleToolCall('get_entertainment_metrics', { platform: 'datawin' });
+  assert.equal(result.status, 'success');
+  assert.equal(result._meta.protocol, 'mcp');
+  assert.equal(result.platforms[0].id, 'datawin');
+  assert.equal(result.platforms[0].nameEn, 'DataWin');
+});
+
+test('MCP server resource kiku://industry-index is defined and readable', async () => {
+  const def = resourceDefinitions.find(r => r.uri === 'kiku://industry-index');
+  assert.ok(def, 'Resource kiku://industry-index must be registered in resourceDefinitions');
+  assert.equal(def.mimeType, 'application/json');
+
+  const resource = await readResource('kiku://industry-index');
+  assert.equal(resource.contents[0].uri, 'kiku://industry-index');
+  assert.equal(resource.contents[0].mimeType, 'application/json');
+
+  const parsed = JSON.parse(resource.contents[0].text);
+  assert.ok(Array.isArray(parsed.platformsCatalog));
+  assert.equal(parsed.platformsCatalog.length, 9);
+  assert.ok(parsed.artistIndustryMetrics);
+  assert.equal(parsed.artistIndustryMetrics.artist.nameCn, '鞠婧祎');
+});