quantum-framework 0.18.0__py3-none-any.whl

quantum/runtime/llm_service.py

@@ -0,0 +1,287 @@
+"""
+Quantum LLM Service - HTTP client for Ollama-compatible LLM APIs.
+
+Provides generate (completion) and chat endpoints for the q:llm tag.
+"""
+
+import os
+import json
+import logging
+from typing import List, Dict, Any, Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class LLMError(Exception):
+    """Raised when LLM invocation fails"""
+    pass
+
+
+class LLMService:
+    """HTTP client for Ollama-compatible LLM APIs."""
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        default_model: Optional[str] = None,
+        timeout: Optional[int] = None
+    ):
+        self.base_url = (
+            base_url
+            or os.getenv('QUANTUM_LLM_BASE_URL', 'http://localhost:11434')
+        ).rstrip('/')
+        self.default_model = (
+            default_model
+            or os.getenv('QUANTUM_LLM_DEFAULT_MODEL', 'phi3')
+        )
+        self.timeout = (
+            timeout
+            or int(os.getenv('QUANTUM_LLM_TIMEOUT', '60'))
+        )
+
+    def generate(
+        self,
+        prompt: str,
+        model: Optional[str] = None,
+        system: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        response_format: Optional[str] = None,
+        timeout: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Call Ollama /api/generate for single-turn completion.
+
+        Args:
+            prompt: The prompt text
+            model: Model name (falls back to default_model)
+            system: Optional system prompt
+            temperature: Sampling temperature (0.0-2.0)
+            max_tokens: Maximum tokens to generate
+            response_format: "text" or "json"
+            timeout: Request timeout in seconds
+
+        Returns:
+            Dict with keys: success, data (response text), model, error
+        """
+        model = model or self.default_model
+        timeout = timeout or self.timeout
+
+        payload: Dict[str, Any] = {
+            "model": model,
+            "prompt": prompt,
+            "stream": False,
+        }
+
+        if system:
+            payload["system"] = system
+
+        options: Dict[str, Any] = {}
+        if temperature is not None:
+            options["temperature"] = temperature
+        if max_tokens is not None:
+            options["num_predict"] = max_tokens
+        if options:
+            payload["options"] = options
+
+        if response_format == "json":
+            payload["format"] = "json"
+
+        try:
+            url = f"{self.base_url}/api/generate"
+            logger.debug(f"LLM generate request: model={model}, url={url}")
+
+            resp = requests.post(url, json=payload, timeout=timeout)
+            resp.raise_for_status()
+
+            data = resp.json()
+            response_text = data.get("response", "")
+
+            result = {
+                "success": True,
+                "data": response_text,
+                "model": data.get("model", model),
+                "done": data.get("done", True),
+                "total_duration": data.get("total_duration"),
+                "eval_count": data.get("eval_count"),
+                "error": None,
+            }
+
+            # If JSON format requested, try to parse
+            if response_format == "json":
+                try:
+                    result["parsed"] = json.loads(response_text)
+                except json.JSONDecodeError:
+                    result["parsed"] = None
+
+            return result
+
+        except requests.ConnectionError:
+            raise LLMError(
+                f"Cannot connect to Ollama at {self.base_url}. "
+                "Ensure Ollama is running (ollama serve)"
+            )
+        except requests.Timeout:
+            raise LLMError(
+                f"LLM request timed out after {timeout}s. "
+                "Try increasing timeout or using a smaller model"
+            )
+        except requests.HTTPError as e:
+            raise LLMError(f"Ollama API error: {e.response.status_code} - {e.response.text}")
+        except Exception as e:
+            raise LLMError(f"LLM generate error: {e}")
+
+    def chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        response_format: Optional[str] = None,
+        timeout: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Call Ollama /api/chat for multi-turn conversation.
+
+        Args:
+            messages: List of {"role": "...", "content": "..."} dicts
+            model: Model name (falls back to default_model)
+            temperature: Sampling temperature (0.0-2.0)
+            max_tokens: Maximum tokens to generate
+            response_format: "text" or "json"
+            timeout: Request timeout in seconds
+
+        Returns:
+            Dict with keys: success, data (response text), model, error
+        """
+        model = model or self.default_model
+        timeout = timeout or self.timeout
+
+        payload: Dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "stream": False,
+        }
+
+        options: Dict[str, Any] = {}
+        if temperature is not None:
+            options["temperature"] = temperature
+        if max_tokens is not None:
+            options["num_predict"] = max_tokens
+        if options:
+            payload["options"] = options
+
+        if response_format == "json":
+            payload["format"] = "json"
+
+        try:
+            url = f"{self.base_url}/api/chat"
+            logger.debug(f"LLM chat request: model={model}, url={url}, messages={len(messages)}")
+
+            resp = requests.post(url, json=payload, timeout=timeout)
+            resp.raise_for_status()
+
+            data = resp.json()
+            message = data.get("message", {})
+            response_text = message.get("content", "")
+
+            result = {
+                "success": True,
+                "data": response_text,
+                "model": data.get("model", model),
+                "role": message.get("role", "assistant"),
+                "done": data.get("done", True),
+                "total_duration": data.get("total_duration"),
+                "eval_count": data.get("eval_count"),
+                "error": None,
+            }
+
+            if response_format == "json":
+                try:
+                    result["parsed"] = json.loads(response_text)
+                except json.JSONDecodeError:
+                    result["parsed"] = None
+
+            return result
+
+        except requests.ConnectionError:
+            raise LLMError(
+                f"Cannot connect to Ollama at {self.base_url}. "
+                "Ensure Ollama is running (ollama serve)"
+            )
+        except requests.Timeout:
+            raise LLMError(
+                f"LLM chat request timed out after {timeout}s. "
+                "Try increasing timeout or using a smaller model"
+            )
+        except requests.HTTPError as e:
+            raise LLMError(f"Ollama API error: {e.response.status_code} - {e.response.text}")
+        except Exception as e:
+            raise LLMError(f"LLM chat error: {e}")
+
+    def list_models(self) -> Dict[str, Any]:
+        """
+        List available models from Ollama /api/tags.
+
+        Returns:
+            Dict with "models" list
+        """
+        try:
+            resp = requests.get(f"{self.base_url}/api/tags", timeout=10)
+            resp.raise_for_status()
+            return resp.json()
+        except requests.ConnectionError:
+            raise LLMError(f"Cannot connect to Ollama at {self.base_url}")
+        except Exception as e:
+            raise LLMError(f"Error listing models: {e}")
+
+    def pull_model(self, model_name: str) -> Dict[str, Any]:
+        """
+        Pull a model from Ollama registry via /api/pull.
+
+        Args:
+            model_name: Name of the model to pull (e.g. "phi3", "mistral")
+
+        Returns:
+            Dict with pull status
+        """
+        try:
+            resp = requests.post(
+                f"{self.base_url}/api/pull",
+                json={"name": model_name, "stream": False},
+                timeout=600  # Model downloads can take a while
+            )
+            resp.raise_for_status()
+            return {"success": True, "model": model_name}
+        except requests.ConnectionError:
+            raise LLMError(f"Cannot connect to Ollama at {self.base_url}")
+        except Exception as e:
+            raise LLMError(f"Error pulling model {model_name}: {e}")
+
+    def test_connection(self) -> Dict[str, Any]:
+        """
+        Test connection to Ollama server.
+
+        Returns:
+            Dict with online status and available models
+        """
+        try:
+            resp = requests.get(f"{self.base_url}/api/tags", timeout=5)
+            resp.raise_for_status()
+            data = resp.json()
+            models = [m.get("name", "") for m in data.get("models", [])]
+            return {
+                "online": True,
+                "url": self.base_url,
+                "models": models,
+                "model_count": len(models)
+            }
+        except Exception:
+            return {
+                "online": False,
+                "url": self.base_url,
+                "models": [],
+                "model_count": 0
+            }

