zsjz-ai/ai-electron/electron/service/codex/providerService.ts

import { mkdir, readFile, writeFile } from 'node:fs/promises';
import { join } from 'node:path';
import { chatBridge } from './chatBridgeService';
import { getCodexDataDir } from './codexHome';
import { DEFAULT_API_KEY_ENV, type CodexProviderSpec, type CodexRuntime, type JsonValue } from './codexRuntime';
import type { AppliedProviderInfo, ApplyProviderInput } from './types';

/**
 * 把后端「模型管理」里的一条记录翻译成 Codex 的 model provider。
 * 全程不做任何 Codex/OpenAI 账号登录：靠 wire_api="responses" + requires_openai_auth=false + env_key。
 * apiKey 只存在于内存与子进程环境变量，落盘的 AppliedProvider 不含任何密钥。
 */

export const PROVIDER_ID = 'zsjz';

export type AppliedProvider = AppliedProviderInfo;

/**
 * 端点判定。后端「模型管理」里的记录一律是 Chat 协议（没有 /responses），
 * 所以这里只关心「能不能用 Chat」：chat → 走内置桥接；其余两种拒绝。
 */
export type EndpointProtocol = 'chat' | 'unsupported' | 'unreachable';

export interface EndpointProbeResult {
  protocol: EndpointProtocol;
  /** /chat/completions 的 HTTP 状态；未探或网络失败为 null */
  chatStatus: number | null;
  detail: string;
}

const EXTRA_ALLOWLIST: readonly string[] = [
  'request_max_retries',
  'stream_max_retries',
  'stream_idle_timeout_ms',
  'query_params',
];

function providerFile(): string {
  return join(getCodexDataDir(), 'provider.json');
}

/** Codex 要求 base_url 是 API 根（形如 https://api.openai.com/v1），它自己再拼路由 */
export function normalizeBaseUrl(raw: string | null | undefined): string | null {
  const value = (raw ?? '').trim().replace(/\/+$/u, '');
  return value || null;
}

/** 给页面的非阻断提示；返回 null 表示没问题 */
export function baseUrlHint(baseUrl: string | null): string | null {
  if (!baseUrl) return '未配置 base_url';
  if (!/^https?:\/\//u.test(baseUrl)) return 'base_url 必须以 http:// 或 https:// 开头';
  if (!/\/v\d+$/u.test(baseUrl)) {
    return 'base_url 通常应写到版本段（如 .../v1），否则拼出的 /chat/completions 可能 404';
  }
  return null;
}

function parseJsonRecord(raw: unknown): Record<string, unknown> | null {
  if (!raw) return null;
  if (typeof raw === 'object' && !Array.isArray(raw)) return raw as Record<string, unknown>;
  if (typeof raw !== 'string') return null;
  try {
    const parsed = JSON.parse(raw) as unknown;
    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
      ? (parsed as Record<string, unknown>)
      : null;
  } catch {
    return null;
  }
}

function readStringMap(raw: unknown): Record<string, string> | null {
  const record = parseJsonRecord(raw);
  if (!record) return null;
  const result: Record<string, string> = {};
  for (const [key, value] of Object.entries(record)) {
    if (typeof value === 'string' && value) result[key] = value;
  }
  return Object.keys(result).length ? result : null;
}

/**
 * 后端「模型管理」的一条记录一律翻译成自定义 provider：Codex 0.155.1 把 ollama / lmstudio
 * 等内置 id 列为保留字，覆盖 model_providers.<内置 id> 会让 app-server 启动即退出。
 * 地址缺失就是配置缺失，直接报错让页面提示，不做 localhost 兜底。
 */
export function toProviderSpec(input: ApplyProviderInput): CodexProviderSpec {
  const model = `${input.modelId ?? ''}`.trim();
  if (!model) throw new Error('缺少 modelId');

  const baseUrl = normalizeBaseUrl(input.baseUrl);
  if (!baseUrl) {
    throw new Error(`模型「${input.name || model}」没有配置 base_url，请到「模型管理」补全（形如 https://host:port/v1）`);
  }

  const config = parseJsonRecord(input.config);
  const extra: Record<string, JsonValue> = {};
  for (const [key, value] of Object.entries(config ?? {})) {
    if (EXTRA_ALLOWLIST.includes(key)) extra[key] = value as JsonValue;
  }

  return {
    id: PROVIDER_ID,
    name: input.name ?? model,
    baseUrl,
    model,
    apiKey: input.apiKey ?? null,
    envKey: DEFAULT_API_KEY_ENV,
    httpHeaders: readStringMap(input.headersJson),
    extra: Object.keys(extra).length ? extra : null,
  };
}

/** config 里被丢弃的非白名单键，用于页面提示 */
export function describeDroppedKeys(input: ApplyProviderInput): string[] {
  const config = parseJsonRecord(input.config);
  return Object.keys(config ?? {}).filter((key) => !EXTRA_ALLOWLIST.includes(key));
}

/**
 * 探测只问「路由在不在」，绝不让端点真去生成：本地服务多是单槽推理，
 * 一次生成能占住整个 HTTP 服务几十秒（实测 max_tokens:1 也要 14 秒，期间连 /models 都不应答）。
 * 15 秒是留给排队的余量。
 */
const PROBE_TIMEOUT_MS = 15_000;

interface ProbeAttempt {
  status: number | null;
  error: string | null;
  ms: number;
  timedOut: boolean;
}

function describeFetchError(error: unknown): { message: string; timedOut: boolean } {
  const err = error instanceof Error ? error : new Error(String(error));
  return {
    message: err.message,
    timedOut: err.name === 'TimeoutError' || err.name === 'AbortError' || /timeout/iu.test(err.message),
  };
}

async function probeFetch(url: string, init: RequestInit, timeoutMs: number): Promise<ProbeAttempt> {
  const startedAt = Date.now();
  try {
    const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
    return { status: response.status, error: null, ms: Date.now() - startedAt, timedOut: false };
  } catch (error) {
    const { message, timedOut } = describeFetchError(error);
    return { status: null, error: message, ms: Date.now() - startedAt, timedOut };
  }
}

async function postProbe(url: string, body: Record<string, unknown>, apiKey?: string | null): Promise<ProbeAttempt> {
  return probeFetch(
    url,
    {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
      },
      body: JSON.stringify(body),
    },
    PROBE_TIMEOUT_MS,
  );
}

