feat: replace Kronos with Google TimesFM 2.5 (200M) forecaster

_ai_refactor.py

@@ -0,0 +1,166 @@
+import re
+path = r'd:\Python\Kronos_Platform_V1\frontend\index.html'
+with open(path, 'r', encoding='utf-8') as f:
+    content = f.read()
+
+# 1. Add fetchPaneAI function (or modify fetchAIAnalysis)
+# Actually, let's just append fetchPaneAI function before fetchAIAnalysis
+# and update the UI binding.
+
+new_fetch_code = """
+    // --- MULTI-PANE AI FETCH ---
+    async function fetchPaneAI(pane, options = {}) {
+      const symbol = pane.symbol;
+      const interval = pane.interval;
+      const horizon = pane.horizon || 24;
+      const requestKey = `${symbol}|${interval}|${horizon}`;
+
+      if (!options.force && pane.analysisRequestPromise && pane.analysisRequestKey === requestKey) {
+        return pane.analysisRequestPromise;
+      }
+
+      if (pane.analysisRetryTimer) {
+        clearTimeout(pane.analysisRetryTimer);
+        pane.analysisRetryTimer = null;
+      }
+      if (pane.analysisFetchController) {
+        pane.analysisFetchController.abort();
+      }
+
+      const controller = new AbortController();
+      pane.analysisFetchController = controller;
+      pane.analysisRequestKey = requestKey;
+
+      if (pane.paneId === Workspace.activePaneId && !pane.lastAnalysis?.payload) {
+         const panel = document.getElementById('analysisPanel');
+         panel.innerHTML = `<div class="dash-loading"><div class="loader-ring"></div><p>AI dang tinh toan...</p></div>`;
+      }
+
+      const requestPromise = (async () => {
+        try {
+          const fData = await DataCoordinator.fetchForecast(symbol, interval, horizon, controller.signal);
+          if (pane.symbol !== symbol || pane.interval !== interval) return null;
+
+          pane.lastAnalysis = { payload: fData, symbol, interval };
+          const hasForecast = Array.isArray(fData.forecast) && fData.forecast.length > 0;
+
+          if (hasForecast && pane.lastCandleData) {
+            const forecastPoints = fData.forecast;
+            const anchorPoint = { time: pane.lastCandleData.time, value: pane.lastCandleData.close };
+            const futurePoints = forecastPoints.filter(d => d && d.time !== undefined && d.p50 !== undefined && d.time !== pane.lastCandleData.time).map(d => ({ time: d.time, value: d.p50 }));
+            const p50 = [anchorPoint, ...futurePoints];
+            const p10 = [anchorPoint, ...forecastPoints.filter(d => d && d.time !== undefined && d.p10 !== undefined && d.time !== pane.lastCandleData.time).map(d => ({ time: d.time, value: d.p10 }))];
+            const p90 = [anchorPoint, ...forecastPoints.filter(d => d && d.time !== undefined && d.p90 !== undefined && d.time !== pane.lastCandleData.time).map(d => ({ time: d.time, value: d.p90 }))];
+
+            if (pane.forecastSeries) {
+               pane.forecastSeries.p50.setData([]);
+               pane.forecastSeries.p10.setData(p10);
+               pane.forecastSeries.p90.setData(p90);
+               
+               // For segments we need a helper since it's complex, or just ignore segments per-pane to keep it fast
+               // Actually we can reuse buildForecastSegmentSeries but pass the pane
+               buildPaneForecastSegments(pane, p50);
+            }
+          }
+
+          if (pane.paneId === Workspace.activePaneId) {
+             renderAnalysisPanel(symbol, interval, fData);
+             renderCompactGauges(symbol, interval, fData);
+             updateDashboardScale();
+          } else {
+             // For non-active panes, render gauges into their mini container
+             renderPaneGauges(pane, fData);
+          }
+
+          return fData;
+        } catch (e) {
+          if (e.name === 'AbortError') return null;
+          console.error(`[Pane ${pane.paneId}] AI Error:`, e);
+          return null;
+        } finally {
+          if (pane.analysisFetchController === controller) pane.analysisFetchController = null;
+        }
+      })();
+
+      pane.analysisRequestPromise = requestPromise;
+      try {
+         return await requestPromise;
+      } finally {
+         if (pane.analysisRequestPromise === requestPromise) {
+            pane.analysisRequestPromise = null;
+            pane.analysisRequestKey = null;
+         }
+      }
+    }
+
+    function buildPaneForecastSegments(pane, p50) {
+       if (!pane.forecastSeries || !pane.forecastSeries.segments) return;
+       const sGroup = pane.forecastSeries.segments;
+       sGroup.forEach(s => s.setData([]));
+       if (p50.length < 2) return;
+       for (let i = 0; i < p50.length - 1; i++) {
+          if (i >= sGroup.length) {
+             const ns = pane.chartInstance.addLineSeries({
+               color: 'rgba(34,211,238,0.8)', lineWidth: 2, lineStyle: 0,
+               crosshairMarkerVisible: false, lastValueVisible: false, priceLineVisible: false
+             });
+             sGroup.push(ns);
+          }
+          const pA = p50[i], pB = p50[i+1];
+          const clr = pB.value >= pA.value ? 'rgba(34,211,238,0.8)' : 'rgba(251,113,133,0.8)';
+          sGroup[i].applyOptions({ color: clr });
+          sGroup[i].setData([pA, pB]);
+       }
+    }
+
+    function renderPaneGauges(pane, payload) {
+       if (!pane.gaugesEl) return;
+       if (!payload || !payload.analysis) {
+          pane.gaugesEl.innerHTML = '';
+          return;
+       }
+       // Build mini gauges
+       const a = payload.analysis;
+       const tScore = typeof a.trend_score === 'number' ? a.trend_score : 50;
+       const sScore = typeof a.strength_score === 'number' ? a.strength_score : 50;
+       const vScore = typeof a.volatility_score === 'number' ? a.volatility_score : 50;
+       
+       const cT = tScore > 60 ? '#22d3ee' : (tScore < 40 ? '#fb7185' : '#94a3b8');
+       const cS = sScore > 60 ? '#818cf8' : (sScore < 40 ? '#fb7185' : '#94a3b8');
+       const cV = vScore > 60 ? '#fb923c' : (vScore < 40 ? '#2dd4bf' : '#94a3b8');
+
+       pane.gaugesEl.innerHTML = `
+          <div style="width:20px;height:20px;border-radius:50%;border:2px solid ${cT};display:flex;align-items:center;justify-content:center;background:var(--bg-depth);">
+             <span style="font-size:8px;font-weight:bold;color:${cT}">${tScore > 50 ? '↑' : '↓'}</span>
+          </div>
+       `;
+    }
+
+    // Replace the active pane listener
+    Workspace._onActivePaneChange = (newPaneId) => {
+       const pane = Workspace.getPane(newPaneId);
+       if (!pane) return;
+       // Sync toolbar
+       if (currentSymbol !== pane.symbol || timeframeSelect.value !== pane.interval) {
+          currentSymbol = pane.symbol;
+          searchInput.value = pane.symbol;
+          timeframeSelect.value = pane.interval;
+          if (window.initSymbolDetails) initSymbolDetails();
+       }
+       // Update AI Panel
+       if (pane.lastAnalysis?.payload) {
+          renderAnalysisPanel(pane.symbol, pane.interval, pane.lastAnalysis.payload);
+          renderCompactGauges(pane.symbol, pane.interval, pane.lastAnalysis.payload);
+          updateDashboardScale();
+       } else {
+          document.getElementById('analysisPanel').innerHTML = '';
+          document.getElementById('chartGauges').innerHTML = '';
+          fetchPaneAI(pane);
+       }
+    };
+
+    // Hook into loadPaneData
+"""
+
+with open('_ai_refactor.txt', 'w') as f:
+    f.write(new_fetch_code)

