""" unified_loop.py — Unified Agent Loop v4 v5 (S197) — Long-prompt file extraction + never-give-up + adaptive timeout: - _compress_goal(): estrae blocchi codice >1800 chars come file virtuali [FILE:N] → riduce token sul provider, elimina timeout su prompt lunghi. - _build_messages(): inietta CODICE_FORNITO come sezione separata nel contesto. - _run_fallback(): timeout adattivo 1.8x quando ci sono file estratti. - never-give-up: rileva frasi di rifiuto ("non posso", "i cannot", ...) e riprova con forza-risposta al 3° tentativo. - Regola system prompt: MAI dire non posso — problem solver assoluto. v4 (S193) — Fix definitivo tool execution: - _run_direct_tools(): layer deterministico che chiama TOOL_REGISTRY direttamente senza passare per smolagents o LLM per il routing. Copre: get_weather, read_page, calculate, web_search. - Architettura: direct_tools FIRST -> se dati reali -> LLM con dati iniettati. smolagents solo per multi-step complessi senza match diretto. - _needs_tools() regex espansa: copre tutti i pattern reali delle domande utente. - System prompt aggiornato: regole di onesta su self-knowledge e training data. - SMOL_TIMEOUT: leggibile da env UNIFIED_LOOP_TIMEOUT (default 25s, era 12s). """ from __future__ import annotations import asyncio import logging import os import re from agents.watchdog import BidirectionalWatchdog from .grid_rag import get_grid_rag from memory.distiller import MemoryDistiller from contextvars import ContextVar from typing import Any _logger = logging.getLogger("agente_ai") # S624: logger per warning sui fallback silenziosi # Tool execution layer (estratto in split module per ridurre dimensione) from agents.unified_loop_tools import DirectToolsMixin from agents.unified_loop_prompts import PromptBuilderMixin from agents.unified_loop_llm import LLMSelectionMixin from agents.unified_loop_helpers import HelpersMixin # RF-2: context_manager lazy import — skeleton injection per sessioni multi-file (S364/S752-A) # Import lazy per evitare circular deps — chiamato solo al runtime quando necessario def _get_context_manager(): from agents.context_manager import get_context_for_goal as _gcfg return _gcfg LLM_TIMEOUT: float = float(os.getenv("LLM_CALL_TIMEOUT", "60")) # QF-2: default 35→60s TOOL_TIMEOUT: float = float(os.getenv("TOOL_CALL_TIMEOUT", "25")) # QF-2: default 12→25s # Types/helpers/state estratti in unified_loop_types.py (P20-TD1 Fase 1) from agents.unified_loop_types import ( StepCallback, _detect_user_lang, _LANG_INSTRUCTIONS, _TASK_VERBS_RE, _ANALYTICAL_VERBS_RE, # Item 1+5: min-length gate + fast-pass non-coding _is_goal_ambiguous, _is_borderline_ambiguous, UnifiedLoopState, _maybe_await, ) # S404: Error Classifier — import lazy per evitare circular import issues def _get_classifier(): from agents.error_classifier import classify_error, format_for_context return classify_error, format_for_context # P17-F2: Upstash REST reader — chiamata dal loop all'avvio per iniettare # le scoperte critiche dei delegate frontend nel context dell'agente backend. # Pattern identico a blackboard.py; duplicato qui per zero import circolare. async def _read_bb_upstash(session_id: str) -> str: """Legge le entry critiche dal blackboard Upstash. Ritorna '' se non disponibile.""" _url = os.getenv("UPSTASH_REDIS_REST_URL", "") _token = os.getenv("UPSTASH_REDIS_REST_TOKEN", "") if not _url or not _token or not session_id: return "" import json as _bb_json import httpx as _bb_httpx try: async with _bb_httpx.AsyncClient(timeout=1.5) as _c: _hdr = {"Authorization": f"Bearer {_token}", "Content-Type": "application/json"} _sr = await _c.post( _url, json=["SCAN", "0", "MATCH", f"bb:{session_id}:*", "COUNT", "50"], headers=_hdr, ) _sd = _sr.json() if _sr.is_success else {} _sc = _sd.get("result", []) _keys = _sc[1] if (isinstance(_sc, list) and len(_sc) >= 2 and isinstance(_sc[1], list)) else [] if not _keys: return "" _mr = await _c.post(_url, json=["MGET"] + _keys, headers=_hdr) _md = _mr.json() if _mr.is_success else {} _out = [] for _v in _md.get("result", []): if _v: try: _e = _bb_json.loads(_v) if _e.get("severity") == "critical": _agid = _e.get("agentId", "") _key = _e.get("key", "") _val = str(_e.get("value", ""))[:200] _out.append(f"- [{_agid}] {_key}: {_val}") except Exception as _d_err: _logger.debug("[unified_loop] delegate parse silenced: %s", type(_d_err).__name__) return ("SCOPERTE CRITICHE DAI DELEGATI:\n" + "\n".join(_out)) if _out else "" except Exception as _d_outer_err: _logger.debug("[unified_loop] _get_delegate_findings silenced: %s", type(_d_outer_err).__name__) return "" # ── Nuovi mixin estratti (split 2026-06-30) ────────────────────────────────── from agents.unified_loop_vfs import VFSMixin from agents.unified_loop_delegate import DelegateMixin from agents.unified_loop_routing import RoutingMixin from agents.unified_loop_fallback import FallbackMixin class UnifiedAgentLoop( VFSMixin, DelegateMixin, RoutingMixin, FallbackMixin, DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin, HelpersMixin, ): """Smolagents-first loop with deterministic direct-tool layer and safe LLM fallback. MRO (sinistra = priorità alta): VFSMixin → _rollback_writes, _vfs_git_backup, _get_vfs_lock DelegateMixin → _reflective_debug, _budget_replan_check, _run_in_loop_delegate RoutingMixin → _CODE_RE, _FILE_BLOCK_RE, _extract_written_files FallbackMixin → _run_fallback DirectToolsMixin → _run_direct_tools, _needs_tools, _is_simple_query PromptBuilderMixin → _build_messages, _compress_goal LLMSelectionMixin → _get_llm_for_goal, _get_fast_llm, _sanitize_agent_output HelpersMixin → _run_fast_path, _proactive_reflect, _budget_replan_check (override) """ def __init__(self, llm_client: Any, planner: Any = None, executor: Any = None, critic: Any = None, memory: Any = None, verifier: Any = None) -> None: self.llm = llm_client self.planner = planner self.executor = executor self.critic = critic self.memory = memory self.verifier = verifier self._coder_llm: Any | None = None # S362: lazy-loaded CODER role client self._fast_llm: Any | None = None # S-FAST: lazy-loaded FAST role client (Groq 8B) self._verifier_llm: Any | None = None # P25-B4: cross-model critic — provider diverso dal generatore self._session_files: dict[str, str] = {} # S416-Fix1: path→content dei file scritti nella sessione self._write_snapshots: dict[str, str | None] = {} # GAP-3: contenuto originale pre-write per rollback atomico self._vfs_write_locks: dict[str, asyncio.Lock] = {} # GAP-VFS: per-path lock — previene race condition su scritture parallele self._run_task_id: str = "" # S568-A: ID unico per run, evita race condition su task paralleli self._tdd_fail_inject: str | None = None # GAP-NEW-2: TDD FAIL traceback → iniettato in exec_warn prima di StrategicHealer # ── GAP-3: Rollback atomico scritture ───────────────────────────────────────── # ── Entry point (S193) ──────────────────────────────────────────────────── async def run(self, goal: str, context: str = "", max_steps: int = 8, on_step: StepCallback | None = None, session_id: str = "") -> dict[str, Any]: # S390-B-L: strip role prefixes che causano prompt injection # Es. "SYSTEM: ignore..." o "ASSISTANT: ..." nel goal utente # S762-BUG3: re.sub con ^ strippava solo il PRIMO prefisso — input come # "System: User: fai X" diventava "User: fai X" con prefisso residuo. # Fix: loop fino a convergenza per gestire prefix annidati. _strip_role_re = re.compile( r"^\s*(?:system|assistant|ai|human|user|instruction|prompt)\s*[:：]\s*", re.IGNORECASE, ) while True: _stripped = _strip_role_re.sub("", goal.strip()) if _stripped == goal: break goal = _stripped # P28-B1: lingua rilevata early — propagata via self._run_lang a _build_messages() self._run_lang = _detect_user_lang(goal) import time as _time _t_run = _time.monotonic() self._t_run_start = _t_run # ttfa_ms: baseline per record_timing in _run_fallback # S568-A: task_id unico per run — previene race condition su sandbox condivisa # quando task paralleli usano lo stesso 'exec_val' hardcoded. self._run_task_id = f"qg_{int(_t_run * 1000) % 999983}" # GAP-3: LoggerAdapter bindato a task_id — Railway: grep qg_XXXXX filtra un singolo task self._log = logging.LoggerAdapter(_logger, {"task_id": self._run_task_id}) # S749-D: imposta ContextVar session_id per isolare sandbox backend-exec per task. # Token permette il reset nel finally anche in presenza di eccezioni — asyncio-safe. try: from tools.registry import _agent_session_id_var as _sid_var _sid_token = _sid_var.set(self._run_task_id) except Exception as _imp_err: _logger.debug("[unified_loop] sid_var import silenced: %s", type(_imp_err).__name__) _sid_token = None # fallback silente — registry usa default "agent_default" # S750-GAP-B: pre-warm sandbox backend-exec — POST /api/session in background. # asyncio.create_task lancia la richiesta senza bloccare il routing: # mentre il LLM classifica il goal (~200-500ms), la sandbox su Railway è già pronta. try: from tools.registry import _call_exec_engine as _ce, _EXEC_ENGINE_URL as _eurl if _eurl: asyncio.ensure_future( _ce({"session_id": self._run_task_id}, endpoint="/api/session") ) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 # S568-B: reset _session_files ogni run — previene memory leak su sessioni lunghe. # Il dict cresce durante _run_fallback e non veniva mai azzerato tra chiamate. self._session_files = {} self._write_snapshots = {} # GAP-3: reset snapshot per ogni run # S568-C: max_steps adattivo — code goals complessi necessitano più step di 8. # Bump a 12 solo se il caller non ha sovrascritto il default (max_steps == 8) # e il goal contiene keyword codice rilevate da _CODE_RE. if max_steps == 8 and self._CODE_RE.search(goal): max_steps = 12 state = UnifiedLoopState(goal=goal, context=context, max_steps=max_steps, session_id=session_id) # S766-GRID: Grid-Enhanced RAG Context grid_rag = get_grid_rag() _grid_context = await grid_rag.prepare_agent_context(state.goal) if _grid_context: state.context += f"\n\n{_grid_context}" # GAP-4: StrategicHealer — init + load past failures (LLM-based self-healing cognitivo) try: from agents.strategic_healer import StrategicHealer as _SHClass self._strategic_healer = _SHClass( getattr(self, 'llm', None) or getattr(self, '_llm', None), state.goal, memory=getattr(self, 'memory', None) or getattr(self, '_memory', None) ) await self._strategic_healer.load_past_failures() _logger.info("GAP-4: StrategicHealer inizializzato per goal '%s'", state.goal[:60]) except Exception as _sh_init_err: self._strategic_healer = None _logger.debug("GAP-4: StrategicHealer init silenced — %s", _sh_init_err) # P17-F2: inject blackboard critical entries at loop start. # I delegate frontend scrivono su Upstash; il loop legge e inietta nel context. if session_id: try: _bb_ctx = await _read_bb_upstash(session_id) if _bb_ctx: state.context = (state.context + "\n\n" + _bb_ctx).strip() if state.context else _bb_ctx _logger.info("[P17-F2] BB ctx injected (%d chars)", len(_bb_ctx)) except Exception as _bb_exc: _logger.debug("[P17-F2] BB read silenced: %s", _bb_exc) # GAP-DECISION-FIX: consulta blacklist prima di eseguire fix già rifiutati try: from api.decision_memory import is_blacklisted as _is_bl _bl_hit, _bl_reason = _is_bl(goal) if _bl_hit: self._log.warning("decision_memory: goal in blacklist — %s", _bl_reason[:100]) if on_step: await _maybe_await(on_step({ "action": "blacklist_warn", "status": "warning", "title": "⚠️ Fix già rifiutato in precedenza", "explanation": _bl_reason[:200], })) # Fail-open: logghiamo e proseguiamo — non blocchiamo task legittimi except Exception as _dm_err: _logger.debug("[unified_loop] decision_memory check silenced: %s", type(_dm_err).__name__) # non disponibile — continua normalmente # P29-B1: gate ambiguità strutturale — _is_goal_ambiguous() era P28-B2 dead code (mai chiamata). # Zero LLM, <0.1ms. Lingua-aware via self._run_lang (P28-B1). Fires dopo blacklist e prima del routing. if _is_goal_ambiguous(goal): _amb_map = { 'en': ( "Your message is too short or doesn't contain a clear action.\n\n" "Try being more specific, for example:\n" "\u2022 'Analyze this code: ...'\n" "\u2022 'Create a function that does X'\n" "\u2022 'Search for information about Y'" ), 'es': ( "Tu mensaje es demasiado corto o no contiene una acci\u00f3n clara.\n\n" "Intenta ser m\u00e1s espec\u00edfico, por ejemplo:\n" "\u2022 'Analiza este c\u00f3digo: ...'\n" "\u2022 'Crea una funci\u00f3n que haga X'" ), 'fr': ( "Votre message est trop court ou ne contient pas d'action claire.\n\n" "Essayez d'\u00eatre plus pr\u00e9cis, par exemple:\n" "\u2022 'Analysez ce code: ...'\n" "\u2022 'Cr\u00e9ez une fonction qui fait X'" ), } _amb_answer = _amb_map.get( getattr(self, '_run_lang', 'auto'), "Il tuo messaggio \u00e8 troppo breve o non contiene un'azione chiara.\n\n" "Prova a essere pi\u00f9 specifico, ad esempio:\n" "\u2022 'Analizza questo codice: ...'\n" "\u2022 'Crea una funzione che fa X'\n" "\u2022 'Cerca informazioni su Y'", ) if on_step: await _maybe_await(on_step({ "action": "ambiguity_gate", "status": "done", "title": "Specifica cosa vuoi fare", "explanation": _amb_answer, })) _r_amb = {"answer": _amb_answer, "timing_ms": 0, "effective_max_steps": state.max_steps} if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) return _r_amb # P29-R1: borderline ambiguity gate — goal con verbo ma oggetto pronominale vago. # Cattura "fix it", "help me with this", "make it better" — goal che passano # _is_goal_ambiguous() perché hanno un verbo, ma mancano di oggetto specifico. # Zero LLM, <0.1ms. Produce domanda mirata in IT/EN/ES/FR (vs. generica P29-B1). _borderline, _bl_pattern = _is_borderline_ambiguous(goal) if _borderline: _lang = getattr(self, '_run_lang', 'auto') _BL_MSGS: dict[str, dict[str, str]] = { 'fix_pronoun': { 'it': ( "Cosa devo fixare? 🔍\n\n" "Per aiutarti ho bisogno di:\n" "\u2022 Il codice o il file da correggere\n" "\u2022 Il messaggio di errore (se presente)\n" "\u2022 Cosa ti aspetti che faccia" ), 'en': ( "What needs fixing? 🔍\n\n" "To help you I need:\n" "\u2022 The code or file to fix\n" "\u2022 The error message (if any)\n" "\u2022 What you expect it to do" ), 'es': ( "\u00bfQué necesita arreglarse? 🔍\n\n" "Para ayudarte necesito:\n" "\u2022 El código o archivo a corregir\n" "\u2022 El mensaje de error (si lo hay)\n" "\u2022 Qué esperas que haga" ), 'fr': ( "Qu'est-ce qui doit être réparé ? 🔍\n\n" "Pour vous aider j'ai besoin de :\n" "\u2022 Le code ou le fichier à corriger\n" "\u2022 Le message d'erreur (s'il y en a un)\n" "\u2022 Ce que vous attendez" ), }, 'help_vague': { 'it': ( "Su cosa posso aiutarti? 💡\n\n" "Descrivimi il task specifico:\n" "\u2022 Cosa stai cercando di fare\n" "\u2022 Qual è il problema attuale\n" "\u2022 Incolla codice/errori rilevanti se ce ne sono" ), 'en': ( "What can I help you with? 💡\n\n" "Describe the specific task:\n" "\u2022 What you're trying to accomplish\n" "\u2022 What the current problem is\n" "\u2022 Paste any relevant code/errors" ), 'es': ( "\u00bfCon qué puedo ayudarte? 💡\n\n" "Describe el task específico:\n" "\u2022 Qué estás intentando hacer\n" "\u2022 Cuál es el problema actual\n" "\u2022 Pega código/errores relevantes si los hay" ), 'fr': ( "Avec quoi puis-je vous aider ? 💡\n\n" "Décrivez la tâche spécifique :\n" "\u2022 Ce que vous essayez d'accomplir\n" "\u2022 Quel est le problème actuel\n" "\u2022 Collez le code/erreurs pertinents s'il y en a" ), }, 'make_vague': { 'it': ( "Cosa vuoi migliorare o far funzionare? \u2699\ufe0f\n\n" "Dimmi:\n" "\u2022 Cosa non funziona o cosa va migliorato\n" "\u2022 Incolla il codice o descrivi il comportamento attuale\n" "\u2022 Qual è il risultato che ti aspetti" ), 'en': ( "What do you want to improve or fix? \u2699\ufe0f\n\n" "Tell me:\n" "\u2022 What's not working or what needs improvement\n" "\u2022 Paste the code or describe the current behavior\n" "\u2022 What result you expect" ), 'es': ( "\u00bfQué quieres mejorar o arreglar? \u2699\ufe0f\n\n" "Dime:\n" "\u2022 Qué no funciona o qué necesita mejora\n" "\u2022 Pega el código o describe el comportamiento actual\n" "\u2022 Qué resultado esperas" ), 'fr': ( "Que voulez-vous améliorer ou réparer ? \u2699\ufe0f\n\n" "Dites-moi :\n" "\u2022 Ce qui ne fonctionne pas ou ce qui doit être amélioré\n" "\u2022 Collez le code ou décrivez le comportement actuel\n" "\u2022 Quel résultat vous attendez" ), }, } _lang_key = _lang if _lang in ('it', 'en', 'es', 'fr') else 'it' _bl_answer = _BL_MSGS.get(_bl_pattern, {}).get( _lang_key, "Puoi essere più specifico? Incolla il codice, l'errore, o descrivi cosa intendi." ) if on_step: await _maybe_await(on_step({ "action": "ambiguity_gate", "status": "done", "title": "Puoi essere più specifico?", "explanation": _bl_answer, })) _r_bl = {"answer": _bl_answer, "timing_ms": 0, "effective_max_steps": state.max_steps} if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) return _r_bl # Sprint 5 ITEM 13: classify_ms — tempo routing/classificazione goal (sync, <1ms) _t0_classify = _time.monotonic() # S402: Fast Path — greeting/ack/identità semplice → bypass tutto l'overhead if self._is_simple_query(goal): try: from api.state import record_timing as _rtc_cls _rtc_cls("classify_ms", (_time.monotonic() - _t0_classify) * 1000) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 _r = await self._run_fast_path(state, on_step) _r.setdefault("timing_ms", int((_time.monotonic() - _t_run) * 1000)) _r["effective_max_steps"] = state.max_steps # GAP-2-FIX # S749-D: reset ContextVar if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) # GAP-NEW-4: schedule VFS backup se ci sono file scritti nella sessione if self._session_files: asyncio.ensure_future(self._vfs_git_backup()) return _r if not self._needs_tools(goal): try: from api.state import record_timing as _rtc_cls _rtc_cls("classify_ms", (_time.monotonic() - _t0_classify) * 1000) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 # Puro ragionamento — LLM diretto, nessun overhead tool _r = await self._run_fallback(state, on_step) _r["timing_ms"] = int((_time.monotonic() - _t_run) * 1000) try: from api.state import record_timing as _rtc_ttr _rtc_ttr("ttr_ms", float(_r["timing_ms"])) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 _r["effective_max_steps"] = state.max_steps # GAP-2-FIX # S749-D: reset ContextVar if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) # GAP-NEW-4: schedule VFS backup se ci sono file scritti nella sessione if self._session_files: asyncio.ensure_future(self._vfs_git_backup()) return _r # S425-BugFix: _SKIP_SMOL_RE chiama direct_tools PRIMA (il commento S371 lo diceva # già — "direct tools + fallback" — ma il codice faceva solo _run_fallback senza tool). # Bug: query meteo/news/cerca non chiamavano mai i tool reali → LLM allucinava i dati # → ResponseVerifier girava su risposta inventata → retry → 20-60s inutili. # B5: query spiegazione pura → _run_fallback diretta (-20-30s risparmio) # Scenari: "cos'è X", "spiegami Y", "how does Z work?", "explain W" # Fail-open: se regex troppo larga → path normale (nessuna perdita) if self._is_pure_explanation(goal): try: from api.state import record_timing as _rtcB5 _rtcB5("classify_ms", (_time.monotonic() - _t0_classify) * 1000) except Exception as _rt_err: _logger.debug("[unified_loop] record_timing silenced: %s", type(_rt_err).__name__) _r = await self._run_fallback(state, on_step) _r["timing_ms"] = int((_time.monotonic() - _t_run) * 1000) _r["effective_max_steps"] = state.max_steps if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) if self._session_files: asyncio.ensure_future(self._vfs_git_backup()) return _r # P36: Hybrid Execution Router — Python code analysis fast path. # Se goal contiene keyword analisi + codice Python nel context/goal, # chiama python_analyze direttamente (<5ms) saltando planner+LLM (5-15s). # Latenza: 50-200ms vs 5-15s del percorso normale (-90%). Fail-open. _P36_ANALYZE_RE = re.compile( r'\b(anali[zs]za?|check\s+syntax|syntax\s+check|' r'complessit[\xe0a]\s+cod|nesting\s+max|struttura\s+cod|' r'errori?\s+sintassi|verifica\s+sintass|metriche\s+cod|' r'ast\s+pars|imports?\s+check|funzioni\s+definite)\b', re.IGNORECASE, ) if _P36_ANALYZE_RE.search(goal): _p36_src = (context or "") + "\n" + goal _p36_match = re.search(r'```(?:python|py)?\n([\s\S]*?)```', _p36_src) _p36_code = _p36_match.group(1).strip() if _p36_match else "" if not _p36_code and context: # context puro (no fence) — accetta se sembra Python if re.search(r'\bdef \w+|\bclass \w+|\bimport \w+|\bfor \w+\s+in\b', context): _p36_code = context.strip() if _p36_code and len(_p36_code) >= 20: try: from tools.registry import TOOL_REGISTRY as _P36_TR _p36_r = await asyncio.wait_for( _P36_TR["python_analyze"]["_fn"](code=_p36_code), timeout=5.0, ) _p36_out = [f"[ANALISI PYTHON — {_p36_r.get('summary', '?')}]"] for _p36e in _p36_r.get("errors", [])[:3]: _p36_out.append( "\u274c " + _p36e.get("type", "") + f" riga {_p36e.get('line','?')}: {_p36e.get('message','')}" + (f" \u2192 {_p36e['text']}" if _p36e.get("text") else "") ) _p36_c = _p36_r.get("complexity", {}) if _p36_c and _p36_r.get("syntax_ok"): _p36_out.append( "\u2705 Sintassi OK \u2014 " f"{_p36_c.get('total_lines',0)} righe, " f"{_p36_c.get('functions',0)} funzioni, " f"{_p36_c.get('classes',0)} classi, " f"imports {_p36_c.get('imports',0)}, " f"nesting max {_p36_c.get('max_nesting',0)}" ) for _p36s in _p36_r.get("suggestions", [])[:5]: _p36_out.append(f"\U0001f4a1 {_p36s}") _p36_answer = "\n".join(_p36_out) _p36_ms = int((_time.monotonic() - _t_run) * 1000) try: from api.state import increment_stat as _p36_stat _p36_stat("p36_fast_path_hit") except Exception as _is_err: _logger.debug("[unified_loop] increment_stat P36 silenced: %s", type(_is_err).__name__) _logger.info("P36 fast-path: python_analyze in %dms", _p36_ms) if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) return { "success": True, "answer": _p36_answer, "timing_ms": _p36_ms, "effective_max_steps": state.max_steps, "steps": [{"action": "p36_python_analyze", "status": "done", "output": _p36_answer[:300]}], } except Exception as _p36_exc: _logger.debug("P36 fast-path silenced: %s", _p36_exc) # fail-open: cade nel percorso normale if self._SKIP_SMOL_RE.search(goal): try: from api.state import record_timing as _rtc_cls _rtc_cls("classify_ms", (_time.monotonic() - _t0_classify) * 1000) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 _t_tool = _time.monotonic() direct_results, _tools_count, _exec_success, _exec_errors = \ await self._run_direct_tools(goal, on_step=on_step) _tool_ms = int((_time.monotonic() - _t_tool) * 1000) if direct_results and on_step: await _maybe_await(on_step({ "loop": 0, "action": "direct_tools", "status": "done", "tools_fired": _tools_count, })) _r = await self._run_fallback( state, on_step, preloaded_tool_results=direct_results or None, preloaded_tool_exec_successes=_exec_success, preloaded_tool_exec_errors=_exec_errors, ) _r["timing_ms"] = int((_time.monotonic() - _t_run) * 1000) try: from api.state import record_timing as _rtc_ttr _rtc_ttr("ttr_ms", float(_r["timing_ms"])) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 _r["tool_ms"] = _tool_ms _r["effective_max_steps"] = state.max_steps # GAP-2-FIX # S749-D: reset ContextVar if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) # GAP-NEW-4: schedule VFS backup se ci sono file scritti nella sessione if self._session_files: asyncio.ensure_future(self._vfs_git_backup()) return _r # Sprint 5 ITEM 13: classify_ms — path normale (tool diretti) try: from api.state import record_timing as _rtc_cls _rtc_cls("classify_ms", (_time.monotonic() - _t0_classify) * 1000) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 # S193: tool diretti PRIMA (deterministici, nessun LLM per routing) # S402: unpack 4-tuple — aggiunto _exec_success/_exec_errors per Tool Integrity Guard _t_tool = _time.monotonic() direct_results, _tools_count, _exec_success, _exec_errors = \ await self._run_direct_tools(goal, on_step=on_step) _tool_ms = int((_time.monotonic() - _t_tool) * 1000) if direct_results: # Dati reali disponibili — LLM risponde con dati iniettati if on_step: await _maybe_await(on_step({ "loop": 0, "action": "direct_tools", "status": "done", "tools_fired": _tools_count, })) _r = await self._run_fallback( state, on_step, preloaded_tool_results=direct_results, preloaded_tool_exec_successes=_exec_success, preloaded_tool_exec_errors=_exec_errors, ) _r["timing_ms"] = int((_time.monotonic() - _t_run) * 1000) try: from api.state import record_timing as _rtc_ttr _rtc_ttr("ttr_ms", float(_r["timing_ms"])) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 _r["tool_ms"] = _tool_ms _r["effective_max_steps"] = state.max_steps # GAP-2-FIX # S749-D: reset ContextVar if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__) # GAP-NEW-4: schedule VFS backup se ci sono file scritti nella sessione if self._session_files: asyncio.ensure_future(self._vfs_git_backup()) return _r # R1 S390: smolagents rimosso dal run() path. # _run_smolagents() aveva timeout 25s worst-case su task non classificati # e non aggiungeva valore rispetto a _run_fallback con tool results iniettati. # Rimosso: -25s worst case, path sempre: direct_tools → _run_fallback. # Fallback: LLM senza tool results (tool non triggered o tutti skip) _r = await self._run_fallback(state, on_step) _r["timing_ms"] = int((_time.monotonic() - _t_run) * 1000) try: from api.state import record_timing as _rtc_ttr _rtc_ttr("ttr_ms", float(_r["timing_ms"])) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 _r["effective_max_steps"] = state.max_steps # GAP-2-FIX # GAP-DECISION-FIX: registra fix falliti per blacklist futura if not _r.get("success", True): try: from api.decision_memory import record_decision as _rec_dec _fail_reason = _r.get("error", "") or str(_r.get("answer", ""))[:200] asyncio.ensure_future(_rec_dec( fix=goal, outcome="rejected", reason=f"run() returned success=False — {_fail_reason[:250]}", )) except Exception as _exc: _logger.debug("[unified_loop] silenced %s", type(_exc).__name__) # noqa: BLE001 # S749-D: reset ContextVar prima di uscire — libera la sandbox per il GC if _sid_token is not None: try: _sid_var.reset(_sid_token) except Exception as _sv_err: _logger.debug("[unified_loop] sid_var.reset silenced: %s", type(_sv_err).__name__)