kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,201 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+import { McpClientManager } from '../mcpClient.js';
+import { KikuAgent } from '../agentCore.js';
+import { routeCommand } from '../commands.js';
+import { PACKAGE_VERSION } from '../version.js';
+
+const stdioServerPath = fileURLToPath(new URL('../../mcp/stdio.js', import.meta.url));
+
+test('McpClientManager connects over stdio, discovers tools, and executes tool call', { timeout: 30_000 }, async () => {
+  const manager = new McpClientManager({ clientInfo: { name: 'kiku-agent-test', version: PACKAGE_VERSION }, autoLoad: false });
+
+  try {
+    const connResult = await manager.connect('local_kiku', {
+      command: process.execPath,
+      args: [stdioServerPath],
+      cwd: process.cwd(),
+    }, { persist: false });
+
+    assert.equal(connResult.success, true);
+    assert.equal(connResult.serverName, 'local_kiku');
+    assert.ok(connResult.toolsCount >= 10);
+
+    const schemas = manager.getToolsSchema();
+    assert.ok(schemas.length >= 10);
+    const searchTool = schemas.find(s => s.function.name === 'mcp_local_kiku_search_works');
+    assert.ok(searchTool, 'Tool should be registered with server namespace prefix');
+    assert.equal(searchTool.type, 'function');
+    assert.ok(searchTool.function.description.includes('[MCP Server: local_kiku]'));
+
+    const callResult = await manager.callTool('mcp_local_kiku_search_works', { year: 2026 });
+    assert.equal(callResult.status, 'success');
+    assert.equal(callResult.server, 'local_kiku');
+    assert.equal(callResult.tool, 'search_works');
+    assert.ok(callResult.count > 0);
+
+    
+    const directCall = await manager.callTool('search_works', { year: 2026 });
+    assert.equal(directCall.status, 'success');
+
+   
+    const status = manager.getStatus();
+    assert.equal(status.activeServersCount, 1);
+    assert.equal(status.servers[0].name, 'local_kiku');
+  } finally {
+    await manager.disconnectAll();
+  }
+});
+
+test('KikuAgent dynamically registers MCP tools into tool schema and system prompt', { timeout: 30_000 }, async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-mcp-agent-test-'));
+  const agent = new KikuAgent({
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp_servers.json'),
+    }),
+    client: {
+      provider: 'lmstudio',
+      model: 'test-model',
+      async chat() { return { role: 'assistant', content: 'test response' }; },
+      async checkConnection() { return { connected: true, models: ['test-model'] }; }
+    }
+  });
+  await agent.ready();
+
+  const initialToolsCount = agent.getAllToolsSchema().length;
+
+  try {
+    const conn = await agent.connectMcp('test_kiku', {
+      command: process.execPath,
+      args: [stdioServerPath],
+      cwd: process.cwd(),
+    });
+    assert.equal(conn.success, true);
+
+    const updatedTools = agent.getAllToolsSchema();
+    assert.ok(updatedTools.length > initialToolsCount);
+    assert.ok(updatedTools.some(t => t.function.name.startsWith('mcp_test_kiku_')));
+    assert.ok(agent.systemPrompt.includes('mcp_test_kiku_'));
+
+    
+    assert.equal(await routeCommand('/mcp status', { agent, sub: 'status' }), 'HANDLED');
+    assert.equal(await routeCommand('/mcp tools', { agent, sub: 'tools' }), 'HANDLED');
+
+    
+    const disconn = await agent.disconnectMcp('test_kiku');
+    assert.equal(disconn, true);
+    assert.equal(agent.getAllToolsSchema().length, initialToolsCount);
+  } finally {
+    await agent.mcpManager.disconnectAll();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('DynamicToolRouter pins tools mentioned with @ in the prompt with top priority', () => {
+  const agent = new KikuAgent({
+    mcpManager: new McpClientManager({ autoLoad: false }),
+    client: {
+      provider: 'lmstudio',
+      model: 'test-model',
+      async chat() { return { role: 'assistant', content: 'test response' }; },
+      async checkConnection() { return { connected: true, models: ['test-model'] }; }
+    }
+  });
+
+  const routed = agent.router.routeToolsForQuery('Please tell me about her works @search_works');
+  assert.ok(routed.length > 0);
+  assert.equal(routed[0].function.name, 'search_works');
+
+  const routedAwards = agent.router.routeToolsForQuery('@get_awards check all music awards');
+  assert.ok(routedAwards.length > 0);
+  assert.equal(routedAwards[0].function.name, 'get_awards');
+});
+
+test('McpClientManager persists configurations across disconnects and supports save/remove', async () => {
+  const manager = new McpClientManager({ autoLoad: false });
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-mcp-config-test-'));
+  const configPath = path.join(tempDir, 'mcp_servers.json');
+
+  try {
+    manager.persistedConfigs.set('test_server', {
+      type: 'streamable-http',
+      url: 'https://example.com/mcp',
+      enabled: true,
+    });
+
+    const status = manager.getStatus();
+    assert.equal(status.totalConfiguredCount, 1);
+    assert.equal(status.servers[0].name, 'test_server');
+    assert.equal(status.servers[0].status, 'saved_offline');
+
+    const saveRes = await manager.savePersistedConfig(configPath);
+    assert.equal(saveRes.success, true);
+    assert.equal(saveRes.filePath, configPath);
+    assert.ok(saveRes.count >= 1);
+    const saved = JSON.parse(await readFile(configPath, 'utf8'));
+    assert.equal(saved.mcpServers.test_server.url, 'https://example.com/mcp');
+
+    const removed = await manager.remove('test_server', { persist: false });
+    assert.equal(removed, true);
+    assert.equal(manager.persistedConfigs.has('test_server'), false);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('McpClientManager permanently removes a server from every loaded config source', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-mcp-source-remove-test-'));
+  const globalConfigPath = path.join(tempDir, 'mcp_servers.json');
+  const workspaceConfigPath = path.join(tempDir, 'opencode.json');
+
+  await writeFile(globalConfigPath, JSON.stringify({
+    mcpServers: {
+      duplicate_server: { type: 'remote', url: 'https://global.example/mcp', enabled: false },
+      global_only: { type: 'remote', url: 'https://global-only.example/mcp', enabled: false },
+    },
+  }, null, 2));
+  await writeFile(workspaceConfigPath, JSON.stringify({
+    $schema: 'https://opencode.ai/config.json',
+    mcp: {
+      duplicate_server: { type: 'remote', url: 'https://workspace.example/mcp', enabled: false },
+      workspace_only: { type: 'remote', url: 'https://workspace-only.example/mcp', enabled: false },
+    },
+  }, null, 2));
+
+  const managerOptions = {
+    globalConfigPath,
+    configPaths: [globalConfigPath, workspaceConfigPath],
+  };
+
+  try {
+    const manager = new McpClientManager(managerOptions);
+    await manager.loadPersistedServers();
+
+    const before = manager.getStatus().servers.find(server => server.name === 'duplicate_server');
+    assert.ok(before);
+    assert.deepEqual(new Set(before.sources), new Set([globalConfigPath, workspaceConfigPath]));
+
+    assert.equal(await manager.remove('duplicate_server'), true);
+
+    const savedGlobal = JSON.parse(await readFile(globalConfigPath, 'utf8'));
+    const savedWorkspace = JSON.parse(await readFile(workspaceConfigPath, 'utf8'));
+    assert.equal(savedGlobal.mcpServers.duplicate_server, undefined);
+    assert.equal(savedWorkspace.mcp.duplicate_server, undefined);
+    assert.ok(savedGlobal.mcpServers.global_only);
+    assert.ok(savedWorkspace.mcp.workspace_only);
+    assert.equal(savedWorkspace.$schema, 'https://opencode.ai/config.json');
+
+    const restartedManager = new McpClientManager(managerOptions);
+    await restartedManager.loadPersistedServers();
+    assert.equal(restartedManager.persistedConfigs.has('duplicate_server'), false);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+

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

@@ -0,0 +1,109 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ModelManager } from '../modelManager.js';
+
+function clientWith(models, connected = true) {
+  return {
+    model: 'requested/model',
+    async checkConnection() {
+      return connected ? { connected: true, models } : { connected: false, models: [], error: 'offline' };
+    },
+  };
+}
+
+test('model manager keeps an explicitly requested loaded model', async () => {
+  const client = clientWith(['requested/model', 'google/gemma-4-e4b']);
+  const result = await new ModelManager(client).resolve();
+  assert.equal(result.state, 'ready');
+  assert.equal(result.usedFallback, false);
+  assert.equal(client.model, 'requested/model');
+});
+
+test('model manager selects a chat fallback when the requested model is missing', async () => {
+  const client = clientWith(['text-embedding-model', 'google/gemma-4-e4b']);
+  const result = await new ModelManager(client).resolve();
+  assert.equal(result.state, 'fallback_selected');
+  assert.equal(result.selectedModel, 'google/gemma-4-e4b');
+  assert.equal(client.model, 'google/gemma-4-e4b');
+});
+
+test('model manager prefers the provider recommendation over an arbitrary catalog model', async () => {
+  const client = clientWith(['random/chat-model', 'gpt-5.6-luna']);
+  client.provider = 'openai';
+  client.getProviderInfo = () => ({ recommendedModels: [{ id: 'gpt-5.6-luna' }] });
+  const result = await new ModelManager(client).resolve();
+  assert.equal(result.state, 'fallback_selected');
+  assert.equal(result.selectedModel, 'gpt-5.6-luna');
+  assert.equal(client.model, 'gpt-5.6-luna');
+});
+
+test('model manager reports online server with no loaded model', async () => {
+  const result = await new ModelManager(clientWith([])).resolve();
+  assert.equal(result.state, 'server_online_no_models');
+  assert.equal(result.selectedModel, undefined);
+});
+
+test('model manager rejects unavailable and non-chat manual selections', () => {
+  const manager = new ModelManager(clientWith([]));
+  assert.throws(() => manager.select('missing', ['chat']), /not available/);
+  assert.throws(() => manager.select('embedding-model', ['embedding-model']), /does not appear to support chat/);
+});
+
+test('model manager normalizes legacy model aliases before availability checks', () => {
+  const client = clientWith([]);
+  client.provider = 'deepseek';
+  const manager = new ModelManager(client);
+  const selected = manager.select('deepseek-chat', ['deepseek-v4-flash']);
+  assert.equal(selected, 'deepseek-v4-flash');
+  assert.equal(client.model, 'deepseek-v4-flash');
+});
+
+test('model manager matches Q8_0 quantization with GGUF file paths and publishers in LM Studio', async () => {
+  const client = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b-Q8_0',
+    async checkConnection() {
+      return {
+        connected: true,
+        models: [
+          'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q4_K_M.gguf',
+          'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf'
+        ],
+        activeLoadedModel: 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf'
+      };
+    }
+  };
+
+  const manager = new ModelManager(client, { requestedModel: 'google/gemma-4-e4b-Q8_0' });
+  const result = await manager.resolve();
+  assert.equal(result.state, 'ready');
+  assert.equal(result.selectedModel, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+  assert.equal(client.model, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+
+  const inspection = await manager.inspect();
+  assert.equal(inspection.state, 'ready');
+});
+
+test('model manager allows selecting shorthand quantizations like Q8_0, q8, Q6_K in LM Studio', () => {
+  const client = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+  };
+  const available = [
+    'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q4_K_M.gguf',
+    'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf'
+  ];
+  const manager = new ModelManager(client);
+
+  const selectedQ8 = manager.select('Q8_0', available);
+  assert.equal(selectedQ8, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+  assert.equal(client.model, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+
+  const selectedQ8Short = manager.select('q8', available);
+  assert.equal(selectedQ8Short, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+
+  const selectedQ4 = manager.select('q4_k_m', available);
+  assert.equal(selectedQ4, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q4_K_M.gguf');
+});
+

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

@@ -0,0 +1,69 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { detectDominantLanguage } from '../agentCore.js';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { executeTool } from '../tools.js';
+
+export const MULTILINGUAL_QUERIES = Object.freeze([
+  {
+    lang: 'th',
+    text: 'จวีจิ้งอี เกิดวันที่เท่าไหร่ และมีผลงานเพลงอะไรบ้างค่ะ',
+    expectedLanguage: 'th'
+  },
+  {
+    lang: 'zh',
+    text: '请问鞠婧祎在2026年有哪些新剧待播？',
+    expectedLanguage: 'zh'
+  },
+  {
+    lang: 'en',
+    text: 'What are the main awards won by Ju Jingyi in her solo career?',
+    expectedLanguage: 'en'
+  },
+  {
+    lang: 'th',
+    text: 'Ju Jingyi (鞠婧祎) ผลงานละครเรื่อง ฮวาเจียนลิ่ง (In Blossom) ฉายปีไหนคะ',
+    expectedLanguage: 'th'
+  },
+  {
+    lang: 'zh',
+    text: '鞠婧祎 Ju Jingyi 个人单曲《每一天》的发行年份和MV',
+    expectedLanguage: 'zh'
+  },
+  {
+    lang: 'en',
+    text: 'Ju Jingyi Chinese name 鞠婧祎 and fandom name Miju 蜜橘 details',
+    expectedLanguage: 'en'
+  },
+  {
+    lang: 'ja',
+    text: '鞠婧祎（ジュ・ジンイー）の最新ドラマと代表曲を教えてください',
+    expectedLanguage: 'ja'
+  },
+  {
+    lang: 'ko',
+    text: '쥐징이의 최신 드라마와 대표곡을 알려주세요',
+    expectedLanguage: 'ko'
+  }
+]);
+
+test('Multilingual Suite: Accurately detects primary language in mixed bilingual queries', () => {
+  for (const item of MULTILINGUAL_QUERIES) {
+    const detected = detectDominantLanguage(item.text);
+    assert.equal(detected, item.expectedLanguage);
+  }
+});
+
+test('Multilingual Suite: Universal and domain search tools find records across Chinese, Thai, and English titles', async () => {
+  const cnRes = await executeTool('search_works', { query: '花间令' });
+  assert.equal(cnRes.status, 'success');
+  assert.ok(cnRes.count > 0);
+
+  const thRes = await executeTool('search_works', { query: 'ฮวาเจียนลิ่ง' });
+  assert.equal(thRes.status, 'success');
+  assert.ok(thRes.count > 0);
+
+  const enRes = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(enRes.status, 'success');
+  assert.ok(enRes.count > 0);
+});