kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,95 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { compactToolResultForContext, estimateTextTokens } from '../contextCompactor.js';
+import { sanitizeToolArguments } from '../textToolProtocol.js';
+import { executeTool } from '../tools.js';
+
+test('compactToolResultForContext strips SearchUrls and projects essential fields', () => {
+  const sampleResult = {
+    status: 'success',
+    works: [
+      {
+        id: 'in-blossom',
+        titleCn: '花间令',
+        titleEn: 'In Blossom',
+        year: 2024,
+        role: 'Yang Caiwei / Shangguan Zhi',
+        youtubeSearchUrl: 'https://youtube.com/results?search_query=fake',
+        bilibiliSearchUrl: 'https://bilibili.com/search?keyword=fake',
+        qqMusicSearchUrl: 'https://qq.com/search?w=fake',
+        unneededMetadata: 'huge payload string here'
+      }
+    ]
+  };
+
+  const compacted = compactToolResultForContext(sampleResult, { maxTokens: 800 });
+  assert.equal(compacted.works.length, 1);
+  const w = compacted.works[0];
+  assert.equal(w.titleCn, '花间令');
+  assert.equal(w.year, 2024);
+  assert.equal(w.youtubeSearchUrl, undefined);
+  assert.equal(w.bilibiliSearchUrl, undefined);
+  assert.equal(w.qqMusicSearchUrl, undefined);
+  assert.equal(w.unneededMetadata, undefined);
+});
+
+test('compactToolResultForContext enforces token budget <= 800 tokens', () => {
+  const hugeWorks = [];
+  for (let i = 0; i < 50; i++) {
+    hugeWorks.push({
+      id: `work-${i}`,
+      titleCn: `作品 ${i}`,
+      titleEn: `Title ${i} with long description text repeating over and over again to bloat token count`,
+      synopsis: 'A very long storyline synopsis that would normally blow the prompt limit for smaller 4B models when multiple tools are run.',
+      year: 2020 + (i % 5),
+      role: `Role ${i}`
+    });
+  }
+
+  const compacted = compactToolResultForContext({ status: 'success', works: hugeWorks }, { maxTokens: 800 });
+  const serialized = JSON.stringify(compacted);
+  const tokens = estimateTextTokens(serialized);
+  assert.ok(tokens <= 800, `Expected <= 800 tokens, got ${tokens}`);
+});
+
+test('sanitizeToolArguments prunes secret keys and coerces types', () => {
+  const schema = [
+    {
+      function: {
+        name: 'search_works',
+        parameters: {
+          type: 'object',
+          properties: {
+            year: { type: 'number' },
+            category: { type: 'string', enum: ['historical-drama', 'modern-drama', 'all'] },
+            query: { type: 'string' }
+          }
+        }
+      }
+    }
+  ];
+
+  const raw = {
+    year: '2024',
+    category: 'Historical-Drama',
+    query: 'In Blossom',
+    KIKU_VIP_KEYS: 'secret_leak_attempt'
+  };
+
+  const clean = sanitizeToolArguments('search_works', raw, schema);
+  assert.equal(clean.year, 2024);
+  assert.equal(clean.category, 'historical-drama');
+  assert.equal(clean.query, 'In Blossom');
+  assert.equal(clean.KIKU_VIP_KEYS, undefined);
+});
+
+test('get_profile_and_fandom returns targeted cat data when cat query is asked', async () => {
+  const res = await executeTool('get_profile_and_fandom', { query: 'แมว' });
+  assert.equal(res.status, 'success');
+  assert.ok(Array.isArray(res.cats));
+  assert.ok(res.cats.length > 0);
+  assert.ok(res.petsSummary);
+  assert.equal(res.profile, undefined);
+  assert.equal(res.talents, undefined);
+  assert.equal(res.stats, undefined);
+});

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

