realtimex-deeptutor 0.5.0.post4__tar.gz → 0.5.0.post7__tar.gz

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: realtimex-deeptutor
-Version: 0.5.0.post4
+Version: 0.5.0.post7
 Summary: RealTimeX DeepTutor - Intelligent learning companion with multi-agent collaboration and LightRAG
 License: Apache-2.0
 Requires-Python: >=3.10

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "realtimex-deeptutor"
-version = "0.5.0.post4"
+version = "0.5.0.post7"
 description = "RealTimeX DeepTutor - Intelligent learning companion with multi-agent collaboration and LightRAG"
 requires-python = ">=3.10"
 readme = "README.md"

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/realtimex_deeptutor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: realtimex-deeptutor
-Version: 0.5.0.post4
+Version: 0.5.0.post7
 Summary: RealTimeX DeepTutor - Intelligent learning companion with multi-agent collaboration and LightRAG
 License: Apache-2.0
 Requires-Python: >=3.10

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/scripts/start_web.py

@@ -20,6 +20,80 @@ if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(line_buffering=True)
 
 
+class ExecutableResolver:
+    """
+    Resolves bundled executables (uvx, uv, npx) to their actual paths.
+    Ported from ExecutableResolver.js
+    """
+
+    def __init__(self):
+        self._resources_root = None
+
+    def get_resources_root(self) -> Path | None:
+        """
+        Get the resources root directory (~/.realtimex.ai)
+        Returns path to resources root or None if not found
+        """
+        if self._resources_root:
+            return self._resources_root
+
+        try:
+            home = Path.home()
+            self._resources_root = home / ".realtimex.ai"
+            return self._resources_root
+        except Exception as e:
+            print_flush(f"⚠️ [ExecutableResolver] Failed to resolve resources directory: {e}")
+            return None
+
+    def resolve_from_candidates(
+        self, env_var: str | None, candidates: list[Path | str]
+    ) -> str | None:
+        """
+        Find a valid executable from a list of candidate paths
+        """
+        search_paths = []
+        if env_var:
+            search_paths.append(Path(env_var))
+
+        search_paths.extend([Path(c) for c in candidates])
+
+        for candidate in search_paths:
+            if not candidate:
+                continue
+            try:
+                if candidate.exists() and candidate.is_file():
+                    return str(candidate)
+            except Exception:
+                pass
+        return None
+
+    def resolve_npx(self) -> str | None:
+        """
+        Resolve npx to bundled executable
+        """
+        resources_dir = self.get_resources_root()
+        if not resources_dir:
+            return None
+
+        node_version = os.environ.get("REALTIMEX_NPX_NODE_VERSION", "v22.16.0")
+        home = Path.home()
+
+        candidates = [
+            # User's NVM installation (most common case)
+            home / ".nvm" / "versions" / "node" / node_version / "bin" / "npx",
+            # NVM-installed node in resources dir (bundled)
+            resources_dir / ".nvm" / "versions" / "node" / node_version / "bin" / "npx",
+            # Windows NVM
+            Path("C:/nvm") / node_version / "npx.cmd",
+            # Bundled in Resources
+            resources_dir / "Resources" / "envs" / "Scripts" / "npx.cmd",
+        ]
+
+        return self.resolve_from_candidates(
+            env_var=os.environ.get("REALTIMEX_NPX_PATH"), candidates=candidates
+        )
+
+
 def print_flush(*args, **kwargs):
     """Print with flush=True by default"""
     kwargs.setdefault("flush", True)
@@ -625,7 +699,9 @@ def _start_frontend_npx(frontend_port, backend_port):
     """Start frontend using published package via npx (production mode)"""
 
     # Check if npx is available
-    npx_path = shutil.which("npx")
+    resolver = ExecutableResolver()
+    npx_path = resolver.resolve_npx() or shutil.which("npx")
+
     if not npx_path:
         print_flush("❌ Error: 'npx' command not found!")
         print_flush("   Please install Node.js and npm first.")
@@ -653,7 +729,7 @@ def _start_frontend_npx(frontend_port, backend_port):
     if os.name == "nt":
         env["PYTHONLEGACYWINDOWSSTDIO"] = "0"
 
