FEAT: Register ADVERSARIAL_CHAT singleturn/multiturn/reasoning variants

Adds three TargetConfig entries (singleturn, multiturn, reasoning), each
tagged [DEFAULT, ADVERSARIAL], for the env-driven variants already
declared in .env_example. Tightens _register_target to skip with a
warning when a TargetConfig declares model_var but the env var is unset;
without this guard the target silently falls back to the global
OPENAI_CHAT_MODEL default and sends requests to the wrong model.

New tests covering naming-related failure modes flagged for the eventual
PR review:
- test_register_instance_with_duplicate_name_silently_overwrites pins
  the current "second write wins" behavior so future hardening (warn /
  raise / idempotent skip) is intentional.
- test_target_configs_have_unique_registry_names guards against typos
  in ENV_TARGET_CONFIGS that would otherwise silently drop a target.
- test_double_initialize_async_is_idempotent regression-guards the
  re-init path that depends on the silent-overwrite semantics above.
- test_variant_skips_when_model_env_var_missing parameterizes the
  missing-_MODEL skip+warning for all three new variants.

Failure modes surfaced during this change but not addressed here
(tracked for the PR description batch):
- Duplicate registry_name silently overwrites in BaseInstanceRegistry.
- registry_name has no format validation; risk grows with per-user
  TargetConfig support in P1.
- No-adversarial-models-found error message UX is owned by the upcoming
  BenchmarkInitializer commit and needs a clear, actionable message.

Author: Victor Valbuena

pyrit/setup/initializers/components/targets.py

@@ -189,6 +189,33 @@ class TargetConfig:
         temperature=1.2,
         tags=[TargetInitializerTags.DEFAULT, TargetInitializerTags.ADVERSARIAL],
     ),
+    TargetConfig(
+        registry_name="adversarial_chat_singleturn",
+        target_class=OpenAIChatTarget,
+        endpoint_var="ADVERSARIAL_CHAT_SINGLETURN_ENDPOINT",
+        key_var="ADVERSARIAL_CHAT_SINGLETURN_KEY",
+        model_var="ADVERSARIAL_CHAT_SINGLETURN_MODEL",
+        temperature=1.2,
+        tags=[TargetInitializerTags.DEFAULT, TargetInitializerTags.ADVERSARIAL],
+    ),
+    TargetConfig(
+        registry_name="adversarial_chat_multiturn",
+        target_class=OpenAIChatTarget,
+        endpoint_var="ADVERSARIAL_CHAT_MULTITURN_ENDPOINT",
+        key_var="ADVERSARIAL_CHAT_MULTITURN_KEY",
+        model_var="ADVERSARIAL_CHAT_MULTITURN_MODEL",
+        temperature=1.2,
+        tags=[TargetInitializerTags.DEFAULT, TargetInitializerTags.ADVERSARIAL],
+    ),
+    TargetConfig(
+        registry_name="adversarial_chat_reasoning",
+        target_class=OpenAIChatTarget,
+        endpoint_var="ADVERSARIAL_CHAT_REASONING_ENDPOINT",
+        key_var="ADVERSARIAL_CHAT_REASONING_KEY",
+        model_var="ADVERSARIAL_CHAT_REASONING_MODEL",
+        temperature=1.2,
+        tags=[TargetInitializerTags.DEFAULT, TargetInitializerTags.ADVERSARIAL],
+    ),
     TargetConfig(
         registry_name="objective_scorer_chat",
         target_class=OpenAIChatTarget,
@@ -573,6 +600,18 @@ def _register_target(self, config: TargetConfig) -> None:
         model_name = os.getenv(config.model_var) if config.model_var else None
         underlying_model = os.getenv(config.underlying_model_var) if config.underlying_model_var else None
 
+        # Guard against silent fallback to a global OPENAI_CHAT_MODEL default when the
+        # declared per-config model env var is unset. Without this skip, the target
+        # registers cleanly but sends requests to the wrong model at runtime.
+        if config.model_var and not model_name:
+            logger.warning(
+                "Skipping target '%s': %s is not set. "
+                "All declared env vars (endpoint, key, model) must be present for this target to register.",
+                config.registry_name,
+                config.model_var,
+            )
+            return
+
         # Build kwargs for the target constructor
         kwargs: dict[str, Any] = {
             "endpoint": endpoint,

tests/unit/registry/test_target_registry.py

@@ -138,6 +138,25 @@ def test_register_instance_same_target_type_different_config(self):
 
         assert len(self.registry) == 2
 
+    def test_register_instance_with_duplicate_name_silently_overwrites(self):
+        """Characterization: re-registering an existing name silently replaces the prior entry.
+
+        BaseInstanceRegistry.register is plain dict assignment; there is no
+        collision check, warning, or error. This test pins the current behavior
+        so any future tightening (warn, raise, idempotent skip) is an
+        intentional decision rather than a silent regression. Tracked as
+        ``duplicate-registry-name`` in failure_mode_followups for the PR
+        review batch.
+        """
+        first = MockPromptTarget(model_name="first")
+        second = MockPromptTarget(model_name="second")
+
+        self.registry.register_instance(first, name="same_name")
+        self.registry.register_instance(second, name="same_name")
+
+        assert len(self.registry) == 1
+        assert self.registry.get("same_name") is second
+
 
 @pytest.mark.usefixtures("patch_central_database")
 class TestTargetRegistryGetInstanceByName:

tests/unit/setup/test_targets_initializer.py

@@ -211,6 +211,23 @@ def test_expected_targets_in_configs(self):
         assert "groq" in registry_names
         assert "google_gemini" in registry_names
 
+    def test_target_configs_have_unique_registry_names(self):
+        """Guard against typos: every ``registry_name`` in ``ENV_TARGET_CONFIGS`` must be unique.
+
+        Duplicate names would silently overwrite each other when
+        ``TargetInitializer`` registers them (per ``BaseInstanceRegistry.register``
+        semantics, characterized in ``test_target_registry.py``). Only the
+        second entry would survive in the registry, which breaks downstream
+        fan-out (``BenchmarkInitializer``) and is hard to diagnose. Tracked
+        as ``duplicate-registry-name`` in failure_mode_followups.
+        """
+        registry_names = [config.registry_name for config in TARGET_CONFIGS]
+        seen: dict[str, int] = {}
+        for name in registry_names:
+            seen[name] = seen.get(name, 0) + 1
+        duplicates = {name: count for name, count in seen.items() if count > 1}
+        assert not duplicates, f"Duplicate registry_name(s) in TARGET_CONFIGS: {duplicates}"
+
 
 class TestTargetInitializerGetInfo:
     """Tests for TargetInitializer.get_info_async method."""
@@ -500,3 +517,148 @@ async def test_register_target_default_objective_tag_still_applied(self) -> None
         assert any(entry.name == "openai_chat" for entry in default_entries), (
             "openai_chat's config.tags=[DEFAULT] must propagate even when default_objective_target=True"
         )
+
+
+ADVERSARIAL_CHAT_VARIANTS: list[tuple[str, str]] = [
+    ("adversarial_chat_singleturn", "ADVERSARIAL_CHAT_SINGLETURN"),
+    ("adversarial_chat_multiturn", "ADVERSARIAL_CHAT_MULTITURN"),
+    ("adversarial_chat_reasoning", "ADVERSARIAL_CHAT_REASONING"),
+]
+
+
+@pytest.mark.usefixtures("patch_central_database")
+class TestTargetInitializerAdversarialChatVariants:
+    """Tests for the ``ADVERSARIAL_CHAT_{SINGLETURN,MULTITURN,REASONING}_*`` env-driven variants."""
+
+    def setup_method(self) -> None:
+        """Reset registry and clear variant env vars."""
+        TargetRegistry.reset_instance()
+        self._clear_variant_env_vars()
+
+    def teardown_method(self) -> None:
+        """Reset registry and clear variant env vars."""
+        TargetRegistry.reset_instance()
+        self._clear_variant_env_vars()
+
+    @staticmethod
+    def _clear_variant_env_vars() -> None:
+        for _, prefix in ADVERSARIAL_CHAT_VARIANTS:
+            for suffix in ("ENDPOINT", "KEY", "MODEL"):
+                os.environ.pop(f"{prefix}_{suffix}", None)
+
+    @staticmethod
+    def _set_variant_env_vars(prefix: str) -> None:
+        os.environ[f"{prefix}_ENDPOINT"] = "https://variant.openai.azure.com/openai/v1"
+        os.environ[f"{prefix}_KEY"] = "test_key"
+        os.environ[f"{prefix}_MODEL"] = "deployment-name"
+
+    @pytest.mark.parametrize(("registry_name", "env_prefix"), ADVERSARIAL_CHAT_VARIANTS)
+    async def test_variant_registers_with_default_and_adversarial_tags(
+        self, registry_name: str, env_prefix: str
+    ) -> None:
+        """Each variant registers with ``[DEFAULT, ADVERSARIAL]`` tags when its env vars are set."""
+        from pyrit.setup.initializers.components.targets import TargetInitializerTags
+
+        self._set_variant_env_vars(env_prefix)
+
+        init = TargetInitializer()
+        await init.initialize_async()
+
+        registry = TargetRegistry.get_registry_singleton()
+        assert registry_name in registry
+
+        adversarial_entries = registry.get_by_tag(tag=TargetInitializerTags.ADVERSARIAL)
+        assert any(entry.name == registry_name for entry in adversarial_entries)
+
+        default_entries = registry.get_by_tag(tag=TargetInitializerTags.DEFAULT)
+        assert any(entry.name == registry_name for entry in default_entries)
+
+    @pytest.mark.parametrize(("registry_name", "env_prefix"), ADVERSARIAL_CHAT_VARIANTS)
+    async def test_variant_skips_when_env_vars_missing(self, registry_name: str, env_prefix: str) -> None:
+        """Variants skip gracefully when their env vars are missing (matches existing adversarial_chat behavior)."""
+        init = TargetInitializer()
+        await init.initialize_async()
+
+        registry = TargetRegistry.get_registry_singleton()
+        assert registry_name not in registry
+
+    @pytest.mark.parametrize(("registry_name", "env_prefix"), ADVERSARIAL_CHAT_VARIANTS)
+    async def test_variant_skips_when_model_env_var_missing(
+        self, registry_name: str, env_prefix: str, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Endpoint+key set but _MODEL unset must skip with a warning, not silently fall back to OPENAI_CHAT_MODEL."""
+        import logging
+
+        os.environ[f"{env_prefix}_ENDPOINT"] = "https://variant.openai.azure.com/openai/v1"
+        os.environ[f"{env_prefix}_KEY"] = "test_key"
+
+        try:
+            with caplog.at_level(logging.WARNING, logger="pyrit.setup.initializers.components.targets"):
+                init = TargetInitializer()
+                await init.initialize_async()
+
+            registry = TargetRegistry.get_registry_singleton()
+            assert registry_name not in registry
+
+            captured_messages = [r.message for r in caplog.records]
+            assert any(f"{env_prefix}_MODEL" in m for m in captured_messages), (
+                f"Expected a warning naming the missing {env_prefix}_MODEL env var; got: {captured_messages}"
+            )
+        finally:
+            os.environ.pop(f"{env_prefix}_ENDPOINT", None)
+            os.environ.pop(f"{env_prefix}_KEY", None)
+
+    async def test_all_variants_discoverable_via_adversarial_tag_query(self) -> None:
+        """End-to-end: variants + ``adversarial_chat`` are returned by adversarial-tag ``get_by_tag_query``."""
+        from pyrit.registry.tag_query import TagQuery
+
+        os.environ["ADVERSARIAL_CHAT_ENDPOINT"] = "https://parent.openai.azure.com/openai/v1"
+        os.environ["ADVERSARIAL_CHAT_KEY"] = "test_key"
+        os.environ["ADVERSARIAL_CHAT_MODEL"] = "deployment-name"
+
+        for _, prefix in ADVERSARIAL_CHAT_VARIANTS:
+            self._set_variant_env_vars(prefix)
+
+        try:
+            init = TargetInitializer()
+            await init.initialize_async()
+
+            registry = TargetRegistry.get_registry_singleton()
+            matches = registry.get_by_tag_query(query=TagQuery.all("adversarial"))
+            match_names = {entry.name for entry in matches}
+
+            expected = {"adversarial_chat"} | {name for name, _ in ADVERSARIAL_CHAT_VARIANTS}
+            assert expected <= match_names, (
+                f"Missing variants from tag query result. Expected superset: {expected}, got: {match_names}"
+            )
+        finally:
+            for var in ("ADVERSARIAL_CHAT_ENDPOINT", "ADVERSARIAL_CHAT_KEY", "ADVERSARIAL_CHAT_MODEL"):
+                os.environ.pop(var, None)
+
+    async def test_double_initialize_async_is_idempotent(self) -> None:
+        """Re-running ``initialize_async`` with the same env state produces the same registry contents.
+
+        Regression guard for the duplicate-registration silent-overwrite path:
+        because env vars haven't changed between calls, the rebuilt entries
+        carry identical configuration. If anyone introduces non-idempotent
+        side-effects (e.g. tag accumulation, instance leaks) into
+        ``_register_target``, this test will catch it. Tracked as
+        ``duplicate-registry-name`` in failure_mode_followups.
+        """
+        from pyrit.setup.initializers.components.targets import TargetInitializerTags
+
+        for _, prefix in ADVERSARIAL_CHAT_VARIANTS:
+            self._set_variant_env_vars(prefix)
+
+        init = TargetInitializer()
+        await init.initialize_async()
+        registry = TargetRegistry.get_registry_singleton()
+        first_names = sorted(registry.get_names())
+        first_adversarial_count = len(registry.get_by_tag(tag=TargetInitializerTags.ADVERSARIAL))
+
+        await init.initialize_async()
+        second_names = sorted(registry.get_names())
+        second_adversarial_count = len(registry.get_by_tag(tag=TargetInitializerTags.ADVERSARIAL))
+
+        assert first_names == second_names
+        assert first_adversarial_count == second_adversarial_count