@@ -0,0 +1,206 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  HARDWARE_TIERS,
+  classifyHardwareTier,
+  detectGpuArchitecture,
+  calculateDynamicVramBudget
+} from '../telemetry/hardwareTiers.js';
+import { techPowerUpClient } from '../telemetry/techPowerUpClient.js';
+import { resolveSystemHardwareTier } from '../vramService.js';
+
+test('Hardware Tiers: classifies RTX 2060 6GB into Tier 1 with Q4_K_M KV cache', () => {
+  const tier = classifyHardwareTier({
+    name: 'NVIDIA GeForce RTX 2060',
+    totalMb: 6144,
+    vendor: 'NVIDIA'
+  });
+
+  assert.equal(tier.id, 1);
+  assert.equal(tier.name, 'Tier 1: Entry AI');
+  assert.equal(tier.contextLimit, 8192);
+  assert.equal(tier.effectiveKvQuant, 'Q4_K_M');
+  assert.equal(tier.architecture.family, 'Turing');
+  assert.equal(tier.isConstrained, true);
+});
+
+test('Hardware Tiers: classifies RTX 4090 24GB into Tier 3 with native FP16', () => {
+  const tier = classifyHardwareTier({
+    name: 'NVIDIA GeForce RTX 4090',
+    totalMb: 24576,
+    vendor: 'NVIDIA'
+  });
+
+  assert.equal(tier.id, 3);
+  assert.equal(tier.name, 'Tier 3: Enthusiast');
+  assert.equal(tier.contextLimit, 32768);
+  assert.equal(tier.effectiveKvQuant, 'FP16');
+  assert.equal(tier.architecture.family, 'Ada Lovelace');
+});
+
+test('Hardware Tiers: detects Apple Silicon architecture flags and headroom requirement', () => {
+  const arch = detectGpuArchitecture('Apple M3 Max', 'Apple');
+  assert.equal(arch.family, 'Apple Silicon');
+  assert.equal(arch.requiresReservedHeadroom, true);
+  assert.ok(arch.headroomPercent >= 25);
+});
+
+test('Dynamic VRAM Budgeting: calculates correct KV budget and safe context limits', () => {
+  const budget = calculateDynamicVramBudget({
+    totalVramMb: 6144,
+    modelWeightsMb: 3900,
+    osSafetyMb: 700,
+    kvQuant: 'Q4_K_M'
+  });
+
+  assert.ok(budget.kvBudgetMb > 1000);
+  assert.equal(budget.isSafe, true);
+  assert.ok(budget.recommendedContextLimit >= 8192);
+});
+
+test('TechPowerUp Disambiguation: correctly differentiates RTX 2060 6GB from 12GB variant', () => {
+  const spec6G = techPowerUpClient.disambiguateGpu('GeForce RTX 2060', 6.0);
+  assert.equal(spec6G.vramGb, 6);
+  assert.equal(spec6G.bandwidthGbs, 336.0);
+
+  const spec12G = techPowerUpClient.disambiguateGpu('GeForce RTX 2060 12GB', 12.0);
+  assert.equal(spec12G.vramGb, 12);
+  assert.equal(spec12G.bandwidthGbs, 336.0);
+});
+
+test('TechPowerUp Disambiguation: RTX 4060 Ti 16GB vs 8GB clamshell bus disambiguation', () => {
+  const spec16G = techPowerUpClient.disambiguateGpu('NVIDIA GeForce RTX 4060 Ti', 16.0);
+  assert.equal(spec16G.vramGb, 16);
+  assert.equal(spec16G.busBits, 128);
+  assert.equal(spec16G.bandwidthGbs, 288.0);
+  assert.equal(spec16G.memoryType, 'GDDR6');
+
+  const spec8G = techPowerUpClient.disambiguateGpu('NVIDIA GeForce RTX 4060 Ti', 8.0);
+  assert.equal(spec8G.vramGb, 8);
+  assert.equal(spec8G.busBits, 128);
+  assert.equal(spec8G.bandwidthGbs, 288.0);
+});
+
+test('TechPowerUp Disambiguation: RTX 3060 12GB (192-bit) vs 8GB (128-bit) vs Laptop (192-bit)', () => {
+  const spec12G = techPowerUpClient.disambiguateGpu('GeForce RTX 3060', 12.0);
+  assert.equal(spec12G.vramGb, 12);
+  assert.equal(spec12G.busBits, 192);
+  assert.equal(spec12G.bandwidthGbs, 360.0);
+
+  const spec8G = techPowerUpClient.disambiguateGpu('GeForce RTX 3060', 8.0);
+  assert.equal(spec8G.vramGb, 8);
+  assert.equal(spec8G.busBits, 128);
+  assert.equal(spec8G.bandwidthGbs, 240.0);
+
+  const specLaptop = techPowerUpClient.disambiguateGpu('GeForce RTX 3060 Laptop', 6.0);
+  assert.equal(specLaptop.vramGb, 6);
+  assert.equal(specLaptop.busBits, 192);
+  assert.equal(specLaptop.bandwidthGbs, 336.0);
+});
+
+test('TechPowerUp Disambiguation: RTX 3080 12GB (384-bit) vs 10GB (320-bit)', () => {
+  const spec12G = techPowerUpClient.disambiguateGpu('NVIDIA GeForce RTX 3080', 12.0);
+  assert.equal(spec12G.vramGb, 12);
+  assert.equal(spec12G.busBits, 384);
+  assert.equal(spec12G.bandwidthGbs, 912.0);
+
+  const spec10G = techPowerUpClient.disambiguateGpu('NVIDIA GeForce RTX 3080', 10.0);
+  assert.equal(spec10G.vramGb, 10);
+  assert.equal(spec10G.busBits, 320);
+  assert.equal(spec10G.bandwidthGbs, 760.3);
+});
+
+test('TechPowerUp Disambiguation: RTX 4070 Ti SUPER 256-bit vs RTX 4070 Ti 192-bit', () => {
+  const superSpec = techPowerUpClient.disambiguateGpu('GeForce RTX 4070 Ti SUPER', 16.0);
+  assert.equal(superSpec.busBits, 256);
+  assert.equal(superSpec.bandwidthGbs, 672.3);
+
+  const nonSuperSpec = techPowerUpClient.disambiguateGpu('GeForce RTX 4070 Ti', 12.0);
+  assert.equal(nonSuperSpec.busBits, 192);
+  assert.equal(nonSuperSpec.bandwidthGbs, 504.2);
+});
+
+test('TechPowerUp Disambiguation: RTX 2080 Ti 22GB AI mod vs 11GB standard', () => {
+  const modSpec = techPowerUpClient.disambiguateGpu('GeForce RTX 2080 Ti', 22.0);
+  assert.equal(modSpec.vramGb, 22);
+  assert.equal(modSpec.busBits, 352);
+  assert.equal(modSpec.bandwidthGbs, 616.0);
+
+  const stdSpec = techPowerUpClient.disambiguateGpu('GeForce RTX 2080 Ti', 11.0);
+  assert.equal(stdSpec.vramGb, 11);
+  assert.equal(stdSpec.busBits, 352);
+});
+
+test('TechPowerUp Disambiguation: Homelab legendary accelerators (Tesla P40 & T4)', () => {
+  const p40 = techPowerUpClient.disambiguateGpu('NVIDIA Tesla P40', 24.0);
+  assert.equal(p40.vramGb, 24);
+  assert.equal(p40.busBits, 384);
+  assert.equal(p40.bandwidthGbs, 345.6);
+
+  const t4 = techPowerUpClient.disambiguateGpu('NVIDIA Tesla T4', 16.0);
+  assert.equal(t4.vramGb, 16);
+  assert.equal(t4.busBits, 128);
+  assert.equal(t4.bandwidthGbs, 320.0);
+});
+
+test('TechPowerUp Disambiguation: Apple Silicon unified memory bus widths (M3 Max & Ultra)', () => {
+  const m3Max36 = techPowerUpClient.disambiguateGpu('Apple M3 Max', 36.0);
+  assert.equal(m3Max36.busBits, 384);
+  assert.equal(m3Max36.bandwidthGbs, 300.0);
+  assert.equal(m3Max36.isUnifiedMemory, true);
+
+  const m3Max128 = techPowerUpClient.disambiguateGpu('Apple M3 Max', 128.0);
+  assert.equal(m3Max128.busBits, 512);
+  assert.equal(m3Max128.bandwidthGbs, 400.0);
+
+  const ultra = techPowerUpClient.disambiguateGpu('Apple M2 Ultra', 192.0);
+  assert.equal(ultra.busBits, 1024);
+  assert.equal(ultra.bandwidthGbs, 800.0);
+});
+
+test('TechPowerUp Disambiguation: AMD Radeon & APU hardware (RX 7900 XTX, Radeon VII, Strix Halo)', () => {
+  const xtx = techPowerUpClient.disambiguateGpu('AMD Radeon RX 7900 XTX', 24.0);
+  assert.equal(xtx.busBits, 384);
+  assert.equal(xtx.bandwidthGbs, 960.0);
+
+  const vii = techPowerUpClient.disambiguateGpu('AMD Radeon VII', 16.0);
+  assert.equal(vii.busBits, 4096);
+  assert.equal(vii.bandwidthGbs, 1024.0);
+
+  const halo = techPowerUpClient.disambiguateGpu('AMD Ryzen AI Max+ 395 Strix Halo', 128.0);
+  assert.equal(halo.busBits, 256);
+  assert.equal(halo.bandwidthGbs, 256.0);
+});
+
+test('TechPowerUp Disambiguation: Intel Arc A770 16GB vs 8GB and Gaudi 3', () => {
+  const a770_16 = techPowerUpClient.disambiguateGpu('Intel Arc A770', 16.0);
+  assert.equal(a770_16.vramGb, 16);
+  assert.equal(a770_16.bandwidthGbs, 560.0);
+
+  const a770_8 = techPowerUpClient.disambiguateGpu('Intel Arc A770', 8.0);
+  assert.equal(a770_8.vramGb, 8);
+  assert.equal(a770_8.bandwidthGbs, 512.0);
+
+  const gaudi = techPowerUpClient.disambiguateGpu('Intel Gaudi 3', 128.0);
+  assert.equal(gaudi.busBits, 8192);
+  assert.equal(gaudi.bandwidthGbs, 3700.0);
+});
+
+test('TechPowerUp Disambiguation: fallback heuristic for uncataloged GPU', () => {
+  const uncataloged = techPowerUpClient.disambiguateGpu('Experimental AI Chip', 16.0);
+  assert.equal(uncataloged.busBits, 256);
+  assert.equal(uncataloged.bandwidthGbs, 672);
+  assert.equal(uncataloged.approximate, true);
+});
+
+test('TechPowerUp Throughput: calculates theoretical max TPS based on memory bandwidth', () => {
+  const tps = techPowerUpClient.calculateTheoreticalTps(336.0, 4.0);
+  assert.equal(tps, 84.0);
+});
+
+test('VRAM Service: resolveSystemHardwareTier returns full architecture and tier metadata', async () => {
+  const resolved = await resolveSystemHardwareTier();
+  assert.ok(resolved.tier);
+  assert.ok(resolved.tier.contextLimit > 0);
+  assert.ok(resolved.budget.recommendedContextLimit > 0);
+});

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