/**
 * 不可达的提示必须带上是哪个地址、等了多久——只说「端点不可达」时，
 * 用户既不知道配错在哪，也无从判断是没起服务还是被防火墙慢慢吞掉。
 */
function unreachableDetail(url: string, attempt: ProbeAttempt): string {
  if (attempt.timedOut) {
    return `端点不可达：${url} 在 ${(attempt.ms / 1000).toFixed(1)} 秒内没有响应，请确认服务已启动、地址与端口正确`;
  }
  return `端点不可达：${url} —— ${attempt.error ?? '网络错误'}`;
}

function probeResult(partial: Partial<EndpointProbeResult> & { protocol: EndpointProtocol; detail: string }): EndpointProbeResult {
  return { chatStatus: null, ...partial };
}

/**
 * 判定端点能不能用 Chat 协议——后端「模型管理」里的记录都是 Chat 端点，
 * 有的就交给内置桥接。
 *
 * 只看 /chat/completions 这条路由在不在：请求体故意不带 messages，
 * 端点会在校验阶段就回 400（实测 15ms），不会真的开始生成。
 * 代价是模型名写错要到真正提问时才暴露。
 */
export async function probeEndpoint(params: {
  baseUrl: string;
  modelId?: string | null;
  apiKey?: string | null;
}): Promise<EndpointProbeResult> {
  const baseUrl = params.baseUrl.replace(/\/+$/u, '');
  const chatUrl = `${baseUrl}/chat/completions`;
  const model = params.modelId?.trim() || 'probe';

  const chat = await postProbe(chatUrl, { model }, params.apiKey);
  if (chat.status === null) {
    return probeResult({ protocol: 'unreachable', detail: unreachableDetail(chatUrl, chat) });
  }
  if (chat.status !== 404 && chat.status !== 405) {
    return probeResult({
      protocol: 'chat',
      chatStatus: chat.status,
      detail: `端点支持 Chat 协议（HTTP ${chat.status}），应用时经内置桥接转换为 Responses`,
    });
  }
  return probeResult({
    protocol: 'unsupported',
    chatStatus: chat.status,
    detail: `端点没有 /chat/completions 路由（HTTP ${chat.status}），本客户端只对接 Chat 协议端点`,
  });
}

export async function readAppliedProvider(): Promise<AppliedProvider | null> {
  try {
    const raw = JSON.parse(await readFile(providerFile(), 'utf8')) as Partial<AppliedProvider>;
    return raw.model ? (raw as AppliedProvider) : null;
  } catch {
    return null;
  }
}

async function writeAppliedProvider(value: AppliedProvider | null): Promise<void> {
  await mkdir(getCodexDataDir(), { recursive: true });
  await writeFile(providerFile(), JSON.stringify(value ?? {}, null, 2), 'utf8');
}

/** 应用一条模型配置：先探端点，再重启子进程（api_key 走 env，换 key 必须重启） */
export async function applyProvider(
  runtime: CodexRuntime,
  input: ApplyProviderInput & { modelRecordId?: string | number | null },
): Promise<AppliedProvider> {
  const spec = toProviderSpec(input);
  /** 落盘存上游真实地址（展示用）；桥接 URL 每次应用临时分配，不落盘 */
  const displayBaseUrl = spec.baseUrl;

  // 一定要先探端点：应用成功后才发现连不上，比这里直接报错更难排查
  const probe = await probeEndpoint({
    baseUrl: spec.baseUrl,
    modelId: spec.model,
    apiKey: spec.apiKey,
  });
  if (probe.protocol !== 'chat') throw new Error(probe.detail);

  // Codex 只会发 Responses，所以 Chat 端点一律经内置桥接：Codex 改连本地代理的 /v1/responses
  const bridge = await chatBridge.start({ upstreamBaseUrl: spec.baseUrl, headers: spec.httpHeaders ?? null });
  spec.baseUrl = bridge.url;

  try {
    await runtime.applyProvider(spec);
  } catch (error) {
    // 应用失败回滚桥接，避免留下一个指着旧上游的孤儿代理
    await chatBridge.stop();
    throw error;
  }

  const applied: AppliedProvider = {
    model: spec.model,
    modelRecordId: input.modelRecordId === undefined || input.modelRecordId === null
      ? null
      : String(input.modelRecordId),
    baseUrl: displayBaseUrl,
    providerId: spec.id,
    name: spec.name ?? null,
    appliedAt: new Date().toISOString(),
    bridged: true,
  };
  await writeAppliedProvider(applied);
  return applied;
}

export async function clearProvider(runtime: CodexRuntime): Promise<void> {
  await chatBridge.stop();
  await runtime.applyProvider(null);
  await writeAppliedProvider(null);
}