metona-ai-desktop/electron/harness/adapters/openai.adapter.ts

/**
 * OpenAI Provider Adapter（P3）
 *
 * OpenAI Chat Completions API（/v1/chat/completions），支持 Tool Calling、
 * 流式输出、多模态图片、o 系列推理模型的 reasoning_effort 参数。
 *
 * 与 DeepSeek 适配器的关键差异：
 * - o 系列 / gpt-5 系列模型使用 max_completion_tokens（非 max_tokens）
 * - Thinking 模式通过顶层 reasoning_effort 参数（o 系列模型）
 * - 模型列表从 /v1/models 动态获取
 *
 * @see apis 官方文档 https://platform.openai.com/docs/api-reference/chat
 */

import { BaseAdapter } from './base-adapter';
import type { MetonaRequest, MetonaResponse, MetonaStreamEvent } from '../types';
import { MetonaFinishReason } from '../types';
import type { MetonaModelInfo } from '../types/metona-adapter';
import { buildOpenAICompatibleMessages, buildOpenAICompatibleTools } from './shared/openai-format';
import { parseSSEStream, parseOpenAICompatibleResponse } from './shared/sse-stream';

export class OpenAIAdapter extends BaseAdapter {
  override readonly providerId: string = 'openai';
  readonly supportedModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'o3-mini'];
  readonly supportsToolCalling = true;
  readonly supportsThinking = true;

  private static readonly MODEL_INFO: Record<string, MetonaModelInfo> = {
    'gpt-4o': {
      id: 'gpt-4o',
      name: 'GPT-4o',
      contextWindow: 128_000,
      maxOutputTokens: 16_384,
      supportsToolCalling: true,
      supportsThinking: false,
      description: 'OpenAI 旗舰多模态模型，128K 上下文',
    },
    'gpt-4o-mini': {
      id: 'gpt-4o-mini',
      name: 'GPT-4o mini',
      contextWindow: 128_000,
      maxOutputTokens: 16_384,
      supportsToolCalling: true,
      supportsThinking: false,
      description: 'OpenAI 高性价比模型，128K 上下文',
    },
    'gpt-4.1': {
      id: 'gpt-4.1',
      name: 'GPT-4.1',
      contextWindow: 1_000_000,
      maxOutputTokens: 32_768,
      supportsToolCalling: true,
      supportsThinking: false,
      description: 'OpenAI 长上下文模型，1M 上下文',
    },
    'o3-mini': {
      id: 'o3-mini',
      name: 'o3-mini',
      contextWindow: 200_000,
      maxOutputTokens: 100_000,
      supportsToolCalling: true,
      supportsThinking: true,
      description: 'OpenAI 推理模型，支持 reasoning_effort',
    },
  };

  // ===== POST /v1/chat/completions（非流式） =====

  async send(request: MetonaRequest): Promise<MetonaResponse> {
    const body = this.toNativeRequest(request, false);

    const response = await this.fetchWithTimeout(`${this.config.baseURL}/chat/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${this.config.apiKey}`,
        ...this.config.headers,
      },
      body: JSON.stringify(body),
    }, this.config.timeoutMs ?? 120_000);

    if (!response.ok) {
      await this.throwHttpError(response, 'OpenAI API error');
    }

    const data = await response.json() as Record<string, unknown>;
    const parsed = parseOpenAICompatibleResponse(data);

    return {
      meta: {
        requestId: request.meta.requestId,
        provider: this.providerId,
        model: (data.model as string) ?? this.config.defaultModel,
        latencyMs: 0,
        timestamp: Date.now(),
      },
      content: parsed.content,
      reasoningContent: parsed.reasoningContent,
      toolCalls: parsed.toolCalls,
      usage: parsed.usage,
      finishReason: parsed.finishReason as MetonaFinishReason,
    };
  }

  // ===== POST /v1/chat/completions（流式） =====

  async *sendStream(request: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
    const body = this.toNativeRequest(request, true);

    const response = await this.fetchWithTimeout(`${this.config.baseURL}/chat/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${this.config.apiKey}`,
        ...this.config.headers,
      },
      body: JSON.stringify(body),
    }, this.config.timeoutMs ?? 300_000);

    if (!response.ok || !response.body) {
      await this.throwHttpError(response, 'OpenAI stream error');
    }

    yield* parseSSEStream(
      // 非空断言：上方 if 已确保 response.body 不为 null
      response.body!,
      request.meta.requestId,
      request.meta.sessionId,
      request.meta.iteration,
    );
  }

  // ===== GET /v1/models =====

  override async listModels(): Promise<MetonaModelInfo[]> {
    try {
      const response = await fetch(`${this.config.baseURL}/models`, {
        headers: { Authorization: `Bearer ${this.config.apiKey}` },
        signal: AbortSignal.timeout(10_000),
      });
      if (response.ok) {
        const data = await response.json() as { data?: Array<{ id: string }> };
        if (data.data?.length) {
          return data.data.map((m) => OpenAIAdapter.MODEL_INFO[m.id] ?? { id: m.id });
        }
      }
    } catch {
      // API 不可用时降级
    }
    return this.supportedModels.map((id) => OpenAIAdapter.MODEL_INFO[id] ?? { id });
  }

  override getContextWindow(): number {
    if (typeof this.config.contextWindow === 'number' && this.config.contextWindow > 0) {
      return this.config.contextWindow;
    }
    const modelInfo = OpenAIAdapter.MODEL_INFO[this.config.defaultModel];
    return modelInfo?.contextWindow ?? 128_000;
  }

  // ========== 私有方法 ==========

  /**
   * 构建 OpenAI 原生请求体
   *
   * OpenAI 特有处理：
   * - 多模态图片：user 消息 images[] → content 数组
   * - o 系列（o1/o3/o4）与 gpt-5 系列使用 max_completion_tokens + reasoning_effort
   * - 思考模式下 temperature 被部分推理模型拒绝，不传
   */
  private toNativeRequest(request: MetonaRequest, stream: boolean): Record<string, unknown> {
    const messages = buildOpenAICompatibleMessages(request);
    const tools = buildOpenAICompatibleTools(request.tools);

    // 推理模型检测（o 系列使用新参数名）
    const model = this.config.defaultModel;
    const isReasoningModel = /^(o\d|gpt-5)/.test(model);

    // === 多模态：将 images 转为 OpenAI content 数组（与 Agnes/MiMo 一致） ===
    const nonSystemMsgs = request.messages.filter((m) => m.role !== 'system');
    let imageCount = 0;
    for (let i = 0; i < messages.length; i++) {
      if (i === 0) continue; // messages[0] 是 system
      const origMsg = nonSystemMsgs[i - 1];
      if (!origMsg?.images?.length) continue;

      imageCount += origMsg.images.length;
      const contentParts: Array<Record<string, unknown>> = [];
      if (origMsg.content) {
        contentParts.push({ type: 'text', text: origMsg.content });
      }
      for (const img of origMsg.images) {
        contentParts.push({ type: 'image_url', image_url: { url: img.url } });
      }
      messages[i].content = contentParts;
    }
    if (imageCount > 0) {
      // 推理模型当前不支持图片输入
      if (isReasoningModel) {
        throw new Error(`Model "${model}" does not support image inputs`);
      }
    }

    const body: Record<string, unknown> = {
      model,
      messages,
      stream,
    };

    // Token 上限参数：o 系列/gpt-5 使用 max_completion_tokens
    if (request.params.maxTokens) {
      if (isReasoningModel) {
        body.max_completion_tokens = request.params.maxTokens;
      } else {
        body.max_tokens = request.params.maxTokens;
      }
    } else if (isReasoningModel) {
      // 推理模型未配置时使用兜底值（thinking 占用 token 配额，默认值过小会被截断）
      body.max_completion_tokens = 32_768;
    }

    if (stream) {
      body.stream_options = { include_usage: true };
    }

    if (tools) {
      body.tools = tools;
    }

    // Thinking 模式：推理模型映射 reasoning_effort；非推理模型忽略
    if (request.params.thinkingEnabled && isReasoningModel) {
      const effortMap: Record<string, string> = { low: 'low', medium: 'medium', high: 'high', max: 'high' };
      body.reasoning_effort = effortMap[request.params.thinkingEffort ?? 'high'] ?? 'high';
    } else if (!isReasoningModel) {
      // 非推理模型使用温度控制
      body.temperature = request.params.temperature;
    }

    // 停止序列
    if (request.params.stopSequences?.length) {
      body.stop = request.params.stopSequences;
    }

    return body;
  }
}