更新前端看板

backend/app/api/v1/endpoints/platform.py

@@ -15,7 +15,7 @@ from app.core.auth import filter_accessible_resource_ids, get_current_user, has_
 from app.core.config import get_settings
 from app.db.platform_store import get_platform_store
 from app.modules.compute_gateway.client import ComputeNodeClient
-from app.modules.compute_gateway.sync import poll_compute_jobs_once
+from app.modules.compute_gateway.sync import fetch_eval_result_content, poll_compute_jobs_once
 
 router = APIRouter()
 
@@ -33,6 +33,62 @@ def _select_first_online_node(store: Any) -> dict[str, Any] | None:
     return None
 
 
+def _build_messages_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    """Convert frontend inference payload to compute API messages format.
+
+    Accepts both:
+      - OpenAI-style: {messages: [{role, content}, ...], temperature, ...}
+      - Frontend-style: {user_question, system_prompt, temperature, ...}
+    """
+    if payload.get("messages"):
+        messages = payload["messages"]
+        # messages already in OpenAI format; pass through with optional system prompt
+        if payload.get("system_prompt") and not any(m.get("role") == "system" for m in messages):
+            messages = [{"role": "system", "content": payload["system_prompt"]}] + list(messages)
+    else:
+        messages = []
+        if payload.get("system_prompt"):
+            messages.append({"role": "system", "content": payload["system_prompt"]})
+        question = payload.get("user_question") or payload.get("question") or ""
+        if question:
+            messages.append({"role": "user", "content": question})
+    return {
+        "messages": messages,
+        "temperature": float(payload.get("temperature", 0.7)),
+        "top_p": float(payload.get("top_p", 0.95)),
+        "max_new_tokens": int(payload.get("max_tokens", 2048)),
+        "do_sample": bool(payload.get("do_sample", True)),
+    }
+
+
+async def _stream_chat_proxy(payload: dict[str, Any]) -> StreamingResponse:
+    """Common SSE streaming proxy: convert payload → forward to compute node → stream back."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return StreamingResponse(
+            iter(['data: {"error": "no online compute node available for inference"}\n\n']),
+            media_type="text/event-stream",
+        )
+    client = ComputeNodeClient(node["api_base_url"])
+    compute_payload = _build_messages_payload(payload)
+
+    async def stream_proxy():
+        async with httpx.AsyncClient(timeout=300) as http:
+            url = f"{node['api_base_url'].rstrip('/')}{client.route_prefix}/inference/chat/stream"
+            try:
+                async with http.stream("POST", url, json=compute_payload, headers=client.headers()) as resp:
+                    if resp.status_code >= 400:
+                        yield f'data: {{"error": "compute node returned {resp.status_code}"}}\n\n'.encode()
+                        return
+                    async for chunk in resp.aiter_bytes():
+                        yield chunk
+            except Exception as exc:
+                yield f'data: {{"error": "stream proxy failed: {exc}"}}\n\n'.encode()
+
+    return StreamingResponse(stream_proxy(), media_type="text/event-stream")
+
+
 def fail(status_code: int, message: str) -> HTTPException:
     return HTTPException(status_code=status_code, detail={"code": status_code, "message": message, "data": None})
 
@@ -856,6 +912,7 @@ async def upload_dataset_files(
 ) -> dict[str, Any]:
     created: list[dict[str, Any]] = []
     compute_sync: list[dict[str, Any]] = []
+    pending_sync: list[tuple[str, str, bytes]] = []
     store = get_platform_store()
     try:
         store.dataset(dataset_id)
@@ -867,16 +924,18 @@ async def upload_dataset_files(
             content = raw.decode("utf-8", errors="replace")
             created_file = store.add_dataset_file(conn, dataset_id, file.filename or "upload.jsonl", content)
             created.append(created_file)
-            if sync_to_compute:
-                compute_sync.extend(
-                    await _sync_dataset_file_to_compute_nodes(
-                        store,
-                        dataset_id,
-                        created_file["id"],
-                        created_file["name"],
-                        raw,
-                    )
+            pending_sync.append((created_file["id"], created_file["name"], raw))
+    if sync_to_compute:
+        for file_id, file_name, raw in pending_sync:
+            compute_sync.extend(
+                await _sync_dataset_file_to_compute_nodes(
+                    store,
+                    dataset_id,
+                    file_id,
+                    file_name,
+                    raw,
                 )
+            )
     return ok({"files": created, "compute_sync": compute_sync})
 
 
@@ -1212,7 +1271,23 @@ async def model_eval_list(current_user: dict = Depends(get_current_user)) -> dic
 @router.get("/model-eval/{task_id}")
 async def model_eval_detail(task_id: str, current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     try:
-        task = get_platform_store().eval_task(task_id)
+        store = get_platform_store()
+        task = store.eval_task(task_id)
+        if task.get("compute_job_id") and task.get("compute_node_id") and task.get("status") in {"queued", "running", "completed"}:
+            node = next(
+                (n for n in store.compute_nodes() if n["id"] == task.get("compute_node_id")),
+                None,
+            )
+            if node:
+                try:
+                    client = ComputeNodeClient(node["api_base_url"])
+                    job = await client.get_job(task["compute_job_id"])
+                    result_content = None
+                    if job.get("status") == "completed" and not task.get("samples"):
+                        result_content = await fetch_eval_result_content(client, node, job)
+                    task = store.apply_eval_job_result(task_id, job, result_content)
+                except Exception:
+                    pass
     except KeyError:
         raise fail(404, "eval task not found")
     if not has_resource_access("eval", task_id, current_user, "read"):
@@ -1222,8 +1297,149 @@ async def model_eval_detail(task_id: str, current_user: dict = Depends(get_curre
 
 @router.post("/model-eval/start")
 async def model_eval_start(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
-    task = get_platform_store().create_eval_task(payload)
-    return ok({"task_id": task["id"], **task})
+    """Start an evaluation task: submit eval job to compute node."""
+    store = get_platform_store()
+    # 1. Create eval task record
+    task = store.create_eval_task({**payload, "status": "pending"})
+
+    # 2. Resolve model path (supports both regular models and trained models)
+    model_id = str(payload.get("model_id", ""))
+    model_path = ""
+    adapter_path = payload.get("adapter_path", "")
+    try:
+        db_model = store.model(model_id)
+        model_path = db_model.get("path", "")
+    except KeyError:
+        # Try trained_models table (IDs prefixed with tm_)
+        trained = next((m for m in store.trained_models() if m["id"] == model_id), None)
+        if trained:
+            merged_path = trained.get("merged_path", "")
+            base_path = trained.get("base_model_path", "")
+            if trained.get("merged") and merged_path:
+                # Merged model: use merged_path as model, no adapter needed
+                model_path = merged_path
+            elif base_path:
+                # Unmerged: use base model + adapter checkpoint
+                model_path = base_path
+                if merged_path:
+                    adapter_path = merged_path
+            else:
+                model_path = merged_path or base_path
+    if not model_path:
+        store.update_eval_task(task["id"], {"status": "failed", "error": "model not found or no path"})
+        return ok({"task_id": task["id"], "status": "failed", "error": "model not found or no path"})
+
+    # 3. Resolve dataset file
+    dataset_id = str(payload.get("dataset_id", ""))
+    dataset_path = ""
+    try:
+        ds_files = store.training_dataset_files(dataset_id)
+        if ds_files:
+            dataset_path = ds_files[0].get("local_path") or ds_files[0].get("name", "")
+    except Exception:
+        pass
+    if not dataset_path:
+        # Try to get file content and sync to compute
+        try:
+            ds = store.dataset(dataset_id)
+            for f in ds.get("files", []):
+                if f.get("content"):
+                    dataset_path = f.get("name", f"dataset_{dataset_id}.jsonl")
+                    break
+        except KeyError:
+            pass
+    if not dataset_path:
+        store.update_eval_task(task["id"], {"status": "failed", "error": "dataset not found or no files"})
+        return ok({"task_id": task["id"], "status": "failed", "error": "dataset not found or no files"})
+
+    # 4. Resolve dimension config
+    dimension_id = str(payload.get("dimension_id", ""))
+    dimension_cfg: dict[str, Any] = {}
+    if dimension_id:
+        try:
+            dim = store.dimension(dimension_id)
+            # Resolve eval model API config
+            eval_model_name = dim.get("eval_model", "")
+            api_url = ""
+            api_key = ""
+            if eval_model_name:
+                try:
+                    eval_model = store.model(eval_model_name) if eval_model_name.startswith("m_") else store.model_by_name(eval_model_name)
+                    api_url = eval_model.get("api_url", "")
+                    api_key = eval_model.get("api_key", "")
+                except (KeyError, Exception):
+                    pass
+            dimension_cfg = {
+                "type": dim.get("type", ""),
+                "eval_model": eval_model_name,
+                "eval_method": dim.get("eval_method", ""),
+                "eval_prompt": dim.get("eval_prompt", ""),
+                "api_url": api_url,
+                "api_key": api_key,
+                "score_min": dim.get("score_min", 0),
+                "score_max": dim.get("score_max", 5),
+                "pass_threshold": dim.get("pass_threshold", 3),
+            }
+        except KeyError:
+            pass
+
+    # 5. Select compute node
+    node = _select_first_online_node(store)
+    if not node:
+        store.update_eval_task(task["id"], {"status": "failed", "error": "no online compute node"})
+        return ok({"task_id": task["id"], "status": "failed", "error": "no online compute node"})
+
+    # 6. Build eval job payload
+    output_dir = f"/data/yg-ft/outputs/{task['id']}"
+    job_payload = {
+        "id": f"eval_{task['id']}",
+        "name": task.get("eval_task_name", task["id"]),
+        "engine": "eval",
+        "model_name_or_path": model_path,
+        "adapter_name_or_path": adapter_path,
+        "template": payload.get("template", "qwen"),
+        "dataset_path": dataset_path,
+        "output_dir": output_dir,
+        "basic_metrics": payload.get("basic_metrics", {}),
+        "dimension": dimension_cfg,
+        "gpus": [int(payload.get("gpu_id", 0))],
+        "temperature": payload.get("temperature", 0.1),
+        "max_new_tokens": payload.get("max_new_tokens", 512),
+        "compute_node_id": node["id"],
+    }
+
+    # 7. Submit to compute node via create_job (uses engine="eval" path)
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        # Sync dataset file to compute node if needed
+        if not dataset_path.startswith("/"):
+            try:
+                ds_files = store.training_dataset_files(dataset_id)
+                if ds_files and ds_files[0].get("content"):
+                    upload_result = await client.upload_file(
+                        ds_files[0].get("name", "eval_data.jsonl"),
+                        ds_files[0]["content"].encode("utf-8"),
+                        f"datasets/{dataset_id}/{ds_files[0].get('name', 'eval_data.jsonl')}",
+                        resource_type="dataset",
+                        resource_id=dataset_id,
+                    )
+                    job_payload["dataset_path"] = upload_result.get("local_path", dataset_path)
+            except Exception:
+                pass
+
+        job = await client.create_job(job_payload)
+        store.update_eval_task(task["id"], {
+            "status": "running",
+            "compute_job_id": job.get("id"),
+            "compute_node_id": node["id"],
+            "output_dir": output_dir,
+        })
+        if job.get("status") in {"queued", "running"}:
+            store.mark_inference_loaded(node["id"])
+        return ok({"task_id": task["id"], "status": "running", "job": job})
+    except Exception as exc:
+        store.update_eval_task(task["id"], {"status": "failed", "error": str(exc)})
+        return ok({"task_id": task["id"], "status": "failed", "error": str(exc)})
 
 
 @router.delete("/model-eval/{task_id}")
@@ -1298,8 +1514,27 @@ async def model_compare_detail(task_id: str) -> dict[str, Any]:
         raise fail(404, "compare task not found")
 
 
+async def _unload_from_compute_node() -> dict[str, Any]:
+    """Best-effort unload the inference model from the first online compute node."""
+    store = get_platform_store()
+    # Clear all inference tracking — only one model can be loaded at a time
+    for node in store.compute_nodes():
+        store.mark_inference_unloaded(node["id"])
+    node = _select_first_online_node(store)
+    if not node:
+        return {"unloaded": False, "error": "no online compute node"}
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        result = await client._request("POST", "/inference/unload", json_data={})
+        return result
+    except Exception as exc:
+        return {"unloaded": False, "error": str(exc)}
+
+
 @router.delete("/model-compare/{task_id}")
 async def model_compare_delete(task_id: str) -> dict[str, Any]:
+    # 删除前先释放算力节点上的模型
+    await _unload_from_compute_node()
     get_platform_store().delete_compare_task(task_id)
     return ok({"deleted": task_id})
 
@@ -1329,26 +1564,56 @@ async def model_compare_update_load_status(task_id: str, payload: dict[str, Any]
 
 @router.post("/model-compare/{task_id}/load")
 async def model_compare_load(task_id: str) -> dict[str, Any]:
+    """真正加载模型到算力节点（不再使用假 PID/端口）。"""
     try:
-        task = get_platform_store().compare_task(task_id)
+        store = get_platform_store()
+        task = store.compare_task(task_id)
         models = task.get("models") or []
         if isinstance(models, str):
             try:
                 models = json.loads(models)
             except json.JSONDecodeError:
                 models = []
-        loaded_models = [
-            {
-                "model_id": item.get("model_id"),
-                "model_name": item.get("model_name"),
-                "status": "ready",
-                "pid": 45000 + index,
-                "port": item.get("port") or 18000 + index,
+        # 选取在线算力节点
+        node = _select_first_online_node(store)
+        if not node:
+            return ok({"status": "failed", "error": "no online compute node"})
+        client = ComputeNodeClient(node["api_base_url"])
+        loaded_models = []
+        for item in models:
+            if not isinstance(item, dict):
+                continue
+            model_path = item.get("model_path", "")
+            if not model_path:
+                # 尝试从模型库获取路径
+                model_id = item.get("model_id", "")
+                try:
+                    db_model = store.model(model_id)
+                    model_path = db_model.get("path", "")
+                except KeyError:
+                    pass
+            if not model_path:
+                loaded_models.append({**item, "status": "error", "error": "model_path not found"})
+                continue
+            # 真正调用算力节点加载模型
+            load_payload = {
+                "model_name_or_path": model_path,
+                "template": item.get("template", "qwen"),
             }
-            for index, item in enumerate(models)
-            if isinstance(item, dict)
-        ]
-        return ok(get_platform_store().update_compare_task(task_id, {"status": "loaded", "load_status": {"loaded_models": loaded_models}}))
+            if item.get("adapter_path"):
+                load_payload["adapter_name_or_path"] = item["adapter_path"]
+            try:
+                result = await client._request("POST", "/inference/load", json_data=load_payload)
+                if result.get("loaded"):
+                    store.mark_inference_loaded(node["id"])
+                    loaded_models.append({**item, "status": "ready"})
+                else:
+                    loaded_models.append({**item, "status": "error", "error": result.get("error", "load failed")})
+            except Exception as exc:
+                loaded_models.append({**item, "status": "error", "error": str(exc)})
+        status = "loaded" if any(m.get("status") == "ready" for m in loaded_models) else "failed"
+        updated = store.update_compare_task(task_id, {"status": status, "load_status": {"loaded_models": loaded_models}})
+        return ok(updated)
     except KeyError:
         raise fail(404, "compare task not found")
 
@@ -1356,7 +1621,11 @@ async def model_compare_load(task_id: str) -> dict[str, Any]:
 @router.post("/model-compare/{task_id}/unload")
 async def model_compare_unload(task_id: str) -> dict[str, Any]:
     try:
-        return ok(get_platform_store().update_compare_task(task_id, {"status": "pending", "load_status": {"loaded_models": []}}))
+        store = get_platform_store()
+        # 真正释放算力节点上的模型资源
+        unload_result = await _unload_from_compute_node()
+        updated = store.update_compare_task(task_id, {"status": "pending", "load_status": {"loaded_models": []}})
+        return ok({"task": updated, "unload": unload_result})
     except KeyError:
         raise fail(404, "compare task not found")
 
@@ -1368,18 +1637,23 @@ async def model_compare_start_model(task_id: str, payload: dict[str, Any] = Body
 
 @router.post("/model-compare/chat-with-port")
 async def model_compare_chat_with_port(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
-    question = ""
-    for message in payload.get("messages") or []:
-        if message.get("role") == "user":
-            question = str(message.get("content") or "")
-    content = f"当前后端已收到推理请求：{question[:120]}"
-    return ok({"response": content, "content": content})
+    """Proxy non-streaming chat to the compute node running the inference model."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return ok({"response": "no online compute node available for inference", "request": payload})
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        result = await client._request("POST", "/inference/chat", json_data=_build_messages_payload(payload))
+        return ok(result)
+    except Exception as exc:
+        return ok({"response": f"inference failed: {exc}", "request": payload})
 
 
 @router.post("/model-compare/stream-chat")