-    npx_cmd = shutil.which("npx") or "npx"
+    npx_cmd = npx_path or "npx"
 
     # Process group configuration
     popen_kwargs = {

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/src/agents/co_writer/narrator_agent.py

@@ -315,30 +315,54 @@ class NarratorAgent(BaseAgent):
         self.logger.info(f"Starting TTS audio generation - ID: {audio_id}, Voice: {voice}")
 
         try:
-            binding = os.getenv("TTS_BINDING", "openai")
-            api_version = self.tts_config.get("api_version")
-
-            # Only use Azure client if binding is explicitly Azure,
-            # OR if binding is generic 'openai' but an Azure-specific api_version is present.
-            if binding == "azure_openai" or (binding == "openai" and api_version):
-                client = AsyncAzureOpenAI(
-                    api_key=self.tts_config["api_key"],
-                    azure_endpoint=self.tts_config["base_url"],
-                    api_version=api_version,
+            # Check if using RealTimeX SDK
+            if self.tts_config.get("source") == "realtimex":
+                from src.utils.realtimex import get_realtimex_sdk
+
+                sdk = get_realtimex_sdk()
+
+                # Use SDK to generate audio
+                audio_bytes = await sdk.tts.speak(
+                    text=script,
+                    voice=voice,
+                    model=self.tts_config.get("model"),
+                    provider=self.tts_config.get("provider")
+                    if self.tts_config.get("provider") != "realtimexai"
+                    else None,
+                    speed=self.tts_config.get("speed"),
+                    num_inference_steps=self.tts_config.get("quality"),
                 )
+
+                # Save bytes to file
+                with open(audio_path, "wb") as f:
+                    f.write(audio_bytes)
+
             else:
-                # Create OpenAI client with custom base_url
-                client = AsyncOpenAI(
-                    base_url=self.tts_config["base_url"], api_key=self.tts_config["api_key"]
+                # Standard OpenAI/Azure implementation
+                binding = os.getenv("TTS_BINDING", "openai")
+                api_version = self.tts_config.get("api_version")
+
+                # Only use Azure client if binding is explicitly Azure,
+                # OR if binding is generic 'openai' but an Azure-specific api_version is present.
+                if binding == "azure_openai" or (binding == "openai" and api_version):
+                    client = AsyncAzureOpenAI(
+                        api_key=self.tts_config["api_key"],
+                        azure_endpoint=self.tts_config["base_url"],
+                        api_version=api_version,
+                    )
+                else:
+                    # Create OpenAI client with custom base_url
+                    client = AsyncOpenAI(
+                        base_url=self.tts_config["base_url"], api_key=self.tts_config["api_key"]
+                    )
+
+                # Call OpenAI TTS API
+                response = await client.audio.speech.create(
+                    model=self.tts_config["model"], voice=voice, input=script
                 )
 
-            # Call OpenAI TTS API
-            response = await client.audio.speech.create(
-                model=self.tts_config["model"], voice=voice, input=script
-            )
-
-            # Save audio to file
-            await response.stream_to_file(audio_path)
+                # Save audio to file
+                await response.stream_to_file(audio_path)
 
             self.logger.info(f"Audio saved to: {audio_path}")
 

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/src/api/routers/realtimex.py

@@ -83,12 +83,16 @@ async def get_providers():
 
 
 from pydantic import BaseModel
+from typing import Optional
 
 
 class RTXConfigApplyRequest(BaseModel):
-    config_type: str  # "llm" or "embedding"
+    config_type: str  # "llm", "embedding" or "tts"
     provider: str
     model: str
+    voice: Optional[str] = None
+    speed: Optional[float] = None
+    quality: Optional[int] = None
 
 
 @router.post("/realtimex/config/apply")
@@ -113,11 +117,20 @@ async def apply_rtx_config(request: RTXConfigApplyRequest):
             config_type_enum = ConfigType.LLM
         elif request.config_type == "embedding":
             config_type_enum = ConfigType.EMBEDDING
+        elif request.config_type == "tts":
+            config_type_enum = ConfigType.TTS
         else:
             raise HTTPException(400, f"Invalid config type: {request.config_type}")
 
         # Save RTX selection to rtx_active.json
-        if not set_rtx_active_config(request.config_type, request.provider, request.model):
+        if not set_rtx_active_config(
+            request.config_type,
+            request.provider,
+            request.model,
+            request.voice,
+            request.speed,
+            request.quality,
+        ):
             raise HTTPException(500, "Failed to save RTX configuration")
 
         # Set 'rtx' as the active config in unified config manager
@@ -129,6 +142,9 @@ async def apply_rtx_config(request: RTXConfigApplyRequest):
             "config_type": request.config_type,
             "provider": request.provider,
             "model": request.model,
+            "voice": request.voice,
+            "speed": request.speed,
+            "quality": request.quality,
         }
 
     except HTTPException:

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/src/services/config/unified_config.py

@@ -190,6 +190,22 @@ class UnifiedConfigManager:
                 self.set_active_config(ConfigType.EMBEDDING, "rtx")
                 logger.info("Auto-activated RealTimeX for Embedding")
 
+            # Auto-activate for TTS
+            tts_data = self._load_configs(ConfigType.TTS)
+            tts_active_id = tts_data.get("active_id", "default")
+
+            # Only auto-activate if still using default
+            if tts_active_id == "default":
+                rtx_tts_config = get_rtx_active_config("tts")
+                if not rtx_tts_config:
+                    # Set default RTX TTS config
+                    set_rtx_active_config("tts", "realtimexai", "tts-1")
+                    logger.info("Auto-configured RealTimeX TTS with default model: tts-1")
+
+                # Activate RTX for TTS
+                self.set_active_config(ConfigType.TTS, "rtx")
+                logger.info("Auto-activated RealTimeX for TTS")
+
         except ImportError:
             # RTX utilities not available
             pass
@@ -472,8 +488,8 @@ class UnifiedConfigManager:
             if not should_use_realtimex_sdk():
                 return None
 
-            # Only LLM and Embedding are supported via RTX
-            if config_type not in (ConfigType.LLM, ConfigType.EMBEDDING):
+            # Only LLM, Embedding, and TTS are supported via RTX
+            if config_type not in (ConfigType.LLM, ConfigType.EMBEDDING, ConfigType.TTS):
                 return None
 
             # Get user's active selection (or use defaults)
@@ -482,15 +498,23 @@ class UnifiedConfigManager:
             if active:
                 provider = active.get("provider", "realtimexai")
                 model = active.get("model", "")
+                voice = active.get("voice")
+                speed = active.get("speed")
+                quality = active.get("quality")
             else:
                 # Use defaults
                 provider = "realtimexai"
+                voice = None
+                speed = None
+                quality = None
                 if config_type == ConfigType.LLM:
                     model = "gpt-4o-mini"
-                else:  # Embedding
+                elif config_type == ConfigType.EMBEDDING:
                     model = "text-embedding-3-small"
+                elif config_type == ConfigType.TTS:
+                    model = "tts-1"
 
-            return {
+            config = {
                 "id": "rtx",
                 "name": "RealTimeX",
                 "is_default": False,
@@ -500,6 +524,16 @@ class UnifiedConfigManager:
                 "api_key": "—",  # No API key needed
                 "base_url": "—",  # Uses SDK proxy
             }
+            
+            # Add TTS-specific fields if present
+            if voice:
+                config["voice"] = voice
+            if speed is not None:
+                config["speed"] = speed
+            if quality is not None:
+                config["quality"] = quality
+                
+            return config
 
         except ImportError:
             return None
@@ -602,15 +636,22 @@ class UnifiedConfigManager:
                             "id": "rtx",
                             "provider": rtx_active.get("provider", "realtimexai"),
                             "model": rtx_active.get("model", ""),
+                            "voice": rtx_active.get("voice"),  # Include voice for TTS
+                            "speed": rtx_active.get("speed"),  # Include speed for TTS
+                            "quality": rtx_active.get("quality"),  # Include quality for TTS
                             "source": "realtimex",  # This tells services to use SDK
                         }
                     else:
                         # Return defaults when no selection exists yet
-                        default_model = (
-                            "gpt-4o-mini"
-                            if config_type == ConfigType.LLM
-                            else "text-embedding-3-small"
-                        )
+                        if config_type == ConfigType.LLM:
+                            default_model = "gpt-4o-mini"
+                        elif config_type == ConfigType.EMBEDDING:
+                            default_model = "text-embedding-3-small"
+                        elif config_type == ConfigType.TTS:
+                            default_model = "tts-1"
+                        else:
+                            default_model = ""
+
                         return {
                             "id": "rtx",
                             "provider": "realtimexai",

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/src/services/tts/config.py

@@ -60,6 +60,7 @@ def get_tts_config() -> dict:
                 "base_url": config.get("base_url", ""),
                 "api_version": config.get("api_version"),
                 "voice": config.get("voice", "alloy"),
+                "source": config.get("source"),  # "realtimex" when using RTX
             }
     except ImportError:
         # Unified config service not yet available, fall back to env

{realtimex_deeptutor-0.5.0.post4 → realtimex_deeptutor-0.5.0.post7}/src/utils/realtimex.py

@@ -45,6 +45,8 @@ def get_realtimex_sdk() -> "RealtimeXSDK":
                         "llm.chat",  # For LLM completions
                         "llm.providers",  # For listing available providers
                         "llm.embed",  # For embeddings
+                        "tts.speak",  # For TTS
+                        "tts.providers",  # For listing TTS providers
                     ]
                 )
             )
