hackagent 0.12.0__tar.gz → 0.13.1__tar.gz

{hackagent-0.12.0 → hackagent-0.13.1}/.gitignore

@@ -145,3 +145,7 @@ tests/e2e/attacks/
 
 # pytest-textual-snapshot report artifact
 snapshot_report.html
+
+# Web UI bundle (built by scripts/build_webui.sh)
+hackagent/server/webui/static/*
+!hackagent/server/webui/static/.gitignore

{hackagent-0.12.0 → hackagent-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hackagent
-Version: 0.12.0
+Version: 0.13.1
 Summary: HackAgent is an open-source security toolkit to detect vulnerabilities of your AI Agents.
 Author-email: AI Security Lab <ais@ai4i.it>
 License: Apache-2.0
@@ -18,10 +18,9 @@ Requires-Python: >=3.10
 Requires-Dist: click>=8.1.0
 Requires-Dist: datasets>=2.14.0
 Requires-Dist: faiss-cpu>=1.13.2
-Requires-Dist: flask>=3.1.2
+Requires-Dist: flask>=3.1.3
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: litellm>=1.69.2
-Requires-Dist: nicegui>=2.0
 Requires-Dist: openai>=1.0.0
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: playwright>=1.40
@@ -30,6 +29,8 @@ Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: rich>=14.0.0
 Requires-Dist: textual>=1.0.0
+Provides-Extra: web
+Requires-Dist: hackagent-webui<1.0,>=0.2; extra == 'web'
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -139,14 +140,20 @@ HackAgent uses a modular pipeline to test agent robustness end-to-end.
 
 HackAgent supports both local and remote reporting.
 
-- Local mode stores test results in SQLite and includes a built-in dashboard.
+- Local mode stores test results in SQLite, readable offline.
 - Cloud mode syncs runs to the HackAgent remote platform when an API key is configured.
 
+`hackagent web` serves the HackAgent dashboard — the same app as
+[app.hackagent.dev](https://app.hackagent.dev) — from your own machine, against
+your cloud data when an API key is configured and against the local SQLite
+database (read-only) when it is not. Your API key stays in the CLI process and
+is never exposed to the browser.
+
 ```bash
 hackagent web
 ```
 
-Access cloud reporting at [https://app.hackagent.dev](https://app.hackagent.dev).
+Install it with `pip install 'hackagent[web]'`; see the [web command docs](docs/docs/cli/web.md) for modes and options.
 
 ## Responsible Use
 

{hackagent-0.12.0 → hackagent-0.13.1}/README.md

@@ -105,14 +105,20 @@ HackAgent uses a modular pipeline to test agent robustness end-to-end.
 
 HackAgent supports both local and remote reporting.
 
-- Local mode stores test results in SQLite and includes a built-in dashboard.
+- Local mode stores test results in SQLite, readable offline.
 - Cloud mode syncs runs to the HackAgent remote platform when an API key is configured.
 
+`hackagent web` serves the HackAgent dashboard — the same app as
+[app.hackagent.dev](https://app.hackagent.dev) — from your own machine, against
+your cloud data when an API key is configured and against the local SQLite
+database (read-only) when it is not. Your API key stays in the CLI process and
+is never exposed to the browser.
+
 ```bash
 hackagent web
 ```
 
-Access cloud reporting at [https://app.hackagent.dev](https://app.hackagent.dev).
+Install it with `pip install 'hackagent[web]'`; see the [web command docs](docs/docs/cli/web.md) for modes and options.
 
 ## Responsible Use
 

{hackagent-0.12.0 → hackagent-0.13.1}/hackagent/agent.py

@@ -5,6 +5,7 @@ from hackagent.logger import get_logger
 from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
 from hackagent import utils
+from hackagent.config import resolve_remote_base_url
 from hackagent.errors import HackAgentError
 from hackagent.router import AgentRouter
 from hackagent.router.types import AgentTypeEnum
@@ -129,7 +130,7 @@ class HackAgent:
             from hackagent.server.client import AuthenticatedClient
             from hackagent.server.storage.remote import RemoteBackend
 
-            _base_url = base_url or "https://api.hackagent.dev"
+            _base_url = base_url or resolve_remote_base_url()
             _client = AuthenticatedClient(
                 base_url=_base_url,
                 token=resolved_auth_token,
@@ -222,6 +223,7 @@ class HackAgent:
                 StaticTemplateOrchestrator,
                 BoNOrchestrator,
                 CipherChatOrchestrator,
+                CrescendoOrchestrator,
                 FCOrchestrator,
                 tFCOrchestrator,
                 H4rm3lOrchestrator,
@@ -240,6 +242,7 @@ class HackAgent:
                 "static_template": StaticTemplateOrchestrator(hackagent_agent=self),
                 "bon": BoNOrchestrator(hackagent_agent=self),
                 "cipherchat": CipherChatOrchestrator(hackagent_agent=self),
+                "crescendo": CrescendoOrchestrator(hackagent_agent=self),
                 "fc": FCOrchestrator(hackagent_agent=self),
                 "tfc": tFCOrchestrator(hackagent_agent=self),
                 "pair": PAIROrchestrator(hackagent_agent=self),

hackagent-0.13.1/hackagent/async_utils.py

@@ -0,0 +1,29 @@
+# Copyright 2026 - AI4I. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Small shared helpers for bridging synchronous APIs to asyncio internals."""
+
+import asyncio
+from typing import Awaitable, Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def run_coroutine_blocking(coro_factory: Callable[[], Awaitable[T]]) -> T:
+    """Run a coroutine factory from synchronous code safely.
+
+    Uses ``asyncio.run`` directly when no event loop is running yet (the
+    common case for a synchronous public API). ``asyncio.run`` cannot be
+    nested, so when called from inside an already-running loop (e.g.
+    notebooks, async callers) a dedicated bridge thread runs its own loop
+    instead, giving synchronous callers the same behavior either way.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro_factory())
+
+    from concurrent.futures import ThreadPoolExecutor
+
+    with ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(lambda: asyncio.run(coro_factory())).result()

{hackagent-0.12.0 → hackagent-0.13.1}/hackagent/attacks/__init__.py

@@ -41,9 +41,20 @@ from .registry import (
     FlipAttackOrchestrator,
     TAPOrchestrator,
 )
+from .taxonomy import (
+    ATTACK_TAXONOMY,
+    AttackCategory,
+    AttackTag,
+    AttackTaxonomy,
+    get_attack_taxonomy,
+)
 
 __all__ = [
     "ATTACK_REGISTRY",
+    "ATTACK_TAXONOMY",
+    "AttackCategory",
+    "AttackTag",
+    "AttackTaxonomy",
     "AdvPrefixOrchestrator",
     "AutoDANTurboOrchestrator",
     "BaselineOrchestrator",
@@ -52,4 +63,5 @@ __all__ = [
     "PAIROrchestrator",
     "FlipAttackOrchestrator",
     "TAPOrchestrator",
+    "get_attack_taxonomy",
 ]

{hackagent-0.12.0 → hackagent-0.13.1}/hackagent/attacks/evaluator/base.py

@@ -24,14 +24,15 @@ Usage:
     )
 """
 
+import asyncio
+import inspect
 import logging
 import re
-import threading
 from abc import ABC, abstractmethod
-from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
+from hackagent.async_utils import run_coroutine_blocking
 from hackagent.attacks.shared.progress import create_progress_bar
 from hackagent.attacks.shared.router_factory import create_router
 from hackagent.server.client import AuthenticatedClient
@@ -443,13 +444,16 @@ class BaseJudgeEvaluator(ABC):
         )
 
         # ── Parallel judge evaluation ──────────────────────────────────────
-        # Each HTTP judge call is independent; fire batch_size rows at once.
-        _bs = getattr(self.config, "batch_size", 1)
-        batch_size = max(1, int(_bs) if isinstance(_bs, (int, float)) else 1)
-        _tracker_lock = threading.Lock()
+        # Judge requests are independent, so use lightweight cooperative tasks
+        # rather than one OS thread per in-flight request.
+        raw_concurrency = getattr(self.config, "judge_concurrency", 10)
+        try:
+            judge_concurrency = max(1, int(raw_concurrency))
+        except (TypeError, ValueError):
+            judge_concurrency = 10
         results_map: Dict[int, tuple] = {}
 
-        def _process_row(idx_row: tuple) -> tuple:
+        async def _process_row_async(idx_row: tuple) -> tuple:
             idx, row = idx_row
             import time as _time
 
@@ -465,7 +469,7 @@ class BaseJudgeEvaluator(ABC):
                     current_eval,
                     current_expl,
                     current_raw_response,
-                ) = self._request_with_assertions(
+                ) = await self._request_with_assertions_async(
                     request_data=request_data,
                     original_index=original_index,
                     max_retries=max_retries,
@@ -481,58 +485,69 @@ class BaseJudgeEvaluator(ABC):
                 )
             finally:
                 _eval_elapsed = round(_time.perf_counter() - _t0, 3)
-                with _tracker_lock:
-                    if self._tracker and request_data is not None:
-                        goal = row.get("goal", "")
-                        if goal:
-                            goal_ctx = self._tracker.get_goal_context_by_goal(goal)
-                            if goal_ctx:
-                                self._tracker.add_evaluation_trace(
-                                    ctx=goal_ctx,
-                                    evaluation_result={
-                                        "score": current_eval,
-                                        "explanation": current_expl,
-                                    },
-                                    score=(
-                                        float(current_eval)
-                                        if isinstance(current_eval, (int, float))
-                                        else 0.0
+                if self._tracker and request_data is not None:
+                    goal = row.get("goal", "")
+                    if goal:
+                        goal_ctx = self._tracker.get_goal_context_by_goal(goal)
+                        if goal_ctx:
+                            self._tracker.add_evaluation_trace(
+                                ctx=goal_ctx,
+                                evaluation_result={
+                                    "score": current_eval,
+                                    "explanation": current_expl,
+                                },
+                                score=(
+                                    float(current_eval)
+                                    if isinstance(current_eval, (int, float))
+                                    else 0.0
+                                ),
+                                explanation=current_expl,
+                                evaluator_name=self.__class__.__name__,
+                                metadata={
+                                    "prefix": row.get("prefix", ""),
+                                    "completion": (
+                                        row.get("completion", "")
+                                        if row.get("completion")
+                                        else None
                                     ),
-                                    explanation=current_expl,
-                                    evaluator_name=self.__class__.__name__,
-                                    metadata={
-                                        "prefix": row.get("prefix", ""),
-                                        "completion": (
-                                            row.get("completion", "")
-                                            if row.get("completion")
-                                            else None
-                                        ),
-                                        "judge_model": self.config.model_id,
-                                        "elapsed_s": _eval_elapsed,
-                                    },
-                                )
+                                    "judge_model": self.config.model_id,
+                                    "elapsed_s": _eval_elapsed,
+                                },
+                            )
             return idx, original_index, current_eval, current_expl, current_raw_response
 
         with create_progress_bar(task_desc, total=len(rows_to_process)) as (
             progress_bar,
             task,
         ):
-            with ThreadPoolExecutor(max_workers=batch_size) as pool:
-                for (
-                    idx,
+
+            async def _fan_out() -> List[tuple]:
+                semaphore = asyncio.Semaphore(judge_concurrency)
+
+                async def _fan_out_one(idx_row: tuple) -> tuple:
+                    async with semaphore:
+                        row_result = await _process_row_async(idx_row)
+                        progress_bar.update(task, advance=1)
+                        progress_bar.refresh()
+                        return row_result
+
+                return await asyncio.gather(
+                    *(_fan_out_one(idx_row) for idx_row in enumerate(rows_to_process))
+                )
+
+            for (
+                idx,
+                original_index,
+                current_eval,
+                current_expl,
+                current_raw_response,
+            ) in run_coroutine_blocking(_fan_out):
+                results_map[idx] = (
                     original_index,
                     current_eval,
                     current_expl,
                     current_raw_response,
-                ) in pool.map(_process_row, enumerate(rows_to_process)):
-                    results_map[idx] = (
-                        original_index,
-                        current_eval,
-                        current_expl,
-                        current_raw_response,
-                    )
-                    progress_bar.update(task, advance=1)
-                    progress_bar.refresh()
+                )
 
         self.logger.info(
             f"{self.config.agent_name}: {self.__class__.__name__} progress {total_rows}/{total_rows}"
@@ -581,6 +596,11 @@ class BaseJudgeEvaluator(ABC):
             Tuple of (score, explanation).
         """
         # Step 1: Initial request
+        configured_thinking = getattr(self.config, "thinking", False)
+        if not isinstance(configured_thinking, bool):
+            configured_thinking = False
+        if request_data.get("thinking") is None:
+            request_data["thinking"] = configured_thinking
         response = self.agent_router.route_request(
             registration_key=self.agent_registration_key,
             request_data=request_data,
@@ -664,6 +684,94 @@ class BaseJudgeEvaluator(ABC):
             )
         return final.score, final.explanation + " (retries exhausted)"
 
+    async def _route_request_async(
+        self, registration_key: str, request_data: Dict[str, Any], **kwargs: Any
+    ) -> Dict[str, Any]:
+        """Use the router's async twin when available, otherwise offload sync I/O."""
+        fn = getattr(self.agent_router, "route_request_async", None)
+        if fn is not None and inspect.iscoroutinefunction(fn):
+            return await fn(registration_key, request_data, **kwargs)
+        return await asyncio.to_thread(
+            self.agent_router.route_request, registration_key, request_data, **kwargs
+        )
+
+    async def _request_with_assertions_async(
+        self,
+        request_data: Dict[str, Any],
+        original_index: Any,
+        max_retries: int = 1,
+        include_raw_response: bool = False,
+    ) -> Tuple[Any, Optional[str]] | Tuple[Any, Optional[str], Optional[str]]:
+        """Async equivalent of :meth:`_request_with_assertions`."""
+        configured_thinking = getattr(self.config, "thinking", False)
+        if not isinstance(configured_thinking, bool):
+            configured_thinking = False
+        if request_data.get("thinking") is None:
+            request_data["thinking"] = configured_thinking
+        response = await self._route_request_async(
+            registration_key=self.agent_registration_key,
+            request_data=request_data,
+        )
+        error_msg = response.get("error_message")
+        response_content = response.get("processed_response")
+        if error_msg:
+            if include_raw_response:
+                return 0, f"{self.__class__.__name__}: {error_msg}", None
+            return 0, f"{self.__class__.__name__}: {error_msg}"
+        if response_content is None:
+            if include_raw_response:
+                return 0, f"{self.__class__.__name__}: No content from router", None
+            return 0, f"{self.__class__.__name__}: No content from router"
+
+        current_eval, current_expl = self._parse_response_content(
+            response_content, original_index
+        )
+        assertion = self._check_assertion(response_content, original_index)
+        if assertion.is_confident or max_retries <= 0:
+            if include_raw_response:
+                return current_eval, current_expl, response_content
+            return current_eval, current_expl
+
+        for retry in range(max_retries):
+            self.logger.debug(
+                f"Assertion retry {retry + 1}/{max_retries} for index {original_index} "
+                f"(response was: '{response_content[:50]}...')"
+            )
+            retry_response = await self._route_request_async(
+                registration_key=self.agent_registration_key,
+                request_data=self._build_retry_request(request_data, response_content),
+            )
+            retry_error = retry_response.get("error_message")
+            retry_content = retry_response.get("processed_response")
+            if retry_error or retry_content is None:
+                self.logger.debug(
+                    f"Retry {retry + 1} failed: {retry_error or 'no content'}"
+                )
+                continue
+            retry_assertion = self._check_assertion(retry_content, original_index)
+            if retry_assertion.is_confident:
+                self.logger.info(
+                    f"✅ Assertion retry {retry + 1} succeeded for index "
+                    f"{original_index}: score={retry_assertion.score}"
+                )
+                if include_raw_response:
+                    return (
+                        retry_assertion.score,
+                        retry_assertion.explanation + " (retry)",
+                        retry_content,
+                    )
+                return retry_assertion.score, retry_assertion.explanation + " (retry)"
+            response_content = retry_content
+
+        final = self._check_assertion(response_content, original_index)
+        if include_raw_response:
+            return (
+                final.score,
+                final.explanation + " (retries exhausted)",
+                response_content,
+            )
+        return final.score, final.explanation + " (retries exhausted)"
+
     def _check_assertion(
         self, content: Optional[str], original_index: Any
     ) -> AssertionResult:
@@ -869,4 +977,9 @@ Answer (yes or no):"""
             "messages": self._build_messages(feedback_prompt),
             "max_tokens": self.config.max_tokens_eval,
             "temperature": 0.0,  # Deterministic for retry
+            "thinking": (
+                original_request_data["thinking"]
+                if original_request_data.get("thinking") is not None
+                else False
+            ),
         }