// src/server.ts 核心路由逻辑
async function handleRequest(req: IncomingMessage, res: ServerResponse) {
  const body = await readJsonBody<ResponsesRequest>(req);

  // 1. Provider 路由：根据 model 字段选择上游
  const { provider, upstreamModel, rewriteNotice } = selectProvider(body.model);

  // 2. 请求翻译：Responses → Chat Completions
  const chatReq = reqToChat(body, { model: upstreamModel, provider });

  // 3. 调用上游
  const upstreamResp = await callOpenAICompat(cfg, chatReq, signal);

  // 4. 响应翻译：Chat Completions → Responses (流式)
  await pipeChatStreamToResponses(upstreamResp, res, { exposeReasoning });
}

// src/translate/reqToChat.ts 核心逻辑
export function reqToChat(req: ResponsesRequest, ctx: PreprocessCtx): ChatRequest {
  const messages: ChatMessage[] = [];

  for (const item of req.input) {
    if (item.type === "message") {
      // role 转换: developer → system, assistant → assistant
      const role = mapRole(item.role);
      const content = partsToChatContent(item.content, ctx);

      messages.push({ role, content, ... });
    }
  }

  // 工具调用转换: Responses 的 function_call → Chat 的 tool_calls
  if (req.tools) {
    chatReq.tools = req.tools.map(t => ({
      type: "function",
      function: { name: t.name, description: t.description, parameters: t.parameters }
    }));
  }

  // reasoning_content 回传 (关键!)
  // 多轮工具调用时，Codex 会在下一轮把 reasoning_content 回传
  // mimo2codex 必须将之前的 reasoning_content 注入到对应 assistant message
  if (ctx.priorReasoning) {
    // 找到上一条 assistant message，注入 reasoning_content
    injectReasoningContent(messages, ctx.priorReasoning);
  }

  return chatReq;
}

// src/translate/respToResponses.ts
export function respToResponses(
  chat: ChatResponse,
  req: ResponsesRequest,
  opts: RespToResponsesOpts
): ResponsesObject {
  const output: ResponsesOutputItem[] = [];

  // 1. reasoning_content 处理 (最关键!)
  if (message.reasoning_content) {
    // 完整 reasoning 必须存入 encrypted_content
    // Codex 视为 opaque blob，回传时原样返回
    // reqToChat 再注入回 reasoning_content
    output.push({
      type: "reasoning",
      id: newReasoningId(),
      summary: opts.exposeReasoning ? [{ type: "summary_text", text: reasoning }] : [],
      encrypted_content: reasoning,  // ← 关键：全量透传
      status: "completed"
    });
  }

  // 2. content 处理：注入 url_citation 注解
  if (message.content) {
    const annotations = message.annotations?.map(a => ({
      type: "url_citation",
      url: a.url,
      title: a.title,
      snippet: a.summary
    })) ?? [];

    output.push({
      type: "message",
      role: "assistant",
      content: [{ type: "output_text", text: message.content, annotations }]
    });
  }

  // 3. 工具调用转换: Chat 的 tool_calls → Responses 的 function_call
  if (message.tool_calls) {
    for (const tc of message.tool_calls) {
      output.push({
        type: "function_call",
        call_id: tc.id,
        name: tc.function.name,
        arguments: tc.function.arguments,
        status: "completed"
      });
    }
  }

  return { id: newResponseId(), model: req.model, output, ... };
}

// src/providers/registry.ts
export const BUILTIN_PROVIDERS: readonly Provider[] = [mimo, deepseek];

export function selectProvider(clientModel: string): SelectedProvider {
  // 1. 遍历所有已注册 provider（内置优先）
  for (const p of providerListMutable) {
    if (p.resolveModel(clientModel) && hasApiKey(p)) {
      return { provider: p, upstreamModel: clientModel };
    }
  }

  // 2. 未匹配 → 使用默认 provider，model 重写为 defaultModel
  return { provider: defaultProvider, upstreamModel: defaultProvider.defaultModel };
}

// src/providers/mimo.ts
const BUILTIN_MODELS = [
  { id: "mimo-v2.5-pro", supportsImages: false, supportsReasoning: true },
  { id: "mimo-v2.5", supportsImages: true, supportsReasoning: true },      // 视觉版
  { id: "mimo-v2-omni", supportsImages: true, supportsReasoning: true },  // 视觉+音频
  { id: "mimo-v2-flash", supportsImages: false },
];

// MiMo 双主机自动切换
const PAYG_BASE_URL = "https://api.xiaomimimo.com/v1";
const TOKEN_PLAN_BASE_URL = "https://token-plan-cn.xiaomimimo.com/v1";

function isTokenPlanRuntime(apiKey: string, baseUrl: string): boolean {
  return /token-plan/i.test(baseUrl) || apiKey.startsWith("tp-");
}

// src/providers/generic.ts
export interface GenericProvider {
  id: string;
  displayName: string;
  baseUrl: string;
  envKey: string;
  defaultModel: string;
  wireApi?: "chat" | "responses";  // chat=翻译, responses=直透
  models?: string[];  // 空=开放目录(any model)
}

// providers.json 示例
{
  "providers": [{
    "id": "qwen",
    "displayName": "Qwen (DashScope)",
    "baseUrl": "https://dashscope.aliyuncs.com/compatible-mode/v1",
    "envKey": "QWEN_API_KEY",
    "defaultModel": "qwen3-max",
    "models": ["qwen3-max", "qwen3"]
  }]
}

// src/translate/streamToSSE.ts
function emit(sink: SseSink, state: StreamState, event: string, data: Record<string, unknown>) {
  // SSE event line + data line 都必须有 type
  sink.write(event, { type: event, ...data, sequence_number: state.nextSeq() });
}

// 流式输出序列
// 1. response.completed (stream start)
// 2. response.outputItem.added (reasoning chunk)
// 3. response.outputItem.done (reasoning done)
// 4. response.outputItem.added (message chunk)
// 5. response.outputItem.done (message done)
// 6. response.done (final)

interface ToolCallState {
  itemId: string;
  outputIndex: number;
  callId: string;
  name: string;
  argsBuffer: string;
  argsEmitted: boolean;
}

// 并行工具调用处理
// 每个 tool_call 对应一个 ToolCallState，逐步累积 arguments
// 完成时输出 response.outputItem.added (function_call)