// types.ts
export type Role = 'system' | 'user' | 'assistant';

export interface ChatMessage {
  role: Role;
  content: string;
}

export interface ChatOptions {
  model: string;
  messages: ChatMessage[];
  temperature?: number;
  maxTokens?: number;
}

export interface NormalizedResponse {
  text: string;
  usage: {
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
  };
  stopReason: 'stop' | 'length' | 'tool_calls' | 'unknown';
  raw: any; // 保留原始响应以备特殊调试
}

// client.ts
import { ChatOptions, NormalizedResponse, ChatMessage } from './types';

export interface ModelProvider {
  chatComplete(options: ChatOptions): Promise<NormalizedResponse>;
}

// OpenAI 适配器
export class OpenAIProvider implements ModelProvider {
  private apiKey: string;
  private baseUrl: string;

  constructor(apiKey: string, baseUrl = 'https://api.openai.com/v1') { 
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  async chatComplete(options: ChatOptions): Promise<NormalizedResponse> {
    // 根据 OpenAI Responses API 设计，直接将所有消息投递给 messages 数组
    const response = await fetch(`${this.baseUrl}/chat/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${this.apiKey}`
      },
      body: JSON.stringify({
        model: options.model,
        messages: options.messages,
        temperature: options.temperature ?? 0.7,
        max_tokens: options.maxTokens
      })
    });

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({}));
      throw new Error(`OpenAI API Error: [${response.status}] ${JSON.stringify(errorData)}`);
    }

    const data = await response.json();
    const choice = data.choices[0];

    // 映射 Stop Reason
    let stopReason: NormalizedResponse['stopReason'] = 'unknown';
    if (choice.finish_reason === 'stop') stopReason = 'stop';
    else if (choice.finish_reason === 'length') stopReason = 'length';
    else if (choice.finish_reason === 'tool_calls') stopReason = 'tool_calls';

    return {
      text: choice.message.content || '',
      usage: {
        promptTokens: data.usage?.prompt_tokens || 0,
        completionTokens: data.usage?.completion_tokens || 0,
        totalTokens: data.usage?.total_tokens || 0
      },
      stopReason,
      raw: data
    };
  }
}

// Anthropic Claude 适配器
export class AnthropicProvider implements ModelProvider {
  private apiKey: string;
  private baseUrl: string;

  constructor(apiKey: string, baseUrl = 'https://api.anthropic.com/v1') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  async chatComplete(options: ChatOptions): Promise<NormalizedResponse> {
    // 教学判断：参考 Anthropic Messages API 规范，system 必须作为顶级参数提取，不能存在于 messages 数组内
    const systemMessage = options.messages.find(msg => msg.role === 'system');
    const filteredMessages = options.messages.filter(msg => msg.role !== 'system');

    const response = await fetch(`${this.baseUrl}/messages`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': this.apiKey,
        'anthropic-version': '2023-06-01' // 截至 2026-05-28 的标准 API 版本
      },
      body: JSON.stringify({
        model: options.model,
        system: systemMessage ? systemMessage.content : undefined,
        messages: filteredMessages.map(msg => ({
          role: msg.role === 'system' ? 'user' : msg.role, // 防御性转换
          content: msg.content
        })),
        max_tokens: options.maxTokens ?? 1024,
        temperature: options.temperature ?? 0.7
      })
    });

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({}));
      throw new Error(`Anthropic API Error: [${response.status}] ${JSON.stringify(errorData)}`);
    }

    const data = await response.json();

    let stopReason: NormalizedResponse['stopReason'] = 'unknown';
    if (data.stop_reason === 'end_turn') stopReason = 'stop';
    else if (data.stop_reason === 'max_tokens') stopReason = 'length';
    else if (data.stop_reason === 'tool_use') stopReason = 'tool_calls';

    return {
      text: data.content[0]?.text || '',
      usage: {
        promptTokens: data.usage?.input_tokens || 0,
        completionTokens: data.usage?.output_tokens || 0,
        totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0)
      },
      stopReason,
      raw: data
    };
  }
}

npm install ai @ai-sdk/openai @ai-sdk/anthropic

import { generateText, LanguageModel } from 'ai';
import { openai } from '@ai-sdk/openai';
import { anthropic } from '@ai-sdk/anthropic';

export async function askModel(
  provider: 'openai' | 'anthropic',
  modelName: string,
  prompt: string
) {
  // 1. 根据传入参数动态选择 Model Instance
  let modelInstance: LanguageModel;
  
  if (provider === 'openai') {
    modelInstance = openai(modelName);
  } else {
    modelInstance = anthropic(modelName);
  }

  // 2. 统一调用 generateText
  const { text, finishReason, usage } = await generateText({
    model: modelInstance,
    system: '你是一个专业的资深技术架构师。',
    prompt: prompt,
    temperature: 0.3,
  });

  return {
    text,
    finishReason, // 自动归一化为 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other'
    tokens: usage.totalTokens
  };
}

import { OpenAIProvider, AnthropicProvider } from './client'; // 引入上面手写的类
import { ChatMessage } from './types';

async function runDiagnostic() {
  const testMessages: ChatMessage[] = [
    { role: 'system', content: '你是一个测试助手。请只输出数字 1' },
    { role: 'user', content: '请输出对应的测试数字。' }
  ];

  const openAIKey = process.env.OPENAI_API_KEY;
  const anthropicKey = process.env.ANTHROPIC_API_KEY;

  console.log('--- 开始多 Provider 调用诊断 ---');

  if (openAIKey) {
    try {
      const openaiClient = new OpenAIProvider(openAIKey);
      // 根据 OpenAI Models 官方文档，选用标准的 gpt-4o-mini 进行低成本测试
      const res = await openaiClient.chatComplete({
        model: 'gpt-4o-mini',
        messages: testMessages,
        maxTokens: 10
      });
      console.log('✅ OpenAI 适配器测试通过：');
      console.log(`   输出: "${res.text}" | 消耗 Token: ${res.usage.totalTokens} | 结束原因: ${res.stopReason}`);
    } catch (e: any) {
      console.error('❌ OpenAI 适配器测试失败:', e.message);
    }
  } else {
    console.log('⚠️ 未检测到 OPENAI_API_KEY，跳过 OpenAI 测试。');
  }

  if (anthropicKey) {
    try {
      const anthropicClient = new AnthropicProvider(anthropicKey);
      const res = await anthropicClient.chatComplete({
        model: 'claude-3-5-sonnet-20241022',
        messages: testMessages,
        maxTokens: 10
      });
      console.log('✅ Anthropic 适配器测试通过：');
      console.log(`   输出: "${res.text}" | 消耗 Token: ${res.usage.totalTokens} | 结束原因: ${res.stopReason}`);
    } catch (e: any) {
      console.error('❌ Anthropic 适配器测试失败:', e.message);
    }
  } else {
    console.log('⚠️ 未检测到 ANTHROPIC_API_KEY，跳过 Anthropic 测试。');
  }
}

runDiagnostic();