synth-ai 0.2.16__py3-none-any.whl → 0.2.19__py3-none-any.whl

synth_ai/tracing_v3/turso/native_manager.py

@@ -14,8 +14,11 @@ import re
 from collections.abc import Callable
 from dataclasses import asdict, dataclass
 from datetime import UTC, datetime
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
+from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
 
+import httpx
 import libsql
 from sqlalchemy.engine import make_url
 
@@ -60,36 +63,70 @@ class _ConnectionTarget:
     auth_token: str | None = None
 
 
+def _strip_auth_component(url: str) -> tuple[str, str | None]:
+    """Remove auth_token query parameter from URL, returning the token separately."""
+    parsed = urlparse(url)
+    if not parsed.query:
+        return url, None
+
+    params = dict(parse_qsl(parsed.query, keep_blank_values=True))
+    token = params.pop("auth_token", None)
+    query = urlencode(params, doseq=True)
+    sanitised = urlunparse(parsed._replace(query=query))
+    return sanitised, token
+
+
 def _resolve_connection_target(db_url: str | None, auth_token: str | None) -> _ConnectionTarget:
     """Normalise the configured database URL."""
     url = db_url or CONFIG.db_url
-
-    # Fast-path local SQLite URLs (`sqlite+aiosqlite:///path/to/db`)
-    if url.startswith("sqlite+aiosqlite:///"):
-        return _ConnectionTarget(database=url.replace("sqlite+aiosqlite:///", ""), auth_token=auth_token)
+    sanitised, token_from_url = _strip_auth_component(url)
+    effective_token = auth_token or token_from_url or CONFIG.auth_token
 
     # SQLAlchemy-compatible libsql scheme (`sqlite+libsql://<endpoint or path>`)
-    if url.startswith("sqlite+libsql://"):
-        target = url.replace("sqlite+libsql://", "", 1)
-        return _ConnectionTarget(database=target, sync_url=target if target.startswith("libsql://") else None, auth_token=auth_token)
+    if sanitised.startswith("sqlite+libsql://"):
+        raise RuntimeError("sqlite+libsql scheme is no longer supported; use libsql://")
+
+    # Plain SQLite files: file://, /absolute/path, or relative path
+    # libsql.connect() handles these without sync_url or auth_token
+    if sanitised.startswith("file://") or sanitised.startswith("/") or "://" not in sanitised:
+        # Strip file:// prefix if present, libsql.connect handles both formats
+        db_path = sanitised.replace("file://", "") if sanitised.startswith("file://") else sanitised
+        return _ConnectionTarget(database=db_path, sync_url=None, auth_token=None)
 
     # Native libsql URLs (`libsql://...`).
-    if url.startswith("libsql://"):
-        return _ConnectionTarget(database=url, sync_url=url, auth_token=auth_token)
+    if sanitised.startswith("libsql://"):
+        return _ConnectionTarget(database=sanitised, sync_url=sanitised, auth_token=effective_token)
 
     # Fallback to SQLAlchemy URL parsing for anything else we missed.
     try:
-        parsed = make_url(url)
-        if parsed.drivername.startswith("sqlite") and parsed.database:
-            return _ConnectionTarget(database=parsed.database, auth_token=auth_token)
-        if parsed.drivername.startswith("libsql"):
+        parsed = make_url(sanitised)
+        driver = parsed.drivername.lower()
+        if driver.startswith("sqlite"):
+            database = parsed.database or ""
+            if database and database not in {":memory:", ":memory"}:
+                # Absolute paths are passed through; relative paths are resolved to cwd
+                if database.startswith("/"):
+                    db_path = database
+                else:
+                    db_path = str(Path(database).expanduser().resolve())
+            elif database in {":memory:", ":memory"}:
+                db_path = ":memory:"
+            else:
+                raise RuntimeError("SQLite URL missing database path.")
+            return _ConnectionTarget(database=db_path, sync_url=None, auth_token=None)
+        if driver.startswith("libsql"):
             database = parsed.render_as_string(hide_password=False)
-            return _ConnectionTarget(database=database, sync_url=database, auth_token=auth_token)
+            return _ConnectionTarget(database=database, sync_url=database, auth_token=effective_token)
     except Exception:  # pragma: no cover - defensive guardrail
         logger.debug("Unable to parse db_url via SQLAlchemy", exc_info=True)
 
-    # As a last resort use the raw value (libsql.connect can handle absolute paths).
-    return _ConnectionTarget(database=url, auth_token=auth_token)
+    # Python libsql client uses HTTP API for http:// URLs, not Hrana WebSocket
+    # For local sqld with http:// URL, we need to ensure it points to the HTTP API port
+    # sqld uses two ports: Hrana WebSocket (e.g. 8080) and HTTP API (e.g. 8081)
+    # libsql.connect() with http:// uses HTTP API, so URL should point to HTTP API port
+    if sanitised.startswith(("http://", "https://", "libsql://")):
+        return _ConnectionTarget(database=sanitised, sync_url=sanitised, auth_token=effective_token)
+    raise RuntimeError(f"Unsupported tracing database URL: {sanitised}")
 
 
 def _json_dumps(value: Any) -> str | None:
@@ -350,6 +387,45 @@ class NativeLibsqlTraceManager(TraceStorage):
             if self._initialized:
                 return
 
+            # Fast-fail preflight: if using remote endpoint or local sqld, check health
+            # Skip health check for plain SQLite files (sync_url is None)
+            if self._target.sync_url:
+                try:
+                    parsed = urlparse(self._target.database or "")
+                    # Check for local sqld: http://, https://, or libsql://
+                    if parsed.scheme in ("http", "https", "libsql"):
+                        host_port = parsed.netloc or ""
+                        host = (host_port.split(":", 1)[0] or "").strip().lower()
+                        if host in {"127.0.0.1", "localhost"} and host_port:
+                            # For http:// URLs, the port should already be the HTTP API port
+                            # For libsql:// URLs, we need to calculate health check port
+                            if ":" in host_port:
+                                port = int(host_port.split(":", 1)[1])
+                                if parsed.scheme == "libsql":
+                                    # libsql:// uses Hrana port, health check is on HTTP API port (Hrana + 1)
+                                    health_url = f"http://{host}:{port + 1}/health"
+                                else:
+                                    # http:// already points to HTTP API port
+                                    health_url = f"http://{host}:{port}/health"
+                            else:
+                                health_url = f"http://{host_port}/health"
+                            try:
+                                async with httpx.AsyncClient(timeout=httpx.Timeout(1.0)) as client:
+                                    resp = await client.get(health_url)
+                                if resp.status_code != 200:
+                                    raise RuntimeError(
+                                        f"Tracing backend unhealthy at {health_url} (status={resp.status_code})"
+                                    )
+                            except Exception as exc:  # pragma: no cover - network env dependent
+                                raise RuntimeError(
+                                    f"Tracing backend not reachable at {health_url}. "
+                                    f"Start sqld with both ports: sqld --db-path <path> --hrana-listen-addr {host}:HRANA_PORT --http-listen-addr {host}:HTTP_PORT "
+                                    f"or disable tracing (TASKAPP_TRACING_ENABLED=0)."
+                                ) from exc
+                except Exception:
+                    # Propagate any preflight failure to abort early
+                    raise
+
             # Establish a libsql connection for future native operations.
             self._conn = self._open_connection()
             self._ensure_schema()

synth_ai/types.py

@@ -0,0 +1,8 @@
+import typing
+from typing import Literal
+
+ModelName = Literal[
+    "synth-small",
+    "synth-medium"
+]
+MODEL_NAMES = list(typing.get_args(ModelName))

synth_ai/urls.py

@@ -0,0 +1,11 @@
+# Base URL for all backends
+BACKEND_URL_BASE = "https://agent-learning.onrender.com"
+
+# Synth Research API base (supports OpenAI, Anthropic, and custom formats)
+# Real routes: /api/synth-research/chat/completions, /api/synth-research/messages
+# V1 routes: /api/synth-research/v1/chat/completions, /api/synth-research/v1/messages
+BACKEND_URL_SYNTH_RESEARCH_BASE = BACKEND_URL_BASE + "/api/synth-research"
+
+# Provider-specific URLs (for SDKs that expect standard paths)
+BACKEND_URL_SYNTH_RESEARCH_OPENAI = BACKEND_URL_SYNTH_RESEARCH_BASE + "/v1"  # For OpenAI SDKs (appends /chat/completions)
+BACKEND_URL_SYNTH_RESEARCH_ANTHROPIC = BACKEND_URL_SYNTH_RESEARCH_BASE  # For Anthropic SDKs (appends /v1/messages)

