realtimex-deeptutor 0.5.0.post3__py3-none-any.whl → 0.5.0.post6__py3-none-any.whl

{realtimex_deeptutor-0.5.0.post3.dist-info → realtimex_deeptutor-0.5.0.post6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: realtimex-deeptutor
-Version: 0.5.0.post3
+Version: 0.5.0.post6
 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.post3.dist-info → realtimex_deeptutor-0.5.0.post6.dist-info}/RECORD

@@ -1,5 +1,5 @@
 realtimex_deeptutor/__init__.py,sha256=sSfuCLjJa6BnayszcU4azNl_sr1OzuKgLP10BAtdoh8,1567
-realtimex_deeptutor-0.5.0.post3.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+realtimex_deeptutor-0.5.0.post6.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
 scripts/__init__.py,sha256=mxMsCbci-Qon3qWU1JIi93-tYlHAy0NIUbDRmAPVcg0,54
 scripts/audit_prompts.py,sha256=Ltuk7tvsjpKhiobVbYq1volgVFKiVLgSTaE_Is4MGaM,5651
 scripts/check_install.py,sha256=GbApEcDLJ6r0QmYrCVHAFCOK4wolpSLwL3eBRmmD3og,13929
@@ -7,7 +7,7 @@ scripts/generate_roster.py,sha256=COsJ12bvZ5W9TI-wAvKpknKBgHr9uQTvJ_JCz2gVMVo,12
 scripts/install_all.py,sha256=u-A3eLhk1ua_KCjz8WZMkrVNJN6QdYs7NhGOcsm-Mks,23875
 scripts/migrate_kb.py,sha256=uyJgplkJag35rT2RrwSiT37__gpB4TiA0xh5uVcWIa4,19667
 scripts/start.py,sha256=EYbyjryor0DN_WcxQMSkKWCboM9UjMkv61fWhLyv63I,30300
-scripts/start_web.py,sha256=vzn7TiW7g2RNpAKYPQjHVNtOt6G9MxokEnZE_YWfHu4,22980
+scripts/start_web.py,sha256=aZ5nqH-h2F6I_tAsY-_uy56jIS5ZJt8Fsjw0OHjEYGc,29755
 scripts/sync_prompts_from_en.py,sha256=TkBSFilYSwnwo0a3cgRnJ84i02zByAIW12N3ePzBwE8,4677
 src/__init__.py,sha256=UNw3C20mbskiQF3rK3HhjglrG8snhfuiVthc5UsoHX0,1046
 src/agents/__init__.py,sha256=IPhP4RZnCH2kcUDBkdKHO_ciVdyWnuHUCG2flG5Ydcw,885
@@ -19,7 +19,7 @@ src/agents/chat/prompts/en/chat_agent.yaml,sha256=K19crF4jLrtGeZYZ7_LSzlpOFljCJ_
 src/agents/chat/prompts/zh/chat_agent.yaml,sha256=dUudCfMKj_75pGdh1rjVUmWlHf8hzUhHia7qfEwmntU,929
 src/agents/co_writer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 src/agents/co_writer/edit_agent.py,sha256=5NCTQtReO7S9A3jD8TefeUNv6LFSCojvo7dUyPJAc9s,9147
-src/agents/co_writer/narrator_agent.py,sha256=RyulrOgvVz1ZXS4njhzPed-li5wKAoJaui1MLe5ZnJ0,15397
+src/agents/co_writer/narrator_agent.py,sha256=h9hjIsWvWJBXsQxPkuwBlHgAMBKFvwXyUprlvh0SXbc,16425
 src/agents/co_writer/prompts/en/edit_agent.yaml,sha256=wGGk_IBq5DlIoDAl7sSHn-xFt6jx07NWv1NbXFBQE2g,4085
 src/agents/co_writer/prompts/en/narrator_agent.yaml,sha256=zUhgsE64uTQPxOBHE34YvDxMq1a7wav1NVMP1XDYMkg,4259
 src/agents/co_writer/prompts/zh/edit_agent.yaml,sha256=Sg6RnG660LvglIaW5bqAH8yqc6EQl2xmE_wHGrixX38,3617
