synth-ai 0.2.10__py3-none-any.whl → 0.2.13.dev1__py3-none-any.whl

synth_ai/cli/task_apps.py

@@ -28,10 +28,61 @@ except Exception:  # pragma: no cover - fallback
 import uuid
 
 import click
+from click.exceptions import Abort
 
-from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT
-from synth_ai.task.apps import ModalDeploymentConfig, TaskAppConfig, TaskAppEntry, registry
-from synth_ai.task.server import create_task_app, run_task_app
+# ---------------------------------------------------------------------------
+# Dynamic imports to avoid hard dependencies during type checking.
+# ---------------------------------------------------------------------------
+ModalDeploymentConfigType = TaskAppConfigType = TaskAppEntryType = Any
+
+try:  # Resolve base URL defaults lazily
+    _config_module = importlib.import_module("synth_ai.config.base_url")
+    PROD_BASE_URL_DEFAULT = cast(str, _config_module.PROD_BASE_URL_DEFAULT)
+except Exception:  # pragma: no cover - fallback
+    PROD_BASE_URL_DEFAULT = "https://agent-learning.onrender.com"
+
+try:
+    _task_apps_module = importlib.import_module("synth_ai.task.apps")
+    ModalDeploymentConfig = cast(
+        type[ModalDeploymentConfigType], _task_apps_module.ModalDeploymentConfig
+    )
+    TaskAppConfig = cast(type[TaskAppConfigType], _task_apps_module.TaskAppConfig)
+    TaskAppEntry = cast(type[TaskAppEntryType], _task_apps_module.TaskAppEntry)
+    registry = _task_apps_module.registry
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load task app registry") from exc
+
+try:
+    _task_server_module = importlib.import_module("synth_ai.task.server")
+    create_task_app = _task_server_module.create_task_app
+    run_task_app = _task_server_module.run_task_app
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load task app server utilities") from exc
+
+
+def _load_demo_directory() -> Path | None:
+    """Return the demo task apps directory if available."""
+
+    try:
+        module = importlib.import_module("synth_ai.demos.demo_task_apps.core")
+        loader = module.load_demo_dir
+        demo_dir = loader()
+        if isinstance(demo_dir, (str, Path)):
+            demo_path = Path(demo_dir)
+            if demo_path.exists():
+                return demo_path.resolve()
+    except Exception:
+        return None
+    return None
+
+
+def _maybe_import(name: str) -> Any:
+    """Safely import a module by name and return it, or None on failure."""
+
+    try:
+        return importlib.import_module(name)
+    except Exception:
+        return None
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
 
@@ -62,12 +113,12 @@ class AppChoice:
     source: str
     description: str | None = None
     aliases: tuple[str, ...] = ()
-    entry: TaskAppEntry | None = None
-    entry_loader: Callable[[], TaskAppEntry] | None = None
+    entry: TaskAppEntryType | None = None
+    entry_loader: Callable[[], TaskAppEntryType] | None = None
     modal_script: Path | None = None
     lineno: int | None = None
 
-    def ensure_entry(self) -> TaskAppEntry:
+    def ensure_entry(self) -> TaskAppEntryType:
         if self.entry is not None:
             return self.entry
         if self.entry_loader is None:
@@ -152,17 +203,9 @@ def _candidate_search_roots() -> list[Path]:
     """Only search for task apps in the current working directory and subdirectories."""
     roots: list[Path] = []
 
-    # Prioritize demo directory if it exists
-    try:
-        from synth_ai.demos.demo_task_apps.core import load_demo_dir
-
-        demo_dir = load_demo_dir()
-        if demo_dir:
-            demo_path = Path(demo_dir)
-            if demo_path.exists() and demo_path.is_dir():
-                roots.append(demo_path.resolve())
-    except Exception:
-        pass
+    demo_path = _load_demo_directory()
+    if demo_path is not None and demo_path.is_dir():
+        roots.append(demo_path)
 
     # Allow explicit search paths via environment variable
     env_paths = os.environ.get("SYNTH_TASK_APP_SEARCH_PATH")
@@ -359,7 +402,7 @@ def _collect_task_app_choices() -> list[AppChoice]:
 
     choices: list[AppChoice] = []
     with contextlib.suppress(Exception):
-        import synth_ai.demos.demo_task_apps  # noqa: F401
+        _maybe_import("synth_ai.demos.demo_task_apps")
     # Only use discovered task apps, not registered ones (since we moved them to examples)
     choices.extend(_collect_scanned_task_configs())
     choices.extend(_collect_modal_scripts())
@@ -515,16 +558,9 @@ def _app_choice_sort_key(choice: AppChoice) -> tuple[int, int, int, int, int, st
 
     # Further prioritize apps in the demo directory if one is set
     demo_rank = 1
-    try:
-        from synth_ai.demos.demo_task_apps.core import load_demo_dir
-
-        demo_dir = load_demo_dir()
-        if demo_dir:
-            demo_path = Path(demo_dir).resolve()
-            if choice.path.is_relative_to(demo_path):
-                demo_rank = 0
-    except Exception:
-        pass
+    demo_dir = _load_demo_directory()
+    if demo_dir and choice.path.is_relative_to(demo_dir):
+        demo_rank = 0
 
     modal_rank = 1 if choice.modal_script else 0
 
@@ -598,7 +634,7 @@ def _has_modal_support_in_file(path: Path) -> bool:
     return False
 
 
-def _extract_modal_config_from_file(path: Path) -> ModalDeploymentConfig | None:
+def _extract_modal_config_from_file(path: Path) -> ModalDeploymentConfigType | None:
     """Extract ModalDeploymentConfig from a file by parsing the AST."""
     try:
         source = path.read_text(encoding="utf-8")
@@ -629,7 +665,7 @@ def _extract_modal_config_from_file(path: Path) -> ModalDeploymentConfig | None:
     return None
 
 
-def _build_modal_config_from_ast(modal_call: ast.Call) -> ModalDeploymentConfig | None:
+def _build_modal_config_from_ast(modal_call: ast.Call) -> ModalDeploymentConfigType | None:
     """Build a ModalDeploymentConfig from an AST Call node."""
     try:
         # Extract keyword arguments
@@ -637,44 +673,41 @@ def _build_modal_config_from_ast(modal_call: ast.Call) -> ModalDeploymentConfig
         for kw in modal_call.keywords:
             if kw.arg and isinstance(kw.value, ast.Constant):
                 kwargs[kw.arg] = kw.value.value
-            elif kw.arg == "pip_packages" and isinstance(kw.value, ast.List | ast.Tuple):
+            elif kw.arg == "pip_packages" and isinstance(kw.value, (ast.List, ast.Tuple)):
                 # Handle pip_packages list/tuple
-                packages = []
+                packages: list[str] = []
                 for elt in kw.value.elts:
                     if isinstance(elt, ast.Constant):
                         packages.append(elt.value)
                 kwargs[kw.arg] = tuple(packages)
-            elif kw.arg == "extra_local_dirs" and isinstance(kw.value, ast.List | ast.Tuple):
+            elif kw.arg == "extra_local_dirs" and isinstance(kw.value, (ast.List, ast.Tuple)):
                 # Handle extra_local_dirs list/tuple of tuples
                 dirs = []
                 for elt in kw.value.elts:
-                    if isinstance(elt, ast.List | ast.Tuple) and len(elt.elts) == 2:
+                    if isinstance(elt, (ast.List, ast.Tuple)) and len(elt.elts) == 2:
                         src = elt.elts[0].value if isinstance(elt.elts[0], ast.Constant) else None
                         dst = elt.elts[1].value if isinstance(elt.elts[1], ast.Constant) else None
                         if src and dst:
                             dirs.append((src, dst))
                 kwargs[kw.arg] = tuple(dirs)
-            elif kw.arg == "secret_names" and isinstance(kw.value, ast.List | ast.Tuple):
+            elif kw.arg == "secret_names" and isinstance(kw.value, (ast.List, ast.Tuple)):
                 # Handle secret_names list/tuple
                 secrets = []
                 for elt in kw.value.elts:
                     if isinstance(elt, ast.Constant):
                         secrets.append(elt.value)
                 kwargs[kw.arg] = tuple(secrets)
-            elif kw.arg == "volume_mounts" and isinstance(kw.value, ast.List | ast.Tuple):
+            elif kw.arg == "volume_mounts" and isinstance(kw.value, (ast.List, ast.Tuple)):
                 # Handle volume_mounts list/tuple of tuples
                 mounts = []
                 for elt in kw.value.elts:
-                    if isinstance(elt, ast.List | ast.Tuple) and len(elt.elts) == 2:
+                    if isinstance(elt, (ast.List, ast.Tuple)) and len(elt.elts) == 2:
                         name = elt.elts[0].value if isinstance(elt.elts[0], ast.Constant) else None
                         mount = elt.elts[1].value if isinstance(elt.elts[1], ast.Constant) else None
                         if name and mount:
                             mounts.append((name, mount))
                 kwargs[kw.arg] = tuple(mounts)
 
-        # Create ModalDeploymentConfig with extracted arguments
-        from synth_ai.task.apps import ModalDeploymentConfig
-
         return ModalDeploymentConfig(**kwargs)
     except Exception:
         return None
@@ -713,7 +746,7 @@ def _prompt_user_for_choice(choices: list[AppChoice]) -> AppChoice:
         click.echo(_format_choice(choice, idx))
     try:
         response = click.prompt("Enter choice", default="1", type=str).strip() or "1"
-    except (click.exceptions.Abort, EOFError, KeyboardInterrupt) as exc:
+    except (Abort, EOFError, KeyboardInterrupt) as exc:
         raise click.ClickException("Task app selection cancelled by user") from exc
     if not response.isdigit():
         raise click.ClickException("Selection must be a number")
@@ -745,6 +778,9 @@ def _select_app_choice(app_id: str | None, purpose: str) -> AppChoice:
         if not matches:
             available = ", ".join(sorted({c.app_id for c in filtered}))
             raise click.ClickException(f"Task app '{app_id}' not found. Available: {available}")
+        exact_matches = [c for c in matches if c.app_id == app_id]
+        if len(exact_matches) == 1:
+            return exact_matches[0]
         if len(matches) == 1:
             return matches[0]
         # Prefer entries with modal support when required
@@ -798,7 +834,7 @@ def _import_task_app_module(
 
 def _load_entry_from_path(
     path: Path, app_id: str, module_search_roots: Sequence[Path] | None = None
-) -> TaskAppEntry:
+) -> TaskAppEntryType:
     resolved = path.resolve()
     search_roots: list[Path] = []
     seen_roots: set[Path] = set()
@@ -849,8 +885,8 @@ def _load_entry_from_path(
             detail = last_error or exc
             raise click.ClickException(f"Failed to import {resolved}: {detail}") from detail
 
-    config_obj: TaskAppConfig | None = None
-    factory_callable: Callable[[], TaskAppConfig] | None = None
+    config_obj: TaskAppConfigType | None = None
+    factory_callable: Callable[[], TaskAppConfigType] | None = None
 
     for attr_name in dir(module):
         try:
@@ -860,7 +896,7 @@ def _load_entry_from_path(
         if isinstance(attr, TaskAppConfig) and attr.app_id == app_id:
             config_obj = attr
 
-            def _return_config(cfg: TaskAppConfig = attr) -> TaskAppConfig:
+            def _return_config(cfg: TaskAppConfigType = attr) -> TaskAppConfigType:
                 return cfg
 
             factory_callable = _return_config
@@ -900,8 +936,8 @@ def _load_entry_from_path(
                 bound_func: Callable[[], TaskAppConfig] = cast(Callable[[], TaskAppConfig], attr)  # type: ignore[assignment]
 
                 def _factory_noargs(
-                    func: Callable[[], TaskAppConfig] = bound_func,
-                ) -> TaskAppConfig:
+                    func: Callable[[], TaskAppConfigType] = bound_func,
+                ) -> TaskAppConfigType:
                     return func()
 
                 factory_callable = _factory_noargs
@@ -919,7 +955,7 @@ def _load_entry_from_path(
                 f"Could not locate TaskAppConfig for '{app_id}' in {resolved}."
             ) from exc
 
-    modal_cfg: ModalDeploymentConfig | None = None
+    modal_cfg: ModalDeploymentConfigType | None = None
     for attr_name in dir(module):
         try:
             attr = getattr(module, attr_name)
@@ -1008,7 +1044,6 @@ def _modal_command_prefix(modal_cli: str) -> list[str]:
 def _build_modal_app_wrapper(original_script: Path) -> tuple[Path, Path]:
     source_dir = original_script.parent.resolve()
     repo_root = REPO_ROOT
-    synth_src = (repo_root / "synth_ai").resolve()
     temp_root = Path(tempfile.mkdtemp(prefix="synth_modal_app_"))
 
     wrapper_source = textwrap.dedent(
@@ -1103,7 +1138,7 @@ def _run_modal_script(
     try:
         _preflight_env_key(env_paths_list, crash_on_failure=True)
     except Exception as _pf_err:
-        raise click.ClickException(str(_pf_err))
+        raise click.ClickException(str(_pf_err)) from _pf_err
 
     proc_env = os.environ.copy()
     pythonpath_entries: list[str] = []
@@ -1172,10 +1207,8 @@ def _run_modal_script(
     finally:
         if wrapper_info is not None:
             wrapper_path, temp_root = wrapper_info
-            try:
+            with contextlib.suppress(Exception):
                 wrapper_path.unlink(missing_ok=True)
-            except Exception:
-                pass
             shutil.rmtree(temp_root, ignore_errors=True)
 
 
@@ -1201,10 +1234,12 @@ def _preflight_env_key(env_paths: Sequence[Path] | None = None, *, crash_on_fail
 
         minted = False
         if not env_api_key:
+            secrets_module = _maybe_import("synth_ai.learning.rl.secrets")
             try:
-                from synth_ai.learning.rl.secrets import mint_environment_api_key
-
-                env_api_key = mint_environment_api_key()
+                if secrets_module is None:
+                    raise RuntimeError("secrets module unavailable")
+                mint_env_key = secrets_module.mint_environment_api_key
+                env_api_key = mint_env_key()
                 os.environ["ENVIRONMENT_API_KEY"] = env_api_key
                 os.environ.setdefault("DEV_ENVIRONMENT_API_KEY", env_api_key)
                 minted = True
@@ -1347,8 +1382,8 @@ def _preflight_env_key(env_paths: Sequence[Path] | None = None, *, crash_on_fail
 
 
 def _run_modal_with_entry(
-    entry: TaskAppEntry,
-    modal_cfg: ModalDeploymentConfig,
+    entry: TaskAppEntryType,
+    modal_cfg: ModalDeploymentConfigType,
     modal_cli: str,
     modal_name: str | None,
     env_paths: list[Path],
@@ -1504,7 +1539,7 @@ def _interactive_fill_env(env_path: Path) -> Path | None:
                 value = click.prompt(
                     label, default=default, show_default=bool(default) or not required
                 ).strip()
-            except (click.exceptions.Abort, EOFError, KeyboardInterrupt):
+            except (Abort, EOFError, KeyboardInterrupt):
                 click.echo("Aborted env creation.")
                 return None
             if value or not required:
@@ -1545,7 +1580,7 @@ def _ensure_env_values(env_paths: list[Path], fallback_dir: Path) -> None:
 
 
 def _deploy_entry(
-    entry: TaskAppEntry,
+    entry: TaskAppEntryType,
     modal_name: str | None,
     dry_run: bool,
     modal_cli: str,
@@ -1573,7 +1608,7 @@ def _deploy_entry(
 
 
 def _modal_serve_entry(
-    entry: TaskAppEntry,
+    entry: TaskAppEntryType,
     modal_name: str | None,
     modal_cli: str,
     env_file: Sequence[str],
@@ -1673,20 +1708,15 @@ def serve_command(
     trace_dir: str | None,
     trace_db: str | None,
 ) -> None:
-    # Change to demo directory if stored (REQUIRED for demo isolation)
-    from synth_ai.demos.demo_task_apps.core import load_demo_dir
-
-    demo_dir = load_demo_dir()
-    if demo_dir:
-        demo_path = Path(demo_dir)
-        if not demo_path.is_dir():
+    demo_dir_path = _load_demo_directory()
+    if demo_dir_path:
+        if not demo_dir_path.is_dir():
             raise click.ClickException(
-                f"Demo directory not found: {demo_dir}\nRun 'synth-ai setup' to create a demo."
+                f"Demo directory not found: {demo_dir_path}\nRun 'synth-ai setup' to create a demo."
             )
-        os.chdir(demo_dir)
-        click.echo(f"Using demo directory: {demo_dir}\n")
-        # Store demo directory for path resolution
-        os.environ["SYNTH_DEMO_DIR"] = str(demo_path.resolve())
+        os.chdir(demo_dir_path)
+        click.echo(f"Using demo directory: {demo_dir_path}\n")
+        os.environ["SYNTH_DEMO_DIR"] = str(demo_dir_path.resolve())
 
     # Prompt for port if not provided
     if port is None:
@@ -1752,9 +1782,10 @@ def info_command(base_url: str | None, api_key: str | None, seeds: tuple[int, ..
     base = (base_url or _os.getenv("TASK_APP_BASE_URL") or "http://127.0.0.1:8001").rstrip("/")
 
     # Resolve API key, permitting dev fallbacks
-    try:
-        from synth_ai.task.auth import normalize_environment_api_key as _norm_key
-    except Exception:
+    auth_module = _maybe_import("synth_ai.task.auth")
+    if auth_module is not None:
+        _norm_key = getattr(auth_module, "normalize_environment_api_key", lambda: _os.getenv("ENVIRONMENT_API_KEY"))
+    else:
         _norm_key = lambda: _os.getenv("ENVIRONMENT_API_KEY")  # noqa: E731
     key = (api_key or _norm_key() or "").strip()
     if not key:
@@ -1831,20 +1862,15 @@ def serve_task_group(
     trace_dir: str | None,
     trace_db: str | None,
 ) -> None:
-    # Change to demo directory if stored (REQUIRED for demo isolation)
-    from synth_ai.demos.demo_task_apps.core import load_demo_dir
-
-    demo_dir = load_demo_dir()
-    if demo_dir:
-        demo_path = Path(demo_dir)
-        if not demo_path.is_dir():
+    demo_dir_path = _load_demo_directory()
+    if demo_dir_path:
+        if not demo_dir_path.is_dir():
             raise click.ClickException(
-                f"Demo directory not found: {demo_dir}\nRun 'synth-ai setup' to create a demo."
+                f"Demo directory not found: {demo_dir_path}\nRun 'synth-ai setup' to create a demo."
             )
-        os.chdir(demo_dir)
-        click.echo(f"Using demo directory: {demo_dir}\n")
-        # Store demo directory for path resolution
-        os.environ["SYNTH_DEMO_DIR"] = str(demo_path.resolve())
+        os.chdir(demo_dir_path)
+        click.echo(f"Using demo directory: {demo_dir_path}\n")
+        os.environ["SYNTH_DEMO_DIR"] = str(demo_dir_path.resolve())
 
     # Prompt for port if not provided
     if port is None:
@@ -1881,7 +1907,7 @@ def serve_task_group(
     )
 
 
-def _determine_env_files(entry: TaskAppEntry, user_env_files: Sequence[str]) -> list[Path]:
+def _determine_env_files(entry: TaskAppEntryType, user_env_files: Sequence[str]) -> list[Path]:
     resolved: list[Path] = []
     for candidate in user_env_files:
         p = Path(candidate).expanduser()
@@ -2068,17 +2094,10 @@ def _validate_required_env_keys() -> None:
 def _print_demo_next_steps_if_applicable() -> None:
     """Print next steps if currently in a demo directory."""
     try:
-        from synth_ai.demos.demo_task_apps.core import load_demo_dir
-
         cwd = Path.cwd().resolve()
-        demo_dir = load_demo_dir()
+        demo_dir = _load_demo_directory()
 
-        # Check if we're in the demo directory
-        if (
-            demo_dir
-            and Path(demo_dir).resolve() == cwd
-            and (cwd / "run_local_rollout_traced.py").exists()
-        ):
+        if demo_dir and demo_dir == cwd and (cwd / "run_local_rollout_traced.py").exists():
             click.echo("\n" + "=" * 60)
             click.echo("Next step: Collect traced rollouts")
             click.echo("=" * 60)
@@ -2088,12 +2107,11 @@ def _print_demo_next_steps_if_applicable() -> None:
             click.echo("\nRun this 5-10 times to collect diverse traces.")
             click.echo("=" * 60 + "\n")
     except Exception:
-        # Silently fail - this is just a helpful printout
         pass
 
 
 def _serve_entry(
-    entry: TaskAppEntry,
+    entry: TaskAppEntryType,
     host: str,
     port: int,
     env_file: Sequence[str],
@@ -2134,13 +2152,13 @@ def _serve_entry(
             os.environ["SQLD_DB_PATH"] = str(db_path)
             os.environ["TURSO_LOCAL_DB_URL"] = db_url
             click.echo(f"Tracing DB path set to {db_path}")
-        from synth_ai.tracing_v3.config import CONFIG as TRACE_CONFIG
-
-        # Use the explicitly set URL if available
-        new_db_url = os.getenv("TURSO_LOCAL_DB_URL") or TRACE_CONFIG.db_url
-        TRACE_CONFIG.db_url = new_db_url
-        if new_db_url:
-            click.echo(f"Tracing DB URL resolved to {new_db_url}")
+        tracing_config_module = _maybe_import("synth_ai.tracing_v3.config")
+        if tracing_config_module is not None:
+            trace_config = tracing_config_module.CONFIG
+            new_db_url = os.getenv("TURSO_LOCAL_DB_URL") or trace_config.db_url
+            trace_config.db_url = new_db_url
+            if new_db_url:
+                click.echo(f"Tracing DB URL resolved to {new_db_url}")
     elif os.getenv("TASKAPP_TRACING_ENABLED"):
         click.echo("Tracing enabled via environment variables")
 
@@ -2183,18 +2201,14 @@ def deploy_app(
 ) -> None:
     """Deploy a task app to Modal."""
 
-    # Change to demo directory if stored (for consistent discovery)
-    from synth_ai.demos.demo_task_apps.core import load_demo_dir
-
-    demo_dir = load_demo_dir()
-    if demo_dir:
-        demo_path = Path(demo_dir)
-        if not demo_path.is_dir():
+    demo_dir_path = _load_demo_directory()
+    if demo_dir_path:
+        if not demo_dir_path.is_dir():
             raise click.ClickException(
-                f"Demo directory not found: {demo_dir}\nRun 'synth-ai demo' to create a demo."
+                f"Demo directory not found: {demo_dir_path}\nRun 'synth-ai demo' to create a demo."
             )
-        os.chdir(demo_dir)
-        click.echo(f"Using demo directory: {demo_dir}\n")
+        os.chdir(demo_dir_path)
+        click.echo(f"Using demo directory: {demo_dir_path}\n")
 
     choice = _select_app_choice(app_id, purpose="deploy")
 
@@ -2241,8 +2255,8 @@ def modal_serve_app(
 
 
 def _write_modal_entrypoint(
-    entry: TaskAppEntry,
-    modal_cfg: ModalDeploymentConfig,
+    entry: TaskAppEntryType,
+    modal_cfg: ModalDeploymentConfigType,
     override_name: str | None,
     *,
     dotenv_paths: Sequence[str] | None = None,
@@ -2291,30 +2305,25 @@ def _write_modal_entrypoint(
     pip_packages = list(modal_cfg.pip_packages)
     # Ensure synth-ai (matching host version if available) is installed in the container
     synth_pkg = "synth-ai"
-    try:
-        import synth_ai as _host_synth
-
-        host_ver = getattr(_host_synth, "__version__", None)
+    host_synth = _maybe_import("synth_ai")
+    if host_synth is not None:
+        host_ver = getattr(host_synth, "__version__", None)
         if host_ver:
             synth_pkg = f"synth-ai=={host_ver}"
-    except Exception:
-        pass
     if not any(str(p).startswith("synth-ai") for p in pip_packages):
         pip_packages.insert(0, synth_pkg)
 
     local_dirs = [(str(Path(src)), dst) for src, dst in modal_cfg.extra_local_dirs]
     # Also mount the host synth_ai source if available to ensure latest code is used
-    try:
-        import synth_ai as _host_synth
-
-        host_synth_dir = Path(_host_synth.__file__).resolve().parent
-        # host_synth_dir points to .../synth_ai; mount that directory
-        sy_dst = "/opt/synth_ai_repo/synth_ai"
-        candidate = (str(host_synth_dir), sy_dst)
-        if candidate not in local_dirs:
-            local_dirs.insert(0, candidate)
-    except Exception:
-        pass
+    if host_synth is not None:
+        try:
+            host_synth_dir = Path(host_synth.__file__).resolve().parent
+            sy_dst = "/opt/synth_ai_repo/synth_ai"
+            candidate = (str(host_synth_dir), sy_dst)
+            if candidate not in local_dirs:
+                local_dirs.insert(0, candidate)
+        except Exception:
+            pass
     # Ensure the discovered app directory is mounted, regardless of modal_cfg
     if original_path:
         discovered_dir = str(Path(original_path).resolve().parent)
@@ -2544,7 +2553,7 @@ def eval_command(
         elif isinstance(ef, list):
             env_file = tuple(str(x) for x in ef)  # type: ignore[assignment]
 
-    entry: TaskAppEntry | None = None
+    entry: TaskAppEntryType | None = None
     if task_app_url is None:
         choice = _select_app_choice(app_id, purpose="eval")
         entry = choice.ensure_entry()

synth_ai/cli/traces.py

@@ -11,6 +11,8 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
+from ._storage import load_storage
+
 
 def register(cli):
     @cli.command()
@@ -26,8 +28,6 @@ def register(cli):
         console = Console()
 
         async def _run():
-            from synth_ai.tracing_v3.storage.factory import StorageConfig, create_storage
-
             # Discover DBs under ./synth_ai.db/dbs (or override via env)
             root = os.getenv("SYNTH_TRACES_ROOT", "./synth_ai.db/dbs")
             if not os.path.isdir(root):
@@ -58,7 +58,8 @@ def register(cli):
 
             async def db_counts(db_dir: str) -> tuple[int, dict[str, int], int, str | None, int]:
                 data_file = os.path.join(db_dir, "data")
-                mgr = create_storage(StorageConfig(connection_string=f"sqlite+aiosqlite:///{data_file}"))
+                create_storage, storage_config = load_storage()
+                mgr = create_storage(storage_config(connection_string=f"sqlite+aiosqlite:///{data_file}"))
                 await mgr.initialize()
                 try:
                     traces_df = await mgr.query_traces("SELECT COUNT(*) AS c FROM session_traces")

synth_ai/cli/watch.py

@@ -16,11 +16,12 @@ from rich.console import Console, Group
 from rich.panel import Panel
 from rich.table import Table
 
-from synth_ai.tracing_v3.storage.factory import StorageConfig, create_storage
+from ._storage import load_storage
 
 
 def _open_db(db_url: str):
-    return create_storage(StorageConfig(connection_string=db_url))
+    create_storage, storage_config = load_storage()
+    return create_storage(storage_config(connection_string=db_url))
 
 
 class _State: