kiku-agent 1.3.0 → 1.3.2

package/server/agent/telemetry/hardwareTiers.js

@@ -0,0 +1,332 @@
+export const HARDWARE_TIERS = Object.freeze({
+  TIER_0: {
+    id: 0,
+    name: 'Tier 0: Constrained',
+    vramRange: '<= 4 GB (or iGPU)',
+    minVramGb: 0,
+    maxVramGb: 4.5,
+    contextLimit: 4096,
+    recommendedKvQuant: 'Q4_K_M',
+    schemaPolicy: 'single_tool_minimal',
+    multiTurnAllowed: false,
+    timeoutSeconds: 30,
+    nBatch: 1024,
+    description: 'Ultra-low VRAM or integrated GPU. Minimal context and strict single-tool dispatch. Q4_K_M KV cache for best quality within tight budget.'
+  },
+  TIER_1: {
+    id: 1,
+    name: 'Tier 1: Entry AI',
+    vramRange: '6 GB - 8 GB',
+    minVramGb: 4.51,
+    maxVramGb: 8.5,
+    contextLimit: 8192,
+    recommendedKvQuant: 'Q4_K_M',
+    schemaPolicy: 'dynamic_minimal',
+    schemaTokenBudget: 1500,
+    multiTurnAllowed: true,
+    timeoutSeconds: 45,
+    nBatch: 2048,
+    description: 'Entry AI GPUs (e.g. RTX 2060 6GB, RTX 3050, RTX 4060 8GB, RX 6600). Enforces 8K context and Q4_K_M KV to balance accuracy and PCIe Shared Memory spillover prevention.'
+  },
+  TIER_2: {
+    id: 2,
+    name: 'Tier 2: Mid-Range',
+    vramRange: '10 GB - 16 GB',
+    minVramGb: 8.51,
+    maxVramGb: 18.0,
+    contextLimit: 16384,
+    recommendedKvQuant: 'Q8_0',
+    schemaPolicy: 'domain_grouped',
+    schemaTokenBudget: 3000,
+    multiTurnAllowed: true,
+    timeoutSeconds: 90,
+    nBatch: 4096,
+    description: 'Mid-range cards (e.g. RTX 3060 12GB, RTX 4070 12GB, RTX 4080 16GB, RX 7800 XT). Full domain grouping and prefix caching enabled.'
+  },
+  TIER_3: {
+    id: 3,
+    name: 'Tier 3: Enthusiast',
+    vramRange: '20 GB - 24 GB',
+    minVramGb: 18.01,
+    maxVramGb: 28.0,
+    contextLimit: 32768,
+    recommendedKvQuant: 'FP16',
+    schemaPolicy: 'full_schema',
+    schemaTokenBudget: 8000,
+    multiTurnAllowed: true,
+    timeoutSeconds: 120,
+    nBatch: 4096,
+    description: 'Enthusiast GPUs (e.g. RTX 3090, RTX 4090 24GB, RX 7900 XTX, Apple M Pro/Max). Full schema access without prompt compaction.'
+  },
+  TIER_4: {
+    id: 4,
+    name: 'Tier 4: Ultra / Pro',
+    vramRange: '>= 32 GB',
+    minVramGb: 28.01,
+    maxVramGb: Infinity,
+    contextLimit: 65536,
+    recommendedKvQuant: 'FP8',
+    schemaPolicy: 'full_schema',
+    schemaTokenBudget: 16000,
+    multiTurnAllowed: true,
+    timeoutSeconds: 180,
+    nBatch: 8192,
+    description: 'Workstation & Flagship (e.g. RTX 5090 32GB, RTX 6000 Ada, Apple M Ultra). Multi-agent parallelism and expansive context.'
+  }
+});
+
+
+export function detectGpuArchitecture(name = '', vendor = '') {
+  const n = String(name || '').toLowerCase();
+  const v = String(vendor || '').toLowerCase();
+
+  if (v.includes('apple') || n.includes('apple') || n.includes('m1') || n.includes('m2') || n.includes('m3') || n.includes('m4')) {
+    return {
+      family: 'Apple Silicon',
+      generation: 'Metal Unified Memory',
+      supportsFp8: false,
+      supportsBf16: true,
+      requiresReservedHeadroom: true,
+      headroomPercent: 28,
+    };
+  }
+
+  if (n.includes('h100') || n.includes('h200') || n.includes('hopper')) {
+    return {
+      family: 'Hopper',
+      generation: 'H100/H200 Enterprise',
+      supportsFp8: true,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'FP8',
+    };
+  }
+
+  if (n.includes('rtx 50') || n.includes('blackwell')) {
+    return {
+      family: 'Blackwell',
+      generation: 'RTX 5000 Series',
+      supportsFp4: true,
+      supportsFp8: true,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'FP8',
+    };
+  }
+
+  if (n.includes('rtx 40') || n.includes('ada') || n.includes('rtx 6000 ada')) {
+    return {
+      family: 'Ada Lovelace',
+      generation: 'RTX 4000 Series',
+      supportsFp8: true,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'FP8',
+    };
+  }
+
+  if (n.includes('rtx 30') || n.includes('ampere') || n.includes('a100') || n.includes('a10') || n.includes('a40') || n.includes('a2000') || n.includes('a4000') || n.includes('a5000') || n.includes('a6000')) {
+    return {
+      family: 'Ampere',
+      generation: 'RTX 3000 Series',
+      supportsFp8: false,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'Q8_0',
+    };
+  }
+
+  if (n.includes('rtx 20') || n.includes('gtx 16') || n.includes('turing') || n.includes('titan rtx') || n.includes('t4')) {
+    return {
+      family: 'Turing',
+      generation: 'RTX 2000 / GTX 1600 Series',
+      supportsFp8: false,
+      supportsBf16: false,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'Q4_K_M',
+    };
+  }
+
+  if (n.includes('v100') || n.includes('volta') || n.includes('titan v')) {
+    return {
+      family: 'Volta',
+      generation: 'Tesla V100 / Titan V',
+      supportsFp8: false,
+      supportsBf16: false,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'Q8_0',
+    };
+  }
+
+  if (n.includes('gtx 10') || n.includes('pascal') || n.includes('p40') || n.includes('p100') || n.includes('titan x')) {
+    return {
+      family: 'Pascal',
+      generation: 'GTX 1000 / Tesla P Series',
+      supportsFp8: false,
+      supportsBf16: false,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'Q4_0',
+    };
+  }
+
+  if (n.includes('mi300') || n.includes('mi250') || n.includes('mi210') || n.includes('mi60') || n.includes('cdna')) {
+    return {
+      family: 'CDNA',
+      generation: 'AMD Instinct Enterprise',
+      supportsFp8: true,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'FP8',
+    };
+  }
+
+  if (n.includes('rx 7') || n.includes('rdna 3') || n.includes('rdna3') || n.includes('w7900')) {
+    return {
+      family: 'RDNA 3',
+      generation: 'Radeon RX 7000 Series',
+      supportsFp8: false,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'Q8_0',
+    };
+  }
+
+  if (n.includes('rx 6') || n.includes('rdna 2') || n.includes('rdna2')) {
+    return {
+      family: 'RDNA 2',
+      generation: 'Radeon RX 6000 Series',
+      supportsFp8: false,
+      supportsBf16: false,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'Q8_0',
+    };
+  }
+
+  if (n.includes('arc') || n.includes('alchemist') || n.includes('battlemage') || n.includes('b580') || n.includes('b570') || n.includes('a770') || n.includes('a750') || n.includes('140v')) {
+    return {
+      family: 'Intel Arc',
+      generation: 'Xe-HPG / Battlemage',
+      supportsFp8: false,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'Q8_0',
+    };
+  }
+
+  if (n.includes('gaudi') || n.includes('ponte vecchio') || n.includes('gpu max')) {
+    return {
+      family: 'Intel Accelerator',
+      generation: 'Gaudi / Xe-HPC Enterprise',
+      supportsFp8: true,
+      supportsBf16: true,
+      requiresReservedHeadroom: false,
+      recommendedKv: 'FP8',
+    };
+  }
+
+  if (n.includes('strix') || n.includes('ryzen ai') || n.includes('780m') || n.includes('890m')) {
+    return {
+      family: 'AMD APU / RDNA 3.5',
+      generation: 'Ryzen AI Strix / Phoenix Unified',
+      supportsFp8: false,
+      supportsBf16: true,
+      requiresReservedHeadroom: true,
+      headroomPercent: 20,
+      recommendedKv: 'Q8_0',
+    };
+  }
+
+  return {
+    family: 'Generic',
+    generation: 'Unknown',
+    supportsFp8: false,
+    supportsBf16: false,
+    requiresReservedHeadroom: false,
+    recommendedKv: 'Q4_K_M',
+  };
+}
+
+
+export function classifyHardwareTier(hardware = {}) {
+  const totalMb = Number(hardware.totalMb) || (Number(hardware.totalGb) ? Number(hardware.totalGb) * 1024 : 0);
+  const totalGb = totalMb / 1024;
+  const name = String(hardware.name || '');
+  const vendor = String(hardware.vendor || '');
+  const arch = detectGpuArchitecture(name, vendor);
+
+  let selectedTier = HARDWARE_TIERS.TIER_1;
+  if (totalGb <= 0 || totalGb <= HARDWARE_TIERS.TIER_0.maxVramGb) {
+    selectedTier = HARDWARE_TIERS.TIER_0;
+  } else if (totalGb <= HARDWARE_TIERS.TIER_1.maxVramGb) {
+    selectedTier = HARDWARE_TIERS.TIER_1;
+  } else if (totalGb <= HARDWARE_TIERS.TIER_2.maxVramGb) {
+    selectedTier = HARDWARE_TIERS.TIER_2;
+  } else if (totalGb <= HARDWARE_TIERS.TIER_3.maxVramGb) {
+    selectedTier = HARDWARE_TIERS.TIER_3;
+  } else {
+    selectedTier = HARDWARE_TIERS.TIER_4;
+  }
+
+  
+  // Tier recommendation is primary (driven by VRAM budget).
+  // For constrained tiers (0/1), cap to arch recommendedKv if it would push
+  // a tighter quant than the tier default — prevents Shared Memory spillover.
+  // For mid/high tiers the tier quant (Q8_0, FP16, FP8) always wins.
+  let effectiveKvQuant = selectedTier.recommendedKvQuant;
+  if (selectedTier.id <= 1 && arch.recommendedKv) {
+    effectiveKvQuant = arch.recommendedKv;
+  }
+
+  return {
+    ...selectedTier,
+    totalMb: Math.round(totalMb),
+    totalGb: Number(totalGb.toFixed(2)),
+    detectedName: name,
+    architecture: arch,
+    effectiveKvQuant,
+    isConstrained: selectedTier.id <= 1,
+  };
+}
+
+
+export function calculateDynamicVramBudget({
+  totalVramMb,
+  modelWeightsMb = 3900,
+  osSafetyMb = 700,
+  bytesPerToken = 0.055, 
+  kvQuant = 'Q4_K_M',
+} = {}) {
+  const total = Number(totalVramMb) || 6144;
+  const weights = Number(modelWeightsMb) || 3900;
+  const safety = Number(osSafetyMb) || 700;
+
+  const usable = total;
+  const kvBudgetMb = Math.max(0, usable - weights - safety);
+
+
+  let quantScale = 1.0;
+  if (kvQuant.toUpperCase() === 'Q4_0' || kvQuant.toUpperCase() === 'Q4') quantScale = 0.25;
+  else if (kvQuant.toUpperCase() === 'Q4_K_M' || kvQuant.toUpperCase() === 'Q4_K_S') quantScale = 0.28;
+  else if (kvQuant.toUpperCase() === 'Q6_K') quantScale = 0.38;
+  else if (kvQuant.toUpperCase() === 'Q8_0' || kvQuant.toUpperCase() === 'Q8') quantScale = 0.50;
+  else if (kvQuant.toUpperCase() === 'FP8') quantScale = 0.50;
+  else if (kvQuant.toUpperCase() === 'FP16') quantScale = 1.0;
+
+  const effectiveBytesPerTokenMb = (bytesPerToken || 0.055) * quantScale;
+  const maxTokens = Math.floor(kvBudgetMb / effectiveBytesPerTokenMb);
+
+  
+  const contextLength = Math.max(2048, Math.min(131072, Math.floor(maxTokens / 1024) * 1024));
+
+  return {
+    totalVramMb: total,
+    modelWeightsMb: weights,
+    osSafetyMb: safety,
+    kvBudgetMb: Number(kvBudgetMb.toFixed(1)),
+    kvQuant,
+    quantScale,
+    calculatedMaxTokens: maxTokens,
+    recommendedContextLimit: contextLength,
+    isSafe: kvBudgetMb >= 256,
+  };
+}

package/server/agent/telemetry/runtimeWatchdog.js

@@ -0,0 +1,66 @@
+import { getSharedMemoryMetrics } from '../gpuMetrics.js';
+import { Events, eventBus } from '../eventBus.js';
+
+export class RuntimeWatchdog {
+  constructor(options = {}) {
+    this.minTpsThreshold = options.minTpsThreshold || 20.0;
+    this.spilloverThresholdMb = options.spilloverThresholdMb || 5.0;
+    this.checkIntervalMs = options.checkIntervalMs || 10000;
+    this.active = false;
+    this.metricsHistory = [];
+  }
+
+
+  async sampleTelemetry() {
+    const mem = await getSharedMemoryMetrics('lm');
+    const snapshot = {
+      timestamp: Date.now(),
+      sharedMemoryUsedMb: mem.sharedMemoryUsedMb || 0,
+      hasSpillover: mem.sharedMemoryUsedMb > this.spilloverThresholdMb,
+    };
+
+    this.metricsHistory.push(snapshot);
+    if (this.metricsHistory.length > 50) this.metricsHistory.shift();
+
+    if (snapshot.hasSpillover) {
+      eventBus.emit(Events.AGENT_QUERY_ERROR, {
+        type: 'vram_spillover_warning',
+        sharedMemoryUsedMb: snapshot.sharedMemoryUsedMb,
+        message: `Detected ${snapshot.sharedMemoryUsedMb} MB Shared GPU Memory allocation (PCIe spillover). Decoding speed will degrade.`
+      });
+    }
+
+    return snapshot;
+  }
+
+
+  selfHealContext(agent) {
+    if (!agent || !Array.isArray(agent.conversationHistory)) return 0;
+    const history = agent.conversationHistory;
+    const nonSystem = history.filter(m => m.role !== 'system');
+    if (nonSystem.length <= 2) return 0;
+
+    const cutCount = Math.floor(nonSystem.length / 2);
+   
+    const recent = nonSystem.slice(cutCount);
+    const system = history.filter(m => m.role === 'system');
+
+    agent.conversationHistory = [
+      ...system,
+      {
+        role: 'system',
+        content: '[WATCHDOG SELF-HEALING: Evicted 50% of older context to restore GPU VRAM headroom and eliminate latency drops.]'
+      },
+      ...recent
+    ];
+
+    eventBus.emit(Events.AGENT_STATE_CHANGE, {
+      state: 'SELF_HEALING_EVICTION',
+      evictedMessages: cutCount
+    });
+
+    return cutCount;
+  }
+}
+
+export const runtimeWatchdog = new RuntimeWatchdog();