@@ -139,7 +139,7 @@ src/api/routers/ideagen.py,sha256=UFgQ0LjKjGwKc-wVjdNi-R-TC7RhU8kZrWxLKBuiCls,16
 src/api/routers/knowledge.py,sha256=gW6Ol6cRMqZ-reRQ30JfJHf51Wg4gNg5vvf0Zpt5MQ8,32056
 src/api/routers/notebook.py,sha256=NwLf2MPaT_rsF6cDlsZG85o3z7JMHXatl-FuWIKYaJw,6098
 src/api/routers/question.py,sha256=aAAY5nz3PRgsww75Ph1ZWY_9_Hey2uudTxdsQlMZzPA,20876
-src/api/routers/realtimex.py,sha256=nMmSWYyIDRoRdeQTFpTrGnpaf87jSiwvJ4zRkyEaW00,3998
+src/api/routers/realtimex.py,sha256=AX4dna8tbScf0W_AWtzxqlXm0WRgPMMqmVTh7fYOZp8,4464
 src/api/routers/research.py,sha256=ZZJRNi1xhmoi8Shg8gBln_1uL1_XEW9Hxo0IM5RsOKo,16520
 src/api/routers/settings.py,sha256=7Q2edffDgD0PeiBJ0emd3kFc3i3qn1rFrTbbIm9LsXI,4549
 src/api/routers/solve.py,sha256=lLyPd_R1o-Yxe9I685nGj_SfyCeGBS74023tbDNpZGI,15939
@@ -150,7 +150,7 @@ src/api/utils/notebook_manager.py,sha256=4zTn_J10BmWlCaCJo3bcNWiWUGgLw4hGR92sfj3
 src/api/utils/progress_broadcaster.py,sha256=u1cfxZ2Rek9tSP9sP1hdQMQkh6Dr_6fhzJjBUvFf-3I,2772
 src/api/utils/task_id_manager.py,sha256=E59dJ2rg-_qY7uACNT3Nmzey0fnpZgfMYerW-8QsaNM,3687
 src/cli/__init__.py,sha256=MQ18rJWUlLlk_keWk7lrCjOYW5c_kDfJr5roKDu5ZT8,269
-src/cli/start.py,sha256=KNQ4ulAB4QCcS39Z5TcYWw4UtTzfEFCJg_yZOtg-Brw,6664
+src/cli/start.py,sha256=g2kYPuynTDCDL66wJ8IUchRLd-ZV8q5-SjAuuZWyYto,6744
 src/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 src/config/accessors.py,sha256=A06OaUK78MdgLu__6MRcKcVoog1ctDj5fHP4APOyRiI,534
 src/config/constants.py,sha256=C3370U6qkFExKkoNyDDLcf05FIJU0_5MHvpT6mvDQ7A,734
@@ -184,7 +184,7 @@ src/services/__init__.py,sha256=91ZEKiPyPtwFgYRtmkKBrdYAZKVnREUw43itPM5n-WM,1851
 src/services/config/__init__.py,sha256=Vjt0TORUt358yZvNCgoIVnuWJWVPuYiNA6ge9DV-Dyo,1792
 src/services/config/knowledge_base_config.py,sha256=l6QlAivVCBf1Q23YaEkHIHvq3TmsowPJmjDASezBf8c,7266
 src/services/config/loader.py,sha256=1PXImuGe8RpJ8UQpyGcsRhkq_YL9kWJq2f1ylQE4N3Y,8068
-src/services/config/unified_config.py,sha256=3sPs06oU0j6BjPZObh5Zoc1eLDusa1qa8HPGU9rncdY,32338
+src/services/config/unified_config.py,sha256=oIPUJ2lVhcREf2V8PdQBwvPoBHhpcuuaWoPvoc6gBt8,34238
 src/services/embedding/__init__.py,sha256=ljDq50as6CkKNHK2sSQtX_iXu9TyOMhzzFNs2f7QYKs,1338
 src/services/embedding/client.py,sha256=X5iUbGuXjtk_6Nkl7N4eRXjbL5hPY46JcTfi65UZWus,6003
 src/services/embedding/config.py,sha256=vBJjsTcYLsIpy0bmR7V8etu8eAXdRShjQIYIMcqwIgU,5368
@@ -269,7 +269,7 @@ src/services/settings/interface_settings.py,sha256=xyiJl_N2eYWmQVufQE63wEZJftgCx
 src/services/setup/__init__.py,sha256=9AyQ8c-3ViiKpylTzqw4_qle0Y8MBo0GBPzTNP4vT_4,711
 src/services/setup/init.py,sha256=fsLMcgZ_LQRI4EoPwfbrmnI9p2lU26lgQwR6QmZW01A,10779
 src/services/tts/__init__.py,sha256=sLKSM4WvthMajSCVKWSK5hi8FOf0xmx_zpE471n97FI,343
-src/services/tts/config.py,sha256=by4OWjPwA16AtL2d3805Y_w3Z_UrmF9I3zfN028twWY,3088
+src/services/tts/config.py,sha256=nVDC_ukWLPE8ZvWOqYA9eHQhqpjjbH23zg-BkJ4sQf8,3166
 src/tools/__init__.py,sha256=Zn9-uR4OqkAUq5oXm8Mwd3I4O_Qpg5GUJkrwEN47QLA,2777
 src/tools/code_executor.py,sha256=Tb8R2Cp-4_q1XfxUYsBUW52UDUwdQxLIwBMukjkEMXk,19436
 src/tools/paper_search_tool.py,sha256=f-CynXbOYo9-DLIaTIlc-odGYo8j3hx4sHb0sFktQF8,4745
@@ -287,10 +287,10 @@ src/utils/document_validator.py,sha256=ogNk0KvMZPQKi9zHoeQzhUxCVsYFpkP9-pjO8kC71
 src/utils/error_rate_tracker.py,sha256=MIhaNaStdrhinVFIKHNOgQMPdbrddjKJy2ok_jK8WX4,3942
 src/utils/error_utils.py,sha256=ME_9q-DlmxFl-Xvv3ETPZE_iP705x6MXiuAREgWYsjM,2262
 src/utils/json_parser.py,sha256=M_KfrsrNvQPSiFvpKHQV79Aj85_MEcLVc6hnKzvTV58,3243
-src/utils/realtimex.py,sha256=WlGeZ7d-ymXIJ6ZYK2nhjqxArV_7rVHHJLCqaNkcOUw,8648
+src/utils/realtimex.py,sha256=vs7fAEnJJ4zpAyyBn-7vUmGWiiQvpTWQCRgax1MLTDw,9769
 src/utils/network/circuit_breaker.py,sha256=BtjogK5R3tG8fuJniS5-PJKZMtwD5P2SkP2JFiQ9sRA,2722
-realtimex_deeptutor-0.5.0.post3.dist-info/METADATA,sha256=cPG-bhP_0bk97uBwQaN9OzVTH9YiVceBLDrNM4_yv8Q,58304
-realtimex_deeptutor-0.5.0.post3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-realtimex_deeptutor-0.5.0.post3.dist-info/entry_points.txt,sha256=slNAzwRLUpqiMtDRZBQIkXbU2vGMHL_om6-o19gYdh8,134
-realtimex_deeptutor-0.5.0.post3.dist-info/top_level.txt,sha256=zUAd6V7jDYhdL7bvg2S38YCM-gVhvd36WqkjxrT-02I,32
-realtimex_deeptutor-0.5.0.post3.dist-info/RECORD,,
+realtimex_deeptutor-0.5.0.post6.dist-info/METADATA,sha256=ZHgtwKQVopSxjI2xUxf27e-HiHVkrPtObk6b35e2zlk,58304
+realtimex_deeptutor-0.5.0.post6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+realtimex_deeptutor-0.5.0.post6.dist-info/entry_points.txt,sha256=slNAzwRLUpqiMtDRZBQIkXbU2vGMHL_om6-o19gYdh8,134
+realtimex_deeptutor-0.5.0.post6.dist-info/top_level.txt,sha256=zUAd6V7jDYhdL7bvg2S38YCM-gVhvd36WqkjxrT-02I,32
+realtimex_deeptutor-0.5.0.post6.dist-info/RECORD,,

scripts/start_web.py

@@ -69,6 +69,194 @@ else:
         return False
 
 
+def check_port_in_use(port: int) -> tuple[bool, int | None]:
+    """
+    Check if a port is in use and return the PID of the process using it.
+
+    Uses connect test to check if something is actually LISTENING on the port,
+    rather than bind test which fails for TIME_WAIT state.
+
+    Args:
+        port: Port number to check
+
+    Returns:
+        Tuple of (is_in_use, pid_or_none)
+    """
+    import socket
+
+    # Use connect test to check if something is actually listening
+    # This avoids false positives from TIME_WAIT state
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.settimeout(1)
+    try:
+        result = sock.connect_ex(("localhost", port))
+        if result != 0:
+            # Connection refused = nothing listening = port is free
+            return False, None
+    except (OSError, socket.timeout):
+        # Connection failed = port is free
+        return False, None
+    finally:
+        try:
+            sock.close()
+        except Exception:
+            pass
+
+    # Port is in use (connection succeeded), try to find the PID
+    pid = None
+    try:
+        if os.name == "nt":
+            # Windows: use netstat
+            result = subprocess.run(
+                ["netstat", "-ano"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            for line in result.stdout.splitlines():
+                if f":{port}" in line and "LISTENING" in line:
+                    parts = line.split()
+                    if parts:
+                        try:
+                            pid = int(parts[-1])
+                            break
+                        except ValueError:
+                            pass
+        else:
+            # Unix: use lsof
+            result = subprocess.run(
+                ["lsof", "-ti", f":{port}"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                # May return multiple PIDs, take the first one
+                try:
+                    pid = int(result.stdout.strip().split()[0])
+                except (ValueError, IndexError):
+                    pass
+    except Exception:
+        pass
+
+    return True, pid
+
+
+def kill_process_on_port(port: int, force: bool = False) -> bool:
+    """
+    Kill the process using a specific port.
+
+    Args:
+        port: Port number
+        force: If True, use SIGKILL instead of SIGTERM
+
+    Returns:
+        True if process was killed successfully
+    """
+    in_use, pid = check_port_in_use(port)
+    if not in_use:
+        return True  # Port is free
+
+    if pid is None:
+        print_flush(f"⚠️  Port {port} is in use but couldn't identify the process")
+        return False
+
+    print_flush(f"   Stopping process {pid} on port {port}...")
+
+    try:
+        if os.name == "nt":
+            subprocess.run(["taskkill", "/F", "/PID", str(pid)], check=True, capture_output=True)
+        else:
+            sig = signal.SIGKILL if force else signal.SIGTERM
+            os.kill(pid, sig)
+            # Wait a moment for process to terminate
+            time.sleep(0.5)
+            # Check if still running, force kill if needed
+            if not force:
+                try:
+                    os.kill(pid, 0)  # Check if process exists
+                    os.kill(pid, signal.SIGKILL)
+                    time.sleep(0.3)
+                except ProcessLookupError:
+                    pass  # Process already terminated
+
+        # Verify port is now free
+        time.sleep(0.3)
+        in_use, _ = check_port_in_use(port)
+        if not in_use:
+            print_flush(f"✅ Port {port} is now free")
+            return True
+        else:
+            print_flush(f"⚠️  Port {port} still in use after killing process")
+            return False
+
+    except Exception as e:
+        print_flush(f"❌ Failed to kill process {pid}: {e}")
+        return False
+
+
+def ensure_ports_available(backend_port: int, frontend_port: int, auto_kill: bool = False) -> bool:
+    """
+    Ensure required ports are available, optionally killing existing processes.
+
+    Args:
+        backend_port: Backend port number
+        frontend_port: Frontend port number
+        auto_kill: If True, automatically kill processes using the ports
+
+    Returns:
+        True if all ports are available
+    """
+    ports_to_check = [
+        (backend_port, "Backend"),
+        (frontend_port, "Frontend"),
+    ]
+
+    conflicts = []
+    for port, name in ports_to_check:
+        in_use, pid = check_port_in_use(port)
+        if in_use:
+            conflicts.append((port, name, pid))
+
+    if not conflicts:
+        return True
+
+    print_flush("")
+    print_flush("⚠️  Port conflict detected:")
+    for port, name, pid in conflicts:
+        pid_info = f" (PID: {pid})" if pid else ""
+        print_flush(f"   - {name} port {port} is already in use{pid_info}")
+
+    if auto_kill:
+        print_flush("")
+        print_flush("🔄 AUTO_KILL_PORTS is enabled, cleaning up...")
+        all_freed = True
+        for port, name, _ in conflicts:
+            if not kill_process_on_port(port):
+                all_freed = False
+        return all_freed
+    else:
+        print_flush("")
+        print_flush("💡 To resolve this, you can either:")
+        print_flush("   1. Set AUTO_KILL_PORTS=true to automatically clean up")
+        print_flush("   2. Manually kill the processes:")
+        for port, name, pid in conflicts:
+            if pid:
+                if os.name == "nt":
+                    print_flush(f"      taskkill /F /PID {pid}")
+                else:
+                    print_flush(f"      kill -9 {pid}")
+            else:
+                if os.name == "nt":
+                    print_flush(f"      netstat -ano | findstr :{port}")
+                else:
+                    print_flush(f"      lsof -ti :{port} | xargs kill -9")
+        print_flush("   3. Use different ports via environment variables:")
+        print_flush("      BACKEND_PORT=8002 FRONTEND_PORT=3783 uvx realtimex-deeptutor")
+        print_flush("")
+        return False
+
+
 def terminate_process_tree(process, name="Process", timeout=5):
     """
     Terminate a process and all its children (process group).
@@ -541,6 +729,23 @@ if __name__ == "__main__":
         print_flush(f"⚠️ Warning: Failed to initialize user directories: {e}")
         print_flush("   Continuing anyway...")
 
+    # Check for port conflicts before starting services
+    try:
+        from pathlib import Path
+
+        from src.services.setup import get_ports
+
+        backend_port, frontend_port = get_ports(
+            Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        )
+
+        auto_kill = os.environ.get("AUTO_KILL_PORTS", "").lower() in ("true", "1", "yes")
+        if not ensure_ports_available(backend_port, frontend_port, auto_kill=auto_kill):
+            sys.exit(1)
+    except Exception as e:
+        print_flush(f"⚠️ Warning: Failed to check ports: {e}")
+        print_flush("   Continuing anyway...")
+
     backend = None
     frontend = None
 

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}")
 

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:

src/cli/start.py

@@ -39,6 +39,7 @@ Examples:
 Environment Variables:
   FRONTEND_PORT       Frontend port (default: 3782)
   BACKEND_PORT        Backend port (default: 8001)
+  AUTO_KILL_PORTS     Auto-kill processes using required ports (default: false)
   RTX_APP_ID          RealTimeX App ID (auto-detected)
   API_BASE_URL        Backend API URL (auto-configured)
   LOG_LEVEL           Logging level (DEBUG, INFO, WARNING, ERROR)

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",

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

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)