synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/core/json.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+
+
+def strip_json_comments(raw: str) -> str:
+    """Remove // and /* */ comments from JSONC text."""
+    result: list[str] = []
+    in_string = False
+    in_line_comment = False
+    in_block_comment = False
+    escape = False
+    i = 0
+    length = len(raw)
+    while i < length:
+        char = raw[i]
+        next_char = raw[i + 1] if i + 1 < length else ""
+
+        if in_line_comment:
+            if char == "\n":
+                in_line_comment = False
+                result.append(char)
+            i += 1
+            continue
+
+        if in_block_comment:
+            if char == "*" and next_char == "/":
+                in_block_comment = False
+                i += 2
+            else:
+                i += 1
+            continue
+
+        if in_string:
+            result.append(char)
+            if char == "\"" and not escape:
+                in_string = False
+            escape = (char == "\\") and not escape
+            i += 1
+            continue
+
+        if char == "/" and next_char == "/":
+            in_line_comment = True
+            i += 2
+            continue
+
+        if char == "/" and next_char == "*":
+            in_block_comment = True
+            i += 2
+            continue
+
+        if char == "\"":
+            in_string = True
+            escape = False
+
+        result.append(char)
+        i += 1
+
+    return "".join(result)
+
+
+def create_and_write_json(path: Path, content: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(content, indent=2) + "\n")
+
+
+def load_json_to_dict(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(strip_json_comments(path.read_text()))
+    except (json.JSONDecodeError, OSError):
+        return {}

synth_ai/core/log_filter.py

@@ -0,0 +1,99 @@
+"""Utilities for filtering noisy logs from stdout/stderr."""
+
+from __future__ import annotations
+
+import re
+import sys
+from typing import TextIO
+
+# Patterns for noisy logs that should be filtered out
+# Using simple substring matching for better performance and broader matching
+_NOISY_LOG_SUBSTRINGS = [
+    'codex_otel::otel_event_manager',
+    'event.kind=response.reasoning_summary_text.delta',
+    'event.name="codex.sse_event"',
+    'codex_otel',
+]
+
+# Compiled regex patterns for more complex matching
+_NOISY_LOG_PATTERNS = [
+    # Filter all codex_otel verbose SSE event logs (most aggressive - catches everything from this module)
+    re.compile(r'.*codex_otel::otel_event_manager.*', re.IGNORECASE),
+    # Filter reasoning summary delta events
+    re.compile(r'.*event\.kind=response\.reasoning_summary_text\.delta.*', re.IGNORECASE),
+    # Filter any codex.sse_event logs
+    re.compile(r'.*event\.name="codex\.sse_event".*', re.IGNORECASE),
+    # Also catch logs that start with timestamp and have codex_otel
+    re.compile(r'^\d{4}-\d{2}-\d{2}T.*codex_otel.*', re.IGNORECASE),
+]
+
+
+def should_filter_log_line(line: str) -> bool:
+    """Check if a log line should be filtered out.
+    
+    Filters out noisy logs like verbose codex_otel SSE event logs.
+    Uses both substring matching (faster) and regex (more precise).
+    """
+    if not line.strip():
+        return False
+    
+    # Fast substring check first
+    line_lower = line.lower()
+    for substr in _NOISY_LOG_SUBSTRINGS:
+        if substr.lower() in line_lower:
+            return True
+    
+    # Fallback to regex for edge cases
+    return any(pattern.search(line) for pattern in _NOISY_LOG_PATTERNS)
+
+
+class FilteredStream:
+    """A file-like object that filters noisy log lines before writing."""
+    
+    def __init__(self, stream: TextIO):
+        self._stream = stream
+        self._buffer = ""
+        # Store original write method to avoid recursion
+        self._original_write = stream.write
+    
+    def write(self, text: str) -> int:
+        """Write text, filtering out noisy log lines."""
+        # Check if entire text matches filter (for unbuffered writes)
+        if should_filter_log_line(text.strip()):
+            return len(text)
+        
+        # Buffer incomplete lines
+        self._buffer += text
+        lines = self._buffer.split('\n')
+        # Keep the last incomplete line in buffer
+        self._buffer = lines[-1]
+        # Process complete lines
+        written = 0
+        for line in lines[:-1]:
+            if not should_filter_log_line(line):
+                written += self._original_write(line + '\n')
+        return len(text)
+    
+    def flush(self) -> None:
+        """Flush any remaining buffered content."""
+        if self._buffer and not should_filter_log_line(self._buffer):
+            self._original_write(self._buffer)
+            self._buffer = ""
+        self._stream.flush()
+    
+    def __getattr__(self, name: str):
+        """Delegate other attributes to the underlying stream."""
+        return getattr(self._stream, name)
+
+
+def install_log_filter() -> None:
+    """Install stdout/stderr filters to suppress noisy logs.
+    
+    This wraps sys.stdout and sys.stderr to filter out verbose
+    codex_otel logs before they're printed.
+    """
+    if not isinstance(sys.stdout, FilteredStream):
+        sys.stdout = FilteredStream(sys.stdout)  # type: ignore[assignment]
+    if not isinstance(sys.stderr, FilteredStream):
+        sys.stderr = FilteredStream(sys.stderr)  # type: ignore[assignment]
+

synth_ai/core/logging.py

@@ -0,0 +1,82 @@
+"""Logging utilities for Synth AI SDK.
+
+This module provides structured logging setup for SDK modules.
+Uses standard logging library, not print statements.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from typing import Literal
+
+# SDK logger name prefix
+SDK_LOGGER_NAME = "synth_ai"
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger with the synth_ai namespace.
+
+    Args:
+        name: Module name (will be prefixed with synth_ai.)
+
+    Returns:
+        Configured logger instance
+    """
+    if name.startswith(SDK_LOGGER_NAME):
+        return logging.getLogger(name)
+    return logging.getLogger(f"{SDK_LOGGER_NAME}.{name}")
+
+
+def configure_logging(
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] | None = None,
+    *,
+    format_style: Literal["simple", "detailed"] = "simple",
+) -> None:
+    """Configure SDK-wide logging.
+
+    Args:
+        level: Log level (or read from SYNTH_LOG_LEVEL env var)
+        format_style: 'simple' for minimal output, 'detailed' for timestamps
+    """
+    if level is None:
+        level_str = os.environ.get("SYNTH_LOG_LEVEL", "INFO").upper()
+        if level_str not in ("DEBUG", "INFO", "WARNING", "ERROR"):
+            level_str = "INFO"
+        level = level_str  # type: ignore[assignment]
+
+    # After assignment, level is guaranteed to be str
+    assert isinstance(level, str), "level must be str at this point"
+    log_level = getattr(logging, level)
+
+    if format_style == "detailed":
+        fmt = "%(asctime)s | %(name)s | %(levelname)s | %(message)s"
+    else:
+        fmt = "%(levelname)s: %(message)s"
+
+    # Configure the SDK root logger
+    logger = logging.getLogger(SDK_LOGGER_NAME)
+    logger.setLevel(log_level)
+
+    # Only add handler if none exist (avoid duplicates)
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stderr)
+        handler.setLevel(log_level)
+        handler.setFormatter(logging.Formatter(fmt))
+        logger.addHandler(handler)
+
+
+def suppress_noisy_loggers() -> None:
+    """Suppress verbose third-party loggers."""
+    for name in ("httpx", "httpcore", "aiohttp", "urllib3"):
+        logging.getLogger(name).setLevel(logging.WARNING)
+
+
+__all__ = [
+    "get_logger",
+    "configure_logging",
+    "suppress_noisy_loggers",
+    "SDK_LOGGER_NAME",
+]
+

