kiku-agent 1.3.2 → 1.3.4

package/server/agent/contextCompactor.js

@@ -1,4 +1,179 @@
-import { dynamicToolRouter } from './toolRouter.js';
+import { dynamicToolRouter } from './toolRouter.js';
+
+const graphemeSegmenter = typeof Intl?.Segmenter === 'function'
+  ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+  : null;
+
+export function sanitizePromptString(input = '') {
+  const value = String(input);
+  let clean = '';
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 0xD800 && code <= 0xDBFF) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 0xDC00 && next <= 0xDFFF) {
+        clean += value[i] + value[i + 1];
+        i++;
+      }
+      continue;
+    }
+    if (code >= 0xDC00 && code <= 0xDFFF) continue;
+    clean += value[i];
+  }
+  return clean.normalize('NFC');
+}
+
+export function truncatePromptString(input, maxLength, suffix = '') {
+  const clean = sanitizePromptString(input);
+  const limit = Math.max(0, Math.floor(Number(maxLength) || 0));
+  if (clean.length <= limit) return clean;
+  if (limit === 0) return '';
+
+  let output = '';
+  const segments = graphemeSegmenter
+    ? Array.from(graphemeSegmenter.segment(clean), part => part.segment)
+    : Array.from(clean);
+  for (const segment of segments) {
+    if (output.length + segment.length > limit) break;
+    output += segment;
+  }
+  return output + suffix;
+}
+
+export function sanitizePromptValue(value) {
+  if (typeof value === 'string') return sanitizePromptString(value);
+  if (Array.isArray(value)) return value.map(sanitizePromptValue);
+  if (!value || typeof value !== 'object') return value;
+  const clean = {};
+  for (const [key, item] of Object.entries(value)) {
+    clean[sanitizePromptString(key)] = sanitizePromptValue(item);
+  }
+  return clean;
+}
+
+function prependUserContext(content, preamble) {
+  const prefix = `[Previous Session Context Summary: ${sanitizePromptString(preamble)}]\n\n`;
+  if (typeof content === 'string') return prefix + sanitizePromptString(content);
+  if (Array.isArray(content)) {
+    return [{ type: 'text', text: prefix.trim() }, ...sanitizePromptValue(content)];
+  }
+  return prefix + sanitizePromptString(content == null ? '' : JSON.stringify(content));
+}
+
+export function alignChatMessageRoles(messages = []) {
+  if (!Array.isArray(messages)) return [];
+  const cleanMessages = sanitizePromptValue(messages).filter(message => message && typeof message === 'object');
+  const firstSystemIndex = cleanMessages[0]?.role === 'system' ? 0 : -1;
+  const leadingSystem = firstSystemIndex === 0 ? cleanMessages[0] : null;
+  const contextualSystemMessages = cleanMessages
+    .filter((message, index) => message.role === 'system' && index !== firstSystemIndex)
+    .map(message => message.content)
+    .filter(Boolean);
+  const aligned = cleanMessages.filter(message => message.role !== 'system');
+
+  if (contextualSystemMessages.length > 0) {
+    let targetIndex = -1;
+    for (let i = aligned.length - 1; i >= 0; i--) {
+      if (aligned[i].role === 'user') {
+        targetIndex = i;
+        break;
+      }
+    }
+    const preamble = contextualSystemMessages.join('\n\n');
+    if (targetIndex >= 0) {
+      aligned[targetIndex] = {
+        ...aligned[targetIndex],
+        content: prependUserContext(aligned[targetIndex].content, preamble),
+      };
+    } else {
+      aligned.unshift({ role: 'user', content: prependUserContext('', preamble).trim() });
+    }
+  }
+
+  return leadingSystem ? [leadingSystem, ...aligned] : aligned;
+}
+
+function messageTokens(messages) {
+  return estimateTokenCount(messages);
+}
+
+function omissionMessage(message) {
+  return {
+    ...message,
+    content: JSON.stringify({
+      status: 'omitted',
+      authoritative: false,
+      message: 'Older tool output omitted by the context budget guard.',
+    }),
+    _omittedForContext: true,
+  };
+}
+
+export function prepareChatMessagesForDispatch(messages = [], options = {}) {
+  const aligned = alignChatMessageRoles(messages);
+  const sanitizedTools = sanitizePromptValue(Array.isArray(options.tools) ? options.tools : []);
+  const maxContextTokens = Math.max(1024, Math.floor(Number(options.maxContextTokens) || 32768));
+  const generationReserve = Math.max(0, Math.floor(Number(options.generationReserve) || 0));
+  const systemTokens = aligned[0]?.role === 'system' ? messageTokens([aligned[0]]) : 0;
+  const toolDefinitionTokens = sanitizedTools.length > 0
+    ? estimateTextTokens(JSON.stringify(sanitizedTools))
+    : 0;
+  const allocation = Math.max(256, maxContextTokens - systemTokens - generationReserve - toolDefinitionTokens);
+  const threshold = Math.max(128, Math.floor(allocation * Math.min(1, Math.max(0.5, Number(options.pruneAt) || 0.85))));
+  const prepared = aligned.map(message => ({ ...message }));
+  const prefixCount = prepared[0]?.role === 'system' ? 1 : 0;
+  const historyUsage = () => messageTokens(prepared.slice(prefixCount));
+
+  let pruned = false;
+  while (historyUsage() > threshold) {
+    const userIndexes = [];
+    for (let i = prefixCount; i < prepared.length; i++) {
+      if (prepared[i].role === 'user') userIndexes.push(i);
+    }
+    if (userIndexes.length <= 1) break;
+    const nextTurn = userIndexes[1];
+    prepared.splice(prefixCount, nextTurn - prefixCount);
+    pruned = true;
+  }
+
+  for (let i = prefixCount; i < prepared.length && historyUsage() > threshold; i++) {
+    if (prepared[i].role !== 'tool' || prepared[i]._omittedForContext) continue;
+    prepared[i] = omissionMessage(prepared[i]);
+    pruned = true;
+  }
+
+  if (historyUsage() > threshold) {
+    for (let i = prefixCount; i < prepared.length && historyUsage() > threshold; i++) {
+      const message = prepared[i];
+      if (typeof message.content !== 'string' || message.content.length <= 256) continue;
+      const currentTokens = estimateTextTokens(message.content);
+      const overflow = historyUsage() - threshold;
+      const targetTokens = Math.max(64, currentTokens - overflow);
+      const targetChars = Math.max(256, Math.floor(message.content.length * (targetTokens / Math.max(1, currentTokens))));
+      prepared[i] = {
+        ...message,
+        content: truncatePromptString(message.content, targetChars, '…'),
+        _truncatedForContext: true,
+      };
+      pruned = true;
+    }
+  }
+
+  return {
+    messages: sanitizePromptValue(prepared),
+    tools: sanitizedTools,
+    budget: {
+      maxContextTokens,
+      systemTokens,
+      generationReserve,
+      toolDefinitionTokens,
+      allocation,
+      threshold,
+      promptTokens: messageTokens(prepared),
+      pruned,
+    },
+  };
+}
 
 export function estimateTextTokens(text) {
   if (!text) return 0;
@@ -56,10 +231,10 @@ export class ContextCompactor {
     const points = [];
     for (const msg of messages) {
       if (msg.role === 'user' && typeof msg.content === 'string' && msg.content.trim()) {
-        const text = msg.content.slice(0, 100).replace(/\n+/g, ' ').trim();
+        const text = truncatePromptString(msg.content, 100).replace(/\n+/g, ' ').trim();
         points.push(`User asked: "${text}"`);
       } else if (msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.trim()) {
-        const text = msg.content.slice(0, 120).replace(/\n+/g, ' ').trim();
+        const text = truncatePromptString(msg.content, 120).replace(/\n+/g, ' ').trim();
         points.push(`Assistant covered: "${text}"`);
       } else if (msg.role === 'tool') {
         const toolName = msg.name || 'tool';
@@ -86,13 +261,15 @@ export class ContextCompactor {
     };
   }
 
-  _assemble(systemMessage, olderMessages, recentMessages, summaryText) {
-    const text = summaryText ?? this.summarizeHistorySync(olderMessages);
-    const compacted = [];
-    if (systemMessage) compacted.push(systemMessage);
-    if (text) compacted.push({ role: 'system', content: `[CONVERSATION CONTEXT SUMMARY OF EARLIER MESSAGES: ${text}]` });
-    compacted.push(...recentMessages);
-    return compacted;
+  _assemble(systemMessage, olderMessages, recentMessages, summaryText) {
+    const text = summaryText ?? this.summarizeHistorySync(olderMessages);
+    const compacted = systemMessage ? [systemMessage, ...recentMessages] : [...recentMessages];
+    if (!text) return alignChatMessageRoles(compacted);
+    const summaryDirective = {
+      role: 'system',
+      content: text,
+    };
+    return alignChatMessageRoles([...compacted, summaryDirective]);
   }
 
   _shouldCompact(conversationHistory, options) {
@@ -147,11 +324,6 @@ export function compactToolsForPrompt(query = '', options = {}) {
 
 
   if (/photoshoot|magazine|editorial|port|大片|九月刊|写真|นิตยสาร|แฟชั่นเซ็ต/i.test(rawQuery)) {
- 
-    if (!/contract|ambassador|commercial|代言|พรีเซนเตอร์|ทูต/i.test(rawQuery)) {
-      routed = routed.filter(t => (t.function?.name || t.schema?.name || t.name) !== 'get_brand_endorsements');
-    }
-   
     const hasGallery = routed.some(t => (t.function?.name || t.schema?.name || t.name) === 'get_gallery_photos');
     if (!hasGallery) {
       const galleryTool = router.allTools?.find(t => (t.function?.name || t.schema?.name) === 'get_gallery_photos');
@@ -159,6 +331,9 @@ export function compactToolsForPrompt(query = '', options = {}) {
         routed.unshift(galleryTool);
       }
     }
+    if (options.schemaStrategy === 'domain_grouped' || !/แบรนด์|พรีเซนเตอร์|ambassador|endorsement/i.test(rawQuery)) {
+      routed = routed.filter(t => (t.function?.name || t.schema?.name || t.name) !== 'get_brand_endorsements');
+    }
   }
 
   return routed.map(t => {
@@ -193,6 +368,17 @@ const ESSENTIAL_SONG_KEYS = new Set([
 const ESSENTIAL_ROLE_KEYS = new Set([
   'workTitle', 'year', 'role', 'roleCn'
 ]);
+const ESSENTIAL_WEB_KEYS = new Set([
+  'title', 'name', 'alt', 'url', 'link', 'snippet', 'description', 'content', 'source', 'date', 'author',
+  'imageUrl', 'thumbUrl', 'sourcePageUrl', 'width', 'height', 'relevanceScore',
+]);
+const LINK_VALUE_KEYS = /(url|link|href|image|thumb|pic|cover)$/i;
+
+function isLinkValue(key, value) {
+  return typeof value === 'string'
+    && LINK_VALUE_KEYS.test(String(key || ''))
+    && /^https?:\/\//i.test(value);
+}
 
 function stripSearchUrls(obj) {
   if (Array.isArray(obj)) {
@@ -239,6 +425,12 @@ export function compactToolResultForContext(result, options = {}) {
   if (Array.isArray(stripped.videos)) stripped.videos = projectList(stripped.videos, ESSENTIAL_VIDEO_KEYS);
   if (Array.isArray(stripped.musicVideos)) stripped.musicVideos = projectList(stripped.musicVideos, ESSENTIAL_VIDEO_KEYS);
   if (Array.isArray(stripped.roles)) stripped.roles = projectList(stripped.roles, ESSENTIAL_ROLE_KEYS);
+  if (Array.isArray(stripped.results)) stripped.results = projectList(stripped.results, ESSENTIAL_WEB_KEYS);
+
+  if (stripped.scrapedPages) delete stripped.scrapedPages;
+  if (typeof stripped.combinedContent === 'string' && stripped.combinedContent.length > 2000) {
+    stripped.combinedContent = truncatePromptString(stripped.combinedContent, 2000, '...');
+  }
 
   
   let serialized = JSON.stringify(stripped);
@@ -255,15 +447,15 @@ export function compactToolResultForContext(result, options = {}) {
     if (node && typeof node === 'object') {
       const out = {};
       for (const [k, v] of Object.entries(node)) {
-        out[k] = truncateNode(v);
+        out[k] = isLinkValue(k, v) ? v : truncateNode(v);
       }
       return out;
     }
     if (typeof node === 'string' && node.length > 240) {
-      return `${node.slice(0, 240)}…`;
+      return truncatePromptString(node, 240, '…');
     }
     return node;
-  };
+  };
 
   stripped = truncateNode(stripped);
   serialized = JSON.stringify(stripped);
@@ -275,12 +467,12 @@ export function compactToolResultForContext(result, options = {}) {
       if (node && typeof node === 'object') {
         const out = {};
         for (const [k, v] of Object.entries(node)) {
-          out[k] = aggressive(v);
+          out[k] = isLinkValue(k, v) ? v : aggressive(v);
         }
         return out;
       }
-      if (typeof node === 'string' && node.length > 120) {
-        return `${node.slice(0, 120)}…`;
+      if (typeof node === 'string' && node.length > 120) {
+        return truncatePromptString(node, 120, '…');
       }
       return node;
     };

package/server/agent/cpuMetrics.js

@@ -0,0 +1,199 @@
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+
+function runProcessCapture(cmd, args, timeoutMs = 2500) {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+
+    const timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch {}
+      finish({ ok: false, stdout: '', stderr: 'timeout' });
+    }, timeoutMs);
+
+    child.stdout?.on('data', d => { stdout += d.toString(); });
+    child.stderr?.on('data', d => { stderr += d.toString(); });
+
+    child.on('error', (err) => finish({ ok: false, stdout: '', stderr: err.message }));
+    child.on('close', (code) => finish({ ok: code === 0, stdout: stdout.trim(), stderr: stderr.trim() }));
+  });
+}
+
+function detectCpuVendor(model = '') {
+  const m = String(model).toLowerCase();
+  if (m.includes('intel')) return 'Intel';
+  if (m.includes('amd') || m.includes('ryzen') || m.includes('epyc')) return 'AMD';
+  if (m.includes('apple') || m.includes('m1') || m.includes('m2') || m.includes('m3') || m.includes('m4')) return 'Apple';
+  if (m.includes('arm') || m.includes('cortex') || m.includes('snapdragon')) return 'ARM';
+  return 'Generic';
+}
+
+let cachedCpuMetrics = null;
+const CPU_METRICS_TTL_MS = 60_000;
+
+export function clearCpuMetricsCache() {
+  cachedCpuMetrics = null;
+}
+
+export async function getCpuMetrics(force = false) {
+  if (!force && cachedCpuMetrics && (Date.now() - cachedCpuMetrics.timestamp < CPU_METRICS_TTL_MS)) {
+    return cachedCpuMetrics.data;
+  }
+
+  const cpus = os.cpus() || [];
+  const rawModel = cpus[0]?.model?.trim() || 'Generic CPU';
+  const logicalCores = Math.max(1, cpus.length || 1);
+  let physicalCores = logicalCores;
+  let maxClockMhz = cpus[0]?.speed ? Math.round(cpus[0].speed) : null;
+  let socket = null;
+  let source = 'os.cpus';
+
+  if (process.platform === 'win32') {
+    try {
+      const psScript = 'Get-CimInstance Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed, SocketDesignation | ConvertTo-Json -Compress';
+      const res = await runProcessCapture('powershell', ['-NoProfile', '-NonInteractive', '-Command', psScript], 2500);
+      if (res.ok && res.stdout) {
+        const parsed = JSON.parse(res.stdout);
+        const item = Array.isArray(parsed) ? parsed[0] : parsed;
+        if (item) {
+          if (item.NumberOfCores && Number.isFinite(Number(item.NumberOfCores))) {
+            physicalCores = Math.max(1, Number(item.NumberOfCores));
+          }
+          if (item.MaxClockSpeed && Number.isFinite(Number(item.MaxClockSpeed))) {
+            maxClockMhz = Math.round(Number(item.MaxClockSpeed));
+          }
+          if (item.SocketDesignation) {
+            socket = String(item.SocketDesignation).trim();
+          }
+          source = 'Win32_Processor';
+        }
+      }
+    } catch {}
+  } else if (process.platform === 'darwin') {
+    try {
+      const [physRes, logRes] = await Promise.all([
+        runProcessCapture('sysctl', ['-n', 'hw.physicalcpu'], 1500),
+        runProcessCapture('sysctl', ['-n', 'hw.logicalcpu'], 1500),
+      ]);
+      if (physRes.ok && physRes.stdout) {
+        const n = parseInt(physRes.stdout, 10);
+        if (Number.isFinite(n) && n > 0) physicalCores = n;
+        source = 'sysctl';
+      }
+    } catch {}
+  } else if (process.platform === 'linux') {
+    try {
+      const res = await runProcessCapture('lscpu', ['-J'], 1500);
+      if (res.ok && res.stdout) {
+        const json = JSON.parse(res.stdout);
+        const list = json?.lscpu || [];
+        const findField = (name) => list.find(x => x.field?.toLowerCase()?.includes(name))?.data;
+        const coresPerSocket = parseInt(findField('core(s) per socket'), 10);
+        const sockets = parseInt(findField('socket(s)'), 10) || 1;
+        if (Number.isFinite(coresPerSocket) && coresPerSocket > 0) {
+          physicalCores = coresPerSocket * sockets;
+          source = 'lscpu';
+        }
+      }
+    } catch {}
+  }
+
+
+  if (physicalCores === logicalCores && logicalCores >= 4) {
+    const vendor = detectCpuVendor(rawModel);
+    if (vendor === 'Intel' || vendor === 'AMD') {
+    
+      physicalCores = Math.max(1, Math.floor(logicalCores / 2));
+      source = 'heuristic-x86-smt';
+    }
+  }
+
+  const hyperThreading = logicalCores > physicalCores;
+  const smtMultiplier = physicalCores > 0 ? Number((logicalCores / physicalCores).toFixed(2)) : 1;
+  const vendor = detectCpuVendor(rawModel);
+
+ 
+  const cleanModel = rawModel
+    .replace(/\(R\)/gi, '')
+    .replace(/\(TM\)/gi, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+ 
+  const recommendedComputeThreads = physicalCores;
+  const recommendedBatchThreads = logicalCores;
+
+  const data = {
+    model: cleanModel,
+    rawModel,
+    vendor,
+    physicalCores,
+    logicalCores,
+    hyperThreading,
+    smtMultiplier,
+    maxClockMhz,
+    socket,
+    source,
+    recommendedComputeThreads,
+    recommendedBatchThreads,
+    statusText: hyperThreading
+      ? `Active (${smtMultiplier}x SMT • ${physicalCores}C/${logicalCores}T)`
+      : `Single-Threaded (${physicalCores}C/${logicalCores}T)`,
+  };
+
+  cachedCpuMetrics = { data, timestamp: Date.now() };
+  return data;
+}
+
+export function resolveOptimalThreadBudget({ mode = 'auto', requested = null, cpuInfo = null } = {}) {
+  const cpu = cpuInfo || { physicalCores: 6, logicalCores: 12, hyperThreading: true };
+  const req = Number(requested);
+  const hasExplicit = Number.isFinite(req) && req >= 1 && req <= 256;
+
+  switch (String(mode).toLowerCase()) {
+    case 'physical':
+      return {
+        threads: cpu.physicalCores,
+        mode: 'physical',
+        explanation: `Locked to ${cpu.physicalCores} physical cores (avoids SMT cache thrashing for optimal LLM generation speed)`,
+      };
+    case 'smt':
+    case 'all':
+    case 'hyperthreading':
+      return {
+        threads: cpu.logicalCores,
+        mode: 'smt',
+        explanation: `Utilizing all ${cpu.logicalCores} logical threads (maximum parallel prediction throughput)`,
+      };
+    case 'custom':
+      return {
+        threads: hasExplicit ? Math.floor(req) : cpu.physicalCores,
+        mode: 'custom',
+        explanation: `Custom thread count: ${hasExplicit ? Math.floor(req) : cpu.physicalCores}`,
+      };
+    case 'auto':
+    default:
+      if (hasExplicit) {
+        return {
+          threads: Math.min(Math.floor(req), cpu.logicalCores),
+          mode: 'custom',
+          explanation: `User requested ${Math.floor(req)} threads (within ${cpu.logicalCores} thread hardware ceiling)`,
+        };
+      }
+      return {
+        threads: cpu.physicalCores,
+        mode: 'auto',
+        explanation: `Auto-tuned to ${cpu.physicalCores} physical cores for optimal single-stream latency`,
+      };
+  }
+}