diff --git a/frontend/src/components/pages/launch-model/launch-dialog/download-progress-details.tsx b/frontend/src/components/pages/launch-model/launch-dialog/download-progress-details.tsx
new file mode 100644
index 0000000000..e7f30f0556
--- /dev/null
+++ b/frontend/src/components/pages/launch-model/launch-dialog/download-progress-details.tsx
@@ -0,0 +1,164 @@
+'use client';
+
+import { CheckCircle2, Download, LoaderCircle } from 'lucide-react';
+
+import { CollapsiblePanel } from '@/components/ui/collapsible';
+import { Progress } from '@/components/ui/progress';
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table';
+import { useI18n } from '@/contexts/i18n-context';
+import { formatFileSize } from '@/lib/utils';
+
+export interface DownloadProgressFile {
+  name: string;
+  downloaded_bytes: number;
+  total_bytes: number | null;
+  progress: number | null;
+  speed_bytes_per_second: number | null;
+  elapsed_seconds: number;
+  eta_seconds: number | null;
+  status: string;
+  replica_id?: number;
+  replica_model_uid?: string;
+}
+
+interface DownloadProgressDetailsProps {
+  files: DownloadProgressFile[];
+}
+
+function getProgressPercent(file: DownloadProgressFile): number {
+  if (file.progress !== null && file.progress !== undefined) {
+    const progress = Number(file.progress);
+    if (Number.isFinite(progress)) {
+      const percent = progress <= 1 ? progress * 100 : progress;
+      return Math.max(0, Math.min(100, percent));
+    }
+  }
+
+  if (file.total_bytes && file.total_bytes > 0) {
+    return Math.max(0, Math.min(100, (file.downloaded_bytes / file.total_bytes) * 100));
+  }
+
+  return 0;
+}
+
+function formatSpeed(bytesPerSecond: number | null, completed: boolean): string {
+  if (completed || bytesPerSecond === null || !Number.isFinite(bytesPerSecond)) {
+    return '—';
+  }
+
+  return `${formatFileSize(Math.max(0, bytesPerSecond))}/s`;
+}
+
+function formatDuration(seconds: number | null): string {
+  if (seconds === null || !Number.isFinite(seconds)) {
+    return '—';
+  }
+
+  const totalSeconds = Math.max(0, Math.ceil(seconds));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const remainingSeconds = totalSeconds % 60;
+
+  return [hours, minutes, remainingSeconds]
+    .map((value) => String(value).padStart(2, '0'))
+    .join(':');
+}
+
+export default function DownloadProgressDetails({ files }: DownloadProgressDetailsProps) {
+  const { t } = useI18n();
+  const hasMultipleReplicas =
+    new Set(files.map((file) => file.replica_model_uid).filter(Boolean)).size > 1;
+
+  return (
+    <CollapsiblePanel
+      title={
+        <span className="flex items-center gap-2">
+          {t('launchModel.downloadDetails')}
+          <span className="rounded-full bg-primary/10 px-2 py-0.5 text-xs font-semibold text-primary">
+            {files.length}
+          </span>
+        </span>
+      }
+      icon={<Download className="size-4" />}
+      className="rounded-lg"
+      contentClassName="p-0"
+    >
+      {files.length === 0 ? (
+        <div className="flex min-h-24 items-center justify-center gap-2 px-4 py-6 text-sm text-muted-foreground">
+          <LoaderCircle className="size-4 animate-spin text-primary" />
+          {t('launchModel.waitingDownloadDetails')}
+        </div>
+      ) : (
+        <div className="max-h-64 overflow-y-auto" aria-live="polite">
+          <Table size="small" className="min-w-[760px] table-fixed">
+            <TableHeader className="sticky top-0 z-10">
+              <TableRow className="hover:bg-muted">
+                <TableHead className="w-[34%]">{t('launchModel.downloadFileName')}</TableHead>
+                <TableHead className="w-[25%]">{t('launchModel.downloadProgress')}</TableHead>
+                <TableHead className="w-[15%]">{t('launchModel.downloadStatus')}</TableHead>
+                <TableHead className="w-[13%]">{t('launchModel.downloadSpeed')}</TableHead>
+                <TableHead className="w-[13%]">{t('launchModel.downloadEta')}</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {files.map((file, index) => {
+                const progress = getProgressPercent(file);
+                const completed = file.status === 'completed' || progress >= 100;
+
+                return (
+                  <TableRow key={`${file.replica_model_uid || 'model'}:${file.name}:${index}`}>
+                    <TableCell className="min-w-0">
+                      <div className="truncate font-medium" title={file.name || '-'}>
+                        {file.name || '-'}
+                      </div>
+                      {hasMultipleReplicas && (
+                        <div className="mt-0.5 truncate text-[11px] text-muted-foreground">
+                          {t('launchModel.replica')} {file.replica_id}
+                        </div>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <div className="flex items-center gap-2">
+                        <Progress value={progress} className="h-1.5 min-w-24 flex-1" />
+                        <span className="w-9 shrink-0 text-right tabular-nums text-muted-foreground">
+                          {Math.round(progress)}%
+                        </span>
+                      </div>
+                    </TableCell>
+                    <TableCell>
+                      <span className="flex items-center gap-1.5 whitespace-nowrap">
+                        {completed ? (
+                          <CheckCircle2 className="size-3.5 text-emerald-500" />
+                        ) : (
+                          <LoaderCircle className="size-3.5 animate-spin text-primary" />
+                        )}
+                        {t(
+                          completed
+                            ? 'launchModel.downloadCompleted'
+                            : 'launchModel.downloadInProgress'
+                        )}
+                      </span>
+                    </TableCell>
+                    <TableCell className="whitespace-nowrap tabular-nums text-muted-foreground">
+                      {formatSpeed(file.speed_bytes_per_second, completed)}
+                    </TableCell>
+                    <TableCell className="whitespace-nowrap tabular-nums text-muted-foreground">
+                      {formatDuration(completed ? 0 : file.eta_seconds)}
+                    </TableCell>
+                  </TableRow>
+                );
+              })}
+            </TableBody>
+          </Table>
+        </div>
+      )}
+    </CollapsiblePanel>
+  );
+}
diff --git a/frontend/src/components/pages/launch-model/launch-dialog/launch-dialog.tsx b/frontend/src/components/pages/launch-model/launch-dialog/launch-dialog.tsx
index fc7a3cb879..e99a97b46f 100644
--- a/frontend/src/components/pages/launch-model/launch-dialog/launch-dialog.tsx
+++ b/frontend/src/components/pages/launch-model/launch-dialog/launch-dialog.tsx
@@ -56,6 +56,7 @@ import {
   GPU_IDX_PATTERN,
 } from '../utils';
 import CommandLine from './command-line';
+import DownloadProgressDetails, { type DownloadProgressFile } from './download-progress-details';
 import ReplicaPlacementConfig from './replica-placement-config';
 import { FormField } from '@/components/ui/form-field';
 
@@ -66,6 +67,23 @@ interface LaunchDialogProps {
   onOpenChange: (open: boolean) => void;
 }
 
+interface LaunchProgressReplica {
+  replica_id: number;
+  replica_model_uid: string;
+  progress: number;
+  stage: string;
+  info: string | null;
+  updated_at: number | null;
+  download_files: DownloadProgressFile[];
+}
+
+interface LaunchProgressResponse {
+  progress?: number | string;
+  stage?: string;
+  download_files?: DownloadProgressFile[];
+  replicas?: LaunchProgressReplica[];
+}
+
 export default function LaunchDialog({
   model,
   modelType,
@@ -83,6 +101,7 @@ export default function LaunchDialog({
   const [canceling, setCanceling] = useState(false);
   const [saveAutostart, setSaveAutostart] = useState(false);
   const [progress, setProgress] = useState(0);
+  const [progressDetails, setProgressDetails] = useState<LaunchProgressResponse | null>(null);
   const [replicaStatuses, setReplicaStatuses] = useState<ReplicaItem[]>([]);
   const [configCacheRefreshKey, setConfigCacheRefreshKey] = useState(0);
   const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);
@@ -1315,9 +1334,7 @@ export default function LaunchDialog({
     const modelUid = form.getFieldValue('model_uid') || model?.model_name;
     try {
       const [progressRes, replicaRes] = await Promise.all([
-        request.get<number | string | { progress?: number | string }>(
-          `/v1/models/${modelUid}/progress`
-        ),
+        request.get<number | string | LaunchProgressResponse>(`/v1/models/${modelUid}/progress`),
         request.get<unknown>(`/v1/models/${modelUid}/replicas`),
       ]);
 
@@ -1326,6 +1343,7 @@ export default function LaunchDialog({
       const nextProgress = normalizeProgress(progressValue);
 
       setProgress(nextProgress);
+      setProgressDetails(progressRes && typeof progressRes === 'object' ? progressRes : null);
       setReplicaStatuses(normalizeReplicaStatuses(replicaRes));
 
       if (nextProgress >= 100) {
@@ -1416,6 +1434,7 @@ export default function LaunchDialog({
       stopPolling();
       setLoading(false);
       setProgress(0);
+      setProgressDetails(null);
       setReplicaStatuses([]);
       toast.success(t('launchModel.launchCanceled'));
     } finally {
@@ -1450,6 +1469,7 @@ export default function LaunchDialog({
     isCanceledLaunchRef.current = false;
     setLoading(true);
     setProgress(0);
+    setProgressDetails(null);
     setReplicaStatuses([]);
 
     request
@@ -1504,6 +1524,7 @@ export default function LaunchDialog({
     setLoading(false);
     setCanceling(false);
     setProgress(0);
+    setProgressDetails(null);
     setReplicaStatuses([]);
     setSaveAutostart(false);
     stopPolling();
@@ -1564,7 +1585,10 @@ export default function LaunchDialog({
           onOpenChange(open);
         }}
       >
-        <DialogContent className="!max-w-3xl" maskClosable={false}>
+        <DialogContent
+          className={cn(loading ? '!max-h-[calc(100%-2rem)] !max-w-6xl' : '!max-w-3xl')}
+          maskClosable={false}
+        >
           <DialogHeader>
             <div className="flex min-w-0 items-center justify-between gap-3 pr-10">
               <DialogTitle className="min-w-0 truncate">{model?.model_name}</DialogTitle>
@@ -1590,7 +1614,20 @@ export default function LaunchDialog({
             {renderLaunchFields(currentLaunchFields)}
           </Form>
           <DialogFooter className={cn(loading ? '!flex-col' : '')}>
-            {loading && <Progress value={progress} />}
+            {loading && (
+              <div className="w-full space-y-2 pr-3">
+                <div className="flex items-center gap-3">
+                  <Progress value={progress} className="flex-1" />
+                  <span className="w-10 shrink-0 text-right text-xs tabular-nums text-muted-foreground">
+                    {Math.round(progress)}%
+                  </span>
+                </div>
+                {(progressDetails?.stage === 'downloading' ||
+                  Boolean(progressDetails?.download_files?.length)) && (
+                  <DownloadProgressDetails files={progressDetails?.download_files ?? []} />
+                )}
+              </div>
+            )}
             <div className="flex w-full flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
               <label className="flex items-center gap-2 text-sm text-muted-foreground">
                 <Switch checked={saveAutostart} disabled={loading} onChange={setSaveAutostart} />
diff --git a/frontend/src/i18n/locales/en.ts b/frontend/src/i18n/locales/en.ts
index 7e2ed943e9..a42f61f304 100644
--- a/frontend/src/i18n/locales/en.ts
+++ b/frontend/src/i18n/locales/en.ts
@@ -210,6 +210,15 @@ const en = {
     launchCanceled: 'Deployment stopped',
     initializing: 'Initializing...',
     moreDetails: 'More Details',
+    downloadDetails: 'Download Details',
+    waitingDownloadDetails: 'Waiting for file download details...',
+    downloadFileName: 'File name',
+    downloadProgress: 'Progress',
+    downloadStatus: 'Status',
+    downloadSpeed: 'Speed',
+    downloadEta: 'Estimated time remaining',
+    downloadInProgress: 'Downloading',
+    downloadCompleted: 'Completed',
   },
   runningModels: {
     searchPlaceholder: 'Search model name or model UID...',
diff --git a/frontend/src/i18n/locales/ja.ts b/frontend/src/i18n/locales/ja.ts
index cc0b961384..eaa0986fb7 100644
--- a/frontend/src/i18n/locales/ja.ts
+++ b/frontend/src/i18n/locales/ja.ts
@@ -209,6 +209,15 @@ const ja = {
     launchCanceled: 'デプロイを停止しました',
     initializing: '初期化中...',
     moreDetails: '詳細を見る',
+    downloadDetails: 'ダウンロード詳細',
+    waitingDownloadDetails: 'ファイルのダウンロード情報を待っています...',
+    downloadFileName: 'ファイル名',
+    downloadProgress: '進捗',
+    downloadStatus: '状態',
+    downloadSpeed: '速度',
+    downloadEta: '推定残り時間',
+    downloadInProgress: 'ダウンロード中',
+    downloadCompleted: '完了',
   },
   runningModels: {
     searchPlaceholder: 'モデル名またはモデルUIDを検索...',
diff --git a/frontend/src/i18n/locales/ko.ts b/frontend/src/i18n/locales/ko.ts
index 785b58464e..d59d38f633 100644
--- a/frontend/src/i18n/locales/ko.ts
+++ b/frontend/src/i18n/locales/ko.ts
@@ -207,6 +207,15 @@ const ko = {
     launchCanceled: '배포가 중지되었습니다',
     initializing: '초기화 중...',
     moreDetails: '자세히 보기',
+    downloadDetails: '다운로드 상세 정보',
+    waitingDownloadDetails: '파일 다운로드 정보를 기다리는 중...',
+    downloadFileName: '파일 이름',
+    downloadProgress: '진행률',
+    downloadStatus: '상태',
+    downloadSpeed: '속도',
+    downloadEta: '예상 남은 시간',
+    downloadInProgress: '다운로드 중',
+    downloadCompleted: '완료',
   },
   runningModels: {
     searchPlaceholder: '모델 이름 또는 모델 UID 검색...',
diff --git a/frontend/src/i18n/locales/zh.ts b/frontend/src/i18n/locales/zh.ts
index d26b03ef70..9053e57937 100644
--- a/frontend/src/i18n/locales/zh.ts
+++ b/frontend/src/i18n/locales/zh.ts
@@ -204,6 +204,15 @@ const zh = {
     launchCanceled: '已停止部署',
     initializing: '初始化中...',
     moreDetails: '更多详情',
+    downloadDetails: '下载详情',
+    waitingDownloadDetails: '正在等待文件下载信息...',
+    downloadFileName: '文件名',
+    downloadProgress: '进度',
+    downloadStatus: '状态',
+    downloadSpeed: '速度',
+    downloadEta: '预计剩余时间',
+    downloadInProgress: '下载中',
+    downloadCompleted: '已完成',
   },
   runningModels: {
     searchPlaceholder: '搜索模型名称或模型UID...',
diff --git a/frontend/src/lib/request.ts b/frontend/src/lib/request.ts
index 71c7d882b5..30f0307048 100644
--- a/frontend/src/lib/request.ts
+++ b/frontend/src/lib/request.ts
@@ -104,7 +104,6 @@ requestInstance.interceptors.response.use(
     return response.data;
   },
   async (error) => {
-    console.log(error, error.message, error.status, 'error');
     const response = error.response;
     if (!response) {
       eventBus.emit(RequestEvents.SERVER_ERROR, error.message || 'Network Error');
@@ -134,7 +133,6 @@ requestInstance.interceptors.response.use(
       response.data?.msg ||
       error.message ||
       'Unknown error';
-    console.log(status, response, 'response');
 
     switch (status) {
       case 401: {
diff --git a/xinference/api/restful_api.py b/xinference/api/restful_api.py
index f6da2c73fb..5d3700389b 100644
--- a/xinference/api/restful_api.py
+++ b/xinference/api/restful_api.py
@@ -1018,13 +1018,13 @@ async def get_model_replicas(self, model_uid: str) -> JSONResponse:
 
     async def get_launch_model_progress(self, model_uid: str) -> JSONResponse:
         try:
-            progress = await (
+            progress_details = await (
                 await self._get_supervisor_ref()
-            ).get_launch_builtin_model_progress(model_uid)
+            ).get_launch_builtin_model_progress_details(model_uid)
         except Exception as e:
             logger.error(str(e), exc_info=True)
             raise HTTPException(status_code=500, detail=str(e))
-        return JSONResponse(content={"progress": progress})
+        return JSONResponse(content=progress_details)
 
     async def cancel_launch_model(self, model_uid: str) -> JSONResponse:
         try:
diff --git a/xinference/core/progress_tracker.py b/xinference/core/progress_tracker.py
index 618ba2f06c..a851904f2b 100644
--- a/xinference/core/progress_tracker.py
+++ b/xinference/core/progress_tracker.py
@@ -17,7 +17,7 @@
 import logging
 import os
 import time
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 import xoscar as xo
@@ -40,6 +40,7 @@ class _ProgressInfo:
     progress: float
     last_updated: float
     info: Optional[str] = None
+    details: Optional[Dict[str, Any]] = None
 
 
 class ProgressTrackerActor(xo.StatelessActor):
@@ -92,13 +93,25 @@ async def _clear_finished(self):
 
             await asyncio.sleep(self._check_interval)
 
-    def start(self, request_id: str, info: Optional[str] = None):
+    def start(
+        self,
+        request_id: str,
+        info: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ):
         self._request_id_to_progress[request_id] = _ProgressInfo(
-            progress=0.0, last_updated=time.time(), info=info
+            progress=0.0,
+            last_updated=time.time(),
+            info=info,
+            details=details,
         )
 
     def set_progress(
-        self, request_id: str, progress: float, info: Optional[str] = None
+        self,
+        request_id: str,
+        progress: float,
+        info: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
     ):
         assert progress <= 1.0
         info_ = self._request_id_to_progress[request_id]
@@ -106,6 +119,8 @@ def set_progress(
         info_.last_updated = time.time()
         if info:
             info_.info = info
+        if details is not None:
+            info_.details = details
         logger.debug(
             "Setting progress, request id: %s, progress: %s", request_id, progress
         )
@@ -117,6 +132,12 @@ def get_progress_info(self, request_id: str) -> Tuple[float, Optional[str]]:
         info = self._request_id_to_progress[request_id]
         return info.progress, info.info
 
+    def get_progress_details(
+        self, request_id: str
+    ) -> Tuple[float, Optional[str], Optional[Dict[str, Any]]]:
+        info = self._request_id_to_progress[request_id]
+        return info.progress, info.info, info.details
+
 
 class Progressor:
     _sub_progress_stack: List[Tuple[float, float]]
@@ -177,7 +198,12 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             self.set_progress(1.0)
         return False
 
-    def set_progress(self, progress: float, info: Optional[str] = None):
+    def set_progress(
+        self,
+        progress: float,
+        info: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ):
         if self.request_id:
             self._current_progress = (
                 self._current_sub_progress_start
@@ -185,11 +211,16 @@ def set_progress(self, progress: float, info: Optional[str] = None):
                 * progress
             )
             if (
-                self._current_progress - self._last_report_progress >= self._upload_span
-                or 1.0 - progress < 1e-5
-            ) or info:
+                (
+                    self._current_progress - self._last_report_progress
+                    >= self._upload_span
+                    or 1.0 - progress < 1e-5
+                )
+                or info
+                or details is not None
+            ):
                 set_progress = self.progress_tracker_ref.set_progress(
-                    self.request_id, self._current_progress
+                    self.request_id, self._current_progress, info, details
                 )
                 asyncio.run_coroutine_threadsafe(set_progress, self.loop)  # type: ignore
                 self._last_report_progress = self._current_progress
diff --git a/xinference/core/supervisor.py b/xinference/core/supervisor.py
index 39f337d1f2..18d2ccfc9b 100644
--- a/xinference/core/supervisor.py
+++ b/xinference/core/supervisor.py
@@ -2936,6 +2936,79 @@ async def get_launch_builtin_model_progress(self, model_uid: str) -> float:
 
         return all_progress / i if i > 0 else 0.0
 
+    async def get_launch_builtin_model_progress_details(
+        self, model_uid: str
+    ) -> Dict[str, Any]:
+        """Return launch progress plus current per-file download activity."""
+        try:
+            self._model_uid_to_replica_info[model_uid]
+        except KeyError:
+            return {
+                "progress": 0.0,
+                "stage": "pending",
+                "download_files": [],
+                "replicas": [],
+            }
+
+        all_progress = 0.0
+        replicas: List[Dict[str, Any]] = []
+        download_files: List[Dict[str, Any]] = []
+        stages: Set[str] = set()
+
+        for rep_model_uid in self._iter_active_replica_model_uids(model_uid):
+            request_id = f"launching-{rep_model_uid}"
+            try:
+                progress, info, details = (
+                    await self._progress_tracker.get_progress_details(request_id)
+                )
+            except KeyError:
+                continue
+
+            _, replica_id = parse_replica_model_uid(rep_model_uid)
+            details = details if isinstance(details, dict) else {}
+            stage = str(details.get("stage") or "launching")
+            files = details.get("download_files")
+            files = files if isinstance(files, list) else []
+            normalized_files = []
+            for file_info in files:
+                if not isinstance(file_info, dict):
+                    continue
+                normalized_file = dict(file_info)
+                normalized_file["replica_id"] = replica_id
+                normalized_file["replica_model_uid"] = rep_model_uid
+                normalized_files.append(normalized_file)
+
+            all_progress += progress
+            stages.add(stage)
+            download_files.extend(normalized_files)
+            replicas.append(
+                {
+                    "replica_id": replica_id,
+                    "replica_model_uid": rep_model_uid,
+                    "progress": progress,
+                    "stage": stage,
+                    "info": info,
+                    "updated_at": details.get("updated_at"),
+                    "download_files": normalized_files,
+                }
+            )
+
+        if "downloading" in stages:
+            stage = "downloading"
+        elif "loading" in stages:
+            stage = "loading"
+        elif stages:
+            stage = sorted(stages)[0]
+        else:
+            stage = "launching"
+
+        return {
+            "progress": all_progress / len(replicas) if replicas else 0.0,
+            "stage": stage,
+            "download_files": download_files,
+            "replicas": replicas,
+        }
+
     async def cancel_launch_builtin_model(self, model_uid: str):
         try:
             info = self._model_uid_to_replica_info[model_uid]
diff --git a/xinference/core/worker.py b/xinference/core/worker.py
index 0e64092bbd..7b35246799 100644
--- a/xinference/core/worker.py
+++ b/xinference/core/worker.py
@@ -3256,10 +3256,26 @@ def _upload_download_progress(
     ):
         while not downloader.done:
             progress = downloader.get_progress()
-            progressor.set_progress(progress)
+            progressor.set_progress(
+                progress,
+                "Downloading model files",
+                {
+                    "stage": "downloading",
+                    "download_files": downloader.get_download_progress_details(),
+                    "updated_at": time.time(),
+                },
+            )
             downloader.wait(1)
 
-        progressor.set_progress(1.0, "Start to load model")
+        progressor.set_progress(
+            1.0,
+            "Start to load model",
+            {
+                "stage": "loading",
+                "download_files": [],
+                "updated_at": time.time(),
+            },
+        )
 
     @log_async(logger=logger, level=logging.INFO)
     async def launch_builtin_model(
diff --git a/xinference/model/tests/test_utils.py b/xinference/model/tests/test_utils.py
index 6977829975..1a14bd8332 100644
--- a/xinference/model/tests/test_utils.py
+++ b/xinference/model/tests/test_utils.py
@@ -13,11 +13,14 @@
 # limitations under the License.
 
 import asyncio
+import io
 import shutil
 import sys
 import threading
+from contextvars import copy_context
 
 import pytest
+import tqdm as tqdm_module
 from tqdm.auto import tqdm
 
 from ...utils import get_real_path
@@ -77,6 +80,90 @@ def test_tqdm_patch():
     assert downloader.done
 
 
+def test_download_progress_details_include_completed_files():
+    downloader = CancellableDownloader(cancel_error_cls=RuntimeError)
+
+    with downloader:
+        bar = tqdm(total=100, unit="B", desc="model.safetensors")
+        bar.update(25)
+
+        [downloading] = downloader.get_download_progress_details()
+        assert downloading["name"] == "model.safetensors"
+        assert downloading["downloaded_bytes"] == 25
+        assert downloading["total_bytes"] == 100
+        assert downloading["progress"] == 0.25
+        assert downloading["status"] == "downloading"
+
+        bar.update(75)
+
+        [completed] = downloader.get_download_progress_details()
+        assert completed["progress"] == 1.0
+        assert completed["speed_bytes_per_second"] is None
+        assert completed["eta_seconds"] == 0.0
+        assert completed["status"] == "completed"
+        bar.close()
+
+
+async def test_concurrent_download_progress_details_are_isolated():
+    """Each launch must only expose tqdm bars from its own task context."""
+    d1 = CancellableDownloader(cancel_error_cls=RuntimeError)
+    d2 = CancellableDownloader(cancel_error_cls=RuntimeError)
+    barrier = threading.Barrier(2)
+
+    async def collect_details(downloader, name):
+        with downloader:
+
+            def update_and_snapshot():
+                bar = tqdm(total=100, unit="B", desc=name, file=io.StringIO())
+                try:
+                    bar.update(25)
+                    barrier.wait(timeout=10)
+                    return downloader.get_download_progress_details()
+                finally:
+                    bar.close()
+
+            return await asyncio.to_thread(update_and_snapshot)
+
+    details1, details2 = await asyncio.gather(
+        collect_details(d1, "model-a.bin"),
+        collect_details(d2, "model-b.bin"),
+    )
+
+    assert [item["name"] for item in details1] == ["model-a.bin"]
+    assert [item["name"] for item in details2] == ["model-b.bin"]
+
+
+def test_tqdm_owner_is_stable_across_threads():
+    """A bar created for one downloader keeps that owner in a raw thread."""
+    d1 = CancellableDownloader(cancel_error_cls=RuntimeError)
+    d2 = CancellableDownloader(cancel_error_cls=RuntimeError)
+
+    with d1:
+        bar = tqdm(total=100, unit="B", desc="model-a.bin", file=io.StringIO())
+        try:
+            with d2:
+                errors = []
+
+                def update():
+                    try:
+                        bar.update(25)
+                    except BaseException as error:
+                        errors.append(error)
+
+                thread = threading.Thread(target=update)
+                thread.start()
+                thread.join(timeout=10)
+
+                assert not thread.is_alive()
+                assert not errors
+                assert [
+                    item["name"] for item in d1.get_download_progress_details()
+                ] == ["model-a.bin"]
+                assert d2.get_download_progress_details() == []
+        finally:
+            bar.close()
+
+
 def test_concurrent_progress_no_set_mutation():
     """Two concurrent downloaders race the progress sets: one thread creates
     new download bars and calls .update() (so patched_update grows
@@ -123,7 +210,11 @@ def poller():
                         errors.append(("poller", e))
                         return
 
-            tu = threading.Thread(target=updater)
+            # Propagate the logical downloader context into the raw thread so
+            # this test still exercises concurrent set growth after tqdm bars
+            # became owner-scoped.
+            updater_context = copy_context()
+            tu = threading.Thread(target=updater_context.run, args=(updater,))
             tp = threading.Thread(target=poller)
             tu.start()
             tp.start()
@@ -149,8 +240,10 @@ def test_class_level_bookkeeping_no_per_instance_shadow():
     CancellableDownloader._active_instances = 0
     CancellableDownloader._original_update = None
     CancellableDownloader._original_update_plain = None
+    CancellableDownloader._original_init_plain = None
     CancellableDownloader._active_registry.clear()
     original_update = tqdm.update
+    original_init_plain = tqdm_module.tqdm.__dict__["__init__"]
 
     d1 = CancellableDownloader(cancel_error_cls=RuntimeError)
     d2 = CancellableDownloader(cancel_error_cls=RuntimeError)
@@ -164,9 +257,11 @@ def test_class_level_bookkeeping_no_per_instance_shadow():
         # Originals stored on the class, no per-instance shadow.
         assert CancellableDownloader._original_update is original_update
         assert CancellableDownloader._original_update_plain is not None
+        assert CancellableDownloader._original_init_plain[0] is original_init_plain
         for d in (d1, d2):
             assert "_original_update" not in vars(d)
             assert "_original_update_plain" not in vars(d)
+            assert "_original_init_plain" not in vars(d)
         # tqdm stays patched while any instance is active.
         assert tqdm.update is not original_update
 
@@ -184,6 +279,7 @@ def test_class_level_bookkeeping_no_per_instance_shadow():
     # last instance out -> counter 0 and tqdm restored
     assert CancellableDownloader._active_instances == 0
     assert tqdm.update is original_update
+    assert tqdm_module.tqdm.__dict__["__init__"] is original_init_plain
 
 
 def test_reset_holds_lock_against_progress_poller():
@@ -195,6 +291,7 @@ def test_reset_holds_lock_against_progress_poller():
     CancellableDownloader._active_instances = 0
     CancellableDownloader._original_update = None
     CancellableDownloader._original_update_plain = None
+    CancellableDownloader._original_init_plain = None
     CancellableDownloader._active_registry.clear()
     d = CancellableDownloader(cancel_error_cls=RuntimeError)
     with d:
@@ -239,8 +336,8 @@ def resetter():
     assert not errors, f"reset/get_progress race raised: {errors}"
 
 
-def test_active_registry_snapshot_holds_global_lock():
-    """The tqdm hook must snapshot the registry under its mutation lock."""
+def test_active_registry_fallback_holds_global_lock():
+    """The no-context, single-downloader fallback must hold the registry lock."""
 
     class LockCheckingSet(set):
         def __iter__(self):
@@ -251,14 +348,28 @@ def __iter__(self):
     CancellableDownloader._active_instances = 0
     CancellableDownloader._original_update = None
     CancellableDownloader._original_update_plain = None
+    CancellableDownloader._original_init_plain = None
     CancellableDownloader._active_registry = LockCheckingSet()
 
     downloader = CancellableDownloader(cancel_error_cls=RuntimeError)
     try:
         with downloader:
-            bar = tqdm(total=1, disable=True)
-            bar.update(1)
-            bar.close()
+            errors = []
+
+            def update():
+                try:
+                    bar = tqdm(total=1, disable=True)
+                    bar.update(1)
+                    bar.close()
+                except BaseException as error:
+                    errors.append(error)
+
+            thread = threading.Thread(target=update)
+            thread.start()
+            thread.join(timeout=10)
+
+            assert not thread.is_alive()
+            assert not errors
     finally:
         CancellableDownloader._active_registry = original_registry
 
diff --git a/xinference/model/utils.py b/xinference/model/utils.py
index 1635021d52..7063e16216 100644
--- a/xinference/model/utils.py
+++ b/xinference/model/utils.py
@@ -17,6 +17,7 @@
 import importlib
 import json
 import logging
+import math
 import os
 import random
 import re
@@ -893,13 +894,21 @@ def set_all_random_seed(seed: int):
     torch.cuda.manual_seed_all(seed)
 
 
+_cancellable_downloaders_var: ContextVar[Tuple["CancellableDownloader", ...]] = (
+    ContextVar("cancellable_downloaders", default=())
+)
+
+
 class CancellableDownloader:
     _global_lock = threading.Lock()
     _active_instances = 0
     _active_registry: Set["CancellableDownloader"] = set()
     _original_update = None  # Class-level original update method (tqdm.auto.tqdm)
     _original_update_plain = None  # Class-level original update method (tqdm.tqdm)
+    _original_init_plain = None  # Class-level original __init__ descriptor
+    _original_thread_pool_submit = None  # Tuple with original pool submit method
     _patch_lock = threading.Lock()  # Additional lock for patching operations
+    _tqdm_owner_attr = "_xinference_downloader"
 
     def __init__(
         self,
@@ -923,6 +932,35 @@ def __init__(
         # Instance-specific tqdm tracking
         self._patched_instances: Set[int] = set()
 
+    @classmethod
+    def _get_tqdm_owner(cls, tqdm_instance: Any) -> Optional["CancellableDownloader"]:
+        owner = getattr(tqdm_instance, cls._tqdm_owner_attr, None)
+        if owner is not None:
+            return owner
+
+        downloaders = _cancellable_downloaders_var.get()
+        if downloaders:
+            owner = downloaders[-1]
+        else:
+            # Some download libraries create their own worker threads without
+            # propagating contextvars. A single active downloader is still an
+            # unambiguous owner; with concurrent downloaders, never guess.
+            with cls._global_lock:
+                if len(cls._active_registry) == 1:
+                    owner = next(iter(cls._active_registry))
+
+        if owner is not None:
+            setattr(tqdm_instance, cls._tqdm_owner_attr, owner)
+        return owner
+
+    def _remove_from_context(self) -> None:
+        downloaders = list(_cancellable_downloaders_var.get())
+        for index in range(len(downloaders) - 1, -1, -1):
+            if downloaders[index] is self:
+                del downloaders[index]
+                _cancellable_downloaders_var.set(tuple(downloaders))
+                break
+
     def reset(self):
         # Hold _progress_lock around both clears so a concurrent get_progress()
         # caller (e.g. the progress-upload thread that already passed its done
@@ -932,18 +970,18 @@ def reset(self):
             self._main_progresses.clear()
             self._download_progresses.clear()
 
+    def _progress_snapshots(self) -> Tuple[List[tqdm], List[tqdm]]:
+        """Return stable copies while tqdm callbacks may update the sets."""
+        with self._progress_lock:
+            return list(self._main_progresses), list(self._download_progresses)
+
     def get_progress(self) -> float:
         if self.done:
             # directly return 1.0 when finished
             return 1.0
         # Don't return 1.0 when cancelled, calculate actual progress
 
-        # Snapshot the progress sets under the lock: patched_update (download
-        # thread) can add a new bar mid-iteration, which would otherwise raise
-        # "Set changed size during iteration".
-        with self._progress_lock:
-            main_progresses = list(self._main_progresses)
-            download_progresses = list(self._download_progresses)
+        main_progresses, download_progresses = self._progress_snapshots()
 
         tasks = finished_tasks = 0
         for main_progress in main_progresses:
@@ -976,6 +1014,72 @@ def get_progress(self) -> float:
         else:
             return finished_ratio
 
+    @staticmethod
+    def _finite_float(value: Any) -> Optional[float]:
+        try:
+            result = float(value)
+        except (TypeError, ValueError):
+            return None
+        return result if math.isfinite(result) else None
+
+    def get_download_progress_details(self) -> List[Dict[str, Any]]:
+        """Return JSON-serializable snapshots for files downloading right now.
+
+        Repository-level tqdm bars count files and use ``it`` as their unit.
+        File download bars use a byte unit, so only those bars are exposed.
+        Completed byte bars remain visible until the download context resets,
+        allowing clients to show both active and just-finished files.
+        """
+        _, download_progresses = self._progress_snapshots()
+        files: List[Dict[str, Any]] = []
+
+        for download_progress in download_progresses:
+            if getattr(download_progress, "disable", False):
+                continue
+
+            unit = str(getattr(download_progress, "unit", "") or "")
+            if unit.lower() not in {"b", "byte", "bytes"}:
+                continue
+
+            downloaded = self._finite_float(getattr(download_progress, "n", None))
+            total = self._finite_float(getattr(download_progress, "total", None))
+            if downloaded is None:
+                continue
+
+            format_dict = getattr(download_progress, "format_dict", {}) or {}
+            rate = self._finite_float(format_dict.get("rate"))
+            elapsed = self._finite_float(format_dict.get("elapsed"))
+            downloaded = max(0.0, downloaded)
+            total = max(0.0, total) if total is not None else None
+            rate = max(0.0, rate) if rate is not None else None
+            elapsed = max(0.0, elapsed) if elapsed is not None else 0.0
+            completed = total is not None and total > 0 and downloaded >= total
+
+            progress = None
+            eta = None
+            if total is not None and total > 0:
+                progress = min(1.0, downloaded / total)
+                if completed:
+                    eta = 0.0
+                    rate = None
+                elif rate is not None and rate > 0:
+                    eta = max(0.0, (total - downloaded) / rate)
+
+            files.append(
+                {
+                    "name": str(getattr(download_progress, "desc", "") or ""),
+                    "downloaded_bytes": int(downloaded),
+                    "total_bytes": int(total) if total is not None else None,
+                    "progress": progress,
+                    "speed_bytes_per_second": rate,
+                    "elapsed_seconds": elapsed,
+                    "eta_seconds": eta,
+                    "status": "completed" if completed else "downloading",
+                }
+            )
+
+        return sorted(files, key=lambda item: item["name"])
+
     def cancel(self):
         self._cancelled.set()
         self._done_event.set()
@@ -1003,6 +1107,8 @@ def patch_tqdm(self):
         # originals — the first to exit then restores tqdm.update while the
         # second is still active.
         with self._patch_lock:
+            from concurrent.futures import ThreadPoolExecutor
+
             import tqdm as tqdm_module
 
             cls = type(self)
@@ -1011,27 +1117,47 @@ def patch_tqdm(self):
                 cls._original_update = tqdm.update
             if cls._original_update_plain is None:
                 cls._original_update_plain = tqdm_module.tqdm.update
-
-            if cls._original_update is None or cls._original_update_plain is None:
+            if cls._original_init_plain is None:
+                # Keep the descriptor inside a tuple so accessing it through
+                # this class does not invoke its own __get__ implementation.
+                cls._original_init_plain = (tqdm_module.tqdm.__dict__["__init__"],)
+            if cls._original_thread_pool_submit is None:
+                # Store the function in a tuple to prevent descriptor binding
+                # when it is accessed through CancellableDownloader.
+                cls._original_thread_pool_submit = (ThreadPoolExecutor.submit,)
+
+            if (
+                cls._original_update is None
+                or cls._original_update_plain is None
+                or cls._original_init_plain is None
+                or cls._original_thread_pool_submit is None
+            ):
                 return
 
             original_update_plain = cls._original_update_plain
+            original_init_plain = cls._original_init_plain[0].__get__(
+                None, tqdm_module.tqdm
+            )
+            original_thread_pool_submit = cls._original_thread_pool_submit[0]
+
+            def patched_init(tqdm_instance, *args, **kwargs):
+                # Bind ownership when the bar is created so later updates from
+                # library worker threads remain scoped to the same downloader.
+                CancellableDownloader._get_tqdm_owner(tqdm_instance)
+                return original_init_plain(tqdm_instance, *args, **kwargs)
 
             # Thread-safe patched update
             def patched_update(tqdm_instance, n):
-                # Iterate the bounded active-instance registry instead of
-                # gc.get_objects(): the whole-heap traversal stalled the GIL
-                # on every progress tick and scanned O(heap) objects.
-                with CancellableDownloader._global_lock:
-                    downloaders = list(CancellableDownloader._active_registry)
-
-                for downloader in downloaders:
+                downloader = CancellableDownloader._get_tqdm_owner(tqdm_instance)
+                if downloader is not None:
                     # if download cancelled, throw error
                     if getattr(downloader, "cancelled", False):
                         downloader.raise_error()
 
                     progresses = None
-                    if not getattr(tqdm_instance, "disable", False):
+                    if not downloader.done and not getattr(
+                        tqdm_instance, "disable", False
+                    ):
                         unit = getattr(tqdm_instance, "unit", "it")
                         if unit == "it":
                             progresses = getattr(downloader, "_main_progresses", None)
@@ -1045,26 +1171,52 @@ def patched_update(tqdm_instance, n):
                         # caller may be iterating this very set.
                         with downloader._progress_lock:
                             progresses.add(tqdm_instance)
-                    else:
-                        logger.debug(f"No progresses found for downloader {downloader}")
 
                 # Call original update with safety check
                 return original_update_plain(tqdm_instance, n)
 
+            def patched_thread_pool_submit(executor, fn, /, *args, **kwargs):
+                # ThreadPoolExecutor does not propagate contextvars. Capture
+                # only the downloader ownership here so libraries that create
+                # tqdm bars in nested pools can still bind each bar correctly.
+                downloaders = _cancellable_downloaders_var.get()
+                if not downloaders:
+                    return original_thread_pool_submit(executor, fn, *args, **kwargs)
+
+                def run_with_downloaders():
+                    token = _cancellable_downloaders_var.set(downloaders)
+                    try:
+                        return fn(*args, **kwargs)
+                    finally:
+                        _cancellable_downloaders_var.reset(token)
+
+                return original_thread_pool_submit(executor, run_with_downloaders)
+
+            tqdm_module.tqdm.__init__ = patched_init
             tqdm.update = patched_update
             tqdm_module.tqdm.update = patched_update
+            ThreadPoolExecutor.submit = patched_thread_pool_submit
 
     def unpatch_tqdm(self):
         with self._patch_lock:
             cls = type(self)
-            if cls._original_update is not None and cls._active_instances == 0:
+            if cls._active_instances == 0:
+                from concurrent.futures import ThreadPoolExecutor
+
                 import tqdm as tqdm_module
 
-                tqdm.update = cls._original_update
-                cls._original_update = None
+                if cls._original_update is not None:
+                    tqdm.update = cls._original_update
+                    cls._original_update = None
                 if cls._original_update_plain is not None:
                     tqdm_module.tqdm.update = cls._original_update_plain
                     cls._original_update_plain = None
+                if cls._original_init_plain is not None:
+                    tqdm_module.tqdm.__init__ = cls._original_init_plain[0]
+                    cls._original_init_plain = None
+                if cls._original_thread_pool_submit is not None:
+                    ThreadPoolExecutor.submit = cls._original_thread_pool_submit[0]
+                    cls._original_thread_pool_submit = None
 
     def __enter__(self):
         # Use global lock to prevent concurrent patching. _active_instances is
@@ -1076,16 +1228,20 @@ def __enter__(self):
                 self.patch_tqdm()
             cls._active_instances += 1
             cls._active_registry.add(self)
+        _cancellable_downloaders_var.set(_cancellable_downloaders_var.get() + (self,))
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        # Use global lock to prevent concurrent unpatching
-        with self._global_lock:
-            cls = type(self)
-            cls._active_instances -= 1
-            cls._active_registry.discard(self)
-            if cls._active_instances == 0:
-                self.unpatch_tqdm()
+        try:
+            # Use global lock to prevent concurrent unpatching
+            with self._global_lock:
+                cls = type(self)
+                cls._active_instances -= 1
+                cls._active_registry.discard(self)
+                if cls._active_instances == 0:
+                    self.unpatch_tqdm()
+        finally:
+            self._remove_from_context()
         try:
             self._done_event.set()
             self.reset()