truss 0.11.6rc102__py3-none-any.whl → 0.11.24rc2__py3-none-any.whl

truss/api/__init__.py

@@ -65,6 +65,7 @@ def push(
     progress_bar: Optional[Type["progress.Progress"]] = None,
     include_git_info: bool = False,
     preserve_env_instance_type: bool = True,
+    deploy_timeout_minutes: Optional[int] = None,
 ) -> definitions.ModelDeployment:
     """
     Pushes a Truss to Baseten.
@@ -77,13 +78,13 @@ def push(
             promote the truss to production after deploy completes.
         promote: Push the truss as a published deployment. Even if a production deployment exists,
             promote the truss to production after deploy completes.
-        preserve_previous_production_deployment: Preserve the previous production deployment’s autoscaling
+        preserve_previous_production_deployment: Preserve the previous production deployment's autoscaling
             setting. When not specified, the previous production deployment will be updated to allow it to
             scale to zero. Can only be use in combination with `promote` option.
         trusted: [DEPRECATED]
         deployment_name: Name of the deployment created by the push. Can only be
             used in combination with `publish` or `promote`. Deployment name must
-            only contain alphanumeric, ’.’, ’-’ or ’_’ characters.
+            only contain alphanumeric, '.', '-' or '_' characters.
         environment: Name of stable environment on baseten.
         progress_bar: Optional `rich.progress.Progress` if output is desired.
         include_git_info: Whether to attach git versioning info (sha, branch, tag) to
@@ -92,6 +93,7 @@ def push(
         preserve_env_instance_type: When pushing a truss to an environment, whether to use the resources
           specified in the truss config to resolve the instance type or preserve the instance type
           configured in the specified environment.
+        deploy_timeout_minutes: Optional timeout in minutes for the deployment operation.
 
     Returns:
         The newly created ModelDeployment.
@@ -135,6 +137,7 @@ def push(
         progress_bar=progress_bar,
         include_git_info=include_git_info,
         preserve_env_instance_type=preserve_env_instance_type,
+        deploy_timeout_minutes=deploy_timeout_minutes,
     )  # type: ignore
 
     return definitions.ModelDeployment(cast(BasetenService, service))

truss/base/constants.py

@@ -49,6 +49,7 @@ FILENAME_CONSTANTS_MAP = {
 }
 
 SERVER_DOCKERFILE_TEMPLATE_NAME = "server.Dockerfile.jinja"
+NO_BUILD_DOCKERFILE_TEMPLATE_NAME = "no_build.Dockerfile.jinja"
 MODEL_DOCKERFILE_NAME = "Dockerfile"
 MODEL_CACHE_PATH = pathlib.Path("/app/model_cache")
 README_TEMPLATE_NAME = "README.md.jinja"

truss/base/trt_llm_config.py

@@ -68,6 +68,7 @@ class TrussTRTLLMQuantizationType(str, Enum):
     FP8_KV = "fp8_kv"
     FP4 = "fp4"
     FP4_KV = "fp4_kv"
+    FP4_MLP_ONLY = "fp4_mlp_only"
 
 
 class TrussTRTLLMPluginConfiguration(PydanticTrTBaseModel):
@@ -329,9 +330,16 @@ pip install truss==0.10.8
             raise ValueError("Using fp8 context fmha requires paged context fmha")
         if (
             self.plugin_configuration.use_fp8_context_fmha
-            and not self.quantization_type == TrussTRTLLMQuantizationType.FP8_KV
+            and self.quantization_type
+            not in (
+                TrussTRTLLMQuantizationType.FP8_KV,
+                TrussTRTLLMQuantizationType.FP4_KV,
+            )
         ):
-            raise ValueError("Using fp8 context fmha requires fp8 kv cache dtype")
+            raise ValueError(
+                "Using fp8 context fmha requires fp8 kv, or fp4 with kv cache dtype"
+            )
+
         return self
 
     def _validate_speculator_config(self):
@@ -570,6 +578,7 @@ class TRTLLMConfigurationV2(PydanticTrTBaseModel):
             "quantization_type",
             "quantization_config",
             "skip_build_result",
+            "num_builder_gpus",
         ]
 
         build_settings = self.build.model_dump(exclude_unset=True)
@@ -705,7 +714,9 @@ def trt_llm_common_validation(config: "TrussConfig"):
             "accelerators or newer (CUDA_COMPUTE>=89)"
         )
     elif trt_llm_config.build.quantization_type in [
-        TrussTRTLLMQuantizationType.FP4
+        TrussTRTLLMQuantizationType.FP4,
+        TrussTRTLLMQuantizationType.FP4_KV,
+        TrussTRTLLMQuantizationType.FP4_MLP_ONLY,
     ] and config.resources.accelerator.accelerator in [
         truss_config.Accelerator.H100,
         truss_config.Accelerator.L4,

truss/base/truss_config.py

@@ -147,7 +147,7 @@ class ModelRepo(custom_types.ConfigModel):
     volume_folder: Optional[
         Annotated[str, pydantic.StringConstraints(min_length=1)]
     ] = None
-    use_volume: bool = False
+    use_volume: bool
     kind: ModelRepoSourceKind = ModelRepoSourceKind.HF
     runtime_secret_name: str = "hf_access_token"
 
@@ -163,7 +163,7 @@ class ModelRepo(custom_types.ConfigModel):
             return v
         if v.get("kind") == ModelRepoSourceKind.HF.value and v.get("revision") is None:
             logger.warning(
-                "the key `revision: str` is required for use_volume=True huggingface repos."
+                "the key `revision: str` is required for use_volume=True huggingface repos. For S3/GCS/Azure repos, set it to any non-empty string."
             )
             raise_insufficent_revision(v.get("repo_id"), v.get("revision"))
         if v.get("volume_folder") is None or len(v["volume_folder"]) == 0:
@@ -202,7 +202,14 @@ class ModelCache(pydantic.RootModel[list[ModelRepo]]):
             )
 
 
-class CacheInternal(ModelCache): ...
+class ModelRepoCacheInternal(ModelRepo):
+    use_volume: bool = False  # override
+
+
+class CacheInternal(pydantic.RootModel[list[ModelRepoCacheInternal]]):
+    @property
+    def models(self) -> list[ModelRepoCacheInternal]:
+        return self.root
 
 
 class HealthChecks(custom_types.ConfigModel):
@@ -541,11 +548,19 @@ class BaseImage(custom_types.ConfigModel):
 
 
 class DockerServer(custom_types.ConfigModel):
-    start_command: str
+    start_command: Optional[str] = None
     server_port: int
     predict_endpoint: str
     readiness_endpoint: str
     liveness_endpoint: str
+    run_as_user_id: Optional[int] = None
+    no_build: Optional[bool] = None
+
+    @pydantic.model_validator(mode="after")
+    def _validate_start_command(self) -> "DockerServer":
+        if not self.no_build and self.start_command is None:
+            raise ValueError("start_command is required when no_build is not true")
+        return self
 
 
 class TrainingArtifactReference(custom_types.ConfigModel):

truss/cli/chains_commands.py

@@ -1,6 +1,6 @@
 import time
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, cast
 
 import rich
 import rich.live
@@ -14,10 +14,13 @@ from rich import progress
 
 from truss.cli import remote_cli
 from truss.cli.cli import truss_cli
+from truss.cli.resolvers.chain_team_resolver import resolve_chain_team_name
 from truss.cli.utils import common, output
 from truss.cli.utils.output import console
 from truss.remote.baseten.core import ACTIVE_STATUS, DEPLOYING_STATUSES
+from truss.remote.baseten.remote import BasetenRemote
 from truss.remote.baseten.utils.status import get_displayable_status
+from truss.remote.remote_factory import RemoteFactory
 from truss.util import user_config
 from truss.util.log_utils import LogInterceptor
 
@@ -211,6 +214,30 @@ def _create_chains_table(service) -> Tuple[rich.table.Table, List[str]]:
     default=False,
     help=common.INCLUDE_GIT_INFO_DOC,
 )
+@click.option(
+    "--disable-chain-download",
+    "disable_chain_download",
+    is_flag=True,
+    required=False,
+    default=False,
+    help="Disable downloading of pushed chain source code from the UI.",
+)
+@click.option(
+    "--deployment-name",
+    type=str,
+    required=False,
+    help=(
+        "Name of the deployment created by the publish. Can only be used "
+        "in combination with '--publish' or '--promote'."
+    ),
+)
+@click.option(
+    "--team",
+    "provided_team_name",
+    type=str,
+    required=False,
+    help="Team name for the chain deployment",
+)
 @click.pass_context
 @common.common_options()
 def push_chain(
@@ -227,6 +254,9 @@ def push_chain(
     environment: Optional[str],
     experimental_watch_chainlet_names: Optional[str],
     include_git_info: bool = False,
+    disable_chain_download: bool = False,
+    deployment_name: Optional[str] = None,
+    provided_team_name: Optional[str] = None,
 ) -> None:
     """
     Deploys a chain remotely.
@@ -271,10 +301,24 @@ def push_chain(
     if not include_git_info:
         include_git_info = user_config.settings.include_git_info
 
+    # Resolve team if not in dryrun mode
+    team_id = None
     with framework.ChainletImporter.import_target(source, entrypoint) as entrypoint_cls:
         chain_name = (
             name or entrypoint_cls.meta_data.chain_name or entrypoint_cls.display_name
         )
+
+        remote_provider = None
+        if not dryrun and remote:
+            remote_provider = cast(BasetenRemote, RemoteFactory.create(remote=remote))
+            existing_teams = remote_provider.api.get_teams()
+            _, team_id = resolve_chain_team_name(
+                remote_provider,
+                provided_team_name,
+                existing_chain_name=chain_name,
+                existing_teams=existing_teams,
+            )
+
         options = chains_def.PushOptionsBaseten.create(
             chain_name=chain_name,
             promote=promote,
@@ -284,6 +328,10 @@ def push_chain(
             environment=environment,
             include_git_info=include_git_info,
             working_dir=source.parent if source.is_file() else source.resolve(),
+            disable_chain_download=disable_chain_download,
+            deployment_name=deployment_name,
+            team_id=team_id,
+            remote_provider=remote_provider,
         )
         service = deployment_client.push(
             entrypoint_cls, options, progress_bar=progress.Progress

truss/cli/cli.py

@@ -19,6 +19,7 @@ from truss.base.truss_config import Build, ModelServer, TransportKind
 from truss.cli import remote_cli
 from truss.cli.logs import utils as cli_log_utils
 from truss.cli.logs.model_log_watcher import ModelDeploymentLogWatcher
+from truss.cli.resolvers.model_team_resolver import resolve_model_team_name
 from truss.cli.utils import common
 from truss.cli.utils.output import console, error_console
 from truss.remote.baseten.core import (
@@ -462,7 +463,7 @@ def run_python(script, target_directory):
     required=False,
     help=(
         "Name of the deployment created by the push. Can only be "
-        "used in combination with '--publish' or '--promote'."
+        "used in combination with --publish or --promote."
     ),
 )
 @click.option(
@@ -501,6 +502,19 @@ def run_python(script, target_directory):
         "Default is --preserve-env-instance-type."
     ),
 )
+@click.option(
+    "--deploy-timeout-minutes",
+    type=int,
+    required=False,
+    help="Timeout in minutes for the deploy operation.",
+)
+@click.option(
+    "--team",
+    "provided_team_name",
+    type=str,
+    required=False,
+    help="Team name for the model",
+)
 @common.common_options()
 def push(
     target_directory: str,
@@ -518,6 +532,8 @@ def push(
     include_git_info: bool = False,
     tail: bool = False,
     preserve_env_instance_type: bool = True,
+    deploy_timeout_minutes: Optional[int] = None,
+    provided_team_name: Optional[str] = None,
 ) -> None:
     """
     Pushes a truss to a TrussRemote.
@@ -547,9 +563,21 @@ def push(
     if not model_name:
         model_name = remote_cli.inquire_model_name()
 
+    # Resolve team_id if BasetenRemote
+    team_id = None
+    if isinstance(remote_provider, BasetenRemote):
+        existing_teams = remote_provider.api.get_teams()
+        _, team_id = resolve_model_team_name(
+            remote_provider=remote_provider,
+            provided_team_name=provided_team_name,
+            existing_model_name=model_name,
+            existing_teams=existing_teams,
+        )
+
     if promote and environment:
-        promote_warning = "'promote' flag and 'environment' flag were both specified. Ignoring the value of 'promote'"
-        console.print(promote_warning, style="yellow")
+        raise click.UsageError(
+            "'promote' flag and 'environment' flag cannot both be specified."
+        )
     if promote and not environment:
         environment = PRODUCTION_ENVIRONMENT_NAME
 
@@ -611,11 +639,12 @@ def push(
             console.print(fp8_and_num_builder_gpus_text, style="yellow")
 
     source = Path(target_directory)
-    # TODO(Abu): This needs to be refactored to be more generic
+    working_dir = source.parent if source.is_file() else source.resolve()
+
     service = remote_provider.push(
-        tr,
+        truss_handle=tr,
         model_name=model_name,
-        working_dir=source.parent if source.is_file() else source.resolve(),
+        working_dir=working_dir,
         publish=publish,
         promote=promote,
         preserve_previous_prod_deployment=preserve_previous_production_deployment,
@@ -625,7 +654,9 @@ def push(
         progress_bar=progress.Progress,
         include_git_info=include_git_info,
         preserve_env_instance_type=preserve_env_instance_type,
-    )  # type: ignore
+        deploy_timeout_minutes=deploy_timeout_minutes,
+        team_id=team_id,
+    )
 
     click.echo(f"✨ Model {model_name} was successfully pushed ✨")
 

truss/cli/logs/base_watcher.py

@@ -17,7 +17,9 @@ class LogWatcher(ABC):
     # NB(nikhil): we add buffer for clock skew, so this helps us detect duplicates.
     # TODO(nikhil): clean up hashes so this doesn't grow indefinitely.
     _log_hashes: set[str] = set()
-    _last_poll_time: Optional[int] = None
+
+    _last_poll_time_ms: Optional[int] = None
+    _last_log_time_ms: Optional[int] = None
 
     def __init__(self, api: BasetenApi):
         self.api = api
@@ -26,37 +28,54 @@ class LogWatcher(ABC):
         log_str = f"{log.timestamp}-{log.message}-{log.replica}"
         return hashlib.sha256(log_str.encode("utf-8")).hexdigest()
 
-    def _poll(self) -> Iterator[ParsedLog]:
-        start_epoch: Optional[int] = None
-        now = int(time.time() * 1000)
-        if self._last_poll_time is not None:
-            start_epoch = self._last_poll_time - CLOCK_SKEW_BUFFER_MS
+    def get_start_epoch_ms(self, now_ms: int) -> Optional[int]:
+        if self._last_poll_time_ms:
+            return self._last_poll_time_ms - CLOCK_SKEW_BUFFER_MS
+
+        return None
 
+    def fetch_and_parse_logs(
+        self, start_epoch_millis: Optional[int], end_epoch_millis: Optional[int]
+    ) -> Iterator[ParsedLog]:
         api_logs = self.fetch_logs(
-            start_epoch_millis=start_epoch, end_epoch_millis=now + CLOCK_SKEW_BUFFER_MS
+            start_epoch_millis=start_epoch_millis, end_epoch_millis=end_epoch_millis
         )
 
         parsed_logs = parse_logs(api_logs)
+
         for log in parsed_logs:
-            h = self._hash_log(log)
-            if h not in self._log_hashes:
+            if (h := self._hash_log(log)) not in self._log_hashes:
                 self._log_hashes.add(h)
+
                 yield log
 
-        self._last_poll_time = now
+    def poll(self) -> Iterator[ParsedLog]:
+        now_ms = int(time.time() * 1000)
+        start_epoch_ms = self.get_start_epoch_ms(now_ms)
+
+        for log in self.fetch_and_parse_logs(
+            start_epoch_millis=start_epoch_ms,
+            end_epoch_millis=now_ms + CLOCK_SKEW_BUFFER_MS,
+        ):
+            yield log
+
+            epoch_ns = int(log.timestamp)
+            self._last_log_time_ms = int(epoch_ns / 1e6)
+
+        self._last_poll_time_ms = now_ms
 
     def watch(self) -> Iterator[ParsedLog]:
         self.before_polling()
         with console.status("Polling logs", spinner="aesthetic"):
             while True:
-                for log in self._poll():
+                for log in self.poll():
                     yield log
                 if self._log_hashes:
                     break
                 time.sleep(POLL_INTERVAL_SEC)
 
             while self.should_poll_again():
-                for log in self._poll():
+                for log in self.poll():
                     yield log
                 time.sleep(POLL_INTERVAL_SEC)
                 self.post_poll()

truss/cli/logs/model_log_watcher.py

@@ -1,9 +1,12 @@
+from functools import cached_property
 from typing import Any, List, Optional
 
 from truss.cli.logs.base_watcher import LogWatcher
 from truss.remote.baseten.api import BasetenApi
 from truss.remote.baseten.utils.status import MODEL_RUNNING_STATES
 
+MAX_LOOK_BACK_MS = 1000 * 60 * 60  # 1 hour.
+
 
 class ModelDeploymentLogWatcher(LogWatcher):
     _model_id: str
@@ -25,11 +28,31 @@ class ModelDeploymentLogWatcher(LogWatcher):
             self._model_id, self._deployment_id, start_epoch_millis, end_epoch_millis
         )
 
+    def get_start_epoch_ms(self, now_ms: int) -> Optional[int]:
+        # NOTE(Tyron): If there can be multiple replicas,
+        # we can't use a timestamp cursor to poll for logs.
+        if not self._is_development:
+            return super().get_start_epoch_ms(now_ms)
+
+        # Cursor logic.
+
+        if self._last_log_time_ms:
+            return max(self._last_log_time_ms, now_ms - MAX_LOOK_BACK_MS)
+
+        return None
+
     def should_poll_again(self) -> bool:
         return self._current_status in MODEL_RUNNING_STATES
 
+    def _get_deployment(self) -> Any:
+        return self.api.get_deployment(self._model_id, self._deployment_id)
+
     def _get_current_status(self) -> str:
-        return self.api.get_deployment(self._model_id, self._deployment_id)["status"]
+        return self._get_deployment()["status"]
+
+    @cached_property
+    def _is_development(self) -> bool:
+        return self._get_deployment()["is_development"]
 
     def post_poll(self) -> None:
         self._current_status = self._get_current_status()

truss/cli/remote_cli.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from InquirerPy import inquirer
 from InquirerPy.validator import ValidationError, Validator
 
@@ -56,3 +58,30 @@ def inquire_remote_name() -> str:
 
 def inquire_model_name() -> str:
     return inquirer.text("📦 Name this model:", qmark="").execute()
+
+
+def get_team_id_from_name(
+    teams: dict[str, dict[str, str]], team_name: str
+) -> Optional[str]:
+    team = teams.get(team_name)
+    return team["id"] if team else None
+
+
+def format_available_teams(teams: dict[str, dict[str, str]]) -> str:
+    team_names = list(teams.keys())
+    return ", ".join(team_names) if team_names else "none"
+
+
+def inquire_team(
+    existing_teams: Optional[dict[str, dict[str, str]]] = None,
+) -> Optional[str]:
+    if existing_teams is not None:
+        selected_team_name = inquirer.select(
+            "👥 Which team do you want to push to?",
+            qmark="",
+            choices=list[str](existing_teams.keys()),
+        ).execute()
+        return selected_team_name
+
+    # If no existing teams, return None (don't propagate team param)
+    return None

truss/cli/resolvers/chain_team_resolver.py

@@ -0,0 +1,82 @@
+"""Team resolution logic for chains."""
+
+from typing import Optional
+
+import click
+
+from truss.cli import remote_cli
+from truss.remote.baseten.remote import BasetenRemote
+
+
+def resolve_chain_team_name(
+    remote_provider: BasetenRemote,
+    provided_team_name: Optional[str],
+    existing_chain_name: Optional[str] = None,
+    existing_teams: Optional[dict[str, dict[str, str]]] = None,
+) -> tuple[Optional[str], Optional[str]]:
+    """Resolve team name and team_id from provided team name or by prompting the user.
+    Returns a tuple of (team_name, team_id).
+    This function handles 8 distinct scenarios organized into 3 high-level categories:
+
+    HIGH-LEVEL SCENARIO 1: --team PROVIDED
+        SCENARIO 1: Valid team name, user has access
+            → Returns (team_name, team_id) for that team (no prompt, no error)
+        SCENARIO 2: Invalid team name (does not exist)
+            → Raises ClickException with error message listing available teams
+
+    HIGH-LEVEL SCENARIO 2: --team NOT PROVIDED, Chain does not exist
+        SCENARIO 3: User has multiple teams, no existing chain
+            → Prompts user to select a team via inquire_team()
+        SCENARIO 6: User has exactly one team, no existing chain
+            → Returns (team_name, team_id) for the single team automatically (no prompt)
+
+    HIGH-LEVEL SCENARIO 3: --team NOT PROVIDED, Chain exists
+        SCENARIO 4: User has multiple teams, existing chain in exactly one team
+            → Auto-detects and returns (team_name, team_id) for that team (no prompt)
+        SCENARIO 5: User has multiple teams, existing chain exists in multiple teams
+            → Prompts user to select a team via inquire_team()
+        SCENARIO 7: User has exactly one team, existing chain matches the team
+            → Auto-detects and returns (team_name, team_id) for the single team (no prompt)
+        SCENARIO 8: User has exactly one team, existing chain exists in different team
+            → Returns (team_name, team_id) for the single team automatically (no prompt, uses user's only team)
+    """
+    if existing_teams is None:
+        existing_teams = remote_provider.api.get_teams()
+
+    def _get_team_id(team_name: Optional[str]) -> Optional[str]:
+        if team_name and existing_teams:
+            team_data = existing_teams.get(team_name)
+            return team_data["id"] if team_data else None
+        return None
+
+    if provided_team_name is not None:
+        if provided_team_name not in existing_teams:
+            available_teams_str = remote_cli.format_available_teams(existing_teams)
+            raise click.ClickException(
+                f"Team '{provided_team_name}' does not exist. Available teams: {available_teams_str}"
+            )
+        return (provided_team_name, _get_team_id(provided_team_name))
+
+    existing_chains = None
+    if existing_chain_name is not None:
+        existing_chains = remote_provider.api.get_chains()
+        matching_chains = [
+            c for c in existing_chains if c.get("name") == existing_chain_name
+        ]
+
+        if len(matching_chains) > 1:
+            selected_team_name = remote_cli.inquire_team(existing_teams=existing_teams)
+            return (selected_team_name, _get_team_id(selected_team_name))
+
+        if len(matching_chains) == 1:
+            chain_team = matching_chains[0].get("team")
+            chain_team_name = chain_team.get("name") if chain_team else None
+            if chain_team_name and chain_team_name in existing_teams:
+                return (chain_team_name, _get_team_id(chain_team_name))
+
+    if len(existing_teams) == 1:
+        single_team_name = list(existing_teams.keys())[0]
+        return (single_team_name, _get_team_id(single_team_name))
+
+    selected_team_name = remote_cli.inquire_team(existing_teams=existing_teams)
+    return (selected_team_name, _get_team_id(selected_team_name))

truss/cli/resolvers/model_team_resolver.py

@@ -0,0 +1,90 @@
+"""Team resolution logic for models."""
+
+from typing import Optional
+
+import click
+
+from truss.cli import remote_cli
+from truss.remote.baseten.remote import BasetenRemote
+
+
+def resolve_model_team_name(
+    remote_provider: BasetenRemote,
+    provided_team_name: Optional[str],
+    existing_model_name: Optional[str] = None,
+    existing_teams: Optional[dict[str, dict[str, str]]] = None,
+) -> tuple[Optional[str], Optional[str]]:
+    """Resolve team name and team_id from provided team name or by prompting the user.
+    Returns a tuple of (team_name, team_id).
+    This function handles 8 distinct scenarios organized into 3 high-level categories:
+
+    HIGH-LEVEL SCENARIO 1: --team PROVIDED
+        SCENARIO 1: Valid team name, user has access
+            → Returns (team_name, team_id) for that team (no prompt, no error)
+        SCENARIO 2: Invalid team name (does not exist)
+            → Raises ClickException with error message listing available teams
+
+    HIGH-LEVEL SCENARIO 2: --team NOT PROVIDED, Model does not exist
+        SCENARIO 3: User has multiple teams, no existing model
+            → Prompts user to select a team via inquire_team()
+        SCENARIO 6: User has exactly one team, no existing model
+            → Returns (team_name, team_id) for the single team automatically (no prompt)
+
+    HIGH-LEVEL SCENARIO 3: --team NOT PROVIDED, Model exists
+        SCENARIO 4: User has multiple teams, existing model in exactly one team
+            → Auto-detects and returns (team_name, team_id) for that team (no prompt)
+        SCENARIO 5: User has multiple teams, existing model exists in multiple teams
+            → Prompts user to select a team via inquire_team()
+        SCENARIO 7: User has exactly one team, existing model matches the team
+            → Auto-detects and returns (team_name, team_id) for the single team (no prompt)
+        SCENARIO 8: User has exactly one team, existing model exists in different team
+            → Returns (team_name, team_id) for the single team automatically (no prompt, uses user's only team)
+    """
+    if existing_teams is None:
+        existing_teams = remote_provider.api.get_teams()
+
+    def _get_team_id(team_name: Optional[str]) -> Optional[str]:
+        if team_name and existing_teams:
+            team_data = existing_teams.get(team_name)
+            return team_data["id"] if team_data else None
+        return None
+
+    def _get_matching_models_in_accessible_teams(model_name: str) -> list[dict]:
+        """Get models matching the name that are in teams the user has access to."""
+        all_models_data = remote_provider.api.models()
+        accessible_team_ids = {team_data["id"] for team_data in existing_teams.values()}
+
+        return [
+            m
+            for m in all_models_data.get("models", [])
+            if m.get("name") == model_name
+            and m.get("team", {}).get("id") in accessible_team_ids
+        ]
+
+    if provided_team_name is not None:
+        if provided_team_name not in existing_teams:
+            available_teams_str = remote_cli.format_available_teams(existing_teams)
+            raise click.ClickException(
+                f"Team '{provided_team_name}' does not exist. Available teams: {available_teams_str}"
+            )
+        return (provided_team_name, _get_team_id(provided_team_name))
+
+    if existing_model_name is not None:
+        matching_models = _get_matching_models_in_accessible_teams(existing_model_name)
+
+        if len(matching_models) == 1:
+            # Exactly one model in an accessible team - auto-detect
+            team = matching_models[0].get("team", {})
+            model_team_name = team.get("name")
+            model_team_id = team.get("id")
+            if model_team_name and model_team_name in existing_teams:
+                return (model_team_name, model_team_id)
+        # If len > 1, multiple models exist - fall through to prompt logic
+        # If len == 0, no models exist - fall through to prompt logic
+
+    if len(existing_teams) == 1:
+        single_team_name = list(existing_teams.keys())[0]
+        return (single_team_name, _get_team_id(single_team_name))
+
+    selected_team_name = remote_cli.inquire_team(existing_teams=existing_teams)
+    return (selected_team_name, _get_team_id(selected_team_name))