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

synth_ai/api/train/config_finder.py

@@ -18,17 +18,15 @@ class ConfigCandidate:
 
 
 def _iter_candidate_paths() -> Iterable[Path]:
-    # Prefer explicit config directories first
-    preferred = [
-        REPO_ROOT / "configs",
-        REPO_ROOT / "examples",
-        REPO_ROOT / "training",
-    ]
     seen: set[Path] = set()
-    for base in preferred:
-        if not base.exists():
-            continue
-        for path in base.rglob("*.toml"):
+    
+    # Prioritize current working directory first
+    try:
+        cwd = Path.cwd().resolve()
+    except Exception:
+        cwd = None
+    if cwd and cwd.exists():
+        for path in cwd.rglob("*.toml"):
             if any(part in _SKIP_DIRS for part in path.parts):
                 continue
             resolved = path.resolve()
@@ -37,14 +35,16 @@ def _iter_candidate_paths() -> Iterable[Path]:
             seen.add(resolved)
             yield resolved
 
-    # Additionally, discover configs anywhere under the current working directory
-    # so users can run `uvx synth-ai train` from project roots without passing --config.
-    try:
-        cwd = Path.cwd().resolve()
-    except Exception:
-        cwd = None
-    if cwd and cwd.exists():
-        for path in cwd.rglob("*.toml"):
+    # Then look in explicit config directories
+    preferred = [
+        REPO_ROOT / "configs",
+        REPO_ROOT / "examples",
+        REPO_ROOT / "training",
+    ]
+    for base in preferred:
+        if not base.exists():
+            continue
+        for path in base.rglob("*.toml"):
             if any(part in _SKIP_DIRS for part in path.parts):
                 continue
             resolved = path.resolve()

synth_ai/api/train/env_resolver.py

@@ -55,17 +55,43 @@ class EnvResolver:
 
 def _collect_default_candidates(config_path: Path | None) -> list[Path]:
     candidates: list[Path] = []
+    cwd = Path.cwd()
+    
+    # Prioritize CWD env files
+    cwd_env = cwd / ".env"
+    if cwd_env.exists():
+        candidates.append(cwd_env.resolve())
+    
+    # Search for additional .env files in CWD subdirectories
+    for sub in cwd.glob("**/.env"):
+        try:
+            resolved = sub.resolve()
+        except Exception:
+            continue
+        if resolved in candidates:
+            continue
+        # avoid nested venv caches
+        if any(part in {".venv", "node_modules", "__pycache__"} for part in resolved.parts):
+            continue
+        if len(candidates) >= 20:
+            break
+        candidates.append(resolved)
+    
+    # Then config path env file
     if config_path:
         cfg_env = config_path.parent / ".env"
         if cfg_env.exists():
             candidates.append(cfg_env.resolve())
+    
+    # Then repo env files
     repo_env = REPO_ROOT / ".env"
     if repo_env.exists():
         candidates.append(repo_env.resolve())
     examples_env = REPO_ROOT / "examples" / ".env"
     if examples_env.exists():
         candidates.append(examples_env.resolve())
-    # Search shallow depth for additional .env files
+    
+    # Search shallow depth for additional .env files in examples
     for sub in (REPO_ROOT / "examples").glob("**/.env"):
         try:
             resolved = sub.resolve()
@@ -79,6 +105,7 @@ def _collect_default_candidates(config_path: Path | None) -> list[Path]:
         if len(candidates) >= 20:
             break
         candidates.append(resolved)
+    
     deduped: list[Path] = []
     for path in candidates:
         if path not in deduped:

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,10 +1192,35 @@ 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__
+    
     dotenv_paths = [str(Path(path)) for path in (dotenv_paths or [])]
 
     pip_packages = list(modal_cfg.pip_packages)
@@ -1036,6 +1232,7 @@ def _write_modal_entrypoint(
     script = f"""from __future__ import annotations
 
 import importlib
+import importlib.util
 import sys
 sys.path.insert(0, '/opt/synth_ai_repo')
 
@@ -1047,6 +1244,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 = {remote_file_str!r}
 DOTENV_PATHS = {dotenv_paths!r}
 
 image = Image.debian_slim(python_version={modal_cfg.python_version!r})
@@ -1070,8 +1268,19 @@ 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:
+    importlib.import_module(MODULE_NAME)
 
+# Get the entry from registry (now that it's registered)
 entry = registry.get(ENTRY_ID)
 modal_cfg = entry.modal
 if modal_cfg is None: