freesolo-flash-dev 1.2.119__tar.gz → 1.2.120__tar.gz

{freesolo_flash_dev-1.2.119 → freesolo_flash_dev-1.2.120}/CHANGELOG.md

@@ -25,13 +25,23 @@ This file starts at 1.1.35. Earlier releases are not reconstructed here; use
 
 ### Changed
 
-- Active training and hosted serving now expose exactly `Qwen/Qwen3.5-9B`,
-  `Qwen/Qwen3.8-27B`, and `Qwen/Qwen3.6-35B-A3B`. Qwen3.8 uses the immutable BF16 revision
+- Active training now exposes exactly `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
+  `Qwen/Qwen3.6-35B-A3B`. Hosted serving remains active for 9B and 35B-A3B; hosted Qwen3.8 27B
+  remains inactive. Qwen3.8 uses the immutable BF16 revision
   `1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0` and official native block-FP8 serving revision
-  `017b9c7af6b5689d5dd426a76e0bc077eb5ca20a`. The Qwen3.5 0.8B, 2B, and 4B tiers and
+  `017b9c7af6b5689d5dd426a76e0bc077eb5ca20a`, with the logical base and tokenizer provenance kept
+  distinct from the served checkpoint. The Qwen3.5 0.8B, 2B, and 4B tiers and
   `Qwen/Qwen3.6-27B` cannot activate, while historical status, accepted billing retry,
   cancellation, cleanup, hosted revocation, and exact identity-based undeploy remain available.
-  Qwen3.6 27B adapters are not compatible with Qwen3.8. Customer-owned serving remains 9B-only.
+  Qwen3.6 27B adapters are not compatible with Qwen3.8.
+- Customer-owned serving is now Modal-only and requires explicit `--provider modal`. Modal remains
+  live-qualified for all three active models. The 27B and 35B-A3B qualifications stay bound to the
+  exact certified serving image digest. Each deployment still serves one exact base model. The 27B
+  engine keeps its `H100!` placement and distinct served checkpoint and tokenizer provenance. The
+  35B-A3B engine keeps its H200, BF16, FP8 KV, 32K context, eight-sequence, 4096 batched-token, and
+  six rank-64 LoRA-slot contract. Customer-serving RunPod commands, profiles, identities, and
+  lifecycle code are removed without a compatibility or teardown shim. Managed RunPod training,
+  serverless workers, dependencies, provider routing, artifacts, and caching are unchanged.
 - `[train] init_from_adapter` now works for every source/target algorithm pair. SFT was rejected as
   a warm-start target, so an adapter could be continued only by GRPO or OPD; that restriction
   described the retired trl SFT backend, and the verl backend that replaced it loads a warm-start

{freesolo_flash_dev-1.2.119 → freesolo_flash_dev-1.2.120}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.119
+Version: 1.2.120
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash
@@ -116,10 +116,10 @@ point of use; install it with `pip install freesolo`.
 
 Two components stay Freesolo-operated and are **not** in this repository:
 
-| Component                 | Where it lives                                                                                         | Self-hosted equivalent                                                      |
-| ------------------------- | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------- |
-| Multi-tenant identity     | `api.freesolo.co`; verifies keys and owns projects/orgs                                                | `FLASH_STANDALONE=1` runs single-tenant on your own key                     |
-| Hosted Multi-LoRA serving | `serve.freesolo.co`, deployed from `flash/serving/`; `flash/serve/` owns the client and shared runtime | `flash serve deploy` provisions serving in your own Modal or RunPod account |
+| Component                 | Where it lives                                                                                         | Self-hosted equivalent                                            |
+| ------------------------- | ------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------- |
+| Multi-tenant identity     | `api.freesolo.co`; verifies keys and owns projects/orgs                                                | `FLASH_STANDALONE=1` runs single-tenant on your own key           |
+| Hosted Multi-LoRA serving | `serve.freesolo.co`, deployed from `flash/serving/`; `flash/serve/` owns the client and shared runtime | `flash serve deploy` provisions serving in your own Modal account |
 
 So there are three ways to use Flash: against the **hosted service**, **self-hosted** against
 your own GPU accounts, or as **training and provider code to read and modify**. The training
@@ -127,9 +127,13 @@ path is self-hostable end to end — see **[SELF_HOSTING.md](SELF_HOSTING.md)**.
 
 ## Using the hosted service
 
-The active training and hosted-serving catalog is `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
-`Qwen/Qwen3.6-35B-A3B`. The retired dense Qwen3.6 27B identity is never translated into Qwen3.8,
-and customer-owned Modal or RunPod serving remains limited to Qwen3.5 9B.
+The active training catalog is `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
+`Qwen/Qwen3.6-35B-A3B`. Hosted serving is active for 9B and 35B-A3B; hosted Qwen3.8 27B remains
+inactive. The retired dense Qwen3.6 27B identity is never translated into Qwen3.8. Customer-owned
+Modal supports all three active models; 27B and 35B-A3B are bound to the certified serving image
+digest. Customer-owned `flash serve` requires explicit `--provider modal`. Customer-serving RunPod
+commands and deployment identities are unsupported, with no migration or teardown shim. Managed
+RunPod training remains supported and unchanged.
 
 `flash login` is not interactive. Export `FREESOLO_API_KEY` first so the key does not appear in process listings:
 
@@ -305,8 +309,10 @@ External bearer tokens are rejected rather than accepted unverified. A standalon
 **single-tenant** — whoever holds that key can spend your GPU budget, so keep it off
 untrusted networks. See [the security model](SELF_HOSTING.md#the-security-model).
 
-`flash serve deploy` provisions serving in your own Modal or RunPod account, implementing the
-same contract `flash/serve/` speaks; [docs/serving-contract.md](docs/serving-contract.md)
+`flash serve deploy` provisions serving in your own Modal account and requires explicit
+`--provider modal`. Each deployment owns one exact base model and its compatible adapters; another
+base model requires another deployment. Customer-serving RunPod identities are unsupported.
+It implements the same contract `flash/serve/` speaks; [docs/serving-contract.md](docs/serving-contract.md)
 documents it if you would rather write your own.
 
 The GPU worker image is public and published under an explicit CUDA tag, not `latest`:

{freesolo_flash_dev-1.2.119 → freesolo_flash_dev-1.2.120}/README.md

@@ -33,10 +33,10 @@ point of use; install it with `pip install freesolo`.
 
 Two components stay Freesolo-operated and are **not** in this repository:
 
-| Component                 | Where it lives                                                                                         | Self-hosted equivalent                                                      |
-| ------------------------- | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------- |
-| Multi-tenant identity     | `api.freesolo.co`; verifies keys and owns projects/orgs                                                | `FLASH_STANDALONE=1` runs single-tenant on your own key                     |
-| Hosted Multi-LoRA serving | `serve.freesolo.co`, deployed from `flash/serving/`; `flash/serve/` owns the client and shared runtime | `flash serve deploy` provisions serving in your own Modal or RunPod account |
+| Component                 | Where it lives                                                                                         | Self-hosted equivalent                                            |
+| ------------------------- | ------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------- |
+| Multi-tenant identity     | `api.freesolo.co`; verifies keys and owns projects/orgs                                                | `FLASH_STANDALONE=1` runs single-tenant on your own key           |
+| Hosted Multi-LoRA serving | `serve.freesolo.co`, deployed from `flash/serving/`; `flash/serve/` owns the client and shared runtime | `flash serve deploy` provisions serving in your own Modal account |
 
 So there are three ways to use Flash: against the **hosted service**, **self-hosted** against
 your own GPU accounts, or as **training and provider code to read and modify**. The training
@@ -44,9 +44,13 @@ path is self-hostable end to end — see **[SELF_HOSTING.md](SELF_HOSTING.md)**.
 
 ## Using the hosted service
 
-The active training and hosted-serving catalog is `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
-`Qwen/Qwen3.6-35B-A3B`. The retired dense Qwen3.6 27B identity is never translated into Qwen3.8,
-and customer-owned Modal or RunPod serving remains limited to Qwen3.5 9B.
+The active training catalog is `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
+`Qwen/Qwen3.6-35B-A3B`. Hosted serving is active for 9B and 35B-A3B; hosted Qwen3.8 27B remains
+inactive. The retired dense Qwen3.6 27B identity is never translated into Qwen3.8. Customer-owned
+Modal supports all three active models; 27B and 35B-A3B are bound to the certified serving image
+digest. Customer-owned `flash serve` requires explicit `--provider modal`. Customer-serving RunPod
+commands and deployment identities are unsupported, with no migration or teardown shim. Managed
+RunPod training remains supported and unchanged.
 
 `flash login` is not interactive. Export `FREESOLO_API_KEY` first so the key does not appear in process listings:
 
@@ -222,8 +226,10 @@ External bearer tokens are rejected rather than accepted unverified. A standalon
 **single-tenant** — whoever holds that key can spend your GPU budget, so keep it off
 untrusted networks. See [the security model](SELF_HOSTING.md#the-security-model).
 
-`flash serve deploy` provisions serving in your own Modal or RunPod account, implementing the
-same contract `flash/serve/` speaks; [docs/serving-contract.md](docs/serving-contract.md)
+`flash serve deploy` provisions serving in your own Modal account and requires explicit
+`--provider modal`. Each deployment owns one exact base model and its compatible adapters; another
+base model requires another deployment. Customer-serving RunPod identities are unsupported.
+It implements the same contract `flash/serve/` speaks; [docs/serving-contract.md](docs/serving-contract.md)
 documents it if you would rather write your own.
 
 The GPU worker image is public and published under an explicit CUDA tag, not `latest`:

{freesolo_flash_dev-1.2.119 → freesolo_flash_dev-1.2.120}/SELF_HOSTING.md

@@ -22,9 +22,11 @@ Two credentials and at least one GPU account:
 
 Everything else is optional.
 
-The active training catalog is Qwen3.5 9B, Qwen3.8 27B, and Qwen3.6 35B-A3B. Customer-owned
-serving through `flash serve deploy` remains Qwen3.5 9B-only; the hosted 27B profile is not a
-customer-provider placement contract.
+The active training catalog is Qwen3.5 9B, Qwen3.8 27B, and Qwen3.6 35B-A3B. Hosted Qwen3.8
+27B remains inactive. Customer-owned Modal supports all three models; 27B and 35B-A3B are bound to
+the certified serving image digest. Customer-owned `flash serve` requires explicit
+`--provider modal`. Customer-serving RunPod commands and identities are unsupported, with no
+migration or teardown shim. Managed RunPod training remains supported and unchanged.
 
 ## Quickstart
 
@@ -363,10 +365,23 @@ without `FLASH_STANDALONE` and set `FREESOLO_BASE_URL` to point at it.
 
 ## Serving
 
-`flash serve deploy` provisions serving in **your own** Modal or RunPod account, running the
-published worker image against one base model and one run's adapter. Training and export remain
-independent of serving. Catalog serving checkpoint repositories are informational only and are never
-resolved by the training path.
+`flash serve deploy` provisions serving in **your own** Modal account, running the published worker
+image against one exact base model and that model's compatible adapters. A separate deployment is
+required for each base model. Training and export remain independent of serving. The required
+provider argument has the sole accepted value `--provider modal`.
+Catalog serving checkpoint repositories are informational only and are never resolved by the
+training path.
+
+Customer-owned Modal is live-qualified for Qwen3.5 9B, Qwen3.8 27B, and Qwen3.6 35B-A3B. The 27B
+and 35B-A3B qualifications are bound to the certified serving image digest. The 27B engine runs on
+`H100!` and serves the pinned `Qwen/Qwen3.8-27B-FP8` checkpoint while retaining
+`Qwen/Qwen3.8-27B` as its logical base and tokenizer provenance. The 35B-A3B engine serves the BF16
+model on one H200 with FP8 KV cache, a 32K context, eight sequences, a 4096 batched-token cap, and
+six rank-64 LoRA slots.
+Customer-serving RunPod lifecycle commands and deployment identities are unsupported. There is no
+migration, status, undeploy, or teardown shim for an old RunPod identity. This does not affect the
+managed RunPod training provider, serverless workers, artifact caching, or `RUNPOD_API_KEY` used by
+the training control plane.
 
 ```bash
 # the `server` extra, not the bare install: `serve deploy` resolves the adapter through
@@ -392,31 +407,9 @@ flash serve deploy \
   --modal-region us-east
 ```
 
-The three `--modal-*` placement flags are required for `--provider modal` even though `--help`
-lists them as optional: they are optional to _argparse_ because RunPod takes its own pair instead,
-and `placement_for` is what requires exactly one provider's set. Omitting them exits with
-`modal placement requires environment, region, workspace_name`.
-
-For RunPod, export `RUNPOD_API_KEY` instead and swap the placement flags rather than adding to
-them -- `placement_for` rejects the other provider's inputs instead of ignoring them, so keeping
-`--modal-*` alongside `--provider runpod` fails before anything is created:
-
-```bash
-flash serve deploy \
-  --provider runpod \
-  --model Qwen/Qwen3.5-9B \
-  --run <run-id> \
-  --deployment-id my-9b-serving \
-  --image ghcr.io/freesolo-co/freesolo-flash-serve@sha256:<digest> \
-  --artifact-repo <hub-repo> \
-  --artifact-subfolder <path-within-repo> \
-  --lora-rank 32 \
-  --runpod-account <your-account-id> \
-  --runpod-data-center <data-center-id>
-```
-
-Both `--runpod-*` flags are required and must be nonempty, for the same reason the `--modal-*`
-trio is: `--help` lists them as optional only because each provider takes its own set.
+The three `--modal-*` placement flags are required for `--provider modal`. Omitting them exits with
+`modal placement requires environment, region, workspace_name`. Passing `--provider runpod` is
+rejected by argument parsing before Hub resolution, credential reads, or provider access.
 
 Provider credentials are read from the process environment for the duration of a single call and are
 never written to the deployment record, logs, or command arguments — so any later resize or teardown

{freesolo_flash_dev-1.2.119 → freesolo_flash_dev-1.2.120}/docs/serving-contract.md

@@ -3,10 +3,23 @@
 `flash models deploy`, `chat`, and `undeploy` use an HTTP serving backend. `flash/serve/` owns the
 client, shared runtime, and customer-owned provider deployment. Freesolo's hosted backend
 (`flash/serving/`) is another implementation of this contract.
-A deployment serves one base model and its LoRA adapters. Use `flash serve deploy` to provision one
-in your own Modal or RunPod account, or implement these endpoints and run the conformance suite
-below. The maintained customer-owned profile supports only `Qwen/Qwen3.5-9B`; Qwen3.6 27B is
-retired and Qwen3.8 27B is available only through the separately managed hosted-serving catalog.
+A deployment serves one exact base model and its compatible LoRA adapters. A different base model
+requires a separate deployment. Use `flash serve deploy --provider modal` to provision one in your
+own Modal account, or implement these endpoints and run the conformance suite below.
+
+Customer-owned Modal is live-qualified for `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
+`Qwen/Qwen3.6-35B-A3B`. The 27B and 35B-A3B qualifications are bound to the exact certified serving
+image digest; another digest remains available for offline planning but cannot allocate Modal.
+Hosted Qwen3.8 27B remains inactive. Its customer-owned engine runs on
+`H100!` and serves the pinned `Qwen/Qwen3.8-27B-FP8` checkpoint while preserving
+`Qwen/Qwen3.8-27B` as the distinct logical base and tokenizer provenance. The 35B-A3B engine serves
+BF16 weights on one H200 with FP8 KV cache,
+a 32K context, eight sequences, a 4096 batched-token cap, and six rank-64 LoRA slots.
+
+Customer-owned `flash serve` is Modal-only and requires the explicit provider argument. Historical
+customer-serving RunPod deployment identities are unsupported, with no migration, status, undeploy,
+or teardown shim. Managed RunPod training remains supported and unchanged. Retired Qwen3.6 27B is
+never translated into Qwen3.8 27B.
 
 ## Identity model
 

freesolo_flash_dev-1.2.120/flash/cli/commands/serving/deploy.py

@@ -0,0 +1,284 @@
+"""provision one exact deployment in the user's own modal account.
+
+Provider credentials are read from the process environment for the duration of one call and wrapped
+in the request-scoped credential boundary. They are never accepted as arguments, written anywhere,
+or logged. Provider failures surface as sanitized codes rather than raw responses.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+
+from flash.serve.control import ModalCredentials
+from flash.serve.provisioning import (
+    FreshDeploymentArtifactTokenRequired,
+    InterruptedProvisioning,
+)
+
+MODAL_TOKEN_ID_ENV = "MODAL_TOKEN_ID"
+MODAL_TOKEN_SECRET_ENV = "MODAL_TOKEN_SECRET"
+# the serving app authenticates callers with this. a provider endpoint url is public, so without
+# it anyone who finds the url can load adapters and spend the customer's gpu budget.
+INFERENCE_KEY_ENV = "FLASH_SERVING_KEY"
+# the container hydrates its adapter from the hub itself, so it needs the same read token the
+# control plane used to resolve that adapter. an artifact repo is private by default, and without
+# this the launcher reaches `_prepare_cache` with nothing to authenticate as and dies after the
+# provider has already created and started billing for every resource.
+ARTIFACT_TOKEN_ENV = "HF_TOKEN"
+
+
+def _err(message: str) -> int:
+    print(f"error: {message}", file=sys.stderr)
+    return 1
+
+
+def _required_env(name: str) -> str:
+    value = os.environ.get(name, "").strip()
+    if not value:
+        raise ValueError(f"{name} is not set")
+    return value
+
+
+def _optional_env(name: str) -> str | None:
+    """read a token that is genuinely optional, mapping unset and blank alike to absence."""
+
+    return os.environ.get(name, "").strip() or None
+
+
+def _require_modal_provider(provider: object) -> None:
+    if provider != "modal":
+        raise ValueError("provider must be modal")
+
+
+def _credentials() -> ModalCredentials:
+    """build request-scoped modal credentials from the environment."""
+
+    return ModalCredentials(
+        token_id=_required_env(MODAL_TOKEN_ID_ENV),
+        token_secret=_required_env(MODAL_TOKEN_SECRET_ENV),
+    )
+
+
+def _image(reference: str):
+    from flash.serve.provisioning import ServingImage
+
+    if "@" not in reference:
+        raise ValueError(
+            "the serving image must be digest-qualified (name@sha256:...). a tag can be moved "
+            "to different content after the deployment is recorded"
+        )
+    _, digest = reference.rsplit("@", 1)
+    return ServingImage(reference=reference, digest=digest)
+
+
+def _report_handle(handle, *, endpoint: bool = True) -> None:
+    """print only sanitized provider identity, never request credentials."""
+
+    if endpoint:
+        print(f"endpoint    {handle.public_url}")
+    print(f"app id      {handle.app_id}")
+    print(f"volume id   {handle.volume_id}")
+    print(f"secret id   {handle.inference_secret_id}")
+
+
+def _report(result, bundle) -> int:
+    print(f"deployment  {result.deployment_id} generation {result.generation}")
+    print(f"provider    {result.provider}")
+    print(f"engine      {result.engine_id}")
+    print(f"image       {result.image_digest}")
+    print(f"status      {result.status}")
+    handle = result.handle
+    if handle is not None:
+        _report_handle(handle)
+    _report_identity(bundle)
+    if result.status == "ready":
+        return 0
+    if result.error_code:
+        print(f"error       {result.error_code}", file=sys.stderr)
+    if result.error_reason:
+        print(f"reason      {result.error_reason}", file=sys.stderr)
+    if str(result.error_reason or "").startswith("artifact_cleanup_") and handle is not None:
+        # every artifact-cleanup reason is raised after readiness proved, so the provider resource
+        # is live and billing whatever the status says.
+        print(
+            f"\nthe service reached readiness on app {handle.app_id}, but artifact cleanup did not "
+            "settle. the app is live and billing. run `flash serve status` to inspect the "
+            "deployment, then `flash serve undeploy` to stop it billing if you do not want it.",
+            file=sys.stderr,
+        )
+    elif result.status == "outcome_unknown":
+        # the provider may or may not hold live resources. saying "failed" here would invite a
+        # retry that double-provisions and bills twice.
+        print(
+            "\nthe provider outcome could not be confirmed. resources may exist; run `flash serve "
+            "status` to inspect them, then `flash serve undeploy` to stop them billing before "
+            "retrying rather than provisioning again.",
+            file=sys.stderr,
+        )
+    return 1
+
+
+def _report_identity(bundle) -> None:
+    """print recovery identity without replacing the reported outcome if encoding fails."""
+
+    try:
+        from flash.cli.commands.serving.identity import encode_deployment_identity
+
+        print(f"identity    {encode_deployment_identity(bundle)}")
+    except Exception:
+        return
+
+
+def _build_provider_plan(bundle):
+    """return the validated modal plan without contacting the provider."""
+
+    from flash.serve.provisioning.modal.planning.plan import build_modal_create_plan
+
+    return build_modal_create_plan(bundle, phase="finalized")
+
+
+def _runtime_secrets():
+    """build request-scoped endpoint secrets from the environment."""
+
+    from flash.serve.provisioning import ServingRuntimeSecrets
+
+    return ServingRuntimeSecrets(
+        inference_token=_required_env(INFERENCE_KEY_ENV),
+        artifact_token=_optional_env(ARTIFACT_TOKEN_ENV),
+    )
+
+
+def _deployment_bundle(args):
+    """build the exact immutable modal deployment input shared by lifecycle commands."""
+
+    from flash.serve.control import DeploymentRequest
+    from flash.serve.deployment.profiles import get_profile, placement_for
+    from flash.serve.deployment.resolve import (
+        execution_inputs,
+        resolve_adapter,
+        resolve_base_revision,
+    )
+    from flash.server.domain.ops.serving_resources import resolve_deployment_bundle
+
+    _require_modal_provider(args.provider)
+    profile = get_profile(args.model)
+    image = _image(args.image)
+    placement = placement_for(
+        profile,
+        args.provider,
+        workspace_name=getattr(args, "modal_workspace", "") or "",
+        environment=getattr(args, "modal_environment", "") or "",
+        region=getattr(args, "modal_region", "") or "",
+        # "" means the no-suffix environment, which is a real modal configuration.
+        web_suffix=(getattr(args, "modal_web_suffix", "") or "") or None,
+    )
+    logical_base_revision = resolve_base_revision(args.model)
+    resolved = resolve_adapter(
+        run_id=args.run,
+        artifact_repo_id=args.artifact_repo,
+        artifact_subfolder=args.artifact_subfolder,
+        artifact_repo_type=getattr(args, "artifact_repo_type", "dataset"),
+        base_model=args.model,
+        base_model_revision=logical_base_revision,
+        lora_rank=args.lora_rank,
+        checkpoint_step=getattr(args, "checkpoint_step", None),
+        thinking_default=bool(getattr(args, "thinking", False)),
+    )
+    logical_base_revision = resolved.adapter.base_model_revision
+    if profile.served_model == args.model:
+        model_revision = logical_base_revision
+    elif profile.served_model_revision is not None:
+        model_revision = profile.served_model_revision
+    else:
+        model_revision = resolve_base_revision(profile.served_model)
+
+    if profile.tokenizer_model == profile.served_model:
+        tokenizer_revision = model_revision
+    elif profile.tokenizer_model == args.model:
+        tokenizer_revision = logical_base_revision
+    else:
+        tokenizer_revision = resolve_base_revision(profile.tokenizer_model)
+
+    engine = profile.engine(
+        model_revision=model_revision,
+        tokenizer_revision=tokenizer_revision,
+        image=image,
+    )
+    request = DeploymentRequest(
+        deployment_id=args.deployment_id,
+        generation=args.generation,
+        provider=args.provider,
+        placement=placement,
+        engine=engine,
+        adapters=(resolved.adapter,),
+    )
+    return resolve_deployment_bundle(
+        request,
+        execution_inputs(profile, image, (resolved,)),
+        image,
+    )
+
+
+def cmd_serve_deploy(args) -> int:
+    try:
+        _require_modal_provider(args.provider)
+        if not getattr(args, "dry_run", False):
+            from flash.serve.deployment.profiles import get_profile, require_live_qualification
+
+            image = _image(args.image)
+            require_live_qualification(get_profile(args.model), args.provider, image.digest)
+        bundle = _deployment_bundle(args)
+    except (ValueError, TypeError) as exc:
+        return _err(str(exc))
+
+    from flash.server.domain.ops.serving_resources import dry_run_deployment
+
+    try:
+        # validate the provider-specific hostname contract on both dry-run and allocation paths.
+        _build_provider_plan(bundle)
+    except (ValueError, TypeError) as exc:
+        return _err(str(exc))
+
+    if getattr(args, "dry_run", False):
+        for key, value in dry_run_deployment(bundle).items():
+            print(f"{key:18} {value}")
+        print("\ndry run: no provider was contacted and nothing was provisioned.")
+        return 0
+
+    try:
+        credentials = _credentials()
+        runtime_secrets = _runtime_secrets()
+    except ValueError as exc:
+        return _err(
+            f"{exc}. provider credentials are read from the environment for this one request "
+            "and are never stored"
+        )
+
+    deadline_at = time.monotonic() + float(args.timeout)
+    try:
+        from flash.serve.provisioning.modal.execution.operations import provision_modal_deployment
+
+        result = provision_modal_deployment(
+            bundle, credentials, runtime_secrets, deadline_at=deadline_at
+        )
+    except FreshDeploymentArtifactTokenRequired as exc:
+        return _err(f"{ARTIFACT_TOKEN_ENV} is not set. {exc}")
+    except InterruptedProvisioning:
+        # the interrupt still propagates, but first report the exact identity and billing ambiguity.
+        _report_identity(bundle)
+        _warn_unconfirmed_cleanup(args.deployment_id)
+        raise
+    return _report(result, bundle)
+
+
+def _warn_unconfirmed_cleanup(deployment_id: str) -> None:
+    """say what ctrl-c actually left behind before the generic handler says aborted."""
+
+    print(
+        f"\nwarning: interrupted before ready, and modal cleanup could not be confirmed for "
+        f"{deployment_id}. resources may still exist and bill; run `flash serve status` to inspect "
+        "them, then `flash serve undeploy` before retrying rather than provisioning again.",
+        file=sys.stderr,
+    )

{freesolo_flash_dev-1.2.119 → freesolo_flash_dev-1.2.120}/flash/cli/commands/serving/identity.py

@@ -1,9 +1,9 @@
 """portable immutable identity for existing customer-owned serving deployments.
 
-The provider plans validate more than deterministic resource names: Modal binds the exact manifest
-and spec into app tags, while RunPod binds image and placement topology into observed resources.
-Re-resolving mutable Hub repositories is therefore neither sufficient nor necessary for status or
-teardown. This codec carries the already-resolved, credential-free bundle without persisting it.
+The Modal plan validates more than deterministic resource names: it binds the exact manifest and
+spec into app tags. Re-resolving mutable Hub repositories is therefore neither sufficient nor
+necessary for status or teardown. This codec carries the already-resolved, credential-free bundle
+without persisting it.
 """
 
 from __future__ import annotations
@@ -23,27 +23,18 @@ _BASE64URL_RE = re.compile(r"[A-Za-z0-9_-]+")
 
 
 def _placement_payload(placement) -> dict[str, object]:
-    from flash.serve.control import ModalPlacement, RunPodPlacement
-
-    if type(placement) is ModalPlacement:
-        return {
-            "environment": placement.environment,
-            "gpu": placement.gpu,
-            "gpu_count": placement.gpu_count,
-            "region": placement.region,
-            "web_suffix": placement.web_suffix,
-            "workspace_name": placement.workspace_name,
-        }
-    if type(placement) is RunPodPlacement:
-        return {
-            "account_id": placement.account_id,
-            "container_disk_gb": placement.container_disk_gb,
-            "data_center_id": placement.data_center_id,
-            "gpu_count": placement.gpu_count,
-            "gpu_type_id": placement.gpu_type_id,
-            "volume_size_gb": placement.volume_size_gb,
-        }
-    raise TypeError("deployment identity requires an exact provider placement")
+    from flash.serve.control import ModalPlacement
+
+    if type(placement) is not ModalPlacement:
+        raise TypeError("deployment identity requires an exact ModalPlacement")
+    return {
+        "environment": placement.environment,
+        "gpu": placement.gpu,
+        "gpu_count": placement.gpu_count,
+        "region": placement.region,
+        "web_suffix": placement.web_suffix,
+        "workspace_name": placement.workspace_name,
+    }
 
 
 def encode_deployment_identity(bundle) -> str:
@@ -120,31 +111,17 @@ def _exact_keys(value: Mapping[str, object], expected: set[str], name: str) -> N
 
 
 def _placement(provider: object, value: object):
-    from flash.serve.control import ModalPlacement, RunPodPlacement
+    from flash.serve.control import ModalPlacement
 
+    if provider != "modal":
+        raise ValueError("deployment identity provider must be modal")
     payload = _mapping(value, "placement")
-    if provider == "modal":
-        _exact_keys(
-            payload,
-            {"environment", "gpu", "gpu_count", "region", "web_suffix", "workspace_name"},
-            "modal placement",
-        )
-        return ModalPlacement(**payload)
-    if provider == "runpod":
-        _exact_keys(
-            payload,
-            {
-                "account_id",
-                "container_disk_gb",
-                "data_center_id",
-                "gpu_count",
-                "gpu_type_id",
-                "volume_size_gb",
-            },
-            "runpod placement",
-        )
-        return RunPodPlacement(**payload)
-    raise ValueError("deployment identity provider must be modal or runpod")
+    _exact_keys(
+        payload,
+        {"environment", "gpu", "gpu_count", "region", "web_suffix", "workspace_name"},
+        "modal placement",
+    )
+    return ModalPlacement(**payload)
 
 
 def _resolved_adapters(manifest) -> tuple[object, ...]:
@@ -193,6 +170,8 @@ def decode_deployment_identity(value: str):
     )
 
     payload = _decode_payload(value)
+    if payload["provider"] != "modal":
+        raise ValueError("deployment identity provider must be modal")
     manifest_value = payload["manifest"]
     image_reference = payload["image_reference"]
     if type(manifest_value) is not str or type(image_reference) is not str:
@@ -216,7 +195,7 @@ def _mismatch(flag: str) -> None:
 
 
 def _validate_authored_identity(args, bundle) -> None:
-    from flash.serve.control import ModalPlacement, RunPodPlacement
+    from flash.serve.control import ModalPlacement
 
     spec = bundle.spec
     if len(spec.adapters) != 1:
@@ -256,14 +235,6 @@ def _validate_authored_identity(args, bundle) -> None:
         for flag, actual, expected in modal:
             if actual != expected:
                 _mismatch(flag)
-    elif type(placement) is RunPodPlacement:
-        runpod = (
-            ("runpod-account", placement.account_id, args.runpod_account),
-            ("runpod-data-center", placement.data_center_id, args.runpod_data_center),
-        )
-        for flag, actual, expected in runpod:
-            if actual != expected:
-                _mismatch(flag)
     else:  # pragma: no cover - DeploymentSpec validation already excludes this
         raise TypeError("deployment identity placement is invalid")