synth_ai/utils/__init__.py

@@ -1,8 +1,18 @@
 from . import task_app_state
+from .agents import write_agents_md
 from .base_url import PROD_BASE_URL_DEFAULT, get_backend_from_env, get_learning_v2_base_url
-from .cli import PromptedChoiceOption, PromptedChoiceType, print_next_step
+from .bin import install_bin, verify_bin
+from .cli import (
+    PromptedChoiceOption,
+    PromptedChoiceType,
+    PromptedPathOption,
+    print_next_step,
+    prompt_choice,
+    prompt_for_path,
+)
 from .env import mask_str, resolve_env_var, write_env_var_to_dotenv, write_env_var_to_json
 from .http import AsyncHttpClient, HTTPError, http_request
+from .json import create_and_write_json, load_json_to_dict, strip_json_comments
 from .modal import (
     ensure_modal_installed,
     ensure_task_app_ready,
@@ -11,6 +21,12 @@ from .modal import (
     is_modal_public_url,
     normalize_endpoint_url,
 )
+from .paths import (
+    find_bin_path,
+    find_config_path,
+    get_env_file_paths,
+    get_home_config_file_paths,
+)
 from .process import ensure_local_port_available, popen_capture, popen_stream, popen_stream_capture
 from .sqld import SQLD_VERSION, find_sqld_binary, install_sqld
 from .task_app_discovery import AppChoice, discover_eval_config_paths, select_app_choice
@@ -50,8 +66,11 @@ __all__ = [
     "PROD_BASE_URL_DEFAULT",
     "PromptedChoiceOption",
     "PromptedChoiceType",
+    "PromptedPathOption",
+    "prompt_for_path",
     "SQLD_VERSION",
     "USER_CONFIG_PATH",
+    "create_and_write_json",
     "current_task_app_id",
     "discover_eval_config_paths",
     "ensure_env_credentials",
@@ -60,14 +79,20 @@ __all__ = [
     "ensure_port_free",
     "ensure_task_app_ready",
     "find_asgi_apps",
+    "find_bin_path",
+    "find_config_path",
     "find_sqld_binary",
     "get_backend_from_env",
+    "get_env_file_paths",
+    "get_home_config_file_paths",
     "get_learning_v2_base_url",
     "http_request",
+    "install_bin",
     "install_sqld",
     "is_local_demo_url",
     "is_modal_public_url",
     "load_demo_dir",
+    "load_json_to_dict",
     "load_template_id",
     "load_user_config",
     "load_user_env",
@@ -84,17 +109,21 @@ __all__ = [
     "popen_stream_capture",
     "preflight_env_key",
     "print_next_step",
+    "prompt_choice",
     "read_task_app_config",
     "record_task_app",
     "resolve_env_var",
     "resolve_task_app_entry",
     "save_user_config",
     "select_app_choice",
+    "strip_json_comments",
     "task_app_config_path",
     "task_app_id_from_path",
     "task_app_state",
     "update_task_app_entry",
     "update_user_config",
+    "verify_bin",
+    'write_agents_md',
     "write_env_var_to_dotenv",
     "write_env_var_to_json",
     "write_task_app_config",

synth_ai/utils/agents.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+
+AGENTS_TEXT = """
+sinf
+"""
+SYNTH_DIV_START = "### --- SYNTH SECTION START ---"
+SYNTH_DIV_END = "### ---- SYNTH SECTION END ----"
+
+
+def _render_block() -> str:
+    return f"{SYNTH_DIV_START}\n{AGENTS_TEXT}\n{SYNTH_DIV_END}"
+
+
+def _append_block(prefix: str) -> str:
+    prefix = prefix.rstrip()
+    block = _render_block()
+    if prefix:
+        return f"{prefix}\n\n{block}\n"
+    return f"{block}\n"
+
+
+def write_agents_md() -> None:
+    path = Path.cwd() / "AGENTS.md"
+    if not path.exists():
+        path.write_text(_append_block(""), encoding="utf-8")
+        return
+
+    file_text = path.read_text(encoding="utf-8")
+
+    # Remove orphan end markers first (end markers without a preceding start marker)
+    cleaned = file_text
+    end_pos = cleaned.find(SYNTH_DIV_END)
+    start_pos = cleaned.find(SYNTH_DIV_START)
+    
+    # If there's an end marker before any start marker
+    if end_pos != -1 and (start_pos == -1 or end_pos < start_pos):
+        if start_pos == -1:
+            # No start markers at all - remove everything including content before orphan
+            cleaned = cleaned[end_pos + len(SYNTH_DIV_END):].lstrip()
+        else:
+            # There are start markers after the orphan - preserve content before orphan
+            before_orphan = cleaned[:end_pos].rstrip()
+            after_orphan = cleaned[end_pos + len(SYNTH_DIV_END):].lstrip()
+            cleaned = "\n\n".join(filter(None, [before_orphan, after_orphan]))
+    
+    # Find the first start and last end marker to consolidate multiple sections
+    first_start = cleaned.find(SYNTH_DIV_START)
+    last_end = cleaned.rfind(SYNTH_DIV_END)
+    
+    if first_start != -1 and last_end != -1 and last_end > first_start:
+        # We have at least one valid section, consolidate all into one
+        before = cleaned[:first_start].rstrip()
+        after = cleaned[last_end + len(SYNTH_DIV_END):].lstrip()
+        
+        parts: list[str] = []
+        if before:
+            parts.append(before)
+        parts.append(_render_block())
+        if after:
+            parts.append(after)
+        
+        new_text = "\n\n".join(parts)
+        if not new_text.endswith("\n"):
+            new_text += "\n"
+        path.write_text(new_text, encoding="utf-8")
+        return
+    
+    # No valid sections found, remove any remaining orphan markers
+    cleaned = cleaned.replace(SYNTH_DIV_END, "")
+    cleaned = cleaned.replace(AGENTS_TEXT, "")
+    cleaned = cleaned.strip()
+    if cleaned:
+        cleaned += "\n\n"
+    path.write_text(f"{cleaned}{_render_block()}\n", encoding="utf-8")

synth_ai/utils/bin.py

@@ -0,0 +1,39 @@
+import shlex
+import subprocess
+from pathlib import Path
+
+from .cli import prompt_choice
+
+
+def install_bin(name: str, install_options: list[str]) -> bool:
+    cmd = prompt_choice(
+        f"How would you like to install {name}?",
+        install_options
+    )
+    div_start = f"{'-' * 29} INSTALL START {'-' * 29}"
+    div_end = f"{'-' * 30} INSTALL END {'-' * 30}"
+    try:
+        print(f"Installing {name} via `{cmd}`")
+        print('\n' + div_start)
+        subprocess.run(shlex.split(cmd), check=True)
+        print(div_end + '\n')
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to install {name}: {e}")
+        print(div_end + '\n')
+        return False
+    
+
+def verify_bin(bin_path: Path) -> bool:
+    try:
+        result = subprocess.run(
+            [str(bin_path), "--version"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+            check=False
+        )
+        return result.returncode == 0
+    except (OSError, subprocess.SubprocessError) as e:
+        print(e)
+        return False

synth_ai/utils/cli.py

@@ -1,9 +1,29 @@
 from collections.abc import Sequence
-from typing import Any, cast
+from pathlib import Path
+from typing import Any, Callable, cast
 
 import click
 
 
+def prompt_choice(msg: str, choices: list[str]) -> str:
+    print(msg)
+    for i, label in enumerate(choices, start=1):
+        print(f" [{i}] {label}")
+    while True:
+        try:
+            choice = click.prompt(
+                "Select an option",
+                default=1,
+                type=int,
+                show_choices=False
+            )
+        except click.Abort:
+            raise
+        if 1 <= choice <= len(choices):
+            return choices[choice - 1]
+        print(f"Invalid selection. Enter a number between 1 and {len(choices)}")
+
+
 class PromptedChoiceType(click.Choice):
     """`click.Choice` variant that reprompts with an interactive menu on failure.
 
@@ -61,9 +81,15 @@ class PromptedChoiceType(click.Choice):
         for index, choice in enumerate(self.choices, 1):
             click.echo(f" [{index}] {choice}")
         while True:
-            selection = click.prompt("> ", type=int)
-            if 1 <= selection <= len(self.choices):
-                return cast(str, self.choices[selection - 1])
+            choice = click.prompt(
+                "Select an option",
+                default=1,
+                type=int,
+                show_choices=False
+            )
+            if 1 <= choice <= len(self.choices):
+                print('')
+                return cast(str, self.choices[choice - 1])
             click.echo(f"Invalid selection for {arg_name}, please try again")
 
     def _get_cmd_name(self, ctx: click.Context | None) -> str:
@@ -122,7 +148,125 @@ class PromptedChoiceOption(click.Option):
         if isinstance(option_type, PromptedChoiceType):
             return option_type._prompt_user(self, ctx)
         return super().prompt_for_value(ctx)
-    
+
+
+def prompt_for_path(
+    label: str,
+    *,
+    available_paths: Sequence[str | Path] | None = None,
+    file_type: str | None = None,
+    path_type: click.Path | None = None,
+) -> Path:
+    """Prompt for a filesystem path, optionally offering curated choices."""
+
+    def _normalize_suffix(ext: str | None) -> str | None:
+        if not ext:
+            return None
+        stripped = ext.strip()
+        if not stripped:
+            return None
+        if not stripped.startswith("."):
+            stripped = f".{stripped}"
+        return stripped.lower()
+
+    def _format_label(text: str) -> str:
+        return text.strip() or "path"
+
+    expected_suffix = _normalize_suffix(file_type)
+    prompt_label = _format_label(label)
+
+    path_type = path_type or click.Path(
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        path_type=Path,
+    )
+
+    candidates: list[str] = []
+    if available_paths:
+        seen: set[str] = set()
+        for entry in available_paths:
+            candidate = str(Path(entry))
+            suffix = Path(candidate).suffix.lower()
+            if candidate in seen:
+                continue
+            if expected_suffix and suffix != expected_suffix:
+                continue
+            seen.add(candidate)
+            candidates.append(candidate)
+
+    ctx = click.get_current_context(silent=True)
+
+    while True:
+        if candidates:
+            click.echo(f"\nPlease choose a {prompt_label}:")
+            for index, option in enumerate(candidates, 1):
+                click.echo(f" [{index}] {option}")
+            custom_index = len(candidates) + 1
+            click.echo(f" [{custom_index}] Enter a custom path")
+
+            selection = click.prompt("> ", type=int)
+            if 1 <= selection <= len(candidates):
+                raw_value = candidates[selection - 1]
+            elif selection == custom_index:
+                raw_value = click.prompt(prompt_label, type=path_type)
+            else:
+                click.echo("Invalid selection, please try again")
+                continue
+        else:
+            raw_value = click.prompt(prompt_label, type=path_type)
+
+        try:
+            converted = path_type.convert(str(raw_value), None, ctx)
+        except click.BadParameter as exc:
+            click.echo(str(exc))
+            continue
+
+        result = converted if isinstance(converted, Path) else Path(converted)
+        if expected_suffix and result.suffix.lower() != expected_suffix:
+            click.echo(f"Expected a {expected_suffix} file. Received: {result}")
+            continue
+        
+        return result
+
+
+class PromptedPathOption(click.Option):
+    """Option that prompts for a filesystem path when omitted."""
+
+    def __init__(
+        self,
+        *args: Any,
+        available_paths: Sequence[str | Path] | None = None,
+        file_type: str | None = None,
+        path_type: click.Path | None = None,
+        prompt_guard: Callable[[click.Context], bool] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self._available_paths = available_paths
+        self._file_type = file_type
+        self._path_type = path_type
+        self._prompt_guard = prompt_guard
+        kwargs.setdefault("prompt", True)
+        kwargs.setdefault("prompt_required", True)
+        super().__init__(*args, **kwargs)
+
+    def prompt_for_value(self, ctx: click.Context) -> Any:
+        if not ctx:
+            return super().prompt_for_value(ctx)
+        if self._prompt_guard is not None:
+            try:
+                if not self._prompt_guard(ctx):
+                    return None
+            except Exception:
+                return None
+        label = self.help or self.name or "path"
+        return prompt_for_path(
+            label,
+            available_paths=self._available_paths,
+            file_type=self._file_type,
+            path_type=self._path_type or getattr(self, "type", None),
+        )
+
 
 def print_next_step(message: str, lines: Sequence[str]) -> None:
     print(f"\n➡️  Next, {message}:")