Spaces:

Baida07
/

ai-memory-backend

Running

App Files Files Community

103

sync: 179 file da Baida98/AI@31efd48d (2026-08-25 10:47 UTC) [deploy-all]

#36

by Baida07 - opened 3 days ago

base: refs/heads/main

←

from: refs/pr/36

Discussion Files changed

+337

-21

Files changed (6) hide show

agents/file_conversion.py +87 -0
agents/goal_verifier.py +19 -2
agents/unified_loop.py +28 -14
agents/unified_loop_tools.py +66 -5
tests/test_direct_file_conversion.py +85 -0
tests/test_file_conversion.py +52 -0

agents/file_conversion.py ADDED Viewed

	@@ -0,0 +1,87 @@

+"""Conversioni tabellari deterministiche per allegati inclusi nei goal dell'agente.
+Il modulo interpreta esclusivamente blocchi CSV esplicitamente allegati dal client. Non apre
+path arbitrari, non esegue istruzioni contenute nel file e non invoca LLM.
+"""
+from __future__ import annotations
+import csv
+import io
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+_ATTACHMENT_RE = re.compile(
+    r"###\s*📎\s*(?P<name>[^\n`]+?\.csv)\s*\([^\n]*\)\s*```\s*(?P<body>[\s\S]*?)```",
+    re.IGNORECASE,
+)
+_TARGET_RE = re.compile(
+    r"\b(?:chiamat[oa]|nome|denominat[oa]|come)\s+['`\"]?(?P<name>[\w.-]+\.json)\b",
+    re.IGNORECASE,
+)
+_CONVERSION_RE = re.compile(
+    r"\b(?:converti|trasforma|conversione|convert|transform)\b[\s\S]{0,180}\b(?:csv|json)\b",
+    re.IGNORECASE,
+)
+@dataclass(frozen=True)
+class CsvJsonConversion:
+    source_name: str
+    target_name: str
+    content: str
+    row_count: int
+def _coerce_scalar(value: str) -> Any:
+    value = value.strip()
+    if re.fullmatch(r"-?(?:0|[1-9]\d*)", value):
+        return int(value)
+    if re.fullmatch(r"-?(?:0|[1-9]\d*)\.\d+", value):
+        return float(value)
+    return value
+def _csv_body(raw_body: str) -> str:
+    lines = raw_body.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    while lines and (not lines[0].strip() or lines[0].lstrip().startswith("## Foglio:")):
+        lines.pop(0)
+    return "\n".join(lines).strip()
+def convert_csv_attachment_to_json(goal: str) -> CsvJsonConversion | None:
+    """Converte il primo allegato CSV esplicitamente serializzato in JSON.
+    Il ritorno è ``None`` quando il goal non richiede una conversione CSV→JSON completa,
+    così il resto del loop conserva il comportamento esistente.
+    """
+    if not _CONVERSION_RE.search(goal):
+        return None
+    attachment = _ATTACHMENT_RE.search(goal)
+    if not attachment:
+        return None
+    target = _TARGET_RE.search(goal)
+    if not target:
+        return None
+    csv_body = _csv_body(attachment.group("body"))
+    if not csv_body:
+        return None
+    try:
+        reader = csv.DictReader(io.StringIO(csv_body))
+        if not reader.fieldnames or any(not header or not header.strip() for header in reader.fieldnames):
+            return None
+        rows = [
+            {str(key).strip(): _coerce_scalar(value or "") for key, value in row.items()}
+            for row in reader
+        ]
+    except (csv.Error, UnicodeError):
+        return None
+    return CsvJsonConversion(
+        source_name=attachment.group("name").strip(),
+        target_name=target.group("name").strip(),
+        content=json.dumps(rows, ensure_ascii=False, indent=2) + "\n",
+        row_count=len(rows),
+    )

agents/goal_verifier.py CHANGED Viewed

@@ -178,7 +178,18 @@ class GoalVerifier:
         r"flask|fastapi|django|express|nestjs|rails|laravel|"
         r"node|deno|bun|docker|dockerfile|nginx|github.*action|workflow\.yml|"
         r"database|schema|migration|model|table|index|query|"
