chrome-devtools-frontend 1.0.1632065 → 1.0.1635876

package/front_end/models/ai_assistance/agents/ContextSelectionAgent.ts

@@ -20,6 +20,7 @@ import {
   AiAgent,
   type AllowedOriginResult,
   type ContextResponse,
+  isOpaqueOrigin,
   type RequestOptions,
 } from './AiAgent.js';
 import {FileContext} from './FileAgent.js';
@@ -126,6 +127,11 @@ export class ContextSelectionAgent extends AiAgent<never> {
           };
         }
         const origin = allowedOriginResult.origin;
+        if (origin && isOpaqueOrigin(origin)) {
+          return {
+            error: 'No requests recorded by DevTools',
+          };
+        }
 
         let hasCrossOriginRequest = false;
         for (const request of Logs.NetworkLog.NetworkLog.instance().requests()) {
@@ -196,6 +202,11 @@ export class ContextSelectionAgent extends AiAgent<never> {
           };
         }
         const origin = allowedOriginResult.origin;
+        if (origin && isOpaqueOrigin(origin)) {
+          return {
+            error: 'No request found',
+          };
+        }
         const request = Logs.NetworkLog.NetworkLog.instance().requests().find(req => {
           if (req.requestId() !== id) {
             return false;
@@ -235,8 +246,23 @@ export class ContextSelectionAgent extends AiAgent<never> {
         };
       },
       handler: async () => {
+        const allowedOriginResult = this.#allowedOrigin();
+        if ('blocked' in allowedOriginResult) {
+          return {
+            error: 'Cross-origin access blocked due to navigation. Please start a new chat.',
+          };
+        }
+        const origin = allowedOriginResult.origin;
+
         const files: Array<{file: string, id: number | undefined}> = [];
         for (const file of ContextSelectionAgent.getUISourceCodes()) {
+          const fileUrl = file.url();
+          const fileOrigin = Common.ParsedURL.ParsedURL.extractOrigin(fileUrl);
+
+          if (origin && fileOrigin !== origin) {
+            continue;
+          }
+
           files.push({
             file: file.fullDisplayName(),
             id: ContextSelectionAgent.uiSourceCodeId.get(file),
@@ -272,8 +298,22 @@ export class ContextSelectionAgent extends AiAgent<never> {
         };
       },
       handler: async params => {
-        const file = ContextSelectionAgent.getUISourceCodes().find(
-            file => ContextSelectionAgent.uiSourceCodeId.get(file) === params.id);
+        const allowedOriginResult = this.#allowedOrigin();
+        if ('blocked' in allowedOriginResult) {
+          return {
+            error: 'Cross-origin access blocked due to navigation. Please start a new chat.',
+          };
+        }
+        const origin = allowedOriginResult.origin;
+
+        const file = ContextSelectionAgent.getUISourceCodes().find(file => {
+          if (ContextSelectionAgent.uiSourceCodeId.get(file) !== params.id) {
+            return false;
+          }
+          const fileUrl = file.url();
+          const fileOrigin = Common.ParsedURL.ParsedURL.extractOrigin(fileUrl);
+          return !origin || fileOrigin === origin;
+        });
 
         if (!file) {
           return {

package/front_end/models/ai_assistance/agents/GreenDevAgent.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Common from '../../../core/common/common.js';
 import * as Host from '../../../core/host/host.js';
 import * as Root from '../../../core/root/root.js';
 import * as SDK from '../../../core/sdk/sdk.js';
@@ -53,9 +54,9 @@ additional context and resolve the user request.
     directly relevant to the user's problem. Do not get distracted by generic framework
     messages.
 
-6.  **Formulate a Hypothesis**: Based on your code investigation, explain the likely root
-    cause to the user and suggest a concrete fix or next step. If you suspect an issue in a
-    JavaScript function, point it out.
+6.  **Formulate a Hypothesis**: Based on your code investigation, and if you have a promising
+    fix, ALWAYS apply it using the provided 'applyFix' function. If you can identify more than
+    one fix, ask the user which one to apply.
 
 ### Available Information
 
@@ -82,6 +83,7 @@ To help you further, you can call the following functions:
   request list.
 - 'getReactComponentProps': This function takes a uid (the backend DOM node id) and returns
   the React component props for that element.
+- 'applyFix': This function accepts a code diff to apply to the code base.
 
 Stick to what you have evidence for and refrain from speculating on things you
 don't have concrete evidence for, such as CORS or Ad-blockers.
@@ -112,11 +114,38 @@ export class GreenDevContext extends ConversationContext<string> {
   }
 }
 
+export const enum Events {
+  CLI_PROMPT_REQUESTED = 'CliPromptRequested',
+}
+
+export interface EventTypes {
+  [Events.CLI_PROMPT_REQUESTED]: {prompt: string};
+}
+
+export const enum RemoteEndpoint {
+  GEMINI_CLI_SOCKET = 'GeminiCliSocket',
+  ANTIGRAVITY_CLI_SOCKET = 'AntigravityCliSocket',
+}
+
 /**
  * This agent is a general-purpose web page troubleshooting agent for GreenDev
  * prototypes.
  */
 export class GreenDevAgent extends AiAgent<string> {
+  #eventTarget = new Common.ObjectWrapper.ObjectWrapper<EventTypes>();
+
+  addEventListener<T extends keyof EventTypes>(
+      eventType: T, listener: (arg0: Common.EventTarget.EventTargetEvent<EventTypes[T]>) => void,
+      thisObject?: Object): Common.EventTarget.EventDescriptor<EventTypes, T> {
+    return this.#eventTarget.addEventListener(eventType, listener, thisObject);
+  }
+
+  removeEventListener<T extends keyof EventTypes>(
+      eventType: T, listener: (arg0: Common.EventTarget.EventTargetEvent<EventTypes[T]>) => void,
+      thisObject?: Object): void {
+    this.#eventTarget.removeEventListener(eventType, listener, thisObject);
+  }
+
   constructor(options: AgentOptions) {
     super(options);
 
@@ -327,6 +356,38 @@ export class GreenDevAgent extends AiAgent<string> {
         };
       },
     });
+
+    this.declareFunction<{
+      codeSuggestionDiff: string,
+    }>('applyFix', {
+      description: 'Apply a code fix for the user to review.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: false,
+        properties: {
+          codeSuggestionDiff: {
+            type: Host.AidaClient.ParametersTypes.STRING,
+            description: 'The diff of the suggested code change.',
+            nullable: false,
+          },
+        },
+        required: ['codeSuggestionDiff'],
+      },
+      handler: async (params: {codeSuggestionDiff: string}) => {
+        const result = await this.applyFix(params.codeSuggestionDiff);
+        return {
+          result,
+        };
+      },
+    });
+  }
+
+  async applyFix(codeSuggestionDiff: string): Promise<string> {
+    console.warn('[GreenDevAgent] applyFix called with:', codeSuggestionDiff);
+    this.#eventTarget.dispatchEventToListeners(
+        Events.CLI_PROMPT_REQUESTED, {prompt: `Apply this diff:\n${codeSuggestionDiff}`});
+    return 'The fix suggestion has been submitted.';
   }
 
   override preamble = preamble;
@@ -377,8 +438,10 @@ export class GreenDevAgent extends AiAgent<string> {
   }
 
   static isEnabled(): boolean {
-    console.warn('BeyondStyling prototype is enabled:', Greendev.Prototypes.instance().isEnabled('beyondStyling'));
-    return Greendev.Prototypes.instance().isEnabled('beyondStyling');
+    const isGeminiEnabled = Greendev.Prototypes.instance().isEnabled('beyondStylingGemini');
+    const isAntigravityEnabled = Greendev.Prototypes.instance().isEnabled('beyondStylingAntigravity');
+    console.warn('BeyondStyling prototype is enabled:', isGeminiEnabled || isAntigravityEnabled);
+    return isGeminiEnabled || isAntigravityEnabled;
   }
 
   static formatConsoleMessage(message: SDK.ConsoleModel.ConsoleMessage, index: number): string {

package/front_end/models/ai_assistance/agents/GreenDevAgentAntigravityCliSocketClient.ts

@@ -0,0 +1,53 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export class GreenDevAgentAntigravityCliSocketClient {
+  #websocket: WebSocket;
+  sessionReady: Promise<void>;
+  #sessionReadyResolve: ((value: void|PromiseLike<void>) => void)|null = null;
+
+  constructor() {
+    this.sessionReady = new Promise(resolve => {
+      this.#sessionReadyResolve = resolve;
+    });
+    this.#websocket = new WebSocket('ws://localhost:5566');
+    this.#websocket.onopen = this.#onOpen.bind(this);
+    this.#websocket.onmessage = this.#onMessage.bind(this);
+    this.#websocket.onclose = this.#onClose.bind(this);
+    this.#websocket.onerror = this.#onError.bind(this);
+  }
+
+  #onOpen(): void {
+    console.warn('WebSocket connected (Antigravity).');
+    if (this.#sessionReadyResolve) {
+      this.#sessionReadyResolve();
+      this.#sessionReadyResolve = null;
+    }
+  }
+
+  #onMessage(event: MessageEvent): void {
+    console.warn('Antigravity WebSocket message received:', event.data);
+    if (this.#onChunkCallback) {
+      this.#onChunkCallback(event.data);
+    }
+  }
+
+  #onClose(): void {
+    console.warn('WebSocket disconnected (Antigravity).');
+  }
+
+  #onError(error: Event): void {
+    console.error('WebSocket error (Antigravity):', error);
+  }
+
+  #onChunkCallback: ((chunk: string) => void)|null = null;
+
+  sendPrompt(promptText: string, onChunk: (chunk: string) => void): Promise<void> {
+    this.#onChunkCallback = onChunk;
+
+    console.warn(`Sending Antigravity prompt: "${promptText}"`);
+    this.#websocket.send(promptText);
+    return Promise.resolve();
+  }
+}

package/front_end/models/ai_assistance/agents/GreenDevAgentGeminiCliSocketClient.ts

@@ -0,0 +1,117 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export class GreenDevAgentGeminiCliSocketClient {
+  #websocket: WebSocket;
+  #sessionId?: string;
+  #activeMessage = '';
+  #messageLog: string[] = [];
+  #promptResolve: ((response: string) => void)|null = null;
+  sessionReady: Promise<void>;
+  #sessionReadyResolve: ((value: void|PromiseLike<void>) => void)|null = null;
+
+  constructor() {
+    this.sessionReady = new Promise(resolve => {
+      this.#sessionReadyResolve = resolve;
+    });
+    this.#websocket = new WebSocket('ws://localhost:6655');
+    this.#websocket.onopen = this.#onOpen.bind(this);
+    this.#websocket.onmessage = this.#onMessage.bind(this);
+    this.#websocket.onclose = this.#onClose.bind(this);
+    this.#websocket.onerror = this.#onError.bind(this);
+  }
+
+  #onOpen(): void {
+    console.warn('WebSocket connected.');
+    this.#websocket.send(
+        JSON.stringify({jsonrpc: '2.0', method: 'session/new', params: {cwd: '.', mcpServers: []}, id: 14}));
+  }
+
+  #onMessage(event: MessageEvent): void {
+    this.#messageLog.push(event.data);
+
+    try {
+      const data = JSON.parse(event.data);
+
+      if (data?.result?.sessionId && !this.#sessionId) {
+        this.#sessionId = data.result.sessionId;
+        console.warn(`Successfully created new session with ID: ${this.#sessionId}`);
+        if (this.#sessionReadyResolve) {
+          this.#sessionReadyResolve();
+          this.#sessionReadyResolve = null;
+        }
+      }
+
+      const update = data?.params?.update;
+      if (update?.sessionUpdate === 'agent_message_chunk') {
+        this.#activeMessage += update.content?.text || '';
+      }
+
+      if (data?.result?.stopReason) {
+        if (this.#activeMessage) {
+          console.warn(this.#activeMessage);
+        }
+        console.warn(`Stop Reason: ${data.result.stopReason}`, this.#messageLog);
+
+        if (this.#promptResolve) {
+          this.#promptResolve(this.#activeMessage);
+          this.#promptResolve = null;
+        }
+
+        this.#activeMessage = '';
+        this.#messageLog = [];
+      } else if (data?.method === 'session/request_permission') {
+        // TODO(finnur): Needs augmenting once I turn off YOLO in the bridge.
+        this.#websocket.send(JSON.stringify({
+          jsonrpc: '2.0',
+          id: data.id,
+          result: {
+            outcome: {
+              selected: {
+                optionId: 'proceed_always',
+              },
+            },
+          },
+        }));
+      }
+    } catch (e) {
+      // Log the raw data if it's not valid JSON.
+      console.error('Failed to parse WebSocket message or process data:', event.data, e);
+    }
+  }
+
+  #onClose(): void {
+    console.warn('WebSocket disconnected.');
+  }
+
+  #onError(error: Event): void {
+    console.error('WebSocket error:', error);
+  }
+
+  sendPrompt(promptText: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      if (this.#promptResolve) {
+        reject(new Error('Another prompt is already in progress.'));
+        return;
+      }
+      if (!this.#sessionId) {
+        reject(new Error('Cannot send prompt without a session ID.'));
+        return;
+      }
+      this.#promptResolve = resolve;
+
+      console.warn(`Sending prompt: "${promptText}"`);
+      console.warn('Thinking...');
+      this.#websocket.send(JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'session/prompt',
+        params: {
+          prompt: [{type: 'text', text: promptText}],
+          sessionId: this.#sessionId,
+        },
+        id: 15,
+      }));
+    });
+  }
+}

package/front_end/models/ai_assistance/agents/PerformanceAgent.ts

@@ -14,6 +14,7 @@ import * as Logs from '../../logs/logs.js';
 import * as SourceMapScopes from '../../source_map_scopes/source_map_scopes.js';
 import * as TextUtils from '../../text_utils/text_utils.js';
 import * as Trace from '../../trace/trace.js';
+import {sanitizeHeaders} from '../data_formatters/NetworkRequestFormatter.js';
 import {
   PerformanceInsightFormatter,
 } from '../data_formatters/PerformanceInsightFormatter.js';
@@ -1060,7 +1061,35 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
         }
 
         // TODO(b/425270067): Format in the same way that "Summary" detail tab does.
-        const details = JSON.stringify(event);
+        let details;
+        if (Trace.Types.Events.isSyntheticNetworkRequest(event)) {
+          const eventToSerialize = {
+            ...event,
+            args: {
+              ...event.args,
+              data: {
+                ...event.args.data,
+                responseHeaders: event.args.data.responseHeaders ? sanitizeHeaders(event.args.data.responseHeaders) :
+                                                                   null,
+              },
+            },
+          };
+          details = JSON.stringify(eventToSerialize);
+        } else if (Trace.Types.Events.isResourceReceiveResponse(event)) {
+          const eventToSerialize = {
+            ...event,
+            args: {
+              ...event.args,
+              data: {
+                ...event.args.data,
+                headers: event.args.data.headers ? sanitizeHeaders(event.args.data.headers) : undefined,
+              },
+            },
+          };
+          details = JSON.stringify(eventToSerialize);
+        } else {
+          details = JSON.stringify(event);
+        }
 
         const key = `getEventByKey('${params.eventKey}')`;
         this.#cacheFunctionResult(focus, key, details);

package/front_end/models/ai_assistance/ai_assistance.ts

@@ -10,6 +10,8 @@ import * as ContextSelectionAgent from './agents/ContextSelectionAgent.js';
 import * as ConversationSummaryAgent from './agents/ConversationSummaryAgent.js';
 import * as FileAgent from './agents/FileAgent.js';
 import * as GreenDevAgent from './agents/GreenDevAgent.js';
+import * as GreenDevAgentAntigravityCliSocketClient from './agents/GreenDevAgentAntigravityCliSocketClient.js';
+import * as GreenDevAgentGeminiCliSocketClient from './agents/GreenDevAgentGeminiCliSocketClient.js';
 import * as NetworkAgent from './agents/NetworkAgent.js';
 import * as PatchAgent from './agents/PatchAgent.js';
 import * as PerformanceAgent from './agents/PerformanceAgent.js';
@@ -57,6 +59,8 @@ export {
   FileAgent,
   FileFormatter,
   GreenDevAgent,
+  GreenDevAgentAntigravityCliSocketClient,
+  GreenDevAgentGeminiCliSocketClient,
   Injected,
   LighthouseFormatter,
   NetworkAgent,

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

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as Common from '../../../core/common/common.js';
+import type * as CrUXManager from '../../crux-manager/crux-manager.js';
 import * as Trace from '../../trace/trace.js';
 import type {ConversationSuggestions} from '../agents/AiAgent.js';
 import type {AgentFocus} from '../performance/AIContext.js';
@@ -48,8 +49,9 @@ export class PerformanceInsightFormatter {
   #insight: Trace.Insights.Types.InsightModel;
   #parsedTrace: Trace.TraceModel.ParsedTrace;
 
-  constructor(focus: AgentFocus, insight: Trace.Insights.Types.InsightModel) {
-    this.#traceFormatter = new PerformanceTraceFormatter(focus);
+  constructor(
+      focus: AgentFocus, insight: Trace.Insights.Types.InsightModel, deviceScope: CrUXManager.DeviceScope|null = null) {
+    this.#traceFormatter = new PerformanceTraceFormatter(focus, deviceScope);
     this.#insight = insight;
     this.#parsedTrace = focus.parsedTrace;
   }

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

@@ -35,15 +35,17 @@ export class PerformanceTraceFormatter {
   #insightSet: Trace.Insights.Types.InsightSet|null;
   #eventsSerializer: Trace.EventsSerializer.EventsSerializer;
   #formattedFunctionCodes = new Set<string>();
+  #deviceScope: CrUXManager.DeviceScope|null;
   resolveFunctionCode?:
       (url: Platform.DevToolsPath.UrlString, line: number,
        column: number) => Promise<SourceMapScopes.FunctionCodeResolver.FunctionCode|null>;
 
-  constructor(focus: AgentFocus) {
+  constructor(focus: AgentFocus, deviceScope: CrUXManager.DeviceScope|null = null) {
     this.#focus = focus;
     this.#parsedTrace = focus.parsedTrace;
     this.#insightSet = focus.primaryInsightSet;
     this.#eventsSerializer = focus.eventsSerializer;
+    this.#deviceScope = deviceScope;
   }
 
   serializeEvent(event: Trace.Types.Events.Event): string {
@@ -64,7 +66,8 @@ export class PerformanceTraceFormatter {
       return [];
     }
     try {
-      const cruxScope = CrUXManager.CrUXManager.instance().getSelectedScope();
+      const cruxScope: CrUXManager.Scope = this.#deviceScope ? {pageScope: 'url', deviceScope: this.#deviceScope} :
+                                                               CrUXManager.CrUXManager.instance().getSelectedScope();
       const parts: string[] = [];
       const fieldMetrics =
           Trace.Insights.Common.getFieldMetricsForInsightSet(insightSet, this.#parsedTrace.metadata, cruxScope);

package/front_end/models/extensions/RecorderExtensionEndpoint.ts

@@ -2,6 +2,8 @@
 // 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 {PrivateAPI} from './ExtensionAPI.js';
 import {ExtensionEndpoint} from './ExtensionEndpoint.js';
 import {RecorderPluginManager} from './RecorderPluginManager.js';
@@ -10,20 +12,26 @@ export class RecorderExtensionEndpoint extends ExtensionEndpoint {
   private readonly name: string;
   private readonly mediaType?: string;
   private readonly capabilities: PrivateAPI.RecordingExtensionPluginCapability[];
+  readonly #extensionOrigin: Platform.DevToolsPath.UrlString;
 
   constructor(
       name: string, port: MessagePort, capabilities: PrivateAPI.RecordingExtensionPluginCapability[],
-      mediaType?: string) {
+      extensionOrigin: Platform.DevToolsPath.UrlString, mediaType?: string) {
     super(port);
     this.name = name;
     this.mediaType = mediaType;
     this.capabilities = capabilities;
+    this.#extensionOrigin = extensionOrigin;
   }
 
   getName(): string {
     return this.name;
   }
 
+  getOrigin(): Platform.DevToolsPath.UrlString {
+    return this.#extensionOrigin;
+  }
+
   getCapabilities(): PrivateAPI.RecordingExtensionPluginCapability[] {
     return this.capabilities;
   }

package/front_end/models/extensions/RecorderPluginManager.ts

@@ -14,6 +14,7 @@ export interface ViewDescriptor {
   pagePath: string;
   onShown: () => void;
   onHidden: () => void;
+  extensionOrigin: string;
 }
 
 export class RecorderPluginManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {

package/front_end/models/greendev/Prototypes.ts

@@ -9,7 +9,8 @@ let instance: Prototypes|null = null;
 
 export interface GreenDevSettings {
   aiAnnotations: Common.Settings.Setting<boolean>;
-  beyondStyling: Common.Settings.Setting<boolean>;
+  beyondStylingGemini: Common.Settings.Setting<boolean>;
+  beyondStylingAntigravity: Common.Settings.Setting<boolean>;
   breakpointDebuggerAgent: Common.Settings.Setting<boolean>;
   emulationCapabilities: Common.Settings.Setting<boolean>;
 }
@@ -42,10 +43,15 @@ export class Prototypes {
         false,
         Common.Settings.SettingStorageType.LOCAL,
     );
-    const beyondStyling = settings.createSetting(
-        'greendev-beyond-styling-enabled',
+    const beyondStylingGemini = settings.createSetting(
+        'greendev-beyond-styling-gemini-enabled',
         false,
-        Common.Settings.SettingStorageType.LOCAL,
+        Common.Settings.SettingStorageType.GLOBAL,
+    );
+    const beyondStylingAntigravity = settings.createSetting(
+        'greendev-beyond-styling-antigravity-enabled',
+        false,
+        Common.Settings.SettingStorageType.GLOBAL,
     );
     const breakpointDebuggerAgent = settings.createSetting(
         'greendev-breakpoint-debugger-agent-enabled',
@@ -58,6 +64,12 @@ export class Prototypes {
         Common.Settings.SettingStorageType.LOCAL,
     );
 
-    return {aiAnnotations, beyondStyling, breakpointDebuggerAgent, emulationCapabilities};
+    return {
+      aiAnnotations,
+      beyondStylingGemini,
+      beyondStylingAntigravity,
+      breakpointDebuggerAgent,
+      emulationCapabilities
+    };
   }
 }

package/front_end/models/trace/handlers/FramesHandler.ts

@@ -507,26 +507,28 @@ export class TimelineFrameBeginFrameQueue {
   private queueFrames: number[] = [];
 
   // Maps frameSeqId to BeginFrameInfo.
-  private mapFrames: Record<number, BeginFrameInfo> = {};
+  private mapFrames = new Map<number, BeginFrameInfo>();
 
   // Add a BeginFrame to the queue, if it does not already exit.
   addFrameIfNotExists(seqId: number, startTime: Types.Timing.Micro, isDropped: boolean, isPartial: boolean): void {
-    if (!(seqId in this.mapFrames)) {
-      this.mapFrames[seqId] = new BeginFrameInfo(seqId, startTime, isDropped, isPartial);
+    if (!this.mapFrames.has(seqId)) {
+      this.mapFrames.set(seqId, new BeginFrameInfo(seqId, startTime, isDropped, isPartial));
       this.queueFrames.push(seqId);
     }
   }
 
   // Set a BeginFrame in queue as dropped.
   setDropped(seqId: number, isDropped: boolean): void {
-    if (seqId in this.mapFrames) {
-      this.mapFrames[seqId].isDropped = isDropped;
+    const frame = this.mapFrames.get(seqId);
+    if (frame) {
+      frame.isDropped = isDropped;
     }
   }
 
   setPartial(seqId: number, isPartial: boolean): void {
-    if (seqId in this.mapFrames) {
-      this.mapFrames[seqId].isPartial = isPartial;
+    const frame = this.mapFrames.get(seqId);
+    if (frame) {
+      frame.isPartial = isPartial;
     }
   }
 
@@ -535,7 +537,7 @@ export class TimelineFrameBeginFrameQueue {
 
     // Do not visualize this frame in the rare case where the current DrawFrame
     // does not have a corresponding BeginFrame.
-    if (seqId in this.mapFrames) {
+    if (this.mapFrames.has(seqId)) {
       // Pop all BeginFrames before the current frame, and add only the dropped
       // ones in |frames_to_visualize|.
       // Non-dropped frames popped here are BeginFrames that are never
@@ -544,17 +546,21 @@ export class TimelineFrameBeginFrameQueue {
       // be naturally presented as continuationss of other frames.
       while (this.queueFrames[0] !== seqId) {
         const currentSeqId = this.queueFrames[0];
-        if (this.mapFrames[currentSeqId].isDropped) {
-          framesToVisualize.push(this.mapFrames[currentSeqId]);
+        const currentFrame = this.mapFrames.get(currentSeqId);
+        if (currentFrame && currentFrame.isDropped) {
+          framesToVisualize.push(currentFrame);
         }
 
-        delete this.mapFrames[currentSeqId];
+        this.mapFrames.delete(currentSeqId);
         this.queueFrames.shift();
       }
 
       // Pop the BeginFrame associated with the current DrawFrame.
-      framesToVisualize.push(this.mapFrames[seqId]);
-      delete this.mapFrames[seqId];
+      const frame = this.mapFrames.get(seqId);
+      if (frame) {
+        framesToVisualize.push(frame);
+      }
+      this.mapFrames.delete(seqId);
       this.queueFrames.shift();
     }
     return framesToVisualize;

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

@@ -123,6 +123,9 @@ export class AccessibilityAgentMarkdownRenderer extends MarkdownRendererWithCode
     if (!node) {
       return;
     }
+    if (node.frameId() !== this.mainFrameId) {
+      return;
+    }
     const linkedNode = PanelsCommon.DOMLinkifier.Linkifier.instance().linkify(node, {textContent: label});
     return linkedNode;
   }

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

@@ -530,9 +530,11 @@ export class ChatInput extends UI.Widget.Widget implements SDK.TargetManager.Obs
 
   setInputValue(text: string): void {
     if (this.#textAreaRef.value) {
-      this.#textAreaRef.value.value = text;
+      const maxLength = this.#textAreaRef.value.maxLength;
+      const truncatedText = (maxLength >= 0) ? text.substring(0, maxLength) : text;
+      this.#textAreaRef.value.value = truncatedText;
       // Place the cursor at the end of the new value.
-      this.#textAreaRef.value.setSelectionRange(text.length, text.length);
+      this.#textAreaRef.value.setSelectionRange(truncatedText.length, truncatedText.length);
     }
     this.performUpdate();
   }