metona-ai-desktop/electron/harness/adapters/shared/openai-compatible-base.ts

/**
 * OpenAI 兼容 Provider 中间基类（v0.6.4 P3-1）
 *
 * 背景：deepseek / agnes-ai / mimo / openai 四家适配器各自复制了几乎逐字相同的
 * ~60 行传输样板 —— send/sendStream 的 fetchWithTimeout 调用、Bearer 头构建、
 * HTTP 错误桥接、非流式 JSON → MetonaResponse 的字段组装、SSE 流接入、以及
 * "config.contextWindow → MODEL_INFO → 兜底" 的上下文窗口回退链。
 * 任何行为修复都要改四处，是历史缺陷（如超时字段不一致）的直接来源。
 *
 * 收敛后职责划分：
 * - 本基类拥有：send / sendStream / buildHeaders / 响应组装 / finishReason 映射 /
 *   getContextWindow 回退链；
 * - 子类只声明差异：chatCompletionsUrl、toNativeRequest（协议参数映射）、
 *   sendTimeoutMs（个别 Provider 历史超时不同）、modelInfoTable。
 *
 * 外部类型穿透铁律不变：OpenAI 原生类型止步于本文件，向上只产出 Metona IR。
 */

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

export abstract class OpenAICompatibleAdapter extends BaseAdapter {
  /**
   * POST /chat/completions 的完整端点。
   * 绝大多数 Provider 为 `${baseURL}/chat/completions`；少数代理需要自定义。
   */
  protected abstract chatCompletionsUrl(): string;

  /**
   * 子类特有的请求体参数映射（messages/tools/thinking/max_tokens 等差异点）。
   * 返回不含 stream 字段的 body —— stream 由本基类统一注入。
   */
  protected abstract toNativeRequest(
    request: MetonaRequest,
    stream: boolean,
  ): Record<string, unknown> | Promise<Record<string, unknown>>;

  /** 非流式 send 的默认超时。DeepSeek/MiMo/OpenAI=120s；Agnes 历史 300s，保留其值。 */
  protected abstract sendTimeoutMs(): number;

  /** 模型元信息表（子类持有；用于 getContextWindow 回退链与钳制） */
  protected abstract modelInfoTable(): Record<string, MetonaModelInfo>;

  /** getContextWindow 的最终兜底窗口（未配置且模型未知时使用） */
  protected defaultContextWindowFallback(): number {
    return 1_000_000;
  }

  // ===== 认证头 =====

  protected buildHeaders(): Record<string, string> {
    return {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${this.config.apiKey}`,
      ...this.config.headers,
    };
  }

  // ===== POST {chatCompletionsUrl} （非流式） =====

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

    const response = await this.fetchWithTimeout(
      this.chatCompletionsUrl(),
      {
        method: 'POST',
        headers: this.buildHeaders(),
        body: JSON.stringify({ ...nativeRequest, stream: false }),
      },
      this.config.timeoutMs ?? this.sendTimeoutMs(),
    );

    if (!response.ok) {
      await this.throwHttpError(response, `${this.providerLabel()} API error`);
    }

    const data = (await response.json()) as Record<string, unknown>;
    return this.toMetonaResponseFromOpenAI(data, request.meta.requestId);
  }

  // ===== POST {chatCompletionsUrl} （流式） =====

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

    const response = await this.fetchWithTimeout(
      this.chatCompletionsUrl(),
      {
        method: 'POST',
        headers: this.buildHeaders(),
        body: JSON.stringify({ ...nativeRequest, stream: true }),
      },
      this.config.timeoutMs ?? 300_000,
    );

    if (!response.ok || !response.body) {
      await this.throwHttpError(response, `${this.providerLabel()} stream error`);
    }

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

  // ===== 共享装配 =====

  /** Provider 展示名（错误上下文用）：默认取 providerId，子类可覆盖 */
  protected providerLabel(): string {
    return this.providerId;
  }

  /**
   * 非流式响应组装 —— OpenAI 原生结构到 MetonaResponse 的唯一映射点
   * （此前在四个子类各有一份逐字拷贝）
   */
  private toMetonaResponseFromOpenAI(
    data: Record<string, unknown>,
    requestId: string,
  ): MetonaResponse {
    const parsed = parseOpenAICompatibleResponse(data);
    return {
      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: this.mapFinishReasonToMetona(parsed.finishReason),
    };
  }

  /** parseOpenAIFinishReason 输出 → MetonaFinishReason 枚举（显式映射替代裸 as 断言） */
  private mapFinishReasonToMetona(reason: string): MetonaFinishReason {
    switch (reason) {
      case 'length':
        return MetonaFinishReason.LENGTH;
      case 'tool_calls':
        return MetonaFinishReason.TOOL_CALLS;
      case 'content_filter':
        return MetonaFinishReason.CONTENT_FILTER;
      case 'error':
        return MetonaFinishReason.ERROR;
      default:
        return MetonaFinishReason.STOP;
    }
  }

  /**
   * 上下文窗口回退链（v0.6.3 一致化后的统一实现）：
   * config.contextWindow（用户显式配置）→ 模型元信息 → Provider 兜底。
   */
  override getContextWindow(): number {
    if (typeof this.config.contextWindow === 'number' && this.config.contextWindow > 0) {
      return this.config.contextWindow;
    }
    const modelInfo = this.modelInfoTable()[this.config.defaultModel];
    return modelInfo?.contextWindow ?? this.defaultContextWindowFallback();
  }
}

/**
 * 模型能力限制类错误（v0.6.4 升级：此前 OpenAI 推理模型拒图抛裸 Error，
 * 引擎分类落到 UNKNOWN，UI 无法区分"该模型不支持图"与一般故障）。
 * 携带 status=400 使引擎按"不可重试请求级错误"处理并直接展示原因。
 */
export class ModelCapabilityError extends Error {
  readonly status = 400;
  constructor(model: string, capability: string) {
    super(`Model "${model}" does not support ${capability}`);
    this.name = 'ModelCapabilityError';
  }
}