-        r"test|spec|fixture|mock|e2e|unit.*test|integration.*test)\b",
         re.IGNORECASE,
     )
@@ -193,7 +204,13 @@ class GoalVerifier:
     @classmethod
     def is_code_goal(cls, goal: str) -> bool:
-        return bool(cls._CODE_RE.search(goal[:500]))
     @classmethod
     def adaptive_threshold(cls, goal: str) -> float:

         r"flask|fastapi|django|express|nestjs|rails|laravel|"
         r"node|deno|bun|docker|dockerfile|nginx|github.*action|workflow\.yml|"
         r"database|schema|migration|model|table|index|query|"
+        r"test|spec|fixture|mock|unit.*test|integration.*test)\b",
+        re.IGNORECASE,
+    )
+    _FILE_CONVERSION_RE = re.compile(
+        r"\b(?:converti|trasforma|conversione|convert|transform)\b[\s\S]{0,240}"
+        r"\b(?:csv|tsv|xlsx|xls|json|pdf|txt|markdown|md|docx)\b",
+        re.IGNORECASE,
+    )
+    _IMPLEMENTATION_CONTEXT_RE = re.compile(
+        r"\b(?:codice|script|funzione|function|class|componente|component|api|endpoint|"
+        r"typescript|javascript|python|react|backend|frontend|test\s+unit|test\s+e2e)\b",
         re.IGNORECASE,
     )
     @classmethod
     def is_code_goal(cls, goal: str) -> bool:
+        # Gli allegati sono serializzati dopo questo separatore: non devono trasformare
+        # una semplice lettura/conversione in un task di sviluppo da riparare.
+        user_goal = goal.split("--- **File allegati:**", 1)[0][:500]
+        if (cls._FILE_CONVERSION_RE.search(user_goal)
+                and not cls._IMPLEMENTATION_CONTEXT_RE.search(user_goal)):
+            return False
+        return bool(cls._CODE_RE.search(user_goal))
     @classmethod
     def adaptive_threshold(cls, goal: str) -> float:

agents/unified_loop.py CHANGED Viewed

@@ -4056,13 +4056,20 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
                     "loop": 0, "action": "direct_tools", "status": "done",
                     "tools_fired": _tools_count,
                 }))
-            await self._transition_state(state, AgentState.THINKING, on_step)
-            _r = await _finish(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
@@ -4101,13 +4108,20 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
                     "loop": 0, "action": "direct_tools", "status": "done",
                     "tools_fired": _tools_count,
                 }))
-            await self._transition_state(state, AgentState.THINKING, on_step)
-            _r = await _finish(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

                     "loop": 0, "action": "direct_tools", "status": "done",
                     "tools_fired": _tools_count,
                 }))
+            if direct_results.startswith("[DIRECT_TERMINAL]\n"):
+                _r = await _finish({
+                    "success": _exec_success > 0,
+                    "output": direct_results.removeprefix("[DIRECT_TERMINAL]\n"),
+                    "steps": state.steps,
+                })
+            else:
+                await self._transition_state(state, AgentState.THINKING, on_step)
+                _r = await _finish(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
                     "loop": 0, "action": "direct_tools", "status": "done",
                     "tools_fired": _tools_count,
                 }))
+            if direct_results.startswith("[DIRECT_TERMINAL]\n"):
+                _r = await _finish({
+                    "success": _exec_success > 0,
+                    "output": direct_results.removeprefix("[DIRECT_TERMINAL]\n"),
+                    "steps": state.steps,
+                })
+            else:
+                await self._transition_state(state, AgentState.THINKING, on_step)
+                _r = await _finish(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

agents/unified_loop_tools.py CHANGED Viewed

@@ -24,6 +24,7 @@ _logger = logging.getLogger("agents.unified_loop_tools")
 # StepCallback centralizzato in unified_loop_types.py (P20-TD1 Fase 1)
 # S-FIX-IMPORT: aggiunto _maybe_await mancante che causava crash nel tool layer
 from agents.unified_loop_types import StepCallback, _maybe_await
 class DirectToolsMixin:
     # ── Direct tool execution (S193) ─────────────────────────────────────────
     # Chiama TOOL_REGISTRY direttamente, senza smolagents, senza LLM per routing.
@@ -293,6 +294,52 @@ class DirectToolsMixin:
                 return f"[web_search: timeout {TOOL_TIMEOUT}s]"
             except Exception as exc:
                 return f"[web_search: errore — {str(exc)[:300]}]"
         async def _t_generate_image() -> str | None:
             if not self._IMAGE_INTENT_RE.search(goal):
                 return None
@@ -317,8 +364,10 @@ class DirectToolsMixin:
                 img_url = r.get("url", "")
                 if img_url:
                     return (
-                        f"[IMMAGINE AI GENERATA]\n"
-                        f"URL: {img_url}\n"
                         f"Prompt usato: {r.get('prompt', _img_prompt)[:200]}\n"
                         f"Dimensioni: {r.get('width')}x{r.get('height')} px"
                     )
@@ -501,7 +550,20 @@ class DirectToolsMixin:
                 return "[python_analyze: timeout]"
             except Exception as _exc:
                 return f"[python_analyze: errore — {str(_exc)[:200]}]"
-        # Esecuzione parallela
         _sem = asyncio.Semaphore(3)
         async def _sem_wrap(coro):
             if coro is None: return None
@@ -511,7 +573,6 @@ class DirectToolsMixin:
             _sem_wrap(_t_read_page()),
             _sem_wrap(_t_calculate()),
             _sem_wrap(_t_web_search()),
-            _sem_wrap(_t_generate_image()),
             _sem_wrap(_t_run_python()),
             _sem_wrap(_t_web_research()),
             _sem_wrap(_t_directory_tree()),
@@ -527,7 +588,7 @@ class DirectToolsMixin:
         # S428 Sprint1-Fix1: Tool Success Contract
         _REAL_DATA_PREFIXES = (
             "[RICERCA WEB REALE", "[METEO REALE", "[PAGINA REALE", "[CALCOLO REALE",
-            "[IMMAGINE AI GENERATA", "[CODICE PYTHON ESEGUITO", "[RICERCA APPROFONDITA REALE",
             "[STRUTTURA PROGETTO REALE", "[RICERCA FILE REALE", "[NOTIZIE REALI",
             "[STATO GIT REALE", "[ANALISI PYTHON REALE"
         )

 # StepCallback centralizzato in unified_loop_types.py (P20-TD1 Fase 1)
 # S-FIX-IMPORT: aggiunto _maybe_await mancante che causava crash nel tool layer
 from agents.unified_loop_types import StepCallback, _maybe_await
+from agents.file_conversion import convert_csv_attachment_to_json
 class DirectToolsMixin:
     # ── Direct tool execution (S193) ─────────────────────────────────────────
     # Chiama TOOL_REGISTRY direttamente, senza smolagents, senza LLM per routing.
                 return f"[web_search: timeout {TOOL_TIMEOUT}s]"
             except Exception as exc:
                 return f"[web_search: errore — {str(exc)[:300]}]"
+        async def _t_convert_csv_attachment() -> str | None:
+            conversion = convert_csv_attachment_to_json(goal)
+            if conversion is None:
+                return None
+            if not _gov_check("convert_csv_to_json", conversion.target_name):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Conversione CSV in JSON",
+                        "explanation": f"Converto {conversion.source_name} in {conversion.target_name}…"}))
+                _t0 = asyncio.get_event_loop().time()
+                written = await asyncio.wait_for(
+                    TOOL_REGISTRY["write_file"]["_fn"](
+                        path=conversion.target_name,
+                        content=conversion.content,
+                    ),
+                    timeout=TOOL_TIMEOUT,
+                )
+                if not written.get("success"):
+                    return f"[convert_csv_to_json: errore — {str(written.get('error', 'scrittura non riuscita'))[:300]}]"
+                if on_step:
+                    await _maybe_await(on_step({
+                        "action": "file_written",
+                        "status": "done",
+                        "path": conversion.target_name,
+                        "content": conversion.content,
+                        "title": "File JSON creato",
+                        "explanation": f"Creato {conversion.target_name} con {conversion.row_count} record.",
+                    }))
+                try:
+                    from api.state import record_timing as _rtc
+                    _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e:
+                    _logger.debug('[timing/record_timing] %s', _e)
+                return (
+                    "[DIRECT_TERMINAL]\n"
+                    f"E2E_CONVERSION_OK: creato `{conversion.target_name}` da `{conversion.source_name}` "
+                    f"con {conversion.row_count} record.\n\n"
+                    f"Percorso workspace: `{conversion.target_name}`."
+                )
+            except asyncio.TimeoutError:
+                return "[convert_csv_to_json: timeout]"
+            except Exception as exc:
+                return f"[convert_csv_to_json: errore — {str(exc)[:300]}]"
         async def _t_generate_image() -> str | None:
             if not self._IMAGE_INTENT_RE.search(goal):
                 return None
                 img_url = r.get("url", "")
                 if img_url:
                     return (
+                        "[DIRECT_TERMINAL]\n"
+                        f"![Immagine generata]({img_url})\n\n"
+                        "E2E_IMAGE_OK: immagine generata e visualizzata qui sopra. "
+                        f"[Apri o scarica l’immagine]({img_url}).\n\n"
                         f"Prompt usato: {r.get('prompt', _img_prompt)[:200]}\n"
                         f"Dimensioni: {r.get('width')}x{r.get('height')} px"
                     )
                 return "[python_analyze: timeout]"
             except Exception as _exc:
                 return f"[python_analyze: errore — {str(_exc)[:200]}]"
