添加预加载，添加流式传输，添加真实模型，添加提示词约束

Author: yang

.env.example

@@ -2,11 +2,11 @@ ADMIN_KEY=change-me-now
 PORT=7860
 WORKERS=1
 LOG_LEVEL=INFO
-MAX_INFLIGHT=1
+MAX_INFLIGHT=2
 MAX_RETRIES=3
-ACCOUNT_MIN_INTERVAL_MS=1200
-REQUEST_JITTER_MIN_MS=120
-REQUEST_JITTER_MAX_MS=360
+ACCOUNT_MIN_INTERVAL_MS=0
+REQUEST_JITTER_MIN_MS=0
+REQUEST_JITTER_MAX_MS=0
 RATE_LIMIT_BASE_COOLDOWN=600
 RATE_LIMIT_MAX_COOLDOWN=3600
 ACCOUNTS_FILE=/workspace/data/accounts.json

README.md

@@ -0,0 +1,258 @@
+"""
+CLIProxy - 协议转换代理层
+统一处理 OpenAI/Claude/Gemini 协议到 StandardRequest 的转换
+"""
+import logging
+from typing import Any
+
+from backend.adapter.standard_request import StandardRequest, CLAUDE_CODE_OPENAI_PROFILE
+from backend.core.config import resolve_model
+from backend.services.prompt_builder import messages_to_prompt
+from backend.toolcall.normalize import build_tool_name_registry
+
+log = logging.getLogger("qwen2api.cli_proxy")
+
+
+class CLIProxy:
+    """
+    协议转换代理 - 类似 ds2api 的 CLIProxy
+    负责将不同协议（OpenAI/Claude/Gemini）转换为统一的 StandardRequest
+    """
+
+    @staticmethod
+    def from_openai(req_data: dict, *, client_profile: str = CLAUDE_CODE_OPENAI_PROFILE) -> StandardRequest:
+        """
+        OpenAI 协议 -> StandardRequest
+
+        Args:
+            req_data: OpenAI 格式的请求体
+            client_profile: 客户端配置文件
+
+        Returns:
+            StandardRequest: 统一的标准请求对象
+        """
+        model_name = req_data.get("model", "gpt-4o")
+        prompt_result = messages_to_prompt(req_data, client_profile=client_profile)
+
+        tools = prompt_result.tools
+        tool_names = [
+            tool_name
+            for tool_name in (tool.get("name") for tool in tools)
+            if isinstance(tool_name, str) and tool_name
+        ]
+
+        return StandardRequest(
+            prompt=prompt_result.prompt,
+            response_model=model_name,
+            resolved_model=resolve_model(model_name),
+            surface="openai",
+            client_profile=client_profile,
+            requested_model=model_name,
+            stream=req_data.get("stream", False),
+            tools=tools,
+            tool_names=tool_names,
+            tool_name_registry=build_tool_name_registry(tool_names),
+            tool_enabled=prompt_result.tool_enabled,
+        )
+
+    @staticmethod
+    def from_anthropic(req_data: dict, *, client_profile: str = CLAUDE_CODE_OPENAI_PROFILE) -> StandardRequest:
+        """
+        Anthropic Claude 协议 -> StandardRequest
+
+        Args:
+            req_data: Claude 格式的请求体
+            client_profile: 客户端配置文件
+
+        Returns:
+            StandardRequest: 统一的标准请求对象
+        """
+        model_name = req_data.get("model", "claude-3-5-sonnet")
+        prompt_result = messages_to_prompt(req_data, client_profile=client_profile)
+
+        tools = prompt_result.tools
+        tool_names = [
+            tool_name
+            for tool_name in (tool.get("name") for tool in tools)
+            if isinstance(tool_name, str) and tool_name
+        ]
+
+        return StandardRequest(
+            prompt=prompt_result.prompt,
+            response_model=model_name,
+            resolved_model=resolve_model(model_name),
+            surface="anthropic",
+            client_profile=client_profile,
+            requested_model=model_name,
+            stream=req_data.get("stream", False),
+            tools=tools,
+            tool_names=tool_names,
+            tool_name_registry=build_tool_name_registry(tool_names),
+            tool_enabled=prompt_result.tool_enabled,
+        )
+
+    @staticmethod
+    def from_gemini(model: str, req_data: dict, *, stream: bool | None = None) -> StandardRequest:
+        """
+        Google Gemini 协议 -> StandardRequest
+
+        Args:
+            model: Gemini 模型名称
+            req_data: Gemini 格式的请求体
+            stream: 是否流式输出（None 则从请求体推断）
+
+        Returns:
+            StandardRequest: 统一的标准请求对象
+        """
+        prompt = CLIProxy._extract_gemini_prompt(req_data)
+        stream_requested = CLIProxy._is_gemini_stream_request(req_data) if stream is None else stream
+
+        # Gemini 暂不支持工具调用，后续可扩展
+        tools = []
+        tool_names = []
+
+        return StandardRequest(
+            prompt=prompt,
+            response_model=model,
+            resolved_model=resolve_model(model),
+            surface="gemini",
+            requested_model=model,
+            content=prompt,
+            stream=stream_requested,
+            tools=tools,
+            tool_names=tool_names,
+            tool_name_registry={},
+            tool_enabled=False,
+        )
+
+    @staticmethod
+    def _extract_gemini_prompt(body: dict) -> str:
+        """从 Gemini 请求体中提取 prompt"""
+        lines: list[str] = []
+        for message in body.get("contents", []) or []:
+            if message.get("role") != "user":
+                continue
+            for part in message.get("parts", []) or []:
+                text = part.get("text")
+                if text:
+                    lines.append(text)
+        return "\n".join(lines)
+
+    @staticmethod
+    def _is_gemini_stream_request(body: dict[str, Any]) -> bool:
+        """判断 Gemini 请求是否为流式"""
+        if body.get("stream") is True:
+            return True
+        generation_config = body.get("generationConfig")
+        if isinstance(generation_config, dict) and generation_config.get("stream") is True:
+            return True
+        return False
+
+    @staticmethod
+    def to_openai_response(execution, standard_request: StandardRequest) -> dict:
+        """
+        StandardRequest 执行结果 -> OpenAI 响应格式
+
+        Args:
+            execution: 执行结果对象
+            standard_request: 原始标准请求
+
+        Returns:
+            dict: OpenAI 格式的响应
+        """
+        return {
+            "id": f"chatcmpl-{execution.chat_id[:12]}",
+            "object": "chat.completion",
+            "created": int(execution.state.created_at or 0),
+            "model": standard_request.response_model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": execution.state.answer_text,
+                    },
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": len(standard_request.prompt),
+                "completion_tokens": len(execution.state.answer_text),
+                "total_tokens": len(standard_request.prompt) + len(execution.state.answer_text),
+            },
+        }
+
+    @staticmethod
+    def to_anthropic_response(execution, standard_request: StandardRequest, msg_id: str, directive) -> dict:
+        """
+        StandardRequest 执行结果 -> Anthropic Claude 响应格式
+
+        Args:
+            execution: 执行结果对象
+            standard_request: 原始标准请求
+            msg_id: 消息 ID
+            directive: 工具调用指令
+
+        Returns:
+            dict: Claude 格式的响应
+        """
+        content_blocks: list[dict] = []
+
+        # 添加思考内容
+        if execution.state.reasoning_text:
+            content_blocks.append({"type": "thinking", "thinking": execution.state.reasoning_text})
+
+        # 添加工具调用块
+        content_blocks.extend(directive.tool_blocks)
+
+        return {
+            "id": msg_id,
+            "type": "message",
+            "role": "assistant",
+            "model": standard_request.response_model,
+            "content": content_blocks,
+            "stop_reason": directive.stop_reason,
+            "stop_sequence": None,
+            "usage": {
+                "input_tokens": len(standard_request.prompt),
+                "output_tokens": len(execution.state.answer_text),
+            },
+        }
+
+    @staticmethod
+    def to_gemini_response(execution, standard_request: StandardRequest) -> dict:
+        """
+        StandardRequest 执行结果 -> Google Gemini 响应格式
+
+        Args:
+            execution: 执行结果对象
+            standard_request: 原始标准请求
+
+        Returns:
+            dict: Gemini 格式的响应
+        """
+        return {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [{"text": execution.state.answer_text}],
+                        "role": "model",
+                    },
+                    "finishReason": "STOP",
+                    "index": 0,
+                }
+            ],
+            "usageMetadata": {
+                "promptTokenCount": len(standard_request.prompt),
+                "candidatesTokenCount": len(execution.state.answer_text),
+                "totalTokenCount": len(standard_request.prompt) + len(execution.state.answer_text),
+            },
+        }
+
+    @staticmethod
+    def log_conversion(surface: str, model: str, prompt_len: int, tool_count: int):
+        """记录协议转换日志"""
+        log.info(
+            f"[CLIProxy] {surface.upper()} -> StandardRequest: "
+            f"model={model}, prompt_len={prompt_len}, tools={tool_count}"
+        )

