@@ -357,15 +357,19 @@ def pad(self, file, size=6):
         Returns:
             generator of records
         """
-        buffer = ""
+        buffer = None
         for element in self.splitter.split(file):
+            if buffer is None:
+                # Match the buffer type to the record type so binary inputs
+                # concatenate correctly instead of raising a TypeError.
+                buffer = b"" if isinstance(element, bytes) else ""
             if _payload_size_within_limit(buffer + element, size):
                 buffer += element
             else:
                 tmp = buffer
                 buffer = element
                 yield tmp
-        if _validate_payload_size(buffer, size):
+        if buffer is not None and _validate_payload_size(buffer, size):
             yield buffer
 
 
 
@@ -86,6 +86,25 @@ def __init__(self, sagemaker_session=None):
         """
         self.sagemaker_session = sagemaker_session or LocalSession()
 
+    def describe_user_profile(self, DomainId, UserProfileName, **kwargs):
+        """Passes ``describe_user_profile`` through to the real SageMaker client.
+
+        Local mode does not model user profiles, but Studio role resolution calls
+        this during session setup. Delegating to a real boto client keeps that path
+        working instead of raising ``AttributeError``.
+
+        Args:
+          DomainId (str): The domain ID the user profile belongs to.
+          UserProfileName (str): The name of the user profile to describe.
+          **kwargs: Additional keyword arguments forwarded to the boto client.
+
+        Returns: (dict) DescribeUserProfile response.
+        """
+        boto_client = self.sagemaker_session.boto_session.client("sagemaker")
+        return boto_client.describe_user_profile(
+            DomainId=DomainId, UserProfileName=UserProfileName, **kwargs
+        )
+
     @_telemetry_emitter(Feature.LOCAL_MODE, "local_session.create_processing_job")
     def create_processing_job(
         self,
@@ -533,7 +552,25 @@ def invoke_endpoint(
             Body = Body.encode("utf-8")
         r = self.http.request("POST", url, body=Body, preload_content=False, headers=headers)
 
-        return {"Body": r, "ContentType": Accept}
+        # Mirror the response shape of the real SageMaker runtime client so the same
+        # code works in local mode and against a hosted endpoint.
+        try:
+            response_headers = dict(r.headers)
+        except (TypeError, ValueError):
+            response_headers = {}
+        request_id = response_headers.get("x-amzn-RequestId", "local-request-id")
+        status_code = getattr(r, "status", None)
+        return {
+            "Body": r,
+            "ContentType": response_headers.get("Content-type", Accept),
+            "InvokedProductionVariant": TargetVariant or "AllTraffic",
+            "ResponseMetadata": {
+                "RequestId": request_id,
+                "HTTPStatusCode": status_code,
+                "HTTPHeaders": response_headers,
+                "RetryAttempts": 0,
+            },
+        }
 
 
 class LocalSession(Session):
 
@@ -278,11 +278,12 @@ def __init__(
         self.role = resolve_value_from_config(
             role, PROCESSING_JOB_ROLE_ARN_PATH, sagemaker_session=self.sagemaker_session
         )
-        if not self.role:
+        if not self.role and self.instance_type not in ("local", "local_gpu"):
             # Originally IAM role was a required parameter.
             # Now we marked that as Optional because we can fetch it from SageMakerConfig
             # Because of marking that parameter as optional, we should validate if it is None, even
-            # after fetching the config.
+            # after fetching the config. In Local Mode the role is never used
+            # (LocalSagemakerClient.create_processing_job discards it), so it is not required.
             raise ValueError("An AWS IAM role is required to create a Processing job.")
 
         self.env = resolve_value_from_config(
@@ -750,11 +751,12 @@ def _get_process_args(self, inputs, outputs, experiment_config):
             process_request_args["network_config"] = self.network_config._to_request_dict()
         else:
             process_request_args["network_config"] = None
-        process_request_args["role_arn"] = (
-            self.role
-            if is_pipeline_variable(self.role)
-            else self.sagemaker_session.expand_role(self.role)
-        )
+        if self.role is None or is_pipeline_variable(self.role):
+            # No role in Local Mode (see __init__): the local client discards RoleArn,
+            # and expand_role(None) would raise.
+            process_request_args["role_arn"] = self.role
+        else:
+            process_request_args["role_arn"] = self.sagemaker_session.expand_role(self.role)
         process_request_args["tags"] = self.tags
         return process_request_args
 
 
@@ -0,0 +1,15 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""Integ tests for sagemaker-core Local Mode session/runtime fixes."""
+
+from __future__ import absolute_import