From 5bf07076e71b1ad6e255e7e5480b73fd08aa48d9 Mon Sep 17 00:00:00 2001
From: iOrange <1606894729@qq.com>
Date: Tue, 12 May 2026 18:03:24 +0800
Subject: [PATCH] =?UTF-8?q?feat=EF=BC=9A=E5=A2=9E=E5=8A=A0=E4=BE=9B?=
 =?UTF-8?q?=E5=BA=94=E5=95=86/API=E7=94=A8=E9=87=8F=E7=9B=91=E6=8E=A7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

新增供应商和脱敏 API Key 的生图统计记录，并在监控端增加供应商详情页、饼图和最近活动供应商列。
---
 __init__.py                            |   8 +-
 adapters/base.py                       |  69 +++++++--
 adapters/generic.py                    |  36 ++++-
 adapters/volcengine.py                 |  18 +++
 dashboard.py                           | 205 +++++++++++++++++++++++--
 independent_generator.py               |  16 +-
 nodes.py                               |  40 ++++-
 tests/test_base_adapter.py             |  28 ++++
 tests/test_dashboard_provider_usage.py | 108 +++++++++++++
 tests/test_independent_generator.py    |  54 +++++++
 tests/test_usage_tracker.py            |  46 ++++++
 usage_tracker.py                       |  76 ++++++++-
 12 files changed, 661 insertions(+), 43 deletions(-)
 create mode 100644 tests/test_dashboard_provider_usage.py

diff --git a/__init__.py b/__init__.py
index 5d64308..89aff5f 100644
--- a/__init__.py
+++ b/__init__.py
@@ -959,6 +959,7 @@ async def on_batch_complete(batch_idx, total, batch_previews):
                 from .image_utils import detect_aspect_ratio as _dar
                 all_preview_images = []
                 all_params_hashes = []
+                all_provider_usage = []
                 total_boxes = len(blurred_b64_list)
                 total_calls = total_boxes * batch_count
                 _progress_total_override = total_calls
@@ -1055,14 +1056,17 @@ async def on_batch_complete(batch_idx, total, batch_previews):
                         all_preview_images.extend(box_result["preview_images"])
                     elif "error" in box_result:
                         result["error"] = box_result["error"]
+                    all_provider_usage.extend(box_result.get("provider_usage", []))
                         
                     if box_result.get("params_hash"):
                         all_params_hashes.append(box_result["params_hash"])
                 
                 # Update combined result, preserving any existing error messages
+                from .usage_tracker import aggregate_provider_usage as _aggregate_provider_usage
                 result["success"] = bool(all_preview_images)
                 result["preview_images"] = all_preview_images
                 result["params_hash"] = "_".join(all_params_hashes) if all_params_hashes else ""
+                result["provider_usage"] = _aggregate_provider_usage(all_provider_usage)
             else:
                 # Merge: blurred image(s) + all reference images
                 merged_images = blurred_b64_list + reference_images_base64
@@ -1107,6 +1111,7 @@ async def on_batch_complete(batch_idx, total, batch_previews):
                     images_saved=_saved_count,
                     success=result.get("success", False),
                     providers_tried=[],
+                    provider_usage=result.get("provider_usage", []),
                     error_message=result.get("error", ""),
                     duration_seconds=_usage_duration,
                 )
@@ -1241,7 +1246,8 @@ async def on_batch_complete(batch_idx, total, batch_previews):
                     images_generated=len(_preview_images),
                     images_saved=_saved_count,
                     success=result.get("success", False),
-                    providers_tried=[],  # Aggregated per-batch, not available in result dict
+                    providers_tried=[],  # Derived from provider_usage by UsageTracker
+                    provider_usage=result.get("provider_usage", []),
                     error_message=result.get("error", ""),
                     duration_seconds=_usage_duration,
                 )
diff --git a/adapters/base.py b/adapters/base.py
index b35c4f5..f3057fd 100644
--- a/adapters/base.py
+++ b/adapters/base.py
@@ -28,6 +28,7 @@ class APIResponse:
     task_id: str = ""
     status: str = ""  # pending, processing, success, failed
     providers_tried: List[str] = field(default_factory=list)  # Usage tracking: providers attempted
+    provider_usage: List[Dict[str, Any]] = field(default_factory=list)  # Safe provider/key image counts
 
 
 @dataclass