@@ -0,0 +1,192 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  canonicalizeUrl,
+  fuseSearchResults,
+  createSearchResult,
+  TokenBucketLimiter,
+  CircuitBreaker,
+  SearchResponseCache,
+  assertSafeUrlHostname,
+  isPrivateIPv4,
+  isPrivateIPv6,
+  MetaSearchOrchestrator,
+  SearchTelemetry
+} from '../websearch/index.js';
+import { searchWeb } from '../webSearch.js';
+
+
+
+test('URL Canonicalization strips tracking parameters, www, and trailing slashes', () => {
+  const url1 = 'http://www.example.com/drama/?utm_source=twitter&utm_medium=social&fbclid=12345#overview';
+  const clean1 = canonicalizeUrl(url1);
+  assert.equal(clean1, 'https://example.com/drama');
+
+  const url2 = 'https://news.example.com/article/?ref=share&gclid=xyz&q=kiku&category=music';
+  const clean2 = canonicalizeUrl(url2);
+  assert.equal(clean2, 'https://news.example.com/article?category=music&q=kiku');
+
+  const urlRoot = 'https://www.example.com/';
+  assert.equal(canonicalizeUrl(urlRoot), 'https://example.com/');
+});
+
+test('Reciprocal Rank Fusion (RRF) correctly scores and deduplicates cross-engine results', () => {
+ 
+  const ddgResults = [
+    createSearchResult({ link: 'https://example.com/page-a', title: 'Page A (DDG)', snippet: 'Snippet A from DDG', engine: 'duckduckgo' }),
+    createSearchResult({ link: 'https://example.com/page-b', title: 'Page B', snippet: 'Snippet B from DDG', engine: 'duckduckgo' })
+  ];
+
+  
+  const searxResults = [
+    createSearchResult({ link: 'https://www.example.com/page-a/', title: 'Page A (SearXNG)', snippet: 'Longer Snippet A from SearXNG', engine: 'searxng' }),
+    createSearchResult({ link: 'https://example.com/page-c', title: 'Page C', snippet: 'Snippet C from SearXNG', engine: 'searxng' })
+  ];
+
+  const fused = fuseSearchResults([ddgResults, searxResults], { k: 60, limit: 10 });
+
+ 
+  assert.equal(fused[0].link, 'https://example.com/page-a');
+  assert.equal(fused[0].metadata.engines.length, 2);
+  assert.ok(fused[0].score > fused[1].score);
+
+
+  const expectedScoreA = (1 / 61) + (1 / 61);
+  assert.ok(Math.abs(fused[0].score - expectedScoreA) < 0.0001);
+
+ 
+  assert.equal(fused[0].snippet, 'Longer Snippet A from SearXNG');
+});
+
+
+
+test('TokenBucketLimiter enforces rate limiting and burst capacity', async () => {
+  const limiter = new TokenBucketLimiter({ name: 'test_limiter', capacity: 2, refillRatePerSec: 10 });
+  assert.equal(limiter.tryAcquire(1), true);
+  assert.equal(limiter.tryAcquire(1), true);
+  
+  assert.equal(limiter.tryAcquire(1), false);
+
+ 
+  const acquired = await limiter.acquire(1, 1000);
+  assert.equal(acquired, true);
+});
+
+test('CircuitBreaker transitions to OPEN on 3 consecutive failures and recovers on cooldown', () => {
+  const breaker = new CircuitBreaker({ name: 'test_breaker', failureThreshold: 3, cooldownMs: 100 });
+  assert.equal(breaker.canExecute(), true);
+
+  breaker.recordFailure(new Error('Fail 1'));
+  assert.equal(breaker.canExecute(), true);
+
+  breaker.recordFailure(new Error('Fail 2'));
+  assert.equal(breaker.canExecute(), true);
+
+  breaker.recordFailure(new Error('Fail 3'));
+
+  assert.equal(breaker.canExecute(), false);
+  assert.equal(breaker.state, 'OPEN');
+  assert.equal(breaker.tripCount, 1);
+
+  
+  breaker.reset();
+  assert.equal(breaker.canExecute(), true);
+  assert.equal(breaker.state, 'CLOSED');
+});
+
+test('SearchResponseCache enforces TTL and LRU max size', () => {
+  const cache = new SearchResponseCache(2);
+  cache.set('key1', { data: 1 }, 10000);
+  cache.set('key2', { data: 2 }, 10000);
+
+  assert.deepEqual(cache.get('key1'), { data: 1 });
+
+ 
+  cache.set('key3', { data: 3 }, 10000);
+  assert.equal(cache.has('key1'), true);
+  assert.equal(cache.has('key2'), false);
+  assert.equal(cache.has('key3'), true);
+});
+
+test('SSRF Defense rejects private IPs, loopback, and metadata addresses', async () => {
+
+  assert.equal(isPrivateIPv4('127.0.0.1'), true);
+  assert.equal(isPrivateIPv4('10.0.0.5'), true);
+  assert.equal(isPrivateIPv4('172.16.50.1'), true);
+  assert.equal(isPrivateIPv4('192.168.1.100'), true);
+  assert.equal(isPrivateIPv4('169.254.169.254'), true);
+  assert.equal(isPrivateIPv4('8.8.8.8'), false);
+
+
+  assert.equal(isPrivateIPv6('::1'), true);
+  assert.equal(isPrivateIPv6('fe80::1'), true);
+  assert.equal(isPrivateIPv6('fc00::1'), true);
+
+  
+  const loopback = await assertSafeUrlHostname('localhost');
+  assert.equal(loopback.safe, false);
+
+  const internalIp = await assertSafeUrlHostname('192.168.0.1');
+  assert.equal(internalIp.safe, false);
+});
+
+
+
+test('MetaSearchOrchestrator generates multilingual query fan-out', () => {
+  const orchestrator = new MetaSearchOrchestrator();
+  const thFanOut = orchestrator.expandQuery('จวีจิ้งอี ผลงาน');
+  assert.ok(thFanOut.includes('Ju Jingyi ผลงาน'));
+  assert.ok(thFanOut.includes('鞠婧祎 ผลงาน'));
+
+  const enFanOut = orchestrator.expandQuery('Ju Jingyi drama list');
+  assert.ok(enFanOut.includes('鞠婧祎 drama list'));
+});
+
+test('MetaSearchOrchestrator handles engine fallbacks and dual consumption modes', async () => {
+  const telemetry = new SearchTelemetry();
+  const orchestrator = new MetaSearchOrchestrator({
+    telemetry,
+    fallbackTimeoutMs: 500
+  });
+
+ 
+  let callCount = 0;
+  orchestrator._searchSingleEngine = async (engine, query, options) => {
+    callCount++;
+    if (engine === 'searxng') {
+      return []; 
+    }
+    if (engine === 'duckduckgo') {
+      return [
+        createSearchResult({ link: 'https://example.com/ju-jingyi', title: 'Ju Jingyi Official', snippet: 'Artist bio and works', engine: 'duckduckgo' })
+      ];
+    }
+    return [];
+  };
+
+
+  const bypassRes = await orchestrator.executeSearch('Ju Jingyi bio', { mode: 'bypass', noCache: true });
+  assert.equal(bypassRes.status, 'success');
+  assert.equal(bypassRes.results.length, 1);
+  assert.equal(bypassRes.results[0].link, 'https://example.com/ju-jingyi');
+
+  
+  const metrics = telemetry.getMetrics();
+  assert.equal(metrics.totalSearches, 1);
+  assert.ok(metrics.searchLatencyP95Ms >= 0);
+});
+
+
+
+test('searchWeb returns backward-compatible format with hybrid meta search', async () => {
+  
+  const errRes = await searchWeb(null);
+  assert.equal(errRes.status, 'error');
+
+
+  const res = await searchWeb('Ju Jingyi news', 5, { noCache: true });
+  assert.ok(['success', 'no_results'].includes(res.status));
+  assert.equal(typeof res.count, 'number');
+  assert.ok(Array.isArray(res.results));
+});