chrome-devtools-frontend 1.0.1526630 → 1.0.1529186

package/front_end/core/sdk/SourceMap.ts

@@ -9,6 +9,8 @@ import * as Platform from '../platform/platform.js';
 import * as Root from '../root/root.js';
 
 import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
+import {scopeTreeForScript} from './ScopeTreeCache.js';
+import type {Script} from './Script.js';
 import {buildOriginalScopes, decodePastaRanges, type NamedFunctionRange} from './SourceMapFunctionRanges.js';
 import {SourceMapScopesInfo} from './SourceMapScopesInfo.js';
 
@@ -131,18 +133,22 @@ export class SourceMap {
   readonly #sourceInfos: SourceInfo[] = [];
   readonly #sourceInfoByURL = new Map<Platform.DevToolsPath.UrlString, SourceInfo>();
 
+  readonly #script?: Script;
   #scopesInfo: SourceMapScopesInfo|null = null;
 
   readonly #debugId?: DebugId;
 
+  scopesFallbackPromiseForTest?: Promise<unknown>;
+
   /**
    * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
    * for format description.
    */
   constructor(
       compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString,
-      payload: SourceMapV3) {
+      payload: SourceMapV3, script?: Script) {
     this.#json = payload;
+    this.#script = script;
     this.#compiledURL = compiledURL;
     this.#sourceMappingURL = sourceMappingURL;
     this.#baseURL = (Common.ParsedURL.schemeIs(sourceMappingURL, 'data:')) ? compiledURL : sourceMappingURL;
@@ -163,7 +169,7 @@ export class SourceMap {
   }
 
   augmentWithScopes(scriptUrl: Platform.DevToolsPath.UrlString, ranges: NamedFunctionRange[]): void {
-    this.#ensureMappingsProcessed();
+    this.#ensureSourceMapProcessed();
     if (this.#json && this.#json.version > 3) {
       throw new Error('Only support augmenting source maps up to version 3.');
     }
@@ -199,6 +205,10 @@ export class SourceMap {
     return this.#debugId ?? null;
   }
 
+  sourceURLForSourceIndex(index: number): Platform.DevToolsPath.UrlString|undefined {
+    return this.#sourceInfos[index]?.sourceURL;
+  }
+
   sourceURLs(): Platform.DevToolsPath.UrlString[] {
     return [...this.#sourceInfoByURL.keys()];
   }
@@ -212,12 +222,12 @@ export class SourceMap {
   }
 
   hasScopeInfo(): boolean {
-    this.#ensureMappingsProcessed();
-    return this.#scopesInfo !== null;
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo !== null && !this.#scopesInfo.isEmpty();
   }
 
   findEntry(lineNumber: number, columnNumber: number, inlineFrameIndex?: number): SourceMapEntry|null {
-    this.#ensureMappingsProcessed();
+    this.#ensureSourceMapProcessed();
     if (inlineFrameIndex && this.#scopesInfo !== null) {
       // For inlineFrameIndex != 0 we use the callsite info for the corresponding inlining site.
       // Note that the callsite for "inlineFrameIndex" is actually in the previous frame.
@@ -372,20 +382,40 @@ export class SourceMap {
   }
 
   mappings(): SourceMapEntry[] {
-    this.#ensureMappingsProcessed();
+    this.#ensureSourceMapProcessed();
     return this.#mappings ?? [];
   }
 
+  /**
+   * If the source map does not contain scope information by itself (e.g. "scopes proposal"
+   * or "pasta" scopes), then we'll use this getter to calculate basic function name information from
+   * the AST and mappings.
+   */
+  async #buildScopesFallback(): Promise<SourceMapScopesInfo|null> {
+    const scopeTreeAndText = this.#script ? await scopeTreeForScript(this.#script) : null;
+    if (!scopeTreeAndText) {
+      return null;
+    }
+
+    const {scopeTree, text} = scopeTreeAndText;
+    return SourceMapScopesInfo.createFromAst(this, scopeTree, text);
+  }
+
   private reversedMappings(sourceURL: Platform.DevToolsPath.UrlString): number[] {
-    this.#ensureMappingsProcessed();
+    this.#ensureSourceMapProcessed();
     return this.#sourceInfoByURL.get(sourceURL)?.reverseMappings ?? [];
   }
 
-  #ensureMappingsProcessed(): void {
+  #ensureSourceMapProcessed(): void {
     if (this.#mappings === null) {
       this.#mappings = [];
       try {
         this.eachSection(this.parseMap.bind(this));
+        if (!this.hasScopeInfo()) {
+          this.scopesFallbackPromiseForTest = this.#buildScopesFallback().then(info => {
+            this.#scopesInfo = info;
+          });
+        }
       } catch (e) {
         console.error('Failed to parse source map', e);
         this.#mappings = [];
@@ -728,7 +758,7 @@ export class SourceMap {
   }
 
   expandCallFrame(frame: CallFrame): CallFrame[] {
-    this.#ensureMappingsProcessed();
+    this.#ensureSourceMapProcessed();
     if (this.#scopesInfo === null) {
       return [frame];
     }
@@ -737,7 +767,7 @@ export class SourceMap {
   }
 
   resolveScopeChain(frame: CallFrame): ScopeChainEntry[]|null {
-    this.#ensureMappingsProcessed();
+    this.#ensureSourceMapProcessed();
     if (this.#scopesInfo === null) {
       return null;
     }
@@ -746,7 +776,7 @@ export class SourceMap {
   }
 
   findOriginalFunctionName(position: ScopesCodec.Position): string|null {
-    this.#ensureMappingsProcessed();
+    this.#ensureSourceMapProcessed();
     return this.#scopesInfo?.findOriginalFunctionName(position) ?? null;
   }
 }

package/front_end/core/sdk/SourceMapManager.ts

@@ -11,17 +11,24 @@ import {type DebugId, parseSourceMap, SourceMap, type SourceMapV3} from './Sourc
 import {SourceMapCache} from './SourceMapCache.js';
 import {type Target, Type} from './Target.js';
 
+export type SourceMapFactory<T> =
+    (compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString,
+     payload: SourceMapV3, client: T) => SourceMap;
+
 export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWrapper.ObjectWrapper<EventTypes<T>> {
   readonly #target: Target;
+  readonly #factory: SourceMapFactory<T>;
   #isEnabled = true;
   readonly #clientData = new Map<T, ClientData>();
   readonly #sourceMaps = new Map<SourceMap, T>();
   #attachingClient: T|null = null;
 
-  constructor(target: Target) {
+  constructor(target: Target, factory?: SourceMapFactory<T>) {
     super();
 
     this.#target = target;
+    this.#factory =
+        factory ?? ((compiledURL, sourceMappingURL, payload) => new SourceMap(compiledURL, sourceMappingURL, payload));
   }
 
   setEnabled(isEnabled: boolean): void {
@@ -109,7 +116,7 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
               loadSourceMap(sourceMapURL, client.debugId(), initiator)
                   .then(
                       payload => {
-                        const sourceMap = new SourceMap(sourceURL, sourceMapURL, payload);
+                        const sourceMap = this.#factory(sourceURL, sourceMapURL, payload, client);
                         if (this.#clientData.get(client) === clientData) {
                           clientData.sourceMap = sourceMap;
                           this.#sourceMaps.set(sourceMap, client);
@@ -167,6 +174,10 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
       this.dispatchEventToListeners(Events.SourceMapFailedToAttach, {client});
     }
   }
+
+  waitForSourceMapsProcessedForTest(): Promise<unknown> {
+    return Promise.all(this.#sourceMaps.keys().map(sourceMap => sourceMap.scopesFallbackPromiseForTest));
+  }
 }
 
 export async function loadSourceMap(

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -6,6 +6,7 @@ import * as Protocol from '../../generated/protocol.js';
 import * as Formatter from '../../models/formatter/formatter.js';
 import type * as TextUtils from '../../models/text_utils/text_utils.js';
 import type * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-map-scopes-codec.js';
+import type * as Platform from '../platform/platform.js';
 
 import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
 import type {SourceMap} from './SourceMap.js';
@@ -95,6 +96,10 @@ export class SourceMapScopesInfo {
     return Boolean(this.#originalScopes[sourceIdx]);
   }
 
+  isEmpty(): boolean {
+    return !this.#originalScopes.length && !this.#generatedRanges.length;
+  }
+
   addOriginalScopesAtIndex(sourceIdx: number, scope: ScopesCodec.OriginalScope): void {
     if (!this.#originalScopes[sourceIdx]) {
       this.#originalScopes[sourceIdx] = scope;
@@ -103,6 +108,37 @@ export class SourceMapScopesInfo {
     }
   }
 
+  /**
+   * @returns true, iff the function surrounding the provided position is marked as "hidden".
+   */
+  isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    for (let i = rangeChain.length - 1; i >= 0; --i) {
+      if (rangeChain[i].isStackFrame) {
+        return rangeChain[i].isHidden;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @returns true, iff the range surrounding the provided position contains multiple
+   * inlined original functions.
+   */
+  hasInlinedFrames(generatedLine: number, generatedColumn: number): boolean {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    for (let i = rangeChain.length - 1; i >= 0; --i) {
+      if (rangeChain[i].isStackFrame) {
+        // We stop looking for inlined original functions once we reach the current frame.
+        return false;
+      }
+      if (rangeChain[i].callSite) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Given a generated position, returns the original name of the surrounding function as well as
    * all the original function names that got inlined into the surrounding generated function and their
@@ -125,7 +161,10 @@ export class SourceMapScopesInfo {
 
       if (range.callSite) {
         // Record the name and call-site if the range corresponds to an inlined function.
-        result.inlinedFunctions.push({name: range.originalScope?.name ?? '', callsite: range.callSite});
+        result.inlinedFunctions.push({
+          name: range.originalScope?.name ?? '',
+          callsite: {...range.callSite, sourceURL: this.#sourceMap.sourceURLForSourceIndex(range.callSite.sourceIndex)}
+        });
       }
       if (range.isStackFrame) {
         // We arrived at an actual generated JS function, don't go further.
@@ -377,7 +416,15 @@ export class SourceMapScopesInfo {
  * The inlined functions are sorted from inner to outer (or top to bottom on the stack).
  */
 export interface InlineInfo {
-  inlinedFunctions: Array<{name: string, callsite: ScopesCodec.OriginalPosition}>;
+  inlinedFunctions: Array<{
+    name: string,
+    callsite: {
+      line: number,
+      column: number,
+      sourceIndex: number,
+      sourceURL?: Platform.DevToolsPath.UrlString,
+    },
+  }>;
   originalFunctionName: string;
 }
 

package/front_end/core/sdk/TargetManager.ts

@@ -10,8 +10,6 @@ import {assertNotNullOrUndefined} from '../platform/platform.js';
 import type * as ProtocolClient from '../protocol_client/protocol_client.js';
 import * as Root from '../root/root.js';
 
-import {StubConnection} from './Connections.js';
-import {RehydratingConnection} from './RehydratingConnection.js';
 import {SDKModel} from './SDKModel.js';
 import {Target, Type as TargetType} from './Target.js';
 
@@ -312,26 +310,6 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     return this.#browserTarget;
   }
 
-  /**
-   * If this returns true, the target is not connected to a legit CDP server.
-   * However, it's not exhaustive, so some `false` responses may be misleading.
-   *    (eg., tab URL of `devtools://devtools/bundled/devtools_app.html` uses a MainConnection but has no CDP server behind it).
-   */
-  hasFakeConnection(): boolean {
-    // Rehydrated DevTools always has a fake connection, so we shortcut and avoid the race.
-    if (Root.Runtime.getPathName().includes('rehydrated_devtools_app')) {
-      return true;
-    }
-    // There _may_ be a race condition hiding here on the router/connection creation.
-    // So we play it safe and consider "no connection yet" as "not fake".
-    const connection = this.primaryPageTarget()?.router()?.connection();
-    if (!connection) {
-      return false;
-    }
-    const isFakeConnection = (connection instanceof StubConnection) || (connection instanceof RehydratingConnection);
-    return isFakeConnection;
-  }
-
   async maybeAttachInitialTarget(): Promise<boolean> {
     if (!Boolean(Root.Runtime.Runtime.queryParam('browserConnection'))) {
       return false;

package/front_end/core/sdk/TraceObject.ts

@@ -14,13 +14,14 @@ import type {SourceMapV3} from './SourceMap.js';
 export class TraceObject {
   readonly traceEvents: Protocol.Tracing.DataCollectedEvent['value'];
   readonly metadata: {sourceMaps?: Array<{sourceMapUrl: string, sourceMap: SourceMapV3, url: string}>};
-  constructor(payload: Protocol.Tracing.DataCollectedEvent['value']|TraceObject, meta: Object = {}) {
-    // Handle the typical traceEvent array juggling here.
-    const events = Array.isArray(payload) ? payload : payload.traceEvents;
-    const metadata = meta ?? (!Array.isArray(payload) && payload.metadata) ?? {};
-
-    this.traceEvents = events;
-    this.metadata = metadata;
+  constructor(payload: Protocol.Tracing.DataCollectedEvent['value']|TraceObject, meta?: Object) {
+    if (Array.isArray(payload)) {
+      this.traceEvents = payload;
+      this.metadata = meta ?? {};
+    } else {
+      this.traceEvents = payload.traceEvents;
+      this.metadata = payload.metadata;
+    }
   }
 }
 

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.ts

@@ -1403,6 +1403,71 @@ export abstract class HeapSnapshot {
         }
         return getBit;
       }
+      case 'objectsRetainedByEventHandlers': {
+        // This filter is based on the assumption that event handler functions are contained
+        // (directly or indirectly) by V8EventListener nodes. In particular, the callback_object_
+        // field of V8EventListener points to either the function used as the event handler,
+        // or to a framework-specific wrapper object that in turn contains the actual handler.
+        //
+        // The filter works in two steps:
+        // 1. Identify all event handler functions and mark them in a bitmap.
+        // 2. Traverse the graph, avoiding paths that pass through any of the event handlers
+        const node = this.createNode(0);
+        const nodeFieldCount = this.nodeFieldCount;
+
+        // First, identify which nodes are event handlers
+        const eventHandlerBitmap = Platform.TypedArrayUtilities.createBitVector(this.nodeCount);
+
+        // Iterate all nodes looking for V8EventListener objects
+        for (let i = 0; i < this.nodeCount; ++i) {
+          node.nodeIndex = i * nodeFieldCount;
+
+          // Check if this node is a V8EventListener
+          if (node.rawName() === 'V8EventListener') {
+            // Get the callback_object_ (edge "1")
+            const callbackNode = this.getEdgeTarget(node, '1');
+            if (!callbackNode) {
+              continue;
+            }
+
+            const callbackOrdinal = callbackNode.nodeIndex / nodeFieldCount;
+
+            // Check if callback has a "code" edge (direct function handler)
+            if (this.getEdgeTarget(callbackNode, 'code')) {
+              eventHandlerBitmap.setBit(callbackOrdinal);
+              continue;
+            }
+
+            // Check if any child has a "code" edge (framework wrapper)
+            let foundChildWithCode = false;
+            for (let childEdgeIt = callbackNode.edges(); childEdgeIt.hasNext(); childEdgeIt.next()) {
+              const childNode = childEdgeIt.item().node();
+              if (this.getEdgeTarget(childNode, 'code')) {
+                eventHandlerBitmap.setBit(childNode.nodeIndex / nodeFieldCount);
+                foundChildWithCode = true;
+                break;
+              }
+            }
+
+            // Fallback to marking the callback node itself
+            if (!foundChildWithCode) {
+              eventHandlerBitmap.setBit(callbackOrdinal);
+            }
+          }
+        }
+
+        // Traverse the graph, avoiding paths that pass through event handlers
+        traverse((currentNode: HeapSnapshotNode, edge: HeapSnapshotEdge) => {
+          const targetNode = edge.node();
+          const targetOrdinal = targetNode.nodeIndex / nodeFieldCount;
+          // Return false (don't traverse) if the target node is an event handler
+          return !eventHandlerBitmap.getBit(targetOrdinal);
+        });
+
+        markUnreachableNodes();
+
+        return (node: HeapSnapshotNode) => !getBit(node);
+      }
     }
     throw new Error('Invalid filter name');
   }
@@ -2394,6 +2459,22 @@ export abstract class HeapSnapshot {
     return this.strings.length - 1;
   }
 
+  /**
+   * Gets the target node of an edge with the specified name.
+   * @param node The source node to search from
+   * @param edgeName The name of the edge to find
+   * @returns The target node if found, null otherwise
+   */
+  private getEdgeTarget(node: HeapSnapshotNode, edgeName: string): HeapSnapshotNode|null {
+    for (let edgeIt = node.edges(); edgeIt.hasNext(); edgeIt.next()) {
+      const edge = edgeIt.item();
+      if (edge.name() === edgeName) {
+        return edge.node();
+      }
+    }
+    return null;
+  }
+
   /**
    * The phase propagates whether a node is attached or detached through the
    * graph and adjusts the low-level representation of nodes.

package/front_end/entrypoints/inspector_main/InspectorMain.ts

@@ -65,7 +65,9 @@ export class InspectorMainImpl implements Common.Runnable.Runnable {
     await SDK.Connections.initMainConnection(async () => {
       const type = Root.Runtime.Runtime.queryParam('v8only') ?
           SDK.Target.Type.NODE :
-          (Root.Runtime.Runtime.queryParam('targetType') === 'tab' ? SDK.Target.Type.TAB : SDK.Target.Type.FRAME);
+          (Root.Runtime.Runtime.queryParam('targetType') === 'tab' || Root.Runtime.Runtime.isTraceApp() ?
+               SDK.Target.Type.TAB :
+               SDK.Target.Type.FRAME);
       // TODO(crbug.com/1348385): support waiting for debugger with tab target.
       const waitForDebuggerInPage =
           type === SDK.Target.Type.FRAME && Root.Runtime.Runtime.queryParam('panel') === 'sources';

package/front_end/entrypoints/main/GlobalAiButton.ts

@@ -82,6 +82,7 @@ export class GlobalAiButton extends UI.Widget.Widget {
   }
 
   override willHide(): void {
+    super.willHide();
     this.#removeHoverEventListeners();
 
     if (this.#returnToDefaultStateTimeout) {

package/front_end/entrypoints/main/MainImpl.ts

@@ -54,7 +54,7 @@ import * as Logs from '../../models/logs/logs.js';
 import * as Persistence from '../../models/persistence/persistence.js';
 import * as ProjectSettings from '../../models/project_settings/project_settings.js';
 import * as Workspace from '../../models/workspace/workspace.js';
-import type * as PanelCommon from '../../panels/common/common.js';
+import * as PanelCommon from '../../panels/common/common.js';
 import * as Snippets from '../../panels/snippets/snippets.js';
 import * as Buttons from '../../ui/components/buttons/buttons.js';
 import * as Snackbar from '../../ui/components/snackbars/snackbars.js';
@@ -120,6 +120,10 @@ const UIStrings = {
    * @description Text describing how to navigate the dock side menu
    */
   dockSideNavigation: 'Use left and right arrow keys to navigate the options',
+  /**
+   * @description Notification shown to the user whenever DevTools receives an external request.
+   */
+  externalRequestReceived: '`DevTools` received an external request',
 } as const;
 const str_ = i18n.i18n.registerUIStrings('entrypoints/main/MainImpl.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
@@ -476,11 +480,13 @@ export class MainImpl {
     isolatedFileSystemManager.addPlatformFileSystem(
         'snippet://' as Platform.DevToolsPath.UrlString, new Snippets.ScriptSnippetFileSystem.SnippetFileSystem());
 
-    Persistence.Persistence.PersistenceImpl.instance({
+    const persistenceImpl = Persistence.Persistence.PersistenceImpl.instance({
       forceNew: true,
       workspace: Workspace.Workspace.WorkspaceImpl.instance(),
       breakpointManager: Breakpoints.BreakpointManager.BreakpointManager.instance(),
     });
+    const linkDecorator = new PanelCommon.PersistenceUtils.LinkDecorator(persistenceImpl);
+    Components.Linkifier.Linkifier.setLinkDecorator(linkDecorator);
     Persistence.NetworkPersistenceManager.NetworkPersistenceManager.instance(
         {forceNew: true, workspace: Workspace.Workspace.WorkspaceImpl.instance()});
 
@@ -510,6 +516,8 @@ export class MainImpl {
     LiveMetrics.LiveMetrics.instance();
     CrUXManager.CrUXManager.instance();
 
+    void AiAssistanceModel.BuiltInAi.BuiltInAi.instance();
+
     new PauseListener();
 
     const actionRegistryInstance = UI.ActionRegistry.ActionRegistry.instance({forceNew: true});
@@ -539,6 +547,14 @@ export class MainImpl {
       });
     }
 
+    const conversationHandler = AiAssistanceModel.ConversationHandler.ConversationHandler.instance();
+    conversationHandler.addEventListener(
+        AiAssistanceModel.ConversationHandler.ConversationHandlerEvents.EXTERNAL_REQUEST_RECEIVED,
+        () => Snackbar.Snackbar.Snackbar.show({message: i18nString(UIStrings.externalRequestReceived)}));
+    conversationHandler.addEventListener(
+        AiAssistanceModel.ConversationHandler.ConversationHandlerEvents.EXTERNAL_CONVERSATION_STARTED,
+        event => void VisualLogging.logFunctionCall(`start-conversation-${event.data}`, 'external'));
+
     MainImpl.timeEnd('Main._createAppUI');
 
     const appProvider = Common.AppProvider.getRegisteredAppProviders()[0];
@@ -568,17 +584,14 @@ export class MainImpl {
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
         Host.InspectorFrontendHostAPI.Events.RevealSourceLine, this.#revealSourceLine, this);
 
-    await UI.InspectorView.InspectorView.instance().createToolbars();
+    const inspectorView = UI.InspectorView.InspectorView.instance();
+    Persistence.NetworkPersistenceManager.NetworkPersistenceManager.instance().addEventListener(
+        Persistence.NetworkPersistenceManager.Events.LOCAL_OVERRIDES_REQUESTED, event => {
+          inspectorView.displaySelectOverrideFolderInfobar(event.data);
+        });
+    await inspectorView.createToolbars();
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.loadCompleted();
 
-    const value = Root.Runtime.Runtime.queryParam('loadTimelineFromURL');
-    if (value !== null) {
-      // Only import Timeline if needed. If this was a static import, every load of devtools
-      // would request and evaluate the Timeline panel dep tree, slowing down the UI's load.
-      const Timeline = await import('../../panels/timeline/timeline.js');
-      Timeline.TimelinePanel.LoadTimelineHandler.instance().handleQueryParam(value);
-    }
-
     // Initialize elements for the live announcer functionality for a11y.
     UI.ARIAUtils.LiveAnnouncer.initializeAnnouncerElements();
     UI.DockController.DockController.instance().announceDockLocation();
@@ -1072,15 +1085,16 @@ type ExternalRequestInput = {
 export async function handleExternalRequest(input: ExternalRequestInput):
     Promise<{response: string, devToolsLogs: object[]}> {
   const generator = await handleExternalRequestGenerator(input);
-  let result: IteratorResult<AiAssistanceModel.ExternalRequestResponse, AiAssistanceModel.ExternalRequestResponse>;
+  let result: IteratorResult<
+      AiAssistanceModel.AiAgent.ExternalRequestResponse, AiAssistanceModel.AiAgent.ExternalRequestResponse>;
   do {
     result = await generator.next();
   } while (!result.done);
   const response = result.value;
-  if (response.type === AiAssistanceModel.ExternalRequestResponseType.ERROR) {
+  if (response.type === AiAssistanceModel.AiAgent.ExternalRequestResponseType.ERROR) {
     throw new Error(response.message);
   }
-  if (response.type === AiAssistanceModel.ExternalRequestResponseType.ANSWER) {
+  if (response.type === AiAssistanceModel.AiAgent.ExternalRequestResponseType.ANSWER) {
     return {
       response: response.message,
       devToolsLogs: response.devToolsLogs,
@@ -1092,8 +1106,8 @@ export async function handleExternalRequest(input: ExternalRequestInput):
 // @ts-expect-error
 globalThis.handleExternalRequest = handleExternalRequest;
 
-export async function handleExternalRequestGenerator(input: ExternalRequestInput):
-    Promise<AsyncGenerator<AiAssistanceModel.ExternalRequestResponse, AiAssistanceModel.ExternalRequestResponse>> {
+export async function handleExternalRequestGenerator(input: ExternalRequestInput): Promise<AsyncGenerator<
+    AiAssistanceModel.AiAgent.ExternalRequestResponse, AiAssistanceModel.AiAgent.ExternalRequestResponse>> {
   switch (input.kind) {
     case 'PERFORMANCE_RELOAD_GATHER_INSIGHTS': {
       const TimelinePanel = await import('../../panels/timeline/timeline.js');
@@ -1105,32 +1119,32 @@ export async function handleExternalRequestGenerator(input: ExternalRequestInput
     }
     case 'NETWORK_DEBUGGER': {
       const AiAssistanceModel = await import('../../models/ai_assistance/ai_assistance.js');
-      const conversationHandler = await AiAssistanceModel.ConversationHandler.instance();
+      const conversationHandler = AiAssistanceModel.ConversationHandler.ConversationHandler.instance();
       return await conversationHandler.handleExternalRequest({
-        conversationType: AiAssistanceModel.ConversationType.NETWORK,
+        conversationType: AiAssistanceModel.AiHistoryStorage.ConversationType.NETWORK,
         prompt: input.args.prompt,
         requestUrl: input.args.requestUrl,
       });
     }
     case 'LIVE_STYLE_DEBUGGER': {
       const AiAssistanceModel = await import('../../models/ai_assistance/ai_assistance.js');
-      const conversationHandler = AiAssistanceModel.ConversationHandler.instance();
+      const conversationHandler = AiAssistanceModel.ConversationHandler.ConversationHandler.instance();
       return await conversationHandler.handleExternalRequest({
-        conversationType: AiAssistanceModel.ConversationType.STYLING,
+        conversationType: AiAssistanceModel.AiHistoryStorage.ConversationType.STYLING,
         prompt: input.args.prompt,
         selector: input.args.selector,
       });
     }
   }
   // eslint-disable-next-line require-yield
-  return (async function*
-          (): AsyncGenerator<AiAssistanceModel.ExternalRequestResponse, AiAssistanceModel.ExternalRequestResponse> {
-            return {
-              type: AiAssistanceModel.ExternalRequestResponseType.ERROR,
-              // @ts-expect-error
-              message: `Debugging with an agent of type '${input.kind}' is not implemented yet.`,
-            };
-          })();
+  return (async function*(): AsyncGenerator<
+          AiAssistanceModel.AiAgent.ExternalRequestResponse, AiAssistanceModel.AiAgent.ExternalRequestResponse> {
+    return {
+      type: AiAssistanceModel.AiAgent.ExternalRequestResponseType.ERROR,
+      // @ts-expect-error
+      message: `Debugging with an agent of type '${input.kind}' is not implemented yet.`,
+    };
+  })();
 }
 
 // @ts-expect-error