react-native-nitro-fetch 1.0.3 → 1.1.0

package/NitroFetch.podspec

@@ -22,6 +22,10 @@ Pod::Spec.new do |s|
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
+  s.dependency 'React-RCTNetwork'
+
+  # Expose the DevTools reporter Obj-C facade to Swift via the pod's umbrella module.
+  s.public_header_files = ["ios/NitroDevToolsReporter.h"]
 
   load 'nitrogen/generated/ios/NitroFetch+autolinking.rb'
   add_nitrogen_files(s)

package/android/src/main/java/com/margelo/nitro/nitrofetch/DevToolsReporter.kt

@@ -0,0 +1,132 @@
+package com.margelo.nitro.nitrofetch
+
+/**
+ * Thin facade over React Native's [com.facebook.react.modules.network.InspectorNetworkReporter].
+ * All methods are no-ops when the modern CDP debugger is not attached (guarded by
+ * `isDebuggingEnabled()` inside RN), so they are safe to call in release builds.
+ *
+ * The underlying reporter is marked `internal` in RN but is the officially documented
+ * Kotlin entry point for third-party networking libraries to surface requests in the
+ * Fusebox / RN DevTools Network tab. We intentionally bypass the visibility modifier
+ * rather than duplicating the JNI bindings, matching the pattern used by other
+ * community HTTP clients. If the class isn't present (RN < 0.76 or a trimmed
+ * distribution), every call becomes a no-op.
+ */
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+internal object DevToolsReporter {
+  private val available: Boolean = try {
+    Class.forName("com.facebook.react.modules.network.InspectorNetworkReporter")
+    true
+  } catch (_: Throwable) {
+    false
+  }
+
+  fun isDebuggingEnabled(): Boolean {
+    if (!available) return false
+    return try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.isDebuggingEnabled()
+    } catch (_: Throwable) {
+      false
+    }
+  }
+
+  fun reportRequestStart(
+    requestId: String,
+    url: String,
+    method: String,
+    headers: Map<String, String>,
+    body: String,
+    encodedDataLength: Long
+  ) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestStart(
+        requestId, url, method, headers, body, encodedDataLength
+      )
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportConnectionTiming(requestId, headers)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportResponseStart(
+    requestId: String,
+    url: String,
+    statusCode: Int,
+    headers: Map<String, String>,
+    expectedDataLength: Long
+  ) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseStart(
+        requestId, url, statusCode, headers, expectedDataLength
+      )
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportDataReceived(requestId: String, length: Int) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportDataReceivedImpl(requestId, length)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportResponseEnd(requestId: String, encodedDataLength: Long) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseEnd(requestId, encodedDataLength)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun reportRequestFailed(requestId: String, cancelled: Boolean) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestFailed(requestId, cancelled)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBody(
+        requestId, body, base64Encoded
+      )
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun storeResponseBodyIncremental(requestId: String, data: String) {
+    if (!available) return
+    try {
+      com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBodyIncremental(requestId, data)
+    } catch (_: Throwable) {
+    }
+  }
+
+  fun isTextualContentType(contentType: String?): Boolean {
+    if (contentType == null) return false
+    val ct = contentType.lowercase()
+    return ct.startsWith("text/") ||
+      ct.contains("application/json") ||
+      ct.contains("application/xml") ||
+      ct.contains("application/javascript") ||
+      ct.contains("+json") ||
+      ct.contains("+xml")
+  }
+
+  fun headersArrayToMap(headers: Array<NitroHeader>?): Map<String, String> {
+    if (headers == null) return emptyMap()
+    val map = LinkedHashMap<String, String>(headers.size)
+    for (h in headers) map[h.key] = h.value
+    return map
+  }
+
+  fun headersListToMap(entries: List<Map.Entry<String, String>>): Map<String, String> {
+    val map = LinkedHashMap<String, String>(entries.size)
+    for (e in entries) map[e.key] = e.value
+    return map
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroFetchClient.kt

@@ -80,10 +80,14 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       if (BuildConfig.NITRO_FETCH_TRACING) {
         Trace.beginAsyncSection(traceLabel, traceCookie)
       }
+      val devToolsRequestId = req.requestId ?: UUID.randomUUID().toString()
+      val devToolsEnabled = DevToolsReporter.isDebuggingEnabled()
       val callback = object : UrlRequest.Callback() {
         private val buffer = ByteBuffer.allocateDirect(16 * 1024)
         private val out = java.io.ByteArrayOutputStream()
         private var redirectStopped = false
+        private var devToolsBytes = 0
+        private var devToolsTextual = false
 
         override fun onRedirectReceived(request: UrlRequest, info: UrlResponseInfo, newLocationUrl: String) {
           if (shouldFollowRedirects) {
@@ -113,6 +117,19 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
         }
 
         override fun onResponseStarted(request: UrlRequest, info: UrlResponseInfo) {
+          if (devToolsEnabled) {
+            val headersMap = LinkedHashMap<String, String>()
+            info.allHeadersAsList.forEach { headersMap[it.key] = it.value }
+            val contentType = headersMap["Content-Type"] ?: headersMap["content-type"]
+            devToolsTextual = DevToolsReporter.isTextualContentType(contentType)
+            DevToolsReporter.reportResponseStart(
+              devToolsRequestId,
+              info.url,
+              info.httpStatusCode,
+              headersMap,
+              -1L
+            )
+          }
           buffer.clear()
           request.read(buffer)
         }
@@ -122,6 +139,13 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           val bytes = ByteArray(byteBuffer.remaining())
           byteBuffer.get(bytes)
           out.write(bytes)
+          if (devToolsEnabled) {
+            devToolsBytes += bytes.size
+            DevToolsReporter.reportDataReceived(devToolsRequestId, bytes.size)
+            if (devToolsTextual) {
+              DevToolsReporter.storeResponseBodyIncremental(devToolsRequestId, String(bytes, Charsets.UTF_8))
+            }
+          }
           byteBuffer.clear()
           request.read(byteBuffer)
         }
@@ -130,6 +154,9 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           if (BuildConfig.NITRO_FETCH_TRACING) {
             Trace.endAsyncSection(traceLabel, traceCookie)
           }
+          if (devToolsEnabled) {
+            DevToolsReporter.reportResponseEnd(devToolsRequestId, devToolsBytes.toLong())
+          }
           try {
             val headersArr: Array<NitroHeader> =
               info.allHeadersAsList.map { NitroHeader(it.key, it.value) }.toTypedArray()
@@ -166,6 +193,9 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           if (BuildConfig.NITRO_FETCH_TRACING) {
             Trace.endAsyncSection(traceLabel, traceCookie)
           }
+          if (devToolsEnabled) {
+            DevToolsReporter.reportRequestFailed(devToolsRequestId, false)
+          }
           onFail(RuntimeException("Cronet failed: ${error.message}", error))
         }
 
@@ -173,6 +203,9 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           if (BuildConfig.NITRO_FETCH_TRACING) {
             Trace.endAsyncSection(traceLabel, traceCookie)
           }
+          if (devToolsEnabled) {
+            DevToolsReporter.reportRequestFailed(devToolsRequestId, true)
+          }
           if (!redirectStopped) {
             onFail(RuntimeException("Cronet canceled"))
           }
@@ -205,6 +238,19 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       }
 
       val request = builder.build()
+      if (devToolsEnabled) {
+        val headersMap = DevToolsReporter.headersArrayToMap(req.headers)
+        val body = req.bodyString ?: ""
+        val encoded = body.toByteArray(Charsets.UTF_8).size.toLong()
+        DevToolsReporter.reportRequestStart(
+          devToolsRequestId,
+          url,
+          method,
+          headersMap,
+          body,
+          encoded
+        )
+      }
       request.start()
       return request
     }

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroUrlRequestBuilder.kt

@@ -7,6 +7,7 @@ import org.chromium.net.UrlRequest as CronetUrlRequest
 import org.chromium.net.UrlResponseInfo as CronetUrlResponseInfo
 import org.chromium.net.CronetException as CronetNativeException
 import java.nio.ByteBuffer
+import java.util.UUID
 import java.util.concurrent.Executor as JavaExecutor
 
 @DoNotStrip
@@ -26,6 +27,14 @@ class NitroUrlRequestBuilder(
 
   private val builder: CronetUrlRequest.Builder
   private val byteBuffer: ByteBuffer
+  private val devToolsRequestId: String = UUID.randomUUID().toString()
+  private val devToolsEnabled: Boolean = DevToolsReporter.isDebuggingEnabled()
+  private var devToolsBytes: Int = 0
+  private var devToolsTextual: Boolean = false
+  private var httpMethod: String = "GET"
+  private val requestHeaders: LinkedHashMap<String, String> = LinkedHashMap()
+  private var uploadBodyString: String = ""
+  private var uploadBodyLength: Long = 0L
 
   init {
     // Allocate ONE reusable owning buffer for all reads (64KB)
@@ -49,6 +58,19 @@ class NitroUrlRequestBuilder(
         request: CronetUrlRequest,
         info: CronetUrlResponseInfo
       ) {
+        if (devToolsEnabled) {
+          val headersMap = LinkedHashMap<String, String>()
+          info.allHeadersAsList.forEach { headersMap[it.key] = it.value }
+          val ct = headersMap["Content-Type"] ?: headersMap["content-type"]
+          devToolsTextual = DevToolsReporter.isTextualContentType(ct)
+          DevToolsReporter.reportResponseStart(
+            devToolsRequestId,
+            info.url,
+            info.httpStatusCode,
+            headersMap,
+            -1L
+          )
+        }
         onResponseStartedCallback?.let { callback ->
           val nitroInfo = info.toNitro()
           callback(nitroInfo)
@@ -60,8 +82,19 @@ class NitroUrlRequestBuilder(
         info: CronetUrlResponseInfo,
         receivedBuffer: ByteBuffer
       ) {
+        val bytesRead = receivedBuffer.position()
+        if (devToolsEnabled && bytesRead > 0) {
+          devToolsBytes += bytesRead
+          DevToolsReporter.reportDataReceived(devToolsRequestId, bytesRead)
+          if (devToolsTextual) {
+            val dup = receivedBuffer.duplicate()
+            dup.flip()
+            val arr = ByteArray(dup.remaining())
+            dup.get(arr)
+            DevToolsReporter.storeResponseBodyIncremental(devToolsRequestId, String(arr, Charsets.UTF_8))
+          }
+        }
         onReadCompletedCallback?.let { callback ->
-          val bytesRead = receivedBuffer.position()
           val nitroInfo = info.toNitro()
           callback(nitroInfo, reusableBuffer, bytesRead.toDouble())
         }
@@ -71,6 +104,9 @@ class NitroUrlRequestBuilder(
         request: CronetUrlRequest,
         info: CronetUrlResponseInfo
       ) {
+        if (devToolsEnabled) {
+          DevToolsReporter.reportResponseEnd(devToolsRequestId, devToolsBytes.toLong())
+        }
         onSucceededCallback?.let { callback ->
           val nitroInfo = info.toNitro()
           callback(nitroInfo)
@@ -82,6 +118,9 @@ class NitroUrlRequestBuilder(
         info: CronetUrlResponseInfo?,
         error: CronetNativeException
       ) {
+        if (devToolsEnabled) {
+          DevToolsReporter.reportRequestFailed(devToolsRequestId, false)
+        }
         onFailedCallback?.let { callback ->
           val nitroInfo = info?.toNitro()
           val nitroError = error.toNitro()
@@ -93,6 +132,9 @@ class NitroUrlRequestBuilder(
         request: CronetUrlRequest,
         info: CronetUrlResponseInfo?
       ) {
+        if (devToolsEnabled) {
+          DevToolsReporter.reportRequestFailed(devToolsRequestId, true)
+        }
         onCanceledCallback?.let { callback ->
           val nitroInfo = info?.toNitro()
           callback(nitroInfo)
@@ -104,11 +146,13 @@ class NitroUrlRequestBuilder(
   }
 
   override fun setHttpMethod(httpMethod: String) {
+    this.httpMethod = httpMethod
     builder.setHttpMethod(httpMethod)
   }
 
   override fun addHeader(name: String, value: String) {
-    builder.addHeader(name, value)  
+    requestHeaders[name] = value
+    builder.addHeader(name, value)
   }
 
   override fun setUploadBody(body: Variant_ArrayBuffer_String) {
@@ -119,8 +163,12 @@ class NitroUrlRequestBuilder(
         buffer.get(bytes)
         bytes
       }
-      is Variant_ArrayBuffer_String.Second -> body.value.toByteArray(Charsets.UTF_8)
+      is Variant_ArrayBuffer_String.Second -> {
+        uploadBodyString = body.value
+        body.value.toByteArray(Charsets.UTF_8)
+      }
     }
+    uploadBodyLength = bodyBytes.size.toLong()
 
     val provider = object : org.chromium.net.UploadDataProvider() {
       private var position = 0
@@ -176,6 +224,16 @@ class NitroUrlRequestBuilder(
 
   override fun build(): HybridUrlRequestSpec {
     val cronetRequest = builder.build()
+    if (devToolsEnabled) {
+      DevToolsReporter.reportRequestStart(
+        devToolsRequestId,
+        url,
+        httpMethod,
+        requestHeaders,
+        uploadBodyString,
+        uploadBodyLength
+      )
+    }
     return NitroUrlRequest(cronetRequest, byteBuffer)
   }
 }

package/ios/HybridUrlRequestBuilder.swift

@@ -16,6 +16,7 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
 
   private var urlRequest: URLRequest
   private var priority: Float = 0.5
+  private let devToolsRequestId: String = UUID().uuidString
 
   init(
     url: String,
@@ -89,7 +90,8 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
       onFailed: onFailedCallback,
       onCanceled: onCanceledCallback,
       executor: executor,
-      hybridRequest: nil
+      hybridRequest: nil,
+      devToolsRequestId: devToolsRequestId
     )
 
     let config = URLSessionConfiguration.default
@@ -107,6 +109,10 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
     task.priority = priority
     delegate.task = task
 
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      NitroDevToolsReporter.reportRequestStart(withRequest: devToolsRequestId, request: urlRequest)
+    }
+
     let request = HybridUrlRequest(task: task, delegate: delegate)
     delegate.hybridRequest = request
 
@@ -129,6 +135,9 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
   weak var hybridRequest: HybridUrlRequest?
 
   private var response: HTTPURLResponse?
+  private let devToolsRequestId: String
+  private var devToolsBytes: Int = 0
+  private var devToolsTextual: Bool = false
 
   init(
     onRedirectReceived: ((_ info: UrlResponseInfo, _ newLocationUrl: String) -> Void)?,
@@ -138,7 +147,8 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
     onFailed: ((_ info: UrlResponseInfo?, _ error: RequestException) -> Void)?,
     onCanceled: ((_ info: UrlResponseInfo?) -> Void)?,
     executor: DispatchQueue,
-    hybridRequest: HybridUrlRequest?
+    hybridRequest: HybridUrlRequest?,
+    devToolsRequestId: String
   ) {
     self.onRedirectReceived = onRedirectReceived
     self.onResponseStarted = onResponseStarted
@@ -148,6 +158,7 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
     self.onCanceled = onCanceled
     self.executor = executor
     self.hybridRequest = hybridRequest
+    self.devToolsRequestId = devToolsRequestId
     super.init()
   }
 
@@ -181,11 +192,17 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       if let error = error {
         let nsError = error as NSError
         if nsError.code == NSURLErrorCancelled {
+          if NitroDevToolsReporter.isDebuggingEnabled() {
+            NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: true)
+          }
           if let callback = self.onCanceled {
             let nitroInfo = self.response?.toNitro()
             callback(nitroInfo)
           }
         } else {
+          if NitroDevToolsReporter.isDebuggingEnabled() {
+            NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: false)
+          }
           if let callback = self.onFailed {
             let nitroError = error.toNitro()
             let nitroInfo = self.response?.toNitro()
@@ -193,6 +210,9 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
           }
         }
       } else if let response = self.response {
+        if NitroDevToolsReporter.isDebuggingEnabled() {
+          NitroDevToolsReporter.reportResponseEnd(self.devToolsRequestId, encodedDataLength: self.devToolsBytes)
+        }
         if let callback = self.onSucceeded {
           let info = response.toNitro()
           callback(info)
@@ -216,6 +236,20 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
 
     executor.sync { [weak self] in
       guard let self = self else { return }
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        var headerDict: [String: String] = [:]
+        httpResponse.allHeaderFields.forEach { k, v in
+          if let key = k as? String { headerDict[key] = String(describing: v) }
+        }
+        NitroDevToolsReporter.reportResponseStart(
+          self.devToolsRequestId,
+          url: httpResponse.url?.absoluteString ?? "",
+          statusCode: httpResponse.statusCode,
+          headers: headerDict
+        )
+        let ct = headerDict["Content-Type"] ?? headerDict["content-type"]
+        self.devToolsTextual = NitroDevToolsReporter.isTextualContentType(ct)
+      }
       if let callback = self.onResponseStarted {
         let info = httpResponse.toNitro()
         callback(info)
@@ -234,6 +268,14 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       executor.sync { [weak self] in
         guard let self = self, let response = self.response else { return }
 
+        if NitroDevToolsReporter.isDebuggingEnabled() {
+          self.devToolsBytes += data.count
+          NitroDevToolsReporter.reportDataReceived(self.devToolsRequestId, length: data.count)
+          if self.devToolsTextual, let text = String(data: data, encoding: .utf8) {
+            NitroDevToolsReporter.storeResponseBodyIncremental(self.devToolsRequestId, text: text)
+          }
+        }
+
         let arrayBuffer: ArrayBuffer
         do {
           arrayBuffer = try ArrayBuffer.copy(data: data)

package/ios/NitroDevToolsReporter.h

@@ -0,0 +1,42 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Swift-friendly facade over RCTInspectorNetworkReporter.
+/// All methods are no-ops when the modern CDP debugger is not attached
+/// (checked via -isDebuggingEnabled). Safe to call in release builds.
+@interface NitroDevToolsReporter : NSObject
+
++ (BOOL)isDebuggingEnabled;
+
++ (void)reportRequestStartWithRequest:(NSString *)requestId
+                              request:(NSURLRequest *)request;
+
++ (void)reportRequestStart:(NSString *)requestId
+                       url:(NSString *)url
+                    method:(NSString *)method
+                   headers:(NSDictionary<NSString *, NSString *> *)headers
+                bodyString:(nullable NSString *)bodyString;
+
++ (void)reportResponseStart:(NSString *)requestId
+                        url:(NSString *)url
+                 statusCode:(NSInteger)statusCode
+                    headers:(NSDictionary<NSString *, NSString *> *)headers;
+
++ (void)reportDataReceived:(NSString *)requestId length:(NSInteger)length;
+
++ (void)reportResponseEnd:(NSString *)requestId encodedDataLength:(NSInteger)length;
+
++ (void)reportRequestFailed:(NSString *)requestId cancelled:(BOOL)cancelled;
+
++ (void)storeResponseBody:(NSString *)requestId
+                     data:(NSData *)data
+            base64Encoded:(BOOL)base64Encoded;
+
++ (void)storeResponseBodyIncremental:(NSString *)requestId text:(NSString *)text;
+
++ (BOOL)isTextualContentType:(nullable NSString *)contentType;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NitroDevToolsReporter.mm

@@ -0,0 +1,129 @@
+#import "NitroDevToolsReporter.h"
+
+// RCTInspectorNetworkReporter is bundled in React-RCTNetwork. In RN < 0.76
+// or when the header isn't visible (release-optimized module maps, OSS forks),
+// we compile to a no-op so the module still builds.
+#if __has_include(<React/RCTInspectorNetworkReporter.h>)
+#import <React/RCTInspectorNetworkReporter.h>
+#define NITRO_HAS_NETWORK_REPORTER 1
+#else
+#define NITRO_HAS_NETWORK_REPORTER 0
+#endif
+
+// The Objective-C wrapper does not expose -isDebuggingEnabled publicly,
+// but the underlying C++ NetworkReporter does. We avoid depending on the
+// C++ header and instead rely on RN guarding every report call internally.
+// For our own body-capture short-circuit we assume enabled when the class
+// exists; the underlying calls are still no-ops when no debugger attached.
+
+@implementation NitroDevToolsReporter
+
++ (BOOL)isDebuggingEnabled {
+#if NITRO_HAS_NETWORK_REPORTER
+  return YES;
+#else
+  return NO;
+#endif
+}
+
++ (void)reportRequestStartWithRequest:(NSString *)requestId
+                              request:(NSURLRequest *)request {
+#if NITRO_HAS_NETWORK_REPORTER
+  if (request == nil) return;
+  int encoded = (int)(request.HTTPBody.length);
+  [RCTInspectorNetworkReporter reportRequestStart:requestId request:request encodedDataLength:encoded];
+  [RCTInspectorNetworkReporter reportConnectionTiming:requestId request:request];
+#endif
+}
+
++ (void)reportRequestStart:(NSString *)requestId
+                       url:(NSString *)url
+                    method:(NSString *)method
+                   headers:(NSDictionary<NSString *, NSString *> *)headers
+                bodyString:(NSString *)bodyString {
+#if NITRO_HAS_NETWORK_REPORTER
+  NSURL *u = [NSURL URLWithString:url];
+  if (u == nil) return;
+  NSMutableURLRequest *req = [NSMutableURLRequest requestWithURL:u];
+  req.HTTPMethod = method ?: @"GET";
+  for (NSString *k in headers) {
+    [req setValue:headers[k] forHTTPHeaderField:k];
+  }
+  if (bodyString.length > 0) {
+    req.HTTPBody = [bodyString dataUsingEncoding:NSUTF8StringEncoding];
+  }
+  NSInteger encoded = bodyString ? (NSInteger)[bodyString lengthOfBytesUsingEncoding:NSUTF8StringEncoding] : 0;
+  [RCTInspectorNetworkReporter reportRequestStart:requestId request:req encodedDataLength:(int)encoded];
+  [RCTInspectorNetworkReporter reportConnectionTiming:requestId request:req];
+#endif
+}
+
++ (void)reportResponseStart:(NSString *)requestId
+                        url:(NSString *)url
+                 statusCode:(NSInteger)statusCode
+                    headers:(NSDictionary<NSString *, NSString *> *)headers {
+#if NITRO_HAS_NETWORK_REPORTER
+  NSURL *u = [NSURL URLWithString:url];
+  if (u == nil) return;
+  NSHTTPURLResponse *resp = [[NSHTTPURLResponse alloc] initWithURL:u
+                                                         statusCode:statusCode
+                                                        HTTPVersion:@"HTTP/1.1"
+                                                       headerFields:headers];
+  [RCTInspectorNetworkReporter reportResponseStart:requestId
+                                           response:resp
+                                         statusCode:(int)statusCode
+                                            headers:headers];
+#endif
+}
+
++ (void)reportDataReceived:(NSString *)requestId length:(NSInteger)length {
+#if NITRO_HAS_NETWORK_REPORTER
+  if (length <= 0) return;
+  // Only data.length is read by the underlying reporter. Avoid allocating a
+  // zero-filled buffer by handing NSData a non-owned byte pointer and the
+  // intended length.
+  static uint8_t sentinel;
+  NSData *sized = [NSData dataWithBytesNoCopy:&sentinel length:(NSUInteger)length freeWhenDone:NO];
+  [RCTInspectorNetworkReporter reportDataReceived:requestId data:sized];
+#endif
+}
+
++ (void)reportResponseEnd:(NSString *)requestId encodedDataLength:(NSInteger)length {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter reportResponseEnd:requestId encodedDataLength:(int)length];
+#endif
+}
+
++ (void)reportRequestFailed:(NSString *)requestId cancelled:(BOOL)cancelled {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter reportRequestFailed:requestId cancelled:cancelled];
+#endif
+}
+
++ (void)storeResponseBody:(NSString *)requestId
+                     data:(NSData *)data
+            base64Encoded:(BOOL)base64Encoded {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter maybeStoreResponseBody:requestId data:data base64Encoded:base64Encoded];
+#endif
+}
+
++ (void)storeResponseBodyIncremental:(NSString *)requestId text:(NSString *)text {
+#if NITRO_HAS_NETWORK_REPORTER
+  [RCTInspectorNetworkReporter maybeStoreResponseBodyIncremental:requestId data:text];
+#endif
+}
+
++ (BOOL)isTextualContentType:(NSString *)contentType {
+  if (contentType == nil) return NO;
+  NSString *ct = [contentType lowercaseString];
+  if ([ct hasPrefix:@"text/"]) return YES;
+  if ([ct containsString:@"application/json"]) return YES;
+  if ([ct containsString:@"application/xml"]) return YES;
+  if ([ct containsString:@"application/javascript"]) return YES;
+  if ([ct containsString:@"+json"]) return YES;
+  if ([ct containsString:@"+xml"]) return YES;
+  return NO;
+}
+
+@end

package/ios/NitroFetchClient.swift

@@ -170,8 +170,26 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
                 "%{public}s %{public}s", traceMethod, tracePath)
     #endif
 
-    let (data, response) = try await session.data(for: urlRequest, delegate: delegate)
+    let devToolsId = req.requestId ?? UUID().uuidString
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      NitroDevToolsReporter.reportRequestStart(withRequest: devToolsId, request: urlRequest)
+    }
+
+    let data: Data
+    let response: URLResponse
+    do {
+      (data, response) = try await session.data(for: urlRequest, delegate: delegate)
+    } catch {
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        let cancelled = (error as NSError).code == NSURLErrorCancelled
+        NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: cancelled)
+      }
+      throw error
+    }
     guard let http = response as? HTTPURLResponse else {
+      if NitroDevToolsReporter.isDebuggingEnabled() {
+        NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: false)
+      }
       throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
     }
 
@@ -180,6 +198,26 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
       return NitroHeader(key: key, value: String(describing: v))
     }
 
+    if NitroDevToolsReporter.isDebuggingEnabled() {
+      var headerDict: [String: String] = [:]
+      for h in headersPairs { headerDict[h.key] = h.value }
+      NitroDevToolsReporter.reportResponseStart(
+        devToolsId,
+        url: finalURL?.absoluteString ?? http.url?.absoluteString ?? req.url,
+        statusCode: http.statusCode,
+        headers: headerDict
+      )
+      NitroDevToolsReporter.reportDataReceived(devToolsId, length: data.count)
+      if NitroDevToolsReporter.isTextualContentType(headerDict["Content-Type"] ?? headerDict["content-type"]) {
+        if let text = String(data: data, encoding: .utf8) {
+          NitroDevToolsReporter.storeResponseBody(devToolsId, data: Data(text.utf8), base64Encoded: false)
+        }
+      } else if data.count > 0 && data.count <= 5 * 1024 * 1024 {
+        NitroDevToolsReporter.storeResponseBody(devToolsId, data: data, base64Encoded: true)
+      }
+      NitroDevToolsReporter.reportResponseEnd(devToolsId, encodedDataLength: data.count)
+    }
+
     // Choose bodyString by default (matching Android’s first pass)
     let charset = NitroFetchClient.detectCharset(from: http) ?? String.Encoding.utf8
     let bodyStr = String(data: data, encoding: charset) ?? String(data: data, encoding: .utf8)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-fetch",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",