Add /v1/responses compatibility and collapse placeholder account

app/config.py

@@ -44,8 +44,12 @@ def _merge_env_secrets(config: dict) -> dict:
             if not isinstance(account, dict):
                 continue
             current_identity = account.get("email") or account.get("mobile")
-            if current_identity == desired_identity:
-                updated = dict(account)
+            if current_identity in {desired_identity, ACCOUNT_PLACEHOLDER}:
+                updated = {
+                    k: v
+                    for k, v in account.items()
+                    if k not in {"email", "mobile", "password", "token", "hif_dliq", "hif_leim"}
+                }
                 updated[identity_key] = desired_identity
                 updated["password"] = env_account["password"]
                 merged_accounts.append(updated)

app/routes.py

@@ -1,12 +1,15 @@
 import json
 import logging
+import os
 import queue
 import re
 import threading
 import time
+from uuid import uuid4
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse, StreamingResponse
+from curl_cffi import requests as curl_requests
 
 from . import chat, config, constants, session as session_module
 from .account import (
@@ -89,6 +92,199 @@ def list_models():
     return JSONResponse(content=data, status_code=200)
 
 
+def _responses_input_to_messages(req_data: dict) -> list[dict]:
+    messages = []
+
+    instructions = req_data.get("instructions")
+    if instructions:
+        messages.append({"role": "system", "content": str(instructions)})
+
+    def append_message(role: str, content):
+        if content is None:
+            return
+        if isinstance(content, list):
+            text_parts = []
+            for item in content:
+                if isinstance(item, str):
+                    text_parts.append(item)
+                elif isinstance(item, dict):
+                    if item.get("type") in {"input_text", "output_text", "text"}:
+                        text = item.get("text") or item.get("content")
+                        if text:
+                            text_parts.append(str(text))
+            content = "\n".join(text_parts)
+        elif isinstance(content, dict):
+            content = json.dumps(content, ensure_ascii=False)
+        else:
+            content = str(content)
+        if content:
+            messages.append({"role": role or "user", "content": content})
+
+    input_data = req_data.get("input")
+    if isinstance(input_data, str):
+        append_message("user", input_data)
+    elif isinstance(input_data, dict):
+        if "role" in input_data:
+            append_message(input_data.get("role", "user"), input_data.get("content") or input_data.get("text"))
+        else:
+            append_message("user", input_data)
+    elif isinstance(input_data, list):
+        for item in input_data:
+            if isinstance(item, str):
+                append_message("user", item)
+            elif isinstance(item, dict):
+                if item.get("type") == "message":
+                    append_message(item.get("role", "user"), item.get("content"))
+                elif item.get("type") in {"input_text", "text"}:
+                    append_message("user", item.get("text") or item.get("content"))
+                elif "role" in item:
+                    append_message(item.get("role", "user"), item.get("content") or item.get("text"))
+                else:
+                    append_message("user", item)
+
+    return messages
+
+
+def _responses_tools_to_chat_tools(tools) -> list[dict]:
+    chat_tools = []
+    for tool in tools or []:
+        if not isinstance(tool, dict):
+            continue
+        if tool.get("type") != "function":
+            continue
+        if isinstance(tool.get("function"), dict):
+            chat_tools.append(tool)
+            continue
+        chat_tools.append(
+            {
+                "type": "function",
+                "function": {
+                    "name": tool.get("name"),
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get("parameters") or tool.get("input_schema") or {},
+                },
+            }
+        )
+    return chat_tools
+
+
+def _call_local_chat_completions(chat_body: dict, auth_header: str, x_api_key: str):
+    local_port = os.getenv("PORT", "7860")
+    headers = {"Content-Type": "application/json"}
+    if auth_header:
+        headers["Authorization"] = auth_header
+    if x_api_key:
+        headers["x-api-key"] = x_api_key
+    resp = curl_requests.post(
+        f"http://127.0.0.1:{local_port}/v1/chat/completions",
+        headers=headers,
+        json=chat_body,
+        impersonate="safari15_3",
+        timeout=180,
+    )
+    try:
+        payload = resp.json()
+    except Exception:
+        payload = {"error": resp.text}
+    return resp.status_code, payload
+
+
+def _chat_completion_to_response_payload(chat_payload: dict) -> dict:
+    choice = ((chat_payload.get("choices") or [{}])[0])
+    message = choice.get("message") or {}
+    text = message.get("content", "") or ""
+    tool_calls = message.get("tool_calls") or []
+    output = []
+
+    if text or not tool_calls:
+        output.append(
+            {
+                "id": f"msg_{uuid4().hex}",
+                "type": "message",
+                "status": "completed",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": text, "annotations": []}],
+            }
+        )
+
+    for tool_call in tool_calls:
+        function = tool_call.get("function") or {}
+        output.append(
+            {
+                "id": tool_call.get("id") or f"fc_{uuid4().hex}",
+                "type": "function_call",
+                "call_id": tool_call.get("id") or f"call_{uuid4().hex}",
+                "name": function.get("name", ""),
+                "arguments": function.get("arguments", "{}"),
+                "status": "completed",
+            }
+        )
+
+    usage = chat_payload.get("usage") or {}
+    return {
+        "id": f"resp_{chat_payload.get('id', uuid4().hex)}",
+        "object": "response",
+        "created": chat_payload.get("created", int(time.time())),
+        "status": "completed",
+        "model": chat_payload.get("model"),
+        "output": output,
+        "output_text": text,
+        "parallel_tool_calls": bool(tool_calls),
+        "usage": {
+            "input_tokens": usage.get("prompt_tokens", 0),
+            "output_tokens": usage.get("completion_tokens", 0),
+            "total_tokens": usage.get("total_tokens", 0),
+        },
+    }
+
+
+@router.post("/v1/responses")
+async def responses_api(request: Request):
+    try:
+        req_data = await request.json()
+        if bool(req_data.get("stream", False)):
+            return JSONResponse(
+                status_code=400,
+                content={"error": "/v1/responses streaming is not supported yet. Use /v1/chat/completions with stream=true."},
+            )
+
+        model = req_data.get("model")
+        messages = _responses_input_to_messages(req_data)
+        if not model or not messages:
+            return JSONResponse(
+                status_code=400,
+                content={"error": "Request must include 'model' and a non-empty 'input'."},
+            )
+
+        chat_body = {
+            "model": model,
+            "messages": messages,
+            "stream": False,
+        }
+        if "tools" in req_data:
+            chat_body["tools"] = _responses_tools_to_chat_tools(req_data.get("tools"))
+        if "tool_choice" in req_data:
+            chat_body["tool_choice"] = req_data.get("tool_choice")
+        if "temperature" in req_data:
+            chat_body["temperature"] = req_data.get("temperature")
+        if "top_p" in req_data:
+            chat_body["top_p"] = req_data.get("top_p")
+
+        status_code, chat_payload = await __import__("asyncio").to_thread(
+            _call_local_chat_completions,
+            chat_body,
+            request.headers.get("Authorization", ""),
+            request.headers.get("x-api-key", ""),
+        )
+        if status_code != 200:
+            return JSONResponse(status_code=status_code, content=chat_payload if isinstance(chat_payload, dict) else {"error": str(chat_payload)})
+
+        return JSONResponse(content=_chat_completion_to_response_payload(chat_payload), status_code=200)
+    except Exception as exc:
+        logger.error(f"[responses_api] 未知异常: {exc}")
+        return JSONResponse(status_code=500, content={"error": "Internal Server Error"})
+
+
 # ----------------------------------------------------------------------
 # 路由：/v1/chat/completions
 # ----------------------------------------------------------------------