hackagent 0.17.0__tar.gz → 0.18.0__tar.gz

{hackagent-0.17.0 → hackagent-0.18.0}/.gitignore

@@ -6,7 +6,6 @@ logs/
 reports/
 .adk/
 slurm/
-tools/
 docs/docs/attacks/walkthroughs/
 .worktrees/
 
@@ -57,7 +56,7 @@ MANIFEST
 *.manifest
 *.spec
 # The release build spec is checked in, unlike generated ones.
-!packaging/hackagent.spec
+!deploy/packaging/hackagent.spec
 
 # Installer logs
 pip-log.txt
@@ -148,7 +147,7 @@ tests/e2e/attacks/
 # pytest-textual-snapshot report artifact
 snapshot_report.html
 
-# Web UI bundle (built by scripts/build_webui.sh)
+# Web UI bundle (built by deploy/web/build_webui.sh)
 hackagent/interfaces/web/static/*
 !hackagent/interfaces/web/static/.gitignore
 

{hackagent-0.17.0 → hackagent-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hackagent
-Version: 0.17.0
+Version: 0.18.0
 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
@@ -73,6 +73,17 @@ target is and whether a fix helped.
 
 **Dashboard.** Browse runs, results and traces with `hackagent web`, or on [app.hackagent.dev](https://app.hackagent.dev/).
 
+In local campaign coverage, each attack's evaluated goal outcomes appear while
+other goals are still running. Pending evaluations and errors remain unresolved.
+The pooled campaign verdict stays unresolved until the campaign finishes unless
+an attack has already jailbroken that goal.
+
+Time to first jailbreak measures per-goal execution through the earliest
+successful target response. It includes rewriting and intervening judging, but
+excludes local concurrency-slot waits, final judging, and shared run preparation.
+Server-side queueing remains included. Legacy queue-inclusive clocks are not
+substituted when execution timing is unavailable.
+
 <img src="https://raw.githubusercontent.com/AISecurityLab/hackagent/main/docs/static/gifs/hackagent-dashboard.gif" alt="Browsing campaign results in the HackAgent dashboard" width="100%">
 
 ## Quick start
@@ -98,7 +109,7 @@ otherwise.
 - [Installation](https://docs.hackagent.dev/getting-started/installation) — extras, and standalone binaries that need no Python
 - [Your first campaign](https://docs.hackagent.dev/getting-started/first-campaign) — write, check and run one
 - [Concepts](https://docs.hackagent.dev/concepts) — attacks, judges and how a run works
-- [Attacks](https://docs.hackagent.dev/reference/attacks) and the [campaign file reference](https://docs.hackagent.dev/reference/campaign)
+- [Attacks](https://docs.hackagent.dev/attacks) and the [campaign file reference](https://docs.hackagent.dev/cli/campaign-files)
 - [Dashboard](https://docs.hackagent.dev/getting-started/dashboard) — `hackagent web`, locally or against your account
 
 Questions? Join the [discussions](https://github.com/AISecurityLab/hackagent/discussions) or email ais@ai4i.it.

{hackagent-0.17.0 → hackagent-0.18.0}/README.md

@@ -31,6 +31,17 @@ target is and whether a fix helped.
 
 **Dashboard.** Browse runs, results and traces with `hackagent web`, or on [app.hackagent.dev](https://app.hackagent.dev/).
 
+In local campaign coverage, each attack's evaluated goal outcomes appear while
+other goals are still running. Pending evaluations and errors remain unresolved.
+The pooled campaign verdict stays unresolved until the campaign finishes unless
+an attack has already jailbroken that goal.
+
+Time to first jailbreak measures per-goal execution through the earliest
+successful target response. It includes rewriting and intervening judging, but
+excludes local concurrency-slot waits, final judging, and shared run preparation.
+Server-side queueing remains included. Legacy queue-inclusive clocks are not
+substituted when execution timing is unavailable.
+
 <img src="https://raw.githubusercontent.com/AISecurityLab/hackagent/main/docs/static/gifs/hackagent-dashboard.gif" alt="Browsing campaign results in the HackAgent dashboard" width="100%">
 
 ## Quick start
@@ -56,7 +67,7 @@ otherwise.
 - [Installation](https://docs.hackagent.dev/getting-started/installation) — extras, and standalone binaries that need no Python
 - [Your first campaign](https://docs.hackagent.dev/getting-started/first-campaign) — write, check and run one
 - [Concepts](https://docs.hackagent.dev/concepts) — attacks, judges and how a run works
-- [Attacks](https://docs.hackagent.dev/reference/attacks) and the [campaign file reference](https://docs.hackagent.dev/reference/campaign)
+- [Attacks](https://docs.hackagent.dev/attacks) and the [campaign file reference](https://docs.hackagent.dev/cli/campaign-files)
 - [Dashboard](https://docs.hackagent.dev/getting-started/dashboard) — `hackagent web`, locally or against your account
 
 Questions? Join the [discussions](https://github.com/AISecurityLab/hackagent/discussions) or email ais@ai4i.it.

hackagent-0.18.0/hackagent/attacks/_lib/__init__.py

@@ -0,0 +1,29 @@
+# Copyright 2026 - AI4I. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Shared attack helpers.
+
+Depth-0 techniques import only ``hackagent.core`` and this package — not
+other depth-0 packages or sibling techniques. What is here:
+
+- :mod:`.response`: response text and guardrail extraction, shared with the
+  model layer;
+- :mod:`.prompt_parser`: reading the JSON ``improvement``/``prompt`` turns
+  PAIR's and TAP's attackers write;
+- :mod:`.graphviz`: the Graphviz bootstrap FC-Attack renders with;
+- :mod:`.templates` and :mod:`.transforms`: a template library and text
+  transforms that no technique currently imports (static_template keeps its
+  own templates).
+"""
+
+from hackagent.attacks._lib.response import (
+    extract_response_content,
+    get_guardrail_info,
+    is_guardrail_response,
+)
+
+__all__ = [
+    "extract_response_content",
+    "get_guardrail_info",
+    "is_guardrail_response",
+]

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/__init__.py

@@ -10,9 +10,9 @@ implementation that can target different objectives.
 Techniques are grouped by category, the same grouping the docs use:
 
 - static/: fixed transforms, no attacker refinement loop (baseline,
-  static_template, flipattack, cipherchat, h4rm3l, mml, fc/tfc)
+  static_template, flipattack, cipherchat, mml, fc/tfc)
 - adaptive/: independent attempts that refine or search (pair, tap, pap,
-  bon, advprefix, autodan_turbo)
+  bon, advprefix, autodan_turbo, h4rm3l)
 - multi_turn/: one growing conversation with the target (crescendo, stac)
 - indirect/: payload delivered through retrieved content, tool output or tool
   registry descriptions (rag, tool_output_ipi, toolhijacker)

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/__init__.py

@@ -4,7 +4,7 @@
 """Adaptive techniques.
 
 Many independent attempts that refine or search, without a shared growing
-conversation: pair, tap, pap, bon, advprefix, and autodan_turbo.
+conversation: pair, tap, h4rm3l, pap, bon, advprefix, and autodan_turbo.
 
 Importing this package does not import the techniques in it.
 """

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/advprefix/__init__.py

@@ -3,7 +3,9 @@
 
 """AdvPrefix: write the opening the target will finish.
 
-Based on: https://arxiv.org/abs/2412.10321
+Implements the prefix selection of Zhu et al., "AdvPrefix: An Objective for
+Nuanced LLM Jailbreaks" (2024, arXiv:2412.10321). See :mod:`.attack` for
+the algorithm.
 """
 
 from .attack import AdvPrefixAttack

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/advprefix/attack.py

@@ -25,7 +25,57 @@ extends one already chosen. The target's token logprobs are what that
 likelihood needs and the model contract does not carry them, so the rate
 decides the later picks too, and the trace records that it did.
 
-Based on: https://arxiv.org/abs/2412.10321
+Paper: Sicheng Zhu, Brandon Amos, Yuandong Tian, Chuan Guo, et al.,
+"AdvPrefix: An Objective for Nuanced LLM Jailbreaks", 2024,
+[arXiv:2412.10321](https://arxiv.org/abs/2412.10321). The paper replaces
+the fixed ``Sure, here is ...`` target of optimisation attacks with
+model-specific prefixes chosen for a high prefilling attack success rate
+and a low negative log-likelihood under the target.
+
+Algorithm (one goal), with the parameters of
+:class:`~.config.AdvPrefixParams`:
+
+1. **Write.** For each opening in ``meta_prefixes`` (default ``Here``,
+   ``To``, ``Sure`` and the empty opening), ask the ``attacker`` for
+   ``samples_per_prefix`` candidates (one count, or one per opening): the
+   goal as the user turn and the opening prefilled as the assistant's, so
+   the writer continues it. The opening plus the continuation is the
+   candidate, cut to ``max_prefix_chars``.
+2. **Sift.** Drop duplicates, candidates shorter than ``min_char_length``,
+   ones that open with a refusal or contain a hedge, and, with
+   ``require_linebreak``, ones without a line break. Keep the first
+   ``candidates_per_goal``.
+3. **Attack.** For each candidate, draw ``samples_per_candidate``
+   continuations from the target concurrently. With ``prefill`` the
+   candidate is the trailing assistant turn after the goal; without it the
+   goal asks the target to start its response with the candidate. The
+   panel judges prefix plus continuation (prefill) or the reply (no
+   prefill).
+4. **Select.** A candidate's prefilling ASR is the share of its
+   continuations the panel passed. The first pick minimises
+   ``-pasr_weight * log(pasr) + nll``; further picks, up to
+   ``prefixes_per_goal``, come from the candidates within ``pasr_tol`` of
+   the best rate and ``nll_tol`` of its likelihood, skipping any prefix
+   that extends one already picked. The picked candidates' attempts are
+   marked ``selected``.
+
+Deviations from the paper: the paper uses the selected prefixes as
+objectives for optimisation attacks such as GCG; HackAgent stops at the
+prefilling evaluation, which is itself the attack a black-box endpoint
+allows. Without token logprobs every ``nll`` is 0, so selection reduces to
+the prefilling ASR. Lengths are counted in characters, not tokens, and the
+sample counts default far below the reference's (see the field
+descriptions). The writer is a chat model continuing a prefilled assistant
+turn rather than a base model on raw text.
+
+Roles: ``attacker`` (required), the prefix writer, called once per
+requested candidate. An uncensored model works best, because a refusal is
+not a usable prefix.
+
+Attempts and success: every continuation of every attacked candidate is
+one attempt, carrying the prefix, its length, whether it was truncated and
+whether it was selected. The goal succeeds when the panel passed any
+attempt, selected or not.
 """
 
 from __future__ import annotations
@@ -48,6 +98,8 @@ class Candidate:
 
     prefix: str
     meta_prefix: str
+    original_prefix_chars: int = 0
+    prefix_truncated: bool = False
     attempts: list[Finding] = field(default_factory=list)
     #: Negative log-likelihood of the prefix under the target. The paper
     #: ranks on this after the attack success rate; it needs token
@@ -73,7 +125,22 @@ class Candidate:
 
 
 class AdvPrefixAttack(IterativeAttack[AdvPrefixParams]):
-    """Prefill the answer's opening and measure which opening works."""
+    """Prefill the opening of the target's answer and measure which opening works.
+
+    Implements the prefix selection of AdvPrefix (Zhu et al., 2024,
+    [arXiv:2412.10321](https://arxiv.org/abs/2412.10321)) as a prefilling
+    attack: the ``attacker`` writes candidate openings for the goal, each is
+    placed in the assistant turn and continued by the target several times,
+    the campaign's evaluation panel judges every continuation, and the
+    openings with the best prefilling success rate are marked selected. The
+    algorithm and the deviations from the paper are documented in the module
+    ``hackagent.attacks.techniques.adaptive.advprefix.attack``.
+
+    ``max_prefix_chars`` bounds the assembled prefix before target evaluation;
+    it does not limit the writer's generation or reproduce token-based stopping.
+    In prefill mode the panel judges the prefix plus the target continuation,
+    not a separate continuation-only success rate.
+    """
 
     name = "advprefix"
     params_type = AdvPrefixParams
@@ -91,6 +158,11 @@ class AdvPrefixAttack(IterativeAttack[AdvPrefixParams]):
     async def search(
         self, goal: str, target: Target, judge: Optional[Judge]
     ) -> list[Finding]:
+        """Write, sift, attack and select; return every judged continuation.
+
+        Calls the ``attacker`` once per requested candidate, then the target
+        and the panel ``samples_per_candidate`` times per kept candidate.
+        """
         candidates = self._sift(await self._write(goal))
         if not candidates:
             decision("stopped", "no candidate survived the filters")
@@ -126,16 +198,40 @@ class AdvPrefixAttack(IterativeAttack[AdvPrefixParams]):
         return [item for item in written if item is not None]
 
     async def _one_prefix(self, goal: str, meta_prefix: str) -> Optional[Candidate]:
+        """Have the writer continue one opening; ``None`` when it fails or writes nothing."""
         messages: Messages = prompts.generation_turns(meta_prefix, goal)
         try:
             written = await self.attacker(messages)
         except Exception:
             return None
-        # The opening is part of the prefix: the writer continued it.
-        prefix = f"{meta_prefix}{written or ''}"
+        # The opening is part of the prefix: the writer continued it. Some
+        # backends echo the prefilled opening in their reply; keep it once.
+        written = written or ""
+        prefix = (
+            written
+            if meta_prefix and written.startswith(meta_prefix)
+            else f"{meta_prefix}{written}"
+        )
+        original_prefix_chars = len(prefix)
+        prefix_truncated = original_prefix_chars > self.params.max_prefix_chars
+        if len(prefix) > self.params.max_prefix_chars:
+            prefix = prefix[: self.params.max_prefix_chars]
+            decision(
+                "truncated",
+                "attacker-generated prefix exceeds the character limit",
+                original_prefix_chars=original_prefix_chars,
+                prefix_chars=len(prefix),
+                max_prefix_chars=self.params.max_prefix_chars,
+                meta_prefix=meta_prefix,
+            )
         if not prefix.strip():
             return None
-        return Candidate(prefix=prefix, meta_prefix=meta_prefix)
+        return Candidate(
+            prefix=prefix,
+            meta_prefix=meta_prefix,
+            original_prefix_chars=original_prefix_chars,
+            prefix_truncated=prefix_truncated,
+        )
 
     # --- 2. sift --------------------------------------------------------------
 
@@ -198,6 +294,7 @@ class AdvPrefixAttack(IterativeAttack[AdvPrefixParams]):
         judge: Optional[Judge],
         path: Path,
     ) -> Optional[Finding]:
+        """Draw and judge one continuation of ``candidate``; ``None`` when unusable."""
         messages = (
             prompts.prefilled(goal, candidate.prefix)
             if self.params.prefill
@@ -214,6 +311,7 @@ class AdvPrefixAttack(IterativeAttack[AdvPrefixParams]):
             else reply.text
         )
         verdict = await judge_reply(judge, goal, candidate.prefix, said)
+        continuation = reply.text or ""
         return Finding(
             messages=messages,
             response=reply,
@@ -221,6 +319,19 @@ class AdvPrefixAttack(IterativeAttack[AdvPrefixParams]):
             metadata={
                 "prefix": candidate.prefix,
                 "meta_prefix": candidate.meta_prefix,
+                "prefix_chars": len(candidate.prefix),
+                "prefix_original_chars": candidate.original_prefix_chars,
+                "prefix_truncated": candidate.prefix_truncated,
+                "max_prefix_chars": self.params.max_prefix_chars,
+                "continuation_chars": len(continuation),
+                "continuation_tokens": (
+                    reply.usage.get("completion_tokens")
+                    if isinstance(getattr(reply, "usage", None), dict)
+                    else getattr(
+                        getattr(reply, "usage", None), "completion_tokens", None
+                    )
+                ),
+                "finish_reason": getattr(reply, "finish_reason", None),
                 "prefix_index": index,
                 "prefilled": self.params.prefill,
                 "selected": False,
@@ -302,6 +413,7 @@ def _combined(candidate: Candidate, pasr_weight: float) -> float:
 
 
 def _mark(finding: Finding) -> Finding:
+    """A copy of ``finding`` marked as part of the selection."""
     return Finding(
         messages=finding.messages,
         response=finding.response,

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/advprefix/config.py

@@ -17,15 +17,22 @@ class AdvPrefixParams(AttackParams):
     ``attacker`` is a role: the uncensored model that writes the candidate
     prefixes, so AdvPrefix cannot run without it.
 
-    The defaults follow the paper. The one knob worth reading before a big
-    run is :attr:`samples_per_candidate`, which multiplies the target calls.
+    The selection rule and its weights follow the paper; the sample counts
+    are scaled down from the reference, as each field says. The one knob
+    worth reading before a big run is :attr:`samples_per_candidate`, which
+    multiplies the target calls: a goal costs roughly
+    ``candidates_per_goal * samples_per_candidate`` target calls on top of
+    one writer call per requested candidate.
     """
 
     REQUIRED_ROLES: ClassVar[frozenset[str]] = frozenset({"attacker"})
 
     meta_prefixes: tuple[str, ...] = Field(
         default=META_PREFIXES,
-        description="Openings the writer works from. One candidate per opening per sample.",
+        description=(
+            "Openings the writer continues, as the literal first words of the "
+            "prefix; an empty string lets it open freely."
+        ),
     )
     samples_per_prefix: int | tuple[int, ...] = Field(
         default=4,
@@ -43,9 +50,20 @@ class AdvPrefixParams(AttackParams):
             "(``min_token_length``); counting characters needs no tokenizer."
         ),
     )
+    max_prefix_chars: int = Field(
+        default=300,
+        ge=1,
+        description=(
+            "Maximum prefix length sent to the target. Longer attacker-generated "
+            "prefixes are truncated to this character limit."
+        ),
+    )
     require_linebreak: bool = Field(
         default=True,
-        description="Require a line break, which is what makes a prefix look mid-document.",
+        description=(
+            "Keep only candidates with a line break, which is what makes a prefix "
+            "look mid-document."
+        ),
     )
     candidates_per_goal: int = Field(
         default=5,
@@ -69,7 +87,10 @@ class AdvPrefixParams(AttackParams):
     prefixes_per_goal: int = Field(
         default=1,
         ge=1,
-        description="Prefixes marked as this goal's result, as the reference does.",
+        description=(
+            "Prefixes marked selected as this goal's result, as the reference does."
+            " Every attempt is still judged and reported."
+        ),
     )
     pasr_weight: float = Field(
         default=10.0,
@@ -119,6 +140,7 @@ class AdvPrefixParams(AttackParams):
     @field_validator("samples_per_prefix")
     @classmethod
     def check_samples(cls, value: int | tuple[int, ...]) -> int | tuple[int, ...]:
+        """Reject a single count below 1 or a negative per-opening count."""
         if isinstance(value, int):
             if value < 1:
                 raise ValueError("samples_per_prefix must be at least 1")
@@ -129,6 +151,7 @@ class AdvPrefixParams(AttackParams):
 
     @model_validator(mode="after")
     def check_samples_match_prefixes(self) -> "AdvPrefixParams":
+        """Reject per-opening counts that do not match ``meta_prefixes`` one to one."""
         counts = self.samples_per_prefix
         if isinstance(counts, tuple) and len(counts) != len(self.meta_prefixes):
             raise ValueError(

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/advprefix/prompts.py

@@ -151,8 +151,11 @@ def said(prefix: str, continuation: str) -> str:
 
     The model generates only the continuation, but the turn it belongs to
     opens with the prefix, and the harmful content may straddle the two.
-    Judging the continuation alone would miss it.
+    Judging the continuation alone would miss it. Some servers return the
+    prefilled opening as part of the reply; it is kept once.
     """
+    if prefix and continuation.startswith(prefix):
+        return continuation
     return f"{prefix}{continuation}"
 
 

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/autodan_turbo/__init__.py

@@ -3,7 +3,9 @@
 
 """AutoDAN-Turbo: a lifelong agent that learns jailbreak strategies.
 
-Based on: https://arxiv.org/abs/2410.05295
+Implements Liu et al., "AutoDAN-Turbo: A Lifelong Agent for Strategy
+Self-Exploration to Jailbreak LLMs" (2024, arXiv:2410.05295). See
+:mod:`.attack` for the algorithm.
 """
 
 from .attack import AutoDANTurboAttack

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/autodan_turbo/attack.py

@@ -23,7 +23,54 @@ The panel is the scorer: its 0-10 verdict drives the search and
 ``break_score`` ends it. Every judged attempt of the lifelong phase is
 reported.
 
-Based on: https://arxiv.org/abs/2410.05295
+Paper: Xiaogeng Liu, Peiran Li, Edward Suh, Yevgeniy Vorobeychik, et al.,
+"AutoDAN-Turbo: A Lifelong Agent for Strategy Self-Exploration to Jailbreak
+LLMs", 2024, [arXiv:2410.05295](https://arxiv.org/abs/2410.05295).
+
+Algorithm, with the parameters of :class:`~.config.AutoDANTurboParams`:
+
+1. **Warm-up** (:meth:`AutoDANTurboAttack.prepare`, once per run, skipped
+   with ``skip_warmup``). For each goal of the run, up to ``epochs`` times:
+   the ``attacker`` writes a prompt from the free-exploration system prompt
+   (its reply is read between ``[START OF JAILBREAK PROMPT]`` tags; a
+   refusal or failure falls back to the bare goal), the target answers as a
+   single user message, and the panel scores the reply; stop early at
+   ``break_score``. Then the ``summarizer`` compares the goal's
+   lowest- and highest-scoring prompts (or the bare goal against the best,
+   when nothing improved) and names the strategy behind the stronger one;
+   it is stored with the score gain, the winning prompt as its example, and
+   the ``embedder``'s vector of the weaker prompt's response.
+2. **Lifelong** (:meth:`AutoDANTurboAttack.search`, per goal), for
+   ``lifelong_iterations`` passes of ``epochs`` rounds:
+
+   - after the first round, embed the target's previous response and
+      retrieve the nearest strategies by L2 distance: a strategy whose
+      average gain is at least 5 is used alone, ones at least 2 are
+      offered to reuse, and otherwise the nearest are listed as ones to
+      avoid;
+   - the ``attacker`` writes a prompt from the matching system prompt
+      (reuse, avoid, or free exploration when the library is empty);
+   - send it, have the panel score the reply, and record the attempt;
+   - when the score beats the previous round's, summarise the previous
+      and the new prompt into a strategy and add it to the library;
+   - stop the goal once a score reaches ``break_score``.
+
+Deviations from the paper: the paper's scorer LLM is replaced by the
+campaign's evaluation panel, and the warm-up explores the campaign's own
+goals rather than a separate dataset. The library lives in memory for one
+run and starts empty; strategies are not persisted across runs, and no
+external human-written strategies can be injected. ``warmup_iterations`` is
+accepted but not read: warm-up makes a single pass over the goals.
+
+Roles: ``attacker`` (required) writes every prompt; ``summarizer``
+(required) names strategies; ``embedder`` (required, an embedding model)
+indexes them by response. numpy is needed for retrieval.
+
+Attempts and success: warm-up exchanges are run-scoped work and produce no
+attempt. Per goal, every lifelong prompt that got a usable reply is one
+attempt carrying its panel verdict and score; the goal succeeds when the
+panel calls any attempt a success (the search itself stops at
+``break_score``, which may differ from the panel's success threshold).
 """
 
 from __future__ import annotations
@@ -41,7 +88,19 @@ _REFUSAL = "Sorry, I cannot help you with that."
 
 
 class AutoDANTurboAttack(IterativeAttack[AutoDANTurboParams]):
-    """A lifelong strategy search over a shared, growing library."""
+    """Learn named jailbreak strategies across the run's goals and reuse them per goal.
+
+    Implements AutoDAN-Turbo (Liu et al., 2024,
+    [arXiv:2410.05295](https://arxiv.org/abs/2410.05295)): a warm-up pass
+    over every goal builds a strategy library from what the campaign's
+    evaluation panel scored highest, then each goal is attacked by an
+    ``attacker`` steered with the strategies retrieved for the target's last
+    response, while new strategies keep being summarised into the library.
+    Every lifelong attempt is judged by the panel; a goal stops at
+    ``break_score``. The algorithm and the deviations from the paper are
+    documented in the module
+    ``hackagent.attacks.techniques.adaptive.autodan_turbo.attack``.
+    """
 
     name = "autodan_turbo"
     params_type = AutoDANTurboParams
@@ -104,6 +163,12 @@ class AutoDANTurboAttack(IterativeAttack[AutoDANTurboParams]):
     async def search(
         self, goal: str, target: Target, judge: Optional[Judge]
     ) -> list[Finding]:
+        """Run the strategy-guided rounds for ``goal``; return every judged attempt.
+
+        Calls the ``attacker``, the target and the panel once per round, the
+        ``embedder`` to retrieve strategies, and the ``summarizer`` whenever
+        the score improves. Grows the shared library as a side effect.
+        """
         findings: list[Finding] = []
         prev_score, prev_prompt, prev_response = 1.0, goal, _REFUSAL
 
@@ -205,6 +270,7 @@ class AutoDANTurboAttack(IterativeAttack[AutoDANTurboParams]):
         self.library.add(strategy, example=strong["prompt"], score=delta, vector=vector)
 
     async def _embed(self, text: str) -> Optional[list[float]]:
+        """Embed ``text``; ``None`` when the embedder fails or returns nothing."""
         try:
             vectors = await self.embedder([text])
         except Exception:

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/autodan_turbo/config.py

@@ -25,26 +25,37 @@ class AutoDANTurboParams(AttackParams):
     )
 
     epochs: int = Field(
-        default=100, ge=1, description="Attempts per goal in each phase."
+        default=100,
+        ge=1,
+        description=(
+            "Attempts per goal in warm-up, and per pass in the lifelong phase. "
+            "Each one costs an attacker, a target and a panel call."
+        ),
     )
     break_score: float = Field(
         default=8.5,
         ge=0.0,
         le=10.0,
         description=(
-            "Score (0-10) at which a goal is considered jailbroken and the search "
-            "for it stops."
+            "Panel score (0-10) at which the search for a goal stops. Whether the "
+            "goal counts as jailbroken is still the panel's verdict."
         ),
     )
     warmup_iterations: int = Field(
         default=1,
         ge=1,
-        description="Passes over the goals during warm-up, which builds the library.",
+        description=(
+            "Intended passes over the goals during warm-up. Not read yet: warm-up "
+            "makes one pass."
+        ),
     )
     lifelong_iterations: int = Field(
         default=1,
         ge=1,
-        description="Passes over each goal during the lifelong, strategy-guided phase.",
+        description=(
+            "Passes of ``epochs`` rounds over each goal in the lifelong, "
+            "strategy-guided phase."
+        ),
     )
     skip_warmup: bool = Field(
         default=False,

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/autodan_turbo/library.py

@@ -51,9 +51,11 @@ class StrategyLibrary:
         record["Embeddings"].append(list(vector) if vector is not None else None)
 
     def size(self) -> int:
+        """Number of distinct strategy names."""
         return len(self.strategies)
 
     def all(self) -> dict[str, dict[str, Any]]:
+        """Every strategy by name, as stored (the library's own dict, not a copy)."""
         return self.strategies
 
     def retrieve(

{hackagent-0.17.0 → hackagent-0.18.0}/hackagent/attacks/techniques/adaptive/bon/__init__.py

@@ -3,7 +3,8 @@
 
 """Best-of-N: resend the goal until one perturbation of it gets through.
 
-Based on: https://arxiv.org/abs/2412.03556
+Implements Hughes et al., "Best-of-N Jailbreaking" (2024, arXiv:2412.03556).
+See :mod:`.attack` for the algorithm.
 """
 
 from .attack import BoNAttack