feat: 模型推理端到端闭环 — 真实流式推理 + 释放/删除 + GPU 状态同步

后端 (platform.py + platform_store.py):
- 新增 _build_messages_payload() 转换前端格式为 OpenAI messages
- 新增 _stream_chat_proxy() SSE 流式代理到算力节点
- 新增 _unload_from_compute_node() 真正释放算力节点 GPU 显存
- 重写 model_compare_load: 从假 PID/端口改为真正调用算力节点加载模型
- 修复 model_compare_unload: 调用 _unload_from_compute_node 释放 GPU
- 修复 model_compare_delete: 先释放 GPU 再删除记录
- 修复 model_compare_stream_chat: 从 mock 改为 StreamingResponse 代理
- 修复 model_chat_local/stream: 消息格式转换 + 路径修正
- PlatformStore 新增 _inference_nodes 追踪，gpus() 同步推理占用状态
- preload/unload 端点标记/清除推理节点占用

算力节点 (compute):
- inference.py: 适配新版 LLaMA-Factory API (get_infer_args 4 返回值、ChatModel args dict、stream_chat 新签名)
- inference.py: unload() 增加 gc.collect + torch.cuda.empty_cache + synchronize 彻底释放显存
- main.py: inference/load 移除 HTTPException(500)，错误以 200 正常返回

前端:
- InferenceChatView: 真实模式下走 SSE 流式推理，mock 模式保留兼容
- InferenceCreateView: 调用 preloadLocalModel + createCompare 真实创建推理任务，失败回退 mock
- InferenceListView: 「停止」改为「释放」，删除前先释放算力节点，改进错误提示
- compare.ts: 新增 streamChatReal() fetch SSE，preload 超时提升至 5 分钟
- useStreamChat.ts: send() 支持 useMock 参数，真实模式调用 streamChatReal
- GPU 选择过滤: 仅显示在线算力节点上的空闲 GPU

Co-Authored-By: Claude <noreply@anthropic.com>

frontend/src/api/modules/compare.ts

@@ -64,6 +64,27 @@ export const streamChat = async (data: any): Promise<any> => {
   }
 }
 
+/** 真实流式对话 — 使用 fetch 调用后端 SSE 端点，返回 Response 供 ReadableStream 消费 */
+export const streamChatReal = (data: any): Promise<Response> => {
+  const messages = data.messages || []
+  if (!messages.length && data.user_question) {
+    if (data.system_prompt) {
+      messages.push({ role: 'system', content: data.system_prompt })
+    }
+    messages.push({ role: 'user', content: data.user_question })
+  }
+  return fetch('/modelTF/model-compare/stream-chat', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages,
+      temperature: data.temperature ?? 0.7,
+      top_p: data.top_p ?? 0.95,
+      max_tokens: data.max_tokens ?? 2048,
+    }),
+  })
+}
+
 /** 非流式对话（按端口代理） */
 export const chatWithPort = (data: any) => post('/model-compare/chat-with-port', data)
 
@@ -73,8 +94,8 @@ export const batchChat = (data: any) => post('/model-chat/batch', data)
 /** 本地 transformers 模型对话 */
 export const localChat = (data: any) => post('/model-chat/local/chat', data)
 
-/** 预加载本地模型 */
-export const preloadLocalModel = (data: any) => post('/model-chat/local/preload', data)
+/** 预加载本地模型（模型加载耗时长，超时 5 分钟） */
+export const preloadLocalModel = (data: any) => post('/model-chat/local/preload', data, { timeout: 300000 })
 
-/** 预加载已训练模型 */
-export const preloadTrainedModel = (data: any) => post('/model-chat/trained/preload', data)
+/** 预加载已训练模型（超时 5 分钟） */
+export const preloadTrainedModel = (data: any) => post('/model-chat/trained/preload', data, { timeout: 300000 })

frontend/src/composables/useStreamChat.ts

@@ -1,5 +1,5 @@
 import { ref } from 'vue'
-import { streamChat } from '@/api/modules/compare'
+import { streamChat, streamChatReal } from '@/api/modules/compare'
 
 export interface StreamMessage {
   /** 用户问题 */
@@ -20,6 +20,11 @@ export interface StreamMessage {
   error?: string
 }
 
+export interface SendOptions {
+  /** 是否使用 mock 模式（默认 true，向后兼容） */
+  useMock?: boolean
+}
+
 /**
  * 流式对话 composable
  * 移植自原 model-chat.html：
@@ -65,8 +70,10 @@ export function useStreamChat() {
   /**
    * 发起流式对话
    * @param payload 后端请求体 { port, model_name, model_path, system_prompt, user_question, ... }
+   * @param options 可选配置 { useMock?: boolean }
    */
-  async function send(payload: any) {
+  async function send(payload: any, options?: SendOptions) {
+    const useMock = options?.useMock ?? true
     loading.value = true
     message.value = {
       question: payload.user_question || '',
@@ -82,7 +89,10 @@ export function useStreamChat() {
     const UPDATE_INTERVAL = 50 // 50ms 节流
 
     try {
-      const response = await streamChat(payload)
+      const response = useMock
+        ? await streamChat(payload)
+        : await streamChatReal(payload)
+
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}`)
       }

frontend/src/types/index.ts

@@ -361,10 +361,10 @@ export interface GpuInfo {
   processes?: GpuProcess[]
   fan_speed?: number
   clock_mhz?: number
-  driver_version?: string
   node_id?: string
   node_code?: string
   node_name?: string
+  driver_version?: string
 }
 
 export interface SystemInfo {

frontend/src/views/inference/InferenceChatView.vue

@@ -10,8 +10,8 @@ import type { CompareTask, LoadedModel } from '@/types'
 const route = useRoute()
 const router = useRouter()
 const taskId = route.params.id as string
-/** 是否为 mock 直通模式（新建推理假数据进入，不走真实任务接口） */
-const isMock = taskId === 'mock'
+/** 是否为 mock 模式（新建推理无真实 taskId 或明确为 mock 时进入 mock 模式） */
+const isMock = taskId === 'mock' || !taskId || taskId === 'unknown'
 /** 当前对话使用的模型名 */
 const modelName = ref(route.query.model as string || '')
 
@@ -88,30 +88,20 @@ async function handleSend() {
     return
   }
 
-  // 真实模式：获取已启动模型的端口/路径
-  const models = parseLoadedModels(task.value)
-  const target = models[0]
-  if (!target) {
-    ElMessage.error('未找到已启动的模型')
-    assistantMsg.content = '未找到已启动的模型，请先返回列表加载模型'
-    assistantMsg.done = true
-    assistantMsg.isStreaming = false
-    return
-  }
-
-  // 流式状态变化时只同步当前回复，避免固定定时器空转。
+  // 真实模式：通过后端 SSE 流式代理到算力节点进行推理
   activeAssistant = assistantMsg
 
-  await send({
-    port: target.port,
-    model_name: target.model_name,
-    model_path: '',
-    system_prompt: systemPrompt.value,
-    user_question: question,
-    temperature: temperature.value,
-    top_p: top_p.value,
-    max_tokens: maxTokens.value,
-  })
+  await send(
+    {
+      model_path: route.query.model_path as string || '',
+      system_prompt: systemPrompt.value,
+      user_question: question,
+      temperature: temperature.value,
+      top_p: top_p.value,
+      max_tokens: maxTokens.value,
+    },
+    { useMock: false },
+  )
 
   // 完成后同步最终内容
   assistantMsg.content = message.value.displayContent || message.value.error || '(无回复)'

frontend/src/views/inference/InferenceCreateView.vue

@@ -5,6 +5,8 @@ import { ElMessage, type FormInstance, type FormRules } from 'element-plus'
 import PageCard from '@/components/PageCard.vue'
 import { getModelList, getTrainedModels } from '@/api/modules/model'
 import { getSystemInfo } from '@/api/modules/system'
+import { getComputeNodes, type ComputeNode } from '@/api/modules/compute'
+import { createCompare, preloadLocalModel, preloadTrainedModel } from '@/api/modules/compare'
 import type { ModelItem, TrainedModel, GpuInfo } from '@/types'
 
 const router = useRouter()
@@ -15,6 +17,7 @@ const startupStatus = ref('')
 const dbModels = ref<ModelItem[]>([])
 const trainedModels = ref<TrainedModel[]>([])
 const gpus = ref<GpuInfo[]>([])
+const computeNodes = ref<ComputeNode[]>([])
 
 /** 可选模型（下拉用，区分本地/已训练两类） */
 interface SelectableModel {
@@ -54,7 +57,17 @@ const trainedOptions = computed<SelectableModel[]>(() =>
   })),
 )
 
-/** key → 模型映射，便于取选中项 */
+/** 仅显示在线算力节点上的空闲 GPU */
+const onlineNodeIds = computed(() => new Set(
+  computeNodes.value
+    .filter((n) => n.enabled && n.scheduler_status === 'online')
+    .map((n) => n.id),
+))
+const idleGpus = computed(() =>
+  gpus.value.filter(
+    (g) => g.status === 'idle' && (!g.node_id || onlineNodeIds.value.has(g.node_id)),
+  ),
+)
 const modelMap = computed<Record<string, SelectableModel>>(() => {
   const map: Record<string, SelectableModel> = {}
   for (const m of [...dbOptions.value, ...trainedOptions.value]) map[m.key] = m
@@ -90,12 +103,56 @@ async function handleSubmit() {
     submitting.value = true
     startupStatus.value = '正在启动模型服务...'
     try {
-      // 当前为 mock 环境：不创建任务、不启动后端服务，
-      // 用假数据直通进入对话界面（模型名通过 query 传递）。
-      // 接入真实后端后，可在此恢复 createCompare / startModelsInBackground / monitorStartup 流程。
-      await new Promise((resolve) => setTimeout(resolve, 1200))
+      // Step 1: 将模型加载到算力节点
+      const preloadPayload = {
+        model_name_or_path: m.model_path,
+        model_name: m.name,
+        template: 'qwen',
+      }
+      let preloadResult: any
+      if (m.source === 'trained') {
+        preloadResult = await preloadTrainedModel(preloadPayload)
+      } else {
+        preloadResult = await preloadLocalModel(preloadPayload)
+      }
+
+      if (preloadResult && (preloadResult as any).error) {
+        ElMessage.warning(`模型加载失败：${(preloadResult as any).error}`)
+        submitting.value = false
+        startupStatus.value = ''
+        return
+      }
+
+      // Step 2: 创建推理任务记录
+      const taskResult = await createCompare({
+        name: form.name || m.name,
+        description: form.description,
+        models: [
+          {
+            model_id: String(m.id),
+            model_name: m.name,
+            model_path: m.model_path,
+            source: m.source,
+            gpu_id: form.gpu_id,
+          },
+        ],
+      })
+      const taskId = taskResult?.id || 'unknown'
 
       ElMessage.success('模型已启动')
+      router.push({
+        path: `/model-inference/chat/${taskId}`,
+        query: {
+          model: m.name,
+          source: m.source,
+          model_path: m.model_path,
+        },
+      })
+    } catch (e: any) {
+      // 真实 API 失败时回退到 mock 模式（方便无算力节点的开发调试）
+      const m = selectedModel.value!
+      const reason = e?.message || e?.toString() || '未知错误'
+      ElMessage.warning(`推理服务启动失败：${reason}，进入 mock 演示模式`)
       router.push({
         path: '/model-inference/chat/mock',
         query: { model: m.name },
@@ -113,16 +170,18 @@ function handleCancel() {
 
 async function loadData() {
   try {
-    const [db, trained, sys] = await Promise.all([
+    const [db, trained, sys, nodes] = await Promise.all([
       getModelList(),
       getTrainedModels(),
       getSystemInfo(),
+      getComputeNodes(),
     ])
     dbModels.value = db || []
     trainedModels.value = trained?.models || []
     gpus.value = sys?.gpu || []
-    // 默认选中第一个 GPU
-    if (gpus.value.length > 0) form.gpu_id = 0
+    computeNodes.value = nodes || []
+    // 默认选中第一个空闲 GPU
+    if (idleGpus.value.length > 0) form.gpu_id = idleGpus.value[0].id ?? 0
   } catch {
     // ignore
   }
@@ -172,10 +231,10 @@ onMounted(loadData)
       <el-form-item label="GPU">
         <el-select v-model="form.gpu_id" style="width: 400px">
           <el-option
-            v-for="(g, idx) in gpus"
-            :key="idx"
-            :label="`${g.name} (GPU${idx})`"
-            :value="idx"
+            v-for="g in idleGpus"
+            :key="g.id ?? 0"
+            :label="`${g.name} (GPU${g.id ?? 0}) [空闲]`"
+            :value="g.id ?? 0"
           />
         </el-select>
       </el-form-item>

frontend/src/views/inference/InferenceListView.vue

@@ -7,10 +7,8 @@ import { usePolling } from '@/composables/usePolling'
 import {
   getCompareList,
   deleteCompare,
-  getCompare,
   loadCompare,
   unloadCompare,
-  stopModelByPid,
 } from '@/api/modules/compare'
 import type { CompareTask, LoadedModel } from '@/types'
 import { statusLabel, statusTagType } from '@/utils/status'
@@ -86,26 +84,19 @@ async function handleLoad(row: any) {
   delayedRefreshTimer = setTimeout(loadData, 1000)
 }
 
-/** 卸载推理任务 */
+/** 释放推理任务（停止模型服务，释放算力节点 GPU 显存） */
 async function handleUnload(row: any) {
-  await ElMessageBox.confirm('确定要停止模型服务吗？', '确认停止', { type: 'warning' })
+  await ElMessageBox.confirm('确定要释放模型服务吗？将停止模型进程并释放 GPU 显存。', '确认释放', { type: 'warning' })
   await unloadCompare(row.id)
-  ElMessage.success('已停止模型服务')
+  ElMessage.success('已释放模型服务')
   loadData()
 }
 
-/** 删除（先停止进程） */
+/** 删除（先释放算力节点再删除记录） */
 async function handleDelete(row: any) {
-  // 先尝试停止已加载的模型进程
-  const task = await getCompare(row.id).catch(() => null)
-  if (task?.load_status) {
-    const models = parseLoadedModels(task as CompareTask)
-    for (const m of models) {
-      if (m.pid) {
-        await stopModelByPid(m.pid).catch(() => {})
-      }
-    }
-  }
+  await ElMessageBox.confirm('确定要删除该推理记录吗？将先释放算力节点再删除。', '确认删除', { type: 'warning' })
+  // 先释放算力节点上的模型
+  await unloadCompare(row.id).catch(() => {})
   await deleteCompare(row.id)
   dataList.value = dataList.value.filter((item) => item.id !== row.id)
   await loadData(true)
@@ -180,7 +171,7 @@ onUnmounted(() => {
             <i class="fa fa-comments-o" style="margin-right: 4px" />对话
           </el-button>
           <el-button type="warning" link size="small" @click="handleUnload(row)">
-            <i class="fa fa-stop-circle-o" style="margin-right: 4px" />停止
+            <i class="fa fa-stop-circle-o" style="margin-right: 4px" />释放
           </el-button>
         </template>
         <template v-else>