@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/agent/chat-mode.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import { getChatTools, knowledgeBaseTools, WRITE_TOOLS } from '@/lib/agent/tools';
+import { CHAT_SYSTEM_PROMPT, AGENT_SYSTEM_PROMPT } from '@/lib/agent/prompt';
+
+// ---------------------------------------------------------------------------
+// getChatTools — tool set correctness
+// ---------------------------------------------------------------------------
+
+describe('getChatTools', () => {
+  const chatTools = getChatTools();
+  const chatToolNames = chatTools.map(t => t.name);
+
+  it('returns a non-empty array of tools', () => {
+    expect(chatTools.length).toBeGreaterThan(0);
+  });
+
+  it('returns exactly the 8 approved read-only tools', () => {
+    const expected = [
+      'list_files', 'read_file', 'read_file_chunk',
+      'search', 'get_recent', 'get_backlinks',
+      'web_search', 'web_fetch',
+    ];
+    expect(new Set(chatToolNames)).toEqual(new Set(expected));
+  });
+
+  it('is a strict subset of knowledgeBaseTools', () => {
+    const allNames = new Set(knowledgeBaseTools.map(t => t.name));
+    for (const name of chatToolNames) {
+      expect(allNames.has(name)).toBe(true);
+    }
+  });
+
+  it('contains zero write tools', () => {
+    for (const name of chatToolNames) {
+      expect(WRITE_TOOLS.has(name)).toBe(false);
+    }
+  });
+
+  it('is significantly smaller than full tool set', () => {
+    expect(chatTools.length).toBeLessThan(knowledgeBaseTools.length);
+  });
+
+  it('each tool has a valid execute function', () => {
+    for (const tool of chatTools) {
+      expect(typeof tool.execute).toBe('function');
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CHAT_SYSTEM_PROMPT — content correctness
+// ---------------------------------------------------------------------------
+
+describe('CHAT_SYSTEM_PROMPT', () => {
+  it('exists and is a non-empty string', () => {
+    expect(typeof CHAT_SYSTEM_PROMPT).toBe('string');
+    expect(CHAT_SYSTEM_PROMPT.length).toBeGreaterThan(100);
+  });
+
+  it('mentions Chat (Read-Only) mode', () => {
+    expect(CHAT_SYSTEM_PROMPT).toContain('Chat');
+    expect(CHAT_SYSTEM_PROMPT).toContain('Read-Only');
+  });
+
+  it('contains anti-hallucination directive', () => {
+    expect(CHAT_SYSTEM_PROMPT).toContain('Anti-Hallucination');
+  });
+
+  it('contains cite-sources directive', () => {
+    expect(CHAT_SYSTEM_PROMPT).toContain('Cite Sources');
+  });
+
+  it('instructs to suggest switching to Agent mode for writes', () => {
+    expect(CHAT_SYSTEM_PROMPT).toContain('Agent mode');
+  });
+
+  it('is significantly shorter than AGENT_SYSTEM_PROMPT', () => {
+    expect(CHAT_SYSTEM_PROMPT.length).toBeLessThan(AGENT_SYSTEM_PROMPT.length);
+  });
+
+  it('does not contain write-related directives', () => {
+    expect(CHAT_SYSTEM_PROMPT).not.toContain('Read-Before-Write');
+    expect(CHAT_SYSTEM_PROMPT).not.toContain('write_file');
+    expect(CHAT_SYSTEM_PROMPT).not.toContain('create_file');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// AskMode type — compile-time type check
+// ---------------------------------------------------------------------------
+
+describe('AskMode type', () => {
+  it('accepts valid mode values', async () => {
+    const { AskMode } = await import('@/lib/types') as any;
+    const validModes: Array<import('@/lib/types').AskMode> = ['chat', 'agent'];
+    expect(validModes).toHaveLength(2);
+  });
+
+  it('AskModeApi includes organize', async () => {
+    const validModes: Array<import('@/lib/types').AskModeApi> = ['chat', 'agent', 'organize'];
+    expect(validModes).toHaveLength(3);
+  });
+});

package/_standalone/__tests__/agent/loop-detection.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { detectLoop, type StepEntry } from '@/lib/agent/loop-detection';
+
+function step(tool: string, input = ''): StepEntry {
+  return { tool, input };
+}
+
+describe('detectLoop', () => {
+  describe('identical repetition', () => {
+    it('detects 3 identical calls in a row', () => {
+      const history = [step('readFile', 'a.md'), step('readFile', 'a.md'), step('readFile', 'a.md')];
+      expect(detectLoop(history)).toBe(true);
+    });
+
+    it('does not trigger with only 2 identical calls', () => {
+      const history = [step('readFile', 'a.md'), step('readFile', 'a.md')];
+      expect(detectLoop(history)).toBe(false);
+    });
+
+    it('does not trigger with different args', () => {
+      const history = [step('readFile', 'a.md'), step('readFile', 'b.md'), step('readFile', 'c.md')];
+      expect(detectLoop(history)).toBe(false);
+    });
+  });
+
+  describe('pattern cycle detection', () => {
+    it('detects A→B→A→B cycle', () => {
+      const history = [step('readFile'), step('writeFile'), step('readFile'), step('writeFile')];
+      expect(detectLoop(history)).toBe(true);
+    });
+
+    it('detects A→B→C→A→B→C cycle', () => {
+      const history = [
+        step('read'), step('search'), step('write'),
+        step('read'), step('search'), step('write'),
+      ];
+      expect(detectLoop(history)).toBe(true);
+    });
+
+    it('does not trigger for non-repeating sequence', () => {
+      const history = [step('read'), step('search'), step('write'), step('commit')];
+      expect(detectLoop(history)).toBe(false);
+    });
+
+    it('detects cycle even with earlier non-repeating history', () => {
+      const history = [
+        step('init'), step('config'), // noise
+        step('read'), step('write'), step('read'), step('write'), // cycle
+      ];
+      expect(detectLoop(history)).toBe(true);
+    });
+
+    it('does not false-positive on same tool names with all different args', () => {
+      // Agent reads different files in alternation — not a loop
+      const history = [
+        step('readFile', 'a.md'), step('writeFile', 'x.md'),
+        step('readFile', 'b.md'), step('writeFile', 'y.md'),
+      ];
+      expect(detectLoop(history)).toBe(false);
+    });
+
+    it('detects cycle when at least one arg pair matches', () => {
+      // read same file, write to different targets — still a loop
+      const history = [
+        step('readFile', 'a.md'), step('writeFile', 'x.md'),
+        step('readFile', 'a.md'), step('writeFile', 'z.md'),
+      ];
+      expect(detectLoop(history)).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns false for empty history', () => {
+      expect(detectLoop([])).toBe(false);
+    });
+
+    it('returns false for single entry', () => {
+      expect(detectLoop([step('read')])).toBe(false);
+    });
+
+    it('returns false for short non-repeating history', () => {
+      expect(detectLoop([step('a'), step('b'), step('c')])).toBe(false);
+    });
+  });
+});

package/_standalone/__tests__/agent/paragraph-extract.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { extractRelevantContent, splitParagraphs } from '@/lib/agent/paragraph-extract';
+
+describe('splitParagraphs', () => {
+  it('splits on double newlines', () => {
+    const text = 'Paragraph 1\n\nParagraph 2\n\nParagraph 3';
+    expect(splitParagraphs(text)).toEqual(['Paragraph 1', 'Paragraph 2', 'Paragraph 3']);
+  });
+
+  it('handles empty string', () => {
+    expect(splitParagraphs('')).toEqual([]);
+  });
+
+  it('handles single paragraph', () => {
+    expect(splitParagraphs('Hello world')).toEqual(['Hello world']);
+  });
+});
+
+describe('extractRelevantContent', () => {
+  it('returns content unchanged if within limit', () => {
+    const content = 'Short content';
+    const { result, truncated } = extractRelevantContent(content, 1000);
+    expect(result).toBe(content);
+    expect(truncated).toBe(false);
+  });
+
+  it('truncates at paragraph boundary without query', () => {
+    const content = 'A'.repeat(100) + '\n\n' + 'B'.repeat(100);
+    const { result, truncated } = extractRelevantContent(content, 150);
+    expect(truncated).toBe(true);
+    expect(result).toContain('A'.repeat(100));
+    expect(result).not.toContain('B'.repeat(100));
+  });
+
+  it('extracts query-relevant paragraphs', () => {
+    const paragraphs = [
+      '# Title\n\nThis is the intro.',
+      'Paragraph about cats and dogs.',
+      'Paragraph about deployment and servers.',
+      'Another paragraph about cats playing.',
+      'Final paragraph about nothing.',
+    ];
+    const content = paragraphs.join('\n\n');
+    const { result } = extractRelevantContent(content, 200, 'cats');
+    // Should include title (always) + cat paragraphs
+    expect(result).toContain('Title');
+    expect(result).toContain('cats');
+  });
+
+  it('preserves original order of extracted paragraphs', () => {
+    const content = 'P1 intro\n\nP2 query match\n\nP3 filler\n\nP4 query match again';
+    const { result } = extractRelevantContent(content, 100, 'query');
+    const idx1 = result.indexOf('P1');
+    const idx2 = result.indexOf('P2');
+    if (idx1 !== -1 && idx2 !== -1) {
+      expect(idx1).toBeLessThan(idx2);
+    }
+  });
+
+  it('handles very long content with CJK query', () => {
+    const intro = '# 知识管理系统';
+    const filler = Array.from({ length: 50 }, (_, i) => `段落 ${i}: 一些无关的内容。`).join('\n\n');
+    const target = '这是关于部署的重要段落。包含了服务器配置信息。';
+    const content = intro + '\n\n' + filler + '\n\n' + target;
+    const { result, truncated } = extractRelevantContent(content, 500, '部署');
+    expect(truncated).toBe(true);
+    expect(result).toContain('部署');
+    expect(result).toContain('知识管理');
+  });
+
+  it('returns truncated flag when paragraphs are dropped', () => {
+    const content = 'Short\n\n' + 'X'.repeat(200);
+    const { truncated } = extractRelevantContent(content, 50, 'Short');
+    expect(truncated).toBe(true);
+  });
+});

package/_standalone/__tests__/agent/prompt.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { AGENT_SYSTEM_PROMPT, CHAT_SYSTEM_PROMPT } from '@/lib/agent/prompt';
+
+describe('agent prompt self-introduction rules', () => {
+  it('uses the MindOS identity without slogan wording in agent mode', () => {
+    expect(AGENT_SYSTEM_PROMPT).toContain('You are MindOS — the user\'s local knowledge assistant.');
+    expect(AGENT_SYSTEM_PROMPT).not.toContain('this appears to be their first message in a new conversation');
+    expect(AGENT_SYSTEM_PROMPT).not.toContain('operator of the user\'s second brain');
+    expect(AGENT_SYSTEM_PROMPT).not.toContain('You are MindOS Agent');
+    expect(AGENT_SYSTEM_PROMPT).toContain('If the user\'s message already contains a concrete task');
+    expect(AGENT_SYSTEM_PROMPT).toContain('skip the self-introduction and do the task directly');
+  });
+
+  it('applies the same concrete-task rule and identity in chat mode', () => {
+    expect(CHAT_SYSTEM_PROMPT).toContain('You are MindOS — the user\'s local knowledge assistant.');
+    expect(CHAT_SYSTEM_PROMPT).not.toContain('operator of the user\'s second brain');
+    expect(CHAT_SYSTEM_PROMPT).not.toContain('You are MindOS Agent');
+    expect(CHAT_SYSTEM_PROMPT).toContain('If the same message also includes a concrete task');
+    expect(CHAT_SYSTEM_PROMPT).toContain('skip the introduction and do the task');
+  });
+});

package/_standalone/__tests__/agent/provider-endpoints.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import { buildCompatEndpointCandidates, getProviderApiType } from '@/lib/agent/providers';
+
+
+describe('buildCompatEndpointCandidates', () => {
+  it('keeps OpenAI-compatible custom path and adds v1 fallback', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://proxy.example.com/custom',
+      '/chat/completions',
+      'openai-completions',
+    );
+
+    expect(endpoints).toEqual([
+      'https://proxy.example.com/custom/chat/completions',
+      'https://proxy.example.com/custom/v1/chat/completions',
+    ]);
+  });
+
+  it('keeps existing version prefix without adding another v1', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://api.openai.com/v1',
+      '/chat/completions',
+      'openai-completions',
+    );
+
+    expect(endpoints).toEqual([
+      'https://api.openai.com/v1/chat/completions',
+    ]);
+  });
+
+  it('preserves GLM path prefix without injecting an extra v1 after /v4', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://api.z.ai/api/coding/paas/v4',
+      '/models',
+      'openai-completions',
+    );
+
+    expect(endpoints).toEqual([
+      'https://api.z.ai/api/coding/paas/v4/models',
+    ]);
+  });
+
+  it('preserves Anthropic-compatible path prefixes for Kimi/MiniMax style gateways', () => {
+    const endpoints = buildCompatEndpointCandidates(
+      'https://api.kimi.com/coding',
+      '/models',
+      'anthropic-messages',
+    );
+
+    expect(endpoints).toEqual([
+      'https://api.kimi.com/coding/models',
+      'https://api.kimi.com/coding/v1/models',
+    ]);
+  });
+});
+
+
+describe('getProviderApiType', () => {
+  it('reports GLM as openai-completions', () => {
+    expect(getProviderApiType('zai')).toBe('openai-completions');
+  });
+
+  it('reports MiniMax CN as anthropic-messages', () => {
+    expect(getProviderApiType('minimax-cn')).toBe('anthropic-messages');
+  });
+
+  it('reports Kimi Coding as anthropic-messages', () => {
+    expect(getProviderApiType('kimi-coding')).toBe('anthropic-messages');
+  });
+});

package/_standalone/__tests__/agent/provider-presets.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { PROVIDER_PRESETS, getDefaultBaseUrl, groupedProviders } from '@/lib/agent/providers';
+
+
+describe('provider presets', () => {
+  it('includes LM Studio as an explicit local preset', () => {
+    const preset = PROVIDER_PRESETS['lm-studio'];
+    expect(preset.name).toBe('LM Studio');
+    expect(preset.fixedBaseUrl).toBe('http://localhost:1234/v1');
+    expect(preset.apiKeyFallback).toBe('lm-studio');
+    expect(preset.supportsListModels).toBe(true);
+  });
+
+  it('resolves LM Studio default base URL from its fixed preset URL', () => {
+    expect(getDefaultBaseUrl('lm-studio')).toBe('http://localhost:1234/v1');
+  });
+
+  it('includes vLLM as an explicit local preset', () => {
+    const preset = PROVIDER_PRESETS.vllm;
+    expect(preset.name).toBe('vLLM');
+    expect(preset.fixedBaseUrl).toBe('http://localhost:8000/v1');
+    expect(preset.apiKeyFallback).toBe('vllm');
+    expect(preset.supportsListModels).toBe(true);
+  });
+
+  it('groups Ollama, LM Studio, and vLLM under local providers', () => {
+    const groups = groupedProviders();
+    expect(groups.local).toContain('ollama');
+    expect(groups.local).toContain('lm-studio');
+    expect(groups.local).toContain('vllm');
+  });
+});

package/_standalone/__tests__/agent/retry-reconnect.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import { isRetryableError, retryDelay, sleep } from '@/lib/agent/reconnect';
+
+// ── isRetryableError ──────────────────────────────────────────────────────────
+
+describe('isRetryableError', () => {
+  describe('non-retryable: AbortError', () => {
+    it('returns false for DOMException AbortError', () => {
+      const err = new DOMException('The user aborted the request.', 'AbortError');
+      expect(isRetryableError(err)).toBe(false);
+    });
+  });
+
+  describe('non-retryable: auth / forbidden HTTP status', () => {
+    it('returns false for HTTP 401', () => {
+      expect(isRetryableError(new Error('Unauthorized'), 401)).toBe(false);
+    });
+
+    it('returns false for HTTP 403', () => {
+      expect(isRetryableError(new Error('Forbidden'), 403)).toBe(false);
+    });
+
+    it('returns false for error message containing "api key"', () => {
+      expect(isRetryableError(new Error('Invalid api key provided'))).toBe(false);
+    });
+
+    it('returns false for error message containing "authentication"', () => {
+      expect(isRetryableError(new Error('Authentication failed'))).toBe(false);
+    });
+
+    it('returns false for "model not found" errors', () => {
+      expect(isRetryableError(new Error('The model gpt-99 was not found'))).toBe(false);
+    });
+  });
+
+  describe('retryable: transient network / server errors', () => {
+    it('returns true for generic network error (no httpStatus)', () => {
+      expect(isRetryableError(new Error('fetch failed'))).toBe(true);
+    });
+
+    it('returns true for HTTP 500', () => {
+      expect(isRetryableError(new Error('Internal Server Error'), 500)).toBe(true);
+    });
+
+    it('returns true for HTTP 503', () => {
+      expect(isRetryableError(new Error('Service Unavailable'), 503)).toBe(true);
+    });
+
+    it('returns true for connection reset', () => {
+      expect(isRetryableError(new Error('ECONNRESET'))).toBe(true);
+    });
+  });
+
+  describe('retryable: rate limit (429)', () => {
+    it('returns false for HTTP 429 (rate limit — caller handles this specially)', () => {
+      // reconnect.ts lists 429 as NON_RETRYABLE_STATUS.
+      // The frontend retry loop decides not to retry 429 at HTTP level;
+      // the backend should handle 429 via its own LLM-layer retry.
+      expect(isRetryableError(new Error('Too Many Requests'), 429)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns true for non-Error values (unknown errors)', () => {
+      expect(isRetryableError('some string error')).toBe(true);
+      expect(isRetryableError(null)).toBe(true);
+      expect(isRetryableError(undefined)).toBe(true);
+    });
+  });
+});
+
+// ── retryDelay ────────────────────────────────────────────────────────────────
+
+describe('retryDelay', () => {
+  it('returns 2000ms for attempt 1 (first retry)', () => {
+    expect(retryDelay(1)).toBe(2000);
+  });
+
+  it('returns 4000ms for attempt 2', () => {
+    expect(retryDelay(2)).toBe(4000);
+  });
+
+  it('returns 8000ms for attempt 3', () => {
+    expect(retryDelay(3)).toBe(8000);
+  });
+
+  it('caps at 10000ms regardless of attempt number', () => {
+    expect(retryDelay(10)).toBe(10000);
+    expect(retryDelay(100)).toBe(10000);
+  });
+
+  it('returns 1000ms for attempt 0 (base case)', () => {
+    expect(retryDelay(0)).toBe(1000);
+  });
+});
+
+// ── sleep ─────────────────────────────────────────────────────────────────────
+
+describe('sleep', () => {
+  it('resolves after specified delay', async () => {
+    const start = Date.now();
+    await sleep(50);
+    expect(Date.now() - start).toBeGreaterThanOrEqual(40);
+  });
+
+  it('rejects immediately when signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    await expect(sleep(1000, controller.signal)).rejects.toThrow();
+  });
+
+  it('rejects early when signal is aborted during sleep', async () => {
+    const controller = new AbortController();
+    const start = Date.now();
+    setTimeout(() => controller.abort(), 30);
+    await expect(sleep(2000, controller.signal)).rejects.toThrow();
+    // Should abort well before the full 2000ms
+    expect(Date.now() - start).toBeLessThan(500);
+  });
+});

package/_standalone/__tests__/agent/stream-consumer-status.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Tests for consumeUIMessageStream handling of 'status' SSE events.
+ *
+ * Status events are sent by the backend during retry attempts to inform
+ * the frontend about the retry state. Previously, these were silently
+ * ignored. After the fix, they should surface as text in the message.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { consumeUIMessageStream } from '@/lib/agent/stream-consumer';
+import type { ToolCallPart } from '@/lib/types';
+
+/** Helper: encode SSE events into a ReadableStream */
+function makeStream(...events: object[]): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      for (const evt of events) {
+        controller.enqueue(encoder.encode(`data:${JSON.stringify(evt)}\n\n`));
+      }
+      controller.close();
+    },
+  });
+}
+
+describe('consumeUIMessageStream — status event handling', () => {
+  it('ignores status events when no text has been emitted yet (silent reconnect)', async () => {
+    // Status-only stream (no text_delta, no done) — after the fix,
+    // status events should NOT appear as visible text in the message
+    // because they are transient UI state, not conversation content.
+    // The frontend AskContent handles reconnect UI via loadingPhase state.
+    const stream = makeStream(
+      { type: 'status', message: 'Request failed, retrying (1/3)...' },
+      { type: 'done' },
+    );
+    const updates: string[] = [];
+    const result = await consumeUIMessageStream(stream, (msg) => {
+      updates.push(msg.content);
+    });
+    // Status messages should NOT appear in the conversation content
+    expect(result.content).toBe('');
+    expect(result.parts).toEqual([]);
+  });
+
+  it('processes text_delta events normally', async () => {
+    const stream = makeStream(
+      { type: 'text_delta', delta: 'Hello, ' },
+      { type: 'text_delta', delta: 'world!' },
+      { type: 'done' },
+    );
+    const result = await consumeUIMessageStream(stream, vi.fn());
+    expect(result.content).toBe('Hello, world!');
+  });
+
+  it('handles stream with status event followed by successful text', async () => {
+    const stream = makeStream(
+      { type: 'status', message: 'Request failed, retrying (1/3)...' },
+      { type: 'text_delta', delta: 'Response after retry' },
+      { type: 'done' },
+    );
+    const result = await consumeUIMessageStream(stream, vi.fn());
+    // Status should not appear, only the actual response text
+    expect(result.content).toBe('Response after retry');
+  });
+
+  it('handles error event by adding error text to message', async () => {
+    const stream = makeStream(
+      { type: 'error', message: 'LLM API unavailable' },
+    );
+    const result = await consumeUIMessageStream(stream, vi.fn());
+    expect(result.content).toContain('LLM API unavailable');
+  });
+
+  it('handles malformed SSE lines gracefully', async () => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode('data:{bad json}\n\n'));
+        controller.enqueue(encoder.encode(`data:${JSON.stringify({ type: 'text_delta', delta: 'ok' })}\n\n`));
+        controller.enqueue(encoder.encode(`data:${JSON.stringify({ type: 'done' })}\n\n`));
+        controller.close();
+      },
+    });
+    const result = await consumeUIMessageStream(stream, vi.fn());
+    expect(result.content).toBe('ok');
+  });
+
+  it('finalizes pending tool calls when stream ends unexpectedly', async () => {
+    const stream = makeStream(
+      { type: 'tool_start', toolCallId: 'tc1', toolName: 'read_file', args: { path: 'a.md' } },
+      // stream ends without tool_end or done
+    );
+    const updates: Array<{ parts?: unknown[] }> = [];
+    const result = await consumeUIMessageStream(stream, (msg) => { updates.push(msg as { parts?: unknown[] }); });
+    // After unexpected stream end, the tool call part should be finalized to 'error' state.
+    // Check both the last onUpdate emission and the final returned message.
+    const allParts = [
+      ...(updates[updates.length - 1]?.parts ?? []),
+      ...(result.parts ?? []),
+    ];
+    const toolPart = allParts.find((p): p is ToolCallPart => (p as ToolCallPart).type === 'tool-call');
+    expect(toolPart?.state).toBe('error');
+  });
+});