+        # Conversione e immagine sono artefatti terminali: eseguirli prima del
+        # fan-out evita risultati accessori e, soprattutto, una successiva chiamata LLM.
+        _terminal_conversion = await _t_convert_csv_attachment()
+        if _terminal_conversion is not None:
+            return (_terminal_conversion, 1,
+                    int(_terminal_conversion.startswith("[DIRECT_TERMINAL]")),
+                    int(": errore" in _terminal_conversion or ": timeout" in _terminal_conversion))
+        _terminal_image = await _t_generate_image()
+        if _terminal_image is not None:
+            return (_terminal_image, 1,
+                    int(_terminal_image.startswith("[DIRECT_TERMINAL]")),
+                    int(": errore" in _terminal_image or ": timeout" in _terminal_image))
+        # Esecuzione parallela per i tool non terminali.
         _sem = asyncio.Semaphore(3)
         async def _sem_wrap(coro):
             if coro is None: return None
             _sem_wrap(_t_read_page()),
             _sem_wrap(_t_calculate()),
             _sem_wrap(_t_web_search()),
             _sem_wrap(_t_run_python()),
             _sem_wrap(_t_web_research()),
             _sem_wrap(_t_directory_tree()),
         # S428 Sprint1-Fix1: Tool Success Contract
         _REAL_DATA_PREFIXES = (
             "[RICERCA WEB REALE", "[METEO REALE", "[PAGINA REALE", "[CALCOLO REALE",
+            "[IMMAGINE AI GENERATA", "[DIRECT_TERMINAL]", "[CODICE PYTHON ESEGUITO", "[RICERCA APPROFONDITA REALE",
             "[STRUTTURA PROGETTO REALE", "[RICERCA FILE REALE", "[NOTIZIE REALI",
             "[STATO GIT REALE", "[ANALISI PYTHON REALE"
         )

tests/test_direct_file_conversion.py ADDED Viewed

	@@ -0,0 +1,85 @@

