synth-ai 0.2.4.dev5__py3-none-any.whl → 0.2.4.dev6__py3-none-any.whl

synth_ai/environments/examples/wordle/taskset.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import json
+import random
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Tuple
+from uuid import uuid4, UUID
+
+from synth_ai.environments.tasks.core import (
+    TaskInstance,
+    TaskInstanceMetadata,
+    TaskInstanceSet,
+    Impetus,
+    Intent,
+    SplitInfo,
+)
+
+from .engine import DEFAULT_SOLUTIONS
+
+
+@dataclass
+class WordleTaskInstanceMetadata(TaskInstanceMetadata):
+    word_length: int
+    max_guesses: int
+    target_word: str
+    enforce_wordlist: bool
+    seed: int | None = None
+    consume_invalid_attempts: bool = True
+
+
+@dataclass
+class WordleTaskInstance(TaskInstance):
+    async def serialize(self) -> dict:
+        return {
+            "id": str(self.id),
+            "impetus": {"instructions": self.impetus.instructions},
+            "intent": {
+                "rubric": self.intent.rubric,
+                "gold_trajectories": self.intent.gold_trajectories,
+                "gold_state_diff": self.intent.gold_state_diff,
+            },
+            "metadata": {
+                "word_length": self.metadata.word_length,
+                "max_guesses": self.metadata.max_guesses,
+                "target_word": self.metadata.target_word,
+                "enforce_wordlist": self.metadata.enforce_wordlist,
+                "seed": self.metadata.seed,
+                "consume_invalid_attempts": self.metadata.consume_invalid_attempts,
+            },
+            "is_reproducible": self.is_reproducible,
+            "initial_engine_snapshot": self.initial_engine_snapshot,
+        }
+
+    @classmethod
+    async def deserialize(cls, data: dict) -> "WordleTaskInstance":
+        from uuid import UUID
+
+        metadata = WordleTaskInstanceMetadata(
+            word_length=data["metadata"]["word_length"],
+            max_guesses=data["metadata"]["max_guesses"],
+            target_word=data["metadata"]["target_word"],
+            enforce_wordlist=data["metadata"]["enforce_wordlist"],
+            seed=data["metadata"].get("seed"),
+            consume_invalid_attempts=data["metadata"].get("consume_invalid_attempts", True),
+        )
+
+        return cls(
+            id=UUID(data["id"]),
+            impetus=Impetus(instructions=data["impetus"]["instructions"]),
+            intent=Intent(
+                rubric=data["intent"]["rubric"],
+                gold_trajectories=data["intent"]["gold_trajectories"],
+                gold_state_diff=data["intent"]["gold_state_diff"],
+            ),
+            metadata=metadata,
+            is_reproducible=data["is_reproducible"],
+            initial_engine_snapshot=data["initial_engine_snapshot"],
+        )
+
+
+def _stable_uuid_for_instance(idx: int, target: str) -> UUID:
+    import uuid
+    return uuid.uuid5(uuid.NAMESPACE_URL, f"wordle-fixed-v1:{idx}:{target}")
+
+
+def _load_fixed_instances_json() -> tuple[List[dict], dict]:
+    """Load fixed instances definition from instances.json (if present).
+
+    Returns a tuple (instances, defaults) where instances is a list of dicts with at least
+    target_word fields, and defaults contains default params.
+    """
+    import os
+    # Allow override via env var
+    override = os.getenv("WORDLE_INSTANCES_JSON")
+    p = Path(override) if override else Path(__file__).with_name("instances.json")
+    if not p.exists():
+        return [], {}
+    try:
+        data = json.loads(p.read_text())
+        defaults = data.get("defaults", {}) or {}
+        insts = data.get("instances", []) or []
+        return insts, defaults
+    except Exception:
+        return [], {}
+
+
+# Note: generation helpers removed from runtime. Use the provided script in tools/
+_ = None
+
+
+async def create_wordle_taskset(
+    *,
+    word_length: int = 5,
+    max_guesses: int = 6,
+    enforce_wordlist: bool = False,
+    sample_size: int = 30,
+    consume_invalid_attempts: bool = True,
+) -> TaskInstanceSet:
+    """Create a Wordle taskset.
+
+    Priority:
+    1) If instances.json exists, use it to produce a fixed, stable taskset with deterministic IDs.
+    2) Otherwise, fall back to a procedural slice of DEFAULT_SOLUTIONS (stable ordering).
+    """
+
+    json_insts, json_defaults = _load_fixed_instances_json()
+
+    instances: List[WordleTaskInstance] = []
+    # Assemble fixed targets from JSON only (no runtime generation)
+    fixed_targets: List[str] = []
+    if json_insts:
+        fixed_targets.extend([str(r.get("target_word", "")).strip().lower() for r in json_insts if r.get("target_word")])
+
+    if fixed_targets:
+        # Use fixed_targets, honoring defaults and slicing by sample_size
+        chosen = fixed_targets[:sample_size]
+        for i, tgt in enumerate(chosen):
+            md = WordleTaskInstanceMetadata(
+                word_length=int(word_length),
+                max_guesses=int(max_guesses),
+                target_word=tgt,
+                enforce_wordlist=bool(enforce_wordlist),
+                seed=i,
+                consume_invalid_attempts=bool(consume_invalid_attempts),
+            )
+            impetus = Impetus(
+                instructions=(
+                    "Play Wordle. Submit one word per turn consisting only of letters. "
+                    f"You have up to {md.max_guesses} guesses to find the {md.word_length}-letter target word. "
+                    "Feedback per letter: G=correct position, Y=present elsewhere, B=absent."
+                )
+            )
+            intent = Intent(
+                rubric={"goal": "Guess the target word in as few moves as possible"},
+                gold_trajectories=None,
+                gold_state_diff={"target_known": False},
+            )
+            inst = WordleTaskInstance(
+                id=_stable_uuid_for_instance(i, md.target_word),
+                impetus=impetus,
+                intent=intent,
+                metadata=md,
+                is_reproducible=True,
+                initial_engine_snapshot=None,
+            )
+            instances.append(inst)
+    else:
+        # Procedural fallback: stable ordering from DEFAULT_SOLUTIONS
+        pool = [w for w in DEFAULT_SOLUTIONS if len(w) == word_length] or [w for w in DEFAULT_SOLUTIONS if len(w) == 5]
+        sample = pool[:sample_size]
+        for i, target in enumerate(sample):
+            seed = i
+            md = WordleTaskInstanceMetadata(
+                word_length=word_length,
+                max_guesses=max_guesses,
+                target_word=target,
+                enforce_wordlist=enforce_wordlist,
+                seed=seed,
+                consume_invalid_attempts=consume_invalid_attempts,
+            )
+            impetus = Impetus(
+                instructions=(
+                    "Play Wordle. Submit one word per turn consisting only of letters. "
+                    f"You have up to {max_guesses} guesses to find the {word_length}-letter target word. "
+                    "Feedback per letter: G=correct position, Y=present elsewhere, B=absent."
+                )
+            )
+            intent = Intent(
+                rubric={"goal": "Guess the target word in as few moves as possible"},
+                gold_trajectories=None,
+                gold_state_diff={"target_known": False},
+            )
+            inst = WordleTaskInstance(
+                id=_stable_uuid_for_instance(i, target),
+                impetus=impetus,
+                intent=intent,
+                metadata=md,
+                is_reproducible=True,
+                initial_engine_snapshot=None,
+            )
+            instances.append(inst)
+
+    # Deterministic split based on index positions
+    val_ids = {instances[i].id for i in range(0, len(instances), 5)}
+    test_ids = {instances[i].id for i in range(0, len(instances), 7)}
+    split = SplitInfo(val_instance_ids=val_ids, test_instance_ids=test_ids, _is_split_defined=True)
+
+    return TaskInstanceSet(
+        name="Wordle Fixed TaskSet" if json_insts else "Wordle Example TaskSet",
+        description=(
+            "Fixed set from instances.json (stable ordering)."
+            if json_insts
+            else "Lightweight Wordle tasks with fixed targets and seeds."
+        ),
+        instances=instances,
+        split_info=split,
+    )
+
+
+# Alias
+taskset = create_wordle_taskset

synth_ai/environments/service/app.py

@@ -38,6 +38,14 @@ import synth_ai.environments.examples.crafter_custom.environment as ccustom
 
 register_environment("CrafterCustom", ccustom.CrafterCustomEnvironment)
 
+# Register Wordle example environment
+try:
+    import synth_ai.environments.examples.wordle.environment as wordle_mod
+    register_environment("Wordle", wordle_mod.WordleEnvironment)
+except Exception as _e:
+    # Keep service robust even if example env import fails
+    logging.getLogger(__name__).warning(f"Wordle env not registered: {_e}")
+
 app = FastAPI(title="Environment Service")
 
 

synth_ai/environments/service/core_routes.py

@@ -7,6 +7,7 @@ import os
 import json
 import pickle
 import base64
+from io import BytesIO
 import numpy as np
 import tempfile
 from dataclasses import dataclass
@@ -727,6 +728,43 @@ async def terminate_env(env_name: str, request: TerminateRequest = Body(...)) ->
         raise HTTPException(status_code=400, detail=str(e))
 
 
+@api_router.get("/env/{env_name}/frame")
+async def get_env_frame(env_name: str, env_id: str) -> Dict[str, Any]:
+    """Return the current rendered frame of the environment as base64 PNG.
+
+    This provides a lightweight way for clients to capture before/after snapshots
+    around steps without modifying core step responses.
+    """
+    env = await storage.get(env_id)
+    if not env:
+        raise HTTPException(status_code=404, detail=f"Environment instance {env_id} not found")
+
+    try:
+        # For CrafterClassic, underlying engine exposes env.render() -> RGB ndarray
+        if hasattr(env, "engine") and hasattr(env.engine, "env") and hasattr(env.engine.env, "render"):
+            rgb = env.engine.env.render()
+        else:
+            raise RuntimeError("Environment does not support render()")
+
+        if rgb is None:
+            raise RuntimeError("render() returned None")
+
+        # Encode to PNG base64
+        try:
+            from PIL import Image  # type: ignore
+            img = Image.fromarray(rgb.astype("uint8"), "RGB")
+            buf = BytesIO()
+            img.save(buf, format="PNG")
+            b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+        except Exception as e:
+            raise RuntimeError(f"failed to encode frame: {e}")
+
+        return {"env_id": env_id, "image_base64": b64}
+    except Exception as e:
+        logger.error(f"Error rendering frame for {env_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @api_router.get("/env/{env_name}/metadata")
 async def get_env_metadata(env_name: str, env_id: str) -> Dict[str, Any]:
     """Get metadata about an environment instance."""

synth_ai/learning/prompts/banking77_injection_eval.py

@@ -0,0 +1,163 @@
+"""
+Banking77 in-context injection evals (async, not tests)
+
+Samples a handful of Banking77 prompts and evaluates multiple override
+contexts in parallel, printing simple accuracy for each.
+
+Usage
+- Keys in .env (GROQ_API_KEY, etc.)
+- Run: uv run -q python -m synth_ai.learning.prompts.banking77_injection_eval
+  Optional env:
+    - N_SAMPLES=20 (default)
+    - MODEL=openai/gpt-oss-20b (default)
+    - VENDOR=groq (default)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import random
+from typing import List, Dict, Any, Tuple
+
+from dotenv import load_dotenv
+from datasets import load_dataset
+
+from synth_ai.lm.core.main_v3 import LM, build_messages
+from synth_ai.lm.overrides import LMOverridesContext
+
+
+async def classify_one(lm: LM, text: str, label_names: List[str]) -> str:
+    labels_joined = ", ".join(label_names)
+    system_message = (
+        "You are an intent classifier for the Banking77 dataset. "
+        "Given a customer message, respond with exactly one label from the list. "
+        "Return only the label text with no extra words.\n\n"
+        f"Valid labels: {labels_joined}"
+    )
+    user_message = f"Message: {text}\nLabel:"
+    messages = build_messages(system_message, user_message, images_bytes=None, model_name=lm.model)
+    resp = await lm.respond_async(messages=messages)
+    return (resp.raw_response or "").strip()
+
+
+def choose_label(pred: str, label_names: List[str]) -> str:
+    norm_pred = pred.strip().lower()
+    label_lookup = {ln.lower(): ln for ln in label_names}
+    mapped = label_lookup.get(norm_pred)
+    if mapped is not None:
+        return mapped
+
+    # Fallback: choose the label with the highest naive token overlap
+    def score(cand: str) -> int:
+        c = cand.lower()
+        return sum(1 for w in c.split() if w in norm_pred)
+
+    return max(label_names, key=score)
+
+
+async def eval_context(lm: LM, items: List[Tuple[str, str]], label_names: List[str], ctx_name: str, specs: List[Dict[str, Any]]) -> Tuple[str, int, int]:
+    correct = 0
+    with LMOverridesContext(specs):
+        tasks = [classify_one(lm, text, label_names) for text, _ in items]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+    for (text, gold), pred in zip(items, results):
+        if isinstance(pred, Exception):
+            # Treat exceptions as incorrect
+            continue
+        mapped = choose_label(pred, label_names)
+        correct += int(mapped == gold)
+    return (ctx_name, correct, len(items))
+
+
+async def main() -> None:
+    load_dotenv()
+
+    n = int(os.getenv("N_SAMPLES", "20"))
+    model = os.getenv("MODEL", "openai/gpt-oss-20b")
+    vendor = os.getenv("VENDOR", "groq")
+
+    lm = LM(model=model, vendor=vendor, temperature=0.0)
+
+    print("Loading Banking77 dataset (split='test')...")
+    ds = load_dataset("banking77", split="test")
+    label_names: List[str] = ds.features["label"].names  # type: ignore
+
+    idxs = random.sample(range(len(ds)), k=min(n, len(ds)))
+    items = [
+        (ds[i]["text"], label_names[int(ds[i]["label"])])  # (text, gold_label)
+        for i in idxs
+    ]
+
+    # Define a few override contexts to compare
+    contexts: List[Dict[str, Any]] = [
+        {
+            "name": "baseline (no overrides)",
+            "overrides": [],
+        },
+        {
+            "name": "nonsense prompt injection (expected worse)",
+            "overrides": [
+                {
+                    "match": {"contains": "", "role": "user"},
+                    "injection_rules": [
+                        # Heavily corrupt user text by replacing vowels
+                        {"find": "a", "replace": "x"},
+                        {"find": "e", "replace": "x"},
+                        {"find": "i", "replace": "x"},
+                        {"find": "o", "replace": "x"},
+                        {"find": "u", "replace": "x"},
+                        {"find": "A", "replace": "X"},
+                        {"find": "E", "replace": "X"},
+                        {"find": "I", "replace": "X"},
+                        {"find": "O", "replace": "X"},
+                        {"find": "U", "replace": "X"},
+                    ],
+                }
+            ],
+        },
+        {
+            "name": "injection: atm->ATM, txn->transaction",
+            "overrides": [
+                {
+                    "match": {"contains": "atm", "role": "user"},
+                    "injection_rules": [
+                        {"find": "atm", "replace": "ATM"},
+                        {"find": "txn", "replace": "transaction"},
+                    ],
+                }
+            ],
+        },
+        {
+            "name": "params: temperature=0.0",
+            "overrides": [
+                {"match": {"contains": ""}, "params": {"temperature": 0.0}},
+            ],
+        },
+        {
+            "name": "model override: 20b->120b",
+            "overrides": [
+                {"match": {"contains": ""}, "params": {"model": "openai/gpt-oss-120b"}},
+            ],
+        },
+    ]
+
+    print(f"\nEvaluating {len(contexts)} contexts on {len(items)} Banking77 samples (async)...")
+
+    # Evaluate each context sequentially but batched (each context classifies in parallel)
+    results: List[Tuple[str, int, int]] = []
+    for ctx in contexts:
+        name = ctx["name"]
+        specs = ctx["overrides"]
+        print(f"Evaluating: {name} ...")
+        res = await eval_context(lm, items, label_names, name, specs)
+        results.append(res)
+
+    print("\nResults:")
+    for name, correct, total in results:
+        acc = correct / total if total else 0.0
+        print(f"- {name}: {correct}/{total} correct ({acc:.2%})")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

synth_ai/learning/prompts/hello_world_in_context_injection_ex.py

@@ -0,0 +1,201 @@
+"""
+Hello World: Banking77 intent classification with in-context injection
+
+This script shows a minimal text-classification pipeline over the
+Hugging Face Banking77 dataset using the Synth LM interface. It also
+demonstrates a simple pre-send prompt-injection step as outlined in
+`synth_ai/learning/prompts/injection_plan.txt`.
+
+Notes
+- Network access is required to download the dataset and call the model.
+- Defaults to Groq with model `openai/gpt-oss-20b`.
+  - Export your key: `export GROQ_API_KEY=...`
+  - Override if needed: `export MODEL=openai/gpt-oss-20b VENDOR=groq`
+
+Run
+- `python -m synth_ai.learning.prompts.hello_world_in_context_injection_ex`
+
+What "in-context injection" means here
+- The script applies ordered substring replacements to the outgoing
+  `messages` array before calling the model. This mirrors the algorithm
+  described in `injection_plan.txt` without importing any non-existent
+  helper yet. You can adapt `INJECTION_RULES` to your needs.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import random
+from typing import Any, Dict, List, Optional
+
+from datasets import load_dataset
+
+# Use the v3 LM class present in this repo
+from synth_ai.lm.core.main_v3 import LM, build_messages
+from synth_ai.tracing_v3.session_tracer import SessionTracer
+from synth_ai.tracing_v3.abstractions import LMCAISEvent
+
+
+# Use Overrides context to demonstrate matching by content
+from synth_ai.lm.overrides import LMOverridesContext
+INJECTION_RULES = [
+    {"find": "accnt", "replace": "account"},
+    {"find": "atm", "replace": "ATM"},
+    {"find": "txn", "replace": "transaction"},
+]
+
+
+async def classify_sample(lm: LM, text: str, label_names: List[str]) -> str:
+    """Classify one Banking77 utterance and return the predicted label name."""
+    labels_joined = ", ".join(label_names)
+    system_message = (
+        "You are an intent classifier for the Banking77 dataset. "
+        "Given a customer message, respond with exactly one label from the list. "
+        "Return only the label text with no extra words.\n\n"
+        f"Valid labels: {labels_joined}"
+    )
+    user_message = f"Message: {text}\nLabel:"
+
+    # Build canonical messages; injection will be applied inside the vendor via context
+    messages = build_messages(system_message, user_message, images_bytes=None, model_name=lm.model)
+    resp = await lm.respond_async(messages=messages)
+    raw = (resp.raw_response or "").strip()
+    return raw
+
+
+async def main() -> None:
+    # Configurable model/provider via env, with sensible defaults
+    # Default to Groq hosting `openai/gpt-oss-20b`
+    model = os.getenv("MODEL", "openai/gpt-oss-20b")
+    vendor = os.getenv("VENDOR", "groq")
+
+    # Construct LM
+    lm = LM(model=model, vendor=vendor, temperature=0.0)
+
+    # Load Banking77 dataset
+    # Columns: {"text": str, "label": int}; label names at ds.features["label"].names
+    print("Loading Banking77 dataset (split='test')...")
+    ds = load_dataset("banking77", split="test")
+    label_names: List[str] = ds.features["label"].names  # type: ignore
+
+    # Sample a few items for a quick demo
+    n = int(os.getenv("N_SAMPLES", "8"))
+    idxs = random.sample(range(len(ds)), k=min(n, len(ds)))
+
+    correct = 0
+    # Apply overrides for all calls in this block (match by content)
+    overrides = [
+        {"match": {"contains": "atm", "role": "user"}, "injection_rules": INJECTION_RULES},
+        {"match": {"contains": "refund"}, "params": {"temperature": 0.0}},
+    ]
+    with LMOverridesContext(overrides):
+        for i, idx in enumerate(idxs, start=1):
+            text: str = ds[idx]["text"]  # type: ignore
+            gold_label_idx: int = int(ds[idx]["label"])  # type: ignore
+            gold_label = label_names[gold_label_idx]
+
+            try:
+                pred = await classify_sample(lm, text, label_names)
+            except Exception as e:
+                print(f"[{i}] Error calling model: {e}")
+                break
+
+            # Normalize and check exact match; if not exact, attempt a loose fallback
+            norm_pred = pred.strip().lower()
+            label_lookup = {ln.lower(): ln for ln in label_names}
+            pred_label = label_lookup.get(norm_pred)
+            if pred_label is None:
+                # Fallback: pick the label with highest substring overlap (very naive)
+                # This avoids extra deps; feel free to replace with a better matcher.
+                def score(cand: str) -> int:
+                    c = cand.lower()
+                    return sum(1 for w in c.split() if w in norm_pred)
+
+                pred_label = max(label_names, key=score)
+
+            is_correct = pred_label == gold_label
+            correct += int(is_correct)
+            print(f"[{i}] text={text!r}\n    gold={gold_label}\n    pred={pred} -> mapped={pred_label} {'✅' if is_correct else '❌'}")
+
+    if idxs:
+        acc = correct / len(idxs)
+        print(f"\nSamples: {len(idxs)} | Correct: {correct} | Accuracy: {acc:.2%}")
+
+    # ------------------------------
+    # Integration tests (three paths)
+    # ------------------------------
+    print("\nRunning integration tests with in-context injection...")
+    test_text = "I used the atm to withdraw cash."
+
+    # 1) LM path with v3 tracing: verify substitution in traced messages
+    tracer = SessionTracer()
+    await tracer.start_session(metadata={"test": "lm_injection"})
+    await tracer.start_timestep(step_id="lm_test")
+    # Use a tracer-bound LM instance
+    lm_traced = LM(model=model, vendor=vendor, temperature=0.0, session_tracer=tracer)
+    with LMOverridesContext([{"match": {"contains": "atm"}, "injection_rules": INJECTION_RULES}]):
+        _ = await classify_sample(lm_traced, test_text, label_names)
+    # inspect trace
+    events = [e for e in (tracer.current_session.event_history if tracer.current_session else []) if isinstance(e, LMCAISEvent)]
+    assert events, "No LMCAISEvent recorded by SessionTracer"
+    cr = events[-1].call_records[0]
+    traced_user = ""
+    for m in cr.input_messages:
+        if m.role == "user":
+            for part in m.parts:
+                if getattr(part, "type", None) == "text":
+                    traced_user += (part.text or "")
+    assert "ATM" in traced_user, f"Expected substitution in traced prompt; got: {traced_user!r}"
+    print("LM path trace verified: substitution present in traced prompt.")
+    await tracer.end_timestep()
+    await tracer.end_session()
+
+    # 2) OpenAI wrapper path (AsyncOpenAI to Groq): ensure apply_injection is active
+    try:
+        import synth_ai.lm.provider_support.openai as _synth_openai_patch  # noqa: F401
+        from openai import AsyncOpenAI
+        from datasets import load_dataset as _ld  # ensure datasets present
+        base_url = os.getenv("OPENAI_BASE_URL", "https://api.groq.com/openai/v1")
+        api_key = os.getenv("OPENAI_API_KEY") or os.getenv("GROQ_API_KEY") or ""
+        client = AsyncOpenAI(base_url=base_url, api_key=api_key)
+        messages = [
+            {"role": "system", "content": "Echo user label."},
+            {"role": "user", "content": f"Please classify: {test_text}"},
+        ]
+        with LMOverridesContext([{"match": {"contains": "atm"}, "injection_rules": INJECTION_RULES}]):
+            resp = await client.chat.completions.create(model=model, messages=messages, temperature=0)
+        # Not all models echo input; instead, verify that our injected expectation matches
+        expected_user = messages[1]["content"].replace("atm", "ATM")
+        if messages[1]["content"] == expected_user:
+            print("OpenAI wrapper: input already normalized; skipping assertion.")
+        else:
+            print("OpenAI wrapper: sent message contains substitution expectation:", expected_user)
+    except Exception as e:
+        print("OpenAI wrapper test skipped due to error:", e)
+
+    # 3) Anthropic wrapper path (AsyncClient): ensure apply_injection is active
+    try:
+        import synth_ai.lm.provider_support.anthropic as _synth_anthropic_patch  # noqa: F401
+        import anthropic
+        a_model = os.getenv("ANTHROPIC_MODEL", "claude-3-5-haiku-20241022")
+        a_key = os.getenv("ANTHROPIC_API_KEY")
+        if a_key:
+            a_client = anthropic.AsyncClient(api_key=a_key)
+            with LMOverridesContext([{"match": {"contains": "atm"}, "injection_rules": INJECTION_RULES}]):
+                _ = await a_client.messages.create(
+                    model=a_model,
+                    system="Echo user label.",
+                    max_tokens=64,
+                    temperature=0,
+                    messages=[{"role": "user", "content": [{"type": "text", "text": test_text}]}],
+                )
+            print("Anthropic wrapper call completed (cannot reliably assert echo).")
+        else:
+            print("Anthropic wrapper test skipped: ANTHROPIC_API_KEY not set.")
+    except Exception as e:
+        print("Anthropic wrapper test skipped due to error:", e)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())