@tokenbuddy/tokenbuddy 1.0.29 → 1.0.31

package/src/daemon.ts

@@ -36,7 +36,9 @@ import {
   isBuyerVisibleRegistrySeller,
   normalizeSellerUrl,
   RegistryTooLargeError,
+  type ModelCatalogEntry,
   type RegistrySeller,
+  type SellerCatalogEntry,
   type SellerManifest,
   type SellerRegistryDocument,
   type SellerRegistryTrustMetadata,
@@ -49,9 +51,10 @@ import { SellerPool, type FailureKind } from "./seller-pool.js";
 import { RouteFailover, type FailoverDecision, type RouteCandidate } from "./route-failover.js";
 import { PrewarmScheduler, type PrewarmReason, type SellerProber } from "./prewarm-scheduler.js";
 import { SellerConcurrencyLimiter, type SellerConcurrencyLimiterOptions } from "./seller-concurrency-limiter.js";
+import { SellerMetadataCache } from "./seller-metadata-cache.js";
 import type { PoolEntry } from "./seller-pool.js";
 import { planSellerRouteSet } from "./seller-route-planner.js";
-import type { SellerRoutePlan } from "./seller-route-planner.js";
+import type { SellerRouteMetric, SellerRoutePlan } from "./seller-route-planner.js";
 import {
   assertSellerRoutingConfig,
   mergeSellerRoutingConfig,
@@ -294,6 +297,14 @@ interface SellerHealthBody {
     lastErrorClass?: unknown;
     last_error_class?: unknown;
   };
+  latency?: {
+    ttftMs?: unknown;
+    ttft_ms?: unknown;
+    avgInferenceMs?: unknown;
+    avg_inference_ms?: unknown;
+    avgTokensPerSecond?: unknown;
+    avg_tokens_per_second?: unknown;
+  };
   capacity?: {
     activeConnections?: unknown;
     active_connections?: unknown;
@@ -316,6 +327,11 @@ interface SellerSettlementSummary {
   priceVersion?: string;
 }
 
+interface SellerAttemptRequestContext {
+  requestId: string;
+  idempotencyKey: string;
+}
+
 interface SellerBalanceSnapshot {
   creditMicros: number;
   reservedMicros: number;
@@ -413,6 +429,23 @@ function parseSellerSettlementObject(raw: string): SellerSettlementSummary | und
   }
 }
 
+function sellerAttemptRequestContext(
+  requestId: string,
+  idempotencyKey: string,
+  routeIndex: number,
+  attempt: number,
+  retryOrdinal: number
+): SellerAttemptRequestContext {
+  if (routeIndex === 0 && attempt === 0 && retryOrdinal === 0) {
+    return { requestId, idempotencyKey };
+  }
+  const suffix = `r${routeIndex}_a${attempt}_n${retryOrdinal}`;
+  return {
+    requestId: `${requestId}_${suffix}`,
+    idempotencyKey: `${idempotencyKey}_${suffix}`
+  };
+}
+
 function arrayLength(value: unknown): number | undefined {
   return Array.isArray(value) ? value.length : undefined;
 }
@@ -558,6 +591,7 @@ export class TokenbuddyDaemon {
   // "fetchRegistry + manifest per request" path.
   private readonly modelIndex = new ModelIndex();
   private readonly prewarmCache = new PrewarmCache();
+  private readonly sellerMetadataCache = new SellerMetadataCache();
   private readonly creditTracker = new CreditTracker();
   private readonly sellerPool = new SellerPool({
     modelIndex: this.modelIndex,
@@ -626,11 +660,15 @@ export class TokenbuddyDaemon {
         const now = Date.now();
         const body = await res.json() as SellerHealthBody;
         const upstream = body.upstream;
+        const latency = body.latency;
         const upstreamErrorClass = upstream?.lastErrorClass ?? upstream?.last_error_class;
         return {
           ok: true,
           latencyMs: now - startedAt,
           httpStatus: res.status,
+          ttftMs: finiteNumber(latency?.ttftMs ?? latency?.ttft_ms),
+          avgInferenceMs: finiteNumber(latency?.avgInferenceMs ?? latency?.avg_inference_ms),
+          avgTokensPerSecond: finiteNumber(latency?.avgTokensPerSecond ?? latency?.avg_tokens_per_second),
           upstreamStatus: typeof upstream?.status === "string"
             ? upstream.status as "healthy" | "degraded" | "unhealthy" | "unknown"
             : undefined,
@@ -857,6 +895,7 @@ export class TokenbuddyDaemon {
   // trades freshness for availability: requests still route, but the
   // model set is whatever was cached before the registry outgrew 1MB.
   private lastRegistrySnapshot: SellerRegistryDocument | null = null;
+  private forceRegistrySnapshotForTest = false;
 
   private async fetchRegistry(): Promise<SellerRegistryDocument> {
     try {
@@ -1106,7 +1145,7 @@ export class TokenbuddyDaemon {
     const payments = this.livePayments().filter((payment) => payment.enabled);
     const clients = this.clientToolsSummary();
     const routeModelId = this.resolveFocusSet()[0] || catalog.models[0]?.id;
-    const routingPreview = routeModelId ? this.buildRoutingPreview({ modelId: routeModelId, routing: currentRouting }) : undefined;
+    const routingPreview = routeModelId ? await this.buildRoutingPreview({ modelId: routeModelId, routing: currentRouting }) : undefined;
     const checks: InitDoctorCheck[] = [
       {
         id: "local_service",
@@ -1229,6 +1268,42 @@ export class TokenbuddyDaemon {
     }
   }
 
+  private async refreshSellerRuntimeMetrics(route: SellerRoute, requestId: string | undefined): Promise<void> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const ac = new AbortController();
+      timer = setTimeout(() => ac.abort(new Error("health timeout")), this.config.warmupProbeTimeoutMs ?? 3000);
+      const startedAt = Date.now();
+      const res = await fetch(`${route.seller.url.replace(/\/+$/, "")}/health`, { signal: ac.signal });
+      if (!res.ok) {
+        logger.warn("pool.runtime_metrics.refresh_failed", "seller health refresh failed after inference", {
+          requestId,
+          sellerId: route.seller.id,
+          status: res.status,
+          durationMs: Date.now() - startedAt
+        });
+        return;
+      }
+      const body = await res.json() as SellerHealthBody;
+      const latency = body.latency;
+      this.sellerPool.recordRuntimeMetrics(route.seller.id, {
+        ttftMs: finiteNumber(latency?.ttftMs ?? latency?.ttft_ms),
+        avgInferenceMs: finiteNumber(latency?.avgInferenceMs ?? latency?.avg_inference_ms),
+        avgTokensPerSecond: finiteNumber(latency?.avgTokensPerSecond ?? latency?.avg_tokens_per_second)
+      });
+    } catch (error: unknown) {
+      logger.warn("pool.runtime_metrics.refresh_failed", "seller health refresh failed after inference", {
+        requestId,
+        sellerId: route.seller.id,
+        errorMessage: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  }
+
   private endpointProtocol(endpoint: string): string | undefined {
     if (endpoint === "/v1/chat/completions") {
       return "chat_completions";
@@ -1337,6 +1412,7 @@ export class TokenbuddyDaemon {
 
     const routing = resolveSellerRoutingForModel(this.refreshSellerRoutingConfig(), modelId);
     const registrySellers = reorderDefaultSellerFirst(registry.sellers, registry.defaultSeller);
+    await this.refreshSellerRouteMetadata(registrySellers);
     this.sellerPool.ensureRegistrySellers(registrySellers);
     this.scheduleLazyPrewarmIfNeeded(modelId, protocol, paymentMethod);
     this.sellerPool.recycleOpenCircuits();
@@ -1350,21 +1426,12 @@ export class TokenbuddyDaemon {
       registrySellers,
       routing,
       prewarmCandidates: this.prewarmCache.get(modelId, protocol, paymentMethod)?.candidates,
-      sellerMetrics: Array.from(poolById.values()).map((entry) => ({
-        sellerId: entry.sellerId,
-        healthScore: entry.healthScore,
-        avgLatencyMs: entry.avgLatencyMs,
-        ttftMs: entry.ttftMs,
-        avgInferenceMs: entry.avgInferenceMs,
-        circuit: entry.circuit,
-        capacityBlockedUntil: entry.capacityBlockedUntil,
-        ...(concurrencySnapshot.enabled
-          ? {
-              localConcurrencyActive: localConcurrencyBySellerId.get(entry.sellerId) ?? 0,
-              localConcurrencyLimit: concurrencySnapshot.maxInFlightPerSeller
-            }
-          : {})
-      })),
+      sellerMetrics: Array.from(poolById.values()).map((entry) => this.routeMetricFromPoolEntry(entry, concurrencySnapshot.enabled
+        ? {
+            localConcurrencyActive: localConcurrencyBySellerId.get(entry.sellerId) ?? 0,
+            localConcurrencyLimit: concurrencySnapshot.maxInFlightPerSeller
+          }
+        : undefined)),
       now: Date.now()
     });
 
@@ -1667,7 +1734,8 @@ export class TokenbuddyDaemon {
     settlement: SellerSettlementSummary
   ): void {
     logger.info("token.balance.reconciled", "seller token balance reconciled from settlement", {
-      requestId: settlement.requestId || requestId,
+      requestId,
+      sellerRequestId: settlement.requestId !== requestId ? settlement.requestId : undefined,
       sellerKey: route.seller.id,
       model: route.modelId,
       remainingCreditMicros: settlement.remainingCreditMicros,
@@ -1681,8 +1749,8 @@ export class TokenbuddyDaemon {
   }
 
   private async listSellerBackedModels(): Promise<{
-    models: Array<{ id: string; sellerId: string; sellerName?: string; sellerUrl: string; supportedProtocols: string[]; paymentMethods: string[] }>;
-    sellers: Array<{ id: string; name?: string; url: string; status: string; manifestSellerId?: string; errorMessage?: string }>;
+    models: ModelCatalogEntry[];
+    sellers: SellerCatalogEntry[];
   }> {
     try {
       const catalog = await discoverSellerBackedModels(this.config.sellerRegistryUrl);
@@ -1696,7 +1764,7 @@ export class TokenbuddyDaemon {
       }
       return {
         models: catalog.models,
-        sellers: catalog.sellers
+        sellers: this.sellerCatalogWithRuntimeMetrics(catalog.sellers)
       };
     } catch (error) {
       const cached = this.loadTrustedRegistryCache(error);
@@ -1706,11 +1774,52 @@ export class TokenbuddyDaemon {
       const snapshot = catalogSnapshotFromRegistry(cached);
       return {
         models: snapshot.models,
-        sellers: snapshot.sellers
+        sellers: this.sellerCatalogWithRuntimeMetrics(snapshot.sellers)
+      };
+    }
+  }
+
+  private sellerCatalogWithRuntimeMetrics(sellers: SellerCatalogEntry[]): SellerCatalogEntry[] {
+    const runtimeBySellerId = new Map(this.sellerPool.snapshot().map((entry) => [entry.sellerId, entry]));
+    return sellers.map((seller) => {
+      const runtime = runtimeBySellerId.get(seller.id);
+      return {
+        ...seller,
+        ttftMs: runtime?.ttftMs ?? seller.ttftMs,
+        avgTokensPerSecond: runtime?.avgTokensPerSecond ?? seller.avgTokensPerSecond ?? 0
       };
+    });
+  }
+
+  private async refreshSellerRouteMetadata(sellers: RegistrySeller[]): Promise<void> {
+    try {
+      await this.sellerMetadataCache.refreshIfStale(sellers.filter(isBuyerVisibleRegistrySeller));
+    } catch (error: unknown) {
+      logger.warn("route.metadata.refresh_failed", "seller route metadata refresh failed", {
+        errorMessage: error instanceof Error ? error.message : String(error)
+      });
     }
   }
 
+  private routeMetricFromPoolEntry(
+    entry: PoolEntry,
+    concurrency?: { localConcurrencyActive: number; localConcurrencyLimit: number }
+  ): SellerRouteMetric {
+    const metadata = this.sellerMetadataCache.snapshot().find((item) => item.sellerId === entry.sellerId);
+    return {
+      sellerId: entry.sellerId,
+      healthScore: entry.healthScore,
+      avgLatencyMs: entry.avgLatencyMs,
+      ttftMs: entry.ttftMs,
+      avgInferenceMs: entry.avgInferenceMs,
+      avgTokensPerSecond: entry.avgTokensPerSecond,
+      discountRatio: metadata?.discountRatio,
+      circuit: entry.circuit,
+      capacityBlockedUntil: entry.capacityBlockedUntil,
+      ...(concurrency ?? {})
+    };
+  }
+
   private readUsage(bodyText: string): UsageSummary {
     const fallback: UsageSummary = {
       promptTokens: 0,
@@ -1779,8 +1888,11 @@ export class TokenbuddyDaemon {
     }
 
     const settledMicros = settlement?.settledMicros;
+    const sellerRequestId = settlement?.requestId && settlement.requestId !== requestId
+      ? settlement.requestId
+      : undefined;
     this.tokenStore.recordInferenceLedger({
-      requestId: settlement?.requestId || requestId,
+      requestId,
       sellerKey: route.seller.id,
       modelId: route.modelId,
       endpoint,
@@ -1805,7 +1917,7 @@ export class TokenbuddyDaemon {
       paymentMethod: extras?.paymentMethod
     });
     logger.info("inference.ledger.recorded", "safe inference ledger recorded", {
-      requestId: settlement?.requestId || requestId,
+      requestId,
       sellerKey: route.seller.id,
       model: route.modelId,
       endpoint,
@@ -1818,6 +1930,7 @@ export class TokenbuddyDaemon {
       completionTokens: usage.completionTokens,
       balanceSnapshotMicros: settlement?.remainingCreditMicros,
       balanceSource: settlement ? "seller_authoritative" : "estimated",
+      sellerRequestId,
       ttftMs: extras?.ttftMs,
       fallbackCount: extras?.fallbackCount,
       routeReason: extras?.routeReason,
@@ -2488,21 +2601,31 @@ export class TokenbuddyDaemon {
           // the `X-TokenBuddy-Deadline-Ms` header (PR-6) can propagate
           // it to their own upstream fetch via the same signal.
           const deadlineMs = this.requestDeadlineMs();
-          const sendSellerRequest = async (token: string) => {
+          const sendSellerRequest = async (token: string, retryOrdinal = 0) => {
+            const attemptContext = sellerAttemptRequestContext(
+              requestId,
+              idempotencyKey,
+              routeIndex,
+              attempt,
+              retryOrdinal
+            );
             const requestAc = new AbortController();
             const requestTimer = setTimeout(() => requestAc.abort(new Error("buyer deadline exceeded")), deadlineMs);
             const headers: Record<string, string> = {
               "Content-Type": "application/json",
               "Authorization": `Bearer ${token}`,
-              "X-Request-Id": requestId,
-              "Idempotency-Key": idempotencyKey
+              "X-Request-Id": attemptContext.requestId,
+              "Idempotency-Key": attemptContext.idempotencyKey
             };
             headers["X-TokenBuddy-Deadline-Ms"] = String(deadlineMs);
             try {
               return await fetch(`${sellerUrl}${endpoint}`, {
                 method: "POST",
                 headers,
-                body: JSON.stringify(upstreamBody),
+                body: JSON.stringify({
+                  ...upstreamBody,
+                  requestId: attemptContext.requestId
+                }),
                 signal: requestAc.signal
               });
             } finally {
@@ -2649,6 +2772,7 @@ export class TokenbuddyDaemon {
                 res.write(settlementTrailing.downstream);
               }
               res.end();
+              void this.refreshSellerRuntimeMetrics(route, requestId);
               this.recordReconciledInference(
                 route,
                 endpoint,
@@ -2675,6 +2799,7 @@ export class TokenbuddyDaemon {
             markFirstByte();
             res.send(responseBody);
             const usage = this.readUsage(responseBody);
+            void this.refreshSellerRuntimeMetrics(route, requestId);
             this.recordReconciledInference(
               route,
               endpoint,
@@ -3212,10 +3337,10 @@ export class TokenbuddyDaemon {
 
     // 2) GET /routing/preview — 算「假如改完会怎样」，不改 state
     //   query: modelId? protocol? paymentMethod? mode? scorer? sellerId? sellerIds?(逗号分隔)
-    controlApp.get("/routing/preview", (req, res) => {
+    controlApp.get("/routing/preview", async (req, res) => {
       try {
         const override = buildRoutingConfigFromQuery(req.query);
-        const result = this.buildRoutingPreview({
+        const result = await this.buildRoutingPreview({
           modelId: typeof req.query.modelId === "string" ? req.query.modelId : undefined,
           protocol: typeof req.query.protocol === "string" ? req.query.protocol : undefined,
           paymentMethod: typeof req.query.paymentMethod === "string" ? req.query.paymentMethod : undefined,
@@ -3244,7 +3369,7 @@ export class TokenbuddyDaemon {
     });
 
     // 3) PUT /routing/strategy — 写策略 + 热更新 + 返回 preview
-    controlApp.put("/routing/strategy", (req, res) => {
+    controlApp.put("/routing/strategy", async (req, res) => {
       try {
         const body = (req.body ?? {}) as Record<string, unknown>;
         const normalized = normalizeSellerRoutingConfig(body);
@@ -3258,7 +3383,7 @@ export class TokenbuddyDaemon {
           sellerId: current.sellerId,
           sellerIds: current.sellerIds
         });
-        const preview = this.buildRoutingPreview({ routing: current });
+        const preview = await this.buildRoutingPreview({ routing: current });
         const previewPayload = "error" in preview.plan
           ? { error: preview.plan.error }
           : {
@@ -3475,15 +3600,18 @@ export class TokenbuddyDaemon {
   /**
    * tb-ui v1 `GET /routing/preview` 和 `PUT /routing/strategy` 复用的 preview 计算。
    * 接受任意 routing 覆盖（来自 request body）算「假如改成这个，路由会是啥」。
-   * 不修改任何内部 state，**纯函数式**。
+   * 不修改 routing state；registry / seller metadata 可按需刷新，保证 preview
+   * 使用的候选和折扣信息与真实请求路径一致。
    */
-  public buildRoutingPreview(input: {
+  public async buildRoutingPreview(input: {
     modelId?: string;
     protocol?: string;
     paymentMethod?: string;
     routing?: Partial<BuyerSellerRoutingConfig>;
-  }): { modelId: string; protocol: string; paymentMethod: string; plan: SellerRoutePlan | { error: string } } {
-    const registry = this.lastRegistrySnapshot;
+  }): Promise<{ modelId: string; protocol: string; paymentMethod: string; plan: SellerRoutePlan | { error: string } }> {
+    const registry = this.lastRegistrySnapshot ?? (
+      this.forceRegistrySnapshotForTest ? null : await this.fetchRegistry()
+    );
     const focusFirst = this.resolveFocusSet()[0];
     const registryFirst = registry?.sellers[0]?.models?.[0];
     const modelId = input.modelId?.trim() || focusFirst || registryFirst || "";
@@ -3501,6 +3629,7 @@ export class TokenbuddyDaemon {
       : current;
     const resolvedRouting = resolveSellerRoutingForModel(routing, modelId);
     const registrySellers = reorderDefaultSellerFirst(registry.sellers, registry.defaultSeller);
+    await this.refreshSellerRouteMetadata(registrySellers);
     this.sellerPool.ensureRegistrySellers(registrySellers);
     const poolById = new Map(this.sellerPool.snapshot().map((entry) => [entry.sellerId, entry]));
     const plan = planSellerRouteSet({
@@ -3510,15 +3639,7 @@ export class TokenbuddyDaemon {
       registrySellers,
       routing: resolvedRouting,
       prewarmCandidates: this.prewarmCache.get(modelId, protocol, paymentMethod)?.candidates,
-      sellerMetrics: Array.from(poolById.values()).map((entry) => ({
-        sellerId: entry.sellerId,
-        healthScore: entry.healthScore,
-        avgLatencyMs: entry.avgLatencyMs,
-        ttftMs: entry.ttftMs,
-        avgInferenceMs: entry.avgInferenceMs,
-        circuit: entry.circuit,
-        capacityBlockedUntil: entry.capacityBlockedUntil
-      })),
+      sellerMetrics: Array.from(poolById.values()).map((entry) => this.routeMetricFromPoolEntry(entry)),
       now: Date.now()
     });
     return { modelId, protocol, paymentMethod, plan };
@@ -3569,12 +3690,13 @@ export class TokenbuddyDaemon {
   }
 
   /**
-   * @internal — test-only seam to inject a registry snapshot without
+   * @internal - test-only hook to inject a registry snapshot without
    * hitting the network. Used by `tests/control-plane-ui-endpoints.test.ts`
    * to drive `buildRoutingPreview` deterministically. Production code
    * must NOT call this; the real `fetchRegistry()` populates the snapshot.
    */
   public setLastRegistrySnapshotForTest(snapshot: SellerRegistryDocument | null): void {
+    this.forceRegistrySnapshotForTest = true;
     this.lastRegistrySnapshot = snapshot;
   }
 }

package/src/doctor-diagnostics.ts

@@ -341,7 +341,11 @@ function discountRatioFromSeller(seller: DoctorSellerEntry): number | undefined
 }
 
 function formatDiscountRatio(value: number): string {
-  return value.toFixed(2).replace(/\.?0+$/, "");
+  const ratio = Math.max(0, value);
+  if (ratio === 0) return "免费";
+  if (Math.abs(ratio - 1) < 0.0001) return "原价";
+  const folded = Math.round(ratio * 100) / 10;
+  return `${Number.isInteger(folded) ? String(folded) : folded.toFixed(1)}折`;
 }
 
 function formatUsdPer1m(microsPer1m: number): string {

package/src/prewarm-cache.ts

@@ -42,6 +42,8 @@ export interface PrewarmCandidate {
   ttftMs?: number;
   /** 平均推理延迟（毫秒），可选 */
   avgInferenceMs?: number;
+  /** 最近 10 分钟窗口内的平均输出吞吐（tokens/s），可选 */
+  avgTokensPerSecond?: number;
   /** 上游状态（与 seller 上报的语义对齐） */
   upstreamStatus?: "healthy" | "degraded" | "unhealthy" | "unknown";
   /** 上游错误类名（HTTP status / 错误码），仅在失败时存在 */
@@ -98,6 +100,8 @@ export interface PrewarmCandidateInput {
   ttftMs?: number;
   /** 平均推理延迟（毫秒），可选 */
   avgInferenceMs?: number;
+  /** 最近 10 分钟窗口内的平均输出吞吐（tokens/s），可选 */
+  avgTokensPerSecond?: number;
   /** 上游状态，可选 */
   upstreamStatus?: "healthy" | "degraded" | "unhealthy" | "unknown";
   /** 上游错误类名，可选 */
@@ -452,6 +456,7 @@ function toCandidate(input: PrewarmCandidateInput): PrewarmCandidate {
     healthProbeLatencyMs: finiteNonNegative(input.healthProbeLatencyMs),
     ttftMs: finiteNonNegative(input.ttftMs),
     avgInferenceMs: finiteNonNegative(input.avgInferenceMs),
+    avgTokensPerSecond: finiteNonNegative(input.avgTokensPerSecond),
     upstreamStatus: input.upstreamStatus,
     upstreamErrorClass: input.upstreamErrorClass,
     capacityBlockedUntil: finiteNonNegative(input.capacityBlockedUntil)

package/src/prewarm-scheduler.ts

@@ -35,6 +35,8 @@ export interface ProbeResult {
   ttftMs?: number;
   /** 平均推理延迟（毫秒），可选 */
   avgInferenceMs?: number;
+  /** 最近 10 分钟窗口内的平均输出吞吐（tokens/s），可选 */
+  avgTokensPerSecond?: number;
   /** 临时容量避让截止时间；大于当前时间时不参与路由 */
   capacityBlockedUntil?: number;
 }
@@ -499,6 +501,7 @@ export class PrewarmScheduler {
           healthProbeLatencyMs: result.latencyMs,
           ttftMs: result.ttftMs,
           avgInferenceMs: result.avgInferenceMs,
+          avgTokensPerSecond: result.avgTokensPerSecond,
           upstreamStatus: result.upstreamStatus,
           upstreamErrorClass: result.upstreamErrorClass,
           capacityBlockedUntil: result.capacityBlockedUntil
@@ -513,7 +516,8 @@ export class PrewarmScheduler {
           upstreamStatus: result.upstreamStatus,
           upstreamErrorClass: result.upstreamErrorClass,
           ttftMs: result.ttftMs,
-          avgInferenceMs: result.avgInferenceMs
+          avgInferenceMs: result.avgInferenceMs,
+          avgTokensPerSecond: result.avgTokensPerSecond
         });
       } else {
         candidates.push({
@@ -526,6 +530,7 @@ export class PrewarmScheduler {
           healthProbeLatencyMs: result.latencyMs,
           ttftMs: result.ttftMs,
           avgInferenceMs: result.avgInferenceMs,
+          avgTokensPerSecond: result.avgTokensPerSecond,
           upstreamStatus: result.upstreamStatus,
           upstreamErrorClass: result.upstreamErrorClass,
           capacityBlockedUntil: result.capacityBlockedUntil