opc-agent 2.0.0 → 2.0.2

package/tests/deepbrain-wire.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BaseAgent } from '../src/core/agent';
+import type { Message } from '../src/core/types';
+
+// Mock LLM provider
+const mockProvider = {
+  chat: vi.fn().mockResolvedValue('Hello from LLM'),
+  chatStream: vi.fn(),
+  listModels: vi.fn(),
+};
+
+vi.mock('../src/providers', () => ({
+  createProvider: () => mockProvider,
+}));
+
+function createAgent(opts?: any) {
+  return new BaseAgent({
+    name: 'test-agent',
+    systemPrompt: 'You are a test agent.',
+    ...opts,
+  });
+}
+
+function createMessage(content: string): Message {
+  return {
+    id: `msg_${Date.now()}`,
+    role: 'user',
+    content,
+    timestamp: Date.now(),
+  };
+}
+
+describe('BaseAgent long-term memory', () => {
+  let agent: BaseAgent;
+  let mockBrain: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    agent = createAgent();
+    mockBrain = {
+      recall: vi.fn().mockResolvedValue([{ content: 'remembered fact' }]),
+      learn: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('setLongTermMemory sets the brain', () => {
+    agent.setLongTermMemory(mockBrain);
+    expect(agent.getLongTermMemory()).toBe(mockBrain);
+  });
+
+  it('setLongTermMemory with config sets autoLearn/autoRecall', () => {
+    agent.setLongTermMemory(mockBrain, { autoLearn: false, autoRecall: true });
+    const config = agent.getLongTermMemoryConfig();
+    expect(config.autoLearn).toBe(false);
+    expect(config.autoRecall).toBe(true);
+  });
+
+  it('handleMessage calls recall before LLM when autoRecall is true', async () => {
+    agent.setLongTermMemory(mockBrain);
+    const callOrder: string[] = [];
+    mockBrain.recall.mockImplementation(async () => {
+      callOrder.push('recall');
+      return [{ content: 'memory' }];
+    });
+    mockProvider.chat.mockImplementation(async () => {
+      callOrder.push('llm');
+      return 'response';
+    });
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    expect(callOrder[0]).toBe('recall');
+    expect(callOrder[1]).toBe('llm');
+    expect(mockBrain.recall).toHaveBeenCalledWith('hello');
+  });
+
+  it('handleMessage calls learn after LLM when autoLearn is true', async () => {
+    agent.setLongTermMemory(mockBrain);
+    const callOrder: string[] = [];
+    mockProvider.chat.mockImplementation(async () => {
+      callOrder.push('llm');
+      return 'response';
+    });
+    mockBrain.learn.mockImplementation(async () => {
+      callOrder.push('learn');
+    });
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    expect(callOrder.indexOf('llm')).toBeLessThan(callOrder.indexOf('learn'));
+    expect(mockBrain.learn).toHaveBeenCalled();
+  });
+
+  it('recall failure does not crash handleMessage', async () => {
+    mockBrain.recall.mockRejectedValue(new Error('DB down'));
+    agent.setLongTermMemory(mockBrain);
+
+    await agent.init();
+    const response = await agent.handleMessage(createMessage('hello'));
+    expect(response.content).toBeDefined();
+  });
+
+  it('learn failure does not crash handleMessage', async () => {
+    mockBrain.learn.mockRejectedValue(new Error('DB down'));
+    agent.setLongTermMemory(mockBrain);
+
+    await agent.init();
+    const response = await agent.handleMessage(createMessage('hello'));
+    expect(response.content).toBeDefined();
+  });
+
+  it('does not recall when autoRecall is false', async () => {
+    agent.setLongTermMemory(mockBrain, { autoRecall: false, autoLearn: true });
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    expect(mockBrain.recall).not.toHaveBeenCalled();
+  });
+
+  it('does not learn when autoLearn is false', async () => {
+    agent.setLongTermMemory(mockBrain, { autoRecall: true, autoLearn: false });
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    expect(mockBrain.learn).not.toHaveBeenCalled();
+  });
+
+  it('injects memory context into LLM prompt', async () => {
+    mockBrain.recall.mockResolvedValue([{ content: 'user likes cats' }]);
+    agent.setLongTermMemory(mockBrain);
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
+    expect(systemPromptArg).toContain('[Relevant memories]');
+    expect(systemPromptArg).toContain('user likes cats');
+  });
+
+  it('handles empty recall array gracefully', async () => {
+    mockBrain.recall.mockResolvedValue([]);
+    agent.setLongTermMemory(mockBrain);
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
+    expect(systemPromptArg).not.toContain('[Relevant memories]');
+  });
+
+  it('handles string recall results', async () => {
+    mockBrain.recall.mockResolvedValue('a single memory string');
+    agent.setLongTermMemory(mockBrain);
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
+    expect(systemPromptArg).toContain('a single memory string');
+  });
+
+  it('learn includes user and assistant content', async () => {
+    mockProvider.chat.mockResolvedValue('I am fine');
+    agent.setLongTermMemory(mockBrain);
+
+    await agent.init();
+    await agent.handleMessage(createMessage('how are you'));
+
+    const learnArg = mockBrain.learn.mock.calls[0][0];
+    expect(learnArg).toContain('User: how are you');
+    expect(learnArg).toContain('Assistant: I am fine');
+  });
+
+  it('no long-term memory means no recall/learn calls', async () => {
+    // No setLongTermMemory called
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    // Should work fine without any brain
+    expect(mockBrain.recall).not.toHaveBeenCalled();
+    expect(mockBrain.learn).not.toHaveBeenCalled();
+  });
+
+  it('getLongTermMemory returns undefined when not set', () => {
+    expect(agent.getLongTermMemory()).toBeUndefined();
+  });
+
+  it('default config has autoLearn and autoRecall true', () => {
+    const config = agent.getLongTermMemoryConfig();
+    expect(config.autoLearn).toBe(true);
+    expect(config.autoRecall).toBe(true);
+  });
+
+  it('recall with compiled_truth format', async () => {
+    mockBrain.recall.mockResolvedValue([{ compiled_truth: 'agent is helpful' }]);
+    agent.setLongTermMemory(mockBrain);
+
+    await agent.init();
+    await agent.handleMessage(createMessage('hello'));
+
+    const systemPromptArg = mockProvider.chat.mock.calls[0][1];
+    expect(systemPromptArg).toContain('agent is helpful');
+  });
+});
+
+describe('OAD LongTerm memory schema', () => {
+  it('accepts deepbrain config with new fields', async () => {
+    const { LongTermMemorySchema } = await import('../src/schema/oad');
+    const result = LongTermMemorySchema.parse({
+      provider: 'deepbrain',
+      collection: 'test',
+      config: {
+        database: './data/brain.db',
+        embeddingProvider: 'ollama',
+        autoLearn: true,
+        autoRecall: true,
+        evolveInterval: 3600000,
+      },
+    });
+    expect(result.provider).toBe('deepbrain');
+    expect(result.config?.database).toBe('./data/brain.db');
+    expect(result.config?.evolveInterval).toBe(3600000);
+  });
+
+  it('accepts minimal config', async () => {
+    const { LongTermMemorySchema } = await import('../src/schema/oad');
+    const result = LongTermMemorySchema.parse({ provider: 'deepbrain' });
+    expect(result.provider).toBe('deepbrain');
+  });
+});

package/tests/doctor.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { getDoctorChecks, runDoctor } from '../src/doctor';
+
+describe('opc doctor', () => {
+  it('runDoctor runs without error', async () => {
+    // Suppress console output
+    const orig = console.log;
+    console.log = () => {};
+    const result = await runDoctor();
+    console.log = orig;
+    expect(result).toHaveProperty('passed');
+    expect(result).toHaveProperty('total');
+    expect(result.total).toBeGreaterThan(0);
+    expect(result.passed).toBeGreaterThanOrEqual(0);
+    expect(result.passed).toBeLessThanOrEqual(result.total);
+  });
+
+  it('Node.js check passes (we are running in Node)', async () => {
+    const checks = getDoctorChecks();
+    const nodeCheck = checks.find(c => c.name === 'Node.js version');
+    expect(nodeCheck).toBeDefined();
+    const result = await nodeCheck!.check();
+    expect(result.ok).toBe(true);
+    expect(result.detail).toMatch(/^v\d+/);
+  });
+
+  it('check result format has ok and detail fields', async () => {
+    const checks = getDoctorChecks();
+    for (const check of checks) {
+      const result = await check.check();
+      expect(typeof result.ok).toBe('boolean');
+      expect(typeof result.detail).toBe('string');
+      if (result.fix !== undefined) {
+        expect(typeof result.fix).toBe('string');
+      }
+    }
+  });
+});

package/tests/eval.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import { AgentEvaluator } from '../src/eval';
+import type { EvalCase, EvalSuite, EvalReport } from '../src/eval';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+
+// Mock agent
+const mockAgent = {
+  chat: async (input: string) => {
+    if (!input) return 'Hello! How can I help?';
+    if (input.includes('capital of France')) return 'The capital of France is Paris.';
+    if (input.includes('Hello')) return 'Hello there! How can I help you?';
+    return `Response to: ${input}`;
+  },
+};
+
+describe('AgentEvaluator', () => {
+  const evaluator = new AgentEvaluator(mockAgent);
+
+  it('should score exact match correctly', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-1',
+      input: 'What is the capital of France?',
+      expectedOutput: 'The capital of France is Paris.',
+    });
+    expect(result.scores.exact_match).toBe(1);
+    expect(result.passed).toBe(true);
+  });
+
+  it('should score exact match failure', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-2',
+      input: 'Hello!',
+      expectedOutput: 'Goodbye!',
+    });
+    expect(result.scores.exact_match).toBe(0);
+    expect(result.passed).toBe(false);
+  });
+
+  it('should score contains correctly', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-3',
+      input: 'What is the capital of France?',
+      expectedContains: ['Paris', 'capital'],
+    });
+    expect(result.scores.contains).toBe(1);
+    expect(result.passed).toBe(true);
+  });
+
+  it('should score partial contains', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-4',
+      input: 'What is the capital of France?',
+      expectedContains: ['Paris', 'London'],
+    });
+    expect(result.scores.contains).toBe(0.5);
+    expect(result.passed).toBe(true); // 0.5 >= 0.5 threshold
+  });
+
+  it('should score not_contains correctly', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-5',
+      input: 'Hello!',
+      expectedNotContains: ['error', 'crash'],
+    });
+    expect(result.scores.not_contains).toBe(1);
+    expect(result.passed).toBe(true);
+  });
+
+  it('should score not_contains failure', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-6',
+      input: 'Hello!',
+      expectedNotContains: ['Hello', 'crash'],
+    });
+    expect(result.scores.not_contains).toBe(0.5);
+  });
+
+  it('should load suite from JSON', () => {
+    const suitePath = path.join(__dirname, '..', 'src', 'eval', 'suites', 'basic.json');
+    const suite = AgentEvaluator.loadSuite(suitePath);
+    expect(suite.name).toBe('basic');
+    expect(suite.cases.length).toBe(10);
+  });
+
+  it('should load all built-in suites', () => {
+    const suites = AgentEvaluator.builtinSuites();
+    expect(suites.length).toBeGreaterThanOrEqual(3);
+    const names = suites.map(s => s.name);
+    expect(names).toContain('basic');
+    expect(names).toContain('safety');
+    expect(names).toContain('memory');
+  });
+
+  it('should have correct case counts for built-in suites', () => {
+    const suites = AgentEvaluator.builtinSuites();
+    const basic = suites.find(s => s.name === 'basic');
+    const safety = suites.find(s => s.name === 'safety');
+    const memory = suites.find(s => s.name === 'memory');
+    expect(basic?.caseCount).toBe(10);
+    expect(safety?.caseCount).toBe(8);
+    expect(memory?.caseCount).toBe(6);
+  });
+
+  it('should compare reports and detect regression', () => {
+    const baseline: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 2, failed: 0, passRate: 1, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+      ],
+    };
+    const current: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 1, failed: 1, passRate: 0.5, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: false },
+      ],
+    };
+    const cmp = AgentEvaluator.compare(baseline, current);
+    expect(cmp.regressed).toContain('b');
+    expect(cmp.delta).toBe(-0.5);
+  });
+
+  it('should compare reports and detect improvement', () => {
+    const baseline: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 1, failed: 1, passRate: 0.5, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: false },
+      ],
+    };
+    const current: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 2, failed: 0, passRate: 1, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+      ],
+    };
+    const cmp = AgentEvaluator.compare(baseline, current);
+    expect(cmp.improved).toContain('b');
+    expect(cmp.delta).toBe(0.5);
+  });
+
+  it('should save and load report', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'eval-'));
+    const reportPath = path.join(tmpDir, 'report.json');
+    const report: EvalReport = {
+      suite: 'test', timestamp: new Date().toISOString(), totalCases: 1, passed: 1, failed: 0, passRate: 1, avgLatency: 5, p95Latency: 5, summary: 'ok',
+      results: [{ caseId: 'x', input: 'hi', output: 'hello', scores: { latency_ms: 5 }, passed: true }],
+    };
+    AgentEvaluator.saveReport(report, reportPath);
+    const loaded = JSON.parse(fs.readFileSync(reportPath, 'utf-8'));
+    expect(loaded.suite).toBe('test');
+    expect(loaded.results.length).toBe(1);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should run evalSuite and produce report', async () => {
+    const suite: EvalSuite = {
+      name: 'mini',
+      cases: [
+        { id: 't1', input: 'Hello!', expectedContains: ['hello', 'hi'] },
+        { id: 't2', input: 'What is the capital of France?', expectedContains: ['Paris'] },
+      ],
+    };
+    const report = await evaluator.evalSuite(suite);
+    expect(report.totalCases).toBe(2);
+    expect(report.passRate).toBeGreaterThanOrEqual(0);
+    expect(report.summary).toContain('mini');
+  });
+});

