kiku-agent 1.3.2 → 1.3.3

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

@@ -0,0 +1,173 @@
+import test, { after } from 'node:test';
+import assert from 'node:assert/strict';
+import { Readable } from 'node:stream';
+import { EventEmitter } from 'node:events';
+import { AgentMemory } from '../memory.js';
+import { setMemoryStore, handleMemoryGetRoute, handleMemoryActionRoute } from '../../web-chat/routes/memoryRoute.js';
+
+function request(body, headers = {}) {
+  const req = Readable.from([JSON.stringify(body === undefined ? {} : body)]);
+  req.socket = { remoteAddress: '127.0.0.1' };
+  req.headers = headers;
+  return req;
+}
+
+function response() {
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = (code) => { res.statusCode = code; res.headersSent = true; };
+  res.write = (data) => { res.chunks += data; };
+  res.end = (data = '') => { res.chunks += data; res.writableEnded = true; res.emit('finish'); };
+  res.json = () => JSON.parse(res.chunks);
+  return res;
+}
+
+function freshStore() {
+  setMemoryStore(new AgentMemory({ persistence: false }));
+}
+
+async function getJson() {
+  const res = response();
+  await handleMemoryGetRoute(request(), res);
+  assert.equal(res.statusCode, 200);
+  return res.json();
+}
+
+async function postJson(body, headers = {}) {
+  const res = response();
+  await handleMemoryActionRoute(request(body, headers), res);
+  return { status: res.statusCode, body: res.chunks ? res.json() : null };
+}
+
+test('memory GET reports empty store with persistence flag', async () => {
+  freshStore();
+  const data = await getJson();
+  assert.equal(data.status, 'ok');
+  assert.equal(data.factsCount, 0);
+  assert.equal(data.persistent, false);
+  assert.deepEqual(data.facts, []);
+  assert.deepEqual(data.topTopics, []);
+});
+
+test('memory add stores, lists, searches and deletes facts', async () => {
+  freshStore();
+  const added = await postJson({ action: 'add', content: 'ผู้ใช้ชื่นชอบซีรีส์ In Blossom', category: 'drama', tags: ['In Blossom'] });
+  assert.equal(added.status, 200);
+  assert.ok(added.body.fact.id);
+  assert.equal(added.body.fact.category, 'drama');
+  assert.ok(added.body.fact.createdAt);
+
+  const listed = await getJson();
+  assert.equal(listed.factsCount, 1);
+  assert.equal(listed.factsByCategory.drama, 1);
+
+  const found = await postJson({ action: 'search', query: 'Blossom' });
+  assert.equal(found.status, 200);
+  assert.equal(found.body.count, 1);
+
+  const missed = await postJson({ action: 'search', query: 'Versace' });
+  assert.equal(missed.body.count, 0);
+
+  const removed = await postJson({ action: 'delete', id: added.body.fact.id });
+  assert.equal(removed.status, 200);
+  assert.equal((await getJson()).factsCount, 0);
+});
+
+test('memory add/delete validate input strictly', async () => {
+  freshStore();
+  assert.equal((await postJson({ action: 'add', content: '   ' })).status, 400);
+  assert.equal((await postJson({ action: 'add', content: 'x'.repeat(2001) })).status, 400);
+  assert.equal((await postJson({ action: 'delete', id: 'bad id!' })).status, 400);
+  assert.equal((await postJson({ action: 'delete', id: 'fact_missing' })).status, 404);
+  assert.equal((await postJson({ action: 'unknown-op' })).status, 400);
+});
+
+test('memory preserves raw content verbatim for UI-side escaping', async () => {
+  freshStore();
+  const evil = '<script>alert(1)</script>';
+  const added = await postJson({ action: 'add', content: evil });
+  assert.equal(added.status, 200);
+  assert.equal(added.body.fact.content, evil);
+});
+
+test('memory GET enriches archived sessions with preview and topics', async () => {
+  freshStore();
+  const data = await getJson();
+  assert.deepEqual(data.sessions, []);
+});
+
+test('memory session_summary returns 400/404 for invalid or unknown ids', async () => {
+  freshStore();
+  assert.equal((await postJson({ action: 'session_summary' })).status, 400);
+  assert.equal((await postJson({ action: 'session_summary', sessionId: 'bad id!' })).status, 400);
+  assert.equal((await postJson({ action: 'session_summary', sessionId: 'sess_missing' })).status, 404);
+});
+
+test('memory session_summary builds exchanges from an archived session on disk', async () => {
+  freshStore();
+  const mem = new AgentMemory({ persistence: false });
+  mem.sessions = [{
+    id: 'sess_live_1',
+    createdAt: new Date('2026-09-15T10:00:00Z'),
+    endedAt: new Date('2026-09-15T10:05:00Z'),
+    messageCount: 2,
+    summary: null,
+  }];
+  mem.loadArchivedSession = async (sessionId) => {
+    assert.equal(sessionId, 'sess_live_1');
+    return {
+      id: 'sess_live_1',
+      createdAt: new Date('2026-09-15T10:00:00Z'),
+      endedAt: new Date('2026-09-15T10:05:00Z'),
+      stats: { totalDurationMs: 65400, totalToolCalls: 2 },
+      messages: [
+        { role: 'user', parts: [{ type: 'text', content: 'In Blossom ออกปีไหน' }] },
+        { role: 'assistant', parts: [{ type: 'text', content: 'ออกอากาศปี 2024 ค่ะ' }] },
+      ],
+    };
+  };
+  setMemoryStore(mem);
+  const result = await postJson({ action: 'session_summary', sessionId: 'sess_live_1' });
+  assert.equal(result.status, 200);
+  assert.equal(result.body.status, 'ok');
+  assert.equal(result.body.sessionId, 'sess_live_1');
+  assert.equal(result.body.messageCount, 2);
+  assert.equal(result.body.stats.totalToolCalls, 2);
+  assert.equal(result.body.summary.questionCount, 1);
+  assert.equal(result.body.summary.durationMs, 65400);
+  assert.equal(result.body.summary.keyExchanges.length, 1);
+  assert.equal(result.body.summary.keyExchanges[0].question, 'In Blossom ออกปีไหน');
+  assert.equal(result.body.summary.keyExchanges[0].answerPreview, 'ออกอากาศปี 2024 ค่ะ');
+});
+
+test('memory export returns a downloadable snapshot', async () => {
+  freshStore();
+  await postJson({ action: 'add', content: 'fact one' });
+  const exported = await postJson({ action: 'export' });
+  assert.equal(exported.status, 200);
+  assert.ok(exported.body.exportedAt);
+  assert.equal(exported.body.facts.length, 1);
+  assert.equal(exported.body.facts[0].content, 'fact one');
+});
+
+test('memory clear requires an admin key', async () => {
+  freshStore();
+  await postJson({ action: 'add', content: 'fact one' });
+  const origAdminKey = process.env.WEBCHAT_ADMIN_KEY;
+  process.env.WEBCHAT_ADMIN_KEY = 'mem-route-test-admin';
+  try {
+    assert.equal((await postJson({ action: 'clear' })).status, 401);
+    assert.equal((await postJson({ action: 'clear' }, { 'x-api-key': 'wrong' })).status, 401);
+    assert.equal((await getJson()).factsCount, 1);
+    const cleared = await postJson({ action: 'clear' }, { 'x-api-key': 'mem-route-test-admin' });
+    assert.equal(cleared.status, 200);
+    assert.equal((await getJson()).factsCount, 0);
+  } finally {
+    if (origAdminKey !== undefined) process.env.WEBCHAT_ADMIN_KEY = origAdminKey;
+    else delete process.env.WEBCHAT_ADMIN_KEY;
+  }
+});
+
+after(() => {
+  setMemoryStore(new AgentMemory({ persistence: false }));
+});

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

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+import { getSettingsHtml } from '../../web-chat/ui/settingsBuilder.js';
+
+test('memory session fields use normalized wrappers and fluid responsive classes', async () => {
+  const html = getSettingsHtml();
+  const css = await readFile(new URL('../../web-chat/ui/styles/main.css', import.meta.url), 'utf8');
+
+  assert.match(html, /class="memory-input-layout memory-input-layout--textarea"/);
+  assert.match(html, /class="memory-input-layout memory-search-field"/);
+  assert.match(html, /id="mem-search" class="form-control memory-field"/);
+  assert.doesNotMatch(html, /id="mem-search"[^>]+min-width:\s*200px/);
+  assert.match(css, /#tab-memory \.memory-field::placeholder[\s\S]*line-height:\s*1\.45/);
+  assert.match(css, /#tab-memory input\.memory-field::placeholder[\s\S]*text-overflow:\s*ellipsis/);
+  assert.match(css, /#tab-memory textarea\.memory-field[\s\S]*line-height:\s*1\.6/);
+  assert.match(css, /#tab-memory \.memory-field \{[\s\S]*min-inline-size:\s*0/);
+  assert.match(css, /padding:\s*0\.625rem 0\.875rem/);
+  assert.match(css, /@media \(max-width:\s*40rem\)[\s\S]*grid-template-columns:\s*minmax\(0, 1fr\)/);
+});
+
+test('memory sessions browser ships session list, filter chips and i18n strings', async () => {
+  const html = getSettingsHtml();
+  const css = await readFile(new URL('../../web-chat/ui/styles/main.css', import.meta.url), 'utf8');
+
+  assert.match(html, /id="mem-sessions-list" class="mem-sessions"/);
+  assert.match(html, /id="mem-category-filter" class="mem-category-filter"/);
+  assert.match(html, /onclick="loadMemorySessions\(true\)"/);
+  assert.match(html, /toggleMemorySession\(this\.dataset\.sessionId\)/);
+  assert.match(html, /filterMemoryFactsByCategory\(this\.dataset\.cat\)/);
+  assert.match(html, /cardTitleMemSessions/);
+  assert.match(html, /memSessionsEmpty/);
+
+  assert.match(css, /#tab-memory \.mem-sessions \{[\s\S]*?flex-direction:\s*column/);
+  assert.match(css, /#tab-memory \.mem-session \{[\s\S]*?border-radius:\s*14px/);
+  assert.match(css, /#tab-memory \.mem-session-head \{[\s\S]*?cursor:\s*pointer/);
+  assert.match(css, /#tab-memory \.mem-session-detail-wrap \{[\s\S]*?border-top:\s*1px dashed/);
+  assert.match(css, /#tab-memory \.mem-filter-chip \{[\s\S]*?border-radius:\s*999px/);
+  assert.match(css, /#tab-memory \.mem-sessions-empty \{[\s\S]*?border:\s*1px dashed/);
+});
+
+test('memory sessions use spaced layout classes instead of cramped inline styles', async () => {
+  const html = getSettingsHtml();
+  const css = await readFile(new URL('../../web-chat/ui/styles/main.css', import.meta.url), 'utf8');
+
+  assert.match(html, /id="mem-status-grid" class="mem-stats"/);
+  assert.match(html, /id="mem-topics" class="mem-topics"/);
+  assert.match(html, /id="mem-facts-list" class="mem-facts"/);
+  assert.match(html, /class="[^"]*\bmem-fact-content\b/);
+  assert.match(html, /class="[^"]*\bmem-fact-meta\b/);
+  assert.match(html, /class="[^"]*\bmem-topic-chip\b/);
+  assert.doesNotMatch(html, /id="mem-facts-list"[^>]*style=/);
+  assert.doesNotMatch(html, /id="mem-status-grid"[^>]*style=/);
+
+  assert.match(css, /#tab-memory \.mem-stats \{[\s\S]*?gap:\s*14px/);
+  assert.match(css, /#tab-memory \.mem-stat \{[\s\S]*?padding:\s*16px 18px/);
+  assert.match(css, /#tab-memory \.mem-stat-value \{[\s\S]*?margin-top:\s*8px/);
+  assert.match(css, /#tab-memory \.mem-topics \{[\s\S]*?gap:\s*10px/);
+  assert.match(css, /#tab-memory \.mem-topic-chip \{[\s\S]*?padding:\s*6px 14px/);
+  assert.match(css, /#tab-memory \.mem-facts \{[\s\S]*?gap:\s*12px/);
+  assert.match(css, /#tab-memory \.mem-fact \{[\s\S]*?padding:\s*16px 18px/);
+  assert.match(css, /#tab-memory \.mem-fact-main \{[\s\S]*?gap:\s*14px/);
+  assert.match(css, /#tab-memory \.mem-fact-content \{[\s\S]*?line-height:\s*1\.7/);
+  assert.match(css, /#tab-memory \.mem-fact-meta \{[\s\S]*?margin-top:\s*12px/);
+  assert.match(css, /#tab-memory \.mem-actions \{[\s\S]*?margin-top:\s*18px/);
+  assert.match(css, /#tab-memory \.form-label \{[\s\S]*?margin-bottom:\s*8px/);
+});
+
+test('LM Studio settings default Gemma sessions to a 32K loaded context and one parallel slot', () => {
+  const html = getSettingsHtml();
+  assert.match(html, /id="cfg-lms-context"[^>]+value="32768"/);
+  assert.match(html, /id="cfg-cpu-threads"[^>]+value="1"/);
+  assert.match(html, /id="cfg-context-limit"[^>]+value="32768"/);
+});

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

@@ -0,0 +1,148 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { LLMClient } from '../llmClient.js';
+import { getModelCompatibility, normalizeAssistantMessage, StreamContentNormalizer } from '../modelCompatibility.js';
+
+test('model compatibility registry selects profiles for major model families', () => {
+  assert.equal(getModelCompatibility('vllm', 'Qwen/Qwen3-8B').id, 'qwen3');
+  assert.equal(getModelCompatibility('vllm', 'Qwen/Qwen3-Coder-30B').toolProtocol, 'qwen3-xml');
+  assert.equal(getModelCompatibility('vllm', 'deepseek-ai/DeepSeek-R1').reasoningProtocol, 'deepseek');
+  assert.equal(getModelCompatibility('vllm', 'meta-llama/Llama-3.1-8B-Instruct').toolProtocol, 'llama-json');
+  assert.equal(getModelCompatibility('vllm', 'mistralai/Mistral-7B-Instruct-v0.3').toolProtocol, 'mistral');
+});
+
+test('normalizer converts legacy function calls and tagged Qwen calls', () => {
+  const legacy = normalizeAssistantMessage({
+    role: 'assistant',
+    content: 'answer',
+    function_call: { name: 'search_works', arguments: { query: 'In Blossom' } }
+  });
+  assert.equal(legacy.tool_calls[0].function.name, 'search_works');
+  assert.deepEqual(JSON.parse(legacy.tool_calls[0].function.arguments), { query: 'In Blossom' });
+
+  const qwen = normalizeAssistantMessage({
+    role: 'assistant',
+    content: '<tool_call>{"name":"search_works","arguments":{"query":"In Blossom"}}</tool_call>'
+  });
+  assert.equal(qwen.tool_calls[0].function.name, 'search_works');
+  assert.equal(qwen.content, '');
+});
+
+test('normalizer keeps reasoning separate from Qwen think content', () => {
+  const result = normalizeAssistantMessage({
+    role: 'assistant',
+    content: '<think>internal plan</think>Final answer'
+  });
+  assert.equal(result.reasoning_content, 'internal plan');
+  assert.equal(result.content, 'Final answer');
+});
+
+test('stream content normalizer handles split think tags and flushes final content', () => {
+  const normalizer = new StreamContentNormalizer();
+  assert.deepEqual(normalizer.push('Before <th'), { answer: 'Before ', reasoning: '' });
+  assert.deepEqual(normalizer.push('ink>hidden</think>After'), { answer: 'After', reasoning: 'hidden' });
+  assert.deepEqual(normalizer.flush(), { answer: '', reasoning: '' });
+});
+
+test('LLMClient applies Qwen3 thinking request options only when requested', async () => {
+  const client = new LLMClient({ provider: 'vllm', model: 'Qwen/Qwen3-8B', baseUrl: 'http://127.0.0.1:8000/v1' });
+  const originalFetch = globalThis.fetch;
+  let request;
+  globalThis.fetch = async (url, options) => {
+    request = JSON.parse(options.body);
+    return new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: 'ok' } }] }), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  };
+  try {
+    await client.chat([{ role: 'user', content: 'hello' }], { stream: false, thinkingMode: 'hide' });
+    assert.deepEqual(request.chat_template_kwargs, { enable_thinking: false });
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('LLMClient flushes a final SSE event without a trailing newline', async () => {
+  const client = new LLMClient({ provider: 'vllm', model: 'Qwen/Qwen2.5-7B-Instruct', baseUrl: 'http://127.0.0.1:8000/v1' });
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => {
+    const body = `data: ${JSON.stringify({ choices: [{ delta: { content: 'final' } }] })}`;
+    const stream = new ReadableStream({ start(controller) { controller.enqueue(new TextEncoder().encode(body)); controller.close(); } });
+    return new Response(stream, { status: 200, headers: { 'Content-Type': 'text/event-stream' } });
+  };
+  try {
+    const result = await client.chat([{ role: 'user', content: 'hello' }], { stream: true });
+    assert.equal(result.content, 'final');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('normalizer converts Meta Llama 3.1+ Pythonic tool calls', () => {
+  const llama = normalizeAssistantMessage({
+    role: 'assistant',
+    content: '<|python_tag|>search_works(query="In Blossom", limit=5, verified=true)'
+  });
+  assert.equal(llama.tool_calls.length, 1);
+  assert.equal(llama.tool_calls[0].function.name, 'search_works');
+  const args = JSON.parse(llama.tool_calls[0].function.arguments);
+  assert.equal(args.query, 'In Blossom');
+  assert.equal(args.limit, 5);
+  assert.equal(args.verified, true);
+  assert.equal(llama.content, '');
+});
+
+test('stream content normalizer suppresses tool tags from answer stream and buffers them', () => {
+  const normalizer = new StreamContentNormalizer();
+  const chunk1 = normalizer.push('Answer before <tool_');
+  assert.equal(chunk1.answer, 'Answer before ');
+
+  const chunk2 = normalizer.push('call>{"name":"search_works","arguments":{"query":"In Blossom"}}</tool_call> answer after');
+  assert.equal(chunk2.answer, ' answer after');
+  assert.equal(chunk2.reasoning, '');
+
+  const flushed = normalizer.flush();
+  assert.ok(flushed.toolCallBuffer.includes('search_works'));
+});
+
+test('toAnthropicMessages preserves extended thinking blocks and groups parallel tool results', async () => {
+  const { toAnthropicMessages, normalizeAnthropicResponse } = await import('../cloudAdapters.js');
+  
+  const normalized = normalizeAnthropicResponse({
+    content: [
+      { type: 'thinking', thinking: 'internal thought plan', signature: 'sig_abc123' },
+      { type: 'text', text: 'Calling tool now' },
+      { type: 'tool_use', id: 'toolu_1', name: 'search_works', input: { query: 'Ju Jingyi' } }
+    ]
+  });
+  assert.equal(normalized.thinking_blocks.length, 1);
+  assert.equal(normalized.thinking_blocks[0].signature, 'sig_abc123');
+
+  const history = [
+    { role: 'user', content: 'Who is Ju Jingyi?' },
+    normalized,
+    { role: 'tool', tool_call_id: 'toolu_1', content: JSON.stringify({ status: 'success', name: 'Ju Jingyi' }) },
+    { role: 'tool', tool_call_id: 'toolu_2', content: JSON.stringify({ status: 'error', error: 'not found' }) }
+  ];
+
+  const anthropic = toAnthropicMessages(history);
+ 
+  const asstMsg = anthropic.messages.find(m => m.role === 'assistant');
+  assert.ok(asstMsg);
+  assert.equal(asstMsg.content[0].type, 'thinking');
+  assert.equal(asstMsg.content[0].signature, 'sig_abc123');
+  assert.equal(asstMsg.content[1].type, 'text');
+  assert.equal(asstMsg.content[2].type, 'tool_use');
+
+ 
+  const userToolMsg = anthropic.messages[anthropic.messages.length - 1];
+  assert.equal(userToolMsg.role, 'user');
+  assert.equal(userToolMsg.content.length, 2);
+  assert.equal(userToolMsg.content[0].tool_use_id, 'toolu_1');
+  assert.equal(userToolMsg.content[0].is_error, undefined);
+  assert.equal(userToolMsg.content[1].tool_use_id, 'toolu_2');
+  assert.equal(userToolMsg.content[1].is_error, true);
+});
+

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

@@ -28,6 +28,14 @@ test('model manager selects a chat fallback when the requested model is missing'
   assert.equal(client.model, 'google/gemma-4-e4b');
 });
 
+test('model manager fails closed for an explicitly requested unavailable model', async () => {
+  const client = clientWith(['google/gemma-4-e4b']);
+  const result = await new ModelManager(client, { requestedModel: 'Qwen/Qwen3-8B', strictModel: true }).resolve();
+  assert.equal(result.state, 'requested_model_missing');
+  assert.equal(result.selectedModel, null);
+  assert.equal(client.model, 'requested/model');
+});
+
 test('model manager prefers the provider recommendation over an arbitrary catalog model', async () => {
   const client = clientWith(['random/chat-model', 'gpt-5.6-luna']);
   client.provider = 'openai';
@@ -107,3 +115,27 @@ test('model manager allows selecting shorthand quantizations like Q8_0, q8, Q6_K
   assert.equal(selectedQ4, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q4_K_M.gguf');
 });
 
+test('model manager reports server_online_model_not_loaded when LM Studio has models on disk but none in VRAM', async () => {
+  const client = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    async checkConnection() {
+      return {
+        connected: true,
+        models: ['google/gemma-4-e4b'],
+        activeLoadedModel: null,
+        loadedModels: []
+      };
+    }
+  };
+
+  const manager = new ModelManager(client);
+  const result = await manager.resolve();
+  assert.equal(result.connected, true);
+  assert.equal(result.state, 'server_online_model_not_loaded');
+  assert.equal(result.isModelLoaded, false);
+  assert.equal(result.activeLoadedModel, null);
+  assert.equal(result.selectedModel, 'google/gemma-4-e4b');
+});
+
+

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

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { Readable } from 'node:stream';
+import { collectMusicControlActions, createMusicControlAction } from '../../web-chat/core/musicControlAction.js';
+import { handleChatRoute } from '../../web-chat/routes/chatRoute.js';
+import { getWebChatHtml } from '../../webChatHtml.js';
+
+function request(body) {
+  const req = Readable.from([JSON.stringify(body)]);
+  req.socket = { remoteAddress: '127.0.0.1' };
+  req.headers = {};
+  return req;
+}
+
+function response() {
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = (code) => { res.statusCode = code; res.headersSent = true; };
+  res.write = (data) => { res.chunks += data; };
+  res.end = (data = '') => { res.chunks += data; res.writableEnded = true; res.emit('finish'); };
+  return res;
+}
+
+function musicAgent(toolName, result) {
+  return {
+    session: { id: 'music-test', messages: [] },
+    memory: { getStatus: () => ({}) },
+    run: async (_query, options) => {
+      options.onToolStart(toolName, {});
+      options.onToolResult(toolName, result, 3);
+      options.onTokenDelta?.('done');
+      return { answer: 'done' };
+    },
+  };
+}
+
+test('music tool results normalize to a bounded dedicated UI action', () => {
+  const event = createMusicControlAction('play_music', {
+    status: 'success',
+    action: 'pause',
+    playing: 'Heartbeat Alert',
+    song: { title: '恋爱告急', youtubeId: '5MLPdCmnlmE', extra: 'not-forwarded' },
+  });
+
+  assert.deepEqual(event, {
+    type: 'ui_action',
+    target: 'music_player',
+    tool: 'play_music',
+    action: 'play',
+    playing: 'Heartbeat Alert',
+    song: {
+      id: undefined,
+      title: '恋爱告急',
+      titleTh: undefined,
+      titleCn: undefined,
+      titleEn: undefined,
+      youtubeId: '5MLPdCmnlmE',
+      duration: undefined,
+      category: undefined,
+      dramaName: undefined,
+    },
+  });
+  assert.equal(createMusicControlAction('search_discography', { status: 'success' }), null);
+  assert.deepEqual(createMusicControlAction('pause_music', { status: 'error' }), {
+    type: 'ui_action',
+    target: 'music_player',
+    tool: 'pause_music',
+    action: 'pause',
+  });
+  assert.equal(collectMusicControlActions([
+    { name: 'set_volume', result: { status: 'success', volume: 140 } },
+    { name: 'seek_music', result: { status: 'success', seconds: -5 } },
+  ]).length, 2);
+});
+
+test('streaming chat emits music UI actions independently from tool inspector events', async () => {
+  const res = response();
+  await handleChatRoute(request({ query: 'pause music', provider: 'lmstudio', stream: true }), res, null, {
+    resolveConnection: async () => ({
+      ready: true,
+      agent: musicAgent('pause_music', { status: 'success', action: 'pause', message: 'paused' }),
+    }),
+  });
+
+  const events = res.chunks
+    .split('\n')
+    .filter((line) => line.startsWith('data: {'))
+    .map((line) => JSON.parse(line.slice(6)));
+  assert.ok(events.some((event) => event.type === 'tool_result' && event.name === 'pause_music'));
+  assert.ok(events.some((event) => event.type === 'ui_action' && event.target === 'music_player' && event.action === 'pause'));
+});
+
+test('non-streaming chat returns music UI actions and both client stream paths consume them', async () => {
+  const res = response();
+  await handleChatRoute(request({ query: 'volume 60', provider: 'lmstudio', stream: false }), res, null, {
+    resolveConnection: async () => ({
+      ready: true,
+      agent: musicAgent('set_volume', { status: 'success', action: 'set_volume', volume: 60 }),
+    }),
+  });
+
+  const body = JSON.parse(res.chunks);
+  assert.equal(body.uiActions[0].action, 'set_volume');
+  assert.equal(body.uiActions[0].volume, 60);
+
+  const html = getWebChatHtml();
+  assert.equal((html.match(/event\.type === 'ui_action' && event\.target === 'music_player'/g) || []).length, 2);
+  assert.equal((html.match(/const uiActions = Array\.isArray\(data\.uiActions\)/g) || []).length, 2);
+  assert.match(html, /miniPlayerState\.isPlaying = false;\s*sendMiniPlayerCommand\('pauseVideo'\)/);
+  assert.match(html, /miniPlayerState\.volume = vol;\s*miniPlayerState\.isMuted = vol === 0;/);
+  assert.match(html, /sendMiniPlayerCommand\(vol === 0 \? 'mute' : 'unMute'\)/);
+});

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

@@ -40,8 +40,10 @@ test('ContextCompactor calculates tokens and summarizes history without losing s
   const compacted = compactor.compact(messages, { maxTokens: 20, keepRecentMessages: 2 });
   assert.equal(compacted[0].role, 'system');
   assert.equal(compacted[0].content, 'You are Kiku AI.');
-  assert.equal(compacted[compacted.length - 1].content, 'What is her latest drama in 2026?');
-  assert.ok(compacted.some(m => m.content.includes('[CONVERSATION CONTEXT SUMMARY')));
+  assert.match(compacted[compacted.length - 1].content, /Previous Session Context Summary/);
+  assert.match(compacted[compacted.length - 1].content, /What is her latest drama in 2026\?/);
+  assert.equal(compacted.filter(message => message.role === 'system').length, 1);
+  assert.ok(compacted.some(m => typeof m.content === 'string' && m.content.includes('[Previous Session Context Summary')));
 });
 
 test('AgentMemory scores fact relevance and applies recency weighting', () => {