sync: 165 file da Baida98/AI@2d40c46b (2026-08-21 15:45 UTC)

benchmarks/model_watch_adapter.py

@@ -10,8 +10,9 @@ from dataclasses import dataclass, field, replace
 import asyncio
 from enum import Enum
 import json
+import os
 import re
-from typing import Any, Mapping, Optional
+from typing import Any, Awaitable, Callable, Mapping, Optional
 
 import httpx
 
@@ -27,6 +28,43 @@ class CatalogStatus(str, Enum):
     MALFORMED = "malformed"
 
 
+@dataclass(frozen=True)
+class ModelWatchConfig:
+    """Safety gate for optional model updates.
+
+    Discovery remains observe-only by default. Auto-apply is enabled only when
+    the explicit flag and approval marker are both present; callers must also
+    provide an allowlist of provider/old/new model triples.
+    """
+
+    auto_apply_enabled: bool = False
+    approval_marker: str = ""
+    required_approval_marker: str = "I_UNDERSTAND_MODEL_UPDATES"
+    approved_updates: tuple[tuple[str, str, str], ...] = ()
+
+    @classmethod
+    def from_env(cls) -> "ModelWatchConfig":
+        raw_updates = os.getenv("MODEL_AUTO_APPLY_ALLOWLIST", "")
+        updates: list[tuple[str, str, str]] = []
+        for item in raw_updates.split(","):
+            parts = tuple(part.strip() for part in item.split("|"))
+            if len(parts) == 3 and all(parts):
+                updates.append(parts)  # type: ignore[arg-type]
+        return cls(
+            auto_apply_enabled=os.getenv("MODEL_AUTO_APPLY_ENABLED", "0").lower() in {"1", "true", "yes"},
+            approval_marker=os.getenv("MODEL_AUTO_APPLY_APPROVAL", ""),
+            approved_updates=tuple(updates),
+        )
+
+    @property
+    def can_auto_apply(self) -> bool:
+        return (
+            self.auto_apply_enabled
+            and self.approval_marker == self.required_approval_marker
+            and bool(self.approved_updates)
+        )
+
+
 @dataclass(frozen=True)
 class ProviderProfile:
     provider: str
@@ -147,9 +185,44 @@ class ProfileScan:
 class ObserveOnlyModelsAdapter:
     """Fetch a provider catalog and classify the result; never mutates state."""
 
-    def __init__(self, *, timeout_seconds: float = 8.0, client: httpx.AsyncClient | None = None):
+    def __init__(
+        self,
+        *,
+        timeout_seconds: float = 8.0,
+        client: httpx.AsyncClient | None = None,
+        config: ModelWatchConfig | None = None,
+    ):
         self.timeout_seconds = timeout_seconds
         self._client = client
+        self.config = config or ModelWatchConfig.from_env()
+
+    @property
+    def can_auto_apply(self) -> bool:
+        """True only when every explicit safety gate is satisfied."""
+        return self.config.can_auto_apply
+
+    async def apply_updates(
+        self,
+        updates: list[tuple[str, str, str]],
+        apply_callback: Callable[[str, str, str], Awaitable[None]],
+    ) -> dict[str, Any]:
+        """Apply only allowlisted updates through a caller-owned callback.
+
+        The adapter never receives a database client and cannot mutate state on
+        its own. With the default config this returns a dry-run result.
+        """
+        if not self.can_auto_apply:
+            return {"applied": False, "dry_run": True, "reason": "auto_apply_disabled"}
+        approved = set(self.config.approved_updates)
+        applied = 0
+        skipped = 0
+        for provider, old_model, new_model in updates:
+            if (provider, old_model, new_model) not in approved:
+                skipped += 1
+                continue
+            await apply_callback(provider, old_model, new_model)
+            applied += 1
+        return {"applied": applied > 0, "dry_run": False, "applied_count": applied, "skipped_count": skipped}
 
     async def list_models(self, profile: ProviderProfile) -> CatalogResult:
         url = models_url(profile.base_url)

main.py

@@ -191,6 +191,18 @@ for prefix, module_name in _ROUTER_MAP.items():
     except Exception as e:
         _logger.error(f"❌ Errore montaggio rotta {prefix}: {e}")
 
+# ── Memory sync protocol ─────────────────────────────────────────────────────
+# È una factory parametrica, quindi non può stare in _ROUTER_MAP. Riutilizza il
+# singleton lazy di state.py per evitare una seconda istanza di MemoryManager.
+try:
+    from memory.sync import create_memory_sync_router
+    from api.state import _get_mem_manager
+    _sync_router = create_memory_sync_router(_get_mem_manager())
+    app.include_router(_sync_router)
+    _logger.info("✅ Route montata: /api/memory/sync (da memory.sync)")
+except Exception as e:
+    _logger.error(f"❌ Errore montaggio memory sync router: {e}")
+
 # ── CLI Task Execution ────────────────────────────────────────────────────────
 async def run_cli_task(task_description: str):
     _logger.info(f"CLI: Avvio task richiesto: {task_description[:50]}...")

tests/test_cognitive_gaps.py

@@ -24,7 +24,8 @@ if _BACKEND not in sys.path:
     sys.path.insert(0, _BACKEND)
 
 def _run(coro):
-    return asyncio.get_event_loop().run_until_complete(coro)
+    """Esegue una coroutine anche quando Python non ha un event loop corrente."""
+    return asyncio.run(coro)
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -642,7 +643,9 @@ class TestCOG5WiringInUnifiedLoop(unittest.TestCase):
         """COG-5 wiring: in caso di drift, il messaggio viene aggiunto a exec_warn."""
         idx = self.src.find("goal_drift_detector")
         self.assertGreater(idx, 0)
-        block = self.src[idx: idx + 800]
+        # Il blocco COG-5 può crescere con il logging diagnostico: non usare
+        # una finestra corta che tronca l'append effettivo.
+        block = self.src[idx: idx + 2200]
         self.assertIn("exec_warn.append", block)
 
     def test_cog5_is_non_blocking(self):
@@ -650,7 +653,9 @@ class TestCOG5WiringInUnifiedLoop(unittest.TestCase):
         idx = self.src.find("goal_drift_detector")
         self.assertGreater(idx, 0)
         # La try/except deve precedere l'import
-        pre_block = self.src[max(0, idx - 200): idx + 800]
+        # L'import e il relativo guard devono restare nello stesso blocco COG-5;
+        # la finestra include anche il logging aggiunto dopo il fix originale.
+        pre_block = self.src[max(0, idx - 500): idx + 2200]
         self.assertIn("except Exception as _cog5_err", pre_block)
 
     def test_cog5_marker_in_source(self):

tests/test_model_watch_adapter.py

@@ -27,6 +27,41 @@ class ModelWatchAdapterTests(unittest.IsolatedAsyncioTestCase):
         transport = httpx.MockTransport(handler)
         return ObserveOnlyModelsAdapter(client=httpx.AsyncClient(transport=transport))
 
+    async def test_auto_apply_is_disabled_by_default(self):
+        adapter = ObserveOnlyModelsAdapter()
+        calls = []
+
+        async def callback(provider, old_model, new_model):
+            calls.append((provider, old_model, new_model))
+
+        result = await adapter.apply_updates([("groq", "old", "new")], callback)
+        self.assertFalse(adapter.can_auto_apply)
+        self.assertEqual(result["reason"], "auto_apply_disabled")
+        self.assertEqual(calls, [])
+
+    async def test_auto_apply_requires_marker_and_allowlist(self):
+        from benchmarks.model_watch_adapter import ModelWatchConfig
+
+        config = ModelWatchConfig(
+            auto_apply_enabled=True,
+            approval_marker="I_UNDERSTAND_MODEL_UPDATES",
+            approved_updates=(("groq", "old", "new"),),
+        )
+        adapter = ObserveOnlyModelsAdapter(config=config)
+        calls = []
+
+        async def callback(provider, old_model, new_model):
+            calls.append((provider, old_model, new_model))
+
+        result = await adapter.apply_updates(
+            [("groq", "old", "new"), ("gemini", "old", "new")],
+            callback,
+        )
+        self.assertTrue(adapter.can_auto_apply)
+        self.assertEqual(result["applied_count"], 1)
+        self.assertEqual(result["skipped_count"], 1)
+        self.assertEqual(calls, [("groq", "old", "new")])
+
     async def test_catalog_available_and_default_present(self):
         async def handler(request):
             self.assertEqual(request.url.path, "/openai/v1/models")

