def _wrap_response(
    status_code: int,
    msg: Any,
    error_code: Optional[str] = None,
    content_type: Optional[str] = DEFAULT_CONTENT_TYPE,
):
    resp = None
    if isinstance(msg, str):
        response_obj = {
            'message': msg,
        }
        if not (status_code >= 200 and status_code < 300) and error_code:
            response_obj['errorCode'] = error_code
        resp = JSONResponse(content=response_obj, status_code=status_code)
    elif isinstance(msg, bytes):
        resp = Response(content=msg, media_type=content_type)
    else:
        # BEGIN NEW CODE
        try:
            resp = JSONResponse(content=msg, status_code=status_code)
        except Exception:
            resp = _wrap_response(status_code, repr(msg), error_code, content_type)
        # END NEW CODE
    return resp

class DaprInternalError(Exception):
    """DaprInternalError encapsulates all Dapr exceptions"""

    def __init__(
        self,
        message: Optional[str],
        error_code: Optional[str] = ERROR_CODE_UNKNOWN,
        raw_response_bytes: Optional[bytes] = None,
    ):
        self._message = message
        self._error_code = error_code
        self._raw_response_bytes = raw_response_bytes

    def as_dict(self):
        return {
            'message': self._message,
            'errorCode': self._error_code,
            'raw_response_bytes': self._raw_response_bytes,
        }

    def json_safe_dict(self):
        error_dict = {'message': self._message, 'errorCode': self._error_code, }

        if self._raw_response_bytes is not None:
            # Encode bytes to base64 for JSON compatibility
            error_dict['raw_response_bytes'] = base64.b64encode(self._raw_response_bytes).decode(
                'utf-8')

        return error_dict