mcpctl/src/mcplocal/tests/proxymodel-llm-adapter.test.ts

import { describe, it, expect, vi } from 'vitest';
import { LLMProviderAdapter } from '../src/proxymodel/llm-adapter.js';
import { ProviderRegistry } from '../src/providers/registry.js';
import type { LlmProvider, CompletionResult } from '../src/providers/types.js';

function mockProvider(name: string, response = 'mock response'): LlmProvider {
  return {
    name,
    complete: vi.fn().mockResolvedValue({
      content: response,
      toolCalls: [],
      usage: { promptTokens: 10, completionTokens: 5, totalTokens: 15 },
      finishReason: 'stop',
    } satisfies CompletionResult),
    listModels: vi.fn().mockResolvedValue([]),
    isAvailable: vi.fn().mockResolvedValue(true),
  };
}

describe('LLMProviderAdapter', () => {
  it('available() returns true when a provider is registered', () => {
    const registry = new ProviderRegistry();
    registry.register(mockProvider('test'));
    registry.assignTier('test', 'fast');

    const adapter = new LLMProviderAdapter(registry);
    expect(adapter.available()).toBe(true);
  });

  it('available() returns false when no provider is registered', () => {
    const registry = new ProviderRegistry();
    const adapter = new LLMProviderAdapter(registry);
    expect(adapter.available()).toBe(false);
  });

  it('complete() sends prompt as user message', async () => {
    const provider = mockProvider('test');
    const registry = new ProviderRegistry();
    registry.register(provider);
    registry.assignTier('test', 'fast');

    const adapter = new LLMProviderAdapter(registry);
    const result = await adapter.complete('summarize this');

    expect(result).toBe('mock response');
    expect(provider.complete).toHaveBeenCalledWith({
      messages: [{ role: 'user', content: 'summarize this' }],
      maxTokens: undefined,
      temperature: 0,
    });
  });

  it('complete() includes system message when provided', async () => {
    const provider = mockProvider('test');
    const registry = new ProviderRegistry();
    registry.register(provider);
    registry.assignTier('test', 'fast');

    const adapter = new LLMProviderAdapter(registry);
    await adapter.complete('summarize', { system: 'You are a summarizer', maxTokens: 200 });

    expect(provider.complete).toHaveBeenCalledWith({
      messages: [
        { role: 'system', content: 'You are a summarizer' },
        { role: 'user', content: 'summarize' },
      ],
      maxTokens: 200,
      temperature: 0,
    });
  });

  it('complete() throws when no provider available', async () => {
    const registry = new ProviderRegistry();
    const adapter = new LLMProviderAdapter(registry);

    await expect(adapter.complete('test')).rejects.toThrow('No LLM provider available');
  });
});