kiku-agent 1.0.11 → 1.2.0

package/server/agent/contextCompactor.js

@@ -16,8 +16,8 @@ export function estimateTokenCount(textOrMessages) {
 
 export class ContextCompactor {
   constructor(options = {}) {
-    this.maxTokens = options.maxTokens || 6000;
-    this.keepRecentMessages = options.keepRecentMessages || 6;
+    this.maxTokens = options.maxTokens || 24000;
+    this.keepRecentMessages = options.keepRecentMessages || 8;
   }
 
   summarizeHistorySync(messages = []) {

package/server/agent/debate.js

@@ -0,0 +1,235 @@
+import { ResearchSubagent } from './subagent.js';
+import { executeTool } from './tools.js';
+import { eventBus, Events } from './eventBus.js';
+import { mapConcurrent } from './suggestions.js';
+
+const CATALOG_TOOLS = Object.freeze([
+  'global_search', 'get_profile_and_fandom', 'search_works', 'get_work_detail',
+  'get_character_roles', 'search_discography', 'get_music_videos',
+  'get_media_links', 'get_brand_endorsements', 'get_career_timeline',
+  'get_awards', 'get_social_feed',
+]);
+const WEB_TOOLS = Object.freeze(['web_search', 'web_extract', 'fetch_webpage']);
+const ALL_TOOLS = Object.freeze([...CATALOG_TOOLS, ...WEB_TOOLS]);
+
+function debatePlan(topicOrClaim, catalogSnippet = '') {
+  const note = catalogSnippet ? `\n[VERIFIED PRIMARY CATALOG KNOWLEDGE]:\n${catalogSnippet}\n` : '';
+  return [
+    {
+      id: 'advocate',
+      label: 'Official Advocate (Corroborator)',
+      tools: ALL_TOOLS,
+      objective: `Find and present verified supporting facts for: "${topicOrClaim}".${note}List confirmed achievements, dates, and official records in clean bullet points with numbers and source citations.`,
+    },
+    {
+      id: 'critic',
+      label: 'Critical Skeptic (Counter-Evidence)',
+      tools: ALL_TOOLS,
+      objective: `Examine counter-arguments, misconceptions, timeline boundaries, or missing proof regarding: "${topicOrClaim}".${note}Check if any aspects are overstated, ambiguous, or discontinued, and state nuances clearly.`,
+    },
+  ];
+}
+
+export class DebateOrchestrator {
+  constructor(options = {}) {
+    if (!options.client) throw new Error('DebateOrchestrator requires an LLM client.');
+    this.client = options.client;
+    this.executeTool = options.executeTool;
+    this.maxWorkers = Math.min(Math.max(options.maxWorkers || 2, 1), 2);
+    this.maxIterations = Math.min(Math.max(options.maxIterations || 2, 1), 3);
+    this.active = null;
+    this.lastResult = null;
+  }
+
+  getStatus() {
+    if (!this.active) return { state: 'idle', lastResult: this.lastResult };
+    return {
+      state: 'running',
+      id: this.active.id,
+      topic: this.active.topic,
+      startedAt: this.active.startedAt,
+      workers: [...this.active.workers.values()],
+    };
+  }
+
+  cancel() {
+    if (!this.active) return false;
+    this.active.controller.abort();
+    return true;
+  }
+
+  async run(topicOrClaim, options = {}) {
+    const query = String(topicOrClaim || '').trim();
+    if (!query) throw new Error('A debate topic or claim is required.');
+    if (this.active) throw new Error('A debate job is already in progress.');
+
+    const controller = new AbortController();
+    const abortParent = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', abortParent, { once: true });
+
+    const sharedToolCache = new Map();
+    const cachedExecute = async (name, args) => {
+      const key = `${name}:${JSON.stringify(args || {})}`;
+      if (!sharedToolCache.has(key)) {
+        sharedToolCache.set(key, Promise.resolve((this.executeTool || executeTool)(name, args)));
+      }
+      return sharedToolCache.get(key);
+    };
+
+    let catalogEvidence = '';
+    try {
+      const gRes = await cachedExecute('global_search', { query });
+      if (gRes && (gRes.returnedCount > 0 || gRes.count > 0)) {
+        catalogEvidence += JSON.stringify(gRes, null, 2) + '\n';
+      }
+      const lowerQ = query.toLowerCase();
+      if (lowerQ.includes('snh') || lowerQ.includes('เลือกตั้ง') || lowerQ.includes('award') || lowerQ.includes('รางวัล')) {
+        const awardsRes = await cachedExecute('get_awards', {});
+        if (awardsRes?.awards) {
+          const matched = awardsRes.awards.filter(a => JSON.stringify(a).toLowerCase().includes('snh') || JSON.stringify(a).toLowerCase().includes('election') || JSON.stringify(a).toLowerCase().includes('总选举'));
+          if (matched.length > 0) catalogEvidence += 'Awards:\n' + JSON.stringify(matched, null, 2) + '\n';
+        }
+      }
+      if (lowerQ.includes('timeline') || lowerQ.includes('ประวัติ') || lowerQ.includes('ปี')) {
+        const tlRes = await cachedExecute('get_career_timeline', {});
+        if (tlRes?.timeline) catalogEvidence += 'Timeline:\n' + JSON.stringify(tlRes.timeline.slice(0, 5), null, 2) + '\n';
+      }
+    } catch {}
+
+    const plan = debatePlan(query, catalogEvidence.slice(0, 3000));
+    const job = {
+      id: `debate_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      topic: query,
+      startedAt: new Date().toISOString(),
+      controller,
+      workers: new Map(plan.map(task => [task.id, { id: task.id, label: task.label, state: 'pending', toolCalls: 0 }])),
+    };
+
+    this.active = job;
+    options.onProgress?.({ type: 'start', id: job.id, workers: plan.length });
+
+    eventBus.emit(Events.AGENT_PLAN_START, {
+      planId: job.id,
+      question: `Debate: ${query}`,
+      steps: [
+        ...plan.map(p => ({ id: p.id, label: p.label, state: 'pending', objective: p.objective })),
+        { id: 'judge', label: 'Neutral Judge Verdict', state: 'pending', objective: 'Synthesize advocate & skeptic findings into a final truth matrix.' }
+      ]
+    });
+
+    const isLocalProvider = Boolean(
+      this.client?.provider === 'lmstudio' ||
+      this.client?.provider === 'ollama' ||
+      this.client?.isLocal ||
+      this.client?.getProviderInfo?.()?.isLocal
+    );
+    const concurrency = isLocalProvider ? 1 : Math.min(this.maxWorkers, plan.length);
+
+    try {
+      const workerResults = await mapConcurrent(plan, concurrency, async task => {
+        const status = job.workers.get(task.id);
+        status.state = 'running';
+        options.onProgress?.({ type: 'worker-start', id: task.id, label: task.label });
+        eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+          planId: job.id,
+          stepId: task.id,
+          state: 'running',
+          label: task.label,
+        });
+
+        const worker = new ResearchSubagent({
+          client: this.client,
+          executeTool: cachedExecute,
+          allowedTools: task.tools,
+          maxIterations: this.maxIterations,
+        });
+
+        const result = await worker.run(task.objective, {
+          signal: controller.signal,
+          skillContext: options.skillContext,
+          onProgress: event => {
+            if (event.type === 'tool') status.toolCalls += 1;
+            options.onProgress?.({ ...event, workerId: task.id, label: task.label });
+          },
+        });
+
+        status.state = 'complete';
+        options.onProgress?.({ type: 'worker-complete', id: task.id, label: task.label });
+        eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+          planId: job.id,
+          stepId: task.id,
+          state: 'complete',
+          label: task.label,
+        });
+
+        let ans = result.answer || '';
+        if (!ans.trim() && catalogEvidence) {
+          ans = task.id === 'advocate'
+            ? `Primary records confirm relevant Ju Jingyi milestones:\n${catalogEvidence.slice(0, 600)}`
+            : `Timeline contextual limits:\n${catalogEvidence.slice(0, 600)}`;
+        }
+
+        return { id: task.id, label: task.label, ...result, answer: ans };
+      });
+
+
+      options.onProgress?.({ type: 'synthesizing', label: 'Synthesizing Neutral Verdict' });
+      eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+        planId: job.id,
+        stepId: 'judge',
+        state: 'running',
+        label: 'Neutral Judge Verdict',
+      });
+
+      const advocateData = workerResults.find(r => r.id === 'advocate')?.answer || 'No advocate response';
+      const criticData = workerResults.find(r => r.id === 'critic')?.answer || 'No critic response';
+
+      const judgePrompt = `You are a neutral fact-checking judge examining a claim or topic about Ju Jingyi (鞠婧祎).
+Topic / Claim: "${query}"
+
+[ADVOCATE / SUPPORTING ARGUMENTS & EVIDENCE]:
+${advocateData}
+
+[CRITIC / COUNTER-EVIDENCE & SKEPTIC FINDINGS]:
+${criticData}
+
+Provide a structured, unbiased evaluation in markdown:
+1. **Verdict Summary**: (VERIFIED TRUE | PARTIALLY ACCURATE / CONTEXT NEEDED | UNVERIFIED | FALSE / RUMOR)
+2. **Confidence Score**: (0-100%)
+3. **Key Corroborated Facts**: Bullet points of confirmed truth
+4. **Counter-Points & Nuances**: Bullet points of debunked aspects or ambiguities
+5. **Final Conclusion**: Clear, authoritative 2-3 sentence conclusion.`;
+
+      const judgeResponse = await this.client.chat({
+        messages: [{ role: 'user', content: judgePrompt }],
+        temperature: 0.2,
+        signal: controller.signal,
+      });
+
+      const verdictText = judgeResponse?.content || judgeResponse?.message?.content || 'Unable to generate synthesis.';
+
+      eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+        planId: job.id,
+        stepId: 'judge',
+        state: 'complete',
+        label: 'Neutral Judge Verdict',
+      });
+
+      const finalOutcome = {
+        id: job.id,
+        topic: query,
+        advocate: advocateData,
+        critic: criticData,
+        verdict: verdictText,
+        workers: workerResults,
+        completedAt: new Date().toISOString(),
+      };
+
+      this.lastResult = finalOutcome;
+      return finalOutcome;
+    } finally {
+      this.active = null;
+      options.signal?.removeEventListener('abort', abortParent);
+    }
+  }
+}

package/server/agent/eventBus.js

@@ -88,6 +88,9 @@ export const Events = Object.freeze({
   AGENT_PLAN_STEP_UPDATE: 'agent:plan:step:update',
   AGENT_PLAN_COMPLETE:    'agent:plan:complete',
 
+  AGENT_CLARIFYING_QUESTIONS: 'agent:clarifying:questions',
+  AGENT_CLARIFYING_ANSWER:    'agent:clarifying:answer',
+
   MUSIC_PLAY:          'music:play',
   MUSIC_STOP:          'music:stop',
   MUSIC_QUEUE_CHANGE:  'music:queue:change',

package/server/agent/feedbackLearning.js

@@ -0,0 +1,217 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+// Minimum feedback samples on a feature before it becomes a learned directive.
+export const FEEDBACK_MIN_SAMPLES = 5;
+// Like-rate at/above this promotes a "prefer" directive.
+export const FEEDBACK_LIKE_THRESHOLD = 0.7;
+// Like-rate at/below this promotes an "avoid" directive.
+export const FEEDBACK_DISLIKE_THRESHOLD = 0.35;
+export const FEEDBACK_MAX_DIRECTIVES = 6;
+const MAX_EVENTS = 500;
+
+export function detectAnswerLanguage(text = '') {
+  const s = String(text);
+  const th = (s.match(/[\u0E00-\u0E7F]/g) || []).length;
+  const cjk = (s.match(/[\u4E00-\u9FFF\u3400-\u4DBF]/g) || []).length;
+  const latin = (s.match(/[A-Za-z]/g) || []).length;
+  if (th > 0 && th >= cjk && th >= latin * 0.1) return 'th';
+  if (cjk > latin) return 'zh';
+  return 'en';
+}
+
+export function extractAnswerFeatures(answer = '', toolsUsed = []) {
+  const text = String(answer || '');
+  const length = text.length;
+  const lengthBucket = length < 600 ? 'short' : length <= 2000 ? 'medium' : 'long';
+  const lines = text.split('\n');
+  const hasHeaders = /^#{1,4}\s+\S/m.test(text);
+  const hasBullets = lines.filter(l => /^\s*[-*•]\s+\S/.test(l)).length >= 2;
+  const hasNumbered = lines.filter(l => /^\s*\d+[.)]\s+\S/.test(l)).length >= 2;
+  const hasTable = /\|.+\|/.test(text) && lines.filter(l => /^\s*\|?[\s:|-]+\|?\s*$/.test(l)).length >= 1;
+  const videoLinks = (text.match(/youtube\.com|youtu\.be|bilibili\.com|douyin\.com|youku\.com/gi) || []).length;
+  const totalLinks = (text.match(/https?:\/\/\S+/gi) || []).length;
+  const tools = Array.isArray(toolsUsed) ? toolsUsed.map(String) : [];
+  const usedDeepResearch = tools.some(t => /run_subagent|run_deep_research|verify_claim|web_search|web_extract|fetch_api/.test(t));
+  return {
+    length,
+    lengthBucket,
+    hasHeaders,
+    hasBullets: hasBullets || hasNumbered,
+    hasTable,
+    videoLinks,
+    totalLinks,
+    language: detectAnswerLanguage(text),
+    usedDeepResearch,
+  };
+}
+
+// Each definition maps one observable answer trait to an optional "prefer"
+// directive (high like-rate) and/or an "avoid" directive (low like-rate).
+// Traits whose dislike-side is ambiguous (e.g. disliking a short answer does
+// not imply verbosity is wanted) only define the like side.
+const FEATURE_DEFS = [
+  {
+    key: 'len:short',
+    test: f => f.lengthBucket === 'short',
+    like: 'ผู้ใช้ชอบคำตอบสั้นกระชับ ตอบตรงประเด็น ไม่ยืดเยื้อ',
+  },
+  {
+    key: 'len:long',
+    test: f => f.lengthBucket === 'long',
+    like: 'ผู้ใช้ชอบคำตอบละเอียดเชิงลึกเป็นบางครั้ง แต่ต้องมีโครงสร้างชัดเจน',
+    dislike: 'หลีกเลี่ยงคำตอบที่ยาวยืดเยื้อ ควรสรุปให้กระชับและจัดโครงสร้างให้อ่านง่าย',
+  },
+  {
+    key: 'fmt:headers',
+    test: f => f.hasHeaders,
+    like: 'ใช้หัวข้อ (headers) จัดโครงสร้างคำตอบให้อ่านง่าย',
+  },
+  {
+    key: 'fmt:bullets',
+    test: f => f.hasBullets,
+    like: 'ใช้ bullet/ลำดับข้อสรุปประเด็นสำคัญ ไม่เขียนเป็นย่อหน้ายาวล้วน',
+  },
+  {
+    key: 'fmt:table',
+    test: f => f.hasTable,
+    like: 'ใช้ตารางเปรียบเทียบเมื่อต้องนำเสนอข้อมูลหลายรายการ',
+  },
+  {
+    key: 'fmt:plain',
+    test: f => !f.hasHeaders && !f.hasBullets && !f.hasTable && f.length > 600,
+    dislike: 'หลีกเลี่ยงคำตอบที่เป็นข้อความล้วนยาวๆ โดยไม่มีหัวข้อ bullet หรือตาราง',
+  },
+  {
+    key: 'links:video',
+    test: f => f.videoLinks >= 1,
+    like: 'แนบลิงก์วิดีโอ/YouTube ที่ตรวจสอบแล้วประกอบคำตอบ',
+  },
+  {
+    key: 'depth:research',
+    test: f => f.usedDeepResearch,
+    like: 'ผู้ใช้เห็นคุณค่าของคำตอบที่มีหลักฐานจากการค้นคว้า/ตรวจสอบก่อนตอบ',
+  },
+];
+
+export class FeedbackLearning {
+  constructor(options = {}) {
+    this.persistenceEnabled = options.persistence !== false;
+    this.storagePath = options.storagePath || join(process.cwd(), '.kiku_sessions', 'answer_feedback.json');
+    this.state = { totals: { like: 0, dislike: 0 }, featureStats: {}, directives: [], recent: [] };
+    this._load();
+  }
+
+  _load() {
+    if (!this.persistenceEnabled) return;
+    try {
+      if (existsSync(this.storagePath)) {
+        const data = JSON.parse(readFileSync(this.storagePath, 'utf-8'));
+        this.state = {
+          totals: { like: 0, dislike: 0, ...(data.totals || {}) },
+          featureStats: data.featureStats || {},
+          directives: Array.isArray(data.directives) ? data.directives : [],
+          recent: Array.isArray(data.recent) ? data.recent.slice(-100) : [],
+        };
+      }
+    } catch {}
+  }
+
+  _save() {
+    if (!this.persistenceEnabled) return;
+    try {
+      const dir = dirname(this.storagePath);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+      writeFileSync(this.storagePath, JSON.stringify(this.state, null, 2), { mode: 0o600 });
+    } catch {}
+  }
+
+  record(event = {}) {
+    const rating = String(event.rating || '').toLowerCase();
+    if (rating !== 'like' && rating !== 'dislike') {
+      throw new Error('rating must be "like" or "dislike".');
+    }
+    const answer = String(event.answer || '').slice(0, 5000);
+    const toolsUsed = Array.isArray(event.toolsUsed)
+      ? event.toolsUsed.map(t => String(t).slice(0, 80)).slice(0, 20)
+      : [];
+    const features = extractAnswerFeatures(answer, toolsUsed);
+
+    this.state.totals[rating] += 1;
+    for (const def of FEATURE_DEFS) {
+      let hit = false;
+      try { hit = def.test(features) === true; } catch { hit = false; }
+      if (!hit) continue;
+      const stat = this.state.featureStats[def.key] || { likes: 0, dislikes: 0 };
+      if (rating === 'like') stat.likes += 1;
+      else stat.dislikes += 1;
+      this.state.featureStats[def.key] = stat;
+    }
+
+    this.state.recent.push({
+      at: new Date().toISOString(),
+      rating,
+      messageId: String(event.messageId || '').slice(0, 100),
+      sessionId: String(event.sessionId || '').slice(0, 100),
+      query: String(event.query || '').slice(0, 300),
+      answerExcerpt: answer.slice(0, 500),
+      answerLength: answer.length,
+      toolsUsed,
+      model: String(event.model || '').slice(0, 120),
+      persona: String(event.persona || '').slice(0, 60),
+    });
+    if (this.state.recent.length > MAX_EVENTS) {
+      this.state.recent = this.state.recent.slice(-MAX_EVENTS);
+    }
+
+    this._recomputeDirectives();
+    this._save();
+    return { totals: { ...this.state.totals }, directives: this.state.directives.map(d => ({ ...d })) };
+  }
+
+  _recomputeDirectives() {
+    const out = [];
+    for (const def of FEATURE_DEFS) {
+      const stat = this.state.featureStats[def.key];
+      if (!stat) continue;
+      const samples = stat.likes + stat.dislikes;
+      if (samples < FEEDBACK_MIN_SAMPLES) continue;
+      const likeRate = stat.likes / samples;
+      if (def.like && likeRate >= FEEDBACK_LIKE_THRESHOLD) {
+        out.push({ id: `prefer:${def.key}`, kind: 'prefer', text: def.like, support: samples, likeRate: Number(likeRate.toFixed(2)), updatedAt: new Date().toISOString() });
+      } else if (def.dislike && likeRate <= FEEDBACK_DISLIKE_THRESHOLD) {
+        out.push({ id: `avoid:${def.key}`, kind: 'avoid', text: def.dislike, support: samples, likeRate: Number(likeRate.toFixed(2)), updatedAt: new Date().toISOString() });
+      }
+    }
+    // Prefer stronger evidence first; cap so the prompt stays lean.
+    out.sort((a, b) => b.support - a.support || (b.kind === 'avoid' ? 1 : 0) - (a.kind === 'avoid' ? 1 : 0));
+    this.state.directives = out.slice(0, FEEDBACK_MAX_DIRECTIVES);
+  }
+
+  buildStyleContext() {
+    const directives = this.state.directives;
+    if (!directives.length) return '';
+    const prefers = directives.filter(d => d.kind === 'prefer').map(d => `- ${d.text}`);
+    const avoids = directives.filter(d => d.kind === 'avoid').map(d => `- ${d.text}`);
+    const lines = [
+      `สิ่งที่เรียนรู้จาก like/dislike ของผู้ใช้ (${this.state.totals.like} likes, ${this.state.totals.dislike} dislikes):`,
+    ];
+    if (prefers.length) lines.push(`ตอบแนวนี้:\n${prefers.join('\n')}`);
+    if (avoids.length) lines.push(`หลีกเลี่ยงแนวนี้:\n${avoids.join('\n')}`);
+    return lines.join('\n');
+  }
+
+  getStats() {
+    const featureWinRates = {};
+    for (const [key, stat] of Object.entries(this.state.featureStats)) {
+      const samples = stat.likes + stat.dislikes;
+      featureWinRates[key] = { ...stat, samples, likeRate: samples ? Number((stat.likes / samples).toFixed(2)) : null };
+    }
+    return {
+      totals: { ...this.state.totals },
+      directives: this.state.directives.map(d => ({ ...d })),
+      featureWinRates,
+      recentCount: this.state.recent.length,
+    };
+  }
+}