sync: 186 file da Baida98/AI@d7fa54a1 (2026-08-25 19:09 UTC) [deploy-all]

api/agent.py

@@ -825,6 +825,12 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
             raise HTTPException(404, detail=f'Task {task_id} non trovato')
 
     task = _agent_tasks[task_id]
+    # I task restaurati da persistenza potrebbero non contenere metadata runtime.
+    # Ricostruire la policy dal goal mantiene il resume fail-closed.
+    if "forbid_tools" not in task or "literal_response" not in task:
+        _restored_policy = build_task_tool_policy(task.get("goal", ""))
+        task["forbid_tools"] = _restored_policy.forbid_tools
+        task["literal_response"] = _restored_policy.literal_response
     _last_event_id = request.headers.get("Last-Event-ID") or request.headers.get("last-event-id")
     _resume_from   = int(_last_event_id) if (_last_event_id and _last_event_id.isdigit()) else resume
 

api/scheduler.py

@@ -28,6 +28,7 @@ import datetime
 import json
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 from .state import safe_json_dumps
+from .task_tool_policy import build_task_tool_policy
 import os
 import time
 import uuid
@@ -246,6 +247,10 @@ async def _run_goal(goal: str, conversation_id: Optional[str] = None, risk: str
     Esegue il goal tramite UnifiedAgentLoop (stesso path di api/agent.py).
     Timeout: derivato da Policy Engine per risk level (safe=30s, medium=90s, risky=180s, dangerous=300s).
     """
+    _task_policy = build_task_tool_policy(goal)
+    if _task_policy.literal_response:
+        return _task_policy.literal_response
+
     try:
         from agents.unified_loop import UnifiedAgentLoop
         from api.state import (
@@ -274,7 +279,8 @@ async def _run_goal(goal: str, conversation_id: Optional[str] = None, risk: str
 
         _timeout_s = float(_POLICY_TIMEOUT_S.get(risk, 120))
         result = await asyncio.wait_for(
-            loop.run(goal=goal, context="", max_steps=8),
+            loop.run(goal=goal, context="", max_steps=8,
+                     allow_tools=not _task_policy.forbid_tools),
             timeout=_timeout_s,
         )
         if isinstance(result, dict):

api/webhook.py

@@ -5,6 +5,7 @@ from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel, field_validator
 from .state import _get_mem_manager, _get_executor, _get_planner
 from .auth_guard import require_role, AuthRole  # GAP-WEBHOOK-ADMIN-FIX
+from .task_tool_policy import build_task_tool_policy
 
 import logging
 _logger = logging.getLogger("api.webhook")
@@ -211,6 +212,13 @@ async def inbound_webhook(webhook_token: str, body: WebhookPayload):
     if webhook_token != _expected:
         raise HTTPException(status_code=401, detail='Unauthorized: token non valido')
 
+    _task_policy = build_task_tool_policy(body.goal)
+    if _task_policy.literal_response:
+        return {
+            'ok': True, 'output': _task_policy.literal_response, 'engine': 'policy',
+            'goal': body.goal, 'steps': 0,
+        }
+
     try:
         from agents.unified_loop import UnifiedAgentLoop
         from models.ai_client import AIClient
@@ -233,7 +241,8 @@ async def inbound_webhook(webhook_token: str, body: WebhookPayload):
         try:
             result = await asyncio.wait_for(
                 loop.run(goal=body.goal, context=context_str,
-                         max_steps=body.max_steps, on_step=lambda _s: None),
+                         max_steps=body.max_steps, on_step=lambda _s: None,
+                         allow_tools=not _task_policy.forbid_tools),
                 timeout=float(os.getenv('AGENT_STREAM_TIMEOUT', '120')),
             )
         except asyncio.TimeoutError:
@@ -274,6 +283,13 @@ async def public_chat(payload: PublicChatPayload, request: Request):
     if not token or token != _expected:
         raise HTTPException(status_code=401, detail='Unauthorized: token non valido.')
 
+    _task_policy = build_task_tool_policy(payload.message)
+    if _task_policy.literal_response:
+        return {
+            'ok': True, 'response': _task_policy.literal_response, 'engine': 'policy',
+            'conversation_id': payload.conversation_id, 'steps': 0,
+        }
+
     try:
         from agents.unified_loop import UnifiedAgentLoop
         from models.ai_client import AIClient
@@ -295,7 +311,8 @@ async def public_chat(payload: PublicChatPayload, request: Request):
         try:
             result = await asyncio.wait_for(
                 loop.run(goal=payload.message, context='',
-                         max_steps=payload.max_steps, on_step=lambda _s: None),
+                         max_steps=payload.max_steps, on_step=lambda _s: None,
+                         allow_tools=not _task_policy.forbid_tools),
                 timeout=float(os.getenv('AGENT_STREAM_TIMEOUT', '120')),
             )
         except asyncio.TimeoutError:

tests/test_entrypoint_policy_contracts.py

@@ -0,0 +1,192 @@
+"""Contratti di integrazione per policy tool nei diversi entry point backend.
+
+Gli endpoint sono invocati direttamente con finti loop/provider. Ogni test misura la
+policy effettivamente passata al loop o dimostra che un contratto letterale termina
+prima di provider, notifiche, planner e tool.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+_BACKEND = os.path.join(os.path.dirname(__file__), "..")
+if _BACKEND not in sys.path:
+    sys.path.insert(0, _BACKEND)
+
+
+NO_TOOL_PROMPT = "Spiega il concetto senza usare strumenti, tool, rete o file."
+LITERAL_PROMPT = (
+    "Rispondi ESCLUSIVAMENTE con TEST_E2E_OK. Non usare strumenti, tool, "
+    "comandi shell, file, rete, servizi esterni, azioni o card."
+)
+
+
+class _Request:
+    def __init__(self, headers: dict[str, str] | None = None) -> None:
+        self.headers = headers or {}
+
+
+class _CallbackRequest(_Request):
+    async def json(self) -> dict[str, object]:
+        raise AssertionError("bad secret must not parse payload")
+
+
+class _RecordingLoop:
+    calls: list[dict] = []
+
+    def __init__(self, **_kwargs: object) -> None:
+        pass
+
+    async def run(self, **kwargs: object) -> dict[str, object]:
+        self.__class__.calls.append(dict(kwargs))
+        return {"success": True, "output": "safe textual result", "steps": []}
+
+
+class _FakeAIClient:
+    pass
+
+
+def _fake_loop_modules() -> dict[str, types.ModuleType]:
+    agents = types.ModuleType("agents")
+    agents.__path__ = []  # type: ignore[attr-defined]
+    unified = types.ModuleType("agents.unified_loop")
+    unified.UnifiedAgentLoop = _RecordingLoop  # type: ignore[attr-defined]
+    models = types.ModuleType("models")
+    models.__path__ = []  # type: ignore[attr-defined]
+    ai_client = types.ModuleType("models.ai_client")
+    ai_client.AIClient = _FakeAIClient  # type: ignore[attr-defined]
+    return {
+        "agents": agents,
+        "agents.unified_loop": unified,
+        "models": models,
+        "models.ai_client": ai_client,
+    }
+
+
+async def _noop(*_args: object, **_kwargs: object) -> None:
+    return None
+
+
+class EntryPointPolicyContracts(unittest.IsolatedAsyncioTestCase):
+    def setUp(self) -> None:
+        _RecordingLoop.calls.clear()
+
+    async def test_telegram_callback_fails_closed_before_payload_or_outbound_work(self) -> None:
+        from api import webhook
+
+        with patch.dict(os.environ, {"TELEGRAM_WEBHOOK_SECRET": ""}, clear=False):
+            result = await webhook.telegram_callback(_CallbackRequest())
+
+        self.assertEqual(result, {"ok": True, "ignored": "bad_secret"})
+
+    async def test_webhook_literal_contract_returns_before_loop_or_notification(self) -> None:
+        from api import webhook
+
+        payload = webhook.WebhookPayload(goal=LITERAL_PROMPT)
+        with patch.dict(os.environ, {"WEBHOOK_TOKEN": "test-webhook-token"}, clear=False), \
+             patch.object(webhook, "_tg_start", side_effect=AssertionError("notification forbidden")), \
+             patch.object(webhook, "_get_mem_manager", side_effect=AssertionError("provider forbidden")):
+            result = await webhook.inbound_webhook("test-webhook-token", payload)
+
+        self.assertEqual(result["output"], "TEST_E2E_OK")
+        self.assertEqual(result["steps"], 0)
+        self.assertEqual(_RecordingLoop.calls, [])
+
+    async def test_public_chat_literal_contract_returns_before_loop_or_notification(self) -> None:
+        from api import webhook
+
+        payload = webhook.PublicChatPayload(message=LITERAL_PROMPT, conversation_id="conv-safe")
+        with patch.dict(os.environ, {"PUBLIC_API_TOKEN": "public-test-token"}, clear=False), \
+             patch.object(webhook, "_tg_start", side_effect=AssertionError("notification forbidden")), \
+             patch.object(webhook, "_get_mem_manager", side_effect=AssertionError("provider forbidden")):
+            result = await webhook.public_chat(
+                payload,
+                _Request({"authorization": "Bearer public-test-token"}),
+            )
+
+        self.assertEqual(result["response"], "TEST_E2E_OK")
+        self.assertEqual(result["conversation_id"], "conv-safe")
+        self.assertEqual(_RecordingLoop.calls, [])
+
+    async def test_webhook_and_public_chat_propagate_no_tool_policy_to_loop(self) -> None:
+        from api import webhook
+
+        fake_modules = _fake_loop_modules()
+        with patch.dict(sys.modules, fake_modules), \
+             patch.dict(os.environ, {"WEBHOOK_TOKEN": "test-webhook-token", "PUBLIC_API_TOKEN": "public-test-token"}, clear=False), \
+             patch.object(webhook, "_get_mem_manager", return_value=object()), \
+             patch.object(webhook, "_get_executor", return_value=object()), \
+             patch.object(webhook, "_get_planner", return_value=object()), \
+             patch.object(webhook, "_tg_start", _noop), \
+             patch.object(webhook, "_tg_done", _noop):
+            webhook_result = await webhook.inbound_webhook(
+                "test-webhook-token", webhook.WebhookPayload(goal=NO_TOOL_PROMPT)
+            )
+            public_result = await webhook.public_chat(
+                webhook.PublicChatPayload(message=NO_TOOL_PROMPT),
+                _Request({"authorization": "Bearer public-test-token"}),
+            )
+
+        self.assertTrue(webhook_result["ok"])
+        self.assertTrue(public_result["ok"])
+        self.assertEqual(len(_RecordingLoop.calls), 2)
+        self.assertTrue(all(call["allow_tools"] is False for call in _RecordingLoop.calls))
+
+    async def test_scheduler_literal_contract_skips_provider_initialization(self) -> None:
+        from api import scheduler
+
+        with patch.object(scheduler, "_get_ai_client", side_effect=AssertionError("provider forbidden"), create=True):
+            result = await scheduler._run_goal(LITERAL_PROMPT)
+
+        self.assertEqual(result, "TEST_E2E_OK")
+        self.assertEqual(_RecordingLoop.calls, [])
+
+    async def test_scheduler_propagates_no_tool_policy_to_loop(self) -> None:
+        from api import scheduler
+        import api.state as state
+
+        fake_modules = _fake_loop_modules()
+        async def fake_memory() -> object:
+            return object()
+
+        with patch.dict(sys.modules, fake_modules), \
+             patch.object(state, "_get_ai_client", return_value=object()), \
+             patch.object(state, "_get_mem_manager_async", fake_memory), \
+             patch.object(state, "_get_executor", return_value=object()), \
+             patch.object(state, "_get_planner", return_value=object()):
+            result = await scheduler._run_goal(NO_TOOL_PROMPT, risk="safe")
+
+        self.assertEqual(result, "safe textual result")
+        self.assertEqual(len(_RecordingLoop.calls), 1)
+        self.assertIs(_RecordingLoop.calls[0]["allow_tools"], False)
+
+    async def test_restored_sse_task_rebuilds_literal_policy_before_task_start(self) -> None:
+        from api import agent
+
+        task_id = "resume-literal-policy"
+        original = dict(agent._agent_tasks)
+        agent._agent_tasks.clear()
+        agent._agent_tasks[task_id] = {"id": task_id, "goal": LITERAL_PROMPT, "status": "QUEUED"}
+        try:
+            with patch.object(agent, "sb_update_status", _noop):
+                response = await agent.stream_agent_task(task_id, _Request())
+                payload = b"".join([
+                    chunk.encode() if isinstance(chunk, str) else chunk
+                    async for chunk in response.body_iterator
+                ]).decode()
+        finally:
+            agent._agent_tasks.clear()
+            agent._agent_tasks.update(original)
+
+        self.assertIn('"event": "task_done"', payload)
+        self.assertIn("TEST_E2E_OK", payload)
+        self.assertNotIn("task_start", payload)
+        self.assertTrue(agent._agent_tasks == original or task_id not in agent._agent_tasks)
+
+
+if __name__ == "__main__":
+    unittest.main()