Stabilize the decision workspace data boundaries

The scan terminal had grown into overlapping CSS, request-state, AI-provider, and city-card data responsibilities. This refactor separates those boundaries without changing product behavior: CSS modules are split by surface, city AI prompt/provider/fallback logic is isolated, and scan terminal request state now has reusable RemoteData adapters plus business-state tests.

Constraint: Preserve existing global scan-terminal class names and API responses during the refactor

Constraint: No new dependencies; keep this as a file-boundary cleanup

Rejected: Introduce React Query now | higher migration risk than the requested lightweight query-client path

Rejected: Rewrite AI stream behavior | progressive/fallback states are product-sensitive and were only adapter-split

Confidence: high

Scope-risk: moderate

Reversibility: clean

Directive: Keep AI stream state changes covered by business snapshots before changing fallback/cache wording

Tested: npm run test:business; npx tsc --noEmit; npm run build; python pytest -q; ruff check; py_compile targeted city AI modules

Not-tested: Live DeepSeek provider network replay and browser visual QA

web/scan_city_ai_provider.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict
+
+import httpx
+from loguru import logger
+
+from web.scan_city_ai_fallback import (
+    _build_city_ai_fallback,
+    _complete_city_ai_payload,
+)
+from web.scan_city_ai_helpers import (
+    _extract_ai_json_object,
+    _extract_provider_content,
+    _provider_response_meta,
+    _truncate_ai_text,
+)
+from web.scan_city_ai_prompt import (
+    _normalize_locale,
+    build_city_ai_empty_retry_request,
+    build_city_ai_repair_request_json,
+    build_city_ai_request_json,
+)
+
+
+def _call_deepseek_city_ai(
+    ai_input: Dict[str, Any],
+    *,
+    locale: str = "zh-CN",
+    api_key: str,
+    base_url: str,
+    model: str,
+    max_tokens: int,
+    timeout_sec: int,
+) -> Dict[str, Any]:
+    if not api_key:
+        raise RuntimeError("POLYWEATHER_DEEPSEEK_API_KEY is not configured")
+    normalized_locale = _normalize_locale(locale)
+    timeout = httpx.Timeout(
+        timeout=float(timeout_sec),
+        connect=min(8.0, float(timeout_sec)),
+        read=float(timeout_sec),
+        write=10.0,
+        pool=5.0,
+    )
+    request_json = build_city_ai_request_json(
+        ai_input,
+        locale=normalized_locale,
+        model=model,
+        max_tokens=max_tokens,
+    )
+    provider_request = {
+        key: value
+        for key, value in request_json.items()
+        if not key.startswith("_polyweather_")
+    }
+    logger.info(
+        "scan city AI provider request city={} locale={} input_bytes={} max_tokens={} timeout_sec={}",
+        ai_input.get("city"),
+        normalized_locale,
+        len(json.dumps(provider_request, ensure_ascii=False, default=str).encode("utf-8")),
+        request_json.get("max_tokens"),
+        timeout_sec,
+    )
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    with httpx.Client(timeout=timeout) as client:
+        response = client.post(
+            f"{base_url}/chat/completions",
+            headers=headers,
+            json=provider_request,
+        )
+        response.raise_for_status()
+        data = response.json()
+        content = _extract_provider_content(data)
+        if not str(content or "").strip():
+            logger.warning(
+                "scan city AI provider returned empty content city={} locale={} finish_reason={} retrying_without_json_mode=true",
+                ai_input.get("city"),
+                normalized_locale,
+                _provider_response_meta(data).get("finish_reason"),
+            )
+            retry_payload = build_city_ai_empty_retry_request(request_json)
+            response = client.post(
+                f"{base_url}/chat/completions",
+                headers=headers,
+                json=retry_payload,
+            )
+            response.raise_for_status()
+            data = response.json()
+            content = _extract_provider_content(data)
+        try:
+            parsed = _extract_ai_json_object(str(content or ""))
+        except ValueError as exc:
+            preview = _truncate_ai_text(content, 700)
+            logger.warning(
+                "scan city AI provider returned non-json city={} locale={} finish_reason={} content_preview={}",
+                ai_input.get("city"),
+                normalized_locale,
+                _provider_response_meta(data).get("finish_reason"),
+                preview,
+            )
+            repair_payload = build_city_ai_repair_request_json(
+                ai_input=ai_input,
+                locale=normalized_locale,
+                model=model,
+                max_tokens=max_tokens,
+                previous_error=str(exc),
+                previous_content=_truncate_ai_text(content, 5000),
+            )
+            try:
+                repair_response = client.post(
+                    f"{base_url}/chat/completions",
+                    headers=headers,
+                    json=repair_payload,
+                )
+                repair_response.raise_for_status()
+                repair_data = repair_response.json()
+                repair_content = _extract_provider_content(repair_data)
+                parsed = _extract_ai_json_object(str(repair_content or ""))
+                if isinstance(parsed, dict):
+                    parsed["_polyweather_meta"] = {
+                        **_provider_response_meta(repair_data),
+                        "repaired_from_non_json": True,
+                        "original_finish_reason": _provider_response_meta(data).get("finish_reason"),
+                        "original_content_preview": preview,
+                    }
+                    return _complete_city_ai_payload(
+                        parsed,
+                        ai_input,
+                        locale=normalized_locale,
+                    )
+            except Exception as repair_exc:
+                logger.warning(
+                    "scan city AI provider json repair failed city={} locale={} error={}",
+                    ai_input.get("city"),
+                    normalized_locale,
+                    repair_exc,
+                )
+            return _build_city_ai_fallback(
+                ai_input,
+                locale=normalized_locale,
+                reason=str(exc),
+                raw_content=str(content or ""),
+                provider_data=data,
+            )
+    if isinstance(data, dict):
+        parsed["_polyweather_meta"] = _provider_response_meta(data)
+    return _complete_city_ai_payload(
+        parsed,
+        ai_input,
+        locale=normalized_locale,
+    )