+import asyncio
+import sys
+import types
+def _install_tool_stubs(writes, image_url="https://example.test/generated.png"):
+    tools_pkg = types.ModuleType("tools")
+    registry = types.ModuleType("tools.registry")
+    async def write_file(path, content):
+        writes[path] = content
+        return {"success": True, "path": path}
+    async def generate_image(prompt, width=512, height=512):
+        return {"url": image_url, "prompt": prompt, "width": width, "height": height}
+    registry.TOOL_REGISTRY = {
+        "write_file": {"_fn": write_file},
+        "generate_image": {"_fn": generate_image},
+    }
+    sys.modules["tools"] = tools_pkg
+    sys.modules["tools.registry"] = registry
+    api_pkg = types.ModuleType("api")
+    speculative = types.ModuleType("api.speculative")
+    speculative.get_speculative_result = lambda *_args, **_kwargs: None
+    sys.modules["api"] = api_pkg
+    sys.modules["api.speculative"] = speculative
+def test_direct_csv_conversion_writes_vfs_content_and_returns_terminal_output():
+    writes = {}
+    _install_tool_stubs(writes)
+    from agents.unified_loop_tools import DirectToolsMixin
+    class Harness(DirectToolsMixin):
+        def _max_tokens_for_goal(self, _goal):
+            return 4096
+    events = []
+    async def on_step(event):
+        events.append(event)
+    goal = """Converti e2e_metrics.csv in un file chiamato e2e_metrics.json.
+--- **File allegati:**
+### 📎 e2e_metrics.csv (excel, 66B)
+```
+mese,richieste,successi
+2026-01,12,11
+2026-02,15,14
+```
+"""
+    output, called, succeeded, errors = asyncio.run(
+        Harness()._run_direct_tools(goal, on_step=on_step)
+    )
+    assert output.startswith("[DIRECT_TERMINAL]\nE2E_CONVERSION_OK")
+    assert called == 1
+    assert succeeded == 1
+    assert errors == 0
+    assert '"richieste": 15' in writes["e2e_metrics.json"]
+    assert any(event.get("action") == "file_written" for event in events)
+def test_direct_image_returns_renderable_terminal_markdown_without_llm():
+    writes = {}
+    _install_tool_stubs(writes)
+    from agents.unified_loop_tools import DirectToolsMixin
+    class Harness(DirectToolsMixin):
+        def _max_tokens_for_goal(self, _goal):
+            return 4096
+    output, called, succeeded, errors = asyncio.run(
+        Harness()._run_direct_tools(
+            "Genera un’immagine quadrata di un aeroplanino arancione su fondo blu notte."
+        )
+    )
+    assert output.startswith("[DIRECT_TERMINAL]\n![Immagine generata](https://example.test/generated.png)")
+    assert "E2E_IMAGE_OK" in output
+    assert called == 1
+    assert succeeded == 1
+    assert errors == 0

tests/test_file_conversion.py ADDED Viewed

	@@ -0,0 +1,52 @@

+from agents.file_conversion import convert_csv_attachment_to_json
+from agents.goal_verifier import GoalVerifier
+def _goal(target: str = "e2e_metrics.json") -> str:
+    return f"""Converti il file allegato e2e_metrics.csv in un nuovo file workspace chiamato {target}.
+Il JSON deve preservare tutti i valori del CSV.
+--- **File allegati:**
+### 📎 e2e_metrics.csv (excel, 66B)
+```
+## Foglio: Sheet1
+mese,richieste,successi
+1/1/26,12,11
+2/1/26,15,14
+3/1/26,18,17
+```
+"""
+def test_convert_csv_attachment_to_json_preserves_rows_and_scalars():
+    result = convert_csv_attachment_to_json(_goal())
+    assert result is not None
+    assert result.source_name == "e2e_metrics.csv"
+    assert result.target_name == "e2e_metrics.json"
+    assert result.row_count == 3
+    assert '"mese": "1/1/26"' in result.content
+    assert '"richieste": 18' in result.content
+    assert '"successi": 17' in result.content
+def test_convert_csv_attachment_requires_explicit_json_target():
+    assert convert_csv_attachment_to_json(_goal(target="output.txt")) is None
+def test_file_conversion_is_not_a_code_goal_even_with_e2e_marker():
+    assert GoalVerifier.is_code_goal(_goal()) is False
+def test_conversion_with_explicit_code_context_remains_code_goal():
+    assert GoalVerifier.is_code_goal(
+        "Converti questo JSON in una funzione Python e scrivi il codice completo."
+    ) is True
+def test_e2e_marker_alone_does_not_turn_file_reading_into_a_code_goal():
+    assert GoalVerifier.is_code_goal(
+        "Leggi il file allegato e restituisci il marker E2E_FILE_READ_OK."
+    ) is False
+    assert GoalVerifier.is_code_goal(
+        "Aggiungi un test e2e per l’endpoint API di conversione file."
+    ) is True