backend/adapter/cli_proxy.py

@@ -33,8 +33,51 @@ class User(BaseModel):
 async def get_system_status(request: Request):
     pool = request.app.state.account_pool
 
+    # 账号层细粒度 inflight / 状态
+    per_account = []
+    for acc in getattr(pool, "accounts", []):
+        per_account.append({
+            "email": acc.email,
+            "status": acc.get_status_code(),
+            "inflight": getattr(acc, "inflight", 0),
+            "max_inflight": getattr(pool, "max_inflight_per_account", 0),
+            "consecutive_failures": getattr(acc, "consecutive_failures", 0),
+            "rate_limit_strikes": getattr(acc, "rate_limit_strikes", 0),
+            "last_request_finished": getattr(acc, "last_request_finished", 0),
+        })
+
+    # chat_id 预热池指标（若已启用）
+    chat_id_pool_stats = None
+    cp = getattr(request.app.state, "chat_id_pool", None)
+    if cp is not None:
+        try:
+            per_account_pool: dict[str, int] = {}
+            for acc in getattr(pool, "accounts", []):
+                per_account_pool[acc.email] = await cp.size(acc.email)
+            chat_id_pool_stats = {
+                "total_cached": await cp.total_size(),
+                "target_per_account": cp._target,
+                "ttl_seconds": cp._ttl,
+                "per_account": per_account_pool,
+            }
+        except Exception:
+            chat_id_pool_stats = {"error": "snapshot failed"}
+
+    # 向运行时拿全局任务计数 / asyncio 状态
+    import asyncio
+    try:
+        tasks = asyncio.all_tasks()
+        running_tasks = sum(1 for t in tasks if not t.done())
+    except Exception:
+        running_tasks = -1
+
     return {
         "accounts": pool.status(),
+        "per_account": per_account,
+        "chat_id_pool": chat_id_pool_stats,
+        "runtime": {
+            "asyncio_running_tasks": running_tasks,
+        },
         "request_runtime": {
             "mode": "direct_http",
             "browser_required_for_requests": False,
@@ -226,24 +269,50 @@ async def delete_account(email: str, request: Request):
     return {"ok": True}
 
 @router.get("/settings", dependencies=[Depends(verify_admin)])
-async def get_settings():
+async def get_settings(request: Request):
     from backend.core.config import MODEL_MAP
-    # 从 settings.py 所在的同级导入 VERSION，避免循环导入或未定义报错
     from backend.core.config import settings as backend_settings
 
-    # 强制将 dict 转换，确保能被 JSON 序列化
     safe_map = {k: v for k, v in MODEL_MAP.items()}
+    pool = getattr(request.app.state, "chat_id_pool", None)
+    acc_pool = getattr(request.app.state, "account_pool", None)
     return {
         "version": "2.0.0",
         "max_inflight_per_account": backend_settings.MAX_INFLIGHT_PER_ACCOUNT,
-        "model_aliases": safe_map
+        "global_max_inflight": getattr(acc_pool, "global_max_inflight", 0),
+        "max_queue_size": getattr(acc_pool, "max_queue_size", 0),
+        "chat_id_pool_target": pool.target if pool else 0,
+        "chat_id_pool_ttl_seconds": pool.ttl if pool else 0,
+        "model_aliases": safe_map,
     }
 
 @router.put("/settings", dependencies=[Depends(verify_admin)])
-async def update_settings(data: dict):
+async def update_settings(data: dict, request: Request):
     from backend.core.config import MODEL_MAP
     if "max_inflight_per_account" in data:
-        settings.MAX_INFLIGHT_PER_ACCOUNT = data["max_inflight_per_account"]
+        try:
+            val = int(data["max_inflight_per_account"])
+            settings.MAX_INFLIGHT_PER_ACCOUNT = val
+            pool = getattr(request.app.state, "account_pool", None)
+            if pool is not None and hasattr(pool, "set_max_inflight"):
+                pool.set_max_inflight(val)
+        except (TypeError, ValueError):
+            pass
+    if "global_max_inflight" in data:
+        try:
+            val = int(data["global_max_inflight"])
+            pool = getattr(request.app.state, "account_pool", None)
+            if pool is not None and val > 0:
+                pool.global_max_inflight = val
+        except (TypeError, ValueError):
+            pass
+    if "chat_id_pool_target" in data or "chat_id_pool_ttl_seconds" in data:
+        cp = getattr(request.app.state, "chat_id_pool", None)
+        if cp is not None:
+            cp.update_config(
+                target=data.get("chat_id_pool_target"),
+                ttl_seconds=data.get("chat_id_pool_ttl_seconds"),
+            )
     if "model_aliases" in data:
         MODEL_MAP.clear()
         MODEL_MAP.update(data["model_aliases"])