@@ -160,21 +162,34 @@ async def get_cached_providers() -> dict:
     try:
         sdk = get_realtimex_sdk()
 
-        # Fetch both in parallel (conceptually, though await is sequential here)
-        # In a real async environment we might use asyncio.gather, but sequential is safe
+        # Fetch all providers in parallel (conceptually)
         llm_result = await sdk.llm.chat_providers()
         embed_result = await sdk.llm.embed_providers()
+        tts_result = await sdk.tts.list_providers()
 
         def serialize_provider(p):
-            return {
+            # Handle both object and dict responses (SDK might return dicts for TTS)
+            if isinstance(p, dict):
+                # Normalize: ensure 'provider' key exists (SDK uses 'id' for TTS)
+                if "provider" not in p and "id" in p:
+                    p["provider"] = p["id"]
+                return p
+            
+            data = {
                 "provider": p.provider,
                 "models": [{"id": m.id, "name": m.name} for m in p.models],
             }
+            # Add config metadata if available (for TTS advanced options)
+            if hasattr(p, "config"):
+                data["config"] = p.config
+                
+            return data
 
         _providers_cache = {
             "rtx_enabled": True,
             "llm": [serialize_provider(p) for p in llm_result.providers],
             "embedding": [serialize_provider(p) for p in embed_result.providers],
+            "tts": [serialize_provider(p) for p in tts_result],
         }
         _providers_cache_time = time.time()
 
@@ -247,23 +262,41 @@ def get_rtx_active_config(config_type: str) -> Optional[dict]:
     return data.get(config_type)
 
 
-def set_rtx_active_config(config_type: str, provider: str, model: str) -> bool:
+def set_rtx_active_config(
+    config_type: str,
+    provider: str,
+    model: str,
+    voice: Optional[str] = None,
+    speed: Optional[float] = None,
+    quality: Optional[int] = None,
+) -> bool:
     """
     Set the active RTX config for a specific config type.
 
     Args:
-        config_type: "llm" or "embedding"
+        config_type: "llm", "embedding" or "tts"
         provider: Provider name (e.g., "openai")
         model: Model ID (e.g., "gpt-4o")
+        voice: Optional voice ID (for TTS)
+        speed: Optional speed multiplier (for TTS)
+        quality: Optional quality/inference steps (for TTS)
 
     Returns:
         True if saved successfully
     """
     data = _load_rtx_active_config()
-    data[config_type] = {
+    config = {
         "provider": provider,
         "model": model,
     }
+    if voice:
+        config["voice"] = voice
+    if speed is not None:
+        config["speed"] = speed
+    if quality is not None:
+        config["quality"] = quality
+
+    data[config_type] = config
     return _save_rtx_active_config(data)