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

src/api/routers/co_writer.py

@@ -23,6 +23,7 @@ from src.agents.co_writer.edit_agent import (
 from src.agents.co_writer.narrator_agent import NarratorAgent
 from src.logging import get_logger
 from src.services.config import load_config_with_main
+from src.services.settings.interface_settings import get_ui_language
 from src.services.tts import get_tts_config
 
 router = APIRouter()
@@ -33,15 +34,17 @@ config = load_config_with_main("solve_config.yaml", project_root)  # Use any con
 log_dir = config.get("paths", {}).get("user_log_dir") or config.get("logging", {}).get("log_dir")
 logger = get_logger("CoWriter", level="INFO", log_dir=log_dir)
 
-# Get system language for agent
-_system_language = config.get("system", {}).get("language", "en")
-
 # Singleton agent instances - use refresh_config() before each request
 # to pick up any configuration changes from Settings
 _edit_agent: EditAgent | None = None
 _narrator_agent: NarratorAgent | None = None
 
 
+def _current_language() -> str:
+    # Prefer UI settings, fall back to main.yaml system.language
+    return get_ui_language(default=config.get("system", {}).get("language", "en"))
+
+
 def get_edit_agent() -> EditAgent:
     """
     Get the singleton EditAgent instance with refreshed configuration.
@@ -51,8 +54,9 @@ def get_edit_agent() -> EditAgent:
     2. Latest LLM configuration from Settings is always used
     """
     global _edit_agent
-    if _edit_agent is None:
-        _edit_agent = EditAgent(language=_system_language)
+    lang = _current_language()
+    if _edit_agent is None or getattr(_edit_agent, "language", None) != lang:
+        _edit_agent = EditAgent(language=lang)
     # Refresh config to pick up any changes from Settings
     _edit_agent.refresh_config()
     return _edit_agent
@@ -67,8 +71,9 @@ def get_narrator_agent() -> NarratorAgent:
     2. Latest LLM configuration from Settings is always used
     """
     global _narrator_agent
-    if _narrator_agent is None:
-        _narrator_agent = NarratorAgent(language=_system_language)
+    lang = _current_language()
+    if _narrator_agent is None or getattr(_narrator_agent, "language", None) != lang:
+        _narrator_agent = NarratorAgent(language=lang)
     # Refresh config to pick up any changes from Settings
     _narrator_agent.refresh_config()
     return _narrator_agent

src/api/routers/config.py

@@ -168,6 +168,7 @@ async def get_config_status():
             "provider": active.get("provider") if active else None,
             "env_configured": env_status,
             "total_configs": len(configs),
+            "source": active.get("source") if active else None,  # "realtimex" when using RTX
         }
 
     return ConfigStatusResponse(

src/api/routers/guide.py

@@ -22,6 +22,7 @@ from src.api.utils.task_id_manager import TaskIDManager
 from src.logging import get_logger
 from src.services.config import load_config_with_main
 from src.services.llm import get_llm_config
+from src.services.settings.interface_settings import get_ui_language
 
 router = APIRouter()
 
@@ -76,11 +77,12 @@ def get_guide_manager():
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"LLM config error: {e!s}")
 
+    ui_language = get_ui_language(default=config.get("system", {}).get("language", "en"))
     return GuideManager(
         api_key=api_key,
         base_url=base_url,
         api_version=api_version,
-        language=None,
+        language=ui_language,
         binding=binding,
     )  # Read from config file
 

src/api/routers/ideagen.py

@@ -23,6 +23,7 @@ from src.api.utils.task_id_manager import TaskIDManager
 from src.logging import get_logger
 from src.services.config import load_config_with_main
 from src.services.llm import get_llm_config
+from src.services.settings.interface_settings import get_ui_language
 
 router = APIRouter()
 
@@ -148,6 +149,7 @@ async def websocket_ideagen(websocket: WebSocket):
 
         # Get LLM configuration
         llm_config = get_llm_config()
+        ui_language = get_ui_language(default=config.get("system", {}).get("language", "en"))
 
         # Get records
         records = []
@@ -198,6 +200,7 @@ async def websocket_ideagen(websocket: WebSocket):
                 base_url=llm_config.base_url,
                 api_version=getattr(llm_config, "api_version", None),
                 model=llm_config.model,
+                language=ui_language,
             )
 
             knowledge_points = await organizer.process(
@@ -258,6 +261,7 @@ async def websocket_ideagen(websocket: WebSocket):
             api_version=getattr(llm_config, "api_version", None),
             model=llm_config.model,
             progress_callback=None,  # We manually manage status here
+            language=ui_language,
         )
 
         filtered_points = await workflow.loose_filter(knowledge_points)
@@ -412,6 +416,9 @@ async def websocket_ideagen(websocket: WebSocket):
             task_manager.update_task_status(task_id, "error", error=str(e))
 
         try:
+            # Send unified error message via send_status
+            # Note: send_status sends {"type": "status", "stage": "error", ...}
+            # which is the standard format for this WebSocket protocol
             await send_status(
                 websocket,
                 IdeaGenStage.ERROR,

src/api/routers/knowledge.py

@@ -142,8 +142,19 @@ async def run_upload_processing_task(
     base_url: str,
     uploaded_file_paths: list[str],
     rag_provider: str = None,
+    folder_id: str = None,
 ):
-    """Background task for processing uploaded files"""
+    """Background task for processing uploaded files.
+
+    Args:
+        kb_name: Knowledge base name
+        base_dir: Base directory for knowledge bases
+        api_key: LLM API key
+        base_url: LLM API base URL
+        uploaded_file_paths: List of file paths to process
+        rag_provider: RAG provider (ignored - we use the one from KB metadata)
+        folder_id: Optional folder ID for sync state update
+    """
     task_manager = TaskIDManager.get_instance()
     task_key = f"{kb_name}_upload_{len(uploaded_file_paths)}"
     task_id = task_manager.generate_task_id("kb_upload", task_key)
@@ -169,8 +180,22 @@ async def run_upload_processing_task(
             rag_provider=rag_provider,
         )
 
-        new_files = [Path(path) for path in uploaded_file_paths]
-        processed_files = await adder.process_new_documents(new_files)
+        # Stage files and check for duplicates
+        staged_files = adder.add_documents(uploaded_file_paths, allow_duplicates=False)
+
+        if not staged_files:
+            logger.info(f"[{task_id}] No new files to process (all duplicates or invalid)")
+            progress_tracker.update(
+                ProgressStage.COMPLETED,
+                "No new files to process (all duplicates or invalid)",
+                current=0,
+                total=0,
+            )
+            task_manager.update_task_status(task_id, "completed")
+            return
+
+        # Process staged files
+        processed_files = await adder.process_new_documents(staged_files)
 
         if processed_files:
             progress_tracker.update(
@@ -181,16 +206,28 @@ async def run_upload_processing_task(
             )
             adder.extract_numbered_items_for_new_docs(processed_files, batch_size=20)
 
-        adder.update_metadata(len(new_files))
+        adder.update_metadata(len(processed_files) if processed_files else 0)
+
+        # Update folder sync state if this was a folder sync
+        if folder_id and processed_files:
+            try:
+                manager = get_kb_manager()
+                manager.update_folder_sync_state(
+                    kb_name, folder_id, [str(f) for f in processed_files]
+                )
+                logger.info(f"[{task_id}] Updated folder sync state for folder '{folder_id}'")
+            except Exception as sync_err:
+                logger.warning(f"[{task_id}] Failed to update folder sync state: {sync_err}")
 
+        num_processed = len(processed_files) if processed_files else 0
         progress_tracker.update(
             ProgressStage.COMPLETED,
-            f"Successfully processed {len(processed_files)} files!",
-            current=len(processed_files),
-            total=len(processed_files),
+            f"Successfully processed {num_processed} files!",
+            current=num_processed,
+            total=num_processed,
         )
 
-        logger.success(f"[{task_id}] Processed {len(processed_files)} files to KB '{kb_name}'")
+        logger.success(f"[{task_id}] Processed {num_processed} files to KB '{kb_name}'")
         task_manager.update_task_status(task_id, "completed")
     except Exception as e:
         error_msg = f"Upload processing failed (KB '{kb_name}'): {e}"
@@ -531,13 +568,28 @@ async def create_knowledge_base(
         except ValueError as e:
             raise HTTPException(status_code=500, detail=f"LLM config error: {e!s}")
 
-        progress_tracker = ProgressTracker(name, _kb_base_dir)
-
         logger.info(f"Creating KB: {name}")
 
-        progress_tracker.update(
-            ProgressStage.INITIALIZING, "Initializing knowledge base...", current=0, total=0
+        # Register KB to kb_config.json immediately with "initializing" status
+        # This ensures the KB appears in the list right away
+        manager.update_kb_status(
+            name=name,
+            status="initializing",
+            progress={
+                "stage": "initializing",
+                "message": "Initializing knowledge base...",
+                "percent": 0,
+                "current": 0,
+                "total": len(files),
+            },
         )
+        # Also store rag_provider in config (reload and update)
+        manager.config = manager._load_config()
+        if name in manager.config.get("knowledge_bases", {}):
+            manager.config["knowledge_bases"][name]["rag_provider"] = rag_provider
+            manager._save_config()
+
+        progress_tracker = ProgressTracker(name, _kb_base_dir)
 
         initializer = KnowledgeBaseInitializer(
             kb_name=name,

src/api/routers/question.py

@@ -23,6 +23,7 @@ sys.path.insert(0, str(project_root))
 from src.logging import get_logger
 from src.services.config import load_config_with_main
 from src.services.llm.config import get_llm_config
+from src.services.settings.interface_settings import get_ui_language
 
 # Setup module logger with unified logging system (from config)
 project_root = Path(__file__).parent.parent.parent.parent
@@ -382,6 +383,7 @@ async def websocket_question_generate(websocket: WebSocket):
             base_url=base_url,
             api_version=api_version,
             kb_name=kb_name,
+            language=get_ui_language(default=config.get("system", {}).get("language", "en")),
             max_rounds=10,
             output_dir=str(output_base),
         )

src/api/routers/realtimex.py

@@ -0,0 +1,137 @@
+"""
+RealTimeX SDK Status Router
+============================
+
+Provides status information about RealTimeX SDK connection and environment.
+"""
+
+from fastapi import APIRouter
+
+from src.utils.realtimex import get_realtimex_sdk, should_use_realtimex_sdk
+
+router = APIRouter()
+
+
+@router.get("/realtimex/status")
+async def get_realtimex_status():
+    """
+    Get RealTimeX SDK connection status.
+
+    Returns:
+        {
+            "connected": bool,
+            "mode": str | null,  # "development" or "production"
+            "appId": str | null,
+            "timestamp": str | null,
+            "error": str | null
+        }
+    """
+    try:
+        # Check if RealTimeX is detected
+        is_detected = should_use_realtimex_sdk()
+
+        if not is_detected:
+            return {
+                "connected": False,
+                "mode": None,
+                "appId": None,
+                "timestamp": None,
+                "error": None,
+            }
+
+        # Get SDK instance and ping (async)
+        try:
+            sdk = get_realtimex_sdk()
+            # Use async ping() instead of ping_sync() to avoid event loop conflict
+            ping_result = await sdk.ping()
+
+            return {
+                "connected": ping_result.get("success", False),
+                "mode": ping_result.get("mode"),
+                "appId": ping_result.get("appId"),
+                "timestamp": ping_result.get("timestamp"),
+                "error": None,
+            }
+        except Exception as e:
+            return {
+                "connected": False,
+                "mode": None,
+                "appId": None,
+                "timestamp": None,
+                "error": str(e),
+            }
+
+    except Exception as e:
+        return {
+            "connected": False,
+            "mode": None,
+            "appId": None,
+            "timestamp": None,
+            "error": f"Detection failed: {str(e)}",
+        }
+
+
+@router.get("/realtimex/providers")
+async def get_providers():
+    """
+    Get available providers from RealTimeX SDK.
+    Returns empty lists if SDK not enabled, allowing frontend to use defaults.
+    """
+    from src.utils.realtimex import get_cached_providers
+
+    return await get_cached_providers()
+
+
+from pydantic import BaseModel
+
+
+class RTXConfigApplyRequest(BaseModel):
+    config_type: str  # "llm" or "embedding"
+    provider: str
+    model: str
+
+
+@router.post("/realtimex/config/apply")
+async def apply_rtx_config(request: RTXConfigApplyRequest):
+    """
+    Apply RTX provider/model selection.
+
+    Saves the selection to rtx_active.json and sets the active config
+    to 'rtx' in the unified config manager.
+    """
+    from fastapi import HTTPException
+
+    from src.services.config.unified_config import ConfigType, get_config_manager
+    from src.utils.realtimex import set_rtx_active_config, should_use_realtimex_sdk
+
+    if not should_use_realtimex_sdk():
+        raise HTTPException(400, "RealTimeX SDK not available")
+
+    try:
+        # Validate config type
+        if request.config_type == "llm":
+            config_type_enum = ConfigType.LLM
+        elif request.config_type == "embedding":
+            config_type_enum = ConfigType.EMBEDDING
+        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):
+            raise HTTPException(500, "Failed to save RTX configuration")
+
+        # Set 'rtx' as the active config in unified config manager
+        manager = get_config_manager()
+        manager.set_active_config(config_type_enum, "rtx")
+
+        return {
+            "success": True,
+            "config_type": request.config_type,
+            "provider": request.provider,
+            "model": request.model,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Failed to apply configuration: {str(e)}")

src/api/routers/research.py

@@ -15,6 +15,7 @@ from src.api.utils.task_id_manager import TaskIDManager
 from src.logging import get_logger
 from src.services.config import load_config_with_main
 from src.services.llm import get_llm_config
+from src.services.settings.interface_settings import get_ui_language
 
 # Force stdout to use utf-8 to prevent encoding errors with emojis on Windows
 if sys.platform == "win32":
@@ -46,6 +47,10 @@ class OptimizeRequest(BaseModel):
 async def optimize_topic(request: OptimizeRequest):
     try:
         config = load_config()
+        config.setdefault("system", {})
+        config["system"]["language"] = get_ui_language(
+            default=config.get("system", {}).get("language", "en")
+        )
 
         # Inject API keys
         try:
@@ -111,6 +116,10 @@ async def websocket_research_run(websocket: WebSocket):
 
         # Use unified logger
         config = load_config()
+        config.setdefault("system", {})
+        config["system"]["language"] = get_ui_language(
+            default=config.get("system", {}).get("language", "en")
+        )
         try:
             # Get log_dir from config
             log_dir = config.get("paths", {}).get("user_log_dir") or config.get("logging", {}).get(

src/api/routers/solve.py

@@ -11,9 +11,9 @@ import re
 import sys
 from typing import Any
 
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect
 
-from src.agents.solve import MainSolver
+from src.agents.solve import MainSolver, SolverSessionManager
 from src.api.utils.history import ActivityType, history_manager
 from src.api.utils.log_interceptor import LogInterceptor
 from src.api.utils.task_id_manager import TaskIDManager
@@ -23,6 +23,7 @@ sys.path.insert(0, str(_project_root))
 from src.logging import get_logger
 from src.services.config import load_config_with_main
 from src.services.llm import get_llm_config
+from src.services.settings.interface_settings import get_ui_language
 
 # Initialize logger with config
 project_root = Path(__file__).parent.parent.parent.parent
@@ -32,6 +33,66 @@ logger = get_logger("SolveAPI", level="INFO", log_dir=log_dir)
 
 router = APIRouter()
 
+# Initialize session manager
+solver_session_manager = SolverSessionManager()
+
+
+# =============================================================================
+# REST Endpoints for Session Management
+# =============================================================================
+
+
+@router.get("/solve/sessions")
+async def list_solver_sessions(limit: int = 20):
+    """
+    List recent solver sessions.
+
+    Args:
+        limit: Maximum number of sessions to return
+
+    Returns:
+        List of session summaries
+    """
+    return solver_session_manager.list_sessions(limit=limit, include_messages=False)
+
+
+@router.get("/solve/sessions/{session_id}")
+async def get_solver_session(session_id: str):
+    """
+    Get a specific solver session with full message history.
+
+    Args:
+        session_id: Session identifier
+
+    Returns:
+        Complete session data including messages
+    """
+    session = solver_session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return session
+
+
+@router.delete("/solve/sessions/{session_id}")
+async def delete_solver_session(session_id: str):
+    """
+    Delete a solver session.
+
+    Args:
+        session_id: Session identifier
+
+    Returns:
+        Success message
+    """
+    if solver_session_manager.delete_session(session_id):
+        return {"status": "deleted", "session_id": session_id}
+    raise HTTPException(status_code=404, detail="Session not found")
+
+
+# =============================================================================
+# WebSocket Endpoint for Solving
+# =============================================================================
+
 
 @router.websocket("/solve")
 async def websocket_solve(websocket: WebSocket):
@@ -81,16 +142,47 @@ async def websocket_solve(websocket: WebSocket):
                 logger.debug(f"Error in log_pusher: {e}")
                 break
 
+    session_id = None  # Track session for this connection
+
     try:
         # 1. Wait for the initial message with the question and config
         data = await websocket.receive_json()
         question = data.get("question")
         kb_name = data.get("kb_name", "ai_textbook")
+        session_id = data.get("session_id")  # Optional session ID
 
         if not question:
             await websocket.send_json({"type": "error", "content": "Question is required"})
             return
 
+        # Get or create session
+        if session_id:
+            session = solver_session_manager.get_session(session_id)
+            if not session:
+                # Session not found, create new one
+                session = solver_session_manager.create_session(
+                    title=question[:50] + ("..." if len(question) > 50 else ""),
+                    kb_name=kb_name,
+                )
+                session_id = session["session_id"]
+        else:
+            # Create new session
+            session = solver_session_manager.create_session(
+                title=question[:50] + ("..." if len(question) > 50 else ""),
+                kb_name=kb_name,
+            )
+            session_id = session["session_id"]
+
+        # Send session ID to frontend
+        await websocket.send_json({"type": "session", "session_id": session_id})
+
+        # Add user message to session
+        solver_session_manager.add_message(
+            session_id=session_id,
+            role="user",
+            content=question,
+        )
+
         task_key = f"solve_{kb_name}_{hash(str(question))}"
         task_id = task_manager.generate_task_id("solve", task_key)
 
@@ -110,12 +202,14 @@ async def websocket_solve(websocket: WebSocket):
             await websocket.send_json({"type": "error", "content": f"LLM configuration error: {e}"})
             return
 
+        ui_language = get_ui_language(default=config.get("system", {}).get("language", "en"))
         solver = MainSolver(
             kb_name=kb_name,
             output_base_dir=str(output_base),
             api_key=api_key,
             base_url=base_url,
             api_version=api_version,
+            language=ui_language,
         )
 
         # Complete async initialization
@@ -247,14 +341,37 @@ async def websocket_solve(websocket: WebSocket):
                 )
 
             # Send final result
+            # Extract relative path from output_dir for frontend use
+            dir_name = ""
+            if output_dir_str:
+                parts = output_dir_str.replace("\\", "/").split("/")
+                dir_name = parts[-1] if parts else ""
+
             final_res = {
                 "type": "result",
+                "session_id": session_id,
                 "final_answer": final_answer,
                 "output_dir": output_dir_str,
+                "output_dir_name": dir_name,
                 "metadata": result.get("metadata"),
             }
             await safe_send_json(final_res)
 
+            # Save assistant message to session
+            if session_id:
+                solver_session_manager.add_message(
+                    session_id=session_id,
+                    role="assistant",
+                    content=final_answer,
+                    output_dir=dir_name,
+                )
+                # Update token stats in session
+                if display_manager:
+                    solver_session_manager.update_token_stats(
+                        session_id=session_id,
+                        token_stats=display_manager.stats.copy(),
+                    )
+
             # Save to history
             history_manager.add_entry(
                 activity_type=ActivityType.SOLVE,
@@ -263,6 +380,7 @@ async def websocket_solve(websocket: WebSocket):
                     "question": question,
                     "answer": result.get("final_answer"),
                     "kb_name": kb_name,
+                    "session_id": session_id,
                 },
                 summary=(
                     result.get("final_answer")[:100] + "..." if result.get("final_answer") else ""

src/cli/__init__.py

@@ -0,0 +1,13 @@
+"""
+Command-line interface for DeepTutor.
+
+Provides entry points for:
+- Full-stack startup (backend + frontend)
+- Backend-only mode (future)
+- Frontend-only mode (future)
+- Config management (future)
+"""
+
+from .start import main as start_main
+
+__all__ = ["start_main"]