chrome-devtools-frontend 1.0.1636056 → 1.0.1640418

package/front_end/models/live-metrics/web-vitals-injected/web-vitals-injected.ts

@@ -105,7 +105,7 @@ window[Spec.INTERNAL_KILL_SWITCH] = () => {
 
 function sendEventToDevTools(event: Spec.WebVitalsEvent): void {
   const payload = JSON.stringify(event);
-  window[Spec.EVENT_BINDING_NAME](payload);
+  window[Spec.EVENT_BINDING_NAME]?.(payload);
 }
 
 /**

package/front_end/models/stack_trace/DetailedErrorStackParser.ts

@@ -180,7 +180,7 @@ export function parseMessage(stack: string): string {
  */
 export function augmentRawFramesWithScriptIds(
     rawFrames: RawFrame[], protocolStackTrace: Protocol.Runtime.StackTrace): void {
-  for (const rawFrame of rawFrames) {
+  function augmentFrame(rawFrame: RawFrame): void {
     const isWasm = rawFrame.parsedFrameInfo?.isWasm;
     const protocolFrame = protocolStackTrace.callFrames.find(frame => {
       if (isWasm) {
@@ -196,5 +196,13 @@ export function augmentRawFramesWithScriptIds(
       // @ts-expect-error scriptId is a readonly property.
       rawFrame.scriptId = protocolFrame.scriptId;
     }
+
+    if (rawFrame.parsedFrameInfo?.evalOrigin) {
+      augmentFrame(rawFrame.parsedFrameInfo.evalOrigin);
+    }
+  }
+
+  for (const rawFrame of rawFrames) {
+    augmentFrame(rawFrame);
   }
 }

package/front_end/models/stack_trace/StackTraceImpl.ts

@@ -7,7 +7,7 @@ import type * as SDK from '../../core/sdk/sdk.js';
 import type * as Workspace from '../workspace/workspace.js';
 
 import type * as StackTrace from './stack_trace.js';
-import type {FrameNode, ParsedFrameInfo} from './Trie.js';
+import type {EvalOrigin, FrameNode, ParsedFrameInfo} from './Trie.js';
 
 export type AnyStackTraceImpl = StackTraceImpl<FragmentImpl|DebuggableFragmentImpl|ParsedErrorStackFragmentImpl>;
 
@@ -102,6 +102,28 @@ export class FrameImpl implements StackTrace.StackTrace.Frame {
   }
 }
 
+/**
+ * Converts the internal recursive `EvalOrigin` trie representation into the public-facing
+ * linear `ParsedErrorStackFrameImpl` representation.
+ *
+ * NOTE: The V8 Error#stack format only allows serializing a single location descriptor
+ * per nested eval origin level (e.g. `eval at functionName (location)`). Therefore, the
+ * public-facing API only surfaces the top-most logical frame (`evalOrigin.frames[0]`) at each
+ * eval level. Any other inlined caller frames at that specific level are technically dropped
+ * in the public API, but they are fully preserved in the internal trie representation for
+ * debugging, navigation, and ignore list correlation.
+ */
+function createParsedErrorStackFrameImplFromEvalOrigin(
+    evalOrigin: EvalOrigin|undefined, parsedFrameInfo?: ParsedFrameInfo): ParsedErrorStackFrameImpl|undefined {
+  if (!evalOrigin || evalOrigin.frames.length === 0) {
+    return undefined;
+  }
+  const frame = evalOrigin.frames[0];
+  const nestedOrigin = createParsedErrorStackFrameImplFromEvalOrigin(
+      evalOrigin.evalOrigin, parsedFrameInfo?.evalOrigin?.parsedFrameInfo);
+  return new ParsedErrorStackFrameImpl(frame, parsedFrameInfo?.evalOrigin?.parsedFrameInfo, nestedOrigin);
+}
+
 export class ParsedErrorStackFragmentImpl implements StackTrace.StackTrace.ParsedErrorStackFragment {
   constructor(readonly fragment: FragmentImpl) {
   }
@@ -114,8 +136,9 @@ export class ParsedErrorStackFragmentImpl implements StackTrace.StackTrace.Parse
     const frames: ParsedErrorStackFrameImpl[] = [];
 
     for (const node of this.fragment.node.getCallStack()) {
+      const evalOrigin = createParsedErrorStackFrameImplFromEvalOrigin(node.evalOrigin, node.parsedFrameInfo);
       for (const frame of node.frames) {
-        frames.push(new ParsedErrorStackFrameImpl(frame, node.parsedFrameInfo, node.evalOriginFrames));
+        frames.push(new ParsedErrorStackFrameImpl(frame, node.parsedFrameInfo, evalOrigin));
       }
     }
 
@@ -126,12 +149,12 @@ export class ParsedErrorStackFragmentImpl implements StackTrace.StackTrace.Parse
 export class ParsedErrorStackFrameImpl implements StackTrace.StackTrace.ParsedErrorStackFrame {
   readonly #frame: FrameImpl;
   readonly #parsedFrameInfo?: ParsedFrameInfo;
-  readonly #evalOriginFrames?: FrameImpl[];
+  readonly #evalOrigin?: ParsedErrorStackFrameImpl;
 
-  constructor(frame: FrameImpl, parsedFrameInfo?: ParsedFrameInfo, evalOriginFrames?: FrameImpl[]) {
+  constructor(frame: FrameImpl, parsedFrameInfo?: ParsedFrameInfo, evalOrigin?: ParsedErrorStackFrameImpl) {
     this.#frame = frame;
     this.#parsedFrameInfo = parsedFrameInfo;
-    this.#evalOriginFrames = evalOriginFrames;
+    this.#evalOrigin = evalOrigin;
   }
 
   get url(): string|undefined {
@@ -166,10 +189,7 @@ export class ParsedErrorStackFrameImpl implements StackTrace.StackTrace.ParsedEr
     return this.#parsedFrameInfo?.isEval;
   }
   get evalOrigin(): ParsedErrorStackFrameImpl|undefined {
-    if (!this.#evalOriginFrames || this.#evalOriginFrames.length === 0) {
-      return undefined;
-    }
-    return new ParsedErrorStackFrameImpl(this.#evalOriginFrames[0], this.#parsedFrameInfo?.evalOrigin?.parsedFrameInfo);
+    return this.#evalOrigin;
   }
   get isWasm(): boolean|undefined {
     return this.#parsedFrameInfo?.isWasm;

package/front_end/models/stack_trace/StackTraceModel.ts

@@ -18,7 +18,7 @@ import {
   ParsedErrorStackFragmentImpl,
   StackTraceImpl
 } from './StackTraceImpl.js';
-import {type FrameNode, type RawFrame, Trie} from './Trie.js';
+import {EvalOrigin, type FrameNode, type RawFrame, Trie} from './Trie.js';
 
 /**
  * A stack trace translation function.
@@ -135,7 +135,6 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
       stackTraceOrPausedEvent: Protocol.Runtime.StackTrace|SDK.DebuggerModel.DebuggerPausedDetails,
       rawFramesToUIFrames: TranslateRawFrames): Promise<AsyncFragmentImpl[]> {
     const asyncFragments: Array<Promise<AsyncFragmentImpl>> = [];
-
     const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel);
     if (debuggerModel) {
       for await (
@@ -185,15 +184,16 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
     const uiFrames = await rawFramesToUIFrames(rawFrames, this.target());
     console.assert(rawFrames.length === uiFrames.length, 'Broken rawFramesToUIFrames implementation');
 
-    const evalOriginPromises: Array<ReturnType<TranslateRawFrames>> = [];
+    const evalOriginPromises: Array<Promise<EvalOrigin|undefined>> = [];
     for (const node of fragment.node.getCallStack()) {
       if (node.parsedFrameInfo?.evalOrigin) {
         // Evaluate each eval origin individually, as they are not a contiguous stack trace.
-        evalOriginPromises.push(rawFramesToUIFrames([node.parsedFrameInfo.evalOrigin], this.target()));
+        evalOriginPromises.push(
+            translateEvalOrigin(node.parsedFrameInfo.evalOrigin, rawFramesToUIFrames, this.target()));
       }
     }
 
-    const evalUiFrames = await Promise.all(evalOriginPromises);
+    const evalOrigins = await Promise.all(evalOriginPromises);
 
     let i = 0;
     let evalI = 0;
@@ -204,12 +204,7 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
               node.rawFrame.functionName));
 
       if (node.parsedFrameInfo?.evalOrigin) {
-        const evalOriginRawFrame = node.parsedFrameInfo.evalOrigin;
-        // evalUiFrames[evalI] is Array<Array<Frame>>, and since we passed a 1-element array, we take [0]
-        node.evalOriginFrames = evalUiFrames[evalI++][0].map(
-            frame => new FrameImpl(
-                frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo,
-                evalOriginRawFrame.functionName));
+        node.evalOrigin = evalOrigins[evalI++];
       }
     }
   }
@@ -241,4 +236,21 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
   }
 }
 
+async function translateEvalOrigin(
+    rawFrame: RawFrame, rawFramesToUIFrames: TranslateRawFrames,
+    target: SDK.Target.Target): Promise<EvalOrigin|undefined> {
+  const uiFrames = await rawFramesToUIFrames([rawFrame], target);
+  const frames = uiFrames[0].map(
+      frame => new FrameImpl(
+          frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo,
+          rawFrame.functionName));
+
+  let parentEvalOrigin: EvalOrigin|undefined;
+  if (rawFrame.parsedFrameInfo?.evalOrigin) {
+    parentEvalOrigin = await translateEvalOrigin(rawFrame.parsedFrameInfo.evalOrigin, rawFramesToUIFrames, target);
+  }
+
+  return new EvalOrigin(frames, parentEvalOrigin);
+}
+
 SDK.SDKModel.SDKModel.register(StackTraceModel, {capabilities: SDK.Target.Capability.NONE, autostart: false});

package/front_end/models/stack_trace/Trie.ts

@@ -41,6 +41,16 @@ export function isBuiltinFrame(rawFrame: RawFrame): boolean {
       !Boolean(rawFrame.url);
 }
 
+export class EvalOrigin {
+  readonly frames: FrameImpl[];
+  readonly evalOrigin?: EvalOrigin;
+
+  constructor(frames: FrameImpl[], evalOrigin?: EvalOrigin) {
+    this.frames = frames;
+    this.evalOrigin = evalOrigin;
+  }
+}
+
 interface FrameNodeBase<ChildT, ParentT> {
   readonly parent: ParentT;
   readonly children: ChildT[];
@@ -58,7 +68,7 @@ export class FrameNode implements FrameNodeBase<FrameNode, AnyFrameNode> {
 
   fragment?: FragmentImpl;
   parsedFrameInfo?: ParsedFrameInfo;
-  evalOriginFrames?: FrameImpl[];
+  evalOrigin?: EvalOrigin;
 
   constructor(rawFrame: RawFrame, parent: AnyFrameNode) {
     this.rawFrame = rawFrame;

package/front_end/models/trace/extras/TraceTree.ts

@@ -406,6 +406,17 @@ export class BottomUpRootNode extends Node {
     const eventGroupIdCallback = this.eventGroupIdCallback;
     const forceGroupIdCallback = this.forceGroupIdCallback;
 
+    const idToIsCacheHit = new Map<string, boolean>();
+    for (const e of this.events) {
+      if (Types.Events.isReceivedDataEvent(e) && e.name === 'ResourceReceiveResponse') {
+        let id = generateEventID(e);
+        if (this.forceGroupIdCallback && this.eventGroupIdCallback) {
+          id = `${id}-${this.eventGroupIdCallback(e)}`;
+        }
+        idToIsCacheHit.set(id, e.args.data.fromCache || false);
+      }
+    }
+
     // encodedDataLength is provided solely on instant events.
     const sumTransferSizeOfInstantEvent = (e: Types.Events.Event): void => {
       if (Types.Events.isReceivedDataEvent(e)) {
@@ -424,7 +435,15 @@ export class BottomUpRootNode extends Node {
         // ResourceReceivedData events tally up the transfer size over time, but the
         // ResourceReceiveResponse / ResourceFinish events hold the final result.
         if (e.name === 'ResourceReceivedData') {
-          node.transferSize += e.args.data.encodedDataLength;
+          if (idToIsCacheHit.get(id)) {
+            // It's a cache hit, so the actual network transfer size is 0.
+            // We overwrite the tallied sum (which is uncompressed body size) with 0.
+            node.transferSize = 0;
+          } else {
+            node.transferSize += e.args.data.encodedDataLength;
+          }
+        } else if (e.name === 'ResourceFinish' && e.args.data.encodedDataLength === 0 && idToIsCacheHit.get(id)) {
+          node.transferSize = 0;
         } else if (e.args.data.encodedDataLength > 0) {
           // For some reason, ResourceFinish can be zero even if data was sent.
           // Ignore that case.

package/front_end/models/trace/insights/Common.ts

@@ -417,6 +417,15 @@ export function calculateDocFirstByteTs(docRequest: Types.Events.SyntheticNetwor
     return docRequest.ts;
   }
 
+  // @ts-expect-error
+  const isLightrider = globalThis.isLightrider;
+  if (isLightrider) {
+    const lrServerResponseTime = docRequest.args.data.lrServerResponseTime;
+    if (lrServerResponseTime !== undefined) {
+      return Types.Timing.Micro(docRequest.ts + Helpers.Timing.milliToMicro(lrServerResponseTime));
+    }
+  }
+
   const timing = docRequest.args.data.timing;
   if (!timing) {
     // Older traces do not have timings.

package/front_end/models/trace/lantern/core/NetworkAnalyzer.ts

@@ -4,8 +4,6 @@
 
 import type * as Lantern from '../types/types.js';
 
-import {LanternError} from './LanternError.js';
-
 class UrlUtils {
   /**
    * There is fancy URL rewriting logic for the chrome://settings page that we need to work around.
@@ -100,6 +98,12 @@ class NetworkAnalyzer {
     const grouped = new Map();
     records.forEach(item => {
       const key = item.parsedURL.securityOrigin;
+
+      // We never care about requests for extensions.
+      if (key.startsWith('chrome-extension:')) {
+        return;
+      }
+
       const group = grouped.get(key) || [];
       group.push(item);
       grouped.set(key, group);
@@ -458,30 +462,25 @@ class NetworkAnalyzer {
       }
     }
 
-    if (!estimatesByOrigin.size) {
-      throw new LanternError('No timing information available');
-    }
     return NetworkAnalyzer.summarize(estimatesByOrigin);
   }
 
+  static estimateMinimumRTTByOrigin(records: Lantern.NetworkRequest[], options?: RTTEstimateOptions):
+      Map<string, number> {
+    const rttByOrigin = new Map<string, number>();
+    for (const [origin, summary] of NetworkAnalyzer.estimateRTTByOrigin(records, options).entries()) {
+      rttByOrigin.set(origin, summary.min);
+    }
+    return rttByOrigin;
+  }
+
   /**
-   * Estimates the server response time of each origin. RTT times can be passed in or will be
-   * estimated automatically if not provided.
+   * Estimates the server response time of each origin. RTT times must be passed in.
    */
-  static estimateServerResponseTimeByOrigin(records: Lantern.NetworkRequest[], options?: RTTEstimateOptions&{
-    rttByOrigin?: Map<string, number>,
+  static estimateServerResponseTimeByOrigin(records: Lantern.NetworkRequest[], options: {
+    rttByOrigin: Map<string, number>,
   }): Map<string, Summary> {
-    let rttByOrigin = options?.rttByOrigin;
-    if (!rttByOrigin) {
-      rttByOrigin = new Map();
-
-      const rttSummaryByOrigin = NetworkAnalyzer.estimateRTTByOrigin(records, options);
-      for (const [origin, summary] of rttSummaryByOrigin.entries()) {
-        rttByOrigin.set(origin, summary.min);
-      }
-    }
-
-    const estimatesByOrigin = NetworkAnalyzer.estimateResponseTimeByOrigin(records, rttByOrigin);
+    const estimatesByOrigin = NetworkAnalyzer.estimateResponseTimeByOrigin(records, options.rttByOrigin);
     return NetworkAnalyzer.summarize(estimatesByOrigin);
   }
 
@@ -546,14 +545,11 @@ class NetworkAnalyzer {
   static computeRTTAndServerResponseTime(records: Lantern.NetworkRequest[]):
       {rtt: number, additionalRttByOrigin: Map<string, number>, serverResponseTimeByOrigin: Map<string, number>} {
     // First pass compute the estimated observed RTT to each origin's servers.
-    const rttByOrigin = new Map<string, number>();
-    for (const [origin, summary] of NetworkAnalyzer.estimateRTTByOrigin(records).entries()) {
-      rttByOrigin.set(origin, summary.min);
-    }
+    const rttByOrigin = NetworkAnalyzer.estimateMinimumRTTByOrigin(records);
 
     // We'll use the minimum RTT as the assumed connection latency since we care about how much addt'l
     // latency each origin introduces as Lantern will be simulating with its own connection latency.
-    const minimumRtt = Math.min(...Array.from(rttByOrigin.values()));
+    const minimumRtt = rttByOrigin.size ? Math.min(...Array.from(rttByOrigin.values())) : 0;
     // We'll use the observed RTT information to help estimate the server response time
     const responseTimeSummaries = NetworkAnalyzer.estimateServerResponseTimeByOrigin(records, {
       rttByOrigin,

package/front_end/panels/ai_assistance/AiAssistancePanel.ts

@@ -185,6 +185,10 @@ const UIStringsNotTranslate = {
    * @description Placeholder text for the chat UI input with branding Gemini (do not translate)
    */
   inputPlaceholderForNoContextBranded: 'Ask Gemini',
+  /**
+   * @description Placeholder text for the chat UI input when AIAgent2 is enabled.
+   */
+  inputPlaceholderForV2: 'Ask a question (AIAgent2 enabled)',
   /**
    * @description Disclaimer text right after the chat input.
    */
@@ -332,13 +336,6 @@ async function getEmptyStateSuggestions(conversation?: AiAssistanceModel.AiConve
         {title: 'What performance issues exist with my page?', jslogContext: 'performance-default'},
       ];
     }
-    case AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT: {
-      return [
-        {title: 'Why did the code pause here?'},
-        {title: 'What function does this breakpoint belong to?'},
-        {title: 'Why is this error thrown?'},
-      ];
-    }
 
     case AiAssistanceModel.AiHistoryStorage.ConversationType.NONE: {
       return [
@@ -383,9 +380,8 @@ function getMarkdownRenderer(conversation?: AiAssistanceModel.AiConversation.AiC
     return new StylingAgentMarkdownRenderer(mainFrameId);
   } else if (conversation?.type === AiAssistanceModel.AiHistoryStorage.ConversationType.ACCESSIBILITY) {
     const domModel = SDK.TargetManager.TargetManager.instance().primaryPageTarget()?.model(SDK.DOMModel.DOMModel);
-    const resourceTreeModel = domModel?.target().model(SDK.ResourceTreeModel.ResourceTreeModel);
-    const mainFrameId = resourceTreeModel?.mainFrame?.id;
-    return new AccessibilityAgentMarkdownRenderer(mainFrameId);
+    const mainDocumentURL = domModel?.existingDocument()?.documentURL;
+    return new AccessibilityAgentMarkdownRenderer(mainDocumentURL);
   }
 
   return new MarkdownRendererWithCodeBlock();
@@ -526,8 +522,7 @@ function defaultView(input: ViewInput, output: PanelViewOutput, target: HTMLElem
     }
   }
 
-  if (Root.Runtime.hostConfig.devToolsAiAssistanceV2?.enabled ||
-    Greendev.Prototypes.instance().isEnabled('breakpointDebuggerAgent')) {
+  if (Root.Runtime.hostConfig.devToolsAiAssistanceV2?.enabled) {
 
     const shouldShowWalkthrough = input.state === ViewState.CHAT_VIEW && input.props.walkthrough.isExpanded;
     /**
@@ -590,14 +585,6 @@ function createFileContext(file: Workspace.UISourceCode.UISourceCode|null): AiAs
   return new AiAssistanceModel.FileAgent.FileContext(file);
 }
 
-function createBreakpointContext(uiLocation: Workspace.UISourceCode.UILocation|null):
-    AiAssistanceModel.BreakpointDebuggerAgent.BreakpointContext|null {
-  if (!uiLocation) {
-    return null;
-  }
-  return new AiAssistanceModel.BreakpointDebuggerAgent.BreakpointContext(uiLocation);
-}
-
 function createAccessibilityContext(report: LighthousePanel.LighthousePanel.ActiveLighthouseReport|null):
     AiAssistanceModel.AccessibilityAgent.AccessibilityContext|null {
   if (!report) {
@@ -684,7 +671,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
   #selectedElement: AiAssistanceModel.StylingAgent.NodeContext|null = null;
   #selectedPerformanceTrace: AiAssistanceModel.PerformanceAgent.PerformanceTraceContext|null = null;
   #selectedRequest: AiAssistanceModel.NetworkAgent.RequestContext|null = null;
-  #selectedBreakpoint: AiAssistanceModel.BreakpointDebuggerAgent.BreakpointContext|null = null;
+
   #selectedAccessibility: AiAssistanceModel.AccessibilityAgent.AccessibilityContext|null = null;
   #selectedStorage: AiAssistanceModel.StorageAgent.StorageContext|null = null;
 
@@ -1017,10 +1004,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
       targetConversationType = AiAssistanceModel.AiHistoryStorage.ConversationType.STYLING;
     } else if (isNetworkPanelVisible && hostConfig.devToolsAiAssistanceNetworkAgent?.enabled) {
       targetConversationType = AiAssistanceModel.AiHistoryStorage.ConversationType.NETWORK;
-    } else if (
-        isSourcesPanelVisible &&
-        this.#conversation?.type === AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT) {
-      targetConversationType = AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT;
+
     } else if (isSourcesPanelVisible && hostConfig.devToolsAiAssistanceFileAgent?.enabled) {
       targetConversationType = AiAssistanceModel.AiHistoryStorage.ConversationType.FILE;
     } else if (isPerformancePanelVisible && hostConfig.devToolsAiAssistancePerformanceAgent?.enabled) {
@@ -1127,30 +1111,6 @@ export class AiAssistancePanel extends UI.Panel.Panel {
     this.requestUpdate();
   }
 
-  async handleBreakpointConversation(uiLocation: Workspace.UISourceCode.UILocation, errorMsg?: string): Promise<void> {
-    const context = new AiAssistanceModel.BreakpointDebuggerAgent.BreakpointContext(uiLocation);
-    this.#selectedBreakpoint = context;
-    const conversation = new AiAssistanceModel.AiConversation.AiConversation({
-      type: AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT,
-      data: [],
-      isReadOnly: false,
-      aidaClient: this.#aidaClient,
-      changeManager: this.#changeManager,
-      isExternal: false,
-      performanceRecordAndReload: this.#handlePerformanceRecordAndReload.bind(this),
-      onInspectElement: this.#handleInspectElement.bind(this),
-      networkTimeCalculator: NetworkPanel.NetworkPanel.NetworkPanel.instance().networkLogView.timeCalculator(),
-      lighthouseRecording: this.#handleLighthouseRun.bind(this),
-    });
-    this.#updateConversationState(conversation);
-    this.#conversation?.setContext(context);
-    this.requestUpdate();
-    await UI.ViewManager.ViewManager.instance().showView(AiAssistancePanel.panelName);
-    const prompt = errorMsg ? `debug the error "${errorMsg}" using breakpoint debugging agent` :
-                              'debug the error using breakpoint debugging agent';
-    await this.#startConversation(prompt);
-  }
-
   override wasShown(): void {
     super.wasShown();
     this.#viewOutput.chatView?.restoreScrollPosition();
@@ -1163,8 +1123,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
     this.#selectedPerformanceTrace =
         createPerformanceTraceContext(UI.Context.Context.instance().flavor(AiAssistanceModel.AIContext.AgentFocus));
     this.#selectedFile = createFileContext(UI.Context.Context.instance().flavor(Workspace.UISourceCode.UISourceCode));
-    this.#selectedBreakpoint =
-        createBreakpointContext(UI.Context.Context.instance().flavor(Workspace.UISourceCode.UILocation));
+
     this.#selectedAccessibility = createAccessibilityContext(
         UI.Context.Context.instance().flavor(LighthousePanel.LighthousePanel.ActiveLighthouseReport));
     this.#selectedStorage =
@@ -1186,8 +1145,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
 
     UI.Context.Context.instance().addFlavorChangeListener(
         Workspace.UISourceCode.UISourceCode, this.#handleUISourceCodeFlavorChange);
-    UI.Context.Context.instance().addFlavorChangeListener(
-        Workspace.UISourceCode.UILocation, this.#handleBreakpointFlavorChange);
+
     UI.Context.Context.instance().addFlavorChangeListener(
         LighthousePanel.LighthousePanel.ActiveLighthouseReport, this.#handleLighthouseReportFlavorChange);
 
@@ -1328,17 +1286,6 @@ export class AiAssistancePanel extends UI.Panel.Panel {
         this.#updateConversationState(this.#conversation);
       };
 
-  #handleBreakpointFlavorChange =
-      (ev: Common.EventTarget.EventTargetEvent<Workspace.UISourceCode.UILocation>): void => {
-        const newBreakpoint = ev.data;
-
-        if (!newBreakpoint || this.#selectedBreakpoint?.getItem() === newBreakpoint) {
-          return;
-        }
-        this.#selectedBreakpoint = new AiAssistanceModel.BreakpointDebuggerAgent.BreakpointContext(newBreakpoint);
-        this.#updateConversationState(this.#conversation);
-      };
-
   #handleLighthouseReportFlavorChange =
       (ev: Common.EventTarget.EventTargetEvent<LighthousePanel.LighthousePanel.ActiveLighthouseReport>): void => {
         const newReport = ev.data;
@@ -1420,6 +1367,10 @@ export class AiAssistancePanel extends UI.Panel.Panel {
       return i18nString(UIStrings.followTheSteps);
     }
 
+    if (Root.Runtime.hostConfig.devToolsAiV2Architecture?.enabled) {
+      return lockedString(UIStringsNotTranslate.inputPlaceholderForV2);
+    }
+
     if (this.#conversation && this.#conversation.isBlockedByOrigin) {
       return lockedString(UIStringsNotTranslate.crossOriginError);
     }
@@ -1447,8 +1398,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
 
         return lockedString(UIStringsNotTranslate.inputPlaceholderForPerformanceWithNoRecording);
       }
-      case AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT:
-        return lockedString(UIStringsNotTranslate.inputPlaceholderForNoContext);
+
       case AiAssistanceModel.AiHistoryStorage.ConversationType.ACCESSIBILITY:
         return this.#conversation.selectedContext ?
             lockedString(UIStringsNotTranslate.inputPlaceholderForAccessibility) :
@@ -1510,8 +1460,6 @@ export class AiAssistancePanel extends UI.Panel.Panel {
         }
         return lockedString(UIStringsNotTranslate.inputDisclaimerForAccessibilityEnterpriseNoLogging);
 
-      case AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT:
-
       case AiAssistanceModel.AiHistoryStorage.ConversationType.STORAGE:
       case AiAssistanceModel.AiHistoryStorage.ConversationType.NONE:
         if (loggingEnabled) {
@@ -1763,8 +1711,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
         return this.#selectedRequest;
       case AiAssistanceModel.AiHistoryStorage.ConversationType.PERFORMANCE:
         return this.#selectedPerformanceTrace;
-      case AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT:
-        return this.#selectedBreakpoint;
+
       case AiAssistanceModel.AiHistoryStorage.ConversationType.ACCESSIBILITY:
         return this.#selectedAccessibility;
       case AiAssistanceModel.AiHistoryStorage.ConversationType.STORAGE:
@@ -1786,8 +1733,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
       this.#selectedRequest = data;
     } else if (data instanceof AiAssistanceModel.PerformanceAgent.PerformanceTraceContext) {
       this.#selectedPerformanceTrace = data;
-    } else if (data instanceof AiAssistanceModel.BreakpointDebuggerAgent.BreakpointContext) {
-      this.#selectedBreakpoint = data;
+
     } else if (data instanceof AiAssistanceModel.AccessibilityAgent.AccessibilityContext) {
       this.#selectedAccessibility = data;
     } else if (data instanceof AiAssistanceModel.StorageAgent.StorageContext) {
@@ -1946,9 +1892,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
             // This ensures that when a user asks a new question, the sidebar updates
             // immediately to show the "loading" state of the new walkthrough.
             const isSidebarWalkthroughOpen = this.#walkthrough.isExpanded && !this.#walkthrough.isInlined;
-            if (isSidebarWalkthroughOpen ||
-                (Greendev.Prototypes.instance().isEnabled('breakpointDebuggerAgent') &&
-                 this.#conversation?.type === AiAssistanceModel.AiHistoryStorage.ConversationType.BREAKPOINT)) {
+            if (isSidebarWalkthroughOpen) {
               this.#openWalkthrough(systemMessage);
             }
             break;

package/front_end/panels/ai_assistance/components/AccessibilityAgentMarkdownRenderer.ts

@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import type * as Platform from '../../../core/platform/platform.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import type * as Protocol from '../../../generated/protocol.js';
+import * as AiAssistanceModel from '../../../models/ai_assistance/ai_assistance.js';
 import type * as Marked from '../../../third_party/marked/marked.js';
 import * as Lit from '../../../ui/lit/lit.js';
 import * as PanelsCommon from '../../common/common.js';
@@ -27,11 +29,16 @@ type ParsedLink = {
 
 export class AccessibilityAgentMarkdownRenderer extends MarkdownRendererWithCodeBlock {
   constructor(
-      private mainFrameId = '',
+      private mainDocumentURL: Platform.DevToolsPath.UrlString = '' as Platform.DevToolsPath.UrlString,
   ) {
     super();
   }
 
+  #isSameOrigin(node: SDK.DOMModel.DOMNode): boolean {
+    const nodeDocumentURL = node.ownerDocument?.documentURL ?? '' as Platform.DevToolsPath.UrlString;
+    return AiAssistanceModel.AiUtils.isSameOrigin(this.mainDocumentURL, nodeDocumentURL);
+  }
+
   override templateForToken(token: Marked.Marked.MarkedToken): Lit.LitTemplate|null {
     if (token.type === 'link' && token.href.startsWith('#')) {
       const parsed = this.#parseLink(token.href);
@@ -98,7 +105,7 @@ export class AccessibilityAgentMarkdownRenderer extends MarkdownRendererWithCode
       return;
     }
 
-    if (node.frameId() !== this.mainFrameId) {
+    if (!this.#isSameOrigin(node)) {
       return;
     }
 
@@ -123,7 +130,7 @@ export class AccessibilityAgentMarkdownRenderer extends MarkdownRendererWithCode
     if (!node) {
       return;
     }
-    if (node.frameId() !== this.mainFrameId) {
+    if (!this.#isSameOrigin(node)) {
       return;
     }
     const linkedNode = PanelsCommon.DOMLinkifier.Linkifier.instance().linkify(node, {textContent: label});