switch-trust-cli 1.7.0__py3-none-any.whl

switch_trust/eval/core/eval/evaluation_garak_probe.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+import asyncio
+import io
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from dataclasses_json import dataclass_json
+
+from switch_trust.eval.common.schema import Content, Message, PartType, Role, Session
+from switch_trust.eval.core.detectors.detector_garak import GarakDetector
+from switch_trust.eval.core.eval.evaluation import Evaluation, EvaluationStatus
+from switch_trust.eval.core.eval.evaluation_multi import MultiEvaluation
+from switch_trust.eval.core.eval.evaluation_single import SingleEvaluation
+from switch_trust.eval.core.eval.evaluation_single_prompt import (
+    SinglePromptEvaluation,
+)
+from switch_trust.eval.core.models.model import Model, ResponseStatus
+from switch_trust.eval.core.models.model_sync_wrapper import SyncModelWrapper
+from switch_trust.eval.core.optional_deps import require_garak
+
+if TYPE_CHECKING:
+    from garak.attempt import Conversation
+    from garak.attempt import Message as GarakMessage
+
+logger = logging.getLogger(__name__)
+
+# Cached at first use so the garak Generator base class (part of the optional
+# ``full`` extra) is only imported when a dynamic garak probe actually runs.
+_generator_adapter_cls: type | None = None
+
+
+# -- Helpers -------------------------------------------------------
+
+
+def _ensure_garak_config() -> None:
+    """Initialize garak's global config if not already loaded.
+
+    Garak probes expect config values (verbose, generations, seed,
+    etc.) that are normally set by garak's CLI harness.
+    ``load_base_config`` reads garak's bundled ``garak.core.yaml``
+    to set all defaults.  We also provide a dummy ``reportfile``
+    since some probes write progress to it.
+    """
+    config = require_garak()._config
+    if not config.loaded:
+        config.load_base_config()
+    if config.transient.reportfile is None:
+        config.transient.reportfile = io.StringIO()
+
+
+def _garak_prompt_to_message(prompt) -> Message:
+    garak = require_garak()
+    if isinstance(prompt, str):
+        text = prompt
+    elif isinstance(prompt, garak.attempt.Message):
+        text = prompt.text
+    elif isinstance(prompt, garak.attempt.Conversation):
+        parts = [turn.content.text for turn in prompt.turns]
+        text = "\n".join(parts)
+    else:
+        text = str(prompt)
+    return Message(content=Content.text(Role.USER, text))
+
+
+def _has_static_prompts(probe: Any) -> bool:
+    """Check whether a garak probe has a static prompts list."""
+    return (
+        hasattr(probe, "prompts")
+        and probe.prompts is not None
+        and len(probe.prompts) > 0
+    )
+
+
+def _conversation_to_messages(
+    conversation: Conversation,
+) -> list[Message]:
+    """Convert a garak Conversation to a list of AIRed Messages."""
+    role_map = {
+        "system": Role.SYSTEM,
+        "user": Role.USER,
+        "assistant": Role.ASSISTANT,
+    }
+    messages: list[Message] = []
+    for turn in conversation.turns:
+        role = role_map.get(turn.role, Role.USER)
+        text = turn.content.text if turn.content else ""
+        messages.append(
+            Message(content=Content.text(role, text)),
+        )
+    return messages
+
+
+def _extract_text(message: Message) -> str:
+    """Extract plain text from an AIRed Message."""
+    text_parts = [
+        part.text
+        for part in message.content.parts
+        if part.part_type == PartType.TEXT and part.text
+    ]
+    return "\n".join(text_parts)
+
+
+def _attempts_to_session(attempts: list) -> Session:
+    """Convert garak Attempts into an AIRed Session."""
+    messages: list[Message] = []
+    role_map = {
+        "system": Role.SYSTEM,
+        "user": Role.USER,
+        "assistant": Role.ASSISTANT,
+    }
+    for attempt in attempts:
+        for conversation in attempt.conversations:
+            for turn in conversation.turns:
+                role = role_map.get(turn.role, Role.USER)
+                text = turn.content.text if turn.content else ""
+                messages.append(
+                    Message(content=Content.text(role, text)),
+                )
+    return Session(messages=messages)
+
+
+# -- Generator adapter ---------------------------------------------
+
+
+def _get_generator_adapter_cls() -> type:
+    """Build (once) the garak Generator adapter class.
+
+    The class subclasses garak's ``Generator``, which lives in the optional
+    ``full`` extra, so it can only be defined once garak is importable.  The
+    result is memoized in ``_generator_adapter_cls``.
+    """
+    global _generator_adapter_cls
+    if _generator_adapter_cls is not None:
+        return _generator_adapter_cls
+
+    generator_base = require_garak().generators.base.Generator
+
+    class GarakGeneratorAdapter(generator_base):
+        """Wraps an AIRed Model as a garak Generator.
+
+        Garak probes call ``generator.generate(conversation)`` which
+        delegates to ``_call_model``.  This adapter translates between
+        garak's Conversation/Message types and AIRed's Message type,
+        forwards the call to the wrapped SyncModelWrapper, and returns
+        the result as a garak Message.
+
+        Uses SyncModelWrapper because garak's probe system is entirely
+        synchronous.
+        """
+
+        def __init__(self, sync_model: SyncModelWrapper):
+            self._sync_model = sync_model
+            self.name = "aired-adapter"
+            self.generations = 1
+            self.supports_multiple_generations = False
+            self.seed = None
+            self.fullname = "aired-adapter"
+
+        def _call_model(
+            self,
+            prompt: Conversation,
+            generations_this_call: int = 1,
+        ) -> list[GarakMessage | None]:
+            messages = _conversation_to_messages(prompt)
+            response = self._sync_model.generate(messages)
+
+            if response.status != ResponseStatus.OK:
+                return [None]
+            if response.message is None:
+                return [None]
+
+            text = _extract_text(response.message)
+            return [require_garak().attempt.Message(text=text)]
+
+    _generator_adapter_cls = GarakGeneratorAdapter
+    return _generator_adapter_cls
+
+
+# -- Evaluation classes --------------------------------------------
+
+
+@dataclass
+class GarakMultiTurnEvaluation(SingleEvaluation):
+    """Evaluates a multi-turn garak probe against a model.
+
+    Delegates the entire interaction to the garak probe's
+    ``.probe()`` method.  This supports probes that dynamically
+    generate prompts, use red-team models, or adapt based on
+    target responses (e.g. ``atkgen.Tox``).
+
+    The probe manages the full conversation flow.  Results are
+    scored using the probe's primary detector.
+    """
+
+    probe_name: str | None = None
+
+    def __init__(self, probe_name: str):
+        super().__init__()
+        self.probe_name = probe_name
+
+    async def init(self):
+        if not self.probe_name:
+            raise ValueError("probe_name is required")
+        self.status = EvaluationStatus.INITIALIZED
+
+    async def execute_internal(self, model: Model) -> float:
+        if not self.probe_name:
+            raise ValueError("probe_name is required")
+
+        return await asyncio.to_thread(
+            self._execute_sync,
+            model,
+        )
+
+    def _execute_sync(self, model: Model) -> float:
+        sync_model = SyncModelWrapper(model)
+        try:
+            plugins = require_garak()._plugins
+            _ensure_garak_config()
+            probe = plugins.load_plugin(self.probe_name)
+            detector_name = f"detectors.{probe.primary_detector}"
+            detector = plugins.load_plugin(detector_name)
+
+            adapter = _get_generator_adapter_cls()(sync_model)
+            attempts = probe.probe(adapter)
+
+            if not attempts:
+                return 1.0
+
+            self.session = _attempts_to_session(attempts)
+
+            all_scores: list[float] = []
+            for attempt in attempts:
+                results = detector.detect(attempt)
+                scores = [s for s in results if s is not None]
+                if scores:
+                    all_scores.append(max(scores))
+
+            if not all_scores:
+                score = 1.0
+            else:
+                worst_hit = max(all_scores)
+                score = 1.0 - worst_hit
+            logger.debug(
+                "GarakMultiTurnEvaluation(%s): score=%.2f", self.probe_name, score
+            )
+            return score
+        finally:
+            sync_model.close()
+
+
+@dataclass_json
+@dataclass
+class GarakProbeEvaluation(MultiEvaluation):
+    """Evaluates a garak probe against a model.
+
+    Automatically detects whether the probe provides static prompts
+    (single-prompt evaluation, run in parallel) or requires dynamic
+    interaction (multi-turn evaluation) and delegates accordingly.
+    """
+
+    probe_name: str | None = None
+
+    def __init__(self, probe_name: str):
+        super().__init__()
+        self.probe_name = probe_name
+
+    async def get_children(self) -> list[Evaluation]:
+        if not self.probe_name:
+            raise ValueError("probe_name is required")
+
+        _ensure_garak_config()
+        probe = require_garak()._plugins.load_plugin(self.probe_name)
+
+        if _has_static_prompts(probe):
+            detector_name = probe.primary_detector
+            detector = GarakDetector(
+                f"detectors.{detector_name}",
+            )
+            children = [
+                SinglePromptEvaluation(
+                    prompt=_garak_prompt_to_message(p),
+                    detector=detector,
+                )
+                for p in probe.prompts
+            ]
+            logger.debug(
+                "GarakProbeEvaluation(%s): %d children (%s)",
+                self.probe_name,
+                len(children),
+                "static",
+            )
+            return children
+
+        children = [
+            GarakMultiTurnEvaluation(
+                probe_name=self.probe_name,
+            ),
+        ]
+        logger.debug(
+            "GarakProbeEvaluation(%s): %d children (%s)",
+            self.probe_name,
+            len(children),
+            "multi-turn",
+        )
+        return children

switch_trust/eval/core/eval/evaluation_message_list.py

@@ -0,0 +1,46 @@
+import random
+from dataclasses import dataclass
+
+from dataclasses_json import dataclass_json
+
+from switch_trust.eval.common.schema import Message
+from switch_trust.eval.core.detectors.detector import Detector
+from switch_trust.eval.core.eval.evaluation import Evaluation
+from switch_trust.eval.core.eval.evaluation_multi import MultiEvaluation
+from switch_trust.eval.core.eval.evaluation_single_prompt import (
+    SinglePromptEvaluation,
+)
+
+
+@dataclass_json
+@dataclass
+class MessageListEvaluation(MultiEvaluation):
+    """Evaluates a list of messages against a detector."""
+
+    messages: list[Message] | None = None
+    detector: Detector | None = None
+    num_prompts: int | None = None
+
+    def __init__(
+        self,
+        messages: list[Message],
+        detector: Detector,
+        num_prompts: int | None = None,
+    ):
+        super().__init__()
+        self.messages = messages
+        self.detector = detector
+        self.num_prompts = num_prompts
+
+    async def get_children(self) -> list[Evaluation]:
+        if not self.messages or self.detector is None:
+            raise ValueError("messages and detector must be set")
+
+        messages = self.messages
+        if self.num_prompts is not None and self.num_prompts < len(messages):
+            messages = random.sample(messages, self.num_prompts)
+
+        return [
+            SinglePromptEvaluation(prompt=msg, detector=self.detector)
+            for msg in messages
+        ]

switch_trust/eval/core/eval/evaluation_multi.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from abc import abstractmethod
+from dataclasses import dataclass, field
+
+from dataclasses_json import dataclass_json
+
+from switch_trust.eval.core.eval.evaluation import (
+    DEFAULT_MIN_SUCCESS_RATE,
+    Evaluation,
+    EvaluationObserver,
+    EvaluationResult,
+    EvaluationStatus,
+    EvaluationSummary,
+)
+from switch_trust.eval.core.models.model import Model
+
+logger = logging.getLogger(__name__)
+
+
+PER_CHILD_TIMEOUT = 60  # seconds per child
+MIN_TIMEOUT = 30 * 60  # 30 minutes minimum
+MAX_CONSECUTIVE_FAILURES = 5
+
+
+@dataclass_json
+@dataclass
+class MultiEvaluation(Evaluation):
+    """An evaluation that produces and runs a list of child evaluations.
+
+    Subclasses implement ``get_children`` to define the children.
+    ``init`` calls ``get_children`` and then initializes each child.
+    ``run`` executes all initialized children concurrently using
+    asyncio with a semaphore for concurrency control.
+
+    Observer propagation: rather than forwarding observers directly
+    to children (which would cause the observer to receive the
+    child as the ``evaluation`` argument and report per-child
+    progress), we attach a relay observer to each child that
+    triggers ``_notify_observers`` on **this** parent evaluation.
+    The observer therefore always sees the top-level aggregated
+    summary.
+    """
+
+    children: list[Evaluation] = field(default_factory=list)
+    _child_relay: EvaluationObserver | None = field(
+        default=None,
+        repr=False,
+    )
+
+    def __init__(self):
+        super().__init__()
+        self.children = []
+        self._child_relay = None
+
+    def _ensure_relay(self) -> EvaluationObserver:
+        """Return a relay observer that notifies this parent."""
+        if self._child_relay is None:
+
+            def relay(_child: Evaluation) -> None:
+                self._notify_observers()
+
+            self._child_relay = relay
+        return self._child_relay
+
+    async def init(self):
+        try:
+            self.status = EvaluationStatus.INITIALIZING
+            self.children = await self.get_children()
+            logger.debug(
+                "%s initialized: %d children", type(self).__name__, len(self.children)
+            )
+            relay = self._ensure_relay()
+            for child in self.children:
+                child.add_observer(relay)
+                await child.init()
+            self.status = EvaluationStatus.INITIALIZED
+        except Exception as e:
+            self.error_message = str(e)
+            self.status = EvaluationStatus.ERROR
+            logger.error(
+                "%s init failed (%s: %s)",
+                type(self).__name__,
+                type(e).__name__,
+                e,
+                exc_info=True,
+            )
+        finally:
+            self._notify_observers()
+
+    @abstractmethod
+    async def get_children(self) -> list[Evaluation]:
+        """Return the child evaluations to run."""
+        pass
+
+    def get_summary(self) -> EvaluationSummary:
+        summaries = [c.get_summary() for c in self.children]
+        total = sum(s.total_evaluations for s in summaries)
+        finished = sum(s.finished_evaluations for s in summaries)
+        errors = sum(s.error_evaluations for s in summaries)
+        max_score = sum(s.max_score for s in summaries)
+        achieved = sum(s.achieved_score for s in summaries)
+        error_msgs = [msg for s in summaries for msg in s.error_messages]
+        if self.error_message:
+            error_msgs.append(self.error_message)
+
+        return EvaluationSummary(
+            status=self.status,
+            total_evaluations=total,
+            finished_evaluations=finished,
+            error_evaluations=errors,
+            max_score=max_score,
+            achieved_score=achieved,
+            error_messages=error_msgs,
+        )
+
+    def get_results(self) -> list[EvaluationResult]:
+        results: list[EvaluationResult] = []
+        for child in self.children:
+            results.extend(child.get_results())
+        return results
+
+    async def run(
+        self,
+        model: Model,
+        concurrency: int = 50,
+        min_success_rate: float = DEFAULT_MIN_SUCCESS_RATE,
+    ) -> None:
+        if self.status == EvaluationStatus.ERROR:
+            return
+        self.status = EvaluationStatus.RUNNING
+        self._notify_observers()
+
+        semaphore = asyncio.Semaphore(concurrency)
+        abort = asyncio.Event()
+        consecutive_errors = 0
+        error_lock = asyncio.Lock()
+
+        initialized = [
+            c
+            for c in self.children
+            if c.get_summary().status == EvaluationStatus.INITIALIZED
+        ]
+        timeout = max(
+            MIN_TIMEOUT,
+            PER_CHILD_TIMEOUT * len(initialized),
+        )
+
+        name = type(self).__name__
+        logger.debug(
+            "%s running: %d children, concurrency=%d",
+            name,
+            len(initialized),
+            concurrency,
+        )
+
+        async def run_child(child: Evaluation) -> None:
+            nonlocal consecutive_errors
+            async with semaphore:
+                if abort.is_set():
+                    child.status = EvaluationStatus.ERROR
+                    child.error_message = "Aborted: too many consecutive failures"
+                    child._notify_observers()
+                    return
+                await child.run(model, concurrency)
+                async with error_lock:
+                    if child.get_summary().status == EvaluationStatus.ERROR:
+                        consecutive_errors += 1
+                        if consecutive_errors >= MAX_CONSECUTIVE_FAILURES:
+                            abort.set()
+                            logger.warning(
+                                "%s: aborting after %d consecutive failures",
+                                name,
+                                consecutive_errors,
+                            )
+                    else:
+                        consecutive_errors = 0
+
+        try:
+            tasks = [asyncio.create_task(run_child(child)) for child in initialized]
+            if tasks:
+                try:
+                    results = await asyncio.wait_for(
+                        asyncio.gather(*tasks, return_exceptions=True),
+                        timeout=timeout,
+                    )
+                    errors = [r for r in results if isinstance(r, Exception)]
+                    if errors:
+                        self.error_message = (
+                            f"Evaluation errors: {'; '.join(str(e) for e in errors)}"
+                        )
+                        logger.warning("%s: %s", name, self.error_message)
+                except TimeoutError:
+                    for task in tasks:
+                        task.cancel()
+                    unfinished = sum(
+                        1
+                        for c in self.children
+                        if c.get_summary().status
+                        not in (
+                            EvaluationStatus.FINISHED,
+                            EvaluationStatus.ERROR,
+                        )
+                    )
+                    self.error_message = (
+                        f"{unfinished} (of {len(initialized)}) "
+                        f"evaluations timed out after "
+                        f"{timeout}s"
+                    )
+                    logger.warning("%s: %s", name, self.error_message)
+
+            if abort.is_set() and not self.error_message:
+                self.error_message = (
+                    f"aborted after {MAX_CONSECUTIVE_FAILURES} consecutive failures"
+                )
+
+            errored = [
+                c
+                for c in self.children
+                if c.get_summary().status == EvaluationStatus.ERROR
+            ]
+            finished = [
+                c
+                for c in self.children
+                if c.get_summary().status == EvaluationStatus.FINISHED
+            ]
+            total = len(self.children)
+            if errored:
+                logger.warning(
+                    "%s: %d of %d prompts errored (%.0f%%)",
+                    name,
+                    len(errored),
+                    total,
+                    100.0 * len(errored) / total,
+                )
+
+            # ERROR on a structural failure (error_message), no successful prompt,
+            # or a success rate below the minimum. Otherwise FINISHED.
+            #
+            # Split into one branch per cause so each sets error_message. The
+            # worker reports that field and falls back to a generic "evaluation
+            # produced no results" when it is empty, which is what every one of
+            # these used to look like from the outside.
+            success_rate = len(finished) / total if total else 0.0
+            if self.error_message:
+                self.status = EvaluationStatus.ERROR
+            elif not finished:
+                self.error_message = (
+                    "evaluation had no prompts to run"
+                    if not total
+                    else f"all {total} prompts failed"
+                )
+                self.status = EvaluationStatus.ERROR
+            elif success_rate < min_success_rate:
+                self.error_message = (
+                    f"only {len(finished)} of {total} prompts succeeded "
+                    # .1%, not .0%: at 200+ prompts a rate under the minimum can
+                    # round up to it (179/200 shows as 90%, below a 90% minimum),
+                    # and the message then contradicts itself.
+                    f"({success_rate:.1%}), below the "
+                    f"{min_success_rate:.1%} minimum"
+                )
+                self.status = EvaluationStatus.ERROR
+            else:
+                self.status = EvaluationStatus.FINISHED
+        except Exception as e:
+            self.error_message = str(e)
+            self.status = EvaluationStatus.ERROR
+            logger.error(
+                "%s run failed (%s: %s)", name, type(e).__name__, e, exc_info=True
+            )
+        finally:
+            logger.info("%s finished: status=%s", name, self.status.value)
+            self._notify_observers()