@@ -81,42 +82,76 @@ def api_key(self) -> str:
           2. api_keys: ["key1", "key2"]                               (plain list)
           3. api_key: "single_key"                                    (original)
         """
+        return self.select_api_key_info().get("key", "")
+
+    def select_api_key_info(self) -> Dict[str, Any]:
+        """Select an API key and return full key plus a safe display label.
+
+        The returned ``key`` is for request signing only. ``label`` is safe for
+        usage logs and dashboards because it never contains the complete key.
+        """
         import random
         import time
         
         keys_config = self.provider.get("api_keys", [])
         if keys_config and isinstance(keys_config, list):
-            # Build list of active keys
-            active_keys = []
-            for item in keys_config:
+            # Build list of active keys with stable config-order numbering.
+            active_infos = []
+            for idx, item in enumerate(keys_config, start=1):
                 if isinstance(item, dict):
                     if item.get("enabled", True) and item.get("key"):
-                        active_keys.append(item["key"])
+                        active_infos.append(self._make_key_info(
+                            item["key"],
+                            idx,
+                            str(item.get("name") or "").strip(),
+                        ))
                 elif isinstance(item, str) and item:
-                    active_keys.append(item)
+                    active_infos.append(self._make_key_info(item, idx, ""))
             
-            if active_keys:
+            if active_infos:
                 # Filter out blacklisted keys (always use CLASS-level dict, never instance)
                 now = time.time()
                 bad = APIAdapter._bad_keys  # explicit class reference
-                good_keys = [k for k in active_keys if k not in bad or bad[k] < now]
-                
+
                 # Clean expired entries IN-PLACE (don't reassign to avoid shadowing)
                 expired = [k for k, t in bad.items() if t < now]
                 for k in expired:
                     del bad[k]
-                
+
+                good_infos = [
+                    info for info in active_infos
+                    if info["key"] not in bad or bad[info["key"]] < now
+                ]
+
                 # Use good keys if available, fall back to all keys if all blacklisted
-                pool = good_keys if good_keys else active_keys
-                key = random.choice(pool)
-                # Key numbering: stable index based on config order (1-based)
-                key_num = active_keys.index(key) + 1 if key in active_keys else "?"
+                pool = good_infos if good_infos else active_infos
+                info = random.choice(pool)
                 provider_name = self.provider.get("display_name", self.provider.get("name", "?"))
-                skipped = len(active_keys) - len(good_keys)
+                skipped = len(active_infos) - len(good_infos)
                 skip_info = f", {skipped} blacklisted" if skipped else ""
-                print(f"[APIAdapter] Key#{key_num} selected for {provider_name} ({len(pool)}/{len(active_keys)} keys{skip_info})")
-                return key
-        return self.provider.get("api_key", "")
+                print(f"[APIAdapter] Key#{info['index']} selected for {provider_name} ({len(pool)}/{len(active_infos)} keys{skip_info})")
+                return dict(info)
+
+        key = self.provider.get("api_key", "")
+        return self._make_key_info(key, 1, "") if key else {"key": "", "index": 0, "name": "", "label": ""}
+
+    def _make_key_info(self, key: str, index: int, name: str = "") -> Dict[str, Any]:
+        safe_name = str(name or "").strip() or f"Key#{index}"
+        return {
+            "key": key,
+            "index": index,
+            "name": safe_name,
+            "label": self._format_safe_key_label(key, index=index, name=safe_name),
+        }
+
+    @staticmethod
+    def _format_safe_key_label(key: str, index: int = 1, name: str = "") -> str:
+        safe_name = str(name or "").strip() or f"Key#{index}"
+        key_str = str(key or "")
+        if not key_str:
+            return safe_name
+        suffix = key_str[-6:]
+        return f"{safe_name} · ****{suffix}"
     
     # Store active_keys list for key number lookup in blacklist_key
     _last_active_keys: list = []
diff --git a/adapters/generic.py b/adapters/generic.py
index bc7f336..b0cef75 100644
--- a/adapters/generic.py
+++ b/adapters/generic.py
@@ -75,7 +75,9 @@ def build_request(self, params: Dict, mode: str = "text2img") -> Dict:
     def _build_openai_request(self, params: Dict, mode: str = "text2img") -> Dict:
         """Build request for OpenAI-compatible APIs."""
         # Pick API key ONCE (self.api_key returns random key each call)
-        _current_key = self.api_key or ""
+        key_info = self.select_api_key_info()
+        _current_key = key_info.get("key", "") or ""
+        key_label = key_info.get("label", "")
         used_key = _current_key  # Track for blacklisting on failure
         endpoint_path = self.mode_config.get("endpoint", "")
         method = self.mode_config.get("method", "POST")
@@ -86,6 +88,7 @@ def _build_openai_request(self, params: Dict, mode: str = "text2img") -> Dict:
         # Build headers - support Account auth mode
         auth_type = self.endpoint.get("auth_type", "api")
         if auth_type == "account":
+            key_label = "Account Token"
             # Account mode: use X-Auth-T token from Account singleton
             try:
                 from ..account import Account
@@ -94,6 +97,7 @@ def _build_openai_request(self, params: Dict, mode: str = "text2img") -> Dict:
             except Exception:
                 headers = {"Authorization": f"Bearer {_current_key}"}
         elif auth_type == "service_account":
+            key_label = "Service Account"
             # Vertex AI proper: OAuth2 Bearer token from Service Account JSON
             try:
                 from ..vertex_sa_auth import get_access_token
@@ -219,6 +223,9 @@ def _build_openai_request(self, params: Dict, mode: str = "text2img") -> Dict:
             "method": method,
             "headers": headers,
             "_used_key": used_key,
+            "_provider": self.provider.get("name", "unknown"),
+            "_provider_label": self.provider.get("display_name") or self.provider.get("name", "unknown"),
+            "_key_label": key_label,
         }
         
         if content_type == "application/json":
@@ -298,7 +305,9 @@ def _build_gemini_request(self, params: Dict, mode: str = "text2img") -> Dict:
         
         # Pick API key ONCE for the entire request (URL + Files API + tracking)
         # CRITICAL: self.api_key is a property that returns a random key each call!
-        _current_key = self.api_key or ""
+        key_info = self.select_api_key_info()
+        _current_key = key_info.get("key", "") or ""
+        key_label = key_info.get("label", "")
         used_key = _current_key  # Track for blacklisting on failure
         
         endpoint_path = self.mode_config.get("endpoint", "")
@@ -327,6 +336,7 @@ def _build_gemini_request(self, params: Dict, mode: str = "text2img") -> Dict:
         auth_header_format = self.endpoint.get("auth_header_format", "bearer")
         
         if auth_type == "account":
+            key_label = "Account Token"
             try:
                 from ..account import Account
                 account = Account.get_instance()
@@ -369,6 +379,8 @@ def _build_gemini_request(self, params: Dict, mode: str = "text2img") -> Dict:
                 from ..vertex_sa_auth import get_random_sa_token
                 sa_token, sa_project_id, sa_name = get_random_sa_token(self.provider)
                 if sa_token:
+                    safe_sa_name = str(sa_name or "Service Account").replace("\\", "/").rsplit("/", 1)[-1]
+                    key_label = f"Service Account · {safe_sa_name}"
                     headers = {
                         "Authorization": f"Bearer {sa_token}",
                         "Content-Type": "application/json"
@@ -566,9 +578,28 @@ def _build_gemini_request(self, params: Dict, mode: str = "text2img") -> Dict:
             "headers": headers,
             "json": payload,
             "_used_key": used_key,
+            "_provider": self.provider.get("name", "unknown"),
+            "_provider_label": self.provider.get("display_name") or self.provider.get("name", "unknown"),
+            "_key_label": key_label,
         }
 
     
+    def _attach_provider_usage(self, result: APIResponse, request_info: Dict[str, Any]) -> APIResponse:
+        """Attach safe provider/key image counts to a successful response."""
+        if not result.success:
+            return result
+        gen_count = len(result.images or [])
+        if gen_count <= 0:
+            return result
+
+        result.provider_usage.append({
+            "provider": request_info.get("_provider") or self.provider.get("name", "unknown"),
+            "provider_label": request_info.get("_provider_label") or self.provider.get("display_name") or self.provider.get("name", "unknown"),
+            "key_label": request_info.get("_key_label") or "未记录Key",
+            "gen": gen_count,
+        })
+        return result
+
     def _prepare_images_base64(self, params: Dict) -> Dict:
         """
         Convert uploaded files to base64 data URLs for Chat API format.
