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

/**
 * Provider maxTokens 上限钳制契约测试（v0.5.3）
 *
 * 背景：引擎默认 maxTokens=63488（engine.ts DEFAULT_CONFIG），超过部分模型
 * 上限时 API 直接 400 —— OpenAI gpt-4o(16384)/gpt-4.1(32768)、Anthropic
 * opus/haiku(32000)、MiMo standard(32768) 曾不可用。v0.5.3 各 adapter 按
 * MODEL_INFO.maxOutputTokens 钳制。
 *
 * 测试策略（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();
});

/** 引擎默认形态的请求（maxTokens=63488，与 engine DEFAULT_CONFIG 一致） */
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 模型上限钳制（引擎默认 63488 场景）', () => {
  it('DeepSeek v4 pro（上限 384K）：63488 未超限，原样传递', 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('Agnes flash（上限 65536）：63488 未超限，原样传递', 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（上限 32768）：钳制到 32768（原为 400 错误场景）', 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(32_768);
  });

  it('MiMo pro（上限 131072）：63488 未超限，原样传递', 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（上限 16384）：钳制到 16384（原为 400 错误场景）', 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(16_384);
  });

  it('OpenAI o3-mini（上限 100K）：63488 未超限，推理模型字段名正确', 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（上限 32000）：钳制到 32000（原为 400 错误场景）', 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(32_000);
  });

  it('Anthropic sonnet（上限 64000）：63488 未超限', 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 时各 adapter 使用安全默认值（不超过模型上限）', async () => {
    mockFetch.mockResolvedValue(openAIResponse());
    const request = makeRequest({
      params: { temperature: 0, stream: false } as MetonaRequest['params'],
    });

    // MiMo standard + thinking 默认 → 兜底 32768（= 上限，安全）
    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).toBe(32_768);
  });
});