refactor(serve): inline additional-source EULA fold in _build_for_jumpstart

Scope the EULA handling down to mirror the primary model exactly: strip
the JumpStart-internal HostingEulaKey (not part of the CreateModel API
shape) and fold accept_eula into each source's ModelAccessConfig when
set. No client-side gatedness check or raise: the control plane
determines gatedness from the artifact's bucket and rejects CreateModel
with its own EULA validation error, for the primary model and
additional sources alike.

This reverts the sagemaker-core half of the previous commit:
session_helper.py returns to upstream and the whole change lives in the
JumpStart builder that produces the spec-derived sources. Tests assert
the new contract on the CreateModel request: acceptance folded when
accept_eula is set (True or False), no ModelAccessConfig when unset.

Author: Eli Davidson

sagemaker-core/src/sagemaker/core/helper/session_helper.py

@@ -3072,47 +3072,6 @@ def _optimization_job_status(sagemaker_client, job_name):
     return desc
 
 
-def _apply_accept_eula_to_additional_model_data_sources(additional_model_data_sources, accept_eula):
-    """Apply EULA acceptance to additional model data sources.
-
-    This is the additional-source counterpart of the primary model handling in
-    ``container_def`` below, driven by the same ``accept_eula`` flag. Sources
-    resolved from JumpStart specs may carry a ``HostingEulaKey``: a truthy value
-    marks a gated source that requires explicit license acceptance. Acceptance
-    is folded into the source's ``S3DataSource.ModelAccessConfig`` and a gated
-    source without acceptance raises before any request is made. The
-    ``HostingEulaKey`` itself is JumpStart-internal metadata the CreateModel
-    API rejects, so it is always removed.
-
-    Args:
-        additional_model_data_sources (list[dict]): AdditionalModelDataSources
-            entries, possibly carrying JumpStart ``HostingEulaKey`` metadata.
-        accept_eula (bool): Whether model terms of use have been accepted.
-
-    Returns:
-        list[dict]: The sources in CreateModel API shape.
-
-    Raises:
-        ValueError: If a gated source is present and ``accept_eula`` is not True.
-    """
-    applied_sources = []
-    for source in additional_model_data_sources:
-        applied_source = dict(source)
-        if applied_source.pop("HostingEulaKey", None):
-            if not accept_eula:
-                raise ValueError(
-                    "accept_eula must be set to True to deploy this model. "
-                    "Please set accept_eula=True on the ModelBuilder instance "
-                    "to confirm you have read and accepted the end-user license "
-                    "agreement for this model."
-                )
-            s3_data_source = dict(applied_source.get("S3DataSource", {}))
-            s3_data_source["ModelAccessConfig"] = {"AcceptEula": True}
-            applied_source["S3DataSource"] = s3_data_source
-        applied_sources.append(applied_source)
-    return applied_sources
-
-
 def container_def(
     image_uri,
     model_data_url=None,
@@ -3156,13 +3115,7 @@ def container_def(
     c_def = {"Image": image_uri, "Environment": env}
 
     if additional_model_data_sources:
-        c_def["AdditionalModelDataSources"] = (
-            _apply_accept_eula_to_additional_model_data_sources(
-                additional_model_data_sources, accept_eula
-            )
-            if isinstance(additional_model_data_sources, list)
-            else additional_model_data_sources
-        )
+        c_def["AdditionalModelDataSources"] = additional_model_data_sources
 
     if isinstance(model_data_url, str) and (
         not (model_data_url.startswith("s3://") and model_data_url.endswith("tar.gz"))

sagemaker-serve/src/sagemaker/serve/model_builder_servers.py

@@ -1017,18 +1017,35 @@ def _build_for_jumpstart(self) -> Model:
         # Propagate additional model data sources resolved from the JumpStart
         # spec (e.g. speculative decoding draft models like EAGLE). The JumpStart
         # factory (_add_additional_model_data_sources_to_kwargs) already returns
-        # these in CreateModel API shape via camel_case_to_pascal_case(...);
-        # EULA handling (enforcing accept_eula on gated sources and stripping
-        # the JumpStart-internal HostingEulaKey) happens in ``container_def``,
-        # the same place the primary model's accept_eula is applied. Without
-        # this propagation, sources declared in the spec are dropped from the
-        # CreateModel call and the container fails to find the referenced
-        # artifacts at runtime.
+        # these in CreateModel API shape via camel_case_to_pascal_case(...),
+        # except for two adjustments applied here, mirroring how ``container_def``
+        # treats the primary model's ``ModelDataSource``:
+        # - the JumpStart-internal ``HostingEulaKey`` is removed (it is not part
+        #   of the CreateModel API shape, request validation rejects it), and
+        # - when ``accept_eula`` is set, it is folded into each source's
+        #   ``S3DataSource.ModelAccessConfig``.
+        # Gated-source EULA enforcement is server-side, same as for the primary
+        # model: the control plane determines gatedness from the artifact's
+        # bucket and rejects CreateModel with an EULA validation error when a
+        # gated source lacks ``ModelAccessConfig`` with ``AcceptEula`` true.
+        # Without this propagation, sources declared in the spec are dropped
+        # from the CreateModel call and the container fails to find the
+        # referenced artifacts at runtime.
         additional_model_data_sources = getattr(
             init_kwargs, "additional_model_data_sources", None
         )
         if isinstance(additional_model_data_sources, list) and additional_model_data_sources:
-            self.additional_model_data_sources = additional_model_data_sources
+            accept_eula = getattr(self, "accept_eula", None)
+            prepared_sources = []
+            for source in additional_model_data_sources:
+                prepared_source = dict(source)
+                prepared_source.pop("HostingEulaKey", None)
+                if accept_eula is not None:
+                    s3_data_source = dict(prepared_source.get("S3DataSource", {}))
+                    s3_data_source["ModelAccessConfig"] = {"AcceptEula": accept_eula}
+                    prepared_source["S3DataSource"] = s3_data_source
+                prepared_sources.append(prepared_source)
+            self.additional_model_data_sources = prepared_sources
 
         # Handle model artifacts for fine-tuned models
         if hasattr(init_kwargs, "model_data") and init_kwargs.model_data:

sagemaker-serve/tests/unit/servers/test_model_builder_servers.py

@@ -1050,8 +1050,9 @@ class TestJumpStartAdditionalModelDataSourcesUserFlow(unittest.TestCase):
     Everything in between runs for real: JumpStart model-id detection,
     JumpStartModelSpecs parsing, inference-config resolution, the
     get_init_kwargs factory (image URI resolution, content-bucket injection,
-    PascalCase shaping), _build_for_jumpstart's EULA translation, and
-    _prepare_container_def_base assembling the CreateModel request.
+    PascalCase shaping), the propagation in _build_for_jumpstart, the
+    accept_eula application in container_def (shared with the primary model),
+    and _prepare_container_def_base assembling the CreateModel request.
     """
 
     SPEC_DIR = Path(__file__).parent / "data" / "jumpstart_specs"
@@ -1078,7 +1079,7 @@ def _spec_additional_source(cls, model_id, config_name="lmi-optimized"):
         return sources[0]
 
     @classmethod
-    def _expected_create_model_source(cls, model_id, bucket, accept_eula=False):
+    def _expected_create_model_source(cls, model_id, bucket, accept_eula=None):
         """The shape the CreateModel request must carry for the fixture's
         source. Data values (channel name, compression, data type, key prefix)
         come from the spec fixture so it stays the single source of truth; the
@@ -1088,8 +1089,8 @@ def _expected_create_model_source(cls, model_id, bucket, accept_eula=False):
         - snake_case spec keys become the PascalCase API keys
         - the bucket-less key prefix resolves into the given content bucket
         - HostingEulaKey never appears (the API rejects it)
-        - EULA acceptance, when given, is folded into
-          S3DataSource.ModelAccessConfig
+        - accept_eula, when set, is folded into S3DataSource.ModelAccessConfig
+          exactly like the primary model's ModelDataSource
         """
         raw = cls._spec_additional_source(model_id)
         expected = {
@@ -1100,8 +1101,8 @@ def _expected_create_model_source(cls, model_id, bucket, accept_eula=False):
                 "S3Uri": f"s3://{bucket}/{raw['s3_data_source']['s3_uri']}",
             },
         }
-        if accept_eula:
-            expected["S3DataSource"]["ModelAccessConfig"] = {"AcceptEula": True}
+        if accept_eula is not None:
+            expected["S3DataSource"]["ModelAccessConfig"] = {"AcceptEula": accept_eula}
         return expected
 
     def setUp(self):
@@ -1196,9 +1197,12 @@ def test_ungated_additional_source_reaches_create_model_without_eula(self):
             ],
         )
 
-    def test_ungated_additional_source_gets_no_model_access_config(self):
-        """accept_eula=True must not add a ModelAccessConfig to an ungated
-        additional source (it applies to the primary model only)."""
+    def test_accept_eula_applies_to_every_model_data_source_uniformly(self):
+        """The single accept_eula knob folds the same ModelAccessConfig into
+        the primary model AND each additional source, exactly like the primary
+        model's ModelDataSource handling. Gatedness is not the SDK's call: the
+        service determines it from the artifact's bucket and ignores the config
+        on ungated sources."""
         self._build(
             "openai-reasoning-gpt-oss-20b", accept_eula=True, instance_type="ml.g7e.2xlarge"
         )
@@ -1208,11 +1212,12 @@ def test_ungated_additional_source_gets_no_model_access_config(self):
             container_def["AdditionalModelDataSources"],
             [
                 self._expected_create_model_source(
-                    "openai-reasoning-gpt-oss-20b", bucket=self.PUBLIC_CONTENT_BUCKET
+                    "openai-reasoning-gpt-oss-20b",
+                    bucket=self.PUBLIC_CONTENT_BUCKET,
+                    accept_eula=True,
                 )
             ],
         )
-        # The single accept_eula knob still covers the primary (base) model.
         self.assertEqual(
             container_def["ModelDataSource"]["S3DataSource"]["ModelAccessConfig"],
             {"AcceptEula": True},
@@ -1244,31 +1249,53 @@ def test_gated_additional_source_with_accepted_eula_sends_model_access_config(se
             {"AcceptEula": True},
         )
 
-    def test_gated_additional_source_without_eula_raises_and_never_calls_create_model(self):
-        """No EULA acceptance: build() fails with the actionable error and no
-        CreateModel call is ever made."""
-        with self.assertRaises(ValueError) as ctx:
-            self._build(
-                "meta-textgeneration-llama-3-1-70b",
-                inference_config_name="lmi-optimized",
-                instance_type="ml.p4d.24xlarge",
-            )
+    def test_gated_additional_source_without_eula_sends_no_model_access_config(self):
+        """No EULA decision: the request carries the gated source without any
+        ModelAccessConfig. Enforcement is the service's: the SageMaker control
+        plane resolves the private-bucket URI as gated and rejects CreateModel
+        with an EULA validation error, the same as for a gated primary model."""
+        self._build(
+            "meta-textgeneration-llama-3-1-70b",
+            inference_config_name="lmi-optimized",
+            instance_type="ml.p4d.24xlarge",
+        )
 
-        self.assertIn("accept_eula must be set to True", str(ctx.exception))
-        self.session.create_model.assert_not_called()
+        container_def = self._create_model_container_def()
+        self.assertEqual(
+            container_def["AdditionalModelDataSources"],
+            [
+                self._expected_create_model_source(
+                    "meta-textgeneration-llama-3-1-70b", bucket=self.PRIVATE_CONTENT_BUCKET
+                )
+            ],
+        )
 
-    def test_gated_additional_source_with_rejected_eula_raises_and_never_calls_create_model(self):
-        """Explicit accept_eula=False fails the same way."""
-        with self.assertRaises(ValueError) as ctx:
-            self._build(
-                "meta-textgeneration-llama-3-1-70b",
-                accept_eula=False,
-                inference_config_name="lmi-optimized",
-                instance_type="ml.p4d.24xlarge",
-            )
-
-        self.assertIn("accept_eula must be set to True", str(ctx.exception))
-        self.session.create_model.assert_not_called()
+    def test_gated_additional_source_with_rejected_eula_sends_acceptance_false(self):
+        """Explicit accept_eula=False is transmitted faithfully as
+        ModelAccessConfig={"AcceptEula": False} on every source, exactly like
+        the primary model. The service rejects the gated sources."""
+        self._build(
+            "meta-textgeneration-llama-3-1-70b",
+            accept_eula=False,
+            inference_config_name="lmi-optimized",
+            instance_type="ml.p4d.24xlarge",
+        )
+
+        container_def = self._create_model_container_def()
+        self.assertEqual(
+            container_def["AdditionalModelDataSources"],
+            [
+                self._expected_create_model_source(
+                    "meta-textgeneration-llama-3-1-70b",
+                    bucket=self.PRIVATE_CONTENT_BUCKET,
+                    accept_eula=False,
+                )
+            ],
+        )
+        self.assertEqual(
+            container_def["ModelDataSource"]["S3DataSource"]["ModelAccessConfig"],
+            {"AcceptEula": False},
+        )
 
     def test_unselected_config_sources_do_not_leak_into_create_model(self):
         """Config resolution gates which sources apply: the same gated model on