package/tests/init-role.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { searchRoles, getPopularRoles, getRole, getCategories } from 'agent-workstation';
+
+const CLI_PATH = path.join(__dirname, '..', 'dist', 'cli.js');
+const TMP_DIR = path.join(process.env.TEMP || require('os').tmpdir(), 'opc-test-init-role-' + process.pid);
+
+function run(args: string): string {
+  return execSync(`node "${CLI_PATH}" ${args}`, { cwd: TMP_DIR, encoding: 'utf-8', timeout: 15000 });
+}
+
+describe('opc init --role integration with agent-workstation', () => {
+  beforeEach(() => {
+    if (fs.existsSync(TMP_DIR)) fs.rmSync(TMP_DIR, { recursive: true, force: true });
+    fs.mkdirSync(TMP_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TMP_DIR)) fs.rmSync(TMP_DIR, { recursive: true, force: true });
+  });
+
+  // --- agent-workstation API tests ---
+
+  it('searchRoles returns results for "customer"', () => {
+    const results = searchRoles('customer');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].category).toBe('customer-service');
+  });
+
+  it('searchRoles returns results for "developer"', () => {
+    const results = searchRoles('developer');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results.some((r: any) => r.role.includes('developer'))).toBe(true);
+  });
+
+  it('searchRoles returns empty for nonexistent role', () => {
+    const results = searchRoles('xyznonexistentrole12345');
+    expect(results.length).toBe(0);
+  });
+
+  it('getPopularRoles returns roles with category and role fields', () => {
+    const roles = getPopularRoles();
+    expect(roles.length).toBeGreaterThan(5);
+    for (const r of roles) {
+      expect(r).toHaveProperty('category');
+      expect(r).toHaveProperty('role');
+    }
+  });
+
+  it('getRole loads full role data with files', () => {
+    const role = getRole('customer-service', 'customer-service-rep');
+    expect(role).toBeTruthy();
+    expect(role.files).toBeTruthy();
+    expect(role.files['system-prompt.md']).toBeTruthy();
+    expect(role.files['brain-seed.md']).toBeTruthy();
+  });
+
+  it('getCategories returns category list', () => {
+    const cats = getCategories();
+    expect(cats.length).toBeGreaterThan(3);
+    expect(cats.some((c: any) => c.name === 'customer-service')).toBe(true);
+  });
+
+  // --- CLI integration tests ---
+
+  it('--list-roles shows available roles', () => {
+    const output = run('init --list-roles');
+    expect(output).toContain('Available workstation roles');
+    expect(output).toContain('customer-service');
+    expect(output).toContain('--role');
+  });
+
+  it('--role customer-service generates SOUL.md from template', () => {
+    const output = run('init test-cs-agent --role customer-service');
+    expect(output).toContain('customer-service');
+    const soulPath = path.join(TMP_DIR, 'test-cs-agent', 'SOUL.md');
+    expect(fs.existsSync(soulPath)).toBe(true);
+    const soul = fs.readFileSync(soulPath, 'utf-8');
+    expect(soul).toContain('Customer Service');
+    expect(soul.split('\n').length).toBeGreaterThan(10);
+  });
+
+  it('--role generates agent.yaml with role systemPrompt', () => {
+    run('init test-yaml-agent --role customer-service');
+    const agentYaml = fs.readFileSync(path.join(TMP_DIR, 'test-yaml-agent', 'agent.yaml'), 'utf-8');
+    expect(agentYaml).toContain('Customer Service');
+    expect(agentYaml).toContain('systemPrompt');
+    expect(agentYaml).toContain('deepbrain');
+  });
+
+  it('--role generates brain-seed when available', () => {
+    run('init test-brain-agent --role customer-service');
+    const brainPath = path.join(TMP_DIR, 'test-brain-agent', 'data', 'brain-seed.md');
+    expect(fs.existsSync(brainPath)).toBe(true);
+    const brain = fs.readFileSync(brainPath, 'utf-8');
+    expect(brain.length).toBeGreaterThan(50);
+  });
+
+  it('--role generates CONTEXT.md with role info', () => {
+    run('init test-ctx-agent --role customer-service');
+    const ctx = fs.readFileSync(path.join(TMP_DIR, 'test-ctx-agent', 'CONTEXT.md'), 'utf-8');
+    expect(ctx).toContain('Customer Service');
+  });
+
+  it('--role with unknown role gives error', () => {
+    expect(() => run('init test-bad --role xyznonexistent123')).toThrow();
+  });
+
+  it('--role with partial match "developer" works', () => {
+    const output = run('init test-dev-agent --role developer');
+    expect(output).toContain('developer');
+    expect(fs.existsSync(path.join(TMP_DIR, 'test-dev-agent', 'SOUL.md'))).toBe(true);
+  });
+
+  it('init without --role still works (generic project)', () => {
+    const output = run('init test-generic -y');
+    expect(output).toContain('Created agent project');
+    expect(output).toContain('Tip');
+    expect(output).toContain('--role');
+    expect(fs.existsSync(path.join(TMP_DIR, 'test-generic', 'SOUL.md'))).toBe(true);
+  });
+});

