chrome-devtools-frontend 1.0.1675430 → 1.0.1676824

package/front_end/models/ai_assistance/README.md

@@ -1,8 +1,15 @@
 # AI in DevTools
 
-## High level architecture
+## Architecture Overview
 
-When the user interacts with AI via the AI Assistance Panel, they are having a _conversation_ with an agent.
+When the user interacts with AI via the AI Assistance Panel, they are having a _conversation_ with an agent. DevTools currently contains two architectural generations for AI assistance:
+
+- **Legacy V1 (Multi-Agent Architecture)**: Implemented in `agents/`. Each domain is handled by a specialized agent subclass extending `AiAgent` (for example, `PerformanceAgent`, `StylingAgent`, `NetworkAgent`).
+- **AIAgentV2 (Unified Single-Agent Architecture)**: Implemented in `AiAgent2.ts`. We are migrating from the siloed multi-agent architecture to a unified, skill-based single-agent architecture. In V2, a single agent (`AiAgent2`) handles multiple domains by dynamically loading **Skills** (`skills/`) and calling type-safe **Tools** (`tools/`).
+
+Both architectures share the core **Contexts**, **Formatters**, and **Security & Origin Isolation** mechanisms described below.
+
+## Core Concepts & Lifecycle
 
 ### Contexts
 
@@ -24,21 +31,47 @@ Encapsulating prompt formatting and UI generation within the context classes sim
 
 To deal with the work to take an object that is the AI agent's context and turn it into a text representation that can be sent to the AI, we use _formatters_. These are typically classes with `static` methods that can take in objects and return their text representation that we want to pass to the AI.
 
-## Future Architecture (V2) - WIP
+### Lifecycle & Cache Clearing
+
+AI Agents can maintain internal stateful variables to optimize performance or store context (such as stashed tool results, formatters, or instruction flags). However, this state must be carefully managed to prevent security leaks (such as cross-origin data leaks after page navigation) or stale results.
+
+The `AiAgent` base class defines a `clearCache()` method. This method is automatically invoked by the system when:
+- An execution error occurs.
+- The user aborts the execution.
+- A cross-origin navigation is detected (via the top-level origin blocking mechanism).
+
+If you introduce new stateful member variables in an `AiAgent` subclass, you **must** override `clearCache()` to reset them:
+1. Always call `super.clearCache()` to ensure base class cleanup is executed.
+2. Reset any subclass-specific state (such as setting formatters to `null`, clearing lists, or resetting boolean flags).
+
+Example from `PerformanceAgent`:
+```typescript
+  override clearCache(): void {
+    super.clearCache();
+    this.#functionCallCacheForFocus.clear();
+    this.#formatter = null;
+    this.#traceFacts = [];
+    // ... reset other stateful fields
+  }
+```
+
+### Security & Origin Isolation
 
-We are migrating the DevTools AI Assistance from a siloed multi-agent architecture to a unified, skill-based single-agent architecture (`AIAgent2`).
+To prevent prompt injection attacks and cross-origin data leaks, the AI Assistance panel enforces strict origin-lock boundaries:
+
+- **Origin Locking**: Once a conversation session begins, it locks to the origin of the initial data context (e.g. `https://google.com` or a specific file path).
+- **Opaque Origins**: Any origin classified as opaque (e.g. `data:`, `about:`, `detached` nodes, unparsed `undefined://` or empty origins) is blocked from starting AI assistance (`isOpaqueOrigin()`).
+- **File Isolation**: Local files (`file://`) do not share a single wildcard origin. Instead, the path is appended (e.g. `file:///path/to/file.js`) to treat each local file as its own unique origin. Swapping local files in the same conversation is blocked.
+- **Trace Isolation**: Imported performance trace recordings are isolated using the virtual origin `imported-trace://${domain}`. This ensures that loaded local trace files do not share origins with live pages, preventing potential cross-origin prompt injection attacks when switching contexts.
+- **Equivalence**: `areOriginsEquivalent()` ensures opaque origins are never equivalent to anything (including themselves), forcing a conversation reset on transitions.
 