@@ -1074,6 +1105,7 @@ def execute(self, params: Dict, mode: str = "text2img",
                     except Exception:
                         pass
 
+                self._attach_provider_usage(result, request_info)
                 return result
                 
             except requests.Timeout:
diff --git a/adapters/volcengine.py b/adapters/volcengine.py
index 4886fe6..7a417e3 100644
--- a/adapters/volcengine.py
+++ b/adapters/volcengine.py
@@ -407,6 +407,24 @@ def execute(self, params: Dict, mode: str = "inpaint") -> APIResponse:
                 if img_bytes:
                     result.images.append(img_bytes)
         
+        self._attach_provider_usage(result)
+        return result
+
+    def _attach_provider_usage(self, result: APIResponse) -> APIResponse:
+        """Attach safe Volcengine access-key image counts to successful image results."""
+        if not result.success or not result.images:
+            return result
+        provider = self.provider.get("name", "volcengine")
+        result.provider_usage.append({
+            "provider": provider,
+            "provider_label": self.provider.get("display_name") or provider,
+            "key_label": self._format_safe_key_label(
+                self.provider.get("access_key", ""),
+                index=1,
+                name="AccessKey",
+            ),
+            "gen": len(result.images),
+        })
         return result
     
     def _poll_for_result(self, task_id: str, timeout: int = 120) -> APIResponse:
diff --git a/dashboard.py b/dashboard.py
index 6a3f797..6105a07 100644
--- a/dashboard.py
+++ b/dashboard.py
@@ -120,6 +120,7 @@ def compute_stats(records: list, date_filter: str = "today",
         "dur_avg": 0, "dur_min": 0, "dur_max": 0,
         "machines": [], "models": {}, "nodes": {},
         "recent": [], "timeline": {}, "machine_list": [],
+        "providers_usage": [],
     }
     if not records:
         return empty
@@ -183,6 +184,46 @@ def compute_stats(records: list, date_filter: str = "today",
         node = r.get("node", "unknown")
         node_map[node] = node_map.get(node, 0) + 1
 
+    # Per-provider/key image counts. Only direct provider_usage records are used.
+    provider_map = {}
+    for r in records:
+        entries = r.get("provider_usage", [])
+        if not isinstance(entries, list):
+            continue
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            try:
+                gen = int(entry.get("gen", 0))
+            except (TypeError, ValueError):
+                continue
+            if gen <= 0:
+                continue
+            provider = str(entry.get("provider") or entry.get("provider_label") or "unknown")
+            provider_label = str(entry.get("provider_label") or provider)
+            key_label = str(entry.get("key_label") or "未记录Key")
+            if provider not in provider_map:
+                provider_map[provider] = {
+                    "provider": provider,
+                    "provider_label": provider_label,
+                    "gen": 0,
+                    "keys": {},
+                }
+            p = provider_map[provider]
+            p["gen"] += gen
+            p["keys"][key_label] = p["keys"].get(key_label, 0) + gen
+
+    providers_usage = []
+    for provider_data in provider_map.values():
+        keys = [
+            {"key_label": key_label, "gen": gen}
+            for key_label, gen in provider_data.pop("keys").items()
+        ]
+        keys.sort(key=lambda x: (-x["gen"], x["key_label"]))
+        provider_data["keys"] = keys
+        providers_usage.append(provider_data)
+    providers_usage.sort(key=lambda x: (-x["gen"], x["provider_label"]))
+
     # Timeline aggregation
     # If viewing a single day (today or date_exact), group by hour.
     # If viewing week/all, group by day.
@@ -228,6 +269,7 @@ def compute_stats(records: list, date_filter: str = "today",
         "nodes": node_map,
         "recent": recent,
         "timeline": sorted_tl,
+        "providers_usage": providers_usage,
     }
 
 
@@ -406,6 +448,32 @@ def save_machine_notes(data_dir: str, notes: dict):
   .recent-table::-webkit-scrollbar { width:6px; }
   .recent-table::-webkit-scrollbar-thumb { background:var(--border); border-radius:3px; }
 
+  /* Provider usage */
+  .provider-usage-list {
+    display:grid; grid-template-columns:repeat(auto-fit, minmax(260px, 1fr));
+    gap:12px;
+  }
+  .provider-card {
+    background:var(--card-bg); border:1px solid var(--border); border-radius:10px;
+    padding:14px;
+  }
+  .provider-card-head {
+    display:flex; justify-content:space-between; align-items:center; gap:10px;
+    font-weight:700; margin-bottom:10px; padding-bottom:8px;
+    border-bottom:1px solid var(--border);
+  }
+  .provider-total { color:var(--green); white-space:nowrap; }
+  .provider-key-row {
+    display:flex; justify-content:space-between; gap:10px;
+    font-size:0.82rem; color:var(--text-dim); padding:5px 0;
+  }
+  .provider-key-name { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+  .provider-key-gen { color:var(--text); font-weight:600; white-space:nowrap; }
+  .empty-block {
+    color:var(--text-dim); background:var(--card-bg); border:1px solid var(--border);
+    border-radius:10px; padding:18px; text-align:center;
+  }
+
   /* Machine detail grid (Tab 2) */
   .machine-grid {
     display:grid; grid-template-columns:repeat(auto-fill, minmax(260px, 1fr));
@@ -455,6 +523,7 @@ def save_machine_notes(data_dir: str, notes: dict):
 <div class="tab-bar">
   <button class="tab-btn active" onclick="switchTab('overview')">📊 总览</button>
   <button class="tab-btn" onclick="switchTab('machines')">👥 机器详情</button>
+  <button class="tab-btn" onclick="switchTab('providers')">供应商/API数量详情</button>
 </div>
 
 <!-- Controls -->
@@ -511,7 +580,7 @@ def save_machine_notes(data_dir: str, notes: dict):
     <div class="recent-table">
       <table id="recentTable"><thead><tr>
         <th>时间</th><th>机器</th><th>节点</th><th>模型</th><th>批次</th>
-        <th>生成</th><th>保存</th><th>状态 (鼠标悬浮看原因)</th><th>耗时</th>
+        <th>供应商</th><th>生成</th><th>保存</th><th>状态 (鼠标悬浮看原因)</th><th>耗时</th>
       </tr></thead><tbody></tbody></table>
     </div>
   </div>
@@ -533,6 +602,20 @@ def save_machine_notes(data_dir: str, notes: dict):
   </div>
   <div class="machine-grid" id="machineGrid"></div>
 </div>
+
+<!-- =================== Tab 3: Provider/API Details =================== -->
+<div class="tab-page" id="page-providers">
+  <div class="chart-row">
+    <div class="chart-box provider-chart-box">
+      <div class="chart-label">供应商生图占比</div>
+      <canvas id="providerChart"></canvas>
+    </div>
+  </div>
+  <div class="section">
+    <div class="section-title">供应商 / API Key 生图统计</div>
+    <div id="providerUsageList" class="provider-usage-list"></div>
+  </div>
+</div>
 </div>
 
 <script>
@@ -543,6 +626,7 @@ def save_machine_notes(data_dir: str, notes: dict):
 let drillDate = '';   // '' = no drill;  'YYYY-MM-DD' = drilled
 let refreshTimer = null;
 let chartTimeline = null, chartMachine = null, chartModel = null;
+let chartProvider = null;
 let machineChartInstances = {};  // Tab2 mini pies
 let fpInstance = null;
 let fpOpen = false;
@@ -575,11 +659,30 @@ def save_machine_notes(data_dir: str, notes: dict):
   if (!s || s <= 0) return '-';
   return s >= 60 ? (s/60).toFixed(1)+'m' : s.toFixed(1)+'s';
 }
+function esc(s) {
+  return String(s ?? '').replace(/[&<>"']/g, ch => ({
+    '&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;', "'":'&#39;'
+  }[ch]));
+}
 function getNote(name) { return machineNotes[name] || ''; }
 function displayName(name) {
   const n = getNote(name);
   return n ? name + ' (' + n + ')' : name;
 }
+function providerSummary(record) {
+  const entries = Array.isArray(record.provider_usage) ? record.provider_usage : [];
+  if (!entries.length) return '';
+  const totals = {};
+  entries.forEach(item => {
+    const label = item.provider_label || item.provider || '';
+    if (!label) return;
+    totals[label] = (totals[label] || 0) + (Number(item.gen) || 0);
+  });
+  return Object.entries(totals)
+    .sort((a,b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .map(([label, gen]) => gen > 0 ? `${label}(${gen})` : label)
+    .join(' / ');
+}
 
 // ==================== Machine Notes ====================
 async function loadNotes() {
@@ -624,13 +727,10 @@ def save_machine_notes(data_dir: str, notes: dict):
 function switchTab(tab) {
   document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
   document.querySelectorAll('.tab-page').forEach(p => p.classList.remove('active'));
-  if (tab === 'overview') {
-    document.querySelector('.tab-btn:nth-child(1)').classList.add('active');
-    document.getElementById('page-overview').classList.add('active');
-  } else {
-    document.querySelector('.tab-btn:nth-child(2)').classList.add('active');
-    document.getElementById('page-machines').classList.add('active');
-  }
+  const tabIndex = { overview: 1, machines: 2, providers: 3 }[tab] || 1;
+  const pageId = 'page-' + (tabIndex === 1 ? 'overview' : tabIndex === 2 ? 'machines' : 'providers');
+  document.querySelector(`.tab-btn:nth-child(${tabIndex})`).classList.add('active');
+  document.getElementById(pageId).classList.add('active');
 }
 
 // ==================== Filter / Machine / Drill ====================
@@ -941,10 +1041,12 @@ def save_machine_notes(data_dir: str, notes: dict):
     chartModel.update('none');
   }
 
+  renderProviderUsage(data.providers_usage || []);
+
   // --- Recent activity table ---
   const rtb = document.querySelector('#recentTable tbody');
   if (!data.recent.length) {
-    rtb.innerHTML = '<tr><td colspan="9" style="text-align:center;color:var(--text-dim)">暂无数据</td></tr>';
+    rtb.innerHTML = '<tr><td colspan="10" style="text-align:center;color:var(--text-dim)">暂无数据</td></tr>';
   } else {
     rtb.innerHTML = data.recent.map(r => {
       let statusHtml;
@@ -960,10 +1062,12 @@ def save_machine_notes(data_dir: str, notes: dict):
       const node = NODE_LABELS[r.node] || r.node;
       const mNote = getNote(r.machine);
       const mLabel = mNote ? r.machine + ' <span style="font-size:0.75rem;color:var(--text-dim)">(' + mNote + ')</span>' : r.machine;
+      const providerText = providerSummary(r);
       return `<tr>
         <td>${fmt(r.ts)}</td>
         <td style="cursor:pointer; color:var(--accent);" onclick="selectMachine('${r.machine}')" title="点击查看此机器详情">${mLabel}</td><td>${node}</td>
         <td>${r.model}</td><td>${r.batch}</td>
+        <td>${esc(providerText)}</td>
         <td>${r.gen}</td><td>${r.saved}</td>
         <td>${statusHtml}</td><td>${fmtDur(r.dur_s)}</td>
       </tr>`;
@@ -971,6 +1075,89 @@ def save_machine_notes(data_dir: str, notes: dict):
   }
 }
 
+function renderProviderUsage(items) {
+  renderProviderChart(items);
+  const box = document.getElementById('providerUsageList');
+  if (!box) return;
+  if (!items.length) {
+    box.innerHTML = '<div class="empty-block">暂无供应商 / API Key 明细；新版本记录后会自动显示</div>';
+    return;
+  }
+
+  box.innerHTML = items.map(provider => {
+    const keys = provider.keys || [];
+    const keyRows = keys.length
+      ? keys.map(k => `
+        <div class="provider-key-row">
+          <span class="provider-key-name" title="${esc(k.key_label)}">${esc(k.key_label)}</span>
+          <span class="provider-key-gen">${k.gen} 张</span>
+        </div>
+      `).join('')
+      : '<div class="provider-key-row"><span class="provider-key-name">未记录Key</span><span class="provider-key-gen">0 张</span></div>';
+    return `
+      <div class="provider-card">
+        <div class="provider-card-head">
+          <span title="${esc(provider.provider)}">${esc(provider.provider_label || provider.provider)}</span>
+          <span class="provider-total">${provider.gen} 张</span>
+        </div>
+        ${keyRows}
+      </div>
+    `;
+  }).join('');
+}
+
+function renderProviderChart(items) {
+  const canvas = document.getElementById('providerChart');
+  if (!canvas) return;
+
+  const hasData = items.length > 0;
+  const labels = hasData
+    ? items.map(p => p.provider_label || p.provider || '未知供应商')
+    : ['暂无数据'];
+  const counts = hasData ? items.map(p => p.gen || 0) : [1];
+  const colors = hasData
+    ? labels.map((_, i) => PALETTE[i % PALETTE.length])
+    : ['#2d3142'];
+
+  if (!chartProvider) {
+    chartProvider = new Chart(canvas, {
+      type: 'doughnut',
+      data: {
+        labels,
+        datasets: [{
+          data: counts,
+          backgroundColor: colors,
+          borderWidth: 0,
+          hoverOffset: hasData ? 6 : 0,
+        }],
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        cutout: '58%',
+        animation: { duration: 400 },
+        plugins: {
+          legend: {
+            position: 'right',
+            labels: { color: '#8b8fa3', padding: 12, usePointStyle: true, pointStyle: 'circle' },
+          },
+          tooltip: {
+            callbacks: {
+              label: (ctx) => hasData ? `${ctx.label}: ${ctx.parsed} 张` : '暂无数据',
+            },
+          },
+        },
+      },
+    });
+  } else {
+    chartProvider.data.labels = labels;
+    chartProvider.data.datasets[0].data = counts;
+    chartProvider.data.datasets[0].backgroundColor = colors;
+    chartProvider.data.datasets[0].hoverOffset = hasData ? 6 : 0;
+    chartProvider.update('none');
+  }
+}
+
 // ==================== Tab 2: Machine Details ====================
 function renderMachineDetails(data) {
   const grid = document.getElementById('machineGrid');
diff --git a/independent_generator.py b/independent_generator.py
index cfd111e..c292e6b 100644
--- a/independent_generator.py
+++ b/independent_generator.py
@@ -19,6 +19,7 @@
 from .config_manager import config_manager
 from .adapters.generic import GenericAPIAdapter
 from .adapters.base import APIResponse
+from .usage_tracker import aggregate_provider_usage
 
 
 class IndependentGenerator:
@@ -49,6 +50,7 @@ def _build_adapter_from_endpoint_info(self, endpoint_info: Optional[Dict[str, An
             return VolcengineAdapter(
                 provider_config={
                     "name": provider.name,
+                    "display_name": getattr(provider, "display_name", provider.name),
                     "base_url": provider.base_url,
                     "access_key": provider.access_key,
                     "secret_key": provider.secret_key,
@@ -305,8 +307,8 @@ async def generate(
         # Generate images in parallel with immediate saving
         response_log = ""
         
-        async def process_single_batch(batch_idx: int) -> Tuple[int, List[Dict], str]:
-            """Process a single batch, save immediately, return (index, preview_results, log)."""
+        async def process_single_batch(batch_idx: int) -> Tuple[int, List[Dict], str, List[Dict]]:
+            """Process a single batch and return previews, log, and safe provider usage."""
             print(f"\n[IndependentGenerator] Batch {batch_idx+1}/{batch_count} - Model: {model}")
             
             current_params = params.copy()
@@ -345,7 +347,7 @@ async def process_single_batch(batch_idx: int) -> Tuple[int, List[Dict], str]:
                 except Exception as e:
                     print(f"[IndependentGenerator] Progress callback error: {e}")
             
-            return (batch_idx, batch_previews, batch_log)
+            return (batch_idx, batch_previews, batch_log, getattr(result, "provider_usage", []))
         
         # All batches run in parallel - memory is shared via cached image data
         print(f"[IndependentGenerator] Running all {batch_count} batches in parallel (shared image data)")
@@ -354,19 +356,22 @@ async def process_single_batch(batch_idx: int) -> Tuple[int, List[Dict], str]:
         
         # Collect results in order
         all_previews = []
+        all_provider_usage = []
         for result in sorted(results, key=lambda x: x[0] if isinstance(x, tuple) else 999):
             if isinstance(result, Exception):
                 response_log += f"Batch error: {result}\n"
             else:
-                _, batch_previews, batch_log = result
+                _, batch_previews, batch_log, batch_provider_usage = result
                 all_previews.extend(batch_previews)
                 response_log += batch_log
+                all_provider_usage.extend(batch_provider_usage)
         
         if not all_previews:
             return {
                 "success": False,
                 "error": f"Generation failed.\n{response_log}",
-                "preview_images": []
+                "preview_images": [],
+                "provider_usage": aggregate_provider_usage(all_provider_usage),
             }
         
         effective_hash_images = None
@@ -395,6 +400,7 @@ async def process_single_batch(batch_idx: int) -> Tuple[int, List[Dict], str]:
             "success": True,
             "preview_images": all_previews,
             "response_info": response_log if response_log else "Success",
+            "provider_usage": aggregate_provider_usage(all_provider_usage),
             "params_hash": params_hash  # Backend-computed hash for cache matching
         }
     
diff --git a/nodes.py b/nodes.py
index a973b6a..a35aa66 100644
--- a/nodes.py
+++ b/nodes.py
@@ -26,6 +26,7 @@
 from .config_manager import config_manager
 from .adapters.generic import GenericAPIAdapter
 from .adapters.base import APIResponse
+from .usage_tracker import aggregate_provider_usage
 from .image_utils import prepare_for_comfyui, pil_to_tensor_rgba, get_image_info
 
 logger = logging.getLogger("batchbox")
@@ -194,6 +195,7 @@ def _build_adapter_from_endpoint_info(self, endpoint_info: Optional[Dict[str, An
             return VolcengineAdapter(
                 provider_config={
                     "name": provider.name,
+                    "display_name": getattr(provider, "display_name", provider.name),
                     "base_url": provider.base_url,
                     "access_key": provider.access_key,
                     "secret_key": provider.secret_key
@@ -205,6 +207,7 @@ def _build_adapter_from_endpoint_info(self, endpoint_info: Optional[Dict[str, An
         return GenericAPIAdapter(
             provider_config={
                 "name": provider.name,
+                "display_name": getattr(provider, "display_name", provider.name),
                 "base_url": provider.base_url,
                 "api_key": provider.api_key,
                 "api_keys": provider.api_keys or [],
@@ -340,7 +343,8 @@ def execute_with_failover(self, model_name: str, params: Dict[str, Any],
     
     def process_batch(self, model_name: str, batch_count: int, 
                       params: Dict[str, Any], mode: str = "text2img",
-                      endpoint_override: Optional[str] = None) :
+                      endpoint_override: Optional[str] = None,
+                      return_usage: bool = False) :
         """
         Process batch of image generation requests in parallel.
         
@@ -356,6 +360,7 @@ def process_batch(self, model_name: str, batch_count: int,
             
         Returns:
             Tuple of (image_tensor, response_log, last_image_url, pil_images)
+            or the same tuple plus provider_usage when return_usage=True.
         """
         from concurrent.futures import ThreadPoolExecutor, as_completed
         
@@ -404,7 +409,14 @@ def process_single_batch(batch_idx: int):
             else:
                 batch_log += f"Batch {batch_idx+1} failed: {result.error_message}\n"
             
-            return (batch_idx, batch_tensors, batch_pil_images, batch_url, batch_log)
+            return (
+                batch_idx,
+                batch_tensors,
+                batch_pil_images,
+                batch_url,
+                batch_log,
+                getattr(result, "provider_usage", []),
+            )
         
         # Run all batches in parallel
         with ThreadPoolExecutor(max_workers=batch_count) as executor:
@@ -421,12 +433,14 @@ def process_single_batch(batch_idx: int):
         # Combine results
         all_tensors = []
         all_pil_images = []
+        all_provider_usage = []
         response_log = ""
         last_url = ""
         
-        for batch_idx, tensors, pil_images, url, log in successful_results:
+        for batch_idx, tensors, pil_images, url, log, provider_usage in successful_results:
             all_tensors.extend(tensors)
             all_pil_images.extend(pil_images)
+            all_provider_usage.extend(provider_usage)
             response_log += log
             if url:
                 last_url = url
@@ -434,12 +448,15 @@ def process_single_batch(batch_idx: int):
         if not all_tensors:
             # Return black placeholder
             placeholder = Image.new('RGB', (512, 512), color='black')
-            return (
+            result_tuple = (
                 pil2tensor(placeholder),
                 f"Generation failed.\n{response_log}",
                 "",
                 [placeholder]
             )
+            if return_usage:
+                return result_tuple + (aggregate_provider_usage(all_provider_usage),)
+            return result_tuple
         
         # Normalize tensor dimensions before concatenation
         # All tensors must have same H,W dimensions to concatenate on dim=0
@@ -461,12 +478,15 @@ def process_single_batch(batch_idx: int):
                     normalized_tensors.append(tensor)
             all_tensors = normalized_tensors
         
-        return (
+        result_tuple = (
             torch.cat(all_tensors, dim=0),
             response_log if response_log else "Success",
             last_url,
             all_pil_images
         )
+        if return_usage:
+            return result_tuple + (aggregate_provider_usage(all_provider_usage),)
+        return result_tuple
     
     def _compute_params_hash(self, model: str, prompt: str, batch_count: int, kwargs: Dict) -> str:
         """
@@ -799,8 +819,8 @@ def generate(self, model: str, prompt: str, batch_count: int, **kwargs) :
         
         # Process batch and get results including PIL images
         _usage_t0 = time.time()
-        images_tensor, response_info, last_url, pil_images = self.process_batch(
-            model, batch_count, params, mode, endpoint_override
+        images_tensor, response_info, last_url, pil_images, provider_usage = self.process_batch(
+            model, batch_count, params, mode, endpoint_override, return_usage=True
         )
         _usage_duration = time.time() - _usage_t0
         
@@ -841,7 +861,8 @@ def generate(self, model: str, prompt: str, batch_count: int, **kwargs) :
                 images_generated=len(pil_images),
                 images_saved=_saved_count,
                 success=bool(pil_images),
-                providers_tried=[],  # Collected per-batch; aggregate not available here
+                providers_tried=[],  # Derived from provider_usage by UsageTracker
+                provider_usage=provider_usage,
                 error_message=response_info if not pil_images else "",
                 duration_seconds=_usage_duration,
             )
@@ -1351,10 +1372,12 @@ def execute_with_retry(attempt_num):
         try:
             from .usage_tracker import get_tracker
             _all_providers = []
+            _provider_usage = []
             for r in results:
                 for p in getattr(r, 'providers_tried', []):
                     if p not in _all_providers:
                         _all_providers.append(p)
+                _provider_usage.extend(getattr(r, 'provider_usage', []))
             get_tracker().record(
                 node_type="editor",
                 model=model,
@@ -1363,6 +1386,7 @@ def execute_with_retry(attempt_num):
                 images_saved=_saved_count,
                 success=bool(output_tensors),
                 providers_tried=_all_providers,
+                provider_usage=aggregate_provider_usage(_provider_usage),
                 error_message=results[-1].error_message if results and not results[-1].success else "",
                 duration_seconds=_usage_duration,
             )
diff --git a/tests/test_base_adapter.py b/tests/test_base_adapter.py
index f4a611d..5f3b72c 100644
--- a/tests/test_base_adapter.py
+++ b/tests/test_base_adapter.py
@@ -41,6 +41,7 @@ def test_default_values(self):
         assert r.error_message == ""
         assert r.task_id == ""
         assert r.status == ""
+        assert r.provider_usage == []
 
     def test_success_response(self):
         r = APIResponse(
@@ -139,6 +140,33 @@ def test_api_key_empty_list_falls_back(self):
         a = self._make_adapter({"base_url": "", "api_keys": [], "api_key": "sk-fallback"})
         assert a.api_key == "sk-fallback"
 
+    @patch("random.choice", side_effect=lambda keys: keys[1])
+    def test_select_api_key_info_masks_named_key(self, _):
+        a = self._make_adapter({
+            "name": "google",
+            "display_name": "Google",
+            "base_url": "",
+            "api_keys": [
+                {"name": "main", "key": "sk-main-111111", "enabled": True},
+                {"name": "backup", "key": "sk-backup-abcdef", "enabled": True},
+            ],
+        })
+
+        info = a.select_api_key_info()
+
+        assert info["key"] == "sk-backup-abcdef"
+        assert info["label"] == "backup · ****abcdef"
+        assert "sk-backup-abcdef" not in info["label"]
+
+    def test_select_api_key_info_masks_single_key(self):
+        a = self._make_adapter({"base_url": "", "api_key": "sk-single-654321"})
+
+        info = a.select_api_key_info()
+
+        assert info["key"] == "sk-single-654321"
+        assert info["label"] == "Key#1 · ****654321"
+        assert "sk-single-654321" not in info["label"]
+
     # _get_nested_value
     def test_get_nested_simple(self):
         a = self._make_adapter()
diff --git a/tests/test_dashboard_provider_usage.py b/tests/test_dashboard_provider_usage.py
new file mode 100644
index 0000000..3c518a1
--- /dev/null
+++ b/tests/test_dashboard_provider_usage.py
@@ -0,0 +1,108 @@
+"""Tests for provider/key usage aggregation in dashboard.py."""
+
+from dashboard import DASHBOARD_HTML, compute_stats
+
+
+def test_compute_stats_provider_usage_is_additive_to_existing_totals():
+    records = [
+        {
+            "ts": "2026-05-12T10:00:00+08:00",
+            "machine": "PC-1_AAAAAA",
+            "node": "image",
+            "model": "NanoBananaPro",
+            "batch": 2,
+            "gen": 2,
+            "saved": 2,
+            "ok": True,
+            "providers": ["google"],
+            "provider_usage": [
+                {
+                    "provider": "google",
+                    "provider_label": "Google",
+                    "key_label": "main · ****abcdef",
+                    "gen": 2,
+                }
+            ],
+        },
+        {
+            "ts": "2026-05-12T10:01:00+08:00",
+            "machine": "PC-2_BBBBBB",
+            "node": "image",
+            "model": "NanoBananaPro",
+            "batch": 1,
+            "gen": 1,
+            "saved": 1,
+            "ok": True,
+            "providers": ["google"],
+            "provider_usage": [
+                {
+                    "provider": "google",
+                    "provider_label": "Google",
+                    "key_label": "backup · ****123456",
+                    "gen": 1,
+                }
+            ],
+        },
+        {
+            "ts": "2026-05-12T10:02:00+08:00",
+            "machine": "PC-3_CCCCCC",
+            "node": "image",
+            "model": "OldModel",
+            "batch": 3,
+            "gen": 3,
+            "saved": 3,
+            "ok": True,
+            "providers": [],
+        },
+    ]
+
+    stats = compute_stats(records, date_filter="today")
+
+    assert stats["total_generated"] == 6
+    assert stats["models"] == {"NanoBananaPro": 2, "OldModel": 1}
+    assert stats["providers_usage"] == [
+        {
+            "provider": "google",
+            "provider_label": "Google",
+            "gen": 3,
+            "keys": [
+                {"key_label": "main · ****abcdef", "gen": 2},
+                {"key_label": "backup · ****123456", "gen": 1},
+            ],
+        }
+    ]
+
+
+def test_dashboard_has_provider_usage_as_top_level_tab():
+    assert "switchTab('providers')" in DASHBOARD_HTML
+    assert "供应商/API数量详情" in DASHBOARD_HTML
+    assert 'id="page-providers"' in DASHBOARD_HTML
+
+    overview_start = DASHBOARD_HTML.index('id="page-overview"')
+    machines_start = DASHBOARD_HTML.index('id="page-machines"')
+    providers_start = DASHBOARD_HTML.index('id="page-providers"')
+    provider_list = DASHBOARD_HTML.index('id="providerUsageList"')
+
+    assert overview_start < machines_start < providers_start
+    assert provider_list > providers_start
+
+
+def test_provider_page_shows_chart_before_key_blocks():
+    assert 'id="providerChart"' in DASHBOARD_HTML
+    assert "let chartProvider" in DASHBOARD_HTML
+    assert "renderProviderChart(items);" in DASHBOARD_HTML
+
+    providers_start = DASHBOARD_HTML.index('id="page-providers"')
+    chart_start = DASHBOARD_HTML.index('id="providerChart"')
+    list_start = DASHBOARD_HTML.index('id="providerUsageList"')
+
+    assert providers_start < chart_start < list_start
+
+
+def test_recent_activity_table_has_provider_column():
+    table_start = DASHBOARD_HTML.index('id="recentTable"')
+    header_end = DASHBOARD_HTML.index("</thead>", table_start)
+    header_html = DASHBOARD_HTML[table_start:header_end]
+
+    assert "<th>供应商</th>" in header_html
+    assert "providerSummary(r)" in DASHBOARD_HTML
diff --git a/tests/test_independent_generator.py b/tests/test_independent_generator.py
index c5c16f5..265fd8c 100644
--- a/tests/test_independent_generator.py
+++ b/tests/test_independent_generator.py
@@ -312,6 +312,60 @@ def test_generate_reports_failed_batches(self):
         assert "Batch 1 failed: no provider" in result["error"]
         assert "Batch 2 failed: no provider" in result["error"]
 
+    def test_generate_aggregates_provider_usage_from_batches(self):
+        png_bytes = self._png_bytes()
+        responses = [
+            APIResponse(
+                success=True,
+                images=[png_bytes],
+                provider_usage=[
+                    {
+                        "provider": "google",
+                        "provider_label": "Google",
+                        "key_label": "main · ****abcdef",
+                        "gen": 1,
+                    }
+                ],
+            ),
+            APIResponse(
+                success=True,
+                images=[png_bytes],
+                provider_usage=[
+                    {
+                        "provider": "google",
+                        "provider_label": "Google",
+                        "key_label": "main · ****abcdef",
+                        "gen": 1,
+                    }
+                ],
+            ),
+        ]
+
+        with patch.object(self.gen, "execute_with_failover", side_effect=responses):
+            with patch.object(
+                self.gen,
+                "_save_single_image",
+                return_value={"filename": "ok.png", "subfolder": "", "type": "output"},
+            ):
+                result = asyncio.run(
+                    self.gen.generate(
+                        "model_a",
+                        "prompt",
+                        seed=10,
+                        batch_count=2,
+                    )
+                )
+
+        assert result["success"] is True
+        assert result["provider_usage"] == [
+            {
+                "provider": "google",
+                "provider_label": "Google",
+                "key_label": "main · ****abcdef",
+                "gen": 2,
+            }
+        ]
+
     def test_generate_hash_uses_only_successfully_decoded_images(self):
         valid_png = self._png_bytes()
         valid_b64 = "data:image/png;base64," + base64.b64encode(valid_png).decode("ascii")
diff --git a/tests/test_usage_tracker.py b/tests/test_usage_tracker.py
index 9dbf441..c661895 100644
--- a/tests/test_usage_tracker.py
+++ b/tests/test_usage_tracker.py
@@ -165,6 +165,52 @@ def test_record_failure(self, tracker_with_tmpdir, tmp_path):
         assert record["providers"] == ["Google", "Vertex"]
         assert record["gen"] == 0
 
+    def test_record_provider_usage_appends_without_replacing_existing_fields(self, tracker_with_tmpdir, tmp_path):
+        """Provider/key usage is additive and never stores full API keys."""
+        tracker = tracker_with_tmpdir
+        tracker.record(
+            node_type="image",
+            model="NanoBananaPro",
+            batch_count=2,
+            images_generated=2,
+            images_saved=1,
+            success=True,
+            providers_tried=["google"],
+            provider_usage=[
+                {
+                    "provider": "google",
+                    "provider_label": "Google",
+                    "key_label": "main · ****abcdef",
+                    "key": "sk-full-secret-abcdef",
+                    "gen": 2,
+                },
+            ],
+            duration_seconds=3.4,
+        )
+
+        import time
+        time.sleep(0.2)
+
+        local_dir = tmp_path / "local"
+        jsonl_files = list(local_dir.glob("usage_*.jsonl"))
+        with open(jsonl_files[0], "r", encoding="utf-8") as f:
+            record = json.loads(f.readline())
+
+        assert record["machine"] == "TEST-PC_AABBCC"
+        assert record["model"] == "NanoBananaPro"
+        assert record["gen"] == 2
+        assert record["saved"] == 1
+        assert record["providers"] == ["google"]
+        assert record["provider_usage"] == [
+            {
+                "provider": "google",
+                "provider_label": "Google",
+                "key_label": "main · ****abcdef",
+                "gen": 2,
+            }
+        ]
+        assert "sk-full-secret-abcdef" not in json.dumps(record, ensure_ascii=False)
+
     def test_nas_failure_graceful(self, tracker_with_tmpdir):
         """Test that NAS write failure doesn't crash."""
         tracker = tracker_with_tmpdir
diff --git a/usage_tracker.py b/usage_tracker.py
index fe2ba1f..4041cc4 100644
--- a/usage_tracker.py
+++ b/usage_tracker.py
@@ -29,6 +29,67 @@
 _TZ_CST = timezone(timedelta(hours=8))
 
 
+def _safe_text(value: Any, limit: int = 160) -> str:
+    text = str(value or "").strip()
+    return text[:limit]
+
+
+def _safe_key_label(value: Any) -> str:
+    label = _safe_text(value, 160)
+    if not label:
+        return "未记录Key"
+    if "****" in label:
+        return label
+    compact = label.replace("-", "").replace("_", "")
+    looks_secret = len(compact) >= 20 and any(c.isalpha() for c in compact) and any(c.isdigit() for c in compact)
+    if looks_secret and " " not in label:
+        return f"Key · ****{label[-6:]}"
+    return label
+
+
+def normalize_provider_usage(provider_usage: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
+    """Return safe provider/key usage entries for logs and dashboards."""
+    safe_entries: List[Dict[str, Any]] = []
+    if not provider_usage:
+        return safe_entries
+
+    for item in provider_usage:
+        if not isinstance(item, dict):
+            continue
+        try:
+            gen = int(item.get("gen", 0))
+        except (TypeError, ValueError):
+            continue
+        if gen <= 0:
+            continue
+
+        provider = _safe_text(item.get("provider") or item.get("provider_label") or "unknown", 80)
+        provider_label = _safe_text(item.get("provider_label") or provider, 120)
+        safe_entries.append({
+            "provider": provider or "unknown",
+            "provider_label": provider_label or provider or "unknown",
+            "key_label": _safe_key_label(item.get("key_label")),
+            "gen": gen,
+        })
+
+    return safe_entries
+
+
+def aggregate_provider_usage(provider_usage: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
+    """Aggregate safe usage entries by provider and key label."""
+    totals: Dict[tuple, Dict[str, Any]] = {}
+    for item in normalize_provider_usage(provider_usage):
+        key = (item["provider"], item["provider_label"], item["key_label"])
+        if key not in totals:
+            totals[key] = dict(item)
+        else:
+            totals[key]["gen"] += item["gen"]
+    return sorted(
+        totals.values(),
+        key=lambda x: (-x["gen"], x["provider_label"], x["key_label"]),
+    )
+
+
 def _get_mac_last6() -> str:
     """Get last 6 hex chars of the primary MAC address."""
     try:
@@ -229,6 +290,7 @@ def record(
         images_saved: int,
         success: bool,
         providers_tried: Optional[List[str]] = None,
+        provider_usage: Optional[List[Dict[str, Any]]] = None,
         error_message: str = "",
         duration_seconds: float = 0.0,
     ):
@@ -244,9 +306,20 @@ def record(
             images_saved: Images saved to output directory
             success: Whether the task succeeded
             providers_tried: List of provider names attempted
+            provider_usage: Safe provider/key image counts
             error_message: Error message if failed
             duration_seconds: Time taken in seconds
         """
+        safe_provider_usage = aggregate_provider_usage(provider_usage)
+        provider_list = list(providers_tried or [])
+        if not provider_list and safe_provider_usage:
+            seen = set()
+            for item in safe_provider_usage:
+                provider_name = item.get("provider", "unknown")
+                if provider_name not in seen:
+                    seen.add(provider_name)
+                    provider_list.append(provider_name)
+
         record = {
             "task_id": uuid.uuid4().hex[:12],
             "ts": datetime.now(_TZ_CST).isoformat(timespec="seconds"),
@@ -258,7 +331,8 @@ def record(
             "gen": images_generated,
             "saved": images_saved,
             "ok": success,
-            "providers": providers_tried or [],
+            "providers": provider_list,
+            "provider_usage": safe_provider_usage,
             "err": error_message[:200] if error_message else "",
         }