-async def model_compare_stream_chat(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
-    question = payload.get("user_question") or payload.get("question") or ""
-    return ok({"response": f"当前后端已收到流式推理请求：{str(question)[:120]}"})
+async def model_compare_stream_chat(payload: dict[str, Any] = Body(...)) -> StreamingResponse:
+    """Stream chat from the compute node (SSE proxy)."""
+    return await _stream_chat_proxy(payload)
 
 
 @router.post("/model-chat/batch")
@@ -1396,7 +1670,7 @@ async def model_chat_local(payload: dict[str, Any] = Body(...)) -> dict[str, Any
         return ok({"response": "no online compute node available for inference", "request": payload})
     try:
         client = ComputeNodeClient(node["api_base_url"])
-        result = await client._request("POST", "/inference/chat", json_data=payload)
+        result = await client._request("POST", "/inference/chat", json_data=_build_messages_payload(payload))
         return ok(result)
     except Exception as exc:
         return ok({"response": f"inference failed: {exc}", "request": payload})
@@ -1405,28 +1679,15 @@ async def model_chat_local(payload: dict[str, Any] = Body(...)) -> dict[str, Any
 @router.post("/model-chat/local/chat/stream")
 async def model_chat_local_stream(payload: dict[str, Any] = Body(...)) -> StreamingResponse:
     """Stream chat from the compute node."""
-    store = get_platform_store()
-    node = _select_first_online_node(store)
-    if not node:
-        return StreamingResponse(
-            iter(['data: {"error": "no online compute node"}\n\n']),
-            media_type="text/event-stream",
-        )
-    client = ComputeNodeClient(node["api_base_url"])
-
-    async def stream_proxy():
-        async with httpx.AsyncClient(timeout=300) as http:
-            url = f"{node['api_base_url'].rstrip('/')}/modelTF/inference/chat/stream"
-            async with http.stream("POST", url, json=payload, headers=client.headers()) as resp:
-                async for chunk in resp.aiter_bytes():
-                    yield chunk
-
-    return StreamingResponse(stream_proxy(), media_type="text/event-stream")
+    return await _stream_chat_proxy(payload)
 
 
 @router.post("/model-chat/local/preload")
 async def model_chat_local_preload(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     """Load a model on the compute node for inference."""
+    model_path = (payload.get("model_name_or_path") or "").strip()
+    if not model_path:
+        return ok({"loaded": False, "error": "model_name_or_path is required"})
     store = get_platform_store()
     node = _select_first_online_node(store)
     if not node:
@@ -1434,6 +1695,8 @@ async def model_chat_local_preload(payload: dict[str, Any] = Body(...)) -> dict[
     try:
         client = ComputeNodeClient(node["api_base_url"])
         result = await client._request("POST", "/inference/load", json_data=payload)
+        if result.get("loaded"):
+            store.mark_inference_loaded(node["id"])
         return ok(result)
     except Exception as exc:
         return ok({"loaded": False, "error": str(exc)})
@@ -1443,6 +1706,9 @@ async def model_chat_local_preload(payload: dict[str, Any] = Body(...)) -> dict[
 async def model_chat_local_unload() -> dict[str, Any]:
     """Unload the inference model from the compute node."""
     store = get_platform_store()
+    # Clear all inference tracking
+    for n in store.compute_nodes():
+        store.mark_inference_unloaded(n["id"])
     node = _select_first_online_node(store)
     if not node:
         return ok({"unloaded": False, "error": "no online compute node"})
@@ -1472,6 +1738,9 @@ async def model_chat_local_status() -> dict[str, Any]:
 @router.post("/model-chat/trained/preload")
 async def model_chat_trained_preload(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     """Load a trained model (base + adapter) on the compute node for inference."""
+    model_path = (payload.get("model_name_or_path") or "").strip()
+    if not model_path:
+        return ok({"loaded": False, "error": "model_name_or_path is required"})
     store = get_platform_store()
     node = _select_first_online_node(store)
     if not node:
@@ -1479,6 +1748,8 @@ async def model_chat_trained_preload(payload: dict[str, Any] = Body(...)) -> dic
     try:
         client = ComputeNodeClient(node["api_base_url"])
         result = await client._request("POST", "/inference/load", json_data=payload)
+        if result.get("loaded"):
+            store.mark_inference_loaded(node["id"])
         return ok(result)
     except Exception as exc:
         return ok({"loaded": False, "error": str(exc)})
@@ -1517,6 +1788,16 @@ async def update_compute_node(node_id: str, payload: dict[str, Any] = Body(...))
         raise fail(400, str(exc))
 
 
+@router.delete("/compute/nodes/{node_id}")
+async def delete_compute_node(node_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().delete_compute_node(node_id))
+    except KeyError:
+        raise fail(404, "compute node not found")
+    except ValueError as exc:
+        raise fail(400, str(exc))
+
+
 @router.post("/compute/nodes/{node_id}/test-connection")
 async def test_compute_node(node_id: str) -> dict[str, Any]:
     store = get_platform_store()