-In this new architecture:
-- A single agent (`AIAgent2`) handles multiple domains.
-- Capabilities are defined as **Skills** in Markdown files.
-- The agent can dynamically load skills as needed via a `learnSkill` tool.
+## AIAgentV2 (Unified Architecture)
 
-This work is currently in progress and behind a feature flag.
+We are migrating DevTools AI Assistance from a siloed multi-agent architecture to a unified, skill-based single-agent architecture (`AiAgent2`). In this new architecture, capabilities are defined as **Skills** in Markdown files, and the agent can dynamically load skills as needed via a `learnSkills` tool.
 
 ### Skills Build System
 
-To support dynamic loading of skills, we generate JavaScript files from Markdown files containing skill definitions.
-We use a nested `BUILD.gn` file in the `skills/` subdirectory specifically for this purpose. This ensures that GN's `target_gen_dir` points to `gen/front_end/models/ai_assistance/skills/`, placing the generated `.skill.js` files in the same relative structure as their source `.md` files. This allows TypeScript files in the `skills/` directory (like `map.ts`) to import the generated files using relative paths (e.g., `./styling.skill.js`) seamlessly. See the [Skills README](skills/README.md) for full details.
+To support dynamic loading of skills, we generate JavaScript files from Markdown files containing skill definitions. We use a nested `BUILD.gn` file in the `skills/` subdirectory specifically for this purpose. This ensures that GN's `target_gen_dir` points to `gen/front_end/models/ai_assistance/skills/`, placing the generated `.skill.js` files in the same relative structure as their source `.md` files. This allows TypeScript files in the `skills/` directory (like `map.ts`) to import the generated files using relative paths (e.g., `./styling.skill.js`) seamlessly. See the [Skills README](skills/README.md) for full details.
 
 ### Tools and ToolRegistry
 
@@ -49,9 +82,13 @@ To support skills requiring execution of code or fetching page state (like compu
 - **Capability Contexts**: Instead of passing a monolithic grab-bag context to all tools, dependencies are broken into narrow capability interfaces (e.g. `PageExecutionCapability`, `StyleMutationCapability`, `TargetCapability`, `OriginLockCapability`). Tools declare their required dependencies by intersecting these interfaces on their generic `ContextType` definition. The caller/Agent fulfills the complete capability context (`AllToolsCapabilities`), guaranteeing 100% compile-time type safety for dependencies without runtime checks.
 - **ToolRegistry**: A static registry (`ToolRegistry`) storing instantiated tools. It uses TypeScript function overloading and generic lookups (`static get<K extends keyof typeof TOOLS>(name: K): typeof TOOLS[K]`) to return the precise class type of each tool, preventing type-erasure and escape-hatches (such as `any` or `as unknown` type assertions) at integration points like `AiAgent2.ts`. See the [Tools README](tools/README.md) for authoring instructions.
 
-## Performance specific documentation
+### Adding a new skill
+
+See the [Skills README](skills/README.md) for detailed instructions.
 
-### `PerformanceTraceContext`
+## Extending Domain Support (Performance Insights)
+
+### PerformanceTraceContext
 
 The context for `PerformanceAgent` is `PerformanceTraceContext`, which wraps `AgentFocus`. `AgentFocus` supports different behavior for different entry-points of the "Ask AI" feature for a trace (such as a specific performance insight, flame chart call tree, trace event, or the whole parsed trace). `PerformanceTraceContext` implements `ConversationContext<AgentFocus>` to fetch prompt details, user-facing accordion details, and context-specific AI suggestions.
 
@@ -73,16 +110,15 @@ In general, the trace bounds are defined by the insight's overlays. If there are
 
 See the `insightBounds` function in `InsightAIContext.ts`.
 
-
 ### Testing the new Insight
 
 Once it's working, it's a good idea to manually experiment with the new Insight and ask a bunch of questions on different traces. Try to find (or create) websites that cause the insight to identify a variety of outputs and see how far you can push the AI. Look for instances where you can perhaps clarify the data you are passing into it, or tweak your wording, to try to make it clearer. You can also take the data you are sending and paste it into Gemini to get feedback on your prompt from the AI.
 
 (We are working on a better, more automated way, of evaluating these responses).
 
-## Debugging tips
+## Debugging & Local Development
 
-To test the AI code, you must be running DevTools in a branded Chrome (e.g. official Chrome Canary) and be signed in. You can use the `npm start` with a canary flag in this repository to run against Chromium, or by running Chrome Canary and pointing it to your local DevTools.":
+To test the AI code, you must be running DevTools in a branded Chrome (e.g. official Chrome Canary) and be signed in. You can use the `npm start` with a canary flag in this repository to run against Chromium, or by running Chrome Canary and pointing it to your local DevTools:
 
 ```
 npm start -- --browser=canary
@@ -108,13 +144,3 @@ Now, when interacting with the AI and sending requests, you will see output logg
 ### Testing the Accessibility Skill
 
 The accessibility skill (`accessibility.md`) relies on an active Lighthouse report. Before interacting with the agent using this skill, ensure you have run a Lighthouse audit on the page you are inspecting so that the `getLighthouseAudits` tool can retrieve the report data.
-
-## Security & Origin Isolation
-
-To prevent prompt injection attacks and cross-origin data leaks, the AI Assistance panel enforces strict origin-lock boundaries:
-
-*   **Origin Locking**: Once a conversation session begins, it locks to the origin of the initial data context (e.g. `https://google.com` or a specific file path).
-*   **Opaque Origins**: Any origin classified as opaque (e.g. `data:`, `about:`, `detached` nodes, unparsed `undefined://` or empty origins) is blocked from starting AI assistance (`isOpaqueOrigin()`).
-*   **File Isolation**: Local files (`file://`) do not share a single wildcard origin. Instead, the path is appended (e.g. `file:///path/to/file.js`) to treat each local file as its own unique origin. Swapping local files in the same conversation is blocked.
-*   **Trace Isolation**: Imported performance trace recordings are isolated using the virtual origin `imported-trace://${domain}`. This ensures that loaded local trace files do not share origins with live pages, preventing potential cross-origin prompt injection attacks when switching contexts.
-*   **Equivalence**: `areOriginsEquivalent()` ensures opaque origins are never equivalent to anything (including themselves), forcing a conversation reset on transitions.

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

@@ -122,6 +122,10 @@ export interface ActionResponse {
   output?: string;
   canceled: boolean;
   widgets?: AiWidget[];
+  /**
+   * The name of the executed tool. Only populated for AI v2.
+   */
+  toolName?: string;
 }
 
 export interface QueryingResponse {
@@ -161,7 +165,7 @@ export type AllowedOriginResult = {
 
 export interface AgentOptions {
   aidaClient: Host.AidaClient.AidaClient;
-  serverSideLoggingEnabled?: boolean;
+  serverSideLoggingAllowed?: boolean;
   sessionId?: string;
   confirmSideEffectForTest?: typeof Promise.withResolvers;
   onInspectElement?: () => Promise<SDK.DOMModel.DOMNode|null>;
@@ -193,6 +197,14 @@ export abstract class ConversationContext<T> {
   abstract getItem(): T;
   abstract getTitle(): string;
 
+  /**
+   * Returns true if the server-side logging is enabled when this context is active.
+   * Currently only used for AI v2.
+   */
+  isLoggingEnabled(): boolean {
+    return true;
+  }
+
   getOrigin(): string {
     return extractContextOrigin(this.getURL());
   }
@@ -387,10 +399,22 @@ export interface SourceCodeAiWidget {
   };
 }
 
+export interface StorageBreakdownAiWidget {
+  name: 'STORAGE_BREAKDOWN';
+  data: {
+    totalUsageBytes: number,
+    totalQuotaBytes: number,
+    usageBreakdown: Array<{
+      storageType: string,
+      bytes: number,
+    }>,
+  };
+}
+
 export type AiWidget = ComputedStyleAiWidget|CoreVitalsAiWidget|StylePropertiesAiWidget|DomTreeAiWidget|
     PerformanceTraceAiWidget|PerfInsightAiWidget|TimelineRangeSummaryAiWidget|BottomUpTreeAiWidget|SourceFileAiWidget|
     LighthouseReportAiWidget|TimelineEventSummaryAiWidget|NetworkRequestGeneralHeadersAiWidget|SourceCodeAiWidget|
-    SourceFilesListAiWidget|NetworkRequestsListAiWidget|NetworkTrackAiWidget;
+    SourceFilesListAiWidget|NetworkRequestsListAiWidget|NetworkTrackAiWidget|StorageBreakdownAiWidget;
 
 /**
  * @deprecated Used for v1 agents. Once v2 is shipped, this can be removed.
@@ -472,7 +496,16 @@ export abstract class AiAgent<T> {
 
   readonly #sessionId: string;
   readonly #aidaClient: Host.AidaClient.AidaClient;
-  #serverSideLoggingEnabled: boolean;
+  /**
+   * Whether server-side logging is permitted by the system policy (based on
+   * user preferences, feature flags, or branding configurations).
+   */
+  readonly #serverSideLoggingAllowed: boolean;
+  /**
+   * Tracks the dynamic runtime state of logging. Even if logging is allowed
+   * by policy, tools can temporarily deactivate this to avoid logging sensitive data.
+   */
+  #serverSideLoggingActive: boolean;
   readonly confirmSideEffect: typeof Promise.withResolvers;
   readonly #functionDeclarations = new Map<string, FunctionDeclaration<Record<string, unknown>, unknown>>();
   readonly #allowedOrigin?: () => AllowedOriginResult;
@@ -499,13 +532,15 @@ export abstract class AiAgent<T> {
 
   constructor(opts: AgentOptions) {
     this.#aidaClient = opts.aidaClient;
-    this.#serverSideLoggingEnabled = opts.serverSideLoggingEnabled ?? false;
+    let serverSideLoggingAllowed = opts.serverSideLoggingAllowed ?? false;
     // Disable logging for now.
     // For context, see b/454563259#comment35.
     // We should be able to remove this ~end of April.
     if (Root.Runtime.hostConfig.devToolsGeminiRebranding?.enabled) {
-      this.#serverSideLoggingEnabled = false;
+      serverSideLoggingAllowed = false;
     }
+    this.#serverSideLoggingAllowed = serverSideLoggingAllowed;
+    this.#serverSideLoggingActive = serverSideLoggingAllowed;
     this.#sessionId = opts.sessionId ?? crypto.randomUUID();
     this.confirmSideEffect = opts.confirmSideEffectForTest ?? (() => Promise.withResolvers());
     this.#history = opts.history ?? [];
@@ -558,8 +593,17 @@ export abstract class AiAgent<T> {
   clearCache(): void {
   }
 
-  protected disableServerSideLogging(): void {
-    this.#serverSideLoggingEnabled = false;
+  /**
+   * Toggles whether server-side logging is active.
+   * Note that logging can only be activated if it was allowed by policy/configuration
+   * at startup (i.e., `#serverSideLoggingAllowed` is true).
+   */
+  protected setServerSideLoggingActive(active: boolean): void {
+    if (active && this.#serverSideLoggingAllowed) {
+      this.#serverSideLoggingActive = true;
+    } else {
+      this.#serverSideLoggingActive = false;
+    }
   }
 
   popPendingMultimodalInput(): MultimodalInput|undefined {
@@ -618,7 +662,7 @@ export abstract class AiAgent<T> {
         model_id: this.options.modelId || undefined,
       },
       metadata: {
-        disable_user_content_logging: !(this.#serverSideLoggingEnabled ?? false),
+        disable_user_content_logging: !(this.#serverSideLoggingActive ?? false),
         string_session_id: this.#sessionId,
         user_tier: userTier,
         client_version:
@@ -1027,6 +1071,7 @@ export abstract class AiAgent<T> {
         output: typeof result.result === 'string' ? result.result : JSON.stringify(result.result),
         widgets: result.widgets,
         canceled: false,
+        toolName: name,
       };
     }
 
@@ -1036,6 +1081,7 @@ export abstract class AiAgent<T> {
         code,
         output: result.error,
         canceled: false,
+        toolName: name,
       };
     }
 

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

@@ -19,6 +19,7 @@ import {DOMNodeContext} from '../contexts/DOMNodeContext.js';
 import {FileContext} from '../contexts/FileContext.js';
 import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 import {getRequestContextOrigin, RequestContext} from '../contexts/RequestContext.js';
+import {StorageContext} from '../contexts/StorageContext.js';
 import {formatBytesToKb, seconds} from '../data_formatters/UnitFormatters.js';
 import {debugLog} from '../debug.js';
 import {StorageItem} from '../StorageItem.js';
@@ -30,7 +31,6 @@ import {
   type ContextResponse,
   type RequestOptions,
 } from './AiAgent.js';
-import {StorageContext} from './StorageAgent.js';
 
 const lockedString = i18n.i18n.lockedString;
 /**

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

@@ -14,12 +14,11 @@ import * as Tracing from '../../../services/tracing/tracing.js';
 import * as Logs from '../../logs/logs.js';
 import * as Trace from '../../trace/trace.js';
 import {canResourceContentsBeReadForTrace} from '../AiOrigins.js';
-import type {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
-import {sanitizeHeaders} from '../data_formatters/NetworkRequestFormatter.js';
+import type {MainThreadSectionLabel, PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 import {
   PerformanceInsightFormatter,
 } from '../data_formatters/PerformanceInsightFormatter.js';
-import {PerformanceTraceFormatter} from '../data_formatters/PerformanceTraceFormatter.js';
+import {formatEventForAI, PerformanceTraceFormatter} from '../data_formatters/PerformanceTraceFormatter.js';
 import {debugLog} from '../debug.js';
 import {AICallTree} from '../performance/AICallTree.js';
 import type {AgentFocus} from '../performance/AIContext.js';
@@ -49,13 +48,6 @@ const UIStringsNotTranslated = {
 } as const;
 const lockedString = i18n.i18n.lockedString;
 
-/**
- * Labels used to identify specific periods or categories in the trace for getting main thread summary.
- * Supports hardcoded phases, dynamic navigation IDs (`NAVIGATION_X`), and insight models.
- */
-export type MainThreadSectionLabel = 'nav-to-lcp'|'lcp-ttfb'|'lcp-render-delay'|'trace-bounds'|'NO_NAVIGATION'|
-                                     `NAVIGATION_${string}`|keyof Trace.Insights.Types.InsightModels;
-
 /**
  * WARNING: preamble defined in code is only used when userTier is
  * TESTERS. Otherwise, a server-side preamble is used (see
@@ -196,14 +188,6 @@ enum ScorePriority {
 // 16k Tokens * ~4 char per token.
 const MAX_FUNCTION_RESULT_BYTE_LENGTH = 16384 * 4;
 
-const STATIC_LABEL_NAMES: Record<string, string> = {
-  'nav-to-lcp': 'navigation to LCP',
-  'lcp-ttfb': 'LCP to TTFB',
-  'lcp-render-delay': 'LCP render delay',
-  'trace-bounds': 'the entire trace',
-  NO_NAVIGATION: 'the period before the first navigation',
-};
-
 function getInsightModel(
     model: Trace.Insights.Types.InsightModels,
     key: string,
@@ -214,33 +198,6 @@ function getInsightModel(
   return undefined;
 }
 
-/**
- * Converts the label name we use in the code to a human readable one that is
- * shown to the user.
- */
-export function getLabelName(label: MainThreadSectionLabel, focus: AgentFocus): string {
-  if (Object.prototype.hasOwnProperty.call(STATIC_LABEL_NAMES, label)) {
-    return STATIC_LABEL_NAMES[label];
-  }
-
-  const {parsedTrace} = focus;
-  const insightSetById = parsedTrace.insights?.get(label as Trace.Types.Events.NavigationId);
-  if (insightSetById) {
-    return `navigation to ${insightSetById.url.href}`;
-  }
-
-  // Go through all the insights we have to find the first one that matches to find the title.
-  // TODO(b/505291090): make it easier to look up Insight titles from a key.
-  for (const insightSet of parsedTrace.insights?.values() ?? []) {
-    const model = getInsightModel(insightSet.model, label);
-    if (model) {
-      return `${model.title} insight`;
-    }
-  }
-
-  return label;
-}
-
 export interface PerformanceAgentOptions extends AgentOptions {
   tracker?: Tracing.FreshRecording.Tracker;
   networkLog?: Logs.NetworkLog.NetworkLog;
@@ -816,9 +773,8 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
         const insightSet = parsedTrace.insights?.get(params.insightSetId);
         if (!insightSet) {
           const valid = ([...parsedTrace.insights?.values() ?? []])
-                            .map(
-                                insightSet => `id: ${insightSet.id}, url: ${insightSet.url}, bounds: ${
-                                    this.#formatter?.serializeBounds(insightSet.bounds)}`)
+                            .map(insightSet => `id: ${insightSet.id}, url: ${insightSet.url}, bounds: ${
+                                     this.#formatter?.serializeBounds(insightSet.bounds)}`)
                             .join('; ');
           return {error: `Invalid insight set id. Valid insight set ids are: ${valid}`};
         }
@@ -939,20 +895,6 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
       },
     });
 
-    const createBounds =
-        (min?: Trace.Types.Timing.Micro, max?: Trace.Types.Timing.Micro): Trace.Types.Timing.TraceWindowMicro|null => {
-          const {min: bMin, max: bMax} = parsedTrace.data.Meta.traceBounds;
-          const clampedMin = Math.max(min ?? bMin, bMin);
-          const clampedMax = Math.min(max ?? bMax, bMax);
-
-          if (clampedMin > clampedMax) {
-            return null;
-          }
-
-          return Trace.Helpers.Timing.traceWindowFromMicroSeconds(
-              clampedMin as Trace.Types.Timing.Micro, clampedMax as Trace.Types.Timing.Micro);
-        };
-
     this.declareFunction<{label: MainThreadSectionLabel}, {summary: string}>('getMainThreadTrackSummaryByLabel', {
       description:
           'Returns a focused, detailed summary of the main thread for a predefined labeled period. Use this to get more relevant detail than the initial trace summary before diagnosing issues.',
@@ -971,7 +913,7 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
         required: ['label'],
       },
       displayInfoFromArgs: args => {
-        const labelName = getLabelName(args.label, focus);
+        const labelName = context.getLabelName(args.label);
         return {
           title: lockedString(`${UIStringsNotTranslated.mainThreadActivity}: ${labelName}`),
           action: `getMainThreadTrackSummaryByLabel('${args.label}')`,
@@ -980,7 +922,7 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
       handler: async args => {
         debugLog('Function call: getMainThreadTrackSummaryByLabel');
 
-        const bounds = this.#getBoundsForLabel(args.label, focus);
+        const bounds = context.getBoundsForLabel(args.label);
         if (!bounds) {
           return {error: `Invalid label: ${args.label}`};
         }
@@ -1028,7 +970,7 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
           throw new Error('missing formatter');
         }
 
-        const bounds = createBounds(args.min, args.max);
+        const bounds = context.createBounds(args.min, args.max);
         if (!bounds) {
           return {error: 'invalid bounds'};
         }
@@ -1326,67 +1268,6 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
     });
   }
 
-  #getBoundsForLabel(label: MainThreadSectionLabel, focus: AgentFocus): Trace.Types.Timing.TraceWindowMicro|null {
-    const {parsedTrace} = focus;
-    const insightSet = focus.primaryInsightSet;
-
-    if (label === 'nav-to-lcp') {
-      if (insightSet) {
-        const lcp = Trace.Insights.Common.getLCP(insightSet);
-        if (lcp) {
-          return Trace.Helpers.Timing.traceWindowFromMicroSeconds(
-              insightSet.bounds.min, lcp.event.ts as Trace.Types.Timing.Micro);
-        }
-      }
-      return null;
-    }
-
-    if (label === 'lcp-ttfb') {
-      if (insightSet) {
-        const subparts = insightSet.model.LCPBreakdown?.subparts;
-        if (subparts?.ttfb) {
-          return subparts.ttfb;
-        }
-      }
-      return null;
-    }
-
-    if (label === 'lcp-render-delay') {
-      if (insightSet) {
-        const subparts = insightSet.model.LCPBreakdown?.subparts;
-        if (subparts?.renderDelay) {
-          return subparts.renderDelay;
-        }
-      }
-      return null;
-    }
-
-    if (label === 'trace-bounds') {
-      return parsedTrace.data.Meta.traceBounds;
-    }
-
-    const insightSetById = parsedTrace.insights?.get(label as Trace.Types.Events.NavigationId);
-    if (insightSetById) {
-      return insightSetById.bounds;
-    }
-
-    if (insightSet) {
-      const model = getInsightModel(insightSet.model, label);
-      if (model) {
-        return Trace.Insights.Common.insightBounds(model, insightSet.bounds);
-      }
-    }
-
-    for (const is of parsedTrace.insights?.values() ?? []) {
-      const model = getInsightModel(is.model, label);
-      if (model) {
-        return Trace.Insights.Common.insightBounds(model, is.bounds);
-      }
-    }
-
-    return null;
-  }
-
   async #getNetworkRequestImageData(lcpRequest: Trace.Types.Events.SyntheticNetworkRequest):
       Promise<TextUtils.ContentData.ContentData|undefined> {
     const target = this.targetManager.primaryPageTarget();
@@ -1408,71 +1289,3 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
     return undefined;
   }
 }
-
-/**
- * Serializes a trace event to a JSON string for AI consumption,
- * ensuring sensitive data (like headers and raw script source code)
- * is sanitized or redacted.
- */
-function formatEventForAI(event: Trace.Types.Events.Event): string {
-  if (Trace.Types.Events.isSyntheticNetworkRequest(event)) {
-    return JSON.stringify({
-      ...event,
-      args: {
-        ...event.args,
-        data: {
-          ...event.args.data,
-          responseHeaders: event.args.data.responseHeaders ? sanitizeHeaders(event.args.data.responseHeaders) : null,
-        },
-      },
-    });
-  }
-
-  if (Trace.Types.Events.isResourceReceiveResponse(event)) {
-    return JSON.stringify({
-      ...event,
-      args: {
-        ...event.args,
-        data: {
-          ...event.args.data,
-          headers: event.args.data.headers ? sanitizeHeaders(event.args.data.headers) : undefined,
-        },
-      },
-    });
-  }
-
-  if (Trace.Types.Events.isRundownScriptSource(event)) {
-    // Redact sensitive cross-origin script source text.
-    const safeData: Omit<Trace.Types.Events.RundownScriptSource['args']['data'], 'sourceText'> = {
-      isolate: event.args.data.isolate,
-      scriptId: event.args.data.scriptId,
-      length: event.args.data.length,
-    };
-    return JSON.stringify({
-      ...event,
-      args: {
-        ...event.args,
-        data: safeData,
-      },
-    });
-  }
-
-  if (Trace.Types.Events.isRundownScriptSourceLarge(event)) {
-    // Redact sensitive cross-origin script source text.
-    const safeData: Omit<Trace.Types.Events.RundownScriptSourceLarge['args']['data'], 'sourceText'> = {
-      isolate: event.args.data.isolate,
-      scriptId: event.args.data.scriptId,
-      splitIndex: event.args.data.splitIndex,
-      splitCount: event.args.data.splitCount,
-    };
-    return JSON.stringify({
-      ...event,
-      args: {
-        ...event.args,
-        data: safeData,
-      },
-    });
-  }
-
-  return JSON.stringify(event);
-}