metona-ai-desktop/electron/harness/adapters/__tests__/max-tokens-clamp.test.ts

/**
 * maxTokens 透传契约测试（v0.8.1 硬性契约重写）
 *
 * 背景：v0.5.3 曾引入"按 MODEL_INFO.maxOutputTokens 钳制"逻辑。v0.8.1 按硬性
 * 契约废除 —— 设置面板「最大输出上限」（llm.maxTokens）是唯一合法的输出上限
 * 配置，adapter 对一切 Provider/模型**原样透传** `params.maxTokens`，代码中
 * 不存在任何写死的输出上限或按模型元信息的钳制行为。
 *
 * 测试策略（v0.5.2 教训）：mock fetch 记录真实请求体并断言契约 ——
 * 不 mock adapter 内部方法，验证"发出的 HTTP 请求体"这个最终事实。
 */

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';

vi.mock('electron-log', () => ({
  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));

import { DeepSeekAdapter } from '../deepseek.adapter';
import { AgnesAdapter } from '../agnes-ai.adapter';
import { MimoAdapter } from '../mimo.adapter';
import { OpenAIAdapter } from '../openai.adapter';
import { AnthropicAdapter } from '../anthropic.adapter';
import type { MetonaRequest } from '../../types';

const mockFetch = vi.fn();
vi.stubGlobal('fetch', mockFetch);

beforeEach(() => {
  mockFetch.mockReset();
});
afterEach(() => {
  mockFetch.mockReset();
});

/** 设置面板「最大输出上限」配置生效时的请求形态（llm.maxTokens → params.maxTokens） */
function makeRequest(overrides: Partial<MetonaRequest> = {}): MetonaRequest {
  return {
    meta: {
      sessionId: 's',
      iteration: 1,
      requestId: 'r',
      timestamp: Date.now(),
      agentVersion: '1',
    },
    systemPrompt: { roleDefinition: '', outputConstraints: '', safetyGuidelines: '' },
    messages: [{ role: 'user', content: 'hi', timestamp: Date.now() }],
    params: {
      maxTokens: 63_488,
      temperature: 0,
      stream: false,
      thinkingEnabled: false,
    },
    ...overrides,
  };
}

/** OpenAI 兼容系成功响应 */
function openAIResponse(): Response {
  return {
    ok: true,
    status: 200,
    json: async () => ({ choices: [{ message: { content: 'ok' } }], usage: {} }),
  } as unknown as Response;
}

/** Anthropic 成功响应 */
function anthropicResponse(): Response {
  return {
    ok: true,
    status: 200,
    json: async () => ({ content: [{ type: 'text', text: 'ok' }], usage: {} }),
  } as unknown as Response;
}

/** 取 mock fetch 收到的请求体 */
function requestBody(): Record<string, unknown> {
  const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
  return JSON.parse(init.body as string) as Record<string, unknown>;
}

describe('maxTokens 原样透传（v0.8.1：设置面板是唯一合法上限配置）', () => {
  it('DeepSeek：max_tokens 原样透传（不按模型钳制）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new DeepSeekAdapter({
      provider: 'deepseek',
      baseURL: 'https://api.deepseek.com',
      apiKey: 'sk',
      defaultModel: 'deepseek-v4-pro',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_tokens).toBe(63_488);
  });

  it('DeepSeek：超出旧模型元信息上限的值同样原样透传（钳制已废除）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new DeepSeekAdapter({
      provider: 'deepseek',
      baseURL: 'https://api.deepseek.com',
      apiKey: 'sk',
      defaultModel: 'deepseek-v4-flash-vision-exp',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_tokens).toBe(63_488);
  });

  it('Agnes：max_tokens 原样透传', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new AgnesAdapter({
      provider: 'agnes',
      baseURL: 'https://api.agnes.com/v1',
      apiKey: 'k',
      defaultModel: 'agnes-2.0-flash',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_tokens).toBe(63_488);
  });

  it('MiMo standard：max_completion_tokens 原样透传（旧 32768 钳制已废除）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new MimoAdapter({
      provider: 'mimo',
      baseURL: 'https://api.mimo.com/v1',
      apiKey: 'k',
      defaultModel: 'mimo-v2.5',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_completion_tokens).toBe(63_488);
  });

  it('MiMo pro：max_completion_tokens 原样透传', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new MimoAdapter({
      provider: 'mimo',
      baseURL: 'https://api.mimo.com/v1',
      apiKey: 'k',
      defaultModel: 'mimo-v2.5-pro',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_completion_tokens).toBe(63_488);
  });

  it('OpenAI gpt-4o（非推理模型）：max_tokens 原样透传（旧 16384 钳制已废除）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new OpenAIAdapter({
      provider: 'openai',
      baseURL: 'https://api.openai.com/v1',
      apiKey: 'k',
      defaultModel: 'gpt-4o',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_tokens).toBe(63_488);
  });

  it('OpenAI o3-mini（推理模型）：max_completion_tokens 原样透传，字段名路由正确', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const adapter = new OpenAIAdapter({
      provider: 'openai',
      baseURL: 'https://api.openai.com/v1',
      apiKey: 'k',
      defaultModel: 'o3-mini',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_completion_tokens).toBe(63_488);
    expect(requestBody().max_tokens).toBeUndefined();
  });

  it('Anthropic opus：max_tokens 原样透传（旧 32000 钳制已废除）', async () => {
    mockFetch.mockResolvedValue(anthropicResponse());
    const adapter = new AnthropicAdapter({
      provider: 'anthropic',
      baseURL: 'https://api.anthropic.com',
      apiKey: 'k',
      defaultModel: 'claude-opus-4-1',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_tokens).toBe(63_488);
  });

  it('Anthropic sonnet：max_tokens 原样透传', async () => {
    mockFetch.mockResolvedValue(anthropicResponse());
    const adapter = new AnthropicAdapter({
      provider: 'anthropic',
      baseURL: 'https://api.anthropic.com',
      apiKey: 'k',
      defaultModel: 'claude-sonnet-4-5',
    });
    await adapter.send(makeRequest());
    expect(requestBody().max_tokens).toBe(63_488);
  });

  it('未配置 maxTokens：不下发任何输出上限字段（由 Provider 服务端默认值决定）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const request = makeRequest({
      params: { temperature: 0, stream: false } as MetonaRequest['params'],
    });

    const mimo = new MimoAdapter({
      provider: 'mimo',
      baseURL: 'https://api.mimo.com/v1',
      apiKey: 'k',
      defaultModel: 'mimo-v2.5',
    });
    await mimo.send(request);
    expect(requestBody().max_completion_tokens).toBeUndefined();

    const deepseek = new DeepSeekAdapter({
      provider: 'deepseek',
      baseURL: 'https://api.deepseek.com',
      apiKey: 'sk',
      defaultModel: 'deepseek-v4-pro',
    });
    mockFetch.mockReset();
    mockFetch.mockResolvedValue(openAIResponse());
    await deepseek.send(request);
    expect(requestBody().max_tokens).toBeUndefined();
  });

  it('Anthropic 未配置 maxTokens + thinking 开启：仅满足协议下限 2048（协议不变量，非上限）', async () => {
    mockFetch.mockResolvedValue(anthropicResponse());
    const adapter = new AnthropicAdapter({
      provider: 'anthropic',
      baseURL: 'https://api.anthropic.com',
      apiKey: 'k',
      defaultModel: 'claude-opus-4-1',
    });
    await adapter.send(
      makeRequest({
        params: { temperature: 0, stream: false, thinkingEnabled: true } as MetonaRequest['params'],
      }),
    );
    expect(requestBody().max_tokens).toBe(2048);
  });
});