decodingtrust-agent-sdk 0.2.4__tar.gz → 0.2.7__tar.gz

{decodingtrust_agent_sdk-0.2.4/decodingtrust_agent_sdk.egg-info → decodingtrust_agent_sdk-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: decodingtrust-agent-sdk
-Version: 0.2.4
+Version: 0.2.7
 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
@@ -224,6 +224,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: uv>=0.5.0
+Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-settings>=2.0
 Requires-Dist: PyYAML>=6.0

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/agent/claudesdk/src/agent.py

@@ -3,6 +3,7 @@ import shutil
 import tempfile
 import uuid
 from datetime import datetime
+from pathlib import Path
 from typing import Dict, Any, Optional, List, Union
 
 from claude_agent_sdk import (
@@ -70,9 +71,25 @@ class ClaudeSDKAgent(Agent):
         # Skill injection temp directory
         self._skill_temp_dir: Optional[str] = None
 
-        # Per-instance Claude Code home. 
+        # Per-instance Claude Code home.
         self._claude_home: str = tempfile.mkdtemp(prefix="claude-home-")
 
+        # Seed the isolated home with the user's OAuth credentials so that,
+        # when ANTHROPIC_API_KEY is unset, the spawned `claude` CLI authenticates
+        # via the logged-in subscription (Max/Pro) instead of reporting
+        # "Not logged in". CLAUDE_CONFIG_DIR points the CLI at this temp home, so
+        # without this copy it can't find ~/.claude/.credentials.json. The temp
+        # home (and this copy) is removed when the agent is cleaned up.
+        # No-op when API-key billing is used or no credentials file exists.
+        _src_creds = Path.home() / ".claude" / ".credentials.json"
+        if _src_creds.is_file():
+            try:
+                _dst_creds = Path(self._claude_home) / ".credentials.json"
+                shutil.copy2(_src_creds, _dst_creds)
+                os.chmod(_dst_creds, 0o600)
+            except OSError as e:
+                print(f"[WARNING] Could not seed Claude subscription credentials: {e}")
+
         # Claude SDK client for multi-turn conversations
         self._client: Optional[ClaudeSDKClient] = None
         self._options: Optional[ClaudeAgentOptions] = None

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/agent/pocketflow/src/agent.py

@@ -5,13 +5,20 @@ from datetime import datetime
 from typing import Dict, Any, List, Optional, Union
 import uuid
 from pocketflow import Flow
-from fastmcp import Client
+from fastmcp import Client, FastMCP
 
 from agent.pocketflow.src.nodes import DecideActionNode, ExecuteToolNode, FinalAnswerNode
 from agent.pocketflow.src.async_helper import AsyncHelper
 
 from dt_arena.src.types.agent import Agent, AgentConfig, RuntimeConfig, MCPServerConfig, AgentResult
 from dt_arena.src.types.trajectory import Trajectory
+from utils.skill_helpers import (
+    create_injected_skills_directory,
+    cleanup_temp_directory,
+    parse_skill_metadata,
+    load_skill_full_content,
+    scan_available_skills,
+)
 
 
 @dataclass
@@ -83,6 +90,11 @@ class MCPReactAgent(Agent):
         self._turn_count: int = 0  # Total turn count across multi-turn conversation
         self._current_trajectory: Optional[Trajectory] = None  # Current trajectory object
 
+        # Skill injection support
+        self._skill_temp_dir: Optional[str] = None
+        self._skill_mcp_server: Optional[FastMCP] = None
+        self._skill_server_thread = None
+
     def _build_flow(self) -> Flow:
         """Build the ReAct workflow using PocketFlow."""
         # Create nodes
@@ -248,6 +260,159 @@ class MCPReactAgent(Agent):
         print(f"[INFO] Total tools available: {len(self._all_tools)}")
         return self._mcp_servers
 
+    async def _setup_skills(self) -> None:
+        """Setup skill directories and apply any skill injections."""
+        skill_directories = self.config.skill_directories if self.config else []
+        skill_injection = self.runtime_config.skill_injection
+
+        has_create_mode = skill_injection and any(
+            any(inj.mode == "create" for inj in injs)
+            for injs in skill_injection.values()
+        )
+
+        if not skill_directories and not has_create_mode:
+            return
+
+        self._skill_temp_dir = create_injected_skills_directory(
+            source_skill_dirs=skill_directories,
+            skill_injection=skill_injection,
+            skill_subpath="skills",
+            base_dir=self.output_dir,
+        )
+
+    def _build_skill_mcp_server(self) -> Optional[FastMCP]:
+        """Build a local FastMCP server that exposes load_skill as an MCP tool."""
+        if not self._skill_temp_dir:
+            return None
+
+        skills_dir = os.path.join(self._skill_temp_dir, "skills")
+        mcp = FastMCP("skill-server")
+
+        @mcp.tool()
+        def load_skill(skill_name: str) -> str:
+            """Load a skill by name and return its full instructions.
+
+            Use this tool to retrieve the complete content of a skill file.
+            After loading, follow the skill's instructions to complete the task.
+
+            Args:
+                skill_name: The name of the skill to load.
+
+            Returns:
+                The full content of the skill's SKILL.md file, or an error message if not found.
+            """
+            available = scan_available_skills(skills_dir)
+            for skill in available:
+                if skill.get("name") == skill_name:
+                    return load_skill_full_content(skill["path"])
+            names = [s.get("name", "") for s in available]
+            return f"Skill '{skill_name}' not found. Available skills: {names}"
+
+        return mcp
+
+    def _build_skill_system_prompt_suffix(self) -> str:
+        """Build system prompt suffix with skill hints."""
+        if not self._skill_temp_dir:
+            return ""
+
+        skills_dir = os.path.join(self._skill_temp_dir, "skills")
+        skill_entries = []
+        if os.path.isdir(skills_dir):
+            for item in sorted(os.listdir(skills_dir)):
+                skill_path = os.path.join(skills_dir, item)
+                if not os.path.isdir(skill_path):
+                    continue
+                skill_file = os.path.join(skill_path, "SKILL.md")
+                if not os.path.exists(skill_file):
+                    continue
+                metadata = parse_skill_metadata(skill_file)
+                if metadata:
+                    skill_entries.append(f"# Skill: {item}\n\n{metadata}")
+                else:
+                    skill_entries.append(f"# Skill: {item}")
+
+        if not skill_entries:
+            return ""
+
+        skills_list = "\n".join(skill_entries)
+        return (
+            "\n\n## Instructions for Using Skills\n"
+            "You have access to the `load_skill` tool that retrieves full skill instructions, "
+            "whose metadata are defined in the system prompt. "
+            "Based on the task requirements, if you need to use a skill, "
+            "call `load_skill` with the skill name to get its full instructions, then follow them.\n\n"
+            f"## Available skills:\n{skills_list}"
+        )
+
+    async def _start_skill_mcp_server(self, mcp_server: FastMCP) -> None:
+        """Start the skill MCP server and register its tools.
+
+        The server runs in a dedicated thread with its own event loop so that
+        it can handle HTTP requests even while the main event loop is blocked
+        by the synchronous PocketFlow ``_flow.run()`` call.
+        """
+        import asyncio
+        import threading
+        import socket
+
+        server_name = "skill-server"
+
+        # Pick a random available port
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.bind(("127.0.0.1", 0))
+        port = sock.getsockname()[1]
+        sock.close()
+
+        server_url = f"http://127.0.0.1:{port}/mcp"
+
+        # Start the server in a dedicated thread with its own event loop
+        # so it stays responsive while _flow.run() blocks the caller's loop.
+        def _run_server():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(
+                mcp_server.run_async(transport="streamable-http", host="127.0.0.1", port=port)
+            )
+
+        self._skill_server_thread = threading.Thread(target=_run_server, daemon=True)
+        self._skill_server_thread.start()
+
+        # Wait for server to be ready
+        for _ in range(30):
+            try:
+                async with Client(server_url) as client:
+                    tools_response = await client.list_tools()
+                    break
+            except Exception:
+                await asyncio.sleep(0.1)
+        else:
+            raise RuntimeError("Skill MCP server failed to start within 3 seconds")
+
+        # Register skill server tools into PocketFlow's tool registry
+        async with Client(server_url) as client:
+            tools_response = await client.list_tools()
+            for tool in tools_response:
+                tool_name = tool.name
+                description = tool.description or ""
+                tool_info = {
+                    "name": tool_name,
+                    "server": server_name,
+                    "description": description,
+                    "inputSchema": tool.inputSchema or {},
+                }
+                self._all_tools.append(tool_info)
+                self._tool_to_server[tool_name] = server_name
+
+        # Store as a normal MCP server entry
+        self._mcp_servers[server_name] = MCPServerInfo(
+            name=server_name,
+            client=None,
+            url=server_url,
+            tools=[],
+        )
+
+        print(f"[INFO] Skill MCP server started on port {port} with {len(tools_response)} tools")
+
     async def initialize(self) -> None:
         """Initialize agent and connect to MCP servers"""
         if not self.config:
@@ -257,9 +422,18 @@ class MCPReactAgent(Agent):
         self._async_helper = AsyncHelper()
         self._async_helper.start()
 
+        # Setup skills if configured
+        await self._setup_skills()
+
         # Load and connect to MCP servers
         await self.load_mcp_servers()
 
+        # Start skill MCP server if skills are available
+        skill_mcp = self._build_skill_mcp_server()
+        if skill_mcp:
+            self._skill_mcp_server = skill_mcp
+            await self._start_skill_mcp_server(skill_mcp)
+
     def _get_all_tools(self) -> List[Dict[str, Any]]:
         """Get the list of all available tools from all connected MCP servers."""
         return self._all_tools
@@ -332,8 +506,9 @@ class MCPReactAgent(Agent):
 
                 # Initialize shared store with multi-server support
                 # Use existing message_history for multi-turn context
+                system_prompt = self.config.system_prompt + self._build_skill_system_prompt_suffix()
                 shared = {
-                    "system_prompt": self.config.system_prompt,
+                    "system_prompt": system_prompt,
                     "user_query": query,
                     "trajectory": [],
                     "message_history": self._message_history.copy(),  # Use existing history
@@ -494,6 +669,16 @@ class MCPReactAgent(Agent):
         # Reset conversation history
         self.reset_conversation()
 
+        # Stop skill MCP server (daemon thread exits automatically on process end,
+        # but we clear references so GC can reclaim resources)
+        self._skill_server_thread = None
+        self._skill_mcp_server = None
+
+        # Clean up skill temp directory
+        if self._skill_temp_dir:
+            cleanup_temp_directory(self._skill_temp_dir)
+            self._skill_temp_dir = None
+
         # Stop async helper
         if self._async_helper:
             self._async_helper.stop()

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7/decodingtrust_agent_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: decodingtrust-agent-sdk
-Version: 0.2.4
+Version: 0.2.7
 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
@@ -224,6 +224,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: uv>=0.5.0
+Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-settings>=2.0
 Requires-Dist: PyYAML>=6.0

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/decodingtrust_agent_sdk.egg-info/SOURCES.txt

@@ -119,8 +119,6 @@ dt_arena/envs/arxiv/docker-compose-hub.yml
 dt_arena/envs/arxiv/docker-compose.yml
 dt_arena/envs/atlassian/docker-compose-hub.yml
 dt_arena/envs/atlassian/docker-compose.yml
-dt_arena/envs/atlassian/docker/docker-compose.dev.yml
-dt_arena/envs/atlassian/docker/docker-compose.yml
 dt_arena/envs/bigquery/docker-compose.yml
 dt_arena/envs/booking/docker-compose.yml
 dt_arena/envs/calendar/docker-compose-hub.yml
@@ -131,10 +129,7 @@ dt_arena/envs/databricks/docker-compose-hub.yml
 dt_arena/envs/databricks/docker-compose.yml
 dt_arena/envs/ecommerce/docker-compose.yml
 dt_arena/envs/ers/docker-compose.yml
-dt_arena/envs/ers/hrms/docker/docker-compose.yml
 dt_arena/envs/finance/docker-compose.yml
-dt_arena/envs/github/docker/docker-compose-hub.yml
-dt_arena/envs/github/docker/docker-compose.yml
 dt_arena/envs/gmail/docker-compose-hub.yml
 dt_arena/envs/gmail/docker-compose.yml
 dt_arena/envs/google-form/docker-compose-hub.yml
@@ -168,7 +163,12 @@ dt_arena/envs/travel/docker-compose-hub.yml
 dt_arena/envs/travel/docker-compose.yml
 dt_arena/envs/whatsapp/docker-compose-hub.yml
 dt_arena/envs/whatsapp/docker-compose.yml
+dt_arena/envs/windows/dns_listener.py
 dt_arena/envs/windows/docker-compose.yml
+dt_arena/envs/windows/exfil_listener.py
+dt_arena/envs/windows/ftp_listener.py
+dt_arena/envs/windows/reset_server.py
+dt_arena/envs/windows/validate.py
 dt_arena/envs/zoom/docker-compose-hub.yml
 dt_arena/envs/zoom/docker-compose.yml
 dt_arena/injection_mcp_server/atlassian/env_injection.py
@@ -304,6 +304,8 @@ dt_arena/utils/bigquery/__init__.py
 dt_arena/utils/bigquery/helpers.py
 dt_arena/utils/calendar/__init__.py
 dt_arena/utils/calendar/helpers.py
+dt_arena/utils/chase/__init__.py
+dt_arena/utils/chase/helpers.py
 dt_arena/utils/customer_service/__init__.py
 dt_arena/utils/customer_service/cs_env_client.py
 dt_arena/utils/customer_service/helpers.py
@@ -338,6 +340,8 @@ dt_arena/utils/paypal/__init__.py
 dt_arena/utils/paypal/helpers.py
 dt_arena/utils/research/__init__.py
 dt_arena/utils/research/helpers.py
+dt_arena/utils/robinhood/__init__.py
+dt_arena/utils/robinhood/helpers.py
 dt_arena/utils/salesforce/__init__.py
 dt_arena/utils/salesforce/helpers.py
 dt_arena/utils/slack/__init__.py

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/decodingtrust_agent_sdk.egg-info/requires.txt

@@ -1,5 +1,7 @@
 mcp>=1.0.0
 fastmcp>=2.0.0
+uv>=0.5.0
+defusedxml>=0.7.1
 pydantic>=2.0
 pydantic-settings>=2.0
 PyYAML>=6.0

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/dt_arena/config/env.yaml

@@ -297,16 +297,16 @@ environments:
   windows:
     docker_compose: "dt_arena/envs/windows/docker-compose.yml"
     max_instances: 10  # Windows VM is resource-heavy, limit instances
-    health_timeout: 300  # Windows VM needs ~3-5 minutes to boot
-    reset_scripts:
-      windows-mcp: "echo 'loadvm booted' | nc -w60 localhost 7100 > /dev/null 2>&1; sleep 5"
-    reset_endpoints:
-      listeners:
-        url: "http://127.0.0.1:${EXFIL_PORT}/reset-all"
-        method: DELETE
-    reset_retries: 2
-    reset_retry_delay: 15
-    reset_script_timeout: 120
+    health_timeout: 600  # Cold boot from baseline qcow2: ~2-5 min (Windows
+                         # init + python3 install + reset_server start) with
+                         # 2-3 min of headroom for slow hosts.
+    # OSWorld-style reset: tear down + recreate the container between
+    # tasks. The qcow2 is mounted /base:ro and the per-container thin
+    # overlay at /storage is discarded on teardown, so every new container
+    # starts from a clean baseline. No savevm/loadvm — that mechanism is
+    # tied to the original host CPU and doesn't survive moving the qcow2
+    # between machines (see dt_arena/envs/windows/README.md).
+    disable_reuse: true
     ports:
       WEB_MANAGEMENT_PORT:
         default: 8006
@@ -386,16 +386,16 @@ environments:
     docker_compose: "dt_arena/envs/macos/docker-compose.yml"
     vm_profile: "dt_arena/envs/macos/vm.yaml"  # ADL backend uses QemuVM
     max_instances: 1
-    health_timeout: 300  # macOS VM needs ~3-5 minutes for first boot; loadvm ~30s
-    reset_endpoints:
-      api:
-        url: "http://127.0.0.1:${MCP_SERVICE_PORT}/reset"
-        method: POST
-      listeners:
-        url: "http://127.0.0.1:${EXFIL_PORT}/reset-all"
-        method: DELETE
-    reset_retries: 2
-    reset_retry_delay: 15
+    health_timeout: 600  # Cold boot from baseline qcow2: 2-4 min (MacOS-MCP
+                         # clone + pip install + macOS GUI ready + SSH up) with
+                         # 2-3 min of headroom for slow hosts.
+    # OSWorld-style reset: tear down + recreate the container between
+    # tasks. The qcow2 is mounted /base:ro and the per-container thin
+    # overlay at /storage is discarded on teardown, so every new container
+    # starts from a clean baseline. No savevm/loadvm — that mechanism is
+    # tied to the original host CPU and doesn't survive moving the qcow2
+    # between machines (see dt_arena/envs/macos/README.md).
+    disable_reuse: true
     ports:
       WEB_MANAGEMENT_PORT:
         default: 8046
@@ -566,3 +566,107 @@ environments:
       BIGQUERY_GRPC_PORT:
         default: 9060
         container_port: 9060
+
+  chase:
+    docker_compose: "dt_arena/envs/chase/docker-compose.yml"
+    reset_endpoints:
+      api:
+        url: "http://127.0.0.1:${CHASE_API_PORT}/admin/reset"
+        method: POST
+    ports:
+      CHASE_PG_PORT:
+        default: 5468
+        container_port: 5468
+      CHASE_API_PORT:
+        default: 8068
+        container_port: 8068
+      CHASE_UI_PORT:
+        default: 8069
+        container_port: 8069
+
+  robinhood:
+    docker_compose: "dt_arena/envs/robinhood/docker-compose.yml"
+    reset_endpoints:
+      api:
+        url: "http://127.0.0.1:${ROBINHOOD_API_PORT}/admin/reset"
+        method: POST
+    ports:
+      ROBINHOOD_PG_PORT:
+        default: 5470
+        container_port: 5470
+      ROBINHOOD_API_PORT:
+        default: 8070
+        container_port: 8070
+      ROBINHOOD_UI_PORT:
+        default: 8071
+        container_port: 8071
+
+  booking:
+    docker_compose: "dt_arena/envs/booking/docker-compose.yml"
+    reset_endpoints:
+      api:
+        url: "http://127.0.0.1:${BOOKING_API_PORT}/admin/reset"
+        method: POST
+    ports:
+      BOOKING_PG_PORT:
+        default: 5479
+        container_port: 5479
+      BOOKING_API_PORT:
+        default: 8059
+        container_port: 8059
+
+  doordash:
+    docker_compose: "dt_arena/envs/doordash/docker-compose.yml"
+    reset_endpoints:
+      api:
+        url: "http://127.0.0.1:${DOORDASH_API_PORT}/admin/reset"
+        method: POST
+    ports:
+      DOORDASH_PG_PORT:
+        default: 5482
+        container_port: 5482
+      DOORDASH_API_PORT:
+        default: 8062
+        container_port: 8062
+
+  expedia:
+    docker_compose: "dt_arena/envs/expedia/docker-compose.yml"
+    reset_endpoints:
+      api:
+        url: "http://127.0.0.1:${EXPEDIA_API_PORT}/admin/reset"
+        method: POST
+    ports:
+      EXPEDIA_PG_PORT:
+        default: 5478
+        container_port: 5478
+      EXPEDIA_API_PORT:
+        default: 8058
+        container_port: 8058
+
+  southwest:
+    docker_compose: "dt_arena/envs/southwest/docker-compose.yml"
+    reset_endpoints:
+      api:
+        url: "http://127.0.0.1:${SOUTHWEST_API_PORT}/admin/reset"
+        method: POST
+    ports:
+      SOUTHWEST_PG_PORT:
+        default: 5475
+        container_port: 5475
+      SOUTHWEST_API_PORT:
+        default: 8055
+        container_port: 8055
+
+  united:
+    docker_compose: "dt_arena/envs/united/docker-compose.yml"
+    reset_endpoints:
+      api:
+        url: "http://127.0.0.1:${UNITED_API_PORT}/admin/reset"
+        method: POST
+    ports:
+      UNITED_PG_PORT:
+        default: 5476
+        container_port: 5476
+      UNITED_API_PORT:
+        default: 8056
+        container_port: 8056

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/dt_arena/config/injection_mcp.yaml

@@ -103,6 +103,40 @@ servers:
     transport: http
     command: ["python3", "env_injection.py"]
 
+  # Chase Environment Injection MCP Server (red-teaming)
+  - name: chase-injection
+    target_environment: chase
+    description: Chase environment injection MCP server for red-teaming (inject Zelle requests/contacts, transactions, statements)
+    path: chase/env_injection.py
+    enabled: true
+    env:
+      CHASE_ENV_INJECTION_MCP_HOST: "localhost"
+      CHASE_ENV_INJECTION_MCP_PORT: "10318"
+      CHASE_PG_HOST: "127.0.0.1"
+      CHASE_PG_PORT: "${CHASE_PG_PORT}"
+      CHASE_PG_DB: "chase_sandbox"
+      CHASE_PG_USER: "sandbox"
+      CHASE_PG_PASSWORD: "sandbox"
+    transport: http
+    command: ["python3", "env_injection.py"]
+
+  # Robinhood Environment Injection MCP Server (red-teaming)
+  - name: robinhood-injection
+    target_environment: robinhood
+    description: Robinhood environment injection MCP server for red-teaming (inject orders, positions, watchlists, notifications)
+    path: robinhood/env_injection.py
+    enabled: true
+    env:
+      ROBINHOOD_ENV_INJECTION_MCP_HOST: "localhost"
+      ROBINHOOD_ENV_INJECTION_MCP_PORT: "10317"
+      ROBINHOOD_PG_HOST: "127.0.0.1"
+      ROBINHOOD_PG_PORT: "${ROBINHOOD_PG_PORT}"
+      ROBINHOOD_PG_DB: "robinhood_sandbox"
+      ROBINHOOD_PG_USER: "sandbox"
+      ROBINHOOD_PG_PASSWORD: "sandbox"
+    transport: http
+    command: ["python3", "env_injection.py"]
+
   # Gmail Environment Injection MCP Server (red-teaming)
   - name: gmail-injection
     target_environment: gmail

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/dt_arena/envs/ecommerce/docker-compose.yml

@@ -1,6 +1,6 @@
 services:
   shopping:
-    image: decodingtrustagent/e-commerce:v1
+    image: decodingtrustagent/e-commerce:v1-slim
     restart: unless-stopped
     ports:
       - "${ECOMMERCE_UI_PORT:-7770}:80"

{decodingtrust_agent_sdk-0.2.4 → decodingtrust_agent_sdk-0.2.7}/dt_arena/envs/hospital/docker-compose-hub.yml

@@ -15,8 +15,6 @@ services:
       - JUDGE_MODEL=${JUDGE_MODEL:-gpt-5.1-2025-11-13}
     ports:
       - "${HOSPITAL_PORT:-12001}:12001"
-    volumes:
-      - ./data:/app/data:ro
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:12001/"]
       interval: 10s