quantum/runtime/local_server.py

@@ -0,0 +1,28 @@
+"""The application's server on a free local port, for renderers that are not a browser.
+
+`quantum console` (UI-3) and `quantum desktop` (UI-4) open the whole
+application — pages, actions, sessions — through the same server that
+`quantum start` runs. Only the drawing differs; nothing of a page's logic runs
+anywhere else.
+"""
+
+import logging
+import threading
+from contextlib import contextmanager
+from typing import Iterator
+
+
+@contextmanager
+def local_server(config_path: str = 'quantum.config.yaml') -> Iterator[str]:
+    """Serve the application on 127.0.0.1 (a free port) in a thread; yield its base URL."""
+    from werkzeug.serving import make_server
+    from quantum.runtime.web_server import QuantumWebServer
+
+    logging.getLogger('werkzeug').setLevel(logging.ERROR)
+    app = QuantumWebServer(config_path).app
+    servidor = make_server('127.0.0.1', 0, app, threaded=True)
+    threading.Thread(target=servidor.serve_forever, daemon=True).start()
+    try:
+        yield f'http://127.0.0.1:{servidor.server_port}/'
+    finally:
+        servidor.shutdown()

quantum/runtime/logging_setup.py

@@ -0,0 +1,141 @@
+"""
+Quantum Logging Setup - Bridges quantum.config.yaml logging section to Python logging.
+
+Configures the 'quantum' root logger with colored console output and file logging.
+All child loggers (quantum.server, quantum.parser, quantum.runtime, quantum.errors)
+inherit the configured handlers.
+"""
+
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+
+class ColoredFormatter(logging.Formatter):
+    """Formatter that adds ANSI color codes based on log level."""
+
+    COLORS = {
+        logging.DEBUG: '\033[36m',      # cyan
+        logging.INFO: '\033[32m',       # green
+        logging.WARNING: '\033[33m',    # yellow
+        logging.ERROR: '\033[31m',      # red
+        logging.CRITICAL: '\033[41m',   # red background
+    }
+    RESET = '\033[0m'
+
+    def __init__(self, fmt=None, datefmt=None, use_color=True):
+        super().__init__(fmt, datefmt)
+        self.use_color = use_color
+
+    def format(self, record):
+        if self.use_color:
+            color = self.COLORS.get(record.levelno, '')
+            reset = self.RESET
+            record.levelname = f"{color}{record.levelname:<8}{reset}"
+        else:
+            record.levelname = f"{record.levelname:<8}"
+        return super().format(record)
+
+
+def _supports_color() -> bool:
+    """Detect whether the terminal supports ANSI color codes."""
+    if os.environ.get('NO_COLOR'):
+        return False
+    if os.environ.get('FORCE_COLOR'):
+        return True
+    if not hasattr(sys.stderr, 'isatty'):
+        return False
+    if sys.stderr.isatty():
+        return True
+    # Windows Terminal sets WT_SESSION
+    if os.environ.get('WT_SESSION'):
+        return True
+    return False
+
+
+def setup_logging(config: Dict[str, Any]) -> logging.Logger:
+    """
+    Configure the 'quantum' root logger from the config dictionary.
+
+    Reads config['logging'] for level, format, console, file, filename.
+    Reads config['paths']['logs'] for the log directory.
+
+    Args:
+        config: Full quantum configuration dictionary
+
+    Returns:
+        The configured 'quantum' root logger
+    """
+    log_config = config.get('logging', {})
+    paths_config = config.get('paths', {})
+
+    level_name = log_config.get('level', 'INFO').upper()
+    level = getattr(logging, level_name, logging.INFO)
+    enable_console = log_config.get('console', True)
+    enable_file = log_config.get('file', True)
+    filename = log_config.get('filename', 'quantum.log')
+    log_dir = paths_config.get('logs', './logs')
+
+    # Get or create the quantum root logger and clear existing handlers
+    logger = logging.getLogger('quantum')
+    logger.setLevel(level)
+    logger.handlers.clear()
+
+    datefmt = '%Y-%m-%d %H:%M:%S'
+    # CFG-3: logging.format was documented here and never read.
+    plain_fmt = log_config.get('format') or '%(asctime)s %(levelname)-8s %(name)s - %(message)s'
+
+    # Console handler with color support
+    if enable_console:
+        console_handler = logging.StreamHandler(sys.stderr)
+        console_handler.setLevel(level)
+        use_color = _supports_color()
+        colored_fmt = log_config.get('format') or '%(asctime)s %(levelname)s %(name)s - %(message)s'
+        formatter = ColoredFormatter(colored_fmt, datefmt=datefmt, use_color=use_color)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+    # File handler with plain formatter
+    if enable_file:
+        log_path = Path(log_dir)
+        log_path.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(
+            str(log_path / filename), encoding='utf-8'
+        )
+        file_handler.setLevel(level)
+        file_handler.setFormatter(logging.Formatter(plain_fmt, datefmt=datefmt))
+        logger.addHandler(file_handler)
+
+    # Suppress werkzeug's noisy default request logging
+    logging.getLogger('werkzeug').setLevel(logging.WARNING)
+
+    # Inject into LoggingService singleton to prevent duplicate handlers
+    try:
+        from quantum.core.features.logging.src.runtime import LoggingService
+        LoggingService.configure_from_external(logger)
+    except Exception:
+        pass  # LoggingService may not be available
+
+    return logger
+
+
+def get_status_color(code: int) -> str:
+    """Return ANSI color escape for an HTTP status code."""
+    if not _supports_color():
+        return ''
+    if code < 300:
+        return '\033[32m'   # green
+    if code < 400:
+        return '\033[33m'   # yellow
+    if code < 500:
+        return '\033[31m'   # red
+    return '\033[91m'       # bright red
+
+
+def get_reset() -> str:
+    """Return ANSI reset escape if color is supported."""
+    if not _supports_color():
+        return ''
+    return '\033[0m'