diff --git a/deps/undici/src/lib/core/diagnostics.js b/deps/undici/src/lib/core/diagnostics.js
index 454ab379be3802..f7f26b2143670a 100644
--- a/deps/undici/src/lib/core/diagnostics.js
+++ b/deps/undici/src/lib/core/diagnostics.js
@@ -21,6 +21,7 @@ const channels = {
   headers: diagnosticsChannel.channel('undici:request:headers'),
   trailers: diagnosticsChannel.channel('undici:request:trailers'),
   error: diagnosticsChannel.channel('undici:request:error'),
+  fetchEventSourceMessage: diagnosticsChannel.channel('undici:fetch:eventsource:message'),
   // WebSocket
   open: diagnosticsChannel.channel('undici:websocket:open'),
   close: diagnosticsChannel.channel('undici:websocket:close'),
diff --git a/deps/undici/src/lib/core/request.js b/deps/undici/src/lib/core/request.js
index 2b2633f3d04224..d23b0a470bed69 100644
--- a/deps/undici/src/lib/core/request.js
+++ b/deps/undici/src/lib/core/request.js
@@ -96,7 +96,8 @@ class Request {
     servername,
     throwOnError,
     maxRedirections,
-    typeOfService
+    typeOfService,
+    fetchRequest
   }, handler) {
     if (typeof path !== 'string') {
       throw new InvalidArgumentError('path must be a string')
@@ -260,7 +261,7 @@ class Request {
     this[kHandler] = handler
 
     if (channels.create.hasSubscribers) {
-      channels.create.publish({ request: this })
+      channels.create.publish({ request: this, fetchRequest })
     }
   }
 
diff --git a/deps/undici/src/lib/web/eventsource/eventsource.js b/deps/undici/src/lib/web/eventsource/eventsource.js
index 32dcf0e423e06f..26fb6ac40b330a 100644
--- a/deps/undici/src/lib/web/eventsource/eventsource.js
+++ b/deps/undici/src/lib/web/eventsource/eventsource.js
@@ -182,6 +182,7 @@ class EventSource extends EventTarget {
 
     // 12. Set request's initiator type to "other".
     initRequest.initiator = 'other'
+    initRequest.eventSource = true
 
     initRequest.urlList = [new URL(this.#url)]
 
diff --git a/deps/undici/src/lib/web/fetch/index.js b/deps/undici/src/lib/web/fetch/index.js
index 85d4c2e9feda0c..9d2ac7949f4693 100644
--- a/deps/undici/src/lib/web/fetch/index.js
+++ b/deps/undici/src/lib/web/fetch/index.js
@@ -11,8 +11,15 @@ const {
   getResponseState
 } = require('./response')
 const { HeadersList } = require('./headers')
-const { Request, cloneRequest, getRequestDispatcher, getRequestState } = require('./request')
+const {
+  Request,
+  cloneRequest,
+  getRequestDispatcher,
+  getRequestState,
+  kOriginalRequest
+} = require('./request')
 const zlib = require('node:zlib')
+const { channels } = require('../../core/diagnostics')
 const {
   makePolicyContainer,
   clonePolicyContainer,
@@ -57,9 +64,10 @@ const {
   subresourceSet
 } = require('./constants')
 const EE = require('node:events')
-const { Readable, pipeline, finished, isErrored, isReadable } = require('node:stream')
+const { Readable, Transform, pipeline, finished, isErrored, isReadable } = require('node:stream')
 const { addAbortListener, bufferToLowerCasedHeaderName } = require('../../core/util')
 const { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require('./data-url')
+const { EventSourceStream } = require('../eventsource/eventsource-stream')
 const { getGlobalDispatcher } = require('../../global')
 const { webidl } = require('../webidl')
 const { STATUS_CODES } = require('node:http')
@@ -75,6 +83,45 @@ const defaultUserAgent = typeof __UNDICI_IS_NODE__ !== 'undefined' || typeof esb
 /** @type {import('buffer').resolveObjectURL} */
 let resolveObjectURL
 
+function createEventSourceMessageTransform (request) {
+  const originalRequest = request[kOriginalRequest] ?? request
+  const parser = new EventSourceStream({
+    eventSourceSettings: { lastEventId: '' },
+    push (event) {
+      if (event === null) {
+        return false
+      }
+      channels.fetchEventSourceMessage.publish({
+        request: originalRequest,
+        eventName: event.type,
+        eventId: event.options.lastEventId,
+        data: event.options.data
+      })
+      return true
+    }
+  })
+
+  let transform
+  transform = new Transform({
+    transform (chunk, encoding, callback) {
+      parser.write(chunk, encoding, (err) => {
+        callback(err, chunk)
+      })
+    },
+    flush (callback) {
+      parser.end(callback)
+    },
+    destroy (err, callback) {
+      parser.destroy(err)
+      callback(err)
+    }
+  })
+
+  parser.on('error', (err) => transform.destroy(err))
+
+  return transform
+}
+
 class Fetch extends EE {
   constructor (dispatcher) {
     super()
@@ -2153,6 +2200,7 @@ async function httpNetworkFetch (
           method: request.method,
           body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
           headers: request.headersList.entries,
+          fetchRequest: request[kOriginalRequest] ?? request,
           maxRedirections: 0,
           upgrade: request.mode === 'websocket' ? 'websocket' : undefined,
           ...(allowH2 === false ? { allowH2 } : null)
@@ -2213,6 +2261,7 @@ async function httpNetworkFetch (
               }
             }
             const location = headersList.get('location', true)
+            const mimeType = extractMimeType(headersList)
 
             this.body = new Readable({ read: () => controller.resume() })
 
@@ -2272,18 +2321,32 @@ async function httpNetworkFetch (
             }
 
             const onError = (err) => this.onResponseError(controller, err)
+            const originalRequest = request[kOriginalRequest] ?? request
+            const shouldPublishEventSourceMessages =
+              channels.fetchEventSourceMessage.hasSubscribers &&
+              originalRequest.eventSource !== true &&
+              mimeType !== 'failure' &&
+              mimeType.essence === 'text/event-stream'
+            const eventSourceMessageTransform = shouldPublishEventSourceMessages ?
+              createEventSourceMessageTransform(request) :
+              null
+            const responseBody = decoders.length || eventSourceMessageTransform ?
+              pipeline(
+                this.body,
+                ...decoders,
+                ...(eventSourceMessageTransform ? [eventSourceMessageTransform] : []),
+                (err) => {
+                  if (err) {
+                    this.onResponseError(controller, err)
+                  }
+                }).on('error', onError) :
+              this.body.on('error', onError)
 
             resolve({
               status,
               statusText,
               headersList,
-              body: decoders.length
-                ? pipeline(this.body, ...decoders, (err) => {
-                  if (err) {
-                    this.onResponseError(controller, err)
-                  }
-                }).on('error', onError)
-                : this.body.on('error', onError)
+              body: responseBody
             })
           },
 
diff --git a/deps/undici/src/lib/web/fetch/request.js b/deps/undici/src/lib/web/fetch/request.js
index 6ef40f99920840..859f6e7406d26b 100644
--- a/deps/undici/src/lib/web/fetch/request.js
+++ b/deps/undici/src/lib/web/fetch/request.js
@@ -29,6 +29,7 @@ const assert = require('node:assert')
 const { getMaxListeners, setMaxListeners, defaultMaxListeners } = require('node:events')
 
 const kAbortController = Symbol('abortController')
+const kOriginalRequest = Symbol('originalRequest')
 
 const requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
   signal.removeEventListener('abort', abort)
@@ -934,6 +935,7 @@ function cloneRequest (request) {
 
   // 1. Let newRequest be a copy of request, except for its body.
   const newRequest = makeRequest({ ...request, body: null })
+  newRequest[kOriginalRequest] = request[kOriginalRequest] ?? request
 
   // 2. If request’s body is non-null, set newRequest’s body to the
   // result of cloning request’s body.
@@ -1110,6 +1112,7 @@ module.exports = {
   makeRequest,
   fromInnerRequest,
   cloneRequest,
+  kOriginalRequest,
   getRequestDispatcher,
   getRequestState
 }
diff --git a/deps/undici/undici.js b/deps/undici/undici.js
index 6be4f5b522b775..d622789567d76e 100644
--- a/deps/undici/undici.js
+++ b/deps/undici/undici.js
@@ -2465,6 +2465,7 @@ var require_diagnostics = __commonJS({
       headers: diagnosticsChannel.channel("undici:request:headers"),
       trailers: diagnosticsChannel.channel("undici:request:trailers"),
       error: diagnosticsChannel.channel("undici:request:error"),
+      fetchEventSourceMessage: diagnosticsChannel.channel("undici:fetch:eventsource:message"),
       // WebSocket
       open: diagnosticsChannel.channel("undici:websocket:open"),
       close: diagnosticsChannel.channel("undici:websocket:close"),
@@ -2748,14 +2749,15 @@ var require_request = __commonJS({
         blocking,
         upgrade,
         headersTimeout,
-        bodyTimeout,
-        reset,
-        expectContinue,
-        servername,
-        throwOnError,
-        maxRedirections,
-        typeOfService
-      }, handler) {
+      bodyTimeout,
+      reset,
+      expectContinue,
+      servername,
+      throwOnError,
+      maxRedirections,
+      typeOfService,
+      fetchRequest
+    }, handler) {
         if (typeof path !== "string") {
           throw new InvalidArgumentError("path must be a string");
         } else if (path[0] !== "/" && !(path.startsWith("http://") || path.startsWith("https://")) && method !== "CONNECT") {
@@ -2874,7 +2876,7 @@ var require_request = __commonJS({
         this.servername = servername || getServerName(this.host) || null;
         this[kHandler] = handler;
         if (channels.create.hasSubscribers) {
-          channels.create.publish({ request: this });
+          channels.create.publish({ request: this, fetchRequest });
         }
       }
       onBodySent(chunk) {
@@ -11760,6 +11762,7 @@ var require_request2 = __commonJS({
     var assert = require("node:assert");
     var { getMaxListeners, setMaxListeners, defaultMaxListeners } = require("node:events");
     var kAbortController = /* @__PURE__ */ Symbol("abortController");
+    var kOriginalRequest = /* @__PURE__ */ Symbol("originalRequest");
     var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
       signal.removeEventListener("abort", abort);
     });
@@ -12341,6 +12344,7 @@ var require_request2 = __commonJS({
     __name(makeRequest, "makeRequest");
     function cloneRequest(request) {
       const newRequest = makeRequest({ ...request, body: null });
+      newRequest[kOriginalRequest] = request[kOriginalRequest] ?? request;
       if (request.body != null) {
         newRequest.body = cloneBody(request.body);
       }
@@ -12488,6 +12492,7 @@ var require_request2 = __commonJS({
       makeRequest,
       fromInnerRequest,
       cloneRequest,
+      kOriginalRequest,
       getRequestDispatcher,
       getRequestState
     };
@@ -12649,8 +12654,9 @@ var require_fetch = __commonJS({
       getResponseState
     } = require_response();
     var { HeadersList } = require_headers();
-    var { Request, cloneRequest, getRequestDispatcher, getRequestState } = require_request2();
+    var { Request, cloneRequest, getRequestDispatcher, getRequestState, kOriginalRequest } = require_request2();
     var zlib = require("node:zlib");
+    var { channels } = require_diagnostics();
     var {
       makePolicyContainer,
       clonePolicyContainer,
@@ -12695,9 +12701,10 @@ var require_fetch = __commonJS({
       subresourceSet
     } = require_constants3();
     var EE = require("node:events");
-    var { Readable, pipeline, finished, isErrored, isReadable } = require("node:stream");
+    var { Readable, Transform, pipeline, finished, isErrored, isReadable } = require("node:stream");
     var { addAbortListener, bufferToLowerCasedHeaderName } = require_util();
     var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url();
+    var { EventSourceStream } = require_eventsource_stream();
     var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global2();
     var { webidl } = require_webidl();
     var { STATUS_CODES } = require("node:http");
@@ -12706,6 +12713,42 @@ var require_fetch = __commonJS({
     var GET_OR_HEAD = ["GET", "HEAD"];
     var defaultUserAgent = typeof __UNDICI_IS_NODE__ !== "undefined" || true ? "node" : "undici";
     var resolveObjectURL;
+    function createEventSourceMessageTransform(request) {
+      const originalRequest = request[kOriginalRequest] ?? request;
+      const parser = new EventSourceStream({
+        eventSourceSettings: { lastEventId: "" },
+        push(event) {
+          if (event === null) {
+            return false;
+          }
+          channels.fetchEventSourceMessage.publish({
+            request: originalRequest,
+            eventName: event.type,
+            eventId: event.options.lastEventId,
+            data: event.options.data
+          });
+          return true;
+        }
+      });
+      let transform;
+      transform = new Transform({
+        transform(chunk, encoding, callback) {
+          parser.write(chunk, encoding, (err) => {
+            callback(err, chunk);
+          });
+        },
+        flush(callback) {
+          parser.end(callback);
+        },
+        destroy(err, callback) {
+          parser.destroy(err);
+          callback(err);
+        }
+      });
+      parser.on("error", (err) => transform.destroy(err));
+      return transform;
+    }
+    __name(createEventSourceMessageTransform, "createEventSourceMessageTransform");
     var Fetch = class extends EE {
       static {
         __name(this, "Fetch");
@@ -13616,6 +13659,7 @@ var require_fetch = __commonJS({
               method: request.method,
               body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body2,
               headers: request.headersList.entries,
+              fetchRequest: request[kOriginalRequest] ?? request,
               maxRedirections: 0,
               upgrade: request.mode === "websocket" ? "websocket" : void 0,
               ...allowH2 === false ? { allowH2 } : null
@@ -13656,6 +13700,7 @@ var require_fetch = __commonJS({
                   }
                 }
                 const location = headersList.get("location", true);
+                const mimeType = extractMimeType(headersList);
                 this.body = new Readable({ read: /* @__PURE__ */ __name(() => controller.resume(), "read") });
                 const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status);
                 const decoders = [];
@@ -13700,15 +13745,24 @@ var require_fetch = __commonJS({
                   }
                 }
                 const onError = /* @__PURE__ */ __name((err) => this.onResponseError(controller, err), "onError");
+                const originalRequest = request[kOriginalRequest] ?? request;
+                const shouldPublishEventSourceMessages = channels.fetchEventSourceMessage.hasSubscribers && originalRequest.eventSource !== true && mimeType !== "failure" && mimeType.essence === "text/event-stream";
+                const eventSourceMessageTransform = shouldPublishEventSourceMessages ? createEventSourceMessageTransform(request) : null;
+                const responseBody = decoders.length || eventSourceMessageTransform ? pipeline(
+                  this.body,
+                  ...decoders,
+                  ...(eventSourceMessageTransform ? [eventSourceMessageTransform] : []),
+                  (err) => {
+                    if (err) {
+                      this.onResponseError(controller, err);
+                    }
+                  }
+                ).on("error", onError) : this.body.on("error", onError);
                 resolve({
                   status,
                   statusText,
                   headersList,
-                  body: decoders.length ? pipeline(this.body, ...decoders, (err) => {
-                    if (err) {
-                      this.onResponseError(controller, err);
-                    }
-                  }).on("error", onError) : this.body.on("error", onError)
+                  body: responseBody
                 });
               },
               onResponseData(controller, chunk) {
@@ -15944,6 +15998,7 @@ var require_eventsource = __commonJS({
         initRequest.headersList = [["accept", { name: "accept", value: "text/event-stream" }]];
         initRequest.cache = "no-store";
         initRequest.initiator = "other";
+        initRequest.eventSource = true;
         initRequest.urlList = [new URL(this.#url)];
         this.#request = makeRequest(initRequest);
         this.#connect();
diff --git a/doc/api/inspector.md b/doc/api/inspector.md
index 4cdbeb62d0e71a..f4f8f6dea3b958 100644
--- a/doc/api/inspector.md
+++ b/doc/api/inspector.md
@@ -572,6 +572,20 @@ This feature is only available with the `--experimental-network-inspection` flag
 Broadcasts the `Network.responseReceived` event to connected frontends. This event indicates that
 HTTP response is available.
 
+### `inspector.Network.eventSourceMessageReceived([params])`
+
+<!-- YAML
+added:
+  - v26.0.0
+-->
+
+* `params` {Object}
+
+This feature is only available with the `--experimental-network-inspection` flag enabled.
+
+Broadcasts the `Network.eventSourceMessageReceived` event to connected frontends.
+This event indicates that a parsed SSE message has been received from a network request.
+
 ### `inspector.Network.loadingFinished([params])`
 
 <!-- YAML
diff --git a/lib/inspector.js b/lib/inspector.js
index 1c440794f3932f..a84ce19d68b36d 100644
--- a/lib/inspector.js
+++ b/lib/inspector.js
@@ -215,6 +215,8 @@ function broadcastToFrontend(eventName, params = kEmptyObject) {
 const Network = {
   requestWillBeSent: (params) => broadcastToFrontend('Network.requestWillBeSent', params),
   responseReceived: (params) => broadcastToFrontend('Network.responseReceived', params),
+  eventSourceMessageReceived:
+    (params) => broadcastToFrontend('Network.eventSourceMessageReceived', params),
   loadingFinished: (params) => broadcastToFrontend('Network.loadingFinished', params),
   loadingFailed: (params) => broadcastToFrontend('Network.loadingFailed', params),
   dataSent: (params) => broadcastToFrontend('Network.dataSent', params),
diff --git a/lib/internal/inspector/network_undici.js b/lib/internal/inspector/network_undici.js
index a80af196587de4..a0227795f1bd2e 100644
--- a/lib/internal/inspector/network_undici.js
+++ b/lib/internal/inspector/network_undici.js
@@ -67,11 +67,14 @@ function responseHeadersArrayToDictionary(headers) {
 /**
  * When a client request starts, emit Network.requestWillBeSent event.
  * https://chromedevtools.github.io/devtools-protocol/1-3/Network/#event-requestWillBeSent
- * @param {{ request: undici.Request }} event
+ * @param {{ request: undici.Request, fetchRequest?: object }} event
  */
-function onClientRequestStart({ request }) {
+function onClientRequestStart({ request, fetchRequest }) {
   const url = `${request.origin}${request.path}`;
   request[kInspectorRequestId] = getNextRequestId();
+  if (fetchRequest != null) {
+    fetchRequest[kInspectorRequestId] = request[kInspectorRequestId];
+  }
 
   const { 0: headers, 1: charset } = requestHeadersArrayToDictionary(request.headers);
 
@@ -89,6 +92,24 @@ function onClientRequestStart({ request }) {
   });
 }
 
+/**
+ * When an SSE message is parsed, emit Network.eventSourceMessageReceived event.
+ * @param {{ request: object, eventName: string, eventId: string, data: string }} event
+ */
+function onEventSourceMessage({ request, eventName, eventId, data }) {
+  if (typeof request[kInspectorRequestId] !== 'string') {
+    return;
+  }
+
+  Network.eventSourceMessageReceived({
+    requestId: request[kInspectorRequestId],
+    timestamp: getMonotonicTime(),
+    eventName,
+    eventId: eventId ?? '',
+    data,
+  });
+}
+
 /**
  * When a client request errors, emit Network.loadingFailed event.
  * https://chromedevtools.github.io/devtools-protocol/1-3/Network/#event-loadingFailed
@@ -152,13 +173,16 @@ function onClientResponseHeaders({ request, response }) {
   }
 
   const { 0: headers, 1: charset, 2: mimeType } = responseHeadersArrayToDictionary(response.headers);
+  const type = mimeType === 'text/event-stream' ?
+    kResourceType.EventSource :
+    kResourceType.Fetch;
 
   const url = `${request.origin}${request.path}`;
   Network.responseReceived({
     requestId: request[kInspectorRequestId],
     timestamp: getMonotonicTime(),
     // TODO(legendecas): distinguish between `undici.request` and `undici.fetch`.
-    type: kResourceType.Fetch,
+    type,
     response: {
       url,
       status: response.statusCode,
@@ -241,6 +265,7 @@ module.exports = registerDiagnosticChannels([
   ['undici:request:bodyChunkSent', onClientRequestBodyChunkSent],
   ['undici:request:bodySent', onClientRequestBodySent],
   ['undici:request:bodyChunkReceived', onClientRequestBodyChunkReceived],
+  ['undici:fetch:eventsource:message', onEventSourceMessage],
   ['undici:websocket:open', onWebSocketOpen],
   ['undici:websocket:close', onWebSocketClose],
 ]);
diff --git a/src/inspector/domain_network.pdl b/src/inspector/domain_network.pdl
index fdfd9ebe1fdeb4..7bc5c009f4e465 100644
--- a/src/inspector/domain_network.pdl
+++ b/src/inspector/domain_network.pdl
@@ -170,6 +170,20 @@ experimental domain Network
       # Response data.
       Response response
 
+  # Fired when EventSource message is received.
+  event eventSourceMessageReceived
+    parameters
+      # Request identifier.
+      RequestId requestId
+      # Timestamp.
+      MonotonicTime timestamp
+      # Message type.
+      string eventName
+      # Message identifier.
+      string eventId
+      # Message content.
+      string data
+
   event loadingFailed
     parameters
       # Request identifier.
diff --git a/src/inspector/network_agent.cc b/src/inspector/network_agent.cc
index ace8ba52287186..8f80c06d871f6a 100644
--- a/src/inspector/network_agent.cc
+++ b/src/inspector/network_agent.cc
@@ -196,6 +196,8 @@ NetworkAgent::NetworkAgent(
       requests_(kDefaultMaxTotalBufferSize) {
   event_notifier_map_["requestWillBeSent"] = &NetworkAgent::requestWillBeSent;
   event_notifier_map_["responseReceived"] = &NetworkAgent::responseReceived;
+  event_notifier_map_["eventSourceMessageReceived"] =
+      &NetworkAgent::eventSourceMessageReceived;
   event_notifier_map_["loadingFailed"] = &NetworkAgent::loadingFailed;
   event_notifier_map_["loadingFinished"] = &NetworkAgent::loadingFinished;
   event_notifier_map_["dataSent"] = &NetworkAgent::dataSent;
@@ -523,6 +525,45 @@ void NetworkAgent::responseReceived(v8::Local<v8::Context> context,
   frontend_->responseReceived(request_id, timestamp, type, std::move(response));
 }
 
+void NetworkAgent::eventSourceMessageReceived(v8::Local<v8::Context> context,
+                                              v8::Local<v8::Object> params) {
+  Isolate* isolate = env_->isolate();
+  protocol::String request_id;
+  if (!ObjectGetProtocolString(context, params, "requestId").To(&request_id)) {
+    ThrowEventError(isolate, "Missing requestId in event");
+    return;
+  }
+  double timestamp;
+  if (!ObjectGetDouble(context, params, "timestamp").To(&timestamp)) {
+    ThrowEventError(isolate, "Missing timestamp in event");
+    return;
+  }
+  protocol::String event_name;
+  if (!ObjectGetProtocolString(context, params, "eventName").To(&event_name)) {
+    ThrowEventError(isolate, "Missing eventName in event");
+    return;
+  }
+  protocol::String event_id;
+  if (!ObjectGetProtocolString(context, params, "eventId").To(&event_id)) {
+    ThrowEventError(isolate, "Missing eventId in event");
+    return;
+  }
+  protocol::String data;
+  if (!ObjectGetProtocolString(context, params, "data").To(&data)) {
+    ThrowEventError(isolate, "Missing data in event");
+    return;
+  }
+
+  auto request_entry = requests_.find(request_id);
+  if (request_entry == requests_.end()) {
+    // No entry found. Ignore it.
+    return;
+  }
+
+  frontend_->eventSourceMessageReceived(
+      request_id, timestamp, event_name, event_id, data);
+}
+
 void NetworkAgent::loadingFailed(v8::Local<v8::Context> context,
                                  v8::Local<v8::Object> params) {
   Isolate* isolate = env_->isolate();
diff --git a/src/inspector/network_agent.h b/src/inspector/network_agent.h
index 2136a45baf45f6..69bfa0cbfe071d 100644
--- a/src/inspector/network_agent.h
+++ b/src/inspector/network_agent.h
@@ -60,6 +60,9 @@ class NetworkAgent : public protocol::Network::Backend {
   void responseReceived(v8::Local<v8::Context> context,
                         v8::Local<v8::Object> params);
 
+  void eventSourceMessageReceived(v8::Local<v8::Context> context,
+                                  v8::Local<v8::Object> params);
+
   void loadingFailed(v8::Local<v8::Context> context,
                      v8::Local<v8::Object> params);
 
diff --git a/test/parallel/test-inspector-emit-protocol-event-errors.js b/test/parallel/test-inspector-emit-protocol-event-errors.js
index 1a76a491c2195c..037bebcc678e18 100644
--- a/test/parallel/test-inspector-emit-protocol-event-errors.js
+++ b/test/parallel/test-inspector-emit-protocol-event-errors.js
@@ -44,6 +44,17 @@ function networkResponse(overrides = {}) {
   };
 }
 
+function eventSourceMessageReceived(overrides = {}) {
+  return {
+    requestId: 'eventsource-id',
+    timestamp: 1000,
+    eventName: 'message',
+    eventId: 'event-id-1',
+    data: 'hello world',
+    ...overrides,
+  };
+}
+
 function loadingFailed(overrides = {}) {
   return {
     requestId: 'loading-failed-id',
@@ -221,6 +232,31 @@ const NETWORK_ERROR_CASES = [
     }),
     'Invalid header value in event',
   ],
+  [
+    'eventSourceMessageReceived',
+    omit(eventSourceMessageReceived(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  [
+    'eventSourceMessageReceived',
+    omit(eventSourceMessageReceived(), 'timestamp'),
+    'Missing timestamp in event',
+  ],
+  [
+    'eventSourceMessageReceived',
+    omit(eventSourceMessageReceived(), 'eventName'),
+    'Missing eventName in event',
+  ],
+  [
+    'eventSourceMessageReceived',
+    omit(eventSourceMessageReceived(), 'eventId'),
+    'Missing eventId in event',
+  ],
+  [
+    'eventSourceMessageReceived',
+    omit(eventSourceMessageReceived(), 'data'),
+    'Missing data in event',
+  ],
 
   [
     'loadingFailed',
@@ -485,6 +521,9 @@ function startRequest(requestId) {
   await session.post('DOMStorage.enable');
 
   for (const [name, params, message] of NETWORK_ERROR_CASES) {
+    if (name === 'eventSourceMessageReceived' && params.requestId) {
+      startRequest(params.requestId);
+    }
     assertEventErrors('Network', name, params, message);
   }
 
diff --git a/test/parallel/test-inspector-emit-protocol-event.js b/test/parallel/test-inspector-emit-protocol-event.js
index 567c92e3eeba6a..655d9632bf4103 100644
--- a/test/parallel/test-inspector-emit-protocol-event.js
+++ b/test/parallel/test-inspector-emit-protocol-event.js
@@ -62,6 +62,16 @@ const EXPECTED_EVENTS = {
         }
       }
     },
+    {
+      name: 'eventSourceMessageReceived',
+      params: {
+        requestId: 'request-id-1',
+        timestamp: 1000,
+        eventName: 'message',
+        eventId: 'event-id-1',
+        data: 'hello world',
+      }
+    },
     {
       name: 'dataReceived',
       // Network.dataReceived is buffered until Network.streamResourceContent/Network.getResponseBody is invoked.
diff --git a/test/parallel/test-inspector-network-fetch-sse.js b/test/parallel/test-inspector-network-fetch-sse.js
new file mode 100644
index 00000000000000..35e2bf7cf5b2c6
--- /dev/null
+++ b/test/parallel/test-inspector-network-fetch-sse.js
@@ -0,0 +1,251 @@
+// Flags: --inspect=0 --experimental-network-inspection
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('node:assert');
+const { once } = require('node:events');
+const http = require('node:http');
+const inspector = require('node:inspector/promises');
+const { setTimeout: delay } = require('node:timers/promises');
+const zlib = require('node:zlib');
+
+const session = new inspector.Session();
+session.connect();
+
+const plainChunks = [
+  'id: alpha\r',
+  '\n',
+  'data: line 1\r',
+  '\n',
+  'data: line 2\r\n',
+  '\r\n',
+  'event: custom\r\n',
+  'data: chunked',
+  ' message\r\n',
+  '\r\n',
+  'id: beta\r\n',
+  'data: second\r\n',
+  '\r\n',
+  'data: inherited\r\n\r\n',
+];
+
+const plainExpectedMessages = [
+  {
+    eventName: 'message',
+    eventId: 'alpha',
+    data: 'line 1\nline 2',
+  },
+  {
+    eventName: 'custom',
+    eventId: 'alpha',
+    data: 'chunked message',
+  },
+  {
+    eventName: 'message',
+    eventId: 'beta',
+    data: 'second',
+  },
+  {
+    eventName: 'message',
+    eventId: 'beta',
+    data: 'inherited',
+  },
+];
+
+const compressedBody = [
+  'id: zipped',
+  'data: compressed line 1',
+  'data: compressed line 2',
+  '',
+  'data: inherited zipped',
+  '',
+  '',
+].join('\n');
+
+const compressedExpectedMessages = [
+  {
+    eventName: 'message',
+    eventId: 'zipped',
+    data: 'compressed line 1\ncompressed line 2',
+  },
+  {
+    eventName: 'message',
+    eventId: 'zipped',
+    data: 'inherited zipped',
+  },
+];
+
+async function writeChunks(res, chunks) {
+  for (const chunk of chunks) {
+    res.write(chunk);
+    await delay(5);
+  }
+  res.end();
+}
+
+async function writeBufferInChunks(res, buffer) {
+  const midpoint = Math.max(1, Math.floor(buffer.length / 2));
+  res.write(buffer.subarray(0, midpoint));
+  await delay(5);
+  res.end(buffer.subarray(midpoint));
+}
+
+const server = http.createServer((req, res) => {
+  switch (req.url) {
+    case '/plain':
+      res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+      res.writeHead(200);
+      void writeChunks(res, plainChunks);
+      break;
+    case '/invalid-type':
+      res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+      res.writeHead(200);
+      void writeChunks(res, plainChunks);
+      break;
+    case '/gzip':
+      res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+      res.setHeader('Content-Encoding', 'gzip');
+      res.writeHead(200);
+      void writeBufferInChunks(res, zlib.gzipSync(compressedBody));
+      break;
+    case '/deflate':
+      res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+      res.setHeader('Content-Encoding', 'deflate');
+      res.writeHead(200);
+      void writeBufferInChunks(res, zlib.deflateSync(compressedBody));
+      break;
+    default:
+      assert.fail(`Unexpected path: ${req.url}`);
+  }
+});
+
+function observeSseRequest(url, expectedMessages) {
+  return new Promise((resolve, reject) => {
+    let requestId;
+    const received = [];
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error(`Timed out waiting for SSE messages for ${url}: received ${received.length}`));
+    }, 5000);
+
+    function cleanup() {
+      clearTimeout(timer);
+      session.off('Network.responseReceived', onResponseReceived);
+      session.off('Network.eventSourceMessageReceived', onEventSourceMessageReceived);
+    }
+
+    function maybeResolve() {
+      if (requestId === undefined || received.length !== expectedMessages.length) {
+        return;
+      }
+
+      try {
+        for (const message of received) {
+          assert.strictEqual(message.requestId, requestId);
+          assert.strictEqual(typeof message.timestamp, 'number');
+        }
+        assert.deepStrictEqual(
+          received.map(({ eventName, eventId, data }) => ({ eventName, eventId, data })),
+          expectedMessages,
+        );
+        cleanup();
+        resolve(requestId);
+      } catch (error) {
+        cleanup();
+        reject(error);
+      }
+    }
+
+    function onResponseReceived({ params }) {
+      if (params.response.url !== url) {
+        return;
+      }
+
+      try {
+        assert.strictEqual(params.type, 'EventSource');
+        assert.strictEqual(params.response.mimeType, 'text/event-stream');
+        assert.strictEqual(params.response.charset, 'utf-8');
+        requestId = params.requestId;
+        maybeResolve();
+      } catch (error) {
+        cleanup();
+        reject(error);
+      }
+    }
+
+    function onEventSourceMessageReceived({ params }) {
+      if (requestId !== undefined && params.requestId !== requestId) {
+        return;
+      }
+      received.push(params);
+      maybeResolve();
+    }
+
+    session.on('Network.responseReceived', onResponseReceived);
+    session.on('Network.eventSourceMessageReceived', onEventSourceMessageReceived);
+  });
+}
+
+async function expectNoSseMessages(url, fetchImpl) {
+  const messages = [];
+  const onEventSourceMessageReceived = ({ params }) => {
+    messages.push(params);
+  };
+  session.on('Network.eventSourceMessageReceived', onEventSourceMessageReceived);
+
+  try {
+    const responseReceivedPromise = once(session, 'Network.responseReceived')
+      .then(([{ params }]) => {
+        assert.strictEqual(params.response.url, url);
+        assert.strictEqual(params.type, 'Fetch');
+        assert.strictEqual(params.response.mimeType, 'text/plain');
+        return params.requestId;
+      });
+
+    const response = await fetchImpl(url);
+    await response.text();
+    const requestId = await responseReceivedPromise;
+    await delay(50);
+
+    assert.deepStrictEqual(
+      messages.filter((message) => message.requestId === requestId),
+      [],
+    );
+  } finally {
+    session.off('Network.eventSourceMessageReceived', onEventSourceMessageReceived);
+  }
+}
+
+async function expectSseMessages(url, fetchImpl, expectedMessages) {
+  const observer = observeSseRequest(url, expectedMessages);
+  const response = await fetchImpl(url);
+  assert.strictEqual(response.status, 200);
+  await response.text();
+  await observer;
+}
+
+(async () => {
+  server.listen(0);
+  await once(server, 'listening');
+
+  const baseUrl = `http://127.0.0.1:${server.address().port}`;
+
+  try {
+    await session.post('Network.enable');
+
+    await expectSseMessages(`${baseUrl}/plain`, fetch, plainExpectedMessages);
+    await expectSseMessages(`${baseUrl}/gzip`, fetch, compressedExpectedMessages);
+    await expectSseMessages(`${baseUrl}/deflate`, fetch, compressedExpectedMessages);
+    await expectNoSseMessages(`${baseUrl}/invalid-type`, fetch);
+
+    await session.post('Network.disable');
+  } catch (error) {
+    assert.fail(error);
+  } finally {
+    session.disconnect();
+    await new Promise((resolve) => server.close(resolve));
+    await inspector.close();
+  }
+})().then(common.mustCall());
diff --git a/test/parallel/test-inspector-network-fetch.js b/test/parallel/test-inspector-network-fetch.js
index 790446c84bfb66..fe19ebf80938a5 100644
--- a/test/parallel/test-inspector-network-fetch.js
+++ b/test/parallel/test-inspector-network-fetch.js
@@ -1,4 +1,5 @@
-// Flags: --inspect=0 --experimental-network-inspection --expose-internals
+// Flags: --inspect=0 --experimental-network-inspection
+// Env: NODE_TLS_REJECT_UNAUTHORIZED=0
 'use strict';
 const common = require('../common');
 
@@ -12,14 +13,6 @@ const http = require('node:http');
 const https = require('node:https');
 const inspector = require('node:inspector/promises');
 
-// Disable certificate validation for the global fetch.
-const undici = require('internal/deps/undici/undici');
-undici.setGlobalDispatcher(new undici.EnvHttpProxyAgent({
-  connect: {
-    rejectUnauthorized: false,
-  },
-}));
-
 const session = new inspector.Session();
 session.connect();
 
@@ -32,12 +25,15 @@ const requestHeaders = [
   ['x-header1', 'value2'],
 ];
 
-const setResponseHeaders = (res) => {
+const kTextResponse = 'hello world\n';
+const kEventStreamResponse = 'data: hello world\n\n';
+
+const setResponseHeaders = (res, contentType = 'text/plain; charset=utf-8') => {
   res.setHeader('server', 'node');
   res.setHeader('etag', 12345);
   res.setHeader('Set-Cookie', ['key1=value1', 'key2=value2']);
   res.setHeader('x-header2', ['value1', 'value2']);
-  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+  res.setHeader('Content-Type', contentType);
 };
 
 const handleRequest = common.mustCallAtLeast((req, res) => {
@@ -52,7 +48,20 @@ const handleRequest = common.mustCallAtLeast((req, res) => {
       req.on('end', common.mustCall(() => {
         assert.strictEqual(Buffer.concat(chunks).toString(), 'foobar');
         res.writeHead(200);
-        res.end('hello world\n');
+        res.end(kTextResponse);
+      }));
+      break;
+    }
+    case '/event-stream': {
+      setResponseHeaders(res, 'text/event-stream; charset=utf-8');
+      const chunks = [];
+      req.on('data', (chunk) => {
+        chunks.push(chunk);
+      });
+      req.on('end', common.mustCall(() => {
+        assert.strictEqual(Buffer.concat(chunks).toString(), 'foobar');
+        res.writeHead(200);
+        res.end(kEventStreamResponse);
       }));
       break;
     }
@@ -108,7 +117,7 @@ function verifyResponseReceived({ method, params }, expect) {
 
   assert.ok(params.requestId.startsWith('node-network-event-'));
   assert.strictEqual(typeof params.timestamp, 'number');
-  assert.strictEqual(params.type, 'Fetch');
+  assert.strictEqual(params.type, expect.type);
   assert.strictEqual(params.response.status, 200);
   assert.strictEqual(params.response.statusText, 'OK');
   assert.strictEqual(params.response.url, expect.url);
@@ -117,8 +126,8 @@ function verifyResponseReceived({ method, params }, expect) {
   assert.strictEqual(params.response.headers.etag, '12345');
   assert.strictEqual(params.response.headers['Set-Cookie'], 'key1=value1\nkey2=value2');
   assert.strictEqual(params.response.headers['x-header2'], 'value1, value2');
-  assert.strictEqual(params.response.mimeType, 'text/plain');
-  assert.strictEqual(params.response.charset, 'utf-8');
+  assert.strictEqual(params.response.mimeType, expect.mimeType);
+  assert.strictEqual(params.response.charset, expect.charset);
 
   return params;
 }
@@ -140,12 +149,17 @@ function verifyLoadingFailed({ method, params }) {
   assert.strictEqual(typeof params.errorText, 'string');
 }
 
-async function testRequest(url) {
+async function testRequest(url, expect) {
   const requestWillBeSentFuture = once(session, 'Network.requestWillBeSent')
     .then(([event]) => verifyRequestWillBeSent(event, { url, method: 'POST' }));
 
   const responseReceivedFuture = once(session, 'Network.responseReceived')
-    .then(([event]) => verifyResponseReceived(event, { url }));
+    .then(([event]) => verifyResponseReceived(event, {
+      url,
+      type: expect.type,
+      mimeType: expect.mimeType,
+      charset: expect.charset,
+    }));
 
   const loadingFinishedFuture = once(session, 'Network.loadingFinished')
     .then(([event]) => verifyLoadingFinished(event));
@@ -170,7 +184,7 @@ async function testRequest(url) {
     requestId: responseReceived.requestId,
   });
   assert.strictEqual(responseBody.base64Encoded, false);
-  assert.strictEqual(responseBody.body, 'hello world\n');
+  assert.strictEqual(responseBody.body, expect.responseBody);
 }
 
 async function testRequestError(url) {
@@ -192,10 +206,28 @@ async function testRequestError(url) {
 
 const testNetworkInspection = async () => {
   // HTTP
-  await testRequest(`http://127.0.0.1:${httpServer.address().port}/hello-world`);
+  await testRequest(`http://127.0.0.1:${httpServer.address().port}/hello-world`, {
+    type: 'Fetch',
+    mimeType: 'text/plain',
+    charset: 'utf-8',
+    responseBody: kTextResponse,
+  });
+  session.removeAllListeners();
+  // HTTP SSE
+  await testRequest(`http://127.0.0.1:${httpServer.address().port}/event-stream`, {
+    type: 'EventSource',
+    mimeType: 'text/event-stream',
+    charset: 'utf-8',
+    responseBody: kEventStreamResponse,
+  });
   session.removeAllListeners();
   // HTTPS
-  await testRequest(`https://127.0.0.1:${httpsServer.address().port}/hello-world`);
+  await testRequest(`https://127.0.0.1:${httpsServer.address().port}/hello-world`, {
+    type: 'Fetch',
+    mimeType: 'text/plain',
+    charset: 'utf-8',
+    responseBody: kTextResponse,
+  });
   session.removeAllListeners();
   // HTTP with invalid host
   await testRequestError(`http://${addresses.INVALID_HOST}/`);