synth-ai 0.2.9.dev3__py3-none-any.whl → 0.2.9.dev5__py3-none-any.whl

synth_ai/cli/task_apps.py

@@ -37,8 +37,6 @@ DEFAULT_IGNORE_DIRS = {
 
 DEFAULT_SEARCH_RELATIVE = (
     Path("."),
-    Path("examples"),
-    Path("synth_ai"),
 )
 
 
@@ -70,32 +68,21 @@ def _should_ignore_path(path: Path) -> bool:
 
 
 def _candidate_search_roots() -> list[Path]:
+    """Only search for task apps in the current working directory and subdirectories."""
     roots: list[Path] = []
+    
+    # Allow explicit search paths via environment variable
     env_paths = os.environ.get("SYNTH_TASK_APP_SEARCH_PATH")
     if env_paths:
         for chunk in env_paths.split(os.pathsep):
             if chunk:
                 roots.append(Path(chunk).expanduser())
 
+    # Always include current working directory
     cwd = Path.cwd().resolve()
     roots.append(cwd)
 
-    for rel in DEFAULT_SEARCH_RELATIVE:
-        try:
-            candidate = (cwd / rel).resolve()
-        except Exception:
-            continue
-        roots.append(candidate)
-        if REPO_ROOT not in (None, candidate):
-            try:
-                repo_candidate = (REPO_ROOT / rel).resolve()
-            except Exception:
-                repo_candidate = None
-            if repo_candidate:
-                roots.append(repo_candidate)
-
-    roots.append(REPO_ROOT)
-
+    # Remove duplicates while preserving order
     seen: set[Path] = set()
     ordered: list[Path] = []
     for root in roots:
@@ -119,6 +106,10 @@ class _TaskAppConfigVisitor(ast.NodeVisitor):
             app_id = _extract_app_id(node)
             if app_id:
                 self.matches.append((app_id, getattr(node, "lineno", 0)))
+        elif _is_register_task_app_call(node):
+            app_id = _extract_register_app_id(node)
+            if app_id:
+                self.matches.append((app_id, getattr(node, "lineno", 0)))
         self.generic_visit(node)
 
 
@@ -142,6 +133,27 @@ def _extract_app_id(node: ast.Call) -> str | None:
     return None
 
 
+def _is_register_task_app_call(node: ast.Call) -> bool:
+    func = node.func
+    if isinstance(func, ast.Name) and func.id == "register_task_app":
+        return True
+    if isinstance(func, ast.Attribute) and func.attr == "register_task_app":
+        return True
+    return False
+
+
+def _extract_register_app_id(node: ast.Call) -> str | None:
+    # Look for entry=TaskAppEntry(app_id="...", ...)
+    for kw in node.keywords:
+        if kw.arg == "entry" and isinstance(kw.value, ast.Call):
+            entry_call = kw.value
+            if isinstance(entry_call.func, ast.Name) and entry_call.func.id == "TaskAppEntry":
+                for entry_kw in entry_call.keywords:
+                    if entry_kw.arg == "app_id" and isinstance(entry_kw.value, ast.Constant) and isinstance(entry_kw.value.value, str):
+                        return entry_kw.value.value
+    return None
+
+
 class _ModalAppVisitor(ast.NodeVisitor):
     def __init__(self) -> None:
         self.app_aliases: set[str] = set()
@@ -186,12 +198,14 @@ def _extract_modal_app_name(node: ast.Call) -> str | None:
     return None
 
 
-@functools.lru_cache(maxsize=1)
 def _collect_task_app_choices() -> list[AppChoice]:
+    # Clear registry to avoid duplicate registration errors
+    registry.clear()
+    
     choices: list[AppChoice] = []
     with contextlib.suppress(Exception):
         import synth_ai.demos.demo_task_apps  # noqa: F401
-    choices.extend(_collect_registered_choices())
+    # 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())
 
@@ -333,10 +347,112 @@ def _choice_has_modal_support(choice: AppChoice) -> bool:
     try:
         entry = choice.ensure_entry()
     except click.ClickException:
-        return False
+        # If we can't load the entry, try to detect Modal support via AST parsing
+        return _has_modal_support_in_file(choice.path)
     return entry.modal is not None
 
 
+def _has_modal_support_in_file(path: Path) -> bool:
+    """Detect if a file has Modal deployment support by parsing the AST."""
+    try:
+        source = path.read_text(encoding="utf-8")
+        tree = ast.parse(source, filename=str(path))
+        
+        # Look for ModalDeploymentConfig in register_task_app calls
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                if _is_register_task_app_call(node):
+                    # Check if the entry has modal=ModalDeploymentConfig(...)
+                    for kw in node.keywords:
+                        if kw.arg == "entry" and isinstance(kw.value, ast.Call):
+                            entry_call = kw.value
+                            if isinstance(entry_call.func, ast.Name) and entry_call.func.id == "TaskAppEntry":
+                                for entry_kw in entry_call.keywords:
+                                    if entry_kw.arg == "modal" and isinstance(entry_kw.value, ast.Call):
+                                        modal_call = entry_kw.value
+                                        if isinstance(modal_call.func, ast.Name) and modal_call.func.id == "ModalDeploymentConfig":
+                                            return True
+    except Exception:
+        pass
+    return False
+
+
+def _extract_modal_config_from_file(path: Path) -> ModalDeploymentConfig | None:
+    """Extract ModalDeploymentConfig from a file by parsing the AST."""
+    try:
+        source = path.read_text(encoding="utf-8")
+        tree = ast.parse(source, filename=str(path))
+        
+        # Look for ModalDeploymentConfig in register_task_app calls
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                if _is_register_task_app_call(node):
+                    # Check if the entry has modal=ModalDeploymentConfig(...)
+                    for kw in node.keywords:
+                        if kw.arg == "entry" and isinstance(kw.value, ast.Call):
+                            entry_call = kw.value
+                            if isinstance(entry_call.func, ast.Name) and entry_call.func.id == "TaskAppEntry":
+                                for entry_kw in entry_call.keywords:
+                                    if entry_kw.arg == "modal" and isinstance(entry_kw.value, ast.Call):
+                                        modal_call = entry_kw.value
+                                        if isinstance(modal_call.func, ast.Name) and modal_call.func.id == "ModalDeploymentConfig":
+                                            # Extract the arguments to ModalDeploymentConfig
+                                            return _build_modal_config_from_ast(modal_call)
+    except Exception:
+        pass
+    return None
+
+
+def _build_modal_config_from_ast(modal_call: ast.Call) -> ModalDeploymentConfig | None:
+    """Build a ModalDeploymentConfig from an AST Call node."""
+    try:
+        # Extract keyword arguments
+        kwargs = {}
+        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)):
+                # Handle pip_packages list/tuple
+                packages = []
+                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)):
+                # 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:
+                        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)):
+                # 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)):
+                # 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:
+                        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
+
+
 def _choice_has_local_support(choice: AppChoice) -> bool:
     if choice.modal_script:
         return False
