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

src/api/routers/solve.py

@@ -0,0 +1,305 @@
+"""
+Solve API Router
+================
+
+WebSocket endpoint for real-time problem solving with streaming logs.
+"""
+
+import asyncio
+from pathlib import Path
+import re
+import sys
+from typing import Any
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+from src.agents.solve import MainSolver
+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
+
+_project_root = Path(__file__).parent.parent.parent.parent
+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
+
+# Initialize logger with config
+project_root = Path(__file__).parent.parent.parent.parent
+config = load_config_with_main("solve_config.yaml", project_root)
+log_dir = config.get("paths", {}).get("user_log_dir") or config.get("logging", {}).get("log_dir")
+logger = get_logger("SolveAPI", level="INFO", log_dir=log_dir)
+
+router = APIRouter()
+
+
+@router.websocket("/solve")
+async def websocket_solve(websocket: WebSocket):
+    await websocket.accept()
+
+    task_manager = TaskIDManager.get_instance()
+    connection_closed = asyncio.Event()
+    log_queue = asyncio.Queue()
+    pusher_task = None
+
+    async def safe_send_json(data: dict[str, Any]):
+        """Safely send JSON to WebSocket, checking if connection is closed"""
+        if connection_closed.is_set():
+            return False
+        try:
+            await websocket.send_json(data)
+            return True
+        except (WebSocketDisconnect, RuntimeError, ConnectionError) as e:
+            logger.debug(f"WebSocket connection closed: {e}")
+            connection_closed.set()
+            return False
+        except Exception as e:
+            logger.debug(f"Error sending WebSocket message: {e}")
+            return False
+
+    async def log_pusher():
+        while not connection_closed.is_set():
+            try:
+                # Use timeout to periodically check if connection is closed
+                entry = await asyncio.wait_for(log_queue.get(), timeout=0.5)
+                try:
+                    await websocket.send_json(entry)
+                except (WebSocketDisconnect, RuntimeError, ConnectionError) as e:
+                    # Connection closed, stop pushing
+                    logger.debug(f"WebSocket connection closed in log_pusher: {e}")
+                    connection_closed.set()
+                    log_queue.task_done()
+                    break
+                except Exception as e:
+                    logger.debug(f"Error sending log entry: {e}")
+                    # Continue to next entry
+                log_queue.task_done()
+            except asyncio.TimeoutError:
+                # Timeout, check if connection is still open
+                continue
+            except Exception as e:
+                logger.debug(f"Error in log_pusher: {e}")
+                break
+
+    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")
+
+        if not question:
+            await websocket.send_json({"type": "error", "content": "Question is required"})
+            return
+
+        task_key = f"solve_{kb_name}_{hash(str(question))}"
+        task_id = task_manager.generate_task_id("solve", task_key)
+
+        await websocket.send_json({"type": "task_id", "task_id": task_id})
+
+        # 2. Initialize Solver
+        root_dir = Path(__file__).parent.parent.parent.parent
+        output_base = root_dir / "data" / "user" / "solve"
+
+        try:
+            llm_config = get_llm_config()
+            api_key = llm_config.api_key
+            base_url = llm_config.base_url
+            api_version = getattr(llm_config, "api_version", None)
+        except Exception as e:
+            logger.error(f"Failed to get LLM config: {e}", exc_info=True)
+            await websocket.send_json({"type": "error", "content": f"LLM configuration error: {e}"})
+            return
+
+        solver = MainSolver(
+            kb_name=kb_name,
+            output_base_dir=str(output_base),
+            api_key=api_key,
+            base_url=base_url,
+            api_version=api_version,
+        )
+
+        # Complete async initialization
+        await solver.ainit()
+
+        logger.info(f"[{task_id}] Solving: {question[:50]}...")
+
+        target_logger = solver.logger.logger
+
+        # Note: System log forwarder removed - all logs now go to unified log file
+        # The main logger already writes to data/user/logs/ai_tutor_YYYYMMDD.log
+
+        # 3. Setup Log Queue
+        # log_queue already initialized
+
+        # 4. Setup status update mechanism
+        display_manager = None
+        if hasattr(solver.logger, "display_manager") and solver.logger.display_manager:
+            display_manager = solver.logger.display_manager
+
+            original_set_status = display_manager.set_agent_status
+
+            def wrapped_set_status(agent_name: str, status: str):
+                original_set_status(agent_name, status)
+                try:
+                    log_queue.put_nowait(
+                        {
+                            "type": "agent_status",
+                            "agent": agent_name,
+                            "status": status,
+                            "all_agents": display_manager.agents_status.copy(),
+                        }
+                    )
+                except Exception:
+                    pass
+
+            display_manager.set_agent_status = wrapped_set_status
+
+            original_update_stats = display_manager.update_token_stats
+
+            def wrapped_update_stats(summary: dict[str, Any]):
+                original_update_stats(summary)
+                try:
+                    stats_copy = display_manager.stats.copy()
+                    logger.debug(
+                        f"Sending token_stats: model={stats_copy.get('model')}, calls={stats_copy.get('calls')}, cost={stats_copy.get('cost')}"
+                    )
+                    log_queue.put_nowait({"type": "token_stats", "stats": stats_copy})
+                except Exception as e:
+                    logger.debug(f"Failed to send token_stats: {e}")
+
+            display_manager.update_token_stats = wrapped_update_stats
+
+            # Re-register the callback to use the wrapped method
+            # (The callback was set before wrapping in main_solver.py)
+            if hasattr(solver, "token_tracker") and solver.token_tracker:
+                solver.token_tracker.set_on_usage_added_callback(wrapped_update_stats)
+
+        def send_progress_update(stage: str, progress: dict[str, Any]):
+            """Send progress update to frontend"""
+            try:
+                log_queue.put_nowait({"type": "progress", "stage": stage, "progress": progress})
+            except Exception:
+                pass
+
+        solver._send_progress_update = send_progress_update
+
+        # 5. Background task to push logs to WebSocket
+        pusher_task = asyncio.create_task(log_pusher())
+
+        # 6. Run Solver within the LogInterceptor context
+        interceptor = LogInterceptor(target_logger, log_queue)
+        with interceptor:
+            await safe_send_json({"type": "status", "content": "started"})
+
+            if display_manager:
+                await safe_send_json(
+                    {
+                        "type": "agent_status",
+                        "agent": "all",
+                        "status": "initial",
+                        "all_agents": display_manager.agents_status.copy(),
+                    }
+                )
+                await safe_send_json({"type": "token_stats", "stats": display_manager.stats.copy()})
+
+            logger.progress(f"[{task_id}] Solving started")
+
+            result = await solver.solve(question, verbose=True)
+
+            logger.success(f"[{task_id}] Solving completed")
+            task_manager.update_task_status(task_id, "completed")
+
+            # Process Markdown content to fix image paths
+            final_answer = result.get("final_answer", "")
+            output_dir_str = result.get("output_dir", "")
+
+            if output_dir_str and final_answer:
+                try:
+                    output_dir = Path(output_dir_str)
+
+                    if not output_dir.is_absolute():
+                        output_dir = output_dir.resolve()
+
+                    path_str = str(output_dir).replace("\\", "/")
+                    parts = path_str.split("/")
+
+                    if "user" in parts:
+                        idx = parts.index("user")
+                        rel_path = "/".join(parts[idx + 1 :])
+                        base_url = f"/api/outputs/{rel_path}"
+
+                        pattern = r"\]\(artifacts/([^)]+)\)"
+                        replacement = rf"]({base_url}/artifacts/\1)"
+                        final_answer = re.sub(pattern, replacement, final_answer)
+                except Exception as e:
+                    logger.debug(f"Error processing image paths: {e}")
+
+            # Send final agent status update
+            if display_manager:
+                final_agent_status = dict.fromkeys(display_manager.agents_status.keys(), "done")
+                await safe_send_json(
+                    {
+                        "type": "agent_status",
+                        "agent": "all",
+                        "status": "complete",
+                        "all_agents": final_agent_status,
+                    }
+                )
+
+            # Send final result
+            final_res = {
+                "type": "result",
+                "final_answer": final_answer,
+                "output_dir": output_dir_str,
+                "metadata": result.get("metadata"),
+            }
+            await safe_send_json(final_res)
+
+            # Save to history
+            history_manager.add_entry(
+                activity_type=ActivityType.SOLVE,
+                title=question[:50] + "..." if len(question) > 50 else question,
+                content={
+                    "question": question,
+                    "answer": result.get("final_answer"),
+                    "kb_name": kb_name,
+                },
+                summary=(
+                    result.get("final_answer")[:100] + "..." if result.get("final_answer") else ""
+                ),
+            )
+
+    except Exception as e:
+        # Mark connection as closed before sending error (to prevent log_pusher from interfering)
+        connection_closed.set()
+        await safe_send_json({"type": "error", "content": str(e)})
+        logger.error(f"[{task_id if 'task_id' in locals() else 'unknown'}] Solving failed: {e}")
+        if "task_id" in locals():
+            task_manager.update_task_status(task_id, "error", error=str(e))
+    finally:
+        # Stop log pusher first
+        connection_closed.set()
+        if pusher_task:
+            pusher_task.cancel()
+            try:
+                await pusher_task
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.debug(f"Error waiting for pusher task: {e}")
+
+        # Close WebSocket connection
+        try:
+            # Check if connection is still open before closing
+            if hasattr(websocket, "client_state"):
+                state = websocket.client_state
+                if hasattr(state, "name") and state.name != "DISCONNECTED":
+                    await websocket.close()
+            else:
+                # Fallback: try to close anyway
+                await websocket.close()
+        except (WebSocketDisconnect, RuntimeError, ConnectionError):
+            # Connection already closed, ignore
+            pass
+        except Exception as e:
+            logger.debug(f"Error closing WebSocket: {e}")

src/api/routers/system.py

@@ -0,0 +1,252 @@
+"""
+System Status API Router
+Manages system status checks and model connection tests
+"""
+
+from datetime import datetime
+import time
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from src.services.embedding import get_embedding_client, get_embedding_config
+from src.services.llm import complete as llm_complete
+from src.services.llm import get_llm_config, get_token_limit_kwargs
+from src.services.tts import get_tts_config
+
+router = APIRouter()
+
+
+class TestResponse(BaseModel):
+    success: bool
+    message: str
+    model: str | None = None
+    response_time_ms: float | None = None
+    error: str | None = None
+
+
+@router.get("/status")
+async def get_system_status():
+    """
+    Get overall system status including backend and model configurations
+
+    Returns:
+        Dictionary containing status of backend, LLM, embeddings, and TTS
+    """
+    result = {
+        "backend": {"status": "online", "timestamp": datetime.now().isoformat()},
+        "llm": {"status": "unknown", "model": None, "testable": True},
+        "embeddings": {"status": "unknown", "model": None, "testable": True},
+        "tts": {"status": "unknown", "model": None, "testable": True},
+    }
+
+    # Check backend status (this endpoint itself proves backend is online)
+    result["backend"]["status"] = "online"
+
+    # Check LLM configuration
+    try:
+        llm_config = get_llm_config()
+        result["llm"]["model"] = llm_config.model
+        result["llm"]["status"] = "configured"
+    except ValueError as e:
+        result["llm"]["status"] = "not_configured"
+        result["llm"]["error"] = str(e)
+    except Exception as e:
+        result["llm"]["status"] = "error"
+        result["llm"]["error"] = str(e)
+
+    # Check Embeddings configuration
+    try:
+        embedding_config = get_embedding_config()
+        result["embeddings"]["model"] = embedding_config.model
+        result["embeddings"]["status"] = "configured"
+    except ValueError as e:
+        result["embeddings"]["status"] = "not_configured"
+        result["embeddings"]["error"] = str(e)
+    except Exception as e:
+        result["embeddings"]["status"] = "error"
+        result["embeddings"]["error"] = str(e)
+
+    # Check TTS configuration
+    try:
+        tts_config = get_tts_config()
+        result["tts"]["model"] = tts_config.get("model")
+        result["tts"]["status"] = "configured"
+    except ValueError as e:
+        result["tts"]["status"] = "not_configured"
+        result["tts"]["error"] = str(e)
+    except Exception as e:
+        result["tts"]["status"] = "error"
+        result["tts"]["error"] = str(e)
+
+    return result
+
+
+@router.post("/test/llm", response_model=TestResponse)
+async def test_llm_connection():
+    """
+    Test LLM model connection by sending a simple completion request
+
+    Returns:
+        Test result with success status and response time
+    """
+    start_time = time.time()
+
+    try:
+        llm_config = get_llm_config()
+        model = llm_config.model
+        base_url = llm_config.base_url.rstrip("/")
+
+        # Sanitize Base URL (remove /chat/completions suffix if present)
+        for suffix in ["/chat/completions", "/completions"]:
+            if base_url.endswith(suffix):
+                base_url = base_url[: -len(suffix)]
+
+        # Handle API Key (inject dummy if missing for local LLMs)
+        api_key = llm_config.api_key
+        if not api_key:
+            api_key = "sk-no-key-required"
+
+        # Send a minimal test request with a prompt that guarantees output
+        test_prompt = "Say 'OK' to confirm you are working. Do not produce long output."
+        token_kwargs = get_token_limit_kwargs(model, max_tokens=200)
+
+        response = await llm_complete(
+            model=model,
+            prompt=test_prompt,
+            system_prompt="You are a helpful assistant. Respond briefly.",
+            binding=llm_config.binding,
+            api_key=api_key,
+            base_url=base_url,
+            temperature=0.1,
+            **token_kwargs,
+        )
+
+        response_time = (time.time() - start_time) * 1000
+
+        if response and len(response.strip()) > 0:
+            return TestResponse(
+                success=True,
+                message="LLM connection successful",
+                model=model,
+                response_time_ms=round(response_time, 2),
+            )
+        return TestResponse(
+            success=False,
+            message="LLM connection failed: Empty response",
+            model=model,
+            error="Empty response from API",
+        )
+
+    except ValueError as e:
+        return TestResponse(success=False, message=f"LLM configuration error: {e!s}", error=str(e))
+    except Exception as e:
+        response_time = (time.time() - start_time) * 1000
+        return TestResponse(
+            success=False,
+            message=f"LLM connection failed: {e!s}",
+            response_time_ms=round(response_time, 2),
+            error=str(e),
+        )
+
+
+@router.post("/test/embeddings", response_model=TestResponse)
+async def test_embeddings_connection():
+    """
+    Test Embeddings model connection by sending a simple embedding request
+
+    Returns:
+        Test result with success status and response time
+    """
+    start_time = time.time()
+
+    try:
+        embedding_config = get_embedding_config()
+        embedding_client = get_embedding_client()
+
+        model = embedding_config.model
+        binding = embedding_config.binding
+
+        # Send a minimal test request using unified client
+        test_texts = ["test"]
+        embeddings = await embedding_client.embed(test_texts)
+
+        response_time = (time.time() - start_time) * 1000
+
+        if embeddings is not None and len(embeddings) > 0 and len(embeddings[0]) > 0:
+            return TestResponse(
+                success=True,
+                message=f"Embeddings connection successful ({binding} provider)",
+                model=model,
+                response_time_ms=round(response_time, 2),
+            )
+        return TestResponse(
+            success=False,
+            message="Embeddings connection failed: Empty response",
+            model=model,
+            error="Empty embedding vector",
+        )
+
+    except ValueError as e:
+        return TestResponse(
+            success=False, message=f"Embeddings configuration error: {e!s}", error=str(e)
+        )
+    except Exception as e:
+        response_time = (time.time() - start_time) * 1000
+        return TestResponse(
+            success=False,
+            message=f"Embeddings connection failed: {e!s}",
+            response_time_ms=round(response_time, 2),
+            error=str(e),
+        )
+
+
+@router.post("/test/tts", response_model=TestResponse)
+async def test_tts_connection():
+    """
+    Test TTS model connection by checking configuration
+
+    Note: We don't actually generate audio for testing to avoid unnecessary API calls.
+    We only verify the configuration is valid.
+
+    Returns:
+        Test result with success status
+    """
+    start_time = time.time()
+
+    try:
+        tts_config = get_tts_config()
+        model = tts_config["model"]
+        api_key = tts_config["api_key"]
+        base_url = tts_config["base_url"]
+
+        # Verify configuration is complete
+        if not model or not api_key or not base_url:
+            return TestResponse(
+                success=False,
+                message="TTS configuration incomplete",
+                model=model,
+                error="Missing required configuration",
+            )
+
+        # For TTS, we just verify the config is valid
+        # Actual audio generation would be expensive, so we skip it
+        response_time = (time.time() - start_time) * 1000
+
+        return TestResponse(
+            success=True,
+            message="TTS configuration valid",
+            model=model,
+            response_time_ms=round(response_time, 2),
+        )
+
+    except ValueError as e:
+        return TestResponse(success=False, message=f"TTS configuration error: {e!s}", error=str(e))
+    except Exception as e:
+        response_time = (time.time() - start_time) * 1000
+        return TestResponse(
+            success=False,
+            message=f"TTS connection check failed: {e!s}",
+            response_time_ms=round(response_time, 2),
+            error=str(e),
+        )

src/api/run_server.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+"""
+Uvicorn Server Startup Script
+Uses Python API instead of command line to avoid Windows path parsing issues.
+"""
+
+import os
+import sys
+
+# Force unbuffered output
+os.environ["PYTHONUNBUFFERED"] = "1"
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(line_buffering=True)
+if hasattr(sys.stderr, "reconfigure"):
+    sys.stderr.reconfigure(line_buffering=True)
+
+from pathlib import Path
+
+import uvicorn
+
+if __name__ == "__main__":
+    # Get project root directory
+    project_root = Path(__file__).parent.parent.parent
+
+    # Change to project root to ensure correct module imports
+    os.chdir(str(project_root))
+
+    # Ensure project root is in Python path
+    if str(project_root) not in sys.path:
+        sys.path.insert(0, str(project_root))
+
+    # Get port from configuration
+    from src.services.setup import get_backend_port
+
+    backend_port = get_backend_port(project_root)
+
+    # Configure reload_excludes to skip directories that shouldn't trigger reloads
+    # Use absolute paths to ensure they're properly resolved
+    reload_excludes = [
+        str(project_root / "venv"),  # Virtual environment
+        str(project_root / ".venv"),  # Virtual environment (alternative name)
+        str(project_root / "data"),  # Data directory (includes knowledge_bases, user data, logs)
+        str(project_root / "node_modules"),  # Node modules (if any at root)
+        str(project_root / "web" / "node_modules"),  # Web node modules
+        str(project_root / "web" / ".next"),  # Next.js build
+        str(project_root / ".git"),  # Git directory
+        str(project_root / "scripts"),  # Scripts directory - don't reload on launcher changes
+    ]
+
+    # Filter out non-existent directories to avoid warnings
+    reload_excludes = [d for d in reload_excludes if Path(d).exists()]
+
+    # Start uvicorn server with reload enabled
+    uvicorn.run(
+        "src.api.main:app",
+        host="0.0.0.0",
+        port=backend_port,
+        reload=True,
+        reload_excludes=reload_excludes,
+        log_level="info",
+    )