chrome-devtools-frontend 1.0.1473514 → 1.0.1510180

package/front_end/models/ai_assistance/data_formatters/PerformanceInsightFormatter.ts

@@ -2,27 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as i18n from '../../../core/i18n/i18n.js';
-import type * as TimelineUtils from '../../../panels/timeline/utils/utils.js';
 import * as Trace from '../../trace/trace.js';
+import type {ConversationSuggestion} from '../agents/AiAgent.js';
 
 import {
   NetworkRequestFormatter,
 } from './NetworkRequestFormatter.js';
-
-function formatMilli(x: number|undefined): string {
-  if (x === undefined) {
-    return '';
-  }
-  return i18n.TimeUtilities.preciseMillisToString(x, 2);
-}
-
-function formatMicro(x: number|undefined): string {
-  if (x === undefined) {
-    return '';
-  }
-  return formatMilli(Trace.Helpers.Timing.microToMilli(x as Trace.Types.Timing.Micro));
-}
+import type {UnitFormatters} from './Types.js';
 
 /**
  * For a given frame ID and navigation ID, returns the LCP Event and the LCP Request, if the resource was an image.
@@ -56,9 +42,28 @@ function getLCPData(parsedTrace: Trace.Handlers.Types.ParsedTrace, frameId: stri
 export class PerformanceInsightFormatter {
   #insight: Trace.Insights.Types.InsightModel;
   #parsedTrace: Trace.Handlers.Types.ParsedTrace;
-  constructor(activeInsight: TimelineUtils.InsightAIContext.ActiveInsight) {
-    this.#insight = activeInsight.insight;
-    this.#parsedTrace = activeInsight.parsedTrace;
+  #unitFormatters: UnitFormatters;
+
+  constructor(
+      formatters: UnitFormatters, parsedTrace: Trace.Handlers.Types.ParsedTrace,
+      insight: Trace.Insights.Types.InsightModel) {
+    this.#insight = insight;
+    this.#parsedTrace = parsedTrace;
+    this.#unitFormatters = formatters;
+  }
+
+  #formatMilli(x?: number): string {
+    if (x === undefined) {
+      return '';
+    }
+    return this.#unitFormatters.millis(x);
+  }
+
+  #formatMicro(x?: number): string {
+    if (x === undefined) {
+      return '';
+    }
+    return this.#formatMilli(Trace.Helpers.Timing.microToMilli(x as Trace.Types.Timing.Micro));
   }
 
   /**
@@ -77,38 +82,347 @@ export class PerformanceInsightFormatter {
     if (!data) {
       return '';
     }
-    const {metricScore, lcpRequest} = data;
 
+    const {metricScore, lcpRequest, lcpEvent} = data;
+    const theLcpElement =
+        lcpEvent.args.data?.nodeName ? `The LCP element (${lcpEvent.args.data.nodeName})` : 'The LCP element';
     const parts: string[] = [
-      `The Largest Contentful Paint (LCP) time for this navigation was ${formatMicro(metricScore.timing)}.`,
+      `The Largest Contentful Paint (LCP) time for this navigation was ${this.#formatMicro(metricScore.timing)}.`,
     ];
+
     if (lcpRequest) {
-      parts.push(`The LCP resource was fetched from \`${lcpRequest.args.data.url}\`.`);
+      parts.push(`${theLcpElement} is an image fetched from \`${lcpRequest.args.data.url}\`.`);
+      const request = TraceEventFormatter.networkRequests(
+          this.#unitFormatters, [lcpRequest], this.#parsedTrace,
+          {verbose: true, customTitle: 'LCP resource network request'});
+      parts.push(request);
     } else {
-      parts.push('The LCP is text based and was not fetched from the network.');
+      parts.push(`${theLcpElement} is text and was not fetched from the network.`);
     }
 
     return parts.join('\n');
   }
 
-  formatInsight(): string {
+  insightIsSupported(): boolean {
+    return this.#description().length > 0;
+  }
+
+  getSuggestions(): [ConversationSuggestion, ...ConversationSuggestion[]] {
+    switch (this.#insight.insightKey) {
+      case 'CLSCulprits':
+        return [
+          {title: 'Help me optimize my CLS score'},
+          {title: 'How can I prevent layout shifts on this page?'},
+        ];
+      case 'DocumentLatency':
+        return [
+          {title: 'How do I decrease the initial loading time of my page?'},
+          {title: 'Did anything slow down the request for this document?'},
+        ];
+      case 'DOMSize':
+        return [{title: 'How can I reduce the size of my DOM?'}];
+      case 'DuplicatedJavaScript':
+        return [
+          {title: 'How do I deduplicate the identified scripts in my bundle?'},
+          {title: 'Which duplicated JavaScript modules are the most problematic?'}
+        ];
+      case 'FontDisplay':
+        return [
+          {title: 'How can I update my CSS to avoid layout shifts caused by incorrect `font-display` properties?'}
+        ];
+      case 'ForcedReflow':
+        return [
+          {title: 'How can I avoid forced reflows and layout thrashing?'},
+          {title: 'What is forced reflow and why is it problematic?'}
+        ];
+      case 'ImageDelivery':
+        return [
+          {title: 'What should I do to improve and optimize the time taken to fetch and display images on the page?'},
+          {title: 'Are all images on my site optimized?'},
+        ];
+      case 'INPBreakdown':
+        return [
+          {title: 'Suggest fixes for my longest interaction'}, {title: 'Why is a large INP score problematic?'},
+          {title: 'What\'s the biggest contributor to my longest interaction?'}
+        ];
+      case 'LCPDiscovery':
+        return [
+          {title: 'Suggest fixes to reduce my LCP'}, {title: 'What can I do to reduce my LCP discovery time?'},
+          {title: 'Why is LCP discovery time important?'}
+        ];
+      case 'LCPBreakdown':
+        return [
+          {title: 'Help me optimize my LCP score'}, {title: 'Which LCP phase was most problematic?'},
+          {title: 'What can I do to reduce the LCP time for this page load?'}
+        ];
+      case 'NetworkDependencyTree':
+        return [{title: 'How do I optimize my network dependency tree?'}];
+      case 'RenderBlocking':
+        return [
+          {title: 'Show me the most impactful render blocking requests that I should focus on'},
+          {title: 'How can I reduce the number of render blocking requests?'}
+        ];
+      case 'SlowCSSSelector':
+        return [{title: 'How can I optimize my CSS to increase the performance of CSS selectors?'}];
+      case 'ThirdParties':
+        return [{title: 'Which third parties are having the largest impact on my page performance?'}];
+      case 'Cache':
+        return [{title: 'What caching strategies can I apply to improve my page performance?'}];
+      case 'Viewport':
+        return [{title: 'How do I make sure my page is optimized for mobile viewing?'}];
+      case 'ModernHTTP':
+        return [
+          {title: 'Is my site using the best HTTP practices?'},
+          {title: 'Which resources are not using a modern HTTP protocol?'},
+        ];
+      case 'LegacyJavaScript':
+        return [
+          {title: 'Is my site polyfilling modern JavaScript features?'},
+          {title: 'How can I reduce the amount of legacy JavaScript on my page?'},
+        ];
+      default:
+        throw new Error('Unknown insight key');
+    }
+  }
+
+  /**
+   * Create an AI prompt string out of the Forced Reflow Insight model to use with Ask AI.
+   * Note: This function accesses the UIStrings within ForcedReflow model to help build the
+   * AI prompt, but does not (and should not) call i18nString to localize these strings. They
+   * should all be sent in English (at least for now).
+   * @param insight The ForcedReflow Insight Model to query.
+   * @returns a string formatted for sending to Ask AI.
+   */
+  formatForcedReflowInsight(insight: Trace.Insights.Models.ForcedReflow.ForcedReflowInsightModel): string {
+    let output = Trace.Insights.Models.ForcedReflow.UIStrings.description + '\n\n';
+
+    if (insight.topLevelFunctionCallData || insight.aggregatedBottomUpData.length > 0) {
+      output += 'The forced reflow checks revealed one or more problems.\n\n';
+    } else {
+      output += 'The forced reflow checks revealed no problems.';
+      return output;
+    }
+
+    function callFrameToString(frame: Trace.Types.Events.CallFrame|null): string {
+      if (frame === null) {
+        return Trace.Insights.Models.ForcedReflow.UIStrings.unattributed;
+      }
+
+      let result = `${frame.functionName || Trace.Insights.Models.ForcedReflow.UIStrings.anonymous}`;
+      if (frame.url) {
+        result += ` @ ${frame.url}:${frame.lineNumber}:${frame.columnNumber}`;
+      } else {
+        result += ' @ unknown location';
+      }
+      return result;
+    }
+
+    if (insight.topLevelFunctionCallData) {
+      output += 'The following is the top function call that caused forced reflow(s):\n\n';
+      output += ' - ' + callFrameToString(insight.topLevelFunctionCallData.topLevelFunctionCall);
+      output += `\n\n${Trace.Insights.Models.ForcedReflow.UIStrings.totalReflowTime}: ${
+          this.#formatMicro(insight.topLevelFunctionCallData.totalReflowTime)}\n`;
+    } else {
+      output += 'No top-level functions causing forced reflows were identified.\n';
+    }
+
+    if (insight.aggregatedBottomUpData.length > 0) {
+      output += '\n' + Trace.Insights.Models.ForcedReflow.UIStrings.relatedStackTrace + ' (including total time):\n';
+      for (const data of insight.aggregatedBottomUpData) {
+        output += `\n - ${this.#formatMicro(data.totalTime)} in ${callFrameToString(data.bottomUpData)}`;
+      }
+    } else {
+      output += '\nNo aggregated bottom-up causes of forced reflows were identified.';
+    }
+
+    return output;
+  }
+
+  /**
+   * Create an AI prompt string out of the NetworkDependencyTree Insight model to use with Ask AI.
+   * Note: This function accesses the UIStrings within NetworkDependencyTree to help build the
+   * AI prompt, but does not (and should not) call i18nString to localize these strings. They
+   * should all be sent in English (at least for now).
+   * @param insight The Network Dependency Tree Insight Model to query.
+   * @returns a string formatted for sending to Ask AI.
+   */
+  formatNetworkDependencyTreeInsight(
+      insight: Trace.Insights.Models.NetworkDependencyTree.NetworkDependencyTreeInsightModel): string {
+    let output = insight.fail ?
+        'The network dependency tree checks found one or more problems.\n\n' :
+        'The network dependency tree checks revealed no problems, but optimization suggestions may be available.\n\n';
+
+    const rootNodes = insight.rootNodes;
+    if (rootNodes.length > 0) {
+      output += `Max critical path latency is ${this.#formatMicro(insight.maxTime)}\n\n`;
+      output += 'The following is the critical request chain:\n';
+
+      function formatNode(
+          this: PerformanceInsightFormatter, node: Trace.Insights.Models.NetworkDependencyTree.CriticalRequestNode,
+          indent: string): string {
+        const url = node.request.args.data.url;
+        const time = this.#formatMicro(node.timeFromInitialRequest);
+        const isLongest = node.isLongest ? ' (longest chain)' : '';
+        let nodeString = `${indent}- ${url} (${time})${isLongest}\n`;
+        for (const child of node.children) {
+          nodeString += formatNode.call(this, child, indent + '  ');
+        }
+        return nodeString;
+      }
+
+      for (const rootNode of rootNodes) {
+        output += formatNode.call(this, rootNode, '');
+      }
+      output += '\n';
+    } else {
+      output += `${Trace.Insights.Models.NetworkDependencyTree.UIStrings.noNetworkDependencyTree}.\n\n`;
+    }
+
+    if (insight.preconnectedOrigins?.length > 0) {
+      output += `${Trace.Insights.Models.NetworkDependencyTree.UIStrings.preconnectOriginsTableTitle}:\n`;
+      output += `${Trace.Insights.Models.NetworkDependencyTree.UIStrings.preconnectOriginsTableDescription}\n`;
+      for (const origin of insight.preconnectedOrigins) {
+        const headerText = 'headerText' in origin ? `'${origin.headerText}'` : ``;
+        output += `
+  - ${origin.url}
+    - ${Trace.Insights.Models.NetworkDependencyTree.UIStrings.columnSource}: '${origin.source}'`;
+        if (headerText) {
+          output += `\n   - Header: ${headerText}`;
+        }
+        if (origin.unused) {
+          output += `\n   - Warning: ${Trace.Insights.Models.NetworkDependencyTree.UIStrings.unusedWarning}`;
+        }
+        if (origin.crossorigin) {
+          output += `\n   - Warning: ${Trace.Insights.Models.NetworkDependencyTree.UIStrings.crossoriginWarning}`;
+        }
+      }
+      if (insight.preconnectedOrigins.length >
+          Trace.Insights.Models.NetworkDependencyTree.TOO_MANY_PRECONNECTS_THRESHOLD) {
+        output +=
+            `\n\n**Warning**: ${Trace.Insights.Models.NetworkDependencyTree.UIStrings.tooManyPreconnectLinksWarning}`;
+      }
+    } else {
+      output += `${Trace.Insights.Models.NetworkDependencyTree.UIStrings.noPreconnectOrigins}.`;
+    }
+
+    if (insight.preconnectCandidates.length > 0 &&
+        insight.preconnectedOrigins.length <
+            Trace.Insights.Models.NetworkDependencyTree.TOO_MANY_PRECONNECTS_THRESHOLD) {
+      output += `\n\n${Trace.Insights.Models.NetworkDependencyTree.UIStrings.estSavingTableTitle}:\n${
+          Trace.Insights.Models.NetworkDependencyTree.UIStrings.estSavingTableDescription}\n`;
+      for (const candidate of insight.preconnectCandidates) {
+        output += `\nAdding [preconnect] to origin '${candidate.origin}' would save ${
+            this.#formatMilli(candidate.wastedMs)}.`;
+      }
+    }
+
+    return output;
+  }
+
+  /**
+   * Create an AI prompt string out of the ThirdParties Insight model to use with Ask AI.
+   * Note: This function accesses the UIStrings within ThirdParties to help build the
+   * AI prompt, but does not (and should not) call i18nString to localize these strings. They
+   * should all be sent in English (at least for now).
+   * @param insight The Third Parties Insight Model to query.
+   * @returns a string formatted for sending to Ask AI.
+   */
+  formatThirdPartiesInsight(insight: Trace.Insights.Models.ThirdParties.ThirdPartiesInsightModel): string {
+    let output = '';
+
+    const entitySummaries = insight.entitySummaries ?? [];
+    const firstPartyEntity = insight.firstPartyEntity;
+
+    const thirdPartyTransferSizeEntries =
+        entitySummaries.filter(s => s.entity !== firstPartyEntity).toSorted((a, b) => b.transferSize - a.transferSize);
+    const thirdPartyMainThreadTimeEntries = entitySummaries.filter(s => s.entity !== firstPartyEntity)
+                                                .toSorted((a, b) => b.mainThreadTime - a.mainThreadTime);
+
+    if (!thirdPartyTransferSizeEntries.length && !thirdPartyMainThreadTimeEntries.length) {
+      return `No 3rd party scripts were found on this page.`;
+    }
+
+    if (thirdPartyTransferSizeEntries.length) {
+      output += `The following list contains the largest transfer sizes by a 3rd party script:\n\n`;
+      for (const entry of thirdPartyTransferSizeEntries) {
+        if (entry.transferSize > 0) {
+          output += `- ${entry.entity.name}: ${this.#unitFormatters.bytes(entry.transferSize)}\n`;
+        }
+      }
+      output += '\n';
+    }
+
+    if (thirdPartyMainThreadTimeEntries.length) {
+      output += `The following list contains the largest amount spent by a 3rd party script on the main thread:\n\n`;
+      for (const entry of thirdPartyMainThreadTimeEntries) {
+        if (entry.mainThreadTime > 0) {
+          output += `- ${entry.entity.name}: ${this.#formatMilli(entry.mainThreadTime)}\n`;
+        }
+      }
+      output += '\n';
+    }
+
+    output += Trace.Insights.Models.ThirdParties.UIStrings.description;
+    return output;
+  }
+
+  /**
+   * Formats and outputs the insight's data.
+   * Pass `{headingLevel: X}` to determine what heading level to use for the
+   * titles in the markdown output. The default is 2 (##).
+   */
+  formatInsight(opts: {headingLevel: number} = {headingLevel: 2}): string {
+    const header = '#'.repeat(opts.headingLevel);
+
     const {title} = this.#insight;
-    return `## Insight Title: ${title}
+    return `${header} Insight Title: ${title}
 
-## Insight Summary:
+${header} Insight Summary:
 ${this.#description()}
 
-## Detailed analysis:
+${header} Detailed analysis:
 ${this.#details()}
 
-## External resources:
+${header} Estimated savings: ${this.estimatedSavings() || 'none'}
+
+${header} External resources:
 ${this.#links()}`;
   }
 
   #details(): string {
-    if (Trace.Insights.Models.LCPPhases.isLCPPhases(this.#insight)) {
-      const {phases, lcpMs} = this.#insight;
-      if (!lcpMs) {
+    if (Trace.Insights.Models.ImageDelivery.isImageDelivery(this.#insight)) {
+      const optimizableImages = this.#insight.optimizableImages;
+      if (optimizableImages.length === 0) {
+        return 'There are no unoptimized images on this page.';
+      }
+
+      const imageDetails = optimizableImages
+                               .map(image => {
+                                 // List potential optimizations for the image
+                                 const optimizations =
+                                     image.optimizations
+                                         .map(optimization => {
+                                           const message =
+                                               Trace.Insights.Models.ImageDelivery.getOptimizationMessage(optimization);
+                                           const byteSavings = this.#unitFormatters.bytes(optimization.byteSavings);
+                                           return `${message} (Est ${byteSavings})`;
+                                         })
+                                         .join('\n');
+
+                                 return `### ${image.request.args.data.url}
+- Potential savings: ${this.#unitFormatters.bytes(image.byteSavings)}
+- Optimizations:\n${optimizations}`;
+                               })
+                               .join('\n\n');
+
+      return `Total potential savings: ${this.#unitFormatters.bytes(this.#insight.wastedBytes)}
+
+The following images could be optimized:\n\n${imageDetails}`;
+    }
+
+    if (Trace.Insights.Models.LCPBreakdown.isLCPBreakdown(this.#insight)) {
+      const {subparts, lcpMs} = this.#insight;
+      if (!lcpMs || !subparts) {
         return '';
       }
 
@@ -116,24 +430,14 @@ ${this.#links()}`;
       // Image based has TTFB, Load delay, Load time and Render delay
       // Note that we expect every trace + LCP to have TTFB + Render delay, but
       // very old traces are missing the data, so we have to code defensively
-      // in case the phases are not present.
+      // in case the subparts are not present.
       const phaseBulletPoints: Array<{name: string, value: string, percentage: string}> = [];
-      if (phases?.ttfb) {
-        const percentage = (phases.ttfb / lcpMs * 100).toFixed(1);
-        phaseBulletPoints.push({name: 'Time to first byte', value: formatMilli(phases.ttfb), percentage});
-      }
-      if (phases?.loadDelay) {
-        const percentage = (phases.loadDelay / lcpMs * 100).toFixed(1);
-        phaseBulletPoints.push({name: 'Resource load delay', value: formatMilli(phases.loadDelay), percentage});
-      }
-      if (phases?.loadTime) {
-        const percentage = (phases.loadTime / lcpMs * 100).toFixed(1);
-        phaseBulletPoints.push({name: 'Resource load duration', value: formatMilli(phases.loadTime), percentage});
-      }
-      if (phases?.renderDelay) {
-        const percentage = (phases.renderDelay / lcpMs * 100).toFixed(1);
-        phaseBulletPoints.push({name: 'Element render delay', value: formatMilli(phases.renderDelay), percentage});
-      }
+
+      Object.values(subparts).forEach((subpart: Trace.Insights.Models.LCPBreakdown.Subpart) => {
+        const phaseMilli = Trace.Helpers.Timing.microToMilli(subpart.range);
+        const percentage = (phaseMilli / lcpMs * 100).toFixed(1);
+        phaseBulletPoints.push({name: subpart.label, value: this.#formatMilli(phaseMilli), percentage});
+      });
 
       return `${this.#lcpMetricSharedContext()}
 
@@ -171,8 +475,8 @@ ${checklistBulletPoints.map(point => `- ${point.name}: ${point.passed ? 'PASSED'
     }
 
     if (Trace.Insights.Models.RenderBlocking.isRenderBlocking(this.#insight)) {
-      const requestSummary = this.#insight.renderBlockingRequests.map(
-          r => TraceEventFormatter.networkRequest(r, this.#parsedTrace, {verbose: false}));
+      const requestSummary = TraceEventFormatter.networkRequests(
+          this.#unitFormatters, this.#insight.renderBlockingRequests, this.#parsedTrace);
 
       if (requestSummary.length === 0) {
         return 'There are no network requests that are render blocking.';
@@ -180,7 +484,7 @@ ${checklistBulletPoints.map(point => `- ${point.name}: ${point.passed ? 'PASSED'
 
       return `Here is a list of the network requests that were render blocking on this page and their duration:
 
-${requestSummary.join('\n\n')}`;
+${requestSummary}`;
     }
 
     if (Trace.Insights.Models.DocumentLatency.isDocumentLatency(this.#insight)) {
@@ -207,7 +511,7 @@ ${requestSummary.join('\n\n')}`;
 
       return `${this.#lcpMetricSharedContext()}
 
-${TraceEventFormatter.networkRequest(documentRequest, this.#parsedTrace, {
+${TraceEventFormatter.networkRequests(this.#unitFormatters, [documentRequest], this.#parsedTrace, {
         verbose: true,
         customTitle: 'Document network request'
       })}
@@ -216,7 +520,7 @@ The result of the checks for this insight are:
 ${checklistBulletPoints.map(point => `- ${point.name}: ${point.passed ? 'PASSED' : 'FAILED'}`).join('\n')}`;
     }
 
-    if (Trace.Insights.Models.InteractionToNextPaint.isINP(this.#insight)) {
+    if (Trace.Insights.Models.INPBreakdown.isINPBreakdown(this.#insight)) {
       const event = this.#insight.longestInteractionEvent;
       if (!event) {
         return '';
@@ -224,11 +528,11 @@ ${checklistBulletPoints.map(point => `- ${point.name}: ${point.passed ? 'PASSED'
 
       const inpInfoForEvent =
           `The longest interaction on the page was a \`${event.type}\` which had a total duration of \`${
-              formatMicro(event.dur)}\`. The timings of each of the three phases were:
+              this.#formatMicro(event.dur)}\`. The timings of each of the three phases were:
 
-1. Input delay: ${formatMicro(event.inputDelay)}
-2. Processing duration: ${formatMicro(event.mainThreadHandling)}
-3. Presentation delay: ${formatMicro(event.presentationDelay)}.`;
+1. Input delay: ${this.#formatMicro(event.inputDelay)}
+2. Processing duration: ${this.#formatMicro(event.mainThreadHandling)}
+3. Presentation delay: ${this.#formatMicro(event.presentationDelay)}.`;
 
       return inpInfoForEvent;
     }
@@ -247,21 +551,99 @@ ${checklistBulletPoints.map(point => `- ${point.name}: ${point.passed ? 'PASSED'
       } as const;
 
       const shiftsFormatted = worstCluster.events.map((layoutShift, index) => {
-        return TraceEventFormatter.layoutShift(layoutShift, index, this.#parsedTrace, shifts.get(layoutShift));
+        return TraceEventFormatter.layoutShift(
+            this.#unitFormatters, layoutShift, index, this.#parsedTrace, shifts.get(layoutShift));
       });
 
       return `The worst layout shift cluster was the cluster that started at ${
-          formatMicro(clusterTimes.start)} and ended at ${formatMicro(clusterTimes.end)}, with a duration of ${
-          formatMicro(worstCluster.dur)}.
+          this.#formatMicro(clusterTimes.start)} and ended at ${
+          this.#formatMicro(clusterTimes.end)}, with a duration of ${this.#formatMicro(worstCluster.dur)}.
 The score for this cluster is ${worstCluster.clusterCumulativeScore.toFixed(4)}.
 
 Layout shifts in this cluster:
 ${shiftsFormatted.join('\n')}`;
     }
 
+    if (Trace.Insights.Models.ModernHTTP.isModernHTTP(this.#insight)) {
+      const requestSummary = (this.#insight.http1Requests.length === 1) ?
+          TraceEventFormatter.networkRequests(
+              this.#unitFormatters, this.#insight.http1Requests, this.#parsedTrace, {verbose: true}) :
+          TraceEventFormatter.networkRequests(this.#unitFormatters, this.#insight.http1Requests, this.#parsedTrace);
+
+      if (requestSummary.length === 0) {
+        return 'There are no requests that were served over a legacy HTTP protocol.';
+      }
+
+      return `Here is a list of the network requests that were served over a legacy HTTP protocol:
+${requestSummary}`;
+    }
+
+    if (Trace.Insights.Models.DuplicatedJavaScript.isDuplicatedJavaScript(this.#insight)) {
+      const totalWastedBytes = this.#insight.wastedBytes;
+      const duplicatedScriptsByModule = this.#insight.duplicationGroupedByNodeModules;
+
+      if (duplicatedScriptsByModule.size === 0) {
+        return 'There is no duplicated JavaScript in the page modules';
+      }
+
+      const filesFormatted =
+          Array.from(duplicatedScriptsByModule)
+              .map(
+                  ([module, duplication]) =>
+                      `- Source: ${module} - Duplicated bytes: ${duplication.estimatedDuplicateBytes} bytes`)
+              .join('\n');
+
+      return `Total wasted bytes: ${totalWastedBytes} bytes.
+
+Duplication grouped by Node modules: ${filesFormatted}`;
+    }
+
+    if (Trace.Insights.Models.LegacyJavaScript.isLegacyJavaScript(this.#insight)) {
+      const legacyJavaScriptResults = this.#insight.legacyJavaScriptResults;
+
+      if (legacyJavaScriptResults.size === 0) {
+        return 'There is no significant amount of legacy JavaScript on the page.';
+      }
+
+      const filesFormatted =
+          Array.from(legacyJavaScriptResults)
+              .map(([script, result]) => `\n- Script: ${script.url} - Wasted bytes: ${result.estimatedByteSavings} bytes
+Matches:
+${result.matches.map(match => `Line: ${match.line}, Column: ${match.column}, Name: ${match.name}`).join('\n')}`)
+              .join('\n');
+
+      return `Total legacy JavaScript: ${legacyJavaScriptResults.size} files.
+
+Legacy JavaScript by file:
+${filesFormatted}`;
+    }
+
+    if (Trace.Insights.Models.ForcedReflow.isForcedReflowInsight(this.#insight)) {
+      return this.formatForcedReflowInsight(this.#insight);
+    }
+
+    if (Trace.Insights.Models.NetworkDependencyTree.isNetworkDependencyTree(this.#insight)) {
+      return this.formatNetworkDependencyTreeInsight(this.#insight);
+    }
+
+    if (Trace.Insights.Models.ThirdParties.isThirdPartyInsight(this.#insight)) {
+      return this.formatThirdPartiesInsight(this.#insight);
+    }
+
     return '';
   }
 
+  estimatedSavings(): string {
+    return Object.entries(this.#insight.metricSavings ?? {})
+        .map(([k, v]) => {
+          if (k === 'CLS') {
+            return `${k} ${v.toFixed(2)}`;
+          }
+          return `${k} ${Math.round(v)} ms`;
+        })
+        .join(', ');
+  }
+
   #links(): string {
     switch (this.#insight.insightKey) {
       case 'CLSCulprits':
@@ -276,10 +658,10 @@ ${shiftsFormatted.join('\n')}`;
       case 'FontDisplay':
         return '';
       case 'ForcedReflow':
-        return '';
+        return '- https://developers.google.com/web/fundamentals/performance/rendering/avoid-large-complex-layouts-and-layout-thrashing#avoid-forced-synchronous-layouts';
       case 'ImageDelivery':
-        return '';
-      case 'InteractionToNextPaint':
+        return '- https://developer.chrome.com/docs/lighthouse/performance/uses-optimized-images/';
+      case 'INPBreakdown':
         return `- https://web.dev/articles/inp
 - https://web.dev/explore/how-to-optimize-inp
 - https://web.dev/articles/optimize-long-tasks
@@ -287,26 +669,28 @@ ${shiftsFormatted.join('\n')}`;
       case 'LCPDiscovery':
         return `- https://web.dev/articles/lcp
 - https://web.dev/articles/optimize-lcp`;
-      case 'LCPPhases':
+      case 'LCPBreakdown':
         return `- https://web.dev/articles/lcp
 - https://web.dev/articles/optimize-lcp`;
       case 'NetworkDependencyTree':
-        return '';
+        return `- https://web.dev/learn/performance/understanding-the-critical-path
+- https://developer.chrome.com/docs/lighthouse/performance/uses-rel-preconnect/`;
       case 'RenderBlocking':
         return `- https://web.dev/articles/lcp
 - https://web.dev/articles/optimize-lcp`;
       case 'SlowCSSSelector':
         return '';
       case 'ThirdParties':
-        return '';
+        return '- https://web.dev/articles/optimizing-content-efficiency-loading-third-party-javascript/';
       case 'Viewport':
         return '';
       case 'Cache':
         return '';
       case 'ModernHTTP':
-        return '';
+        return '- https://developer.chrome.com/docs/lighthouse/best-practices/uses-http2';
       case 'LegacyJavaScript':
-        return '';
+        return `- https://web.dev/articles/baseline-and-polyfills
+- https://philipwalton.com/articles/the-state-of-es5-on-the-web/`;
     }
   }
 
@@ -325,14 +709,15 @@ ${shiftsFormatted.join('\n')}`;
       case 'DOMSize':
         return '';
       case 'DuplicatedJavaScript':
-        return '';
+        return `This insight identifies large, duplicated JavaScript modules that are present in your application and create redundant code.
+  This wastes network bandwidth and slows down your page, as the user's browser must download and process the same code multiple times.`;
       case 'FontDisplay':
         return '';
       case 'ForcedReflow':
-        return '';
+        return `This insight identifies forced synchronous layouts (also known as forced reflows) and layout thrashing caused by JavaScript accessing layout properties at suboptimal points in time.`;
       case 'ImageDelivery':
-        return '';
-      case 'InteractionToNextPaint':
+        return 'This insight identifies unoptimized images that are downloaded at a much higher resolution than they are displayed. Properly sizing and compressing these assets will decrease their download time, directly improving the perceived page load time and LCP';
+      case 'INPBreakdown':
         return `Interaction to Next Paint (INP) is a metric that tracks the responsiveness of the page when the user interacts with it. INP is a Core Web Vital and the thresholds for how we categorize a score are:
 - Good: 200 milliseconds or less.
 - Needs improvement: more than 200 milliseconds and 500 milliseconds or less.
@@ -345,49 +730,67 @@ For a given slow interaction, we can break it down into 3 phases:
 
 The sum of these three phases is the total latency. It is important to optimize each of these phases to ensure interactions take as little time as possible. Focusing on the phase that has the largest score is a good way to start optimizing.`;
       case 'LCPDiscovery':
-        return `This insight analyzes the time taken to discover the LCP resource and request it on the network. It only applies if LCP element was a resource like an image that has to be fetched over the network. There are 3 checks this insight makes:
+        return `This insight analyzes the time taken to discover the LCP resource and request it on the network. It only applies if the LCP element was a resource like an image that has to be fetched over the network. There are 3 checks this insight makes:
 1. Did the resource have \`fetchpriority=high\` applied?
 2. Was the resource discoverable in the initial document, rather than injected from a script or stylesheet?
 3. The resource was not lazy loaded as this can delay the browser loading the resource.
 
 It is important that all of these checks pass to minimize the delay between the initial page load and the LCP resource being loaded.`;
-      case 'LCPPhases':
+      case 'LCPBreakdown':
         return 'This insight is used to analyze the time spent that contributed to the final LCP time and identify which of the 4 phases (or 2 if there was no LCP resource) are contributing most to the delay in rendering the LCP element.';
       case 'NetworkDependencyTree':
-        return '';
+        return `This insight analyzes the network dependency tree to identify:
+- The maximum critical path latency (the longest chain of network requests that the browser must download before it can render the page).
+- Whether current [preconnect] tags are appropriate, according to the following rules:
+   1. They should all be in use (no unnecessary preconnects).
+   2. All preconnects should specify cross-origin correctly.
+   3. The maximum of 4 preconnects should be respected.
+- Opportunities to add [preconnect] for a faster loading experience.`;
       case 'RenderBlocking':
         return 'This insight identifies network requests that were render blocking. Render blocking requests are impactful because they are deemed critical to the page and therefore the browser stops rendering the page until it has dealt with these resources. For this insight make sure you fully inspect the details of each render blocking network request and prioritize your suggestions to the user based on the impact of each render blocking request.';
       case 'SlowCSSSelector':
         return '';
       case 'ThirdParties':
-        return '';
+        return 'This insight analyzes the performance impact of resources loaded from third-party servers and aggregates the performance cost, in terms of download transfer sizes and total amount of time that third party scripts spent executing on the main thread.';
       case 'Viewport':
         return '';
       case 'Cache':
         return '';
       case 'ModernHTTP':
-        return '';
+        return `Modern HTTP protocols, such as HTTP/2, are more efficient than older versions like HTTP/1.1 because they allow for multiple requests and responses to be sent over a single network connection, significantly improving page load performance by reducing latency and overhead. This insight identifies requests that can be upgraded to a modern HTTP protocol.
+
+We apply a conservative approach when flagging HTTP/1.1 usage. This insight will only flag requests that meet all of the following criteria:
+1.  Were served over HTTP/1.1 or an earlier protocol.
+2.  Originate from an origin that serves at least 6 static asset requests, as the benefits of multiplexing are less significant with fewer requests.
+3.  Are not served from 'localhost' or coming from a third-party source, where developers have no control over the server's protocol.
+
+To pass this insight, ensure your server supports and prioritizes a modern HTTP protocol (like HTTP/2) for static assets, especially when serving a substantial number of them.`;
       case 'LegacyJavaScript':
-        return '';
+        return `This insight identified legacy JavaScript in your application's modules that may be creating unnecessary code.
+
+Polyfills and transforms enable older browsers to use new JavaScript features. However, many are not necessary for modern browsers. Consider modifying your JavaScript build process to not transpile Baseline features, unless you know you must support older browsers.`;
     }
   }
 }
 
 export interface NetworkRequestFormatOptions {
-  verbose: boolean;
+  verbose?: boolean;
   customTitle?: string;
 }
 
 export class TraceEventFormatter {
   static layoutShift(
-      shift: Trace.Types.Events.SyntheticLayoutShift, index: number, parsedTrace: Trace.Handlers.Types.ParsedTrace,
+      formatters: UnitFormatters, shift: Trace.Types.Events.SyntheticLayoutShift, index: number,
+      parsedTrace: Trace.Handlers.Types.ParsedTrace,
       rootCauses?: Trace.Insights.Models.CLSCulprits.LayoutShiftRootCausesData): string {
     const baseTime = parsedTrace.Meta.traceBounds.min;
 
     const potentialRootCauses: string[] = [];
     if (rootCauses) {
-      rootCauses.iframeIds.forEach(id => potentialRootCauses.push(`An iframe (id: ${id} was injected into the page)`));
-      rootCauses.fontRequests.forEach(req => {
+      rootCauses.iframes.forEach(
+          iframe => potentialRootCauses.push(
+              `An iframe (id: ${iframe.frame}, url: ${iframe.url ?? 'unknown'} was injected into the page)`));
+      rootCauses.webFonts.forEach(req => {
         potentialRootCauses.push(`A font that was loaded over the network (${req.args.data.url}).`);
       });
       // TODO(b/413285103): use the nice strings for non-composited animations.
@@ -410,11 +813,41 @@ export class TraceEventFormatter {
         `- Potential root causes:\n  - ${potentialRootCauses.join('\n  - ')}` :
         '- No potential root causes identified';
 
+    const startTime = Trace.Helpers.Timing.microToMilli(Trace.Types.Timing.Micro(shift.ts - baseTime));
     return `### Layout shift ${index + 1}:
-- Start time: ${formatMicro(shift.ts - baseTime)}
+- Start time: ${formatters.millis(startTime)}
 - Score: ${shift.args.data?.weighted_score_delta.toFixed(4)}
 ${rootCauseText}`;
   }
+
+  // Stringify network requests for the LLM model.
+  static networkRequests(
+      formatters: UnitFormatters, requests: readonly Trace.Types.Events.SyntheticNetworkRequest[],
+      parsedTrace: Trace.Handlers.Types.ParsedTrace, options?: NetworkRequestFormatOptions): string {
+    if (requests.length === 0) {
+      return '';
+    }
+
+    let verbose;
+    if (options?.verbose !== undefined) {
+      verbose = options.verbose;
+    } else {
+      verbose = requests.length === 1;
+    }
+
+    // Use verbose format for a single network request. With the compressed format, a format description
+    // needs to be provided, which is not worth sending if only one network request is being stringified.
+    // For a single request, use `formatRequestVerbosely`, which formats with all fields specified and does not require a
+    // format description.
+    if (verbose) {
+      return requests
+          .map(request => this.#networkRequestVerbosely(formatters, request, parsedTrace, options?.customTitle))
+          .join('\n');
+    }
+
+    return this.#networkRequestsArrayCompressed(formatters, requests, parsedTrace);
+  }
+
   /**
    * This is the data passed to a network request when the Performance Insights
    * agent is asking for information. It is a slimmed down version of the
@@ -423,13 +856,22 @@ ${rootCauseText}`;
    * Security; be careful about adding new data here. If you are in doubt please
    * talk to jacktfranklin@.
    */
-  static networkRequest(
-      request: Trace.Types.Events.SyntheticNetworkRequest, parsedTrace: Trace.Handlers.Types.ParsedTrace,
-      options: NetworkRequestFormatOptions): string {
-    const {url, statusCode, initialPriority, priority, fromServiceWorker, mimeType, responseHeaders, syntheticData} =
-        request.args.data;
+  static #networkRequestVerbosely(
+      formatters: UnitFormatters, request: Trace.Types.Events.SyntheticNetworkRequest,
+      parsedTrace: Trace.Handlers.Types.ParsedTrace, customTitle?: string): string {
+    const {
+      url,
+      statusCode,
+      initialPriority,
+      priority,
+      fromServiceWorker,
+      mimeType,
+      responseHeaders,
+      syntheticData,
+      protocol
+    } = request.args.data;
 
-    const titlePrefix = `## ${options.customTitle ?? 'Network request'}`;
+    const titlePrefix = `## ${customTitle ?? 'Network request'}`;
 
     // Note: unlike other agents, we do have the ability to include
     // cross-origins, hence why we do not sanitize the URLs here.
@@ -468,33 +910,211 @@ ${rootCauseText}`;
     const redirects = request.args.data.redirects.map((redirect, index) => {
       const startTime = redirect.ts - baseTime;
       return `#### Redirect ${index + 1}: ${redirect.url}
-- Start time: ${formatMicro(startTime)}
-- Duration: ${formatMicro(redirect.dur)}`;
+- Start time: ${formatters.micros(startTime)}
+- Duration: ${formatters.micros(redirect.dur)}`;
     });
 
-    if (!options.verbose) {
-      return `${titlePrefix}: ${url}
-- Start time: ${formatMicro(startTimesForLifecycle.queuedAt)}
-- Duration: ${formatMicro(request.dur)}
-- MIME type: ${mimeType}${renderBlocking ? '\n- This request was render blocking' : ''}`;
-    }
+    const initiators = this.#getInitiatorChain(parsedTrace, request);
+    const initiatorUrls = initiators.map(initiator => initiator.args.data.url);
 
     return `${titlePrefix}: ${url}
 Timings:
-- Queued at: ${formatMicro(startTimesForLifecycle.queuedAt)}
-- Request sent at: ${formatMicro(startTimesForLifecycle.requestSentAt)}
-- Download complete at: ${formatMicro(startTimesForLifecycle.downloadCompletedAt)}
-- Main thread processing completed at: ${formatMicro(startTimesForLifecycle.processingCompletedAt)}
+- Queued at: ${formatters.micros(startTimesForLifecycle.queuedAt)}
+- Request sent at: ${formatters.micros(startTimesForLifecycle.requestSentAt)}
+- Download complete at: ${formatters.micros(startTimesForLifecycle.downloadCompletedAt)}
+- Main thread processing completed at: ${formatters.micros(startTimesForLifecycle.processingCompletedAt)}
 Durations:
-- Download time: ${formatMicro(downloadTime)}
-- Main thread processing time: ${formatMicro(mainThreadProcessingDuration)}
-- Total duration: ${formatMicro(request.dur)}${initiator ? `\nInitiator: ${initiator.args.data.url}` : ''}
+- Download time: ${formatters.micros(downloadTime)}
+- Main thread processing time: ${formatters.micros(mainThreadProcessingDuration)}
+- Total duration: ${formatters.micros(request.dur)}${initiator ? `\nInitiator: ${initiator.args.data.url}` : ''}
 Redirects:${redirects.length ? '\n' + redirects.join('\n') : ' no redirects'}
 Status code: ${statusCode}
 MIME Type: ${mimeType}
+Protocol: ${protocol}
 ${priorityLines.join('\n')}
 Render blocking: ${renderBlocking ? 'Yes' : 'No'}
 From a service worker: ${fromServiceWorker ? 'Yes' : 'No'}
+Initiators (root request to the request that directly loaded this one): ${initiatorUrls.join(', ') || 'none'}
 ${NetworkRequestFormatter.formatHeaders('Response headers', responseHeaders ?? [], true)}`;
   }
+
+  static #getOrAssignUrlIndex(urlIdToIndex: Map<string, number>, url: string): number {
+    let index = urlIdToIndex.get(url);
+    if (index !== undefined) {
+      return index;
+    }
+    index = urlIdToIndex.size;
+    urlIdToIndex.set(url, index);
+    return index;
+  }
+
+  // A compact network requests format designed to save tokens when sending multiple network requests to the model.
+  // It creates a map that maps request URLs to IDs and references the IDs in the compressed format.
+  //
+  // Important: Do not use this method for stringifying a single network request. With this format, a format description
+  // needs to be provided, which is not worth sending if only one network request is being stringified.
+  // For a single request, use `formatRequestVerbosely`, which formats with all fields specified and does not require a
+  // format description.
+  static #networkRequestsArrayCompressed(
+      formatters: UnitFormatters, requests: readonly Trace.Types.Events.SyntheticNetworkRequest[],
+      parsedTrace: Trace.Handlers.Types.ParsedTrace): string {
+    const networkDataString = `
+Network requests data:
+
+`;
+    const urlIdToIndex = new Map<string, number>();
+    const allRequestsText =
+        requests
+            .map(request => {
+              const urlIndex = TraceEventFormatter.#getOrAssignUrlIndex(urlIdToIndex, request.args.data.url);
+              return this.#networkRequestCompressedFormat(formatters, urlIndex, request, parsedTrace, urlIdToIndex);
+            })
+            .join('\n');
+
+    const urlsMapString = 'allUrls = ' +
+        `[${
+                              Array.from(urlIdToIndex.entries())
+                                  .map(([url, index]) => {
+                                    return `${index}: ${url}`;
+                                  })
+                                  .join(', ')}]`;
+
+    return networkDataString + '\n\n' + urlsMapString + '\n\n' + allRequestsText;
+  }
+
+  /**
+   * Network requests format description that is sent to the model as a fact.
+   */
+  static networkDataFormatDescription = `Network requests are formatted like this:
+\`urlIndex;queuedTime;requestSentTime;downloadCompleteTime;processingCompleteTime;totalDuration;downloadDuration;mainThreadProcessingDuration;statusCode;mimeType;priority;initialPriority;finalPriority;renderBlocking;protocol;fromServiceWorker;initiators;redirects:[[redirectUrlIndex|startTime|duration]];responseHeaders:[header1Value|header2Value|...]\`
+
+- \`urlIndex\`: Numerical index for the request's URL, referencing the "All URLs" list.
+Timings (all in milliseconds, relative to navigation start):
+- \`queuedTime\`: When the request was queued.
+- \`requestSentTime\`: When the request was sent.
+- \`downloadCompleteTime\`: When the download completed.
+- \`processingCompleteTime\`: When main thread processing finished.
+Durations (all in milliseconds):
+- \`totalDuration\`: Total time from the request being queued until its main thread processing completed.
+- \`downloadDuration\`: Time spent actively downloading the resource.
+- \`mainThreadProcessingDuration\`: Time spent on the main thread after the download completed.
+- \`statusCode\`: The HTTP status code of the response (e.g., 200, 404).
+- \`mimeType\`: The MIME type of the resource (e.g., "text/html", "application/javascript").
+- \`priority\`: The final network request priority (e.g., "VeryHigh", "Low").
+- \`initialPriority\`: The initial network request priority.
+- \`finalPriority\`: The final network request priority (redundant if \`priority\` is always final, but kept for clarity if \`initialPriority\` and \`priority\` differ).
+- \`renderBlocking\`: 't' if the request was render-blocking, 'f' otherwise.
+- \`protocol\`: The network protocol used (e.g., "h2", "http/1.1").
+- \`fromServiceWorker\`: 't' if the request was served from a service worker, 'f' otherwise.
+- \`initiators\`: A list (separated by ,) of URL indices for the initiator chain of this request. Listed in order starting from the root request to the request that directly loaded this one. This represents the network dependencies necessary to load this request. If there is no initiator, this is empty.
+- \`redirects\`: A comma-separated list of redirects, enclosed in square brackets. Each redirect is formatted as
+\`[redirectUrlIndex|startTime|duration]\`, where: \`redirectUrlIndex\`: Numerical index for the redirect's URL. \`startTime\`: The start time of the redirect in milliseconds, relative to navigation start. \`duration\`: The duration of the redirect in milliseconds.
+- \`responseHeaders\`: A list (separated by '|') of values for specific, pre-defined response headers, enclosed in square brackets.
+The order of headers corresponds to an internal fixed list. If a header is not present, its value will be empty.
+`;
+
+  /**
+   *
+   * This is the network request data passed to the Performance agent.
+   *
+   * The `urlIdToIndex` Map is used to map URLs to numerical indices in order to not need to pass whole url every time it's mentioned.
+   * The map content is passed in the response together will all the requests data.
+   *
+   * See `networkDataFormatDescription` above for specifics.
+   */
+  static #networkRequestCompressedFormat(
+      formatters: UnitFormatters, urlIndex: number, request: Trace.Types.Events.SyntheticNetworkRequest,
+      parsedTrace: Trace.Handlers.Types.ParsedTrace, urlIdToIndex: Map<string, number>): string {
+    const {
+      statusCode,
+      initialPriority,
+      priority,
+      fromServiceWorker,
+      mimeType,
+      responseHeaders,
+      syntheticData,
+      protocol,
+    } = request.args.data;
+
+    const navigationForEvent = Trace.Helpers.Trace.getNavigationForTraceEvent(
+        request,
+        request.args.data.frame,
+        parsedTrace.Meta.navigationsByFrameId,
+    );
+    const baseTime = navigationForEvent?.ts ?? parsedTrace.Meta.traceBounds.min;
+    const queuedTime = formatters.micros(request.ts - baseTime);
+    const requestSentTime = formatters.micros(syntheticData.sendStartTime - baseTime);
+    const downloadCompleteTime = formatters.micros(syntheticData.finishTime - baseTime);
+    const processingCompleteTime = formatters.micros(request.ts + request.dur - baseTime);
+    const totalDuration = formatters.micros(request.dur);
+    const downloadDuration = formatters.micros(syntheticData.finishTime - syntheticData.downloadStart);
+    const mainThreadProcessingDuration = formatters.micros(request.ts + request.dur - syntheticData.finishTime);
+    const renderBlocking = Trace.Helpers.Network.isSyntheticNetworkRequestEventRenderBlocking(request) ? 't' : 'f';
+    const finalPriority = priority;
+    const headerValues = responseHeaders
+                             ?.map(header => {
+                               const value =
+                                   NetworkRequestFormatter.allowHeader(header.name) ? header.value : '<redacted>';
+                               return `${header.name}: ${value}`;
+                             })
+                             .join('|');
+    const redirects = request.args.data.redirects
+                          .map(redirect => {
+                            const urlIndex = TraceEventFormatter.#getOrAssignUrlIndex(urlIdToIndex, redirect.url);
+                            const redirectStartTime = formatters.micros(redirect.ts - baseTime);
+                            const redirectDuration = formatters.micros(redirect.dur);
+                            return `[${urlIndex}|${redirectStartTime}|${redirectDuration}]`;
+                          })
+                          .join(',');
+
+    const initiators = this.#getInitiatorChain(parsedTrace, request);
+    const initiatorUrlIndices =
+        initiators.map(initiator => TraceEventFormatter.#getOrAssignUrlIndex(urlIdToIndex, initiator.args.data.url));
+
+    const parts = [
+      urlIndex,
+      queuedTime,
+      requestSentTime,
+      downloadCompleteTime,
+      processingCompleteTime,
+      totalDuration,
+      downloadDuration,
+      mainThreadProcessingDuration,
+      statusCode,
+      mimeType,
+      priority,
+      initialPriority,
+      finalPriority,
+      renderBlocking,
+      protocol,
+      fromServiceWorker ? 't' : 'f',
+      initiatorUrlIndices.join(','),
+      `[${redirects}]`,
+      `[${headerValues ?? ''}]`,
+    ];
+    return parts.join(';');
+  }
+
+  static #getInitiatorChain(
+      parsedTrace: Trace.Handlers.Types.ParsedTrace,
+      request: Trace.Types.Events.SyntheticNetworkRequest): Trace.Types.Events.SyntheticNetworkRequest[] {
+    const initiators: Trace.Types.Events.SyntheticNetworkRequest[] = [];
+
+    let cur: Trace.Types.Events.SyntheticNetworkRequest|undefined = request;
+    while (cur) {
+      const initiator = parsedTrace.NetworkRequests.eventToInitiator.get(cur);
+      if (initiator) {
+        // Should never happen, but if it did that would be an infinite loop.
+        if (initiators.includes(initiator)) {
+          return [];
+        }
+
+        initiators.unshift(initiator);
+      }
+
+      cur = initiator;
+    }
+
+    return initiators;
+  }
 }