Merge branch 'dev' into main

Author: Mirrowel

DOCUMENTATION.md

@@ -3,34 +3,60 @@
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, Optional
 import logging
 
-LOGS_DIR = Path(__file__).resolve().parent.parent.parent / "logs"
-DETAILED_LOGS_DIR = LOGS_DIR / "detailed_logs"
+from rotator_library.utils.resilient_io import (
+    safe_write_json,
+    safe_log_write,
+    safe_mkdir,
+)
+from rotator_library.utils.paths import get_logs_dir
+
+
+def _get_detailed_logs_dir() -> Path:
+    """Get the detailed logs directory, creating it if needed."""
+    logs_dir = get_logs_dir()
+    detailed_dir = logs_dir / "detailed_logs"
+    detailed_dir.mkdir(parents=True, exist_ok=True)
+    return detailed_dir
+
 
 class DetailedLogger:
     """
     Logs comprehensive details of each API transaction to a unique, timestamped directory.
+
+    Uses fire-and-forget logging - if disk writes fail, logs are dropped (not buffered)
+    to prevent memory issues, especially with streaming responses.
     """
+
     def __init__(self):
         """
         Initializes the logger for a single request, creating a unique directory to store all related log files.
         """
         self.start_time = time.time()
         self.request_id = str(uuid.uuid4())
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        self.log_dir = DETAILED_LOGS_DIR / f"{timestamp}_{self.request_id}"
-        self.log_dir.mkdir(parents=True, exist_ok=True)
+        self.log_dir = _get_detailed_logs_dir() / f"{timestamp}_{self.request_id}"
         self.streaming = False
+        self._dir_available = safe_mkdir(self.log_dir, logging)
 
     def _write_json(self, filename: str, data: Dict[str, Any]):
         """Helper to write data to a JSON file in the log directory."""
-        try:
-            with open(self.log_dir / filename, "w", encoding="utf-8") as f:
-                json.dump(data, f, indent=4, ensure_ascii=False)
-        except Exception as e:
-            logging.error(f"[{self.request_id}] Failed to write to {filename}: {e}")
+        if not self._dir_available:
+            # Try to create directory again in case it was recreated
+            self._dir_available = safe_mkdir(self.log_dir, logging)
+            if not self._dir_available:
+                return
+
+        safe_write_json(
+            self.log_dir / filename,
+            data,
+            logging,
+            atomic=False,
+            indent=4,
+            ensure_ascii=False,
+        )
 
     def log_request(self, headers: Dict[str, Any], body: Dict[str, Any]):
         """Logs the initial request details."""
@@ -39,23 +65,22 @@ def log_request(self, headers: Dict[str, Any], body: Dict[str, Any]):
             "request_id": self.request_id,
             "timestamp_utc": datetime.utcnow().isoformat(),
             "headers": dict(headers),
-            "body": body
+            "body": body,
         }
         self._write_json("request.json", request_data)
 
     def log_stream_chunk(self, chunk: Dict[str, Any]):
         """Logs an individual chunk from a streaming response to a JSON Lines file."""
-        try:
-            log_entry = {
-                "timestamp_utc": datetime.utcnow().isoformat(),
-                "chunk": chunk
-            }
-            with open(self.log_dir / "streaming_chunks.jsonl", "a", encoding="utf-8") as f:
-                f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
-        except Exception as e:
-            logging.error(f"[{self.request_id}] Failed to write stream chunk: {e}")
-
-    def log_final_response(self, status_code: int, headers: Optional[Dict[str, Any]], body: Dict[str, Any]):
+        if not self._dir_available:
+            return
+
+        log_entry = {"timestamp_utc": datetime.utcnow().isoformat(), "chunk": chunk}
+        content = json.dumps(log_entry, ensure_ascii=False) + "\n"
+        safe_log_write(self.log_dir / "streaming_chunks.jsonl", content, logging)
+
+    def log_final_response(
+        self, status_code: int, headers: Optional[Dict[str, Any]], body: Dict[str, Any]
+    ):
         """Logs the complete final response, either from a non-streaming call or after reassembling a stream."""
         end_time = time.time()
         duration_ms = (end_time - self.start_time) * 1000
@@ -66,7 +91,7 @@ def log_final_response(self, status_code: int, headers: Optional[Dict[str, Any]]
             "status_code": status_code,
             "duration_ms": round(duration_ms),
             "headers": dict(headers) if headers else None,
-            "body": body
+            "body": body,
         }
         self._write_json("final_response.json", response_data)
         self._log_metadata(response_data)
@@ -75,10 +100,10 @@ def _extract_reasoning(self, response_body: Dict[str, Any]) -> Optional[str]:
         """Recursively searches for and extracts 'reasoning' fields from the response body."""
         if not isinstance(response_body, dict):
             return None
-        
+
         if "reasoning" in response_body:
             return response_body["reasoning"]