@@ -418,6 +534,10 @@ def _load_entry_from_path(path: Path, app_id: str) -> TaskAppEntry:
         raise click.ClickException(f"Unable to load Python module from {resolved}")
     module = importlib.util.module_from_spec(spec)
     sys.modules[module_name] = module
+    
+    # Clear registry before importing to avoid duplicate registration errors
+    registry.clear()
+    
     try:
         spec.loader.exec_module(module)
     except Exception as exc:
@@ -468,10 +588,16 @@ def _load_entry_from_path(path: Path, app_id: str) -> TaskAppEntry:
                 config_obj = result
                 break
 
+    # If no TaskAppConfig found directly, check if it was registered via register_task_app
     if factory_callable is None or config_obj is None:
-        raise click.ClickException(
-            f"Could not locate TaskAppConfig for '{app_id}' in {resolved}."
-        )
+        try:
+            # Check if the app was registered in the registry
+            entry = registry.get(app_id)
+            return entry
+        except KeyError:
+            raise click.ClickException(
+                f"Could not locate TaskAppConfig for '{app_id}' in {resolved}."
+            )
 
     modal_cfg: ModalDeploymentConfig | None = None
     for attr_name in dir(module):
@@ -482,6 +608,10 @@ def _load_entry_from_path(path: Path, app_id: str) -> TaskAppEntry:
         if isinstance(attr, ModalDeploymentConfig):
             modal_cfg = attr
             break
+    
+    # If no ModalDeploymentConfig found, try to detect it via AST parsing
+    if modal_cfg is None:
+        modal_cfg = _extract_modal_config_from_file(resolved)
 
     description = inspect.getdoc(module) or f"Discovered task app in {resolved.name}"
     env_files: Iterable[str] = getattr(module, "ENV_FILES", ())  # type: ignore[arg-type]
@@ -507,20 +637,35 @@ def _resolve_env_paths_for_script(script_path: Path, explicit: Sequence[str]) ->
             resolved.append(p)
         return resolved
 
+    # Always prompt for env file selection instead of auto-loading defaults
     script_dir = script_path.parent.resolve()
-    fallback_order = [
-        script_dir / ".env",
-        REPO_ROOT / "examples" / "rl" / ".env",
-        REPO_ROOT / "examples" / "warming_up_to_rl" / ".env",
-        REPO_ROOT / ".env",
-    ]
-    resolved = [p for p in fallback_order if p.exists()]
-    if resolved:
-        return resolved
-    created = _interactive_create_env(script_dir)
-    if created is None:
-        raise click.ClickException("Env file required (--env-file) for this task app")
-    return [created]
+    cwd = Path.cwd()
+    
+    # Look for env files in current working directory first, then repo root
+    env_candidates = []
+    
+    # Add CWD env files first (prioritized)
+    cwd_env_files = sorted(cwd.glob('**/*.env'))
+    env_candidates.extend(cwd_env_files)
+    
+    # Add repo root env files
+    repo_env_files = sorted(REPO_ROOT.glob('**/*.env'))
+    # Avoid duplicates
+    for repo_file in repo_env_files:
+        if repo_file not in env_candidates:
+            env_candidates.append(repo_file)
+    
+    if not env_candidates:
+        created = _interactive_create_env(script_dir)
+        if created is None:
+            raise click.ClickException("Env file required (--env-file) for this task app")
+        return [created]
+
+    click.echo('Select env file to load:')
+    for idx, path in enumerate(env_candidates, start=1):
+        click.echo(f"  {idx}) {path}")
+    choice = click.prompt('Enter choice', type=click.IntRange(1, len(env_candidates)))
+    return [env_candidates[choice - 1]]
 
 
 def _run_modal_script(
@@ -554,7 +699,7 @@ def _run_modal_script(
         raise click.ClickException(f"modal {command} failed with exit code {exc.returncode}") from exc
 
 
-def _preflight_env_key() -> None:
+def _preflight_env_key(crash_on_failure: bool = False) -> None:
     try:
         raw_backend = os.environ.get("BACKEND_BASE_URL") or os.environ.get("SYNTH_BASE_URL") or "http://localhost:8000/api"
         backend_base = raw_backend.rstrip('/')
@@ -591,13 +736,24 @@ def _preflight_env_key() -> None:
                         click.echo("[preflight] verifying env key presence…")
                         ver = c.get(f"{backend_base.rstrip('/')}/v1/env-keys/verify")
                         if ver.status_code == 200 and (ver.json() or {}).get("present"):
-                            click.echo("✅ ENVIRONMENT_API_KEY upserted and verified in backend")
+                            # Show first and last 5 chars of the API key for verification
+                            key_preview = f"{env_api_key[:5]}...{env_api_key[-5:]}" if len(env_api_key) > 10 else env_api_key
+                            click.echo(f"✅ ENVIRONMENT_API_KEY upserted and verified in backend ({key_preview})")
                         else:
-                            click.echo("[WARN] ENVIRONMENT_API_KEY verification failed; proceeding anyway")
-                except Exception:
-                    click.echo("[WARN] Failed to encrypt/upload ENVIRONMENT_API_KEY; proceeding anyway")
-    except Exception:
-        click.echo("[WARN] Backend preflight for ENVIRONMENT_API_KEY failed; proceeding anyway")
+                            error_msg = "ENVIRONMENT_API_KEY verification failed"
+                            if crash_on_failure:
+                                raise click.ClickException(f"[CRITICAL] {error_msg}")
+                            click.echo(f"[WARN] {error_msg}; proceeding anyway")
+                except Exception as e:
+                    error_msg = f"Failed to encrypt/upload ENVIRONMENT_API_KEY: {e}"
+                    if crash_on_failure:
+                        raise click.ClickException(f"[CRITICAL] {error_msg}")
+                    click.echo(f"[WARN] {error_msg}; proceeding anyway")
+    except Exception as e:
+        error_msg = f"Backend preflight for ENVIRONMENT_API_KEY failed: {e}"
+        if crash_on_failure:
+            raise click.ClickException(f"[CRITICAL] {error_msg}")
+        click.echo(f"[WARN] {error_msg}; proceeding anyway")
 
 
 def _run_modal_with_entry(
@@ -609,6 +765,7 @@ def _run_modal_with_entry(
     command: str,
     *,
     dry_run: bool = False,
+    original_path: Path | None = None,
 ) -> None:
     modal_path = shutil.which(modal_cli)
     if modal_path is None:
@@ -620,13 +777,14 @@ def _run_modal_with_entry(
     fallback_dir = env_paths_list[0].parent if env_paths_list else Path.cwd()
     _ensure_env_values(env_paths_list, fallback_dir)
     _load_env_values(env_paths_list)
-    _preflight_env_key()
+    _preflight_env_key(crash_on_failure=True)
 
     script_path = _write_modal_entrypoint(
         entry,
         modal_cfg,
         modal_name,
         dotenv_paths=dotenv_paths,
+        original_path=original_path,
     )
     cmd = [modal_path, command, str(script_path)]
 
@@ -742,6 +900,7 @@ def _deploy_entry(
     dry_run: bool,
     modal_cli: str,
     env_file: Sequence[str],
+    original_path: Path | None = None,
 ) -> None:
     modal_cfg = entry.modal
     if modal_cfg is None:
@@ -749,7 +908,7 @@ def _deploy_entry(
 
     env_paths = _determine_env_files(entry, env_file)
     click.echo('Using env file(s): ' + ', '.join(str(p) for p in env_paths))
-    _run_modal_with_entry(entry, modal_cfg, modal_cli, modal_name, env_paths, command="deploy", dry_run=dry_run)
+    _run_modal_with_entry(entry, modal_cfg, modal_cli, modal_name, env_paths, command="deploy", dry_run=dry_run, original_path=original_path)
 
 
 def _modal_serve_entry(
@@ -757,6 +916,7 @@ def _modal_serve_entry(
     modal_name: str | None,
     modal_cli: str,
     env_file: Sequence[str],
+    original_path: Path | None = None,
 ) -> None:
     modal_cfg = entry.modal
     if modal_cfg is None:
@@ -764,7 +924,7 @@ def _modal_serve_entry(
 
     env_paths = _determine_env_files(entry, env_file)
     click.echo('Using env file(s): ' + ', '.join(str(p) for p in env_paths))
-    _run_modal_with_entry(entry, modal_cfg, modal_cli, modal_name, env_paths, command="serve")
+    _run_modal_with_entry(entry, modal_cfg, modal_cli, modal_name, env_paths, command="serve", original_path=original_path)
 
 @click.group(
     name='task-app',
@@ -862,11 +1022,22 @@ def _determine_env_files(entry: TaskAppEntry, user_env_files: Sequence[str]) ->
     if resolved:
         return resolved
 
-    defaults = [Path(path).expanduser() for path in (entry.env_files or []) if Path(path).expanduser().exists()]
-    if defaults:
-        return defaults
-
-    env_candidates = sorted(REPO_ROOT.glob('**/*.env'))
+    # Always prompt for env file selection instead of auto-loading defaults
+    # Look for env files in current working directory first, then repo root
+    cwd = Path.cwd()
+    env_candidates = []
+    
+    # Add CWD env files first (prioritized)
+    cwd_env_files = sorted(cwd.glob('**/*.env'))
+    env_candidates.extend(cwd_env_files)
+    
+    # Add repo root env files
+    repo_env_files = sorted(REPO_ROOT.glob('**/*.env'))
+    # Avoid duplicates
+    for repo_file in repo_env_files:
+        if repo_file not in env_candidates:
+            env_candidates.append(repo_file)
+    
     if not env_candidates:
         raise click.ClickException('No env file found. Pass --env-file explicitly.')
 
@@ -995,7 +1166,7 @@ def deploy_app(app_id: str | None, modal_name: str | None, dry_run: bool, modal_
         return
 
     entry = choice.ensure_entry()
-    _deploy_entry(entry, modal_name, dry_run, modal_cli, env_file)
+    _deploy_entry(entry, modal_name, dry_run, modal_cli, env_file, original_path=choice.path)
 
 @task_app_group.command('modal-serve')
 @click.argument('app_id', type=str, required=False)
@@ -1012,7 +1183,7 @@ def modal_serve_app(app_id: str | None, modal_cli: str, modal_name: str | None,
         return
 
     entry = choice.ensure_entry()
-    _modal_serve_entry(entry, modal_name, modal_cli, env_file)
+    _modal_serve_entry(entry, modal_name, modal_cli, env_file, original_path=choice.path)
 
 
 def _write_modal_entrypoint(
@@ -1021,21 +1192,58 @@ def _write_modal_entrypoint(
     override_name: str | None,
     *,
     dotenv_paths: Sequence[str] | None = None,
+    original_path: Path | None = None,
 ) -> Path:
     modal_name = override_name or modal_cfg.app_name
 
+    # For dynamically discovered apps, import the module by its package path
+    # Compute the module name relative to the mounted repo root (/opt/synth_ai_repo)
+    remote_file_str: str | None = None
+    if original_path:
+        try:
+            # Build lookup of local->remote mounts
+            mount_map: list[tuple[Path, Path]] = [
+                (Path(local).resolve(), Path(remote)) for (local, remote) in modal_cfg.extra_local_dirs
+            ]
+            orig = Path(original_path).resolve()
+            for local_src, remote_dst in mount_map:
+                with contextlib.suppress(Exception):
+                    if orig.is_relative_to(local_src):  # py311+
+                        remote_file_str = str((remote_dst / orig.relative_to(local_src)).resolve())
+                        break
+                try:
+                    rel = orig.relative_to(local_src)
+                    remote_file_str = str((remote_dst / rel).resolve())
+                    break
+                except Exception:
+                    pass
+        except Exception:
+            remote_file_str = None
     module_name = entry.config_factory.__module__
+
+    # Prefer a guaranteed mount for the discovered file to avoid package import issues
+    guaranteed_file_str: str | None = None
+    if original_path:
+        guaranteed_file_str = str((Path("/opt/synth_ai_repo/__local_task_app__") / Path(original_path).stem).with_suffix('.py'))
+    
     dotenv_paths = [str(Path(path)) for path in (dotenv_paths or [])]
 
     pip_packages = list(modal_cfg.pip_packages)
 
     local_dirs = [(str(Path(src)), dst) for src, dst in modal_cfg.extra_local_dirs]
+    # Ensure the discovered app directory is mounted, regardless of modal_cfg
+    if original_path:
+        discovered_dir = str(Path(original_path).resolve().parent)
+        mount_dst = "/opt/synth_ai_repo/__local_task_app__"
+        if (discovered_dir, mount_dst) not in local_dirs:
+            local_dirs.append((discovered_dir, mount_dst))
     secret_names = list(modal_cfg.secret_names)
     volume_mounts = [(name, mount) for name, mount in modal_cfg.volume_mounts]
 
     script = f"""from __future__ import annotations
 
 import importlib
+import importlib.util
 import sys
 sys.path.insert(0, '/opt/synth_ai_repo')
 
@@ -1047,6 +1255,7 @@ from synth_ai.task.server import create_task_app
 ENTRY_ID = {entry.app_id!r}
 MODAL_APP_NAME = {modal_name!r}
 MODULE_NAME = {module_name!r}
+    MODULE_FILE = {guaranteed_file_str or remote_file_str!r}
 DOTENV_PATHS = {dotenv_paths!r}
 
 image = Image.debian_slim(python_version={modal_cfg.python_version!r})
@@ -1070,8 +1279,34 @@ volume_map = {{}}
 for vol_name, mount_path in volume_mounts:
     volume_map[mount_path] = Volume.from_name(vol_name, create_if_missing=True)
 
-importlib.import_module(MODULE_NAME)
-
+# Import the module to trigger registration
+if MODULE_FILE:
+    spec = importlib.util.spec_from_file_location(MODULE_NAME or 'task_app_module', MODULE_FILE)
+    if spec and spec.loader:
+        mod = importlib.util.module_from_spec(spec)
+        sys.modules[MODULE_NAME or 'task_app_module'] = mod
+        spec.loader.exec_module(mod)
+    else:
+        raise RuntimeError("Failed to import task app from file: " + str(MODULE_FILE))
+else:
+    # Try module import; if that fails, attempt to load from the guaranteed mount
+    try:
+        importlib.import_module(MODULE_NAME)
+    except Exception:
+        import os
+        fallback_file = '/opt/synth_ai_repo/__local_task_app__/' + (MODULE_NAME.split('.')[-1] if MODULE_NAME else 'task_app') + '.py'
+        if os.path.exists(fallback_file):
+            spec = importlib.util.spec_from_file_location(MODULE_NAME or 'task_app_module', fallback_file)
+            if spec and spec.loader:
+                mod = importlib.util.module_from_spec(spec)
+                sys.modules[MODULE_NAME or 'task_app_module'] = mod
+                spec.loader.exec_module(mod)
+            else:
+                raise
+        else:
+            raise
+
+# Get the entry from registry (now that it's registered)
 entry = registry.get(ENTRY_ID)
 modal_cfg = entry.modal
 if modal_cfg is None:

synth_ai/task/apps/__init__.py

@@ -2,7 +2,11 @@ from __future__ import annotations
 
 """Registry for Task Apps exposed via the shared FastAPI harness."""
 
+import importlib
+import os
+import sys
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Callable, Dict, Iterable, List, Sequence
 
 from ..server import TaskAppConfig
@@ -64,6 +68,11 @@ class TaskAppRegistry:
 
     def __iter__(self) -> Iterable[TaskAppEntry]:
         return iter(self.list())
+    
+    def clear(self) -> None:
+        """Clear all registered task apps."""
+        self._entries.clear()
+        self._alias_to_id.clear()
 
 
 registry = TaskAppRegistry()
@@ -73,16 +82,48 @@ def register_task_app(*, entry: TaskAppEntry) -> None:
     registry.register(entry)
 
 
-
-# Register built-in task apps
-try:
-    from . import grpo_crafter  # noqa: F401
-except Exception:
-    # Defer import errors so CLI can report missing deps gracefully
-    pass
-
-try:
-    from . import math_single_step  # noqa: F401
-except Exception:
-    # Defer import errors so CLI can report missing deps gracefully
-    pass
+def discover_task_apps_from_cwd() -> None:
+    """Discover and register task apps from the current working directory and subdirectories."""
+    cwd = Path.cwd()
+    
+    # Look for task app files in common patterns
+    patterns = [
+        "**/task_app/*.py",
+        "**/task_apps/*.py", 
+        "**/*_task_app.py",
+        "**/grpo_crafter.py",
+        "**/math_single_step.py",
+    ]
+    
+    discovered_files = []
+    for pattern in patterns:
+        discovered_files.extend(cwd.glob(pattern))
+    
+    # Add current directory to Python path temporarily
+    original_path = sys.path.copy()
+    try:
+        sys.path.insert(0, str(cwd))
+        
+        for file_path in discovered_files:
+            if file_path.name.startswith('__'):
+                continue
+                
+            # Convert file path to module name
+            relative_path = file_path.relative_to(cwd)
+            module_parts = list(relative_path.parts[:-1]) + [relative_path.stem]
+            module_name = '.'.join(module_parts)
+            
+            try:
+                # Import the module to trigger registration
+                importlib.import_module(module_name)
+            except Exception as exc:
+                # Silently skip modules that can't be imported
+                # This allows for graceful handling of missing dependencies
+                continue
+                
+    finally:
+        sys.path[:] = original_path
+
+
+# Note: Task apps are now discovered dynamically by the CLI, not auto-registered
+# This allows for better separation between SDK and example-specific implementations

{synth_ai-0.2.9.dev3.dist-info → synth_ai-0.2.9.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.2.9.dev3
+Version: 0.2.9.dev5
 Summary: RL as a service SDK - Core AI functionality and tracing
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT