0x676e67 · 0x676e67 · Aug 14, 2025 · Aug 14, 2025 · Aug 14, 2025 · Aug 14, 2025
diff --git a/src/client/request.rs b/src/client/request.rs
@@ -31,6 +31,7 @@ use crate::{
         ext::{RequestConfig, RequestConfigValue, RequestLevelOptions, RequestOrigHeaderMap},
     },
     header::{CONTENT_TYPE, HeaderMap, HeaderName, HeaderValue, OrigHeaderMap},
+    into_url::IntoUrlSealed,
     redirect,
 };
 
@@ -823,7 +824,7 @@ where
             headers,
             ..
         } = parts;
-        let url = crate::into_url::IntoUrlSealed::into_url(uri.to_string())?;
+        let url = IntoUrlSealed::into_url(uri.to_string())?;
         Ok(Request {
             method,
             url,
@@ -837,6 +838,7 @@ where
 impl TryFrom<Request> for HttpRequest<Body> {
     type Error = crate::Error;
 
+    #[inline]
     fn try_from(req: Request) -> crate::Result<Self> {
         req.try_into().map(|(_, http_req)| http_req)
     }

diff --git a/src/client/response.rs b/src/client/response.rs
@@ -16,6 +16,7 @@ use crate::cookie;
 use crate::{
     Error, Upgraded,
     core::{client::connect::HttpInfo, ext::ReasonPhrase},
+    response::ResponseUrl,
 };
 
 /// A Response to a submitted `Request`.
@@ -442,8 +443,6 @@ impl fmt::Debug for Response {
 // to use `http::Response`, not `wreq::Response`.
 impl<T: Into<Body>> From<http::Response<T>> for Response {
     fn from(r: http::Response<T>) -> Response {
-        use crate::response::ResponseUrl;
-
         let (mut parts, body) = r.into_parts();
         let body: super::body::Body = body.into();
         let url = parts
@@ -465,7 +464,9 @@ impl From<Response> for http::Response<Body> {
     fn from(r: Response) -> http::Response<Body> {
         let (parts, body) = r.res.into_parts();
         let body = Body::wrap(body);
-        http::Response::from_parts(parts, body)
+        let mut response = http::Response::from_parts(parts, body);
+        response.extensions_mut().insert(ResponseUrl(*r.url));
+        response
     }
 }
 
@@ -482,7 +483,7 @@ mod tests {
     use url::Url;
 
     use super::Response;
-    use crate::ResponseBuilderExt;
+    use crate::{ResponseBuilderExt, response::ResponseExt};
 
     #[test]
     fn test_from_http_response() {
@@ -497,4 +498,23 @@ mod tests {
         assert_eq!(response.status(), 200);
         assert_eq!(*response.url(), url);
     }
+
+    #[test]
+    fn test_from_http_response_with_url() {
+        let url = Url::parse("http://example.com").unwrap();
+        let response = Builder::new()
+            .status(200)
+            .url(url.clone())
+            .body("foo")
+            .unwrap();
+        let response = Response::from(response);
+
+        assert_eq!(response.status(), 200);
+        assert_eq!(*response.url(), url);
+
+        let http_response = http::Response::from(response);
+        let resp_url = http_response.url();
+        assert_eq!(http_response.status(), 200);
+        assert_eq!(resp_url, Some(&url));
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -311,7 +311,7 @@ pub use self::{
     error::{Error, Result},
     into_url::IntoUrl,
     proxy::{NoProxy, Proxy},
-    response::ResponseBuilderExt,
+    response::{ResponseBuilderExt, ResponseExt},
 };
 
 fn _assert_impls() {

diff --git a/src/redirect.rs b/src/redirect.rs
@@ -179,6 +179,7 @@ impl<'a> Attempt<'a> {
     pub fn previous(&self) -> &[Url] {
         self.previous
     }
+
     /// Returns an action meaning wreq should follow the next URL.
     pub fn follow(self) -> Action {
         Action {

diff --git a/src/response.rs b/src/response.rs
@@ -1,5 +1,7 @@
 use url::Url;
 
+use crate::Body;
+
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct ResponseUrl(pub Url);
 
@@ -12,18 +14,33 @@ pub trait ResponseBuilderExt {
     fn url(self, url: Url) -> Self;
 }
 
+/// Extension trait for http::Response objects
+///
+/// Provides methods to extract URL information from HTTP responses
+pub trait ResponseExt {
+    /// Returns a reference to the `Url` associated with this response, if available.
+    fn url(&self) -> Option<&Url>;
+}
+
 impl ResponseBuilderExt for http::response::Builder {
     fn url(self, url: Url) -> Self {
         self.extension(ResponseUrl(url))
     }
 }
 
+impl ResponseExt for http::Response<Body> {
+    fn url(&self) -> Option<&Url> {
+        self.extensions().get::<ResponseUrl>().map(|r| &r.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use http::response::Builder;
     use url::Url;
 
-    use super::{ResponseBuilderExt, ResponseUrl};
+    use super::{ResponseBuilderExt, ResponseExt, ResponseUrl};
+    use crate::Body;
 
     #[test]
     fn test_response_builder_ext() {
@@ -39,4 +56,16 @@ mod tests {
             Some(&ResponseUrl(url))
         );
     }
+
+    #[test]
+    fn test_response_ext() {
+        let url = Url::parse("http://example.com").unwrap();
+        let response = http::Response::builder()
+            .status(200)
+            .extension(ResponseUrl(url.clone()))
+            .body(Body::empty())
+            .unwrap();
+
+        assert_eq!(response.url(), Some(&url));
+    }
 }