synth_ai/core/paths.py

@@ -0,0 +1,107 @@
+import os
+import shutil
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+
+def is_file_type(path: Path, type: str) -> bool:
+    if not type.startswith('.'):
+        type = '.' + type
+    return path.is_file() and path.suffix == type
+
+
+def validate_file_type(path: Path, type: str) -> None:
+    if not is_file_type(path, type):
+        raise ValueError(f"{path} is not a {type} file")
+    return None
+
+
+def is_hidden_path(path: Path, root: Path) -> bool:
+    try:
+        relative = path.relative_to(root)
+    except ValueError:
+        relative = path
+    return any(part.startswith('.') for part in relative.parts)
+
+
+def get_bin_path(name: str) -> Path | None:
+    path = shutil.which(name)
+    return Path(path) if path else None
+
+
+def get_env_file_paths(base_dir: str | Path = '.') -> list[Path]:
+    base = Path(base_dir).resolve()
+    return [path for path in base.rglob(".env*") if path.is_file()]
+
+
+def get_home_config_file_paths(
+    dir_name: str,
+    file_extension: str = "json"
+) -> list[Path]:
+    dir = Path.home() / dir_name
+    if not dir.exists():
+        return []
+    return [path for path in dir.glob(f"*.{file_extension}") if path.is_file()]
+
+
+def find_config_path(
+    bin: Path,
+    home_subdir: str,
+    filename: str,
+) -> Path | None:
+    home_candidate = Path.home() / home_subdir / filename
+    if home_candidate.exists():
+        return home_candidate
+    local_candidate = Path(bin).parent / home_subdir / filename
+    if local_candidate.exists():
+        return local_candidate
+    return None
+
+
+def configure_import_paths(
+    app: Path,
+    repo_root: Path | None = REPO_ROOT
+) -> None:
+    app_dir = app.parent.resolve()
+
+    initial_dirs: list[Path] = [app_dir]
+    if (app_dir / "__init__.py").exists():
+        initial_dirs.append(app_dir.parent.resolve())
+    if repo_root:
+        initial_dirs.append(repo_root)
+
+    unique_dirs: list[str] = []
+    for dir in initial_dirs:
+        dir_str = str(dir)
+        if dir_str and dir_str not in unique_dirs:
+            unique_dirs.append(dir_str)
+
+    existing_pythonpath_dirs = os.environ.get("PYTHONPATH")
+    if existing_pythonpath_dirs:
+        for segment in existing_pythonpath_dirs.split(os.pathsep):
+            if segment and segment not in unique_dirs:
+                unique_dirs.append(segment)
+
+    os.environ["PYTHONPATH"] = os.pathsep.join(unique_dirs)
+
+    for dir in reversed(unique_dirs):
+        if dir and dir not in sys.path:
+            sys.path.insert(0, dir)
+
+
+def cleanup_paths(*, file: Path, dir: Path) -> None:
+    if not file.is_relative_to(dir):
+        raise ValueError(f"{file} is not inside {dir}")
+    file.unlink(missing_ok=True)
+    shutil.rmtree(dir, ignore_errors=True)
+
+
+def print_paths_formatted(entries: list[tuple]) -> None:
+    for i, entry in enumerate(entries, start=1):
+        *item_parts, mtime = entry
+        suffix = " ← most recent" if i == 1 else ""
+        timestamp = f"modified {mtime}" if mtime else ""
+        start = f"[{item_parts[0]}] {item_parts[1]}" if len(item_parts) == 2 else str(item_parts[0])
+        print(f"{start}  |  {timestamp}{suffix}")

synth_ai/core/pricing.py

@@ -0,0 +1,109 @@
+"""Model pricing utilities for Synth AI SDK.
+
+This module provides per-token pricing data for supported models,
+used by status commands and cost estimation.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TokenRates:
+    """Per-token pricing rates in USD."""
+
+    input_usd: float
+    output_usd: float
+
+
+# Pricing data - updated Nov 2025
+# Organized by provider -> model -> rates
+MODEL_PRICES: dict[str, dict[str, TokenRates]] = {
+    "openai": {
+        # GPT-5 family
+        "gpt-5": TokenRates(input_usd=0.00000125, output_usd=0.00001000),
+        "gpt-5-mini": TokenRates(input_usd=0.00000025, output_usd=0.00000200),
+        "gpt-5-nano": TokenRates(input_usd=0.00000005, output_usd=0.00000040),
+        # GPT-4.1 family
+        "gpt-4.1": TokenRates(input_usd=0.00000200, output_usd=0.00000800),
+        "gpt-4.1-mini": TokenRates(input_usd=0.00000040, output_usd=0.00000160),
+        "gpt-4.1-nano": TokenRates(input_usd=0.00000010, output_usd=0.00000040),
+        # GPT-4o family
+        "gpt-4o": TokenRates(input_usd=0.00000250, output_usd=0.00001000),
+        "gpt-4o-mini": TokenRates(input_usd=0.00000015, output_usd=0.00000060),
+    },
+    "anthropic": {
+        "claude-3-5-sonnet": TokenRates(input_usd=0.000003, output_usd=0.000015),
+        "claude-3-5-haiku": TokenRates(input_usd=0.00000025, output_usd=0.00000125),
+        "claude-3-opus": TokenRates(input_usd=0.000015, output_usd=0.000075),
+    },
+    "google": {
+        "gemini-2.5-pro": TokenRates(input_usd=0.00000125, output_usd=0.00001000),
+        "gemini-2.5-flash": TokenRates(input_usd=0.00000030, output_usd=0.00000250),
+        "gemini-2.5-flash-lite": TokenRates(input_usd=0.00000010, output_usd=0.00000040),
+    },
+    "groq": {
+        "llama-3.3-70b-versatile": TokenRates(
+            input_usd=0.000000590, output_usd=0.000000790
+        ),
+        "llama-3.1-8b-instant": TokenRates(
+            input_usd=0.000000050, output_usd=0.000000080
+        ),
+    },
+}
+
+
+def get_token_rates(model: str, provider: str | None = None) -> TokenRates | None:
+    """Get token rates for a model.
+
+    Args:
+        model: Model identifier (e.g., "gpt-4o")
+        provider: Optional provider hint (e.g., "openai")
+
+    Returns:
+        TokenRates if found, None otherwise
+    """
+    if provider:
+        provider_rates = MODEL_PRICES.get(provider.lower())
+        if provider_rates:
+            return provider_rates.get(model.lower())
+
+    # Search all providers
+    for provider_rates in MODEL_PRICES.values():
+        if model.lower() in provider_rates:
+            return provider_rates[model.lower()]
+
+    return None
+
+
+def estimate_cost(
+    input_tokens: int,
+    output_tokens: int,
+    model: str,
+    provider: str | None = None,
+) -> float | None:
+    """Estimate cost for token usage.
+
+    Args:
+        input_tokens: Number of input tokens
+        output_tokens: Number of output tokens
+        model: Model identifier
+        provider: Optional provider hint
+
+    Returns:
+        Estimated cost in USD, or None if model not found
+    """
+    rates = get_token_rates(model, provider)
+    if rates is None:
+        return None
+    return (input_tokens * rates.input_usd) + (output_tokens * rates.output_usd)
+
+
+__all__ = [
+    "TokenRates",
+    "MODEL_PRICES",
+    "get_token_rates",
+    "estimate_cost",
+]
+

synth_ai/core/process.py

@@ -0,0 +1,233 @@
+import os
+import signal
+import socket
+import time
+from collections.abc import Iterable
+from typing import Any
+
+__all__ = [
+    "ensure_local_port_available",
+    "popen_capture",
+    "popen_stream",
+    "popen_stream_capture",
+    "should_filter_log_line",
+    "get_subprocess_env",
+]
+
+# Import log filter to avoid duplication
+from synth_ai.core.log_filter import should_filter_log_line
+
+
+def get_subprocess_env(extra_env: dict[str, Any] | None = None) -> dict[str, str]:
+    """Get environment dict for subprocesses with RUST_LOG set to suppress noisy logs.
+    
+    Always includes RUST_LOG="codex_otel::otel_event_manager=warn" unless overridden.
+    """
+    env = os.environ.copy()
+    # Set RUST_LOG to suppress noisy codex_otel logs by default
+    if "RUST_LOG" not in env:
+        env["RUST_LOG"] = "codex_otel::otel_event_manager=warn"
+    if extra_env:
+        env.update(extra_env)
+    return env
+
+
+def popen_capture(
+    cmd: list[str], cwd: str | None = None, env: dict[str, Any] | None = None
+) -> tuple[int, str]:
+    """Execute a subprocess and capture combined stdout/stderr."""
+    import subprocess
+
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            cwd=cwd,
+            env=get_subprocess_env(env),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        out, _ = proc.communicate()
+        return int(proc.returncode or 0), out or ""
+    except Exception as exc:
+        return 1, str(exc)
+
+
+def popen_stream(
+    cmd: list[str], cwd: str | None = None, env: dict[str, Any] | None = None
+) -> int:
+    """Stream subprocess output line-by-line to stdout for real-time feedback."""
+    import subprocess
+    import threading
+
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            cwd=cwd,
+            env=get_subprocess_env(env),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+    except Exception as exc:
+        print(f"Failed to launch {' '.join(cmd)}: {exc}")
+        return 1
+
+    def _pump(stdout) -> None:
+        try:
+            for line in stdout:
+                if not should_filter_log_line(line):
+                    print(line.rstrip())
+        except Exception:
+            pass
+
+    if proc.stdout is not None:
+        t = threading.Thread(target=_pump, args=(proc.stdout,), daemon=True)
+        t.start()
+        proc.wait()
+        t.join(timeout=1.0)
+    else:
+        proc.wait()
+    return int(proc.returncode or 0)
+
+
+def popen_stream_capture(
+    cmd: list[str], cwd: str | None = None, env: dict[str, Any] | None = None
+) -> tuple[int, str]:
+    """Stream subprocess output to stdout and also capture it into a buffer."""
+    import subprocess
+    import threading
+
+    buf_lines: list[str] = []
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            cwd=cwd,
+            env=get_subprocess_env(env),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+    except Exception as exc:
+        print(f"Failed to launch {' '.join(cmd)}: {exc}")
+        return 1, ""
+
+    def _pump(stdout) -> None:
+        try:
+            for line in stdout:
+                line = line.rstrip()
+                if not should_filter_log_line(line):
+                    print(line)
+                    buf_lines.append(line)
+        except Exception:
+            pass
+
+    if proc.stdout is not None:
+        t = threading.Thread(target=_pump, args=(proc.stdout,), daemon=True)
+        t.start()
+        proc.wait()
+        t.join(timeout=1.0)
+    else:
+        proc.wait()
+    return int(proc.returncode or 0), "\n".join(buf_lines)
+
+
+def _list_process_ids(port: int) -> list[int]:
+    try:
+        import subprocess
+
+        out = subprocess.run(
+            ["lsof", "-ti", f"TCP:{port}"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if not out.stdout:
+            return []
+        result: list[int] = []
+        for token in out.stdout.strip().splitlines():
+            token = token.strip()
+            if token.isdigit():
+                result.append(int(token))
+        return result
+    except Exception:
+        return []
+
+
+def _terminate_pids(pids: Iterable[int], *, aggressive: bool) -> bool:
+    terminated_any = False
+    for pid in pids:
+        try:
+            os.kill(pid, signal.SIGTERM)
+            terminated_any = True
+        except Exception as exc:
+            print(f"Failed to terminate PID {pid}: {exc}")
+    if terminated_any:
+        time.sleep(1.0)
+
+    if aggressive and pids:
+        still_running = []
+        for pid in pids:
+            try:
+                os.kill(pid, 0)
+            except OSError:
+                continue
+            still_running.append(pid)
+        if still_running:
+            for pid in still_running:
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                except Exception as exc:
+                    print(f"Failed to force terminate PID {pid}: {exc}")
+            time.sleep(0.5)
+    return terminated_any
+
+
+def ensure_local_port_available(host: str, port: int, *, force: bool = False) -> bool:
+    """Ensure ``host:port`` is free before starting a local server."""
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(0.5)
+        in_use = sock.connect_ex((host, port)) == 0
+    if not in_use:
+        return True
+
+    print(f"Port {port} on {host} is already in use.")
+    pids = _list_process_ids(port)
+
+    if pids:
+        print("Found processes using this port:")
+        for pid in pids:
+            print(f"  PID {pid}")
+    else:
+        print("Could not automatically identify the owning process.")
+
+    if not force:
+        try:
+            choice = input(f"Stop the existing process on port {port}? [y/N]: ").strip().lower() or "n"
+        except Exception:
+            choice = "n"
+        if not choice.startswith("y"):
+            print("Aborting; stop the running server and try again.")
+            return False
+    else:
+        print("Attempting to terminate the existing process...")
+
+    if pids:
+        _terminate_pids(pids, aggressive=force)
+    else:
+        print("Unable to determine owning process. Please stop it manually and retry.")
+        return False
+
+    for _ in range(10):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(0.5)
+            if sock.connect_ex((host, port)) != 0:
+                print("Port is now available.")
+                return True
+        time.sleep(0.5)
+
+    print("Port still in use after terminating processes.")
+    return False