tests/test_regression_doc2.py

@@ -189,7 +189,7 @@ class TestMemorySyncRouterMount(unittest.TestCase):
                          f"Prefix sbagliato: {router.prefix}")
 
     def test_sync_router_has_required_endpoints(self):
-        """Doc2-1b: router espone /status, /push, /pull."""
+        """Doc2-1b: router espone status, push e pull sotto il prefisso API."""
         try:
             from memory.sync import create_memory_sync_router
         except ImportError as e:
@@ -204,9 +204,9 @@ class TestMemorySyncRouterMount(unittest.TestCase):
 
         router = create_memory_sync_router(_MemStub())
         paths = {r.path for r in router.routes}
-        self.assertIn("/status", paths, "/status mancante dal sync router")
-        self.assertIn("/push",   paths, "/push mancante dal sync router")
-        self.assertIn("/pull",   paths, "/pull mancante dal sync router")
+        self.assertIn("/api/memory/sync/status", paths, "status mancante dal sync router")
+        self.assertIn("/api/memory/sync/push",   paths, "push mancante dal sync router")
+        self.assertIn("/api/memory/sync/pull",   paths, "pull mancante dal sync router")
 
     def test_main_py_mounts_sync_router(self):
         """
@@ -282,9 +282,17 @@ class TestTerminalRoutingNotFixedOnSpaceA(unittest.TestCase):
         src = self._read(self._AGENT_SSE)
         idx_chain = src.find("_getBackendChain")
         self.assertNotEqual(idx_chain, -1, "_getBackendChain non trovato in agentSSE.ts")
-        chain_block = src[idx_chain: idx_chain + 1500]
-        self.assertIn("baida-a-terminal.hf.space", chain_block,
-                      "Backend verificato non trovato nella catena di fallback")
+        chain_block = src[idx_chain: idx_chain + 1800]
+        # In produzione il contratto corrente è il proxy same-origin CF Worker;
+        # in locale la catena è interamente configurata tramite ENV.*.
+        self.assertIn('if (isProd) return ["/api"]', chain_block,
+                      "Il routing production non usa il proxy same-origin /api")
+        for env_name in (
+            "ENV.BACKEND_URL", "ENV.BACKEND_URL_2", "ENV.BACKEND_URL_C",
+            "ENV.BACKEND_URL_D", "ENV.BACKEND_URL_E", "ENV.BACKEND_URL_HF_B",
+        ):
+            self.assertIn(env_name, chain_block,
+                          f"Fallback configurabile mancante: {env_name}")
         self.assertNotIn("arjanit98-terminal.hf.space", chain_block,
                          "Space ritirato presente nella catena di fallback")
         self.assertNotIn("baida00-ai-backend-collab.hf.space", chain_block,

tests/test_scaffold_project.py

@@ -37,8 +37,8 @@ if _BACKEND not in sys.path:
 
 
 def _run(coro):
-    """Esegui coroutine in modo compatibile con Python 3.10+."""
-    return asyncio.get_event_loop().run_until_complete(coro)
+    """Esegue una coroutine anche quando Python non ha un event loop corrente."""
+    return asyncio.run(coro)
 
 
 # ═══════════════════════════════════════════════════════════════════════════════