package/tests/mcp-client.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MCPClient } from '../src/tools/mcp-client';
+
+describe('MCPClient', () => {
+  it('starts with no process', () => {
+    const client = new MCPClient();
+    expect((client as any).process).toBeNull();
+  });
+
+  it('starts with empty buffer', () => {
+    const client = new MCPClient();
+    expect((client as any).buffer).toBe('');
+  });
+
+  it('starts not connected', () => {
+    const client = new MCPClient();
+    expect((client as any).connected).toBe(false);
+  });
+
+  it('nextId starts at 1', () => {
+    const client = new MCPClient();
+    expect((client as any).nextId).toBe(1);
+  });
+
+  it('pending map starts empty', () => {
+    const client = new MCPClient();
+    expect((client as any).pending.size).toBe(0);
+  });
+
+  it('config starts null', () => {
+    const client = new MCPClient();
+    expect((client as any).config).toBeNull();
+  });
+
+  it('processBuffer handles complete JSON line', () => {
+    const client = new MCPClient();
+    const resolve = vi.fn();
+    const reject = vi.fn();
+    (client as any).pending.set(1, { resolve, reject });
+    (client as any).buffer = '{"id":1,"result":{"tools":[]}}\n';
+    (client as any).processBuffer();
+    expect(resolve).toHaveBeenCalledWith({ tools: [] });
+    expect((client as any).pending.size).toBe(0);
+  });
+
+  it('processBuffer handles error response', () => {
+    const client = new MCPClient();
+    const resolve = vi.fn();
+    const reject = vi.fn();
+    (client as any).pending.set(2, { resolve, reject });
+    (client as any).buffer = '{"id":2,"error":{"message":"not found"}}\n';
+    (client as any).processBuffer();
+    expect(reject).toHaveBeenCalled();
+    expect(reject.mock.calls[0][0].message).toBe('not found');
+  });
+
+  it('processBuffer handles partial message (no newline)', () => {
+    const client = new MCPClient();
+    const resolve = vi.fn();
+    (client as any).pending.set(1, { resolve, reject: vi.fn() });
+    (client as any).buffer = '{"id":1,"result":';
+    (client as any).processBuffer();
+    expect(resolve).not.toHaveBeenCalled();
+    // Partial stays in buffer
+    expect((client as any).buffer).toBe('{"id":1,"result":');
+  });
+
+  it('processBuffer handles multiple responses in one chunk', () => {
+    const client = new MCPClient();
+    const r1 = vi.fn(), r2 = vi.fn();
+    (client as any).pending.set(1, { resolve: r1, reject: vi.fn() });
+    (client as any).pending.set(2, { resolve: r2, reject: vi.fn() });
+    (client as any).buffer = '{"id":1,"result":"a"}\n{"id":2,"result":"b"}\n';
+    (client as any).processBuffer();
+    expect(r1).toHaveBeenCalledWith('a');
+    expect(r2).toHaveBeenCalledWith('b');
+  });
+
+  it('processBuffer ignores non-JSON lines', () => {
+    const client = new MCPClient();
+    (client as any).buffer = 'not json at all\n';
+    // Should not throw
+    (client as any).processBuffer();
+  });
+
+  it('processBuffer ignores responses without matching id', () => {
+    const client = new MCPClient();
+    (client as any).buffer = '{"id":999,"result":"orphan"}\n';
+    // Should not throw
+    (client as any).processBuffer();
+  });
+});