kiku-agent 1.0.0

package/server/agent/config.js

@@ -0,0 +1,90 @@
+export const config = {
+  lmStudio: {
+    baseUrl: process.env.LMSTUDIO_BASE_URL || process.env.OPENAI_BASE_URL || 'http://127.0.0.1:1234/v1',
+    model: 'google/gemma-4-e4b',
+    defaultModel: 'google/gemma-4-e4b',
+    temperature: 0.3,
+    maxTokens: 1536,
+    requestTimeoutMs: 180000,
+  },
+
+  agent: {
+    maxIterations: 4,
+    slidingWindowSize: 8,
+    language: 'auto',
+    systemPersona: `You are "Kiku AI" (จวีจิ้งอี AI ผู้ช่วยอัจฉริยะ / 鞠婧祎智能AI助手), an expert AI specialist on the Chinese singer, actress, and artist Ju Jingyi (鞠婧祎 - จวีจิ้งอี).
+You have access to a verified API database of her dramas, songs, character roles, brand endorsements, timeline milestones, awards, and music videos, as well as LIVE Internet Search (web_search, fetch_webpage, web_extract, fetch_json).
+
+=== CRITICAL INSTRUCTIONS ===
+
+1. PROPORTIONAL RESPONSE & GREETINGS:
+   - CASUAL GREETINGS ("Hi", "Hello", "สวัสดี", "你好"): Reply warmly in 1-2 sentences. DO NOT call tools or dump catalogs.
+   - SHORT QUESTIONS: Give direct, concise 1-3 sentence answer.
+   - BROAD REQUESTS: Provide structured, well-organized list with key details and clickable links.
+
+2. DYNAMIC LANGUAGE MIRRORING:
+   - THAI INPUT ➔ Reply in polite Thai (ใช้ ค่ะ/นะคะ เสมอ)
+   - CHINESE INPUT ➔ Reply in fluent, polite Chinese (简体/繁体中文)
+   - ENGLISH INPUT ➔ Reply in polished, professional English
+   - MIXED INPUT ➔ Match dominant language while preserving bilingual titles
+
+3. RESPONSE FORMATTING (CRITICAL — NO SYSTEM LEAK):
+   - NEVER include "Thinking Process", "Tool Calling", "Action:", "Action Input:", or any internal reasoning steps in your response text.
+   - NEVER include tool call JSON, function names, or parameter schemas in your response.
+   - NEVER include advertisements, sponsor mentions, or promotional content in your response.
+   - Emoji are optional and must be semantic: use at most one relevant emoji per response, never decorate every heading or bullet.
+   - Your response must be CLEAN user-facing content ONLY — formatted with Markdown headers (###), bold (**text**), bullet points (•), and clickable links.
+   - Think silently using tools, then present ONLY the final answer to the user.
+
+4. REAL YOUTUBE & MEDIA LINKS (WHEN DISCUSSING MEDIA):
+   - Provide REAL, WORKING, CLICKABLE links in Markdown format:
+     • Direct Watch Link: [Watch on YouTube](https://www.youtube.com/watch?v=VIDEO_ID)
+     • Search Link: https://www.youtube.com/results?search_query=QUERY
+   - NEVER use fake placeholder links like "watch?v=xxx".
+
+5. SMART TOOL SELECTION (USE TOOLS TO GATHER FACTS, THEN ANSWER):
+   - Music videos & stages ➔ get_music_videos or get_media_links
+   - Songs, OSTs, Singles ➔ search_discography or get_media_links
+   - Drama works & trailers ➔ search_works or get_work_detail
+   - Profile & fandom ➔ get_profile_and_fandom
+   - Brand endorsements ➔ get_brand_endorsements
+   - Breaking news & external facts ➔ web_search or web_extract (preferred for multi-source research)
+   - Deep research on a topic ➔ web_extract (search + auto-fetch top results)
+   - Read a specific webpage ➔ fetch_webpage (cheerio-powered extraction)
+   - Fetch REST API / JSON data ➔ fetch_json
+   - Read local project files ➔ read_local_file
+   - Browse directory structure ➔ list_directory
+   - Visual screenshot ➔ screenshot_webpage
+   - If local tools return insufficient results, ALWAYS fall back to web_search or web_extract.
+
+6. FACT RETRIEVAL & CHRONOLOGICAL ACCURACY:
+   - THE CURRENT YEAR IS 2026.
+   - Always use tools to verify facts before answering. Do NOT hallucinate dates, titles, or links.
+   - Sort chronologically (newest first). Never repeat the same statement.
+   - Ju Jingyi's key 2026 projects:
+     • "Veil of Shadows (月鳞绮纪)" — Role: Lu Wuyi (露芜衣) on Youku
+     • "The Eternal Fragrance (千香)" — Role: Jiang Lifei (姜黎非) with Song Weilong on Youku
+     • "Wanhua Sin (万华世界)" — Promo OST: "Set Fire to the Silent World (着火的沉默世界)"
+     • 2026 Solo Single: "FIND THE WAY" (YouTube: 9AeErG03SZw)
+     • 2026 Special Live Stage: "Yu Ai / 雨爱" (YouTube: OMLpNyp8T7Q)
+   - Classic hits: "In Blossom (2024)", "Sword and Fairy 4 (2024)", "Beauty of Resilience (2023)", "Rebirth for You (2021)", "The Blooms at Ruyi Pavilion (2020)", "The Legend of White Snake (2019)", "Legend of Yunxi (2018)".
+
+7. COMPREHENSIVE KNOWLEDGE — LEGAL & CAREER DETAILS:
+   When discussing Ju Jingyi's career or controversies, be accurate and specific:
+   - CAREER PATH: SNH48 2nd gen (2013) → "4000-year idol" nickname (2014) → General Election winner 2 consecutive years (2016-2017) → Star Hall of Fame → Solo career → Acting breakthrough with "Legend of Yunxi" (2018).
+   - CONTRACT DISPUTE (Star48/Siba Media): The supplementary agreement dispute. JJY's side claims main contract ended June 2024, alleges forged signatures. Star48 claims contract extends to 2033. Tax evasion tip-off report was filed by Star48's side; JJY denies all allegations and confirms tax compliance.
+   - PORTRAIT/COPYRIGHT INFRINGEMENT CASES: Ju Jingyi has filed lawsuits against beauty clinics and brands for unauthorized use of her image/likeness (Right of Portrait / 肖像权纠纷). This is a separate legal matter from the Star48 dispute.
+   - When asked about legal issues, use web_search or web_extract to get the latest verified information.
+
+8. CONCISE & SMART RESPONSE QUALITY:
+   - Match the depth of your answer to what the user asked.
+   - Do not dump the entire database unless specifically requested.
+   - Start directly with the answer — no template greetings like "Hello!" or "I searched...".
+   - Keep the interface visually restrained; omit emoji unless one clearly improves recognition of the topic.
+
+9. PROACTIVE MUSIC INVITATION:
+   - When discussing a specific song/MV/OST, naturally ask if the user wants to listen.
+- Example: "เพลง FIND THE WAY จังหวะทรงพลังมากเลยค่ะ! อยากให้ Kiku เปิดให้ฟังมั้ยคะ?"
+   - If user agrees → call play_music. If user says "Stop" → call stop_music.`,
+  }
+};

package/server/agent/errors.js

@@ -0,0 +1,9 @@
+export function createAbortError(message = 'Query cancelled by user.') {
+  const error = new Error(message);
+  error.name = 'AbortError';
+  return error;
+}
+
+export function isAbortError(error) {
+  return error?.name === 'AbortError';
+}

package/server/agent/eventBus.js

@@ -0,0 +1,103 @@
+class EventBus {
+  constructor() {
+    this._listeners = new Map();
+    this._history = [];
+    this._maxHistory = 50;
+  }
+
+  on(event, fn) {
+    if (!this._listeners.has(event)) this._listeners.set(event, new Set());
+    this._listeners.get(event).add(fn);
+    return () => this.off(event, fn);
+  }
+
+  once(event, fn) {
+    const wrapper = (data, name) => {
+      this.off(event, wrapper);
+      fn(data, name);
+    };
+    return this.on(event, wrapper);
+  }
+
+  off(event, fn) {
+    const set = this._listeners.get(event);
+    if (set) set.delete(fn);
+  }
+
+  emit(event, data) {
+    this._history.push({ event, data, ts: Date.now() });
+    if (this._history.length > this._maxHistory) {
+      this._history.shift();
+    }
+
+    const exactSet = this._listeners.get(event);
+    if (exactSet) {
+      for (const fn of exactSet) {
+        try { fn(data, event); } catch { /* swallow */ }
+      }
+    }
+
+    const ns = event.split(':')[0];
+    const wildcardEvent = ns + ':*';
+    const wildcardSet = this._listeners.get(wildcardEvent);
+    if (wildcardSet) {
+      for (const fn of wildcardSet) {
+        try { fn(data, event); } catch { /* swallow */ }
+      }
+    }
+
+    const globalSet = this._listeners.get('*');
+    if (globalSet) {
+      for (const fn of globalSet) {
+        try { fn(data, event); } catch { /* swallow */ }
+      }
+    }
+  }
+
+  getHistory(limit = this._maxHistory) {
+    return this._history.slice(-limit);
+  }
+
+  clear() {
+    this._listeners.clear();
+    this._history.length = 0;
+  }
+}
+
+export const eventBus = new EventBus();
+
+export const Events = Object.freeze({
+  AGENT_QUERY_START:    'agent:query:start',
+  AGENT_QUERY_END:      'agent:query:end',
+  AGENT_QUERY_ERROR:    'agent:query:error',
+  AGENT_STATE_CHANGE:   'agent:state:change',
+
+  AGENT_REASONING_START: 'agent:reasoning:start',
+  AGENT_REASONING_DELTA: 'agent:reasoning:delta',
+  AGENT_REASONING_END:   'agent:reasoning:end',
+  AGENT_TOKEN_START:     'agent:token:start',
+  AGENT_TOKEN_DELTA:     'agent:token:delta',
+  AGENT_TOKEN_END:       'agent:token:end',
+  AGENT_FINAL_ANSWER:    'agent:final:answer',
+
+  AGENT_TOOL_START:    'agent:tool:start',
+  AGENT_TOOL_RESULT:   'agent:tool:result',
+  AGENT_TOOL_ERROR:    'agent:tool:error',
+
+  MUSIC_PLAY:          'music:play',
+  MUSIC_STOP:          'music:stop',
+  MUSIC_QUEUE_CHANGE:  'music:queue:change',
+  MUSIC_STATE_CHANGE:  'music:state:change',
+
+  SESSION_SAVED:       'session:saved',
+  SESSION_ARCHIVED:    'session:archived',
+  MEMORY_FACT_ADDED:   'memory:fact:added',
+
+  UI_RENDER:           'ui:render',
+  UI_CLEAR:            'ui:clear',
+  UI_MESSAGE:          'ui:message',
+
+  QUEUE_ITEM_ADDED:    'queue:item:added',
+  QUEUE_ITEM_CONSUMED: 'queue:item:consumed',
+  QUEUE_CLEARED:       'queue:cleared',
+});

package/server/agent/llmClient.js

@@ -0,0 +1,200 @@
+import { config } from './config.js';
+
+export class LMStudioClient {
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl || config.lmStudio.baseUrl).replace(/\/+$/, '');
+    this.model = options.model || config.lmStudio.model || 'google/gemma-4-e4b';
+    this.timeout = options.timeout || config.lmStudio.requestTimeoutMs;
+  }
+
+  async checkConnection() {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 4000);
+
+      const res = await fetch(`${this.baseUrl}/models`, {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json' },
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!res.ok) {
+        return {
+          connected: false,
+          error: `LM Studio returned status ${res.status}: ${res.statusText}`,
+          models: []
+        };
+      }
+
+      const data = await res.json();
+      const models = (data.data || []).map(m => m.id);
+
+      const matchedGemma = models.find(m => 
+        m === 'google/gemma-4-e4b' || 
+        m === 'gemma-4-e4b' || 
+        m.toLowerCase().includes('gemma-4-e4b') ||
+        (m.toLowerCase().includes('gemma') && m.toLowerCase().includes('e4b'))
+      );
+
+      if (matchedGemma) {
+        this.model = matchedGemma;
+      }
+
+      return {
+        connected: true,
+        baseUrl: this.baseUrl,
+        models,
+        activeModel: this.model,
+        isModelAvailable: !!matchedGemma
+      };
+    } catch (err) {
+      return {
+        connected: false,
+        error: err.name === 'AbortError' 
+          ? `Connection timed out at ${this.baseUrl}` 
+          : `Cannot reach LM Studio at ${this.baseUrl} (${err.message})`,
+        models: []
+      };
+    }
+  }
+
+  async chat({
+    messages,
+    tools = null,
+    temperature = 0.3,
+    maxTokens = 1536,
+    stream = true,
+    signal = null,
+    onToken = null,
+    onThought = null
+  }) {
+    const payload = {
+      model: this.model,
+      messages,
+      temperature,
+      max_tokens: maxTokens,
+      stream
+    };
+
+    if (tools && Array.isArray(tools) && tools.length > 0) {
+      payload.tools = tools;
+      payload.tool_choice = "auto";
+    }
+
+    const controller = new AbortController();
+    let timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+    const abortHandler = () => controller.abort();
+    if (signal) signal.addEventListener('abort', abortHandler, { once: true });
+
+    const resetTimeout = () => {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    };
+
+    try {
+      const res = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer lm-studio'
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+
+      resetTimeout();
+
+      if (!res.ok) {
+        const errorText = await res.text();
+        throw new Error(`LM Studio error (${res.status}): ${errorText}`);
+      }
+
+      if (!stream) {
+        const data = await res.json();
+        clearTimeout(timeoutId);
+        if (signal) signal.removeEventListener('abort', abortHandler);
+        return data.choices && data.choices[0] ? data.choices[0].message : null;
+      }
+
+     
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder('utf-8');
+      let fullContent = '';
+      let fullReasoning = '';
+      let toolCalls = [];
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        resetTimeout();
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data:')) continue;
+          const jsonStr = trimmed.replace(/^data:\s*/, '');
+          if (jsonStr === '[DONE]') continue;
+
+          try {
+            const parsed = JSON.parse(jsonStr);
+            const delta = parsed.choices?.[0]?.delta;
+            if (!delta) continue;
+
+            if (delta.reasoning_content) {
+              fullReasoning += delta.reasoning_content;
+              if (onThought) onThought(delta.reasoning_content);
+            }
+
+            if (delta.content) {
+              fullContent += delta.content;
+              if (onToken) onToken(delta.content);
+            }
+
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0;
+                if (!toolCalls[idx]) {
+                  toolCalls[idx] = {
+                    id: tc.id || `call_${Date.now()}_${idx}`,
+                    type: 'function',
+                    function: { name: '', arguments: '' }
+                  };
+                }
+                if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
+                if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+
+      clearTimeout(timeoutId);
+
+      const resultMessage = {
+        role: 'assistant',
+        content: fullContent,
+        reasoning_content: fullReasoning
+      };
+
+      if (toolCalls.length > 0) {
+        resultMessage.tool_calls = toolCalls.filter(Boolean);
+      }
+
+      if (signal) signal.removeEventListener('abort', abortHandler);
+      return resultMessage;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (signal) signal.removeEventListener('abort', abortHandler);
+      throw err;
+    }
+  }
+}