decodingtrust-agent-sdk 0.1.1__tar.gz → 0.2.1__tar.gz

{decodingtrust_agent_sdk-0.1.1/decodingtrust_agent_sdk.egg-info → decodingtrust_agent_sdk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: decodingtrust-agent-sdk
-Version: 0.1.1
+Version: 0.2.1
 Summary: DecodingTrust Agent Platform (DTap) — A controllable and interactive red-teaming platform for AI agents
 Author-email: DTap Team <zhaorun@uchicago.edu>
 License:                                  Apache License

{decodingtrust_agent_sdk-0.1.1 → decodingtrust_agent_sdk-0.2.1}/cli/main.py

@@ -12,7 +12,7 @@ from .scaffold import SUPPORTED_FRAMEWORKS, scaffold
 
 app = typer.Typer(
     name="dtap",
-    help="DecodingTrust Agent Platform: run red-teaming evaluations against AI agents.",
+    help="DecodingTrust-Agent Platform (DTap): A Controllable and Interactive Red-Teaming Platform for AI Agents",
     add_completion=False,
     no_args_is_help=True,
 )

{decodingtrust_agent_sdk-0.1.1 → decodingtrust_agent_sdk-0.2.1/decodingtrust_agent_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: decodingtrust-agent-sdk
-Version: 0.1.1
+Version: 0.2.1
 Summary: DecodingTrust Agent Platform (DTap) — A controllable and interactive red-teaming platform for AI agents
 Author-email: DTap Team <zhaorun@uchicago.edu>
 License:                                  Apache License

{decodingtrust_agent_sdk-0.1.1 → decodingtrust_agent_sdk-0.2.1}/decodingtrust_agent_sdk.egg-info/SOURCES.txt

@@ -351,6 +351,7 @@ dt_arena/utils/windows/helpers.py
 dt_arena/utils/zoom/__init__.py
 dt_arena/utils/zoom/helpers.py
 eval/__init__.py
+eval/_ui.py
 eval/evaluation.py
 eval/task_runner.py
 utils/__init__.py

decodingtrust_agent_sdk-0.2.1/eval/_ui.py

@@ -0,0 +1,339 @@
+"""Rich live-progress UI for `dtap eval`.
+
+Off when --verbose is set or stdout is not a TTY. The UI consumes structured
+`[DTAP_STATUS]` lines emitted by task_runner.py via stdout-pipe capture.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import threading
+import time
+from collections import deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Tuple
+
+import psutil
+from rich.console import Console, Group
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, TextColumn, TimeRemainingColumn
+from rich.table import Table
+from rich.text import Text
+
+
+STATUS_PREFIX = "[DTAP_STATUS]"
+_MAX_FAILURES_SHOWN = 5
+_MAX_RUNNING_SHOWN = 12
+
+
+# ─── Live state ──────────────────────────────────────────────────────────────
+
+@dataclass
+class TaskState:
+    task_id: str
+    domain: str
+    environments: Tuple[str, ...]
+    start_time: float
+    phase: str = "queued"        # queued | loading | running | judging | done
+    turn: int = 0
+    total_turns: int = 0
+    log_path: Optional[Path] = None
+
+
+@dataclass
+class EvalUIState:
+    total_tasks: int
+    agent_type: str
+    model: str
+    max_parallel: int
+    filters: Dict[str, Optional[str]]
+    start_time: float = field(default_factory=time.monotonic)
+
+    running: Dict[str, TaskState] = field(default_factory=dict)
+    succeeded: int = 0
+    failed: int = 0
+    recent_failures: deque = field(default_factory=lambda: deque(maxlen=_MAX_FAILURES_SHOWN))
+    durations: List[float] = field(default_factory=list)
+
+    _lock: threading.Lock = field(default_factory=threading.Lock)
+
+    # mutation helpers — thread-safe (status lines arrive on background reader tasks)
+
+    def start_task(self, task_id: str, domain: str, environments: Iterable[str],
+                   log_path: Optional[Path]) -> None:
+        with self._lock:
+            self.running[task_id] = TaskState(
+                task_id=task_id,
+                domain=domain,
+                environments=tuple(environments),
+                start_time=time.monotonic(),
+                log_path=log_path,
+            )
+
+    def update_status(self, task_id: str, fields: Dict[str, str]) -> None:
+        with self._lock:
+            st = self.running.get(task_id)
+            if st is None:
+                return
+            if "phase" in fields:
+                st.phase = fields["phase"]
+            if "turn" in fields:
+                st.turn = int(fields["turn"])
+            if "total_turns" in fields:
+                st.total_turns = int(fields["total_turns"])
+            if "turns" in fields and not st.total_turns:
+                st.total_turns = int(fields["turns"])
+
+    def finish_task(self, task_id: str, success: bool) -> None:
+        with self._lock:
+            st = self.running.pop(task_id, None)
+            elapsed = time.monotonic() - st.start_time if st else 0.0
+            self.durations.append(elapsed)
+            if success:
+                self.succeeded += 1
+            else:
+                self.failed += 1
+                if st:
+                    self.recent_failures.append((task_id, st.log_path))
+
+    @property
+    def completed(self) -> int:
+        return self.succeeded + self.failed
+
+
+# ─── Status-line parsing ─────────────────────────────────────────────────────
+
+def parse_status_line(line: str) -> Optional[Dict[str, str]]:
+    """Parse a '[DTAP_STATUS] k=v k=v' line into a dict, or None if not a status."""
+    if not line.startswith(STATUS_PREFIX):
+        return None
+    body = line[len(STATUS_PREFIX):].strip()
+    fields: Dict[str, str] = {}
+    for tok in body.split():
+        if "=" in tok:
+            k, v = tok.split("=", 1)
+            fields[k] = v
+    return fields
+
+
+# ─── Rendering ───────────────────────────────────────────────────────────────
+
+def _format_duration(secs: float) -> str:
+    secs = max(0, int(secs))
+    h, rem = divmod(secs, 3600)
+    m, s = divmod(rem, 60)
+    if h:
+        return f"{h:d}:{m:02d}:{s:02d}"
+    return f"{m:02d}:{s:02d}"
+
+
+def _docker_container_count() -> Optional[int]:
+    if shutil.which("docker") is None:
+        return None
+    try:
+        out = subprocess.run(
+            ["docker", "ps", "--quiet"],
+            capture_output=True, text=True, timeout=2,
+        )
+        if out.returncode != 0:
+            return None
+        return sum(1 for line in out.stdout.splitlines() if line.strip())
+    except Exception:
+        return None
+
+
+def _phase_chip(phase: str, turn: int, total_turns: int) -> Text:
+    color = {
+        "queued": "dim",
+        "loading": "yellow",
+        "running": "cyan",
+        "judging": "magenta",
+        "done": "green",
+    }.get(phase, "white")
+    label = phase
+    if phase == "running" and total_turns:
+        label = f"turn {turn or 1}/{total_turns}"
+    return Text(f"[{label}]", style=color)
+
+
+def _header_panel(state: EvalUIState) -> Panel:
+    filter_str = " · ".join(f"{k}={v}" for k, v in state.filters.items() if v)
+    line = Text.assemble(
+        (state.agent_type, "bold cyan"),
+        " · ",
+        (state.model, "bold"),
+        f" · max_parallel={state.max_parallel}",
+    )
+    if filter_str:
+        line.append(" · ")
+        line.append(filter_str, style="dim")
+    return Panel(line, title="DTap evaluation", title_align="left", border_style="cyan")
+
+
+def _progress_panel(state: EvalUIState, progress: Progress, task_id: int) -> Panel:
+    progress.update(task_id, completed=state.completed)
+    elapsed = time.monotonic() - state.start_time
+    avg = (sum(state.durations) / len(state.durations)) if state.durations else 0.0
+    summary = Text.assemble(
+        ("Succeeded: ", "bold"),
+        (str(state.succeeded), "green"),
+        "   Failed: ",
+        (str(state.failed), "red" if state.failed else "dim"),
+        "   Avg: ",
+        (f"{avg:0.1f}s", "cyan"),
+        "   Elapsed: ",
+        (_format_duration(elapsed), "cyan"),
+    )
+    return Panel(Group(progress, summary), title="Progress", title_align="left", border_style="white")
+
+
+def _running_panel(state: EvalUIState) -> Panel:
+    with state._lock:
+        items = list(state.running.values())
+    items.sort(key=lambda t: t.start_time)
+    table = Table.grid(padding=(0, 1))
+    table.add_column(width=3, no_wrap=True)
+    table.add_column(no_wrap=True)
+    table.add_column(no_wrap=True)
+    table.add_column(no_wrap=True, justify="right")
+
+    now = time.monotonic()
+    shown = items[:_MAX_RUNNING_SHOWN]
+    for st in shown:
+        envs = ",".join(st.environments) or "—"
+        table.add_row(
+            "▸",
+            Text(f"{st.domain}/{st.task_id}", style="bold"),
+            _phase_chip(st.phase, st.turn, st.total_turns),
+            Text(_format_duration(now - st.start_time), style="dim"),
+        )
+    if len(items) > _MAX_RUNNING_SHOWN:
+        table.add_row("", Text(f"... +{len(items) - _MAX_RUNNING_SHOWN} more", style="dim"), "", "")
+    if not items:
+        table.add_row("", Text("(idle)", style="dim"), "", "")
+    return Panel(
+        table,
+        title=f"Running ({len(items)}/{state.max_parallel})",
+        title_align="left",
+        border_style="cyan",
+    )
+
+
+def _resources_panel(state: EvalUIState, port_provider=None) -> Panel:
+    cpu = psutil.cpu_percent(interval=None)
+    vm = psutil.virtual_memory()
+    mem_used_gb = (vm.total - vm.available) / (1024 ** 3)
+    mem_total_gb = vm.total / (1024 ** 3)
+
+    containers = _docker_container_count()
+    docker_str = f"{containers}" if containers is not None else "n/a"
+
+    ports = port_provider() if port_provider else []
+    if len(ports) > 12:
+        port_str = ", ".join(str(p) for p in sorted(ports)[:12]) + f", … (+{len(ports) - 12})"
+    else:
+        port_str = ", ".join(str(p) for p in sorted(ports)) if ports else "—"
+
+    line = Text.assemble(
+        ("Docker: ", "bold"), (f"{docker_str} containers   ", "white"),
+        ("CPU: ", "bold"), (f"{cpu:0.0f}%   ", "white"),
+        ("Mem: ", "bold"), (f"{mem_used_gb:0.1f}/{mem_total_gb:0.0f} GB", "white"),
+    )
+    ports_line = Text.assemble(("Ports in use: ", "bold"), (port_str, "dim"))
+    return Panel(Group(line, ports_line), title="Resources", title_align="left", border_style="magenta")
+
+
+def _failures_panel(state: EvalUIState) -> Optional[Panel]:
+    with state._lock:
+        failures = list(state.recent_failures)
+    if not failures:
+        return None
+    table = Table.grid(padding=(0, 1))
+    table.add_column(no_wrap=True)
+    table.add_column(no_wrap=False)
+    for task_id, log in failures:
+        log_str = str(log) if log else "(no log)"
+        table.add_row(Text(task_id, style="red"), Text(log_str, style="dim"))
+    return Panel(table, title="Recent failures", title_align="left", border_style="red")
+
+
+# ─── LiveProgress controller ─────────────────────────────────────────────────
+
+class LiveProgress:
+    """Owns the Rich Live layout and exposes mutation hooks for the eval loop."""
+
+    def __init__(
+        self,
+        *,
+        total_tasks: int,
+        agent_type: str,
+        model: str,
+        max_parallel: int,
+        filters: Dict[str, Optional[str]],
+        port_provider=None,
+        console: Optional[Console] = None,
+    ) -> None:
+        self.state = EvalUIState(
+            total_tasks=total_tasks,
+            agent_type=agent_type,
+            model=model,
+            max_parallel=max_parallel,
+            filters=filters,
+        )
+        self._console = console or Console()
+        self._port_provider = port_provider
+        self._progress = Progress(
+            TextColumn("[bold blue]{task.percentage:>5.1f}%"),
+            BarColumn(bar_width=None),
+            TextColumn("{task.completed}/{task.total}"),
+            TextColumn("ETA"),
+            TimeRemainingColumn(),
+            expand=True,
+        )
+        self._task_id = self._progress.add_task("overall", total=total_tasks)
+        self._live: Optional[Live] = None
+
+    def __enter__(self) -> "LiveProgress":
+        self._live = Live(
+            self._render(),
+            console=self._console,
+            refresh_per_second=4,
+            transient=False,
+        )
+        self._live.__enter__()
+        # Kick off a refresh thread so the elapsed-time / resources tick even
+        # when no events arrive.
+        self._stop = threading.Event()
+        self._refresher = threading.Thread(target=self._tick, daemon=True)
+        self._refresher.start()
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self._stop.set()
+        self._refresher.join(timeout=2)
+        if self._live:
+            self._live.update(self._render())
+            self._live.__exit__(*exc)
+
+    def _tick(self) -> None:
+        while not self._stop.is_set():
+            if self._live is not None:
+                self._live.update(self._render())
+            self._stop.wait(0.25)
+
+    def _render(self) -> Layout:
+        layout = Layout()
+        sections = [
+            Layout(_header_panel(self.state), size=3, name="header"),
+            Layout(_progress_panel(self.state, self._progress, self._task_id), size=4, name="progress"),
+            Layout(_running_panel(self.state), name="running"),
+            Layout(_resources_panel(self.state, self._port_provider), size=4, name="resources"),
+        ]
+        failures = _failures_panel(self.state)
+        if failures is not None:
+            sections.insert(4, Layout(failures, size=min(len(self.state.recent_failures) + 2, 8), name="failures"))
+        layout.split_column(*sections)
+        return layout

{decodingtrust_agent_sdk-0.1.1 → decodingtrust_agent_sdk-0.2.1}/eval/evaluation.py

@@ -4,7 +4,7 @@ import os
 import sys
 import time
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import Dict, List, Optional, Tuple
 
 from utils import (
     PROJECT_ROOT,
@@ -18,6 +18,8 @@ from utils.memory_guard import check_memory_before_launch
 from utils.task_executor import TaskExecutor, ScheduledTask, EnvInstance, get_task_environments
 from utils.eval_stats import TaskTiming, EvaluationStats
 
+from eval._ui import LiveProgress, parse_status_line
+
 
 def _build_scheduled_tasks(task_specs: List[TaskSpec]) -> List[ScheduledTask]:
     """Convert TaskSpec list to ScheduledTask list with environment requirements."""
@@ -37,49 +39,65 @@ def _build_scheduled_tasks(task_specs: List[TaskSpec]) -> List[ScheduledTask]:
     return scheduled
 
 
+def _short_task_id(task: ScheduledTask) -> str:
+    """Compact ID like 'finance/indirect/action_reversal/12' for the UI."""
+    if task.risk_category and task.task_id:
+        return f"{task.risk_category}/{task.task_id}"
+    return task.task_dir.name
+
+
+def _task_log_path(args: argparse.Namespace, task: ScheduledTask) -> Path:
+    """Where to write the captured subprocess output for this task."""
+    output_root = Path(os.getenv("EVAL_RESULTS_ROOT", str(Path.cwd() / "results")))
+    dataset_path = extract_dataset_path(task.task_dir)
+    safe_model = args.model.replace("/", "_").replace(":", "_")
+    result_type = "direct_prompt" if args.direct_prompt else "benchmark"
+    log_dir = output_root / result_type / args.agent_type / safe_model / dataset_path
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir / "task.log"
+
+
 async def _run_single_task_subprocess(
     task: ScheduledTask,
     instances: Dict[str, EnvInstance],
     args: argparse.Namespace,
     base_env: Dict[str, str],
+    ui: Optional[LiveProgress] = None,
 ) -> int:
-    """
-    Invoke task_runner.py as a subprocess for a single task.
+    """Invoke task_runner.py as a subprocess for one task.
+
+    One code path regardless of UI mode:
+      - subprocess stdout/stderr are always piped, written to <out>/task.log,
+        and scanned for [DTAP_STATUS] lines feeding the UI state.
+      - --verbose additionally echoes each captured line to the terminal.
 
-    The Docker environments are already running (managed by TaskExecutor).
-    We pass the port mappings via environment variables so task_runner
-    can skip Docker startup and use the existing instances.
+    Docker environments are managed by TaskExecutor; we pass port mappings
+    via env vars so task_runner skips its own Docker startup.
     """
     env = base_env.copy()
+    env["PYTHONUNBUFFERED"] = "1"  # keep per-line latency low
 
-    # Ensure PYTHONPATH includes project root
+    # PYTHONPATH must include the project root for the subprocess
     pythonpath = env.get("PYTHONPATH", "")
     if str(PROJECT_ROOT) not in pythonpath:
         env["PYTHONPATH"] = f"{PROJECT_ROOT}:{pythonpath}" if pythonpath else str(PROJECT_ROOT)
 
     # Pass port mappings and project names from instances
-    print(f"[DEBUG] Instances: {list(instances.keys())}", flush=True)
     for instance in instances.values():
-        print(f"[DEBUG] Instance {instance.env_name} ports: {instance.ports}", flush=True)
         for var_name, port in instance.ports.items():
             env[var_name] = str(port)
-        # Pass project name so env_seed.py can use it for docker commands
         env_name_upper = instance.env_name.upper().replace("-", "_")
         env[f"{env_name_upper}_PROJECT_NAME"] = instance.project_name
 
-    # Port range for MCP servers (allocated per-task)
     if args.port_range:
         env["DT_PORT_RANGE"] = args.port_range
 
     cmd = [
         sys.executable,
         str(TASK_RUNNER_PATH),
-        "--task-dir",
-        str(task.task_dir),
-        "--agent-type",
-        args.agent_type,
-        "--model",
-        args.model,
+        "--task-dir", str(task.task_dir),
+        "--agent-type", args.agent_type,
+        "--model", args.model,
     ]
     if args.skip_mcp:
         cmd.append("--skip-mcp")
@@ -94,14 +112,54 @@ async def _run_single_task_subprocess(
     if args.disallowed_tools:
         cmd.extend(["--disallowed-tools"] + args.disallowed_tools)
 
-    print(f"[EVAL] Starting task: {task.task_dir} (envs={list(task.environments)})", flush=True)
+    short_id = _short_task_id(task)
+    log_path = _task_log_path(args, task)
+
+    if ui is not None:
+        ui.state.start_task(
+            task_id=short_id,
+            domain=task.domain or "?",
+            environments=task.environments,
+            log_path=log_path,
+        )
+    if args.verbose:
+        sys.stdout.write(
+            f"[EVAL] {short_id}  envs={list(task.environments)}  log={log_path}\n"
+        )
+        sys.stdout.flush()
+
     proc = await asyncio.create_subprocess_exec(
         *cmd,
         cwd=str(PROJECT_ROOT),
         env=env,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,  # merge so the log has the full timeline
     )
+    assert proc.stdout is not None
+
+    with log_path.open("wb") as logf:
+        async for line in proc.stdout:
+            logf.write(line)
+            logf.flush()
+
+            text = line.decode(errors="replace").rstrip()
+
+            # Status lines drive the UI state regardless of display mode.
+            fields = parse_status_line(text)
+            if fields and ui is not None:
+                ui.state.update_status(short_id, fields)
+
+            # Verbose mode echoes raw output to the terminal.
+            if args.verbose:
+                sys.stdout.write(text + "\n")
+                sys.stdout.flush()
+
     rc = await proc.wait()
-    print(f"[EVAL] Finished task: {task.task_dir} (rc={rc})")
+    if ui is not None:
+        ui.state.finish_task(short_id, success=(rc == 0))
+    if args.verbose:
+        sys.stdout.write(f"[EVAL] {short_id} finished (rc={rc})\n")
+        sys.stdout.flush()
     return rc
 
 
@@ -223,6 +281,31 @@ async def _run_all_tasks(args: argparse.Namespace) -> int:
     base_env = os.environ.copy()
     task_timings: Dict[str, TaskTiming] = {}
 
+    # Decide between Rich live UI vs raw passthrough.
+    # Live UI is the default; --verbose or non-TTY falls back to legacy logs.
+    use_live_ui = (not args.verbose) and sys.stdout.isatty()
+
+    def _ports_in_use() -> list:
+        try:
+            ports: set = set()
+            for inst in getattr(executor, "_all_instances", {}).values():
+                for p in (inst.ports or {}).values():
+                    ports.add(int(p))
+            return sorted(ports)
+        except Exception:
+            return []
+
+    ui_ctx: Optional[LiveProgress] = None
+    if use_live_ui:
+        ui_ctx = LiveProgress(
+            total_tasks=len(scheduled_tasks),
+            agent_type=args.agent_type,
+            model=args.model,
+            max_parallel=args.max_parallel,
+            filters=filter_items,
+            port_provider=_ports_in_use,
+        )
+
     async def run_task(task: ScheduledTask, instances: Dict[str, EnvInstance]) -> int:
         """Wrapper to run a task and track timing."""
         task_name = task.task_dir.name
@@ -230,11 +313,12 @@ async def _run_all_tasks(args: argparse.Namespace) -> int:
         timing.start_time = time.time()
 
         try:
-            rc = await _run_single_task_subprocess(task, instances, args, base_env)
+            rc = await _run_single_task_subprocess(task, instances, args, base_env, ui=ui_ctx)
             timing.success = (rc == 0)
             return rc
         except Exception as e:
-            print(f"[EVAL] Error running task {task_name}: {e}", flush=True)
+            if not use_live_ui:
+                print(f"[EVAL] Error running task {task_name}: {e}", flush=True)
             timing.success = False
             return 1
         finally:
@@ -243,9 +327,13 @@ async def _run_all_tasks(args: argparse.Namespace) -> int:
             stats.task_timings.append(timing)
 
     try:
-        # Run all tasks
-        print(f"\n[EVAL] Starting evaluation...", flush=True)
-        results = await executor.run_all(scheduled_tasks, run_task)
+        if not use_live_ui:
+            print(f"\n[EVAL] Starting evaluation...", flush=True)
+        if ui_ctx is not None:
+            with ui_ctx:
+                results = await executor.run_all(scheduled_tasks, run_task)
+        else:
+            results = await executor.run_all(scheduled_tasks, run_task)
 
     finally:
         # Record end time
@@ -387,6 +475,15 @@ def main() -> None:
         action="store_true",
         help="Enable debug mode to save extra info like tool descriptions in trajectory.",
     )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help=(
+            "Stream raw task_runner stdout/stderr to the terminal. "
+            "Without this, dtap eval shows a live progress UI and writes "
+            "per-task logs to <results>/.../task.log."
+        ),
+    )
     parser.add_argument(
         "--direct-prompt",
         action="store_true",

{decodingtrust_agent_sdk-0.1.1 → decodingtrust_agent_sdk-0.2.1}/eval/task_runner.py

@@ -35,6 +35,16 @@ from dt_arena.src.types.agent import AgentConfig, RuntimeConfig
 from dt_arena.src.types.task import AttackConfig, TaskConfig
 
 
+def _status(**fields: object) -> None:
+    """Emit a machine-readable status line consumed by the dtap eval progress UI.
+
+    Format: [DTAP_STATUS] key1=val1 key2=val2 ...
+    Always flushes so the parent gets near-real-time updates.
+    """
+    parts = " ".join(f"{k}={v}" for k, v in fields.items())
+    print(f"[DTAP_STATUS] {parts}", flush=True)
+
+
 async def run_single_task(
     task_dir: Path,
     *,
@@ -68,6 +78,7 @@ async def run_single_task(
         print(f"[ERROR] Configuration file not found: {config_path}")
         return 1
     
+    _status(phase="loading")
     print(f"[INFO] Loading agent config from: {config_path}")
     print("-" * 80)
 
@@ -241,6 +252,7 @@ async def run_single_task(
             print(attack_cfg.malicious_goal.strip())
             print("-" * 80)
 
+        _status(phase="running", turns=len(user_instruction) if isinstance(user_instruction, list) else 1)
         # Run agent with per-turn env injection support
         async with agent:
             metadata = {
@@ -281,6 +293,7 @@ async def run_single_task(
                                 print(f"       Error: {inj_result['error']}")
 
                 # Run agent for this turn
+                _status(turn=turn_id, total_turns=len(instructions))
                 print(f"\n[TURN {turn_id}] Processing query...")
                 try:
                     result = await agent.run(turn_instruction, metadata=metadata)
@@ -315,6 +328,7 @@ async def run_single_task(
 
             # Run judge
             if not skip_judge:
+                _status(phase="judging")
                 judge_result = run_judge(task_dir, response=final_output)
                 print_judge_result(judge_result)
 
@@ -325,10 +339,12 @@ async def run_single_task(
                 print(f"[INFO] Judge result saved to: {judge_output_path}")
 
                 if judge_result.get("task_success") is False:
+                    _status(phase="done", success=0)
                     return 1
             else:
                 print("[JUDGE] Skipped judge as requested.")
 
+            _status(phase="done", success=1)
             return 0
 
     except subprocess.CalledProcessError as e:

{decodingtrust_agent_sdk-0.1.1 → decodingtrust_agent_sdk-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "decodingtrust-agent-sdk"
-version = "0.1.1"
+version = "0.2.1"
 description = "DecodingTrust Agent Platform (DTap) — A controllable and interactive red-teaming platform for AI agents"
 readme = "README.md"
 license = { file = "LICENSE" }