Upload 2 files

backend/config.py

@@ -24,7 +24,7 @@ DATA_DIR.mkdir(exist_ok=True)
 MODELS_DIR.mkdir(exist_ok=True)
 
 class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_file=".env", enable_decoding=False)
+    model_config = SettingsConfigDict(env_file=".env", enable_decoding=False, extra="ignore")
 
     # App settings
     APP_NAME: str = "GAKR AI Chatbot"

backend/model_manager.py

@@ -1,9 +1,13 @@
 """Model manager that proxies inference requests to a Cloudflare Worker."""
 import asyncio
+import http.client
 import json
 import platform
+import socket
+import ssl
 from datetime import datetime
 from typing import Any, AsyncGenerator, Dict, List, Optional
+from urllib.parse import urlparse
 
 import httpx
 
@@ -73,6 +77,117 @@ class ModelManager:
     #  Worker communication                                               #
     # ------------------------------------------------------------------ #
 
+    @staticmethod
+    def _should_try_dns_fallback(exc: Exception) -> bool:
+        message = str(exc).lower()
+        indicators = [
+            "no address associated with hostname",
+            "name or service not known",
+            "temporary failure in name resolution",
+            "getaddrinfo failed",
+            "nodename nor servname provided",
+        ]
+        return any(indicator in message for indicator in indicators)
+
+    def _resolve_worker_ips(self) -> List[str]:
+        parsed = urlparse(self.worker_url)
+        hostname = parsed.hostname or ""
+        if not hostname:
+            return []
+
+        doh_endpoints = [
+            (
+                "https://cloudflare-dns.com/dns-query",
+                {"name": hostname, "type": "A"},
+                {"accept": "application/dns-json"},
+            ),
+            (
+                "https://dns.google/resolve",
+                {"name": hostname, "type": "A"},
+                {},
+            ),
+        ]
+
+        for endpoint, params, headers in doh_endpoints:
+            try:
+                with httpx.Client(timeout=10, trust_env=False, headers=headers) as client:
+                    response = client.get(endpoint, params=params)
+                    response.raise_for_status()
+                    payload = response.json()
+                answers = payload.get("Answer") or []
+                ips = [
+                    str(item.get("data") or "").strip()
+                    for item in answers
+                    if str(item.get("type") or "") == "1" and str(item.get("data") or "").strip()
+                ]
+                if ips:
+                    return ips
+            except Exception:
+                continue
+
+        return []
+
+    def _request_worker_via_resolved_ip(self, method: str, path: str, payload: Optional[dict], timeout: int) -> dict:
+        parsed = urlparse(self.worker_url)
+        hostname = parsed.hostname or ""
+        if not hostname:
+            raise RuntimeError("WORKER_URL hostname is empty")
+
+        port = parsed.port or (443 if (parsed.scheme or "https") == "https" else 80)
+        base_path = (parsed.path or "").rstrip("/")
+        request_path = f"{base_path}{path}" or "/"
+        body = b""
+        headers = {
+            "Host": hostname,
+            "Accept": "application/json",
+            "Connection": "close",
+            "User-Agent": "gakrchat-backend/1.0",
+        }
+
+        if payload is not None:
+            body = json.dumps(payload).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+            headers["Content-Length"] = str(len(body))
+
+        request_lines = [f"{method} {request_path} HTTP/1.1"]
+        request_lines.extend(f"{key}: {value}" for key, value in headers.items())
+        request_bytes = ("\r\n".join(request_lines) + "\r\n\r\n").encode("utf-8") + body
+
+        ips = self._resolve_worker_ips()
+        if not ips:
+            raise RuntimeError(f"Unable to resolve worker hostname via DNS-over-HTTPS: {hostname}")
+
+        ssl_context = ssl.create_default_context()
+        last_error: Optional[Exception] = None
+
+        for ip_address in ips:
+            try:
+                with socket.create_connection((ip_address, port), timeout=timeout) as raw_socket:
+                    with ssl_context.wrap_socket(raw_socket, server_hostname=hostname) as tls_socket:
+                        tls_socket.settimeout(timeout)
+                        tls_socket.sendall(request_bytes)
+                        response = http.client.HTTPResponse(tls_socket)
+                        response.begin()
+                        response_body = response.read()
+
+                if response.status >= 400:
+                    body_preview = response_body.decode("utf-8", errors="replace")[:500]
+                    raise httpx.HTTPStatusError(
+                        f"Worker returned status {response.status}: {body_preview}",
+                        request=None,
+                        response=None,
+                    )
+
+                try:
+                    return json.loads(response_body.decode("utf-8"))
+                except json.JSONDecodeError as exc:
+                    raise RuntimeError("Worker returned non-JSON response during DNS fallback") from exc
+            except Exception as exc:
+                last_error = exc
+                continue
+
+        raise RuntimeError(f"Worker DNS fallback failed: {last_error}")
+
     def load_model(self, force_reload: bool = False) -> bool:
         """Verify that the Cloudflare Worker is healthy and reachable."""
         if self._worker_healthy and not force_reload:
@@ -90,8 +205,22 @@ class ModelManager:
                     return True
                 self._last_error = f"Worker returned status: {data.get('status')}"
         except Exception as exc:
-            self._last_error = f"Worker health check failed: {exc}"
-            self._worker_healthy = False
+            if self._should_try_dns_fallback(exc):
+                try:
+                    data = self._request_worker_via_resolved_ip("GET", "/health", None, timeout=10)
+                    if data.get("status") == "ok":
+                        self._worker_healthy = True
+                        self._worker_model_name = data.get("model")
+                        self._last_error = None
+                        print(f"Worker healthy via DNS fallback: model={self._worker_model_name}")
+                        return True
+                    self._last_error = f"Worker returned status: {data.get('status')}"
+                except Exception as fallback_exc:
+                    self._last_error = f"Worker health check failed: {exc}; DNS fallback failed: {fallback_exc}"
+                    self._worker_healthy = False
+            else:
+                self._last_error = f"Worker health check failed: {exc}"
+                self._worker_healthy = False
         return False
 
     def unload_model(self):
@@ -101,13 +230,18 @@ class ModelManager:
 
     def _call_worker_sync(self, payload: dict) -> dict:
         """Synchronous POST to worker /chat endpoint."""
-        with httpx.Client(timeout=180, trust_env=False) as client:
-            resp = client.post(f"{self.worker_url}/chat", json=payload)
-            if resp.status_code >= 400:
-                body = resp.text[:500]
-                print(f"[WORKER] {resp.status_code} from {self.worker_url}/chat: {body}")
-                resp.raise_for_status()
-            return resp.json()
+        try:
+            with httpx.Client(timeout=180, trust_env=False) as client:
+                resp = client.post(f"{self.worker_url}/chat", json=payload)
+                if resp.status_code >= 400:
+                    body = resp.text[:500]
+                    print(f"[WORKER] {resp.status_code} from {self.worker_url}/chat: {body}")
+                    resp.raise_for_status()
+                return resp.json()
+        except Exception as exc:
+            if self._should_try_dns_fallback(exc):
+                return self._request_worker_via_resolved_ip("POST", "/chat", payload, timeout=180)
+            raise
 
     async def _stream_worker_sse(self, payload: dict) -> AsyncGenerator[dict, None]:
         """Streaming POST to worker /chat, yields parsed SSE events."""