kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,160 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { resolveQueryEntities, buildCatalogIndex, detectPromotionIntent } from '../catalogEntityResolver.js';
+import { createCatalogMatcher, executeTool } from '../tools.js';
+import { KikuAgent } from '../agentCore.js';
+import { McpClientManager } from '../mcpClient.js';
+
+const MULTI_INTENT_QUERY = 'เปิดเพลงล่าสุดของจวีจิ้งอี และดูคลิปละครใหม่หน่อย ล่าสุดมีข่าวไหม';
+
+test('router keeps playback tools visible when multiple intents share the 15-tool cap', () => {
+  const router = new DynamicToolRouter();
+  const routed = router.routeToolsForQuery(MULTI_INTENT_QUERY, { includeMcp: true });
+  const names = new Set(routed.map(t => t.function?.name));
+
+  assert.ok(routed.length <= 15, `Expected cap of 15, got ${routed.length}`);
+  assert.ok(names.has('play_music'), 'play_music must survive the cap on a play request');
+  assert.ok(names.has('search_discography'), 'search_discography must survive the cap');
+  assert.ok(names.has('search_works'), 'second intent essentials must follow the first intent before generic tools');
+  assert.ok(names.has('get_character_roles'), 'WORKS essentials must be included before the cap cuts them');
+});
+
+test('router no longer routes PROFILE intent on substring collisions', () => {
+  const router = new DynamicToolRouter();
+
+  const winter = router.detectIntents('Tell me about her winter concert');
+  const winterTypes = winter.map(p => p.type);
+  assert.ok(winterTypes.includes('MEDIA'), 'concert should route MEDIA');
+  assert.ok(!winterTypes.includes('PROFILE_AWARDS_BRANDS'), '"win" inside "winter" must not route PROFILE');
+
+  const superlative = router.detectIntents('เพลงที่ยอดวิวสูงสุดของเธอคือเพลงไหน');
+  const superlativeTypes = superlative.map(p => p.type);
+  assert.ok(superlativeTypes.includes('MEDIA'));
+  assert.ok(!superlativeTypes.includes('PROFILE_AWARDS_BRANDS'), 'สูงสุด must not route PROFILE');
+
+  const happen = router.detectIntents('มีอะไรเกิดขึ้นกับงานนี้');
+  assert.ok(!happen.map(p => p.type).includes('PROFILE_AWARDS_BRANDS'), 'เกิดขึ้น must not route PROFILE');
+});
+
+test('profile queries no longer leak SYSTEM_SKILL tools via "file" inside "profile"', () => {
+  const router = new DynamicToolRouter();
+  const intents = router.detectIntents('Show me her profile and fandom details').map(p => p.type);
+  assert.ok(intents.includes('PROFILE_AWARDS_BRANDS'));
+  assert.ok(!intents.includes('SYSTEM_SKILL'), '"file" inside "profile" must not route SYSTEM_SKILL');
+});
+
+test('off-topic queries enforce internet tools and suppress all catalog tools', () => {
+  const router = new DynamicToolRouter();
+  const catalogTools = new Set([
+    'search_works', 'get_work_detail', 'search_discography', 'get_profile_and_fandom',
+    'get_awards', 'get_brand_endorsements', 'get_career_timeline', 'get_character_roles',
+    'get_gallery_photos', 'get_quotes', 'get_social_feed', 'global_search', 'get_media_links',
+  ]);
+  for (const q of [
+    'วิธีทำต้มยำกุ้งน้ำข้น',
+    'แนะนำเพลงสากลเพราะๆ หน่อย',
+    'หนัง Dune ภาคใหม่สนุกไหม',
+    'ประวัติศาสตร์อยุธยาตอนต้น',
+    'เขียนฟังก์ชันเรียงข้อมูลให้หน่อย',
+  ]) {
+    const names = router.routeToolsForQuery(q).map(t => t.function?.name);
+    assert.ok(names.includes('web_search'), `${q} must include web_search`);
+    for (const c of catalogTools) {
+      assert.ok(!names.includes(c), `${q} must not route catalog tool ${c}`);
+    }
+  }
+});
+
+test('off-topic enforcement keeps in-domain music routing intact', () => {
+  const router = new DynamicToolRouter();
+  const names = router.routeToolsForQuery('เพลง 0.2s ใครร้อง').map(t => t.function?.name);
+  assert.ok(names.includes('search_discography'), 'in-domain song query keeps search_discography');
+});
+
+test('explicit @mention pins survive off-topic enforcement', () => {
+  const router = new DynamicToolRouter();
+  const names = router.routeToolsForQuery('วิธีทำต้มยำกุ้ง @search_works').map(t => t.function?.name);
+  assert.ok(names.includes('search_works'), 'explicit user pin must survive enforcement');
+});
+
+test('ฟังก์ชัน no longer collides with the ฟัง music intent', () => {
+  const router = new DynamicToolRouter();
+  const types = router.detectIntents('เขียนฟังก์ชันเรียงข้อมูลให้หน่อย').map(p => p.type);
+  assert.ok(!types.includes('MEDIA'), 'ฟังก์ชัน must not route MEDIA');
+  assert.ok(router.detectIntents('ขอฟังเพลงก่อนนอนหน่อย').map(p => p.type).includes('MEDIA'), 'ฟังเพลง must still route MEDIA');
+});
+
+test('promotion intent no longer fires on generic words like "look" or "brand"', () => {
+  assert.equal(detectPromotionIntent('What does she look like?'), false);
+  assert.equal(detectPromotionIntent('a brand new song'), false);
+  assert.equal(detectPromotionIntent('her fashion ambassador campaign'), true);
+  assert.equal(detectPromotionIntent('รับโปรโมทแบรนด์'), true);
+
+  const lookRes = resolveQueryEntities('What does she look like?');
+  assert.equal(lookRes.isPromotion, false);
+  assert.equal(lookRes.hasBrand, false);
+});
+
+test('brand entities have no Thai name fallback polluted by category strings', () => {
+  const index = buildCatalogIndex();
+  const prsr = index.find(e => e.id === 'prsr');
+  assert.ok(prsr, 'prsr entity must exist');
+  assert.equal(prsr.nameTh, '');
+});
+
+test('get_awards returns not_found instead of the full list when the query matches nothing', async () => {
+  const empty = await executeTool('get_awards', { query: 'quantum oscars 2099' });
+  assert.equal(empty.status, 'not_found');
+  assert.equal(empty.count, 0);
+  assert.deepEqual(empty.awards, []);
+
+  const all = await executeTool('get_awards', {});
+  assert.equal(all.status, 'success');
+  assert.ok(all.count > 0);
+});
+
+test('get_gallery_photos returns not_found instead of the full list when the query matches nothing', async () => {
+  const empty = await executeTool('get_gallery_photos', { query: 'quantum oscars 2099' });
+  assert.equal(empty.status, 'not_found');
+  assert.equal(empty.count, 0);
+  assert.deepEqual(empty.photos, []);
+});
+
+test('stopword-only catalog queries are flagged as broad matches with an explicit note', () => {
+  const matcher = createCatalogMatcher('MV จวีจิ้งอี');
+  assert.equal(matcher.broad, true, 'stopword-only query must set the broad flag');
+  assert.equal(createCatalogMatcher('In Blossom').broad, undefined, 'real-term queries must not set the broad flag');
+  assert.equal(createCatalogMatcher('').broad, undefined, 'empty query is an intentional full listing, not broad');
+});
+
+test('search_works appends a broad-query note so the model does not present latest entries as matches', async () => {
+  const broad = await executeTool('search_works', { query: 'MV จวีจิ้งอี' });
+  assert.equal(broad.status, 'success');
+  assert.ok(broad.message, 'broad query must attach an explanatory message');
+  assert.match(broad.message, /Broad query/);
+
+  const exact = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(exact.status, 'success');
+  assert.equal(exact.message, undefined);
+});
+
+test('text tool protocol parses against the active tool set, not the full schema', () => {
+  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 content = 'Action: get_awards\nAction Input: {"query": "Oscar"}';
+  const unrestricted = agent._extractTextToolCalls(content);
+  assert.ok(unrestricted.calls.length === 1, 'without routing, the full schema applies');
+
+  agent._activeToolSchema = agent.getAllToolsSchema().filter(t => t.function.name === 'search_works');
+  const restricted = agent._extractTextToolCalls(content);
+  assert.equal(restricted.calls.length, 0, 'tools hidden by the router must not be callable via text protocol');
+});

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

@@ -0,0 +1,259 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { executeTool, formatCatalogTitle, prepareToolArguments, toolHandlers } from '../tools.js';
+
+test('catalog titles do not repeat an alternate title already present', () => {
+  assert.equal(formatCatalogTitle('รักกลางสายฝน (Yu Ai / 雨爱)', '雨爱'), 'รักกลางสายฝน (Yu Ai / 雨爱)');
+  assert.equal(formatCatalogTitle('In Blossom', '花间令'), 'In Blossom (花间令)');
+});
+
+test('discography search reports an empty result as not found', async () => {
+  const result = await toolHandlers.search_discography({
+    query: 'no-such-kiku-track-xyz',
+    type: 'ost',
+  });
+
+  assert.equal(result.status, 'not_found');
+  assert.equal(result.count, 0);
+});
+
+test('supported drama OST example returns catalog entries', async () => {
+  const result = await toolHandlers.search_discography({
+    query: 'The Blooms at Ruyi Pavilion',
+    type: 'ost',
+  });
+
+  assert.equal(result.status, 'success');
+  assert.ok(result.count >= 1);
+});
+
+test('global search ignores generic OST wording and still finds the drama', async () => {
+  const result = await toolHandlers.global_search({ query: 'In Blossom OST songs' });
+
+  assert.equal(result.status, 'success');
+  assert.ok(result.results.works.some(work => work.title.includes('In Blossom')));
+});
+
+test('tool runtime rejects malformed JSON instead of inventing a query argument', () => {
+  const prepared = prepareToolArguments('global_search', '{query: broken json}');
+  assert.equal(prepared.safe, false);
+  assert.match(prepared.error, /Invalid JSON arguments/);
+});
+
+test('tool runtime validates required arguments and removes unknown keys', () => {
+  assert.equal(prepareToolArguments('global_search', {}).safe, false);
+  const prepared = prepareToolArguments('global_search', { query: 'In Blossom', unexpected: true });
+  assert.equal(prepared.safe, true);
+  assert.deepEqual(prepared.args, { query: 'In Blossom' });
+  assert.match(prepared.warnings.join(' '), /unexpected/);
+});
+
+test('tool runtime normalizes empty successful collections to not_found', async () => {
+  const result = await executeTool('search_works', { year: '1900' });
+  assert.equal(result.status, 'not_found');
+  assert.equal(result.count, 0);
+  assert.match(result.validationWarnings.join(' '), /converted to number/);
+});
+
+test('search_works maps category synonyms onto real catalog values (no false not_found)', async () => {
+ 
+  const series = await executeTool('search_works', { category: 'series', featuredOnly: true }, { noCache: true });
+  assert.equal(series.status, 'success');
+  assert.ok(series.count > 0);
+  assert.ok(series.works.every(w => ['historical-drama', 'modern-drama'].includes(w.category)));
+
+  const movie = await executeTool('search_works', { category: 'movie' }, { noCache: true });
+  assert.equal(movie.status, 'success');
+  assert.ok(movie.count >= 1);
+  assert.ok(movie.works.every(w => w.category === 'movie'));
+
+
+  const junk = await executeTool('search_works', { category: 'documentary' }, { noCache: true });
+  assert.equal(junk.status, 'not_found');
+});
+
+test('manage_skill tool executes learn, list, disable, and remove actions', async () => {
+  const memory = {
+    preferences: { skillsEnabled: true, userSkills: [] },
+    addUserSkill(inst) {
+      const s = { id: 'sk_test', instruction: inst };
+      this.preferences.userSkills.push(s);
+      return s;
+    },
+    removeUserSkill(id) {
+      const idx = this.preferences.userSkills.findIndex(s => s.id === id);
+      if (idx >= 0) {
+        this.preferences.userSkills.splice(idx, 1);
+        return true;
+      }
+      return false;
+    },
+    clearUserSkills() { this.preferences.userSkills = []; },
+    setPreference(k, v) { this.preferences[k] = v; },
+  };
+
+  const learnRes = await executeTool('manage_skill', { action: 'learn', instruction: 'ตอบสั้นกระชับ' }, { memory });
+  assert.equal(learnRes.status, 'success');
+  assert.equal(learnRes.skill.instruction, 'ตอบสั้นกระชับ');
+
+  const listRes = await executeTool('manage_skill', { action: 'list' }, { memory });
+  assert.equal(listRes.status, 'success');
+  assert.equal(listRes.skills.length, 1);
+
+  const disableRes = await executeTool('manage_skill', { action: 'disable' }, { memory });
+  assert.equal(disableRes.status, 'success');
+  assert.equal(memory.preferences.skillsEnabled, false);
+
+  const removeRes = await executeTool('manage_skill', { action: 'remove', skillId: 'sk_test' }, { memory });
+  assert.equal(removeRes.status, 'success');
+  assert.equal(memory.preferences.userSkills.length, 0);
+});
+
+test('run_subagent tool routes through agent context when available', async () => {
+  const mockAgent = {
+    async runSubagent(task) {
+      return { answer: `Report for ${task}`, toolCalls: [{ name: 'search_works' }], iterations: 1 };
+    }
+  };
+
+  const res = await executeTool('run_subagent', { task: 'Verify 2026 drama' }, { agent: mockAgent });
+  assert.equal(res.status, 'success');
+  assert.equal(res.task, 'Verify 2026 drama');
+  assert.match(res.answer, /Report for/);
+  assert.equal(res.toolCalls.length, 1);
+});
+
+test('run_deep_research and verify_claim route through agent research orchestrator', async () => {
+  let verifyModeCalled = false;
+  const mockAgent = {
+    async runResearch(query, options = {}) {
+      if (options.mode === 'verify') verifyModeCalled = true;
+      return { answer: `Synthesized for ${query}`, sources: ['https://example.com/source1'], reports: [] };
+    }
+  };
+
+  const researchRes = await executeTool('run_deep_research', { question: 'All 2026 plans' }, { agent: mockAgent });
+  assert.equal(researchRes.status, 'success');
+  assert.equal(researchRes.sources.length, 1);
+
+  const verifyRes = await executeTool('verify_claim', { claim: 'Is Qian Xiang releasing in 2026' }, { agent: mockAgent });
+  assert.equal(verifyRes.status, 'success');
+  assert.equal(verifyModeCalled, true);
+});
+
+test('globalToolCache stores and returns cached tool execution results', async () => {
+  const { globalToolCache, ToolCache } = await import('../tools.js');
+  const cache = new ToolCache(10, 5000);
+  cache.set('test_key', { data: 123 });
+  assert.deepEqual(cache.get('test_key'), { data: 123 });
+  assert.equal(cache.get('non_existent'), null);
+
+  const firstCall = await executeTool('get_awards', {});
+  assert.equal(firstCall.status, 'success');
+
+  const secondCall = await executeTool('get_awards', {});
+  assert.equal(secondCall.status, 'success');
+  assert.deepEqual(firstCall.awards, secondCall.awards);
+});
+
+test('get_brand_endorsements finds Versace and global brand ambassador roles', async () => {
+  const versaceRes = await executeTool('get_brand_endorsements', { query: 'Versace', isGlobal: true });
+  assert.equal(versaceRes.status, 'success');
+  assert.ok(versaceRes.count >= 1);
+  assert.ok(versaceRes.brands.some(b => b.brand.toLowerCase().includes('versace')));
+
+  const prsrRes = await executeTool('get_brand_endorsements', { query: 'PRSR' });
+  assert.equal(prsrRes.status, 'success');
+  assert.ok(prsrRes.count >= 1);
+  assert.ok(prsrRes.brands.some(b => b.brand.includes('PRSR')));
+});
+
+
+test('createCatalogMatcher uses scoring fuzzy matching for multi-word and misspelled queries', async () => {
+  const { createCatalogMatcher } = await import('../tools.js');
+  const matcher = createCatalogMatcher('เพลง Ost Ju Jingyi 2024 Yunxi');
+  assert.equal(matcher('ตำนานหยุนซี Legend of Yunxi', 'Yunxi'), true);
+
+  const res = await executeTool('search_works', { query: 'เพลง Ost Ju Jingyi 2024 Yunxi' });
+  assert.equal(res.status, 'success');
+  assert.ok(res.count > 0);
+  assert.ok(res.works.some(w => (w.titleTh || '').includes('หยุนซี') || (w.titleEn || '').toLowerCase().includes('yunxi')));
+});
+
+test('empty or not_found tool results are not stored in globalToolCache', async () => {
+  const { globalToolCache } = await import('../tools.js');
+  const query = 'totally_fake_drama_xyz_never_exists_123';
+  const notFound = await executeTool('search_works', { query });
+  assert.equal(notFound.status, 'not_found');
+
+  const cacheKey = `search_works:${JSON.stringify({ query })}`;
+  assert.equal(globalToolCache.get(cacheKey), null);
+});
+
+test('get_system_stats returns dynamically computed activeYears and metadata', async () => {
+  const statsRes = await executeTool('get_system_stats', {});
+  assert.equal(statsRes.status, 'success');
+  assert.equal(statsRes.sourceType, 'local_database');
+  assert.ok(statsRes.dataFreshness);
+  assert.match(statsRes.stats.activeYears, /2013 - Present/);
+  assert.ok(Array.isArray(statsRes.stats.featured2026Works));
+  assert.ok(statsRes.stats.featured2026Works.length > 0);
+});
+
+test('tool results distinguish direct links from search URLs with isDirectLink', async () => {
+  const worksRes = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(worksRes.status, 'success');
+  const work = worksRes.works[0];
+  assert.equal(work.youtubeTrailerIsDirectLink, false);
+  if (work.themeSong) {
+    assert.equal(typeof work.themeSong.isDirectLink, 'boolean');
+  }
+
+  const discoRes = await executeTool('search_discography', { query: 'In Blossom' });
+  assert.equal(discoRes.status, 'success');
+  assert.equal(typeof discoRes.songs[0].isDirectLink, 'boolean');
+});
+
+test('generic artist-name queries return catalog data instead of false not_found', async () => {
+  for (const tool of ['search_works', 'search_discography', 'get_character_roles', 'get_music_videos', 'get_brand_endorsements', 'global_search']) {
+    const res = await executeTool(tool, { query: 'Ju Jingyi' }, { noCache: true });
+    assert.equal(res.status, 'success', `${tool} should not not_found a generic artist query`);
+    assert.ok((res.count ?? 0) > 0, `${tool} should return items for a generic artist query`);
+  }
+  const gallery = await executeTool('get_gallery_photos', { query: 'Ju Jingyi' }, { noCache: true });
+  assert.equal(gallery.status, 'success');
+  assert.ok(gallery.count > 0);
+});
+
+test('latest-intent queries fall back to the newest-first catalog list', async () => {
+  const works = await executeTool('search_works', { query: 'เรื่องล่าสุด' }, { noCache: true });
+  assert.equal(works.status, 'success');
+  assert.ok(works.count > 0);
+
+  const songs = await executeTool('search_discography', { query: 'เพลงล่าสุด' }, { noCache: true });
+  assert.equal(songs.status, 'success');
+  assert.ok(songs.count > 0);
+});
+
+test('get_social_feed aggregates douyin and weibo cards', async () => {
+  const res = await executeTool('get_social_feed', { limit: 4 }, { noCache: true });
+  assert.equal(res.status, 'success');
+  assert.ok(res.count > 0);
+  assert.ok(res.posts.every(p => p.platform === 'douyin' || p.platform === 'weibo'));
+  assert.ok(res.posts[0].content && res.posts[0].content.length > 10);
+
+  const weibo = await executeTool('get_social_feed', { platform: 'weibo', limit: 2 }, { noCache: true });
+  assert.equal(weibo.status, 'success');
+  assert.ok(weibo.posts.every(p => p.platform === 'weibo'));
+});
+
+test('get_work_detail resolves dash/underscore/space id variants and fuzzy titles', async () => {
+  for (const variant of ['in-blossom', 'in_blossom', 'in blossom']) {
+    const res = await executeTool('get_work_detail', { workIdOrTitle: variant }, { noCache: true });
+    assert.equal(res.status, 'success', `id variant "${variant}" should resolve`);
+    assert.match(res.work.id, /in-blossom/);
+  }
+  const missing = await executeTool('get_work_detail', { workIdOrTitle: 'no-such-work-xyz' }, { noCache: true });
+  assert.equal(missing.status, 'not_found');
+});

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

@@ -0,0 +1,159 @@
+import test, { after } from 'node:test';
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+import assert from 'node:assert/strict';
+const isolatedSettingsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kiku-provider-test-'));
+process.env.KIKU_DATA_DIR = isolatedSettingsDir;
+after(() => fs.rmSync(isolatedSettingsDir, { recursive: true, force: true }));
+const {
+  DEFAULT_LOCAL_ENDPOINTS,
+  getProviderBaseUrl,
+  savePersistedProviderBaseUrl,
+  setActiveProvider,
+  getUnifiedProviderCatalog,
+  config
+} = await import("../config.js");
+const { LLMClient } = await import("../llmClient.js");
+const { routeCommand } = await import("../commands.js");
+const { handleProviderGetRoute, handleProviderUpdateRoute } = await import("../../web-chat/routes/providerRoute.js");
+
+test('DEFAULT_LOCAL_ENDPOINTS exposes canonical local endpoints', () => {
+  assert.equal(DEFAULT_LOCAL_ENDPOINTS.lmstudio, 'http://127.0.0.1:1234/v1');
+  assert.equal(DEFAULT_LOCAL_ENDPOINTS.vllm, 'http://127.0.0.1:8000/v1');
+});
+
+test('getProviderBaseUrl resolves local engines and custom endpoints correctly', () => {
+  const lmUrl = getProviderBaseUrl('lmstudio');
+  assert.ok(lmUrl.includes(':1234') || lmUrl.startsWith('http://127.0.0.1:1234'));
+
+  const vllmUrl = getProviderBaseUrl('vllm');
+  assert.ok(vllmUrl.includes(':8000') || vllmUrl.startsWith('http://127.0.0.1:8000'));
+
+  const customTestUrl = 'http://127.0.0.1:8888/v1';
+  savePersistedProviderBaseUrl('vllm', customTestUrl);
+  assert.equal(getProviderBaseUrl('vllm'), customTestUrl);
+
+
+  savePersistedProviderBaseUrl('vllm', DEFAULT_LOCAL_ENDPOINTS.vllm);
+  assert.equal(getProviderBaseUrl('vllm'), DEFAULT_LOCAL_ENDPOINTS.vllm);
+});
+
+test('setActiveProvider updates active provider and in-memory configuration', () => {
+  const infoVllm = setActiveProvider('vllm');
+  assert.equal(infoVllm.provider, 'vllm');
+  assert.equal(config.activeProvider, 'vllm');
+  assert.equal(config.lmStudio.baseUrl, getProviderBaseUrl('vllm'));
+
+  const catalog = getUnifiedProviderCatalog();
+  assert.equal(catalog.activeProvider, 'vllm');
+  assert.equal(catalog.localEndpoints.vllm.isActive, true);
+  assert.equal(catalog.localEndpoints.lmstudio.isActive, false);
+
+  const infoLm = setActiveProvider('lmstudio');
+  assert.equal(infoLm.provider, 'lmstudio');
+  assert.equal(config.activeProvider, 'lmstudio');
+  assert.equal(config.lmStudio.baseUrl, getProviderBaseUrl('lmstudio'));
+
+  const catalogLm = getUnifiedProviderCatalog();
+  assert.equal(catalogLm.activeProvider, 'lmstudio');
+  assert.equal(catalogLm.localEndpoints.lmstudio.isActive, true);
+  assert.equal(catalogLm.localEndpoints.vllm.isActive, false);
+});
+
+test('LLMClient respects unified baseUrl for vLLM and LM Studio', () => {
+  const vllmClient = new LLMClient({ provider: 'vllm' });
+  assert.equal(vllmClient.provider, 'vllm');
+  assert.equal(vllmClient.baseUrl, getProviderBaseUrl('vllm'));
+  assert.equal(vllmClient._buildHeaders()['Authorization'], 'Bearer token-kiku');
+
+  vllmClient.setBaseUrl('http://127.0.0.1:8008/v1');
+  assert.equal(vllmClient.baseUrl, 'http://127.0.0.1:8008/v1');
+  assert.equal(getProviderBaseUrl('vllm'), 'http://127.0.0.1:8008/v1');
+
+  vllmClient.setBaseUrl(DEFAULT_LOCAL_ENDPOINTS.vllm);
+  assert.equal(vllmClient.baseUrl, DEFAULT_LOCAL_ENDPOINTS.vllm);
+
+  const lmClient = new LLMClient({ provider: 'lmstudio' });
+  assert.equal(lmClient.provider, 'lmstudio');
+  assert.equal(lmClient.baseUrl, getProviderBaseUrl('lmstudio'));
+  assert.equal(lmClient._buildHeaders()['Authorization'], 'Bearer lm-studio');
+});
+
+test('CLI routeCommand handles /provider url, /url, and /endpoint', async () => {
+  const fakeContext = {
+    client: new LLMClient({ provider: 'vllm' }),
+    agent: null,
+    parts: ['/provider', 'url'],
+    sub: 'url',
+    extra: '',
+  };
+
+  const res1 = await routeCommand('/provider url', fakeContext);
+  assert.equal(res1, 'HANDLED');
+
+  const res2 = await routeCommand('/url', fakeContext);
+  assert.equal(res2, 'HANDLED');
+
+  const res3 = await routeCommand('/endpoint', fakeContext);
+  assert.equal(res3, 'HANDLED');
+
+  const res4 = await routeCommand('/provider url vllm http://127.0.0.1:8000/v1', {
+    ...fakeContext,
+    parts: ['/provider', 'url', 'vllm', 'http://127.0.0.1:8000/v1'],
+    sub: 'url'
+  });
+  assert.equal(res4, 'HANDLED');
+});
+
+import { Readable } from 'node:stream';
+
+test('Web Chat /api/provider GET and POST routes work as unified manager', async () => {
+  let resStatus = null;
+  let resPayload = null;
+
+  const mockRes = {
+    writeHead(status, headers) {
+      resStatus = status;
+    },
+    end(content) {
+      if (content) resPayload = JSON.parse(content);
+    },
+    setHeader() {}
+  };
+
+  await handleProviderGetRoute({}, mockRes);
+  assert.equal(resStatus, 200);
+  assert.ok(resPayload);
+  assert.equal(resPayload.status, 'ok');
+  assert.ok(resPayload.localEndpoints.lmstudio);
+  assert.ok(resPayload.localEndpoints.vllm);
+
+
+  const updateReq = Readable.from([
+    Buffer.from(JSON.stringify({
+      provider: 'vllm',
+      baseUrl: 'http://127.0.0.1:8000/v1'
+    }))
+  ]);
+
+  let postStatus = null;
+  let postPayload = null;
+  const mockPostRes = {
+    writeHead(status, headers) {
+      postStatus = status;
+    },
+    end(content) {
+      if (content) postPayload = JSON.parse(content);
+    },
+    setHeader() {}
+  };
+
+  updateReq.socket = { remoteAddress: '127.0.0.1' };
+  await handleProviderUpdateRoute(updateReq, mockPostRes);
+  assert.equal(postStatus, 200);
+  assert.equal(postPayload.activeProvider, 'vllm');
+  assert.equal(postPayload.activeBaseUrl, 'http://127.0.0.1:8000/v1');
+
+  setActiveProvider('lmstudio');
+});