kiku-agent 1.3.2 → 1.3.4

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

@@ -0,0 +1,278 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+
+import {
+  probeLmStudioRuntime,
+  isLmStudioResponding,
+  getLoadedModels,
+  wakeUpLmStudio,
+  clearLmStudioProbeCache,
+  buildLmsLoadArgs,
+  resolveParallelSlotBudget
+} from '../lmStudioWakeup.js';
+import { probeLmStudioRuntime as vramProbe } from '../vramService.js';
+
+test('probeLmStudioRuntime returns safe offline defaults when unreachable', async () => {
+  clearLmStudioProbeCache();
+  const offlineUrl = 'http://127.0.0.1:9/v1';
+  const result = await probeLmStudioRuntime(offlineUrl, { timeoutMs: 500, bypassCache: true });
+
+  assert.equal(result.reachable, false);
+  assert.equal(result.loadedModel, null);
+  assert.deepEqual(result.loadedModels, []);
+  assert.equal(result.loadedContextLength, null);
+  assert.equal(result.quantization, null);
+  assert.deepEqual(result.models, []);
+});
+
+test('isLmStudioResponding and getLoadedModels return expected offline values', async () => {
+  clearLmStudioProbeCache();
+  const offlineUrl = 'http://127.0.0.1:9/v1';
+  const isResponding = await isLmStudioResponding(offlineUrl, 300);
+  assert.equal(isResponding, false);
+
+  const loaded = await getLoadedModels(offlineUrl, 300);
+  assert.deepEqual(loaded, []);
+});
+
+test('vramService re-exports probeLmStudioRuntime with identical signature and behavior', async () => {
+  clearLmStudioProbeCache();
+  const offlineUrl = 'http://127.0.0.1:9/v1';
+  const result = await vramProbe(offlineUrl);
+  assert.equal(result.reachable, false);
+  assert.equal(result.loadedModel, null);
+  assert.equal(result.loadedContextLength, null);
+});
+
+test('wakeUpLmStudio strictly skips non-local endpoints', async () => {
+  const remoteResult = await wakeUpLmStudio({ baseUrl: 'https://remote-llm-host.example.com/v1' });
+  assert.equal(remoteResult.ok, false);
+  assert.match(remoteResult.reason, /Non-local|non-standard/i);
+});
+
+test('probeLmStudioRuntime correctly parses proprietary /api/v0/models structure', async () => {
+  clearLmStudioProbeCache();
+  const server = createServer((req, res) => {
+    if (req.url === '/api/v0/models') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        data: [
+          {
+            id: 'google/gemma-4-e4b',
+            type: 'llm',
+            state: 'loaded',
+            loaded_context_length: 32768,
+            quantization: 'q4_k_m'
+          },
+          {
+            id: 'qwen2.5-coder-7b',
+            type: 'llm',
+            state: 'not_loaded'
+          }
+        ]
+      }));
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  const mockUrl = `http://127.0.0.1:${port}/v1`;
+
+  try {
+    const probe = await probeLmStudioRuntime(mockUrl, { bypassCache: true });
+    assert.equal(probe.reachable, true);
+    assert.equal(probe.loadedModel, 'google/gemma-4-e4b');
+    assert.deepEqual(probe.loadedModels, ['google/gemma-4-e4b']);
+    assert.equal(probe.loadedContextLength, 32768);
+    assert.equal(probe.quantization, 'q4_k_m');
+    assert.deepEqual(probe.models, ['google/gemma-4-e4b', 'qwen2.5-coder-7b']);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('probeLmStudioRuntime falls back to /v1/models if /api/v0/models returns 404', async () => {
+  clearLmStudioProbeCache();
+  const server = createServer((req, res) => {
+    if (req.url === '/v1/models') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        data: [
+          { id: 'fallback-model-a' },
+          { id: 'fallback-model-b' }
+        ]
+      }));
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  const mockUrl = `http://127.0.0.1:${port}/v1`;
+
+  try {
+    const probe = await probeLmStudioRuntime(mockUrl, { bypassCache: true });
+    assert.equal(probe.reachable, true);
+    assert.equal(probe.loadedModel, 'fallback-model-a');
+    assert.deepEqual(probe.models, ['fallback-model-a', 'fallback-model-b']);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('buildLmsLoadArgs constructs correct lms CLI args with GPU offload and threads', () => {
+  const base = buildLmsLoadArgs('google/gemma-4-e4b');
+  assert.deepEqual(base, [
+    'load', 'google/gemma-4-e4b', '-y', '--identifier', 'google/gemma-4-e4b',
+    '--context-length', '32768', '--parallel', '1'
+  ]);
+
+  const withMax = buildLmsLoadArgs('test-model', { gpuOffload: 'max' });
+  assert.ok(withMax.includes('--gpu'));
+  assert.equal(withMax[withMax.indexOf('--gpu') + 1], 'max');
+
+  const withOff = buildLmsLoadArgs('test-model', { gpuOffload: 'off' });
+  assert.equal(withOff[withOff.indexOf('--gpu') + 1], 'off');
+
+  const withRatio = buildLmsLoadArgs('test-model', { gpuOffload: 0.75 });
+  assert.equal(withRatio[withRatio.indexOf('--gpu') + 1], '0.75');
+
+  const withCtx = buildLmsLoadArgs('test-model', { contextLength: 32768 });
+  assert.ok(withCtx.includes('--context-length'));
+  assert.equal(withCtx[withCtx.indexOf('--context-length') + 1], '32768');
+
+  const withThreads = buildLmsLoadArgs('test-model', { cpuThreads: 4 });
+  assert.ok(withThreads.includes('--parallel'));
+  assert.equal(withThreads[withThreads.indexOf('--parallel') + 1], '4');
+
+  const withAuto = buildLmsLoadArgs('test-model', { gpuOffload: 'auto' });
+  assert.ok(!withAuto.includes('--gpu'), 'auto should not add --gpu flag');
+
+  const withAll = buildLmsLoadArgs('test-model', { gpuOffload: 'max', cpuThreads: 8, contextLength: 16384 });
+  assert.ok(withAll.includes('--gpu'));
+  assert.ok(withAll.includes('--parallel'));
+  assert.ok(withAll.includes('--context-length'));
+});
+
+test('buildLmsLoadArgs maps layer counts and handles out-of-range values safely', () => {
+  const withLayers = buildLmsLoadArgs('test-model', { nGpuLayers: 29 });
+  assert.ok(withLayers.includes('--gpu'));
+  assert.equal(withLayers[withLayers.indexOf('--gpu') + 1], '0.88');
+
+  const with99Layers = buildLmsLoadArgs('test-model', { nGpuLayers: 99 });
+  assert.equal(with99Layers[with99Layers.indexOf('--gpu') + 1], 'max');
+
+  const with0Layers = buildLmsLoadArgs('test-model', { nGpuLayers: 0 });
+  assert.equal(with0Layers[with0Layers.indexOf('--gpu') + 1], 'off');
+
+  const withThreadsAlias = buildLmsLoadArgs('test-model', { threads: 6 });
+  assert.ok(withThreadsAlias.includes('--parallel'));
+  assert.equal(withThreadsAlias[withThreadsAlias.indexOf('--parallel') + 1], '6');
+
+  const badCtx = buildLmsLoadArgs('test-model', { contextLength: 100 });
+  assert.ok(!badCtx.includes('--context-length'), 'ctx < 512 should be ignored');
+
+  const badThreads = buildLmsLoadArgs('test-model', { cpuThreads: 999 });
+  assert.ok(!badThreads.includes('--parallel'), 'threads > 256 should be ignored');
+
+  const nullGpu = buildLmsLoadArgs('test-model', { gpuOffload: null });
+  assert.ok(!nullGpu.includes('--gpu'), 'null should not add --gpu');
+});
+
+test('buildLmsLoadArgs clamps --parallel to available CPU resources', () => {
+  const clamped = buildLmsLoadArgs('test-model', { cpuThreads: 64, availableCpus: 8 });
+  assert.ok(clamped.includes('--parallel'));
+  assert.equal(clamped[clamped.indexOf('--parallel') + 1], '8');
+
+  const within = buildLmsLoadArgs('test-model', { cpuThreads: 4, availableCpus: 8 });
+  assert.equal(within[within.indexOf('--parallel') + 1], '4');
+
+  const zero = buildLmsLoadArgs('test-model', { cpuThreads: 0, availableCpus: 8 });
+  assert.ok(!zero.includes('--parallel'), 'threads < 1 should be ignored');
+
+  const tinyHost = buildLmsLoadArgs('test-model', { parallel: 4, availableCpus: 1 });
+  assert.equal(tinyHost[tinyHost.indexOf('--parallel') + 1], '1');
+
+  const aliasClamped = buildLmsLoadArgs('test-model', { threads: 32, availableCpus: 6 });
+  assert.equal(aliasClamped[aliasClamped.indexOf('--parallel') + 1], '6');
+
+  assert.equal(resolveParallelSlotBudget(32, 8).value, 8);
+  assert.equal(resolveParallelSlotBudget(32, 8).capped, true);
+  assert.equal(resolveParallelSlotBudget(4, 8).value, 4);
+  assert.equal(resolveParallelSlotBudget(4, 8).capped, false);
+  assert.equal(resolveParallelSlotBudget(999, 8).value, undefined);
+  assert.equal(resolveParallelSlotBudget('abc', 8).value, undefined);
+  assert.equal(resolveParallelSlotBudget(4, 0).ceiling, 4);
+});
+
+test('normalizeModelLoadSettings round-trips persisted values correctly', async () => {
+  const { normalizeModelLoadSettings, MODEL_LOAD_DEFAULTS } = await import('../config.js');
+
+  const defaults = normalizeModelLoadSettings({});
+  assert.equal(defaults.gpuOffload, 'auto');
+  assert.equal(defaults.cpuThreads, 1);
+  assert.equal(defaults.contextLength, 32768);
+
+  const withMax = normalizeModelLoadSettings({ gpuOffload: 'max', cpuThreads: 4 });
+  assert.equal(withMax.gpuOffload, 'max');
+  assert.equal(withMax.cpuThreads, 4);
+
+  const withRatio = normalizeModelLoadSettings({ gpuOffload: '0.5' });
+  assert.equal(withRatio.gpuOffload, 0.5);
+
+  const resetThreads = normalizeModelLoadSettings({ cpuThreads: null }, withMax);
+  assert.equal(resetThreads.cpuThreads, null);
+  assert.equal(resetThreads.gpuOffload, 'max');
+
+  const clamped = normalizeModelLoadSettings({ cpuThreads: 999 });
+  assert.equal(clamped.cpuThreads, null, 'out-of-range threads should be rejected');
+
+  const badGpu = normalizeModelLoadSettings({ gpuOffload: 'invalid' });
+  assert.equal(badGpu.gpuOffload, 'auto', 'invalid GPU value should fall back to auto');
+});
+
+test('normalizeLmStudioModelKey resolves raw GGUF filenames to valid LM Studio keys', async () => {
+  const { normalizeLmStudioModelKey } = await import('../lmStudioWakeup.js');
+  assert.equal(normalizeLmStudioModelKey('gemma-4-E4B-it-Q4_K_M.gguf'), 'google/gemma-4-e4b');
+  assert.equal(normalizeLmStudioModelKey('C:\\models\\gemma-4-E4B-it-Q4_K_M.gguf'), 'google/gemma-4-e4b');
+  assert.equal(normalizeLmStudioModelKey('gemma-4-e4b-Q6_K.gguf'), 'google/gemma-4-e4b@q6_k');
+  assert.equal(normalizeLmStudioModelKey('gemma-4-e4b-Q8_0.gguf'), 'google/gemma-4-e4b@q8_0');
+  assert.equal(normalizeLmStudioModelKey('google/gemma-4-e4b'), 'google/gemma-4-e4b');
+  assert.equal(normalizeLmStudioModelKey('google/gemma-4-e4b@q4_k_m'), 'google/gemma-4-e4b@q4_k_m');
+  assert.equal(normalizeLmStudioModelKey('custom-chat-model.gguf'), 'custom-chat-model');
+});
+
+test('buildLmsLoadArgs strictly excludes unsupported CLI options (flash-attn, split-mode, tensor-split, etc.)', async () => {
+  const { getPersistedModelLoadSettings } = await import('../config.js');
+  const persisted = getPersistedModelLoadSettings();
+  const args = buildLmsLoadArgs('google/gemma-4-e4b', {
+    ...persisted,
+    flashAttn: true,
+    splitMode: 'layer',
+    tensorSplit: '20,12',
+    mainGpu: 0,
+    batchSize: 2048,
+    ubatchSize: 512,
+  });
+
+  assert.ok(!args.includes('--flash-attn'), 'lms load does not support --flash-attn');
+  assert.ok(!args.includes('--split-mode'), 'lms load does not support --split-mode');
+  assert.ok(!args.includes('--tensor-split'), 'lms load does not support --tensor-split');
+  assert.ok(!args.includes('--main-gpu'), 'lms load does not support --main-gpu');
+  assert.ok(!args.includes('--batch-size'), 'lms load does not support --batch-size');
+  assert.ok(!args.includes('--ubatch-size'), 'lms load does not support --ubatch-size');
+
+  const validPrefixes = ['load', '-y', '--identifier', '--gpu', '--context-length', '--parallel', '--ttl'];
+  for (const item of args) {
+    if (item.startsWith('-')) {
+      assert.ok(validPrefixes.includes(item), `Unexpected CLI option passed to lms load: ${item}`);
+    }
+  }
+});
+

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

@@ -0,0 +1,278 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { toolsSchema, toolHandlers } from '../tools.js';
+import { dynamicToolRouter } from '../toolRouter.js';
+import { buildSystemPrompt } from '../prompts.js';
+import {
+  calculateHaversineDistance,
+  estimateWalkingTime,
+  estimateDrivingTime,
+  formatDistance,
+  findNearestLandmark,
+  buildOsmMapTag,
+  buildOsmUrl,
+  cleanLocationQuery,
+  LANDMARK_REGISTRY,
+  detectIpLocation,
+  fetchRealtimeWeather,
+  rankLandmarksByScore,
+  scoreLocationSearchResult,
+  rankLocationSearchResults,
+  scoreLocationConfidence
+} from '../locationService.js';
+
+describe('get_user_location & Precise Geolocation Pipeline', () => {
+  test('calculateHaversineDistance calculates accurate spherical distance', () => {
+    const distBangkokToChiangMai = calculateHaversineDistance(13.7563, 100.5018, 18.7883, 98.9853);
+    assert.ok(distBangkokToChiangMai > 570000 && distBangkokToChiangMai < 610000);
+
+    const distClose = calculateHaversineDistance(13.7563, 100.5018, 13.7567, 100.5018);
+    assert.ok(distClose < 100);
+  });
+
+  test('estimateWalkingTime and estimateDrivingTime calculate logical travel times', () => {
+    const walking1600m = estimateWalkingTime(1600);
+    assert.equal(walking1600m, 20);
+
+    const driving20km = estimateDrivingTime(20000);
+    assert.equal(driving20km, 30);
+
+    assert.equal(formatDistance(450), '450 m');
+    assert.equal(formatDistance(3200), '3.2 km');
+  });
+
+  test('findNearestLandmark accurately matches nearest landmark in Thailand and China', () => {
+    const nearDemocracy = findNearestLandmark(13.7563, 100.5018);
+    assert.ok(nearDemocracy);
+    assert.equal(nearDemocracy.landmark.id, 'democracy_monument');
+    assert.ok(nearDemocracy.distanceMeters < 100);
+
+    const nearHengdian = findNearestLandmark(29.1454, 120.3104);
+    assert.ok(nearHengdian);
+    assert.equal(nearHengdian.landmark.id, 'hengdian_studios');
+    assert.ok(nearHengdian.distanceMeters < 100);
+  });
+
+  test('buildOsmMapTag and buildOsmUrl format compliant tags and links', () => {
+    const tag = buildOsmMapTag(13.7563, 100.5018, 'Bangkok Center');
+    assert.equal(tag, '[MAP_OSM:13.7563,100.5018,Bangkok Center]');
+
+    const url = buildOsmUrl(13.7563, 100.5018, 16);
+    assert.ok(url.includes('openstreetmap.org/?mlat=13.7563&mlon=100.5018'));
+  });
+
+  test('cleanLocationQuery strips colloquial prefixes', () => {
+    assert.equal(cleanLocationQuery('ขอแผนที่สยามพารากอน'), 'สยามพารากอน');
+    assert.equal(cleanLocationQuery('พิกัดของพระราชวังต้องห้าม'), 'พระราชวังต้องห้าม');
+    assert.equal(cleanLocationQuery('where is Hengdian World Studios'), 'Hengdian World Studios');
+  });
+
+  test('toolsSchema includes get_user_location and search_location_map with correct schemas', () => {
+    const locTool = toolsSchema.find(t => (t.function?.name || t.name) === 'get_user_location');
+    assert.ok(locTool);
+    const locFn = locTool.function || locTool;
+    assert.equal(locFn.parameters.type, 'object');
+    assert.ok(locFn.parameters.properties.reason);
+    assert.ok(locFn.parameters.properties.query);
+    assert.ok(locFn.parameters.properties.latitude);
+    assert.ok(locFn.parameters.properties.longitude);
+
+    const mapTool = toolsSchema.find(t => (t.function?.name || t.name) === 'search_location_map');
+    assert.ok(mapTool);
+    const mapFn = mapTool.function || mapTool;
+    assert.equal(mapFn.parameters.type, 'object');
+    assert.ok(mapFn.parameters.properties.query);
+    assert.ok(mapFn.parameters.required.includes('query'));
+  });
+
+  test('toolHandlers.get_user_location returns enhanced coordinates and landmark context', async () => {
+    const mockClientLocation = {
+      latitude: 13.7563,
+      longitude: 100.5018,
+      accuracy: 12,
+      city: 'Bangkok',
+      country: 'Thailand',
+      source: 'gps'
+    };
+
+    const res = await toolHandlers.get_user_location(
+      { reason: 'Check current weather' },
+      { clientLocation: mockClientLocation }
+    );
+
+    assert.equal(res.status, 'success');
+    assert.equal(res.location_granted, true);
+    assert.equal(res.source, 'client_location');
+    assert.equal(res.latitude, 13.7563);
+    assert.equal(res.longitude, 100.5018);
+    assert.ok(res.nearest_landmark);
+    assert.equal(res.nearest_landmark.landmark.id, 'democracy_monument');
+    assert.ok(res.map_url);
+    assert.ok(res.map_tag.startsWith('[MAP_OSM:13.7563,100.5018'));
+  });
+
+  test('toolHandlers.get_user_location returns system or IP location fallback with nearest landmark', async () => {
+    const res = await toolHandlers.get_user_location(
+      { reason: 'Check local time and weather' },
+      {}
+    );
+
+    assert.equal(res.status, 'success');
+    assert.ok(typeof res.timezone === 'string' && res.timezone.length > 0);
+    assert.ok(typeof res.estimated_city === 'string');
+    assert.ok(typeof res.latitude === 'number');
+    assert.ok(typeof res.longitude === 'number');
+    assert.equal(res.location_granted, true);
+    assert.ok(res.source === 'ip_lookup' || res.source === 'system_timezone_estimate');
+    assert.ok(res.nearest_landmark);
+    assert.ok(res.map_tag);
+  });
+
+  test('toolHandlers.get_user_location handles client denied status gracefully', async () => {
+    const deniedClientLocation = {
+      denied: true
+    };
+
+    const res = await toolHandlers.get_user_location(
+      { reason: 'Check current weather' },
+      { clientLocation: deniedClientLocation }
+    );
+
+    assert.equal(res.status, 'permission_denied_or_unavailable');
+    assert.equal(res.location_granted, false);
+    assert.ok(res.message);
+  });
+
+  test('toolHandlers.search_location_map requires query and handles empty input gracefully', async () => {
+    const res = await toolHandlers.search_location_map({});
+    assert.equal(res.status, 'error');
+    assert.ok(res.message.includes('query'));
+  });
+
+  test('routeTools prioritizes get_user_location and search_location_map for weather and map queries', () => {
+    const weatherQueries = [
+      'สภาพอากาศในตอนนี้',
+      'อากาศวันนี้เป็นอย่างไรบ้าง',
+      'What is the weather today?',
+      'พยากรณ์อากาศกรุงเทพ',
+      'ร้านอาหารใกล้ฉัน'
+    ];
+
+    for (const q of weatherQueries) {
+      const routed = dynamicToolRouter.routeToolsForQuery(q);
+      const names = routed.map(t => t.function?.name || t.name);
+      assert.ok(
+        names.includes('get_user_location') || names.includes('get_weather'),
+        `Query "${q}" should route to location or weather tools`
+      );
+      assert.ok(
+        names.includes('get_weather'),
+        `Query "${q}" should route to get_weather`
+      );
+    }
+
+    const mapQueries = [
+      'ขอแผนที่สยามพารากอน',
+      'พิกัดของโรงถ่ายเหิงเตี้ยน',
+      'where is Shanghai Grand Theatre map',
+      'เปิดแมพนำทางไปวัดพระแก้ว'
+    ];
+
+    for (const q of mapQueries) {
+      const routed = dynamicToolRouter.routeToolsForQuery(q);
+      const names = routed.map(t => t.function?.name || t.name);
+      assert.ok(
+        names.includes('search_location_map'),
+        `Query "${q}" should route to search_location_map`
+      );
+    }
+  });
+
+  test('buildSystemPrompt includes anti-refusal directive and map instructions', () => {
+    const prompt = buildSystemPrompt(['get_user_location', 'search_location_map']);
+    assert.ok(prompt.includes('get_user_location'));
+    assert.ok(prompt.includes('search_location_map'));
+    assert.ok(prompt.includes('MAP_OSM'));
+    assert.ok(
+      prompt.includes('สภาพอากาศ') ||
+      prompt.includes('location') ||
+      prompt.includes('พิกัด')
+    );
+  });
+
+  test('detectIpLocation resolves coordinates and city without crashing', async () => {
+    const loc = await detectIpLocation();
+    assert.ok(loc);
+    assert.ok(typeof loc.latitude === 'number');
+    assert.ok(typeof loc.longitude === 'number');
+    assert.ok(typeof loc.city === 'string');
+    assert.ok(typeof loc.country === 'string');
+  });
+
+  test('fetchRealtimeWeather retrieves real-time weather metrics from Open-Meteo', async () => {
+    const weather = await fetchRealtimeWeather(13.7563, 100.5018);
+    if (weather) {
+      assert.equal(weather.status, 'success');
+      assert.ok(typeof weather.temperature === 'number');
+      assert.ok(typeof weather.humidity === 'number');
+      assert.ok(typeof weather.summaryTh === 'string');
+      assert.ok(typeof weather.conditionTh === 'string');
+    }
+  });
+
+  test('toolHandlers.get_weather resolves weather for location or detected coordinates', async () => {
+    const res = await toolHandlers.get_weather({ location: 'Bangkok' });
+    assert.equal(res.status, 'success');
+    assert.ok(res.location.includes('Bangkok') || res.location.includes('กรุงเทพ'));
+    assert.ok(res.latitude);
+    assert.ok(res.longitude);
+    assert.ok(res.map_tag);
+
+    const autoRes = await toolHandlers.get_weather({});
+    assert.equal(autoRes.status, 'success');
+    assert.ok(autoRes.location);
+    assert.ok(autoRes.latitude);
+    assert.ok(autoRes.map_tag);
+  });
+
+  test('rankLandmarksByScore ranks landmarks using multi-factor scores', () => {
+    const ranked = rankLandmarksByScore(13.7563, 100.5018, { city: 'Bangkok' });
+    assert.ok(Array.isArray(ranked) && ranked.length > 0);
+    assert.ok(ranked[0].finalScore >= ranked[1].finalScore);
+    assert.ok(typeof ranked[0].distanceScore === 'number');
+    assert.ok(typeof ranked[0].prominenceScore === 'number');
+    assert.equal(ranked[0].landmark.id, 'democracy_monument');
+  });
+
+  test('rankLocationSearchResults ranks items by name match, type, and importance', () => {
+    const mockResults = [
+      { name: 'กรุงเทพมหานคร', displayName: 'กรุงเทพมหานคร, ประเทศไทย', type: 'city', category: 'administrative', importance: 0.8 },
+      { name: 'ซอยกรุงเทพ', displayName: 'ซอยกรุงเทพ, นนทบุรี', type: 'residential', category: 'highway', importance: 0.2 }
+    ];
+    const ranked = rankLocationSearchResults(mockResults, 'กรุงเทพมหานคร');
+    assert.equal(ranked[0].name, 'กรุงเทพมหานคร');
+    assert.ok(ranked[0].relevanceScore > ranked[1].relevanceScore);
+  });
+
+  test('scoreLocationConfidence computes quantitative confidence score and tier', () => {
+    const high = scoreLocationConfidence({ source: 'explicit_coordinates', accuracy: 15 });
+    assert.equal(high.confidenceTier, 'high');
+    assert.ok(high.score >= 90);
+    assert.equal(high.isEstimated, false);
+
+    const est = scoreLocationConfidence({ source: 'ip_lookup' });
+    assert.equal(est.confidenceTier, 'medium');
+    assert.equal(est.isEstimated, true);
+  });
+
+  test('toolHandlers.search_location_map bundles real-time weather and map pin for named venue', async () => {
+    const res = await toolHandlers.search_location_map({ query: 'CentralWorld' });
+    assert.equal(res.status, 'success');
+    assert.ok(res.results.length > 0);
+    assert.ok(res.map_tag);
+    if (res.weather) {
+      assert.ok(typeof res.weather.temperature === 'number');
+      assert.ok(res.message.includes('สภาพอากาศ') || res.message.includes('Weather'));
+    }
+  });
+});