backend/main.py

@@ -107,7 +107,6 @@ from backend.startup_utils import (
     build_source_selftest_urls,
     clear_stale_ip_limits,
     run_source_selftest,
-    warmup_kronos,
 )
 from backend.symbol_utils import (
     assemble_market_peer_payload,
@@ -417,35 +416,33 @@ if IS_FROZEN:
 else:
     logger.info("Running in DEV mode. PROJECT_ROOT: %s", PROJECT_ROOT)
 
-KRONOS_PATH = os.path.join(CURRENT_DIR, "kronos_core")
-
-if KRONOS_PATH not in sys.path:
-    sys.path.append(KRONOS_PATH)
+# TimesFM 2.5 — replaces legacy local Kronos model
+TIMESFM_AVAILABLE = False
+TIMESFM_IMPORT_ERROR: Optional[str] = None
 
 if TORCH_IMPORT_ERROR:
-    KRONOS_AVAILABLE = False
-    logger.error("Torch import error: %s", TORCH_IMPORT_ERROR)
-    logger.warning("Kronos forecasting disabled because torch is unavailable")
+    TIMESFM_IMPORT_ERROR = TORCH_IMPORT_ERROR
+    logger.warning("TimesFM disabled because torch is unavailable: %s", TORCH_IMPORT_ERROR)
 else:
     try:
-        from model.kronos import Kronos, KronosTokenizer, KronosPredictor, calc_time_stamps
-        KRONOS_AVAILABLE = True
-        logger.info("Kronos loaded from: %s", KRONOS_PATH)
-    except Exception as ex:
-        KRONOS_AVAILABLE = False
-        logger.error("Kronos load error: %s", ex)
-        logger.warning("Kronos not found or failed at: %s — forecasting disabled", KRONOS_PATH)
-
-PRELOAD_KRONOS = os.getenv("KRONOS_PRELOAD", "1").strip().lower() not in {"0", "false", "no"}
+        import timesfm  # pip install timesfm[torch]
+        TIMESFM_AVAILABLE = True
+        logger.info("TimesFM library imported successfully")
+    except Exception as _tfm_ex:
+        TIMESFM_IMPORT_ERROR = str(_tfm_ex)
+        logger.error("TimesFM import error: %s", _tfm_ex)
+        logger.warning("TimesFM not installed — forecasting disabled. Run: pip install timesfm[torch]")
+
+PRELOAD_TIMESFM = os.getenv("TIMESFM_PRELOAD", "1").strip().lower() not in {"0", "false", "no"}
 STARTUP_STATE: Dict[str, Any] = {
-    "kronos": {
-        "available": KRONOS_AVAILABLE,
-        "preload_enabled": PRELOAD_KRONOS,
+    "timesfm": {
+        "available": TIMESFM_AVAILABLE,
+        "preload_enabled": PRELOAD_TIMESFM,
         "warming": False,
         "loaded": False,
         "device": "not_loaded",
-        "last_error": TORCH_IMPORT_ERROR if TORCH_IMPORT_ERROR else None,
-        "path": KRONOS_PATH,
+        "last_error": TIMESFM_IMPORT_ERROR,
+        "model": "google/timesfm-2.5-200m-pytorch",
     },
     "sources": {},
 }
@@ -4443,10 +4440,10 @@ async def lifespan(app: FastAPI):
     # Quick source reachability check (non-blocking)
     _start_background_task(_source_selftest(), "source-selftest")
     
-    if PRELOAD_KRONOS and KRONOS_AVAILABLE:
-        _start_background_task(_warmup_kronos(), "kronos-warmup")
-    elif not KRONOS_AVAILABLE:
-        STARTUP_STATE["kronos"]["last_error"] = TORCH_IMPORT_ERROR or "Kronos source import failed"
+    if PRELOAD_TIMESFM and TIMESFM_AVAILABLE:
+        _start_background_task(_warmup_timesfm(), "timesfm-warmup")
+    elif not TIMESFM_AVAILABLE:
+        STARTUP_STATE["timesfm"]["last_error"] = TIMESFM_IMPORT_ERROR or "TimesFM import failed"
     
     try:
         yield
@@ -4491,12 +4488,28 @@ def market_status_now() -> List[Dict[str, Any]]:
 # ──────────────────────────────────────────────────────────────────────────────
 # Kronos Forecaster (identical to v3, with CLIP_DEFAULT fix retained)
 # ──────────────────────────────────────────────────────────────────────────────
-class KronosForecaster:
-    MAX_CONTEXT = 512
-    MODEL_NAME  = "NeoQuasar/Kronos-base"
+class TimesFMForecaster:
+    """Async wrapper around Google TimesFM 2.5 (200M, PyTorch).
+
+    External contract identical to the old KronosForecaster / new TimesFMForecaster:
+        await forecaster.forecast(df, horizon=N, ...) -> {
+            p10, p50, p90,          # np.ndarray of shape (horizon,)
+            model_name, context_length,
+            input_semantics, output_semantics
+        }
+    Input:  OHLCV DataFrame; OHLC4 = (O+H+L+C)/4 computed internally.
+    Output: p10/p50/p90 future OHLC4 values for `horizon` future bars.
+    """
+    MAX_CONTEXT = 15_360          # TimesFM 2.5 supports up to 16 384 ctx
+    MODEL_HF_ID = "google/timesfm-2.5-200m-pytorch"
+    # quantile_forecast tensor indices (batch, horizon, 10)
+    # timesfm returns: [mean, q10, q20, q30, q40, q50, q60, q70, q80, q90]
+    _Q10 = 1
+    _Q50 = 5   # median
+    _Q90 = 9
 
     def __init__(self) -> None:
-        self._predictor: Optional[Any] = None
+        self._model: Optional[Any] = None
         self._loaded = False
         self._lock: Optional[asyncio.Lock] = None
         self._predict_lock: Optional[asyncio.Lock] = None
@@ -4517,52 +4530,13 @@ class KronosForecaster:
 
     @property
     def device(self) -> str:
-        return str(self._predictor.device) if self._predictor else "not_loaded"
-
-    @property
-    def _clip(self) -> float:
-        if self._predictor is None:
-            return CLIP_DEFAULT
-        return getattr(self._predictor, "clip", CLIP_DEFAULT)
-
-    @staticmethod
-    def _collapse_tokenizer_to_single_ohlc4_channel(tokenizer: Any) -> Any:
-        """
-        Convert the 6-channel public Kronos tokenizer into a true 1-channel
-        tokenizer for OHLC4 inference.
-
-        The encoder-side projection preserves the previous replicated-OHLC4
-        behaviour exactly by summing the O/H/L/C input weights, because the old
-        wrapper fed the same OHLC4 value into all four price channels.
-
-        The decoder-side projection emits a single OHLC4 channel by averaging
-        the original O/H/L/C output heads.
-        """
-        d_in = int(getattr(tokenizer, "d_in", 0) or 0)
-        if d_in == 1:
-            return tokenizer
-        if d_in != 6:
-            raise ValueError(f"Unsupported Kronos tokenizer d_in={d_in}; expected 6 for adapter collapse")
-
-        device = tokenizer.embed.weight.device
-        dtype = tokenizer.embed.weight.dtype
-
-        collapsed_embed = torch.nn.Linear(1, tokenizer.d_model, bias=tokenizer.embed.bias is not None).to(device=device, dtype=dtype)
-        collapsed_head = torch.nn.Linear(tokenizer.d_model, 1, bias=tokenizer.head.bias is not None).to(device=device, dtype=dtype)
-
-        with torch.no_grad():
-            collapsed_embed.weight.copy_(tokenizer.embed.weight[:, :4].sum(dim=1, keepdim=True))
-            if tokenizer.embed.bias is not None and collapsed_embed.bias is not None:
-                collapsed_embed.bias.copy_(tokenizer.embed.bias)
-
-            collapsed_head.weight.copy_(tokenizer.head.weight[:4].mean(dim=0, keepdim=True))
-            if tokenizer.head.bias is not None and collapsed_head.bias is not None:
-                collapsed_head.bias.copy_(tokenizer.head.bias[:4].mean().reshape(1))
-
-        tokenizer.embed = collapsed_embed
-        tokenizer.head = collapsed_head
-        tokenizer.d_in = 1
-        return tokenizer
+        if self._model is None:
+            return "not_loaded"
+        try:
+            params = list(self._model.parameters())
+            return str(params[0].device) if params else "cpu"
+        except Exception:
+            return "cpu"
 
     async def _lazy_load(self) -> None:
         if self._loaded:
@@ -4571,116 +4545,110 @@ class KronosForecaster:
         async with lock:
             if self._loaded:
                 return
-            if not KRONOS_AVAILABLE:
-                raise HTTPException(status_code=500, detail="Kronos not available")
+            if not TIMESFM_AVAILABLE:
+                raise HTTPException(
+                    status_code=503,
+                    detail="TimesFM not installed. Run: pip install timesfm[torch]",
+                )
             try:
-                device = ("cuda:0" if torch.cuda.is_available()
-                          else "mps" if (hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
-                          else "cpu")
-                logger.info("[Kronos] Loading on %s …", device)
-                tokenizer = await asyncio.to_thread(KronosTokenizer.from_pretrained, "NeoQuasar/Kronos-Tokenizer-base")
-                tokenizer = self._collapse_tokenizer_to_single_ohlc4_channel(tokenizer)
-                model     = await asyncio.to_thread(Kronos.from_pretrained, self.MODEL_NAME)
-                self._predictor = KronosPredictor(model, tokenizer, device=device, max_context=self.MAX_CONTEXT)
-                self._loaded = True
-                logger.info("[Kronos] Ready on %s", device)
-            except Exception as ex:
-                logger.error("[Kronos] Init failed: %s", ex)
-                raise HTTPException(status_code=500, detail=f"Kronos init failed: {ex}")
+                device = (
+                    "cuda" if torch.cuda.is_available()
+                    else "mps" if (hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
+                    else "cpu"
+                )
+                logger.info("[TimesFM] Loading %s on %s ...", self.MODEL_HF_ID, device)
 
-    @staticmethod
-    def _prepare_feature_frame(df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Prepare a true 1-channel OHLC4 frame for Kronos inference.
-        """
-        required_price_cols = ["open", "high", "low", "close"]
-        ohlc4 = df[required_price_cols].mean(axis=1).astype(np.float32)
-        return pd.DataFrame({"ohlc4": ohlc4}, index=df.index).astype(np.float32)
+                model = await asyncio.to_thread(
+                    timesfm.TimesFM_2p5_200M_torch.from_pretrained,
+                    self.MODEL_HF_ID,
+                )
+                # Apply inference config (must run after loading weights)
+                model.compile(
+                    timesfm.ForecastConfig(
+                        max_context=self.MAX_CONTEXT,
+                        normalize_inputs=True,
+                        use_continuous_quantile_head=True,
+                        force_flip_invariance=True,
+                        infer_is_positive=True,
+                        fix_quantile_crossing=True,
+                    )
+                )
 
-    @staticmethod
-    def _normalize_feature_matrix(
-        x: np.ndarray,
-        clip: float,
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-        """
-        Use the same normalization contract as KronosPredictor.predict():
-        std is stabilized by +1e-5 rather than replacing zero-std columns with 1.0.
-        """
-        x_mean = np.mean(x, axis=0).astype(np.float32)
-        x_scale = (np.std(x, axis=0) + 1e-5).astype(np.float32)
-        x_norm = np.clip((x - x_mean) / x_scale, -clip, clip).astype(np.float32)
-        return x_norm, x_mean, x_scale
-
-    async def forecast(self, df: pd.DataFrame, x_timestamp: pd.Series,
-                       y_timestamp: pd.Series, horizon: int,
-                       sample_count: int = 10) -> Dict[str, Any]:
+                self._model = model
+                self._loaded = True
+                STARTUP_STATE["timesfm"]["loaded"] = True
+                STARTUP_STATE["timesfm"]["device"] = device
+                logger.info("[TimesFM] Ready on %s", device)
+            except Exception as ex:
+                STARTUP_STATE["timesfm"]["last_error"] = str(ex)
+                logger.error("[TimesFM] Init failed: %s", ex, exc_info=True)
+                raise HTTPException(status_code=500, detail=f"TimesFM init failed: {ex}")
+
+    async def forecast(
+        self,
+        df: pd.DataFrame,
+        horizon: int,
+        # legacy kwargs from callers — absorbed and ignored
+        x_timestamp=None,
+        y_timestamp=None,
+        sample_count: int = 10,
+    ) -> Dict[str, Any]:
         await self._lazy_load()
-        assert self._predictor is not None
+        assert self._model is not None
         try:
-            if not isinstance(x_timestamp, pd.Series):
-                x_timestamp = pd.Series(x_timestamp.values if hasattr(x_timestamp, "values") else x_timestamp)
-            if not isinstance(y_timestamp, pd.Series):
-                y_timestamp = pd.Series(y_timestamp.values if hasattr(y_timestamp, "values") else y_timestamp)
-
-            prepared_df = self._prepare_feature_frame(df)
-            x = prepared_df[["ohlc4"]].values.astype(np.float32)
-
-            x_stamp = calc_time_stamps(x_timestamp).values.astype(np.float32)
-            y_stamp = calc_time_stamps(y_timestamp).values.astype(np.float32)
-
-            x_norm, x_mean, x_scale = self._normalize_feature_matrix(x, self._clip)
+            # Build single OHLC4 series: (O+H+L+C)/4
+            ohlc4 = (
+                df[["open", "high", "low", "close"]]
+                .mean(axis=1)
+                .astype(np.float32)
+                .values
+            )
 
-            x_norm  = x_norm[np.newaxis, :]
-            x_stamp = x_stamp[np.newaxis, :]
-            y_stamp = y_stamp[np.newaxis, :]
+            # Clip to model context limit (take the most-recent N bars)
+            context_len = min(len(ohlc4), self.MAX_CONTEXT)
+            ohlc4_ctx = ohlc4[-context_len:]
 
             t0 = time.time()
             predict_lock = await self._get_predict_lock()
             async with predict_lock:
-                samples = await asyncio.to_thread(
-                    self._predictor.generate,
-                    x=x_norm, x_stamp=x_stamp, y_stamp=y_stamp,
-                    pred_len=horizon, T=1.0, top_k=0, top_p=0.9,
-                    sample_count=sample_count, verbose=False, return_samples=True,
+                # model.forecast() expects list[np.ndarray]
+                point_forecast, quantile_forecast = await asyncio.to_thread(
+                    self._model.forecast,
+                    inputs=[ohlc4_ctx],
+                    horizon=horizon,
                 )
-            logger.info("[Kronos] %.2fs | horizon=%d samples=%d ctx=%d",
-                        time.time() - t0, horizon, sample_count, len(df))
+            elapsed = time.time() - t0
+            logger.info(
+                "[TimesFM] %.2fs | horizon=%d ctx=%d",
+                elapsed, horizon, context_len,
+            )
 
-            if "cuda" in self.device:
+            if torch is not None and torch.cuda.is_available():
                 torch.cuda.empty_cache()
 
-            ohlc4_samples = np.asarray(samples[0, :, :, 0], dtype=float)
-            # Some Kronos checkpoints return the full decoded sequence rather than
-            # only the requested pred_len. Keep the most recent horizon window so
-            # downstream logic always receives a forecast-length vector.
-            if ohlc4_samples.shape[1] > horizon:
-                ohlc4_samples = ohlc4_samples[:, -horizon:]
-            elif ohlc4_samples.shape[1] < horizon:
-                pad_width = horizon - ohlc4_samples.shape[1]
-                ohlc4_samples = np.pad(ohlc4_samples, ((0, 0), (0, pad_width)), mode="edge")
-
-            ohlc4_samples = ohlc4_samples * float(x_scale[0]) + float(x_mean[0])
-            p10 = np.percentile(ohlc4_samples, 10, axis=0)
-            p50 = np.percentile(ohlc4_samples, 50, axis=0)
-            p90 = np.percentile(ohlc4_samples, 90, axis=0)
+            # point_forecast:    (1, horizon)
+            # quantile_forecast: (1, horizon, 10)
+            p10 = quantile_forecast[0, :, self._Q10].astype(float)
+            p50 = quantile_forecast[0, :, self._Q50].astype(float)
+            p90 = quantile_forecast[0, :, self._Q90].astype(float)
 
             return {
                 "p10": p10,
                 "p50": p50,
                 "p90": p90,
-                "model_name":     self.MODEL_NAME,
-                "context_length": len(df),
-                "output_horizon": int(ohlc4_samples.shape[1]),
+                "model_name": self.MODEL_HF_ID,
+                "context_length": context_len,
+                "output_horizon": horizon,
                 "input_semantics": {
                     "feature_channels": ["ohlc4"],
                     "active_forecast_channels": ["ohlc4"],
-                    "ignored_channels": [],
+                    "ignored_channels": ["volume"],
                     "price_mode": "ohlc4_single_channel",
                     "base_signal": "ohlc4",
                     "volume_mode": "omitted",
                     "amount_mode": "omitted",
-                    "adapter_mode": "tokenizer_6ch_to_1ch_ohlc4",
-                    "normalization": "std_plus_epsilon_1e-5",
+                    "adapter_mode": "timesfm_native",
+                    "normalization": "timesfm_internal",
                 },
                 "output_semantics": {
                     "forecast_channel": "ohlc4",
@@ -4690,20 +4658,11 @@ class KronosForecaster:
                 },
             }
         except Exception as ex:
-            logger.error("[Kronos] Forecast failed: %s", ex, exc_info=True)
-            raise HTTPException(status_code=500, detail=f"Kronos prediction failed: {ex}")
-
-
-forecaster = KronosForecaster()
+            logger.error("[TimesFM] Forecast failed: %s", ex, exc_info=True)
+            raise HTTPException(status_code=500, detail=f"TimesFM prediction failed: {ex}")
 
 
-def _is_kronos_shape_mismatch_error(exc: Exception) -> bool:
-    detail = getattr(exc, "detail", exc)
-    text = str(detail)
-    return (
-        "size of tensor" in text
-        and "must match" in text
-    )
+forecaster = TimesFMForecaster()
 
 
 
@@ -4914,13 +4873,16 @@ async def _source_selftest():
         )
 
 
-async def _warmup_kronos() -> None:
-    """Load Kronos in the background so the first forecast is fast and health is explicit."""
-    await warmup_kronos(
-        forecaster=forecaster,
-        startup_kronos_state=STARTUP_STATE["kronos"],
-        logger=logger,
-    )
+async def _warmup_timesfm() -> None:
+    """Load TimesFM in the background so the first forecast is fast."""
+    try:
+        STARTUP_STATE["timesfm"]["warming"] = True
+        await forecaster._lazy_load()
+        STARTUP_STATE["timesfm"]["warming"] = False
+        logger.info("[TimesFM] Warmup complete — ready on %s", forecaster.device)
+    except Exception as ex:
+        STARTUP_STATE["timesfm"]["warming"] = False
+        logger.error("[TimesFM] Warmup failed: %s", ex)
 
 
 # ── Symbol / Interval listing ─────────────────────────────────────────────────
@@ -5242,7 +5204,7 @@ def _forecast_payload_is_current(cached: Optional[Dict[str, Any]]) -> bool:
 
     display = cached.get("display") or {}
     if (
-        display.get("mode") != "raw_kronos_ohlc4_line"
+        display.get("mode") != "raw_timesfm_ohlc4_line"
         or display.get("output_mode") != "single_future_ohlc4_line"
         or display.get("channels") != ["ohlc4"]
     ):
@@ -5258,7 +5220,7 @@ def _forecast_payload_is_current(cached: Optional[Dict[str, Any]]) -> bool:
         and semantics.get("feature_channels") == ["ohlc4"]
         and semantics.get("price_mode") == "ohlc4_single_channel"
         and semantics.get("base_signal") == "ohlc4"
-        and semantics.get("adapter_mode") == "tokenizer_6ch_to_1ch_ohlc4"
+        and semantics.get("adapter_mode") == "timesfm_native"
         and output_semantics.get("forecast_channel") == "ohlc4"
         and output_semantics.get("forecast_mode") == "single_future_ohlc4_line"
         and output_semantics.get("candle_projection") == "omitted"
@@ -5297,7 +5259,7 @@ async def _prepare_forecast_response_payload(
         refresh=refresh,
         min_context=FORECAST_CONTEXT,
     )
-    if not KRONOS_AVAILABLE:
+    if not TIMESFM_AVAILABLE:
         last_ohlc4 = (
             float(
                 np.mean(
@@ -5316,8 +5278,7 @@ async def _prepare_forecast_response_payload(
             "symbol": symbol,
             "interval": interval,
             "forecast_rows": [],
-            "error": "AI Forecaster is currently offline or not found in bundle.",
-            "path_checked": KRONOS_PATH,
+            "error": "TimesFM not installed. Run: pip install timesfm[torch]",
             "ai_runtime": {"mode": "local_only", "model": "offline"},
             "_data_list": data_list,
             "indicators_snapshot": indicators,
@@ -5334,12 +5295,12 @@ async def _prepare_forecast_response_payload(
                 "input_semantics": {
                     "feature_channels": ["ohlc4"],
                     "active_forecast_channels": ["ohlc4"],
-                    "ignored_channels": [],
+                    "ignored_channels": ["volume"],
                     "price_mode": "ohlc4_single_channel",
                     "base_signal": "ohlc4",
                     "volume_mode": "omitted",
                     "amount_mode": "omitted",
-                    "adapter_mode": "tokenizer_6ch_to_1ch_ohlc4",
+                    "adapter_mode": "timesfm_native",
                 },
                 "output_semantics": {
                     "forecast_channel": "ohlc4",
@@ -5363,49 +5324,19 @@ async def _prepare_forecast_response_payload(
     else:
         df_hist["amount"] = df_hist["amount"].fillna(0)
 
-    context_len = min(len(df_hist), KronosForecaster.MAX_CONTEXT)
+    # TimesFM handles context internally; pass the full available history
+    context_len = min(len(df_hist), TimesFMForecaster.MAX_CONTEXT)
     df_context = df_hist.tail(context_len).reset_index(drop=True)
 
     logger.info("[forecast] %s %s | ctx=%d/%d | horizon=%d", symbol, interval, context_len, len(df_hist), horizon)
 
     last_time = int(df_hist["time"].iloc[-1])
     step = STEP_SECONDS[interval]
-    y_timestamps = pd.Series(pd.to_datetime(
-        [last_time + step * (i + 1) for i in range(horizon)], unit="s", utc=True
-    ))
-
-    sample_count = 10 if forecaster.device in {"not_loaded", "cpu"} else 15
-
-    async def _run_model(model_df: pd.DataFrame) -> Dict[str, Any]:
-        return await forecaster.forecast(
-            df=model_df[["open", "high", "low", "close", "volume", "amount"]],
-            x_timestamp=model_df["timestamps"],
-            y_timestamp=y_timestamps,
-            horizon=horizon,
-            sample_count=sample_count,
-        )
 
-    try:
-        model_output = await _run_model(df_context)
-    except HTTPException as exc:
-        if not _is_kronos_shape_mismatch_error(exc) or context_len <= 504:
-            raise
-
-        fallback_context_len = min(context_len - 8, 504)
-        fallback_context_len = max(fallback_context_len, min(256, context_len))
-        if fallback_context_len >= context_len:
-            raise
-
-        logger.warning(
-            "[forecast] %s %s | Kronos shape mismatch at ctx=%d, retrying with ctx=%d",
-            symbol,
-            interval,
-            context_len,
-            fallback_context_len,
-        )
-        context_len = fallback_context_len
-        df_context = df_hist.tail(context_len).reset_index(drop=True)
-        model_output = await _run_model(df_context)
+    model_output = await forecaster.forecast(
+        df=df_context[["open", "high", "low", "close", "volume"]],
+        horizon=horizon,
+    )
 
     last_ohlc4 = float(df_hist[["open", "high", "low", "close"]].mean(axis=1).iloc[-1])
     last_close = last_ohlc4
@@ -5438,11 +5369,11 @@ async def _prepare_forecast_response_payload(
         "forecast_rows": forecast_rows,
         "from_persistent_cache": False,
         "model": {
-            "name": model_output.get("model_name", "Kronos-base"),
+            "name": model_output.get("model_name", TimesFMForecaster.MODEL_HF_ID),
             "context_length": int(model_output.get("context_length", context_len)),
             "quantiles": [0.1, 0.5, 0.9],
             "cache_version": CACHE_VERSION,
-            "sample_count": sample_count,
+            "sample_count": 0,  # TimesFM is deterministic; no sampling needed
             "input_semantics": model_output.get("input_semantics", {}),
             "output_semantics": model_output.get("output_semantics", {}),
         },
@@ -5453,7 +5384,7 @@ async def _prepare_forecast_response_payload(
         "_cache_origin": cache_origin,
         "ai_runtime": {
             "mode": "local_only",
-            "model": str(model_output.get("model_name", "Kronos-base")),
+            "model": str(model_output.get("model_name", TimesFMForecaster.MODEL_HF_ID)),
             "device": forecaster.device,
         },
     }
@@ -5501,7 +5432,7 @@ def _build_raw_close_bundle(
         "confidence": round(confidence, 2),
         "model_bias_pct": 0.0,
         "path_metrics": path_metrics,
-        "mode": "raw_kronos_ohlc4",
+        "mode": "raw_timesfm_ohlc4",
     }
 
 
@@ -5512,12 +5443,12 @@ async def _finalize_forecast_response_payload(payload: Dict[str, Any]) -> Dict[s
             "interval": payload["interval"],
             "forecast": payload.get("forecast_rows", []),
             "error": payload["error"],
-            "path_checked": payload.get("path_checked", KRONOS_PATH),
+            "path_checked": None,
             "display": {
-                "mode": "raw_kronos_ohlc4_line",
+                "mode": "raw_timesfm_ohlc4_line",
                 "channels": ["ohlc4"],
                 "output_mode": "single_future_ohlc4_line",
-                "uncertainty_source": "raw_kronos_ohlc4_quantiles",
+                "uncertainty_source": "timesfm_quantile_head",
                 "uses_anchor_blending": False,
             },
             "ai_runtime": payload.get("ai_runtime", {"mode": "local_only", "model": "offline"}),
@@ -5547,14 +5478,14 @@ async def _finalize_forecast_response_payload(payload: Dict[str, Any]) -> Dict[s
         "from_persistent_cache": payload.get("from_persistent_cache", False),
         "model": payload["model"],
         "display": {
-            "mode": "raw_kronos_ohlc4_line",
+            "mode": "raw_timesfm_ohlc4_line",
             "channels": ["ohlc4"],
             "output_mode": "single_future_ohlc4_line",
-            "uncertainty_source": "raw_kronos_ohlc4_quantiles",
+            "uncertainty_source": "timesfm_quantile_head",
             "uses_anchor_blending": False,
         },
         "ensemble": {
-            "mode": "raw_kronos_ohlc4",
+            "mode": "raw_timesfm_ohlc4",
             "model_weight": analysis_bundle["model_weight"],
             "anchor_weight": analysis_bundle["anchor_weight"],
             "trend_agreement": analysis_bundle["agreement"],
@@ -5722,10 +5653,10 @@ async def cache_stats(request: Request) -> Dict[str, Any]:
 # ── Health ────────────────────────────────────────────────────────────────────
 @app.get("/api/health")
 async def health_check() -> Dict[str, Any]:
-    STARTUP_STATE["kronos"]["loaded"] = forecaster.is_ready
-    STARTUP_STATE["kronos"]["device"] = forecaster.device
+    STARTUP_STATE["timesfm"]["loaded"] = forecaster.is_ready
+    STARTUP_STATE["timesfm"]["device"] = forecaster.device
     return {
-        "status":        "online" if KRONOS_AVAILABLE else "degraded",
+        "status":        "online" if TIMESFM_AVAILABLE else "degraded",
         "version":       APP_VERSION,
         "model_ready":   forecaster.is_ready,
         "device":        forecaster.device,
@@ -5736,7 +5667,7 @@ async def health_check() -> Dict[str, Any]:
         "cors_allow_origins": CORS_ALLOW_ORIGINS,
         "admin_auth_configured": ADMIN_TOKEN != DEFAULT_ADMIN_TOKEN,
         "request_metrics": REQUEST_METRICS.snapshot(),
-        "kronos":       STARTUP_STATE["kronos"],
+        "timesfm":      STARTUP_STATE["timesfm"],
         "startup_checks": STARTUP_STATE["sources"],
     }
 
@@ -5779,7 +5710,7 @@ async def get_metrics(request: Request):
         },
         "circuit_breakers": cb_stats,
         "sources": STARTUP_STATE["sources"],
-        "kronos_status": STARTUP_STATE["kronos"]["loaded"],
+        "timesfm_status": STARTUP_STATE["timesfm"]["loaded"],
     }
 
 

requirements.txt

@@ -8,9 +8,9 @@ ccxt==4.5.49
 torch==2.11.0
 aiofiles==25.1.0
 pytz==2026.1.post1
-einops==0.8.1
 huggingface_hub==0.33.1
 matplotlib==3.9.3
 tqdm==4.67.1
 safetensors==0.6.2
 python-dotenv==1.1.0
+timesfm[torch]>=2.0.0