package/_standalone/__tests__/agent/token-estimation.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { estimateStringTokens } from '@/lib/agent/context';
+
+describe('estimateStringTokens', () => {
+  it('estimates pure ASCII at ~4 chars per token', () => {
+    const text = 'Hello world, this is a test sentence.';
+    const tokens = estimateStringTokens(text);
+    // 37 chars / 4 = 9.25 → ceil = 10 tokens
+    expect(tokens).toBe(10);
+  });
+
+  it('estimates pure CJK at ~1.5 tokens per char', () => {
+    const text = '知识管理系统';
+    const tokens = estimateStringTokens(text);
+    // 6 CJK chars * 1.5 = 9 tokens
+    expect(tokens).toBe(9);
+  });
+
+  it('handles mixed CJK and ASCII correctly', () => {
+    const text = 'MindOS 知识管理';
+    const tokens = estimateStringTokens(text);
+    // "MindOS " = 7 ASCII chars → 7/4 = 1.75
+    // "知识管理" = 4 CJK chars → 4 * 1.5 = 6
+    // total = ceil(1.75 + 6) = 8
+    expect(tokens).toBe(8);
+  });
+
+  it('returns 0 for empty string', () => {
+    expect(estimateStringTokens('')).toBe(0);
+  });
+
+  it('estimates Japanese Hiragana as CJK', () => {
+    const text = 'こんにちは';
+    const tokens = estimateStringTokens(text);
+    // 5 chars * 1.5 = 7.5 → ceil = 8
+    expect(tokens).toBe(8);
+  });
+
+  it('estimates Korean Hangul as CJK', () => {
+    const text = '안녕하세요';
+    const tokens = estimateStringTokens(text);
+    // 5 chars * 1.5 = 7.5 → ceil = 8
+    expect(tokens).toBe(8);
+  });
+
+  it('is more accurate than naive length/4 for Chinese text', () => {
+    const chineseText = '这是一个关于人工智能的知识库管理系统';
+    const accurate = estimateStringTokens(chineseText);
+    const naive = Math.ceil(chineseText.length / 4);
+    // Naive: 17/4 = 5, Accurate: 17*1.5 = 26
+    // Accurate should be much higher for pure CJK
+    expect(accurate).toBeGreaterThan(naive * 3);
+  });
+});