eval-protocol 0.2.46.dev3__tar.gz → 0.2.48__tar.gz

{eval_protocol-0.2.46.dev3/eval_protocol.egg-info → eval_protocol-0.2.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.46.dev3
+Version: 0.2.48
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/__init__.py

@@ -35,6 +35,9 @@ from .pytest.parameterize import DefaultParameterIdGenerator
 from .log_utils.elasticsearch_direct_http_handler import ElasticsearchDirectHttpHandler
 from .log_utils.rollout_id_filter import RolloutIdFilter
 from .log_utils.util import setup_rollout_logging_for_elasticsearch_handler
+from .log_utils.fireworks_tracing_http_handler import FireworksTracingHttpHandler
+from .log_utils.elasticsearch_client import ElasticsearchConfig
+
 
 from .types.remote_rollout_processor import (
     InitRequest,
@@ -70,16 +73,10 @@ try:
 except ImportError:
     WeaveAdapter = None
 
-try:
-    from .proxy import create_app, AuthProvider
-except ImportError:
-    create_app = None
-    AuthProvider = None
-
-
 warnings.filterwarnings("default", category=DeprecationWarning, module="eval_protocol")
 
 __all__ = [
+    "ElasticsearchConfig",
     "ElasticsearchDirectHttpHandler",
     "RolloutIdFilter",
     "setup_rollout_logging_for_elasticsearch_handler",
@@ -102,6 +99,7 @@ __all__ = [
     "BraintrustAdapter",
     "create_braintrust_adapter",
     "LangSmithAdapter",
+    "FireworksTracingHttpHandler",
     # Core interfaces
     "Message",
     "MetricResult",
@@ -137,9 +135,6 @@ __all__ = [
     "RolloutMetadata",
     "StatusResponse",
     "create_langfuse_config_tags",
-    # Proxy
-    "create_app",
-    "AuthProvider",
 ]
 
 from . import _version

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-10-10T01:45:32-0700",
+ "date": "2025-10-10T13:52:05-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "1757548441eb93afd5dc0428b0218637787cdd80",
- "version": "0.2.46-dev3"
+ "full-revisionid": "8e5d3a5f347613eafe384a726d3598cf58719822",
+ "version": "0.2.48"
 }
 '''  # END VERSION_JSON
 

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/adapters/fireworks_tracing.py

@@ -7,9 +7,9 @@ to pull data from Langfuse deployments with simplified retry logic handling.
 from __future__ import annotations
 import logging
 import requests
+import time
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Protocol
-import os
 
 from eval_protocol.models import EvaluationRow, InputMetadata, ExecutionMetadata, Message
 from .base import BaseAdapter
@@ -343,17 +343,15 @@ class FireworksTracingAdapter(BaseAdapter):
         # Remove None values
         params = {k: v for k, v in params.items() if v is not None}
 
-        # Make request to proxy (using pointwise for efficiency)
+        # Make request to proxy
         if self.project_id:
-            url = f"{self.base_url}/v1/project_id/{self.project_id}/traces/pointwise"
+            url = f"{self.base_url}/v1/project_id/{self.project_id}/traces"
         else:
-            url = f"{self.base_url}/v1/traces/pointwise"
-
-        headers = {"Authorization": f"Bearer {os.environ.get('FIREWORKS_API_KEY')}"}
+            url = f"{self.base_url}/v1/traces"
 
         result = None
         try:
-            response = requests.get(url, params=params, timeout=self.timeout, headers=headers)
+            response = requests.get(url, params=params, timeout=self.timeout)
             response.raise_for_status()
             result = response.json()
         except requests.exceptions.HTTPError as e:
@@ -367,7 +365,7 @@ class FireworksTracingAdapter(BaseAdapter):
                 except Exception:  # In case e.response.json() fails
                     error_msg = f"Proxy error: {e.response.text}"
 
-            logger.error("Failed to fetch traces from proxy (HTTP %s): %s", e.response.status_code, error_msg)
+            logger.error("Failed to fetch traces from proxy: %s", error_msg)
             return eval_rows
         except requests.exceptions.RequestException as e:
             # Non-HTTP errors (network issues, timeouts, etc.)

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/adapters/openai_responses.py

@@ -169,7 +169,9 @@ class OpenAIResponsesAdapter(BaseAdapter):
                         raise NotImplementedError(f"Unsupported content type: {content_item.type}")
             elif item.type == "function_call_output":
                 # Collect tool call outputs to add before assistant message
-                tool_call_outputs.append(Message(role="tool", content=item.output, tool_call_id=item.call_id))
+                tool_call_outputs.append(
+                    Message(role="tool", content=self._coerce_tool_output(item.output), tool_call_id=item.call_id)
+                )
             elif item.type == "function_call":
                 tool_call = ChatCompletionMessageToolCall(
                     id=item.call_id, type="function", function=Function(name=item.name, arguments=item.arguments)
@@ -186,3 +188,29 @@ class OpenAIResponsesAdapter(BaseAdapter):
             messages.append(Message(role="assistant", tool_calls=current_tool_calls))
 
         return reversed(messages)
+
+    def _coerce_tool_output(self, output: Any) -> str:
+        """Coerce OpenAI Responses tool output into a string for Message.content.
+
+        The Responses API may return structured content lists. For our purposes,
+        we stringify non-string outputs to satisfy the Message.content type.
+        """
+        if isinstance(output, str):
+            return output
+        try:
+            # Attempt to join list of objects with any 'text' fields
+            if isinstance(output, list):
+                parts: list[str] = []
+                for part in output:
+                    text = None
+                    if isinstance(part, dict):
+                        text = part.get("text")
+                    if text:
+                        parts.append(str(text))
+                    else:
+                        parts.append(str(part))
+                return "\n".join(parts)
+            # Fallback to string conversion
+            return str(output)
+        except Exception:
+            return str(output)

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/cli.py

@@ -301,6 +301,12 @@ def parse_args(args=None):
     logs_parser = subparsers.add_parser("logs", help="Serve logs with file watching and real-time updates")
     logs_parser.add_argument("--port", type=int, default=8000, help="Port to bind to (default: 8000)")
     logs_parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+    logs_parser.add_argument("--disable-elasticsearch-setup", action="store_true", help="Disable Elasticsearch setup")
+    logs_parser.add_argument(
+        "--use-env-elasticsearch-confi",
+        action="store_true",
+        help="Use env vars for Elasticsearch config (requires ELASTICSEARCH_URL, ELASTICSEARCH_API_KEY, ELASTICSEARCH_INDEX_NAME)",
+    )
 
     # Upload command
     upload_parser = subparsers.add_parser(

eval_protocol-0.2.48/eval_protocol/cli_commands/logs.py

@@ -0,0 +1,54 @@
+"""
+CLI command for serving logs with file watching and real-time updates.
+"""
+
+import sys
+from pathlib import Path
+
+from ..utils.logs_server import serve_logs
+
+
+def logs_command(args):
+    """Serve logs with file watching and real-time updates"""
+
+    port = args.port
+    print("🚀 Starting Eval Protocol Logs Server")
+    print(f"🌐 URL: http://localhost:{port}")
+    print(f"🔌 WebSocket: ws://localhost:{port}/ws")
+    print(f"👀 Watching paths: {['current directory']}")
+    print(f"🔍 Debug mode: {args.debug}")
+    print("Press Ctrl+C to stop the server")
+    print("-" * 50)
+
+    # Setup Elasticsearch based on flags
+    elasticsearch_config = None
+    try:
+        if getattr(args, "use_env_elasticsearch_config", False):
+            # Use environment variables for configuration
+            print("⚙️ Using environment variables for Elasticsearch config")
+            from eval_protocol.pytest.remote_rollout_processor import (
+                create_elasticsearch_config_from_env,
+            )
+
+            elasticsearch_config = create_elasticsearch_config_from_env()
+        elif not getattr(args, "disable_elasticsearch_setup", False):
+            # Default behavior: start or connect to local Elasticsearch via Docker helper
+            from eval_protocol.pytest.elasticsearch_setup import ElasticsearchSetup
+
+            print("🧰 Auto-configuring local Elasticsearch (Docker)")
+            elasticsearch_config = ElasticsearchSetup().setup_elasticsearch()
+        else:
+            print("🚫 Elasticsearch setup disabled; running without Elasticsearch integration")
+    except Exception as e:
+        print(f"❌ Failed to configure Elasticsearch: {e}")
+        return 1
+
+    try:
+        serve_logs(port=args.port, elasticsearch_config=elasticsearch_config, debug=args.debug)
+        return 0
+    except KeyboardInterrupt:
+        print("\n🛑 Server stopped by user")
+        return 0
+    except Exception as e:
+        print(f"❌ Error starting server: {e}")
+        return 1

eval_protocol-0.2.48/eval_protocol/log_utils/fireworks_tracing_http_handler.py

@@ -0,0 +1,63 @@
+import logging
+import os
+import threading
+from datetime import datetime, timezone
+from typing import Optional, Any, Dict, List, cast
+
+import requests
+
+
+class FireworksTracingHttpHandler(logging.Handler):
+    """Logging handler that posts structured logs to tracing.fireworks gateway /logs endpoint."""
+
+    def __init__(self, gateway_base_url: Optional[str] = None, rollout_id_env: str = "EP_ROLLOUT_ID") -> None:
+        super().__init__()
+        self.gateway_base_url = gateway_base_url or os.getenv("FW_TRACING_GATEWAY_BASE_URL")
+        self.rollout_id_env = rollout_id_env
+        self._session = requests.Session()
+        self._lock = threading.Lock()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            if not self.gateway_base_url:
+                return
+            rollout_id = self._get_rollout_id(record)
+            if not rollout_id:
+                return
+            payload = self._build_payload(record, rollout_id)
+            url = f"{self.gateway_base_url.rstrip('/')}/logs"
+            with self._lock:
+                self._session.post(url, json=payload, timeout=5)
+        except Exception:
+            # Avoid raising exceptions from logging
+            self.handleError(record)
+
+    def _get_rollout_id(self, record: logging.LogRecord) -> Optional[str]:
+        if hasattr(record, "rollout_id") and cast(Any, getattr(record, "rollout_id")) is not None:
+            return str(cast(Any, getattr(record, "rollout_id")))
+        return os.getenv(self.rollout_id_env)
+
+    def _build_payload(self, record: logging.LogRecord, rollout_id: str) -> Dict[str, Any]:
+        timestamp = datetime.fromtimestamp(record.created, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+        message = record.getMessage()
+        tags: List[str] = [f"rollout_id:{rollout_id}"]
+        # Optional additional tags
+        if hasattr(record, "experiment_id") and cast(Any, getattr(record, "experiment_id")):
+            tags.append(f"experiment_id:{cast(Any, getattr(record, 'experiment_id'))}")
+        if hasattr(record, "run_id") and cast(Any, getattr(record, "run_id")):
+            tags.append(f"run_id:{cast(Any, getattr(record, 'run_id'))}")
+        program = cast(Optional[str], getattr(record, "program", None)) or "eval_protocol"
+        status_val = cast(Any, getattr(record, "status", None))
+        status = status_val if isinstance(status_val, str) else None
+        return {
+            "program": program,
+            "status": status,
+            "message": message,
+            "tags": tags,
+            "metadata": cast(Any, getattr(record, "metadata", None)),
+            "extras": {
+                "logger_name": record.name,
+                "level": record.levelname,
+                "timestamp": timestamp,
+            },
+        }

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/pytest/evaluation_test.py

@@ -62,7 +62,8 @@ from eval_protocol.pytest.utils import (
     run_tasks_with_eval_progress,
     run_tasks_with_run_progress,
 )
-from eval_protocol.utils.show_results_url import store_local_ui_results_url
+from eval_protocol.utils.show_results_url import store_local_ui_results_url, generate_invocation_filter_url
+from eval_protocol.utils.browser_utils import is_logs_server_running, open_browser_tab
 
 from ..common_utils import load_jsonl
 
@@ -80,6 +81,7 @@ def evaluation_test(
     rollout_processor_kwargs: RolloutProcessorInputParam | None = None,
     aggregation_method: AggregationMethod = "mean",
     passed_threshold: EvaluationThreshold | float | EvaluationThresholdDict | None = None,
+    disable_browser_open: bool = False,
     num_runs: int = 1,
     filtered_row_ids: Sequence[str] | None = None,
     max_dataset_rows: int | None = None,
@@ -246,10 +248,29 @@ def evaluation_test(
             else:
                 invocation_id = generate_id()
 
+            # Track whether we've opened browser for this invocation
+            browser_opened_for_invocation = False
+
             async def wrapper_body(**kwargs: Unpack[ParameterizedTestKwargs]) -> None:
+                nonlocal browser_opened_for_invocation
+
                 # Store URL for viewing results (after all postprocessing is complete)
                 store_local_ui_results_url(invocation_id)
 
+                # Auto-open browser if server is running and not disabled (only once per invocation)
+                if (
+                    not browser_opened_for_invocation
+                    and not disable_browser_open
+                    and os.environ.get("EP_DISABLE_AUTO_BROWSER") is None
+                ):
+                    is_running, port = is_logs_server_running()
+                    if is_running:
+                        # Generate URL for table view with invocation filter
+                        base_url = f"http://localhost:{port}" if port else "http://localhost:8000"
+                        table_url = generate_invocation_filter_url(invocation_id, f"{base_url}/table")
+                        open_browser_tab(table_url)
+                        browser_opened_for_invocation = True
+
                 eval_metadata = None
 
                 all_results: list[list[EvaluationRow]] = [[] for _ in range(num_runs)]

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/pytest/remote_rollout_processor.py

@@ -26,6 +26,25 @@ import os
 logger = logging.getLogger(__name__)
 
 
+def create_elasticsearch_config_from_env() -> ElasticsearchConfig:
+    """Setup Elasticsearch config from environment variables."""
+    url = os.getenv("ELASTICSEARCH_URL")
+    api_key = os.getenv("ELASTICSEARCH_API_KEY")
+    index_name = os.getenv("ELASTICSEARCH_INDEX_NAME")
+
+    if url is None:
+        raise ValueError("ELASTICSEARCH_URL must be set")
+    if api_key is None:
+        raise ValueError("ELASTICSEARCH_API_KEY must be set")
+    if index_name is None:
+        raise ValueError("ELASTICSEARCH_INDEX_NAME must be set")
+    return ElasticsearchConfig(
+        url=url,
+        api_key=api_key,
+        index_name=index_name,
+    )
+
+
 def _build_fireworks_tracing_url(
     base_url: str, metadata: RolloutMetadata, completion_params_base_url: Optional[str] = None
 ) -> str:
@@ -93,7 +112,7 @@ class RemoteRolloutProcessor(RolloutProcessor):
         poll_interval: float = 1.0,
         timeout_seconds: float = 120.0,
         output_data_loader: Optional[Callable[[DataLoaderConfig], DynamicDataLoader]] = None,
-        disable_elastic_search: bool = False,
+        disable_elastic_search_setup: bool = False,
         elastic_search_config: Optional[ElasticsearchConfig] = None,
     ):
         # Prefer constructor-provided configuration. These can be overridden via
@@ -108,11 +127,11 @@ class RemoteRolloutProcessor(RolloutProcessor):
         self._poll_interval = poll_interval
         self._timeout_seconds = timeout_seconds
         self._output_data_loader = output_data_loader or _default_output_data_loader
-        self._disable_elastic_search = disable_elastic_search
+        self._disable_elastic_search_setup = disable_elastic_search_setup
         self._elastic_search_config = elastic_search_config
 
     def setup(self) -> None:
-        if self._disable_elastic_search:
+        if self._disable_elastic_search_setup:
             logger.info("Elasticsearch is disabled, skipping setup")
             return
         logger.info("Setting up Elasticsearch")

eval_protocol-0.2.48/eval_protocol/utils/browser_utils.py

@@ -0,0 +1,114 @@
+"""
+Browser utilities for auto-opening evaluation results in the local UI.
+"""
+
+import json
+import os
+import threading
+import time
+import webbrowser
+from pathlib import Path
+from typing import Tuple, Optional
+
+try:
+    import psutil
+
+    PSUTIL_AVAILABLE = True
+except ImportError:
+    PSUTIL_AVAILABLE = False
+
+
+def _get_pid_file_path() -> Path:
+    """Get the path to the logs server PID file."""
+    from eval_protocol.directory_utils import find_eval_protocol_dir
+
+    return Path(find_eval_protocol_dir()) / "logs_server.pid"
+
+
+def write_pid_file(pid: int, port: int) -> None:
+    """
+    Write the server PID and port to a file for external processes to check.
+
+    Args:
+        pid: The process ID of the logs server
+        port: The port the server is running on
+    """
+    try:
+        pid_file = _get_pid_file_path()
+
+        data = {"pid": pid, "port": port}
+
+        with open(pid_file, "w") as f:
+            json.dump(data, f)
+
+        # Use print instead of logger to avoid circular imports
+        print(f"Wrote PID file: {pid_file} with PID {pid} and port {port}")
+    except Exception as e:
+        print(f"Warning: Failed to write PID file: {e}")
+
+
+def is_logs_server_running() -> Tuple[bool, Optional[int]]:
+    """
+    Check if the logs server is running by reading the PID file and verifying the process.
+
+    Returns:
+        Tuple of (is_running, port) where:
+        - is_running: True if server is running, False otherwise
+        - port: The port the server is running on, or None if not running
+    """
+    if not PSUTIL_AVAILABLE:
+        return False, None
+
+    pid_file = _get_pid_file_path()
+    if not pid_file.exists():
+        return False, None
+
+    try:
+        with open(pid_file, "r") as f:
+            data = json.load(f)
+            pid = data.get("pid")
+            port = data.get("port")
+    except (json.JSONDecodeError, KeyError, FileNotFoundError):
+        return False, None
+
+    if pid is None:
+        return False, None
+
+    try:
+        # Check if the process is still running
+        process = psutil.Process(pid)
+        if not process.is_running():
+            return False, None
+
+        # Optionally verify it's listening on the expected port
+        if port is not None:
+            try:
+                connections = process.net_connections()
+                for conn in connections:
+                    if conn.laddr.port == port and conn.status == "LISTEN":
+                        return True, port
+            except (psutil.AccessDenied, psutil.NoSuchProcess):
+                # If we can't check connections, assume it's running if process exists
+                pass
+
+        return True, port
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return False, None
+
+
+def open_browser_tab(url: str, delay: float = 0.5) -> None:
+    """
+    Open a URL in a new browser tab with an optional delay.
+
+    Args:
+        url: The URL to open
+        delay: Delay in seconds before opening browser (default: 0.5)
+    """
+
+    def _open():
+        time.sleep(delay)  # Give the server time to start
+        webbrowser.open_new_tab(url)
+
+    thread = threading.Thread(target=_open)
+    thread.daemon = True
+    thread.start()

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol/utils/logs_server.py

@@ -6,6 +6,7 @@ import threading
 import time
 from datetime import datetime
 from contextlib import asynccontextmanager
+from pathlib import Path
 from queue import Queue
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
@@ -23,6 +24,7 @@ from eval_protocol.utils.vite_server import ViteServer
 from eval_protocol.log_utils.elasticsearch_client import ElasticsearchClient
 from eval_protocol.types.remote_rollout_processor import ElasticsearchConfig
 from eval_protocol.utils.logs_models import LogEntry, LogsResponse
+from eval_protocol.utils.browser_utils import write_pid_file
 
 if TYPE_CHECKING:
     from eval_protocol.models import EvaluationRow
@@ -378,7 +380,7 @@ class LogsServer(ViteServer):
         event_bus.subscribe(self._handle_event)
         logger.debug("[LOGS_SERVER_INIT] Successfully subscribed to event bus")
 
-        logger.info(f"[LOGS_SERVER_INIT] LogsServer initialized on {host}:{port}")
+        logger.info(f"[LOGS_SERVER_INIT] LogsServer initialized on {self.host}:{self.port}")
 
     def _setup_websocket_routes(self):
         """Set up WebSocket routes for real-time communication."""
@@ -541,6 +543,12 @@ class LogsServer(ViteServer):
             )
 
             server = uvicorn.Server(config)
+
+            # Write PID file after server is configured but before serving
+            logger.debug(f"[LOGS_SERVER_RUN_ASYNC] Writing PID file for port {self.port}")
+            write_pid_file(os.getpid(), self.port)
+            logger.debug(f"[LOGS_SERVER_RUN_ASYNC] Successfully wrote PID file for port {self.port}")
+
             await server.serve()
 
         except KeyboardInterrupt:

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48/eval_protocol.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.46.dev3
+Version: 0.2.48
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

{eval_protocol-0.2.46.dev3 → eval_protocol-0.2.48}/eval_protocol.egg-info/SOURCES.txt

@@ -40,9 +40,9 @@ eval_protocol.egg-info/requires.txt
 eval_protocol.egg-info/top_level.txt
 eval_protocol/../vite-app/dist/index.html
 eval_protocol/../vite-app/dist/assets/favicon-BkAAWQga.png
-eval_protocol/../vite-app/dist/assets/index-C81y9r9l.js
-eval_protocol/../vite-app/dist/assets/index-C81y9r9l.js.map
-eval_protocol/../vite-app/dist/assets/index-DpYZaoAr.css
+eval_protocol/../vite-app/dist/assets/index-34WaHH5W.css
+eval_protocol/../vite-app/dist/assets/index-DOPsfOMT.js
+eval_protocol/../vite-app/dist/assets/index-DOPsfOMT.js.map
 eval_protocol/../vite-app/dist/assets/logo-light-BprIBJQW.png
 eval_protocol/adapters/__init__.py
 eval_protocol/adapters/base.py
@@ -124,6 +124,7 @@ eval_protocol/log_utils/__init__.py
 eval_protocol/log_utils/elasticsearch_client.py
 eval_protocol/log_utils/elasticsearch_direct_http_handler.py
 eval_protocol/log_utils/elasticsearch_index_manager.py
+eval_protocol/log_utils/fireworks_tracing_http_handler.py
 eval_protocol/log_utils/rollout_id_filter.py
 eval_protocol/log_utils/util.py
 eval_protocol/mcp/__init__.py
@@ -165,15 +166,6 @@ eval_protocol/mcp_servers/tau2/tests/test_tau2_e2e.py
 eval_protocol/mcp_servers/tau2/tests/system_prompts/airline_agent_system_prompt.md
 eval_protocol/mcp_servers/tau2/tests/system_prompts/mock_agent_system_prompt.md
 eval_protocol/mcp_servers/tau2/tests/system_prompts/retail_agent_system_prompt.md
-eval_protocol/proxy/__init__.py
-eval_protocol/proxy/proxy_core/__init__.py
-eval_protocol/proxy/proxy_core/app.py
-eval_protocol/proxy/proxy_core/auth.py
-eval_protocol/proxy/proxy_core/langfuse.py
-eval_protocol/proxy/proxy_core/litellm.py
-eval_protocol/proxy/proxy_core/main.py
-eval_protocol/proxy/proxy_core/models.py
-eval_protocol/proxy/proxy_core/redis_utils.py
 eval_protocol/pytest/__init__.py
 eval_protocol/pytest/default_agent_rollout_processor.py
 eval_protocol/pytest/default_dataset_adapter.py
@@ -238,6 +230,7 @@ eval_protocol/types/types.py
 eval_protocol/utils/__init__.py
 eval_protocol/utils/batch_evaluation.py
 eval_protocol/utils/batch_transformation.py
+eval_protocol/utils/browser_utils.py
 eval_protocol/utils/check_server_status.py
 eval_protocol/utils/dataset_helpers.py
 eval_protocol/utils/logs_models.py