-            
+
         if "choices" in response_body and response_body["choices"]:
             message = response_body["choices"][0].get("message", {})
             if "reasoning" in message:
@@ -93,8 +118,13 @@ def _log_metadata(self, response_data: Dict[str, Any]):
         usage = response_data.get("body", {}).get("usage") or {}
         model = response_data.get("body", {}).get("model", "N/A")
         finish_reason = "N/A"
-        if "choices" in response_data.get("body", {}) and response_data["body"]["choices"]:
-            finish_reason = response_data["body"]["choices"][0].get("finish_reason", "N/A")
+        if (
+            "choices" in response_data.get("body", {})
+            and response_data["body"]["choices"]
+        ):
+            finish_reason = response_data["body"]["choices"][0].get(
+                "finish_reason", "N/A"
+            )
 
         metadata = {
             "request_id": self.request_id,
@@ -110,12 +140,12 @@ def _log_metadata(self, response_data: Dict[str, Any]):
             },
             "finish_reason": finish_reason,
             "reasoning_found": False,
-            "reasoning_content": None
+            "reasoning_content": None,
         }
 
         reasoning = self._extract_reasoning(response_data.get("body", {}))
         if reasoning:
             metadata["reasoning_found"] = True
             metadata["reasoning_content"] = reasoning
-        
-        self._write_json("metadata.json", metadata)
+
+        self._write_json("metadata.json", metadata)

README.md

@@ -16,6 +16,20 @@
 console = Console()
 
 
+def _get_env_file() -> Path:
+    """
+    Get .env file path (lightweight - no heavy imports).
+
+    Returns:
+        Path to .env file - EXE directory if frozen, else current working directory
+    """
+    if getattr(sys, "frozen", False):
+        # Running as PyInstaller EXE - use EXE's directory
+        return Path(sys.executable).parent / ".env"
+    # Running as script - use current working directory
+    return Path.cwd() / ".env"
+
+
 def clear_screen():
     """
     Cross-platform terminal clear that works robustly on both
@@ -74,7 +88,7 @@ def update(self, **kwargs):
     @staticmethod
     def update_proxy_api_key(new_key: str):
         """Update PROXY_API_KEY in .env only"""
-        env_file = Path.cwd() / ".env"
+        env_file = _get_env_file()
         set_key(str(env_file), "PROXY_API_KEY", new_key)
         load_dotenv(dotenv_path=env_file, override=True)
 
@@ -85,7 +99,7 @@ class SettingsDetector:
     @staticmethod
     def _load_local_env() -> dict:
         """Load environment variables from local .env file only"""
-        env_file = Path.cwd() / ".env"
+        env_file = _get_env_file()
         env_dict = {}
         if not env_file.exists():
             return env_dict
@@ -107,7 +121,7 @@ def _load_local_env() -> dict:
 
     @staticmethod
     def get_all_settings() -> dict:
-        """Returns comprehensive settings overview"""
+        """Returns comprehensive settings overview (includes provider_settings which triggers heavy imports)"""
         return {
             "credentials": SettingsDetector.detect_credentials(),
             "custom_bases": SettingsDetector.detect_custom_api_bases(),
@@ -117,6 +131,17 @@ def get_all_settings() -> dict:
             "provider_settings": SettingsDetector.detect_provider_settings(),
         }
 
+    @staticmethod
+    def get_basic_settings() -> dict:
+        """Returns basic settings overview without provider_settings (avoids heavy imports)"""
+        return {
+            "credentials": SettingsDetector.detect_credentials(),
+            "custom_bases": SettingsDetector.detect_custom_api_bases(),
+            "model_definitions": SettingsDetector.detect_model_definitions(),
+            "concurrency_limits": SettingsDetector.detect_concurrency_limits(),
+            "model_filters": SettingsDetector.detect_model_filters(),
+        }
+
     @staticmethod
     def detect_credentials() -> dict:
         """Detect API keys and OAuth credentials"""
@@ -260,7 +285,7 @@ def __init__(self):
         self.console = Console()
         self.config = LauncherConfig()
         self.running = True
-        self.env_file = Path.cwd() / ".env"
+        self.env_file = _get_env_file()
         # Load .env file to ensure environment variables are available
         load_dotenv(dotenv_path=self.env_file, override=True)
 
@@ -277,8 +302,8 @@ def show_main_menu(self):
         """Display main menu and handle selection"""
         clear_screen()
 
-        # Detect all settings
-        settings = SettingsDetector.get_all_settings()
+        # Detect basic settings (excludes provider_settings to avoid heavy imports)
+        settings = SettingsDetector.get_basic_settings()
         credentials = settings["credentials"]
         custom_bases = settings["custom_bases"]
 
@@ -363,18 +388,17 @@ def show_main_menu(self):
         self.console.print("━" * 70)
         provider_count = len(credentials)
         custom_count = len(custom_bases)
-        provider_settings = settings.get("provider_settings", {})
+
+        self.console.print(f"   Providers:           {provider_count} configured")
+        self.console.print(f"   Custom Providers:    {custom_count} configured")
+        # Note: provider_settings detection is deferred to avoid heavy imports on startup
         has_advanced = bool(
             settings["model_definitions"]
             or settings["concurrency_limits"]
             or settings["model_filters"]
-            or provider_settings
         )
-
-        self.console.print(f"   Providers:           {provider_count} configured")
-        self.console.print(f"   Custom Providers:    {custom_count} configured")
         self.console.print(
-            f"   Advanced Settings:   {'Active (view in menu 4)' if has_advanced else 'None'}"
+            f"   Advanced Settings:   {'Active (view in menu 4)' if has_advanced else 'None (view menu 4 for details)'}"
         )
 
         # Show menu
@@ -418,7 +442,7 @@ def show_main_menu(self):
         elif choice == "4":
             self.show_provider_settings_menu()
         elif choice == "5":
-            load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+            load_dotenv(dotenv_path=_get_env_file(), override=True)
             self.config = LauncherConfig()  # Reload config
             self.console.print("\n[green]✅ Configuration reloaded![/green]")
         elif choice == "6":
@@ -659,13 +683,14 @@ def show_provider_settings_menu(self):
         """Display provider/advanced settings (read-only + launch tool)"""
         clear_screen()
 
-        settings = SettingsDetector.get_all_settings()
+        # Use basic settings to avoid heavy imports - provider_settings deferred to Settings Tool
+        settings = SettingsDetector.get_basic_settings()
+
         credentials = settings["credentials"]
         custom_bases = settings["custom_bases"]
         model_defs = settings["model_definitions"]
         concurrency = settings["concurrency_limits"]
         filters = settings["model_filters"]
-        provider_settings = settings.get("provider_settings", {})
 
         self.console.print(
             Panel.fit(
@@ -740,23 +765,13 @@ def show_provider_settings_menu(self):
                 status = " + ".join(status_parts) if status_parts else "None"
                 self.console.print(f"   • {provider:15} ✅ {status}")
 
-        # Provider-Specific Settings
+        # Provider-Specific Settings (deferred to Settings Tool to avoid heavy imports)
         self.console.print()
         self.console.print("[bold]🔬 Provider-Specific Settings[/bold]")
         self.console.print("━" * 70)
-        try:
-            from proxy_app.settings_tool import PROVIDER_SETTINGS_MAP
-        except ImportError:
-            from .settings_tool import PROVIDER_SETTINGS_MAP
-        for provider in PROVIDER_SETTINGS_MAP.keys():
-            display_name = provider.replace("_", " ").title()
-            modified = provider_settings.get(provider, 0)
-            if modified > 0:
-                self.console.print(
-                    f"   • {display_name:20} [yellow]{modified} setting{'s' if modified > 1 else ''} modified[/yellow]"
-                )
-            else:
-                self.console.print(f"   • {display_name:20} [dim]using defaults[/dim]")
+        self.console.print(
+            "   [dim]Launch Settings Tool to view/configure provider-specific settings[/dim]"
+        )
 
         # Actions
         self.console.print()
@@ -823,15 +838,31 @@ def launch_credential_tool(self):
         # Run the tool with from_launcher=True to skip duplicate loading screen
         run_credential_tool(from_launcher=True)
         # Reload environment after credential tool
-        load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+        load_dotenv(dotenv_path=_get_env_file(), override=True)
 
     def launch_settings_tool(self):
         """Launch settings configuration tool"""
-        from proxy_app.settings_tool import run_settings_tool
+        import time
+
+        clear_screen()
+
+        self.console.print("━" * 70)
+        self.console.print("Advanced Settings Configuration Tool")
+        self.console.print("━" * 70)
+
+        _start_time = time.time()
+
+        with self.console.status("Initializing settings tool...", spinner="dots"):
+            from proxy_app.settings_tool import run_settings_tool
+
+        _elapsed = time.time() - _start_time
+        self.console.print(f"✓ Settings tool ready in {_elapsed:.2f}s")
+
+        time.sleep(0.3)
 
         run_settings_tool()
         # Reload environment after settings tool
-        load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+        load_dotenv(dotenv_path=_get_env_file(), override=True)
 
     def show_about(self):
         """Display About page with project information"""
@@ -919,9 +950,9 @@ def run_proxy(self):
             )
 
             ensure_env_defaults()
-            load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+            load_dotenv(dotenv_path=_get_env_file(), override=True)
             run_credential_tool()
-            load_dotenv(dotenv_path=Path.cwd() / ".env", override=True)
+            load_dotenv(dotenv_path=_get_env_file(), override=True)
 
             # Check again after credential tool
             if not os.getenv("PROXY_API_KEY"):