chrome-devtools-frontend 1.0.1675430 → 1.0.1678416

package/front_end/models/ai_assistance/tools/ListSources.ts

@@ -0,0 +1,116 @@
+// 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.
+
+import * as Common from '../../../core/common/common.js';
+import * as Host from '../../../core/host/host.js';
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as Workspace from '../../workspace/workspace.js';
+import {isOpaqueOrigin} from '../AiOrigins.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type OriginLockCapability,
+  ToolName,
+} from './Tool.js';
+
+const UIStringsNotTranslate = {
+  listingSources: 'Listing workspace sources',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+interface SourceSummary {
+  id: number;
+  name: string;
+}
+
+/**
+ * A tool that lists all network source files in the workspace.
+ * Each file is returned with its displayName and a unique session-based numeric ID.
+ */
+export class ListSourcesTool implements
+    DataTool<Record<string, never>, {files: SourceSummary[]}, BaseToolCapability&OriginLockCapability> {
+  readonly name = ToolName.LIST_SOURCES;
+  readonly description = 'Lists all source files in the workspace with their name and a unique ID.';
+
+  static lastSourceId = 0;
+  static uiSourceCodeId = new WeakMap<Workspace.UISourceCode.UISourceCode, number>();
+
+  static reset(): void {
+    ListSourcesTool.lastSourceId = 0;
+    ListSourcesTool.uiSourceCodeId = new WeakMap();
+  }
+
+  // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+  static getUISourceCodes(workspace: Workspace.Workspace.WorkspaceImpl = Workspace.Workspace.WorkspaceImpl.instance()):
+      Workspace.UISourceCode.UISourceCode[] {
+    const projects =
+        workspace.projects().filter(project => project.type() === Workspace.Workspace.projectTypes.Network);
+    const uiSourceCodes = new Map<string, Workspace.UISourceCode.UISourceCode>();
+
+    for (const project of projects) {
+      for (const uiSourceCode of project.uiSourceCodes()) {
+        if (uiSourceCode.isIgnoreListed()) {
+          continue;
+        }
+        const url = uiSourceCode.url();
+        if (!uiSourceCodes.get(url) || uiSourceCode.contentType().isFromSourceMap()) {
+          uiSourceCodes.set(url, uiSourceCode);
+          if (!ListSourcesTool.uiSourceCodeId.has(uiSourceCode)) {
+            ListSourcesTool.uiSourceCodeId.set(uiSourceCode, ++ListSourcesTool.lastSourceId);
+          }
+        }
+      }
+    }
+
+    return [...uiSourceCodes.values()];
+  }
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<never> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: '',
+    nullable: true,
+    required: [],
+    properties: {},
+  };
+
+  displayInfoFromArgs(): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString(UIStringsNotTranslate.listingSources),
+      action: 'listSources()',
+    };
+  }
+
+  async handler(
+      _params: Record<string, never>,
+      context: BaseToolCapability&OriginLockCapability,
+      ): Promise<DataHandlerResult<{files: SourceSummary[]}>> {
+    const origin = context.getEstablishedOrigin();
+    if (origin && isOpaqueOrigin(origin)) {
+      return {
+        error: 'Opaque origin not allowed',
+      };
+    }
+
+    const files = ListSourcesTool.getUISourceCodes().filter(file => {
+      const fileUrl = file.url();
+      const fileOrigin = Common.ParsedURL.ParsedURL.extractOrigin(fileUrl);
+      return !origin || fileOrigin === origin;
+    });
+
+    return {
+      result: {
+        files: files.map(file => ({
+                           id: ListSourcesTool.uiSourceCodeId.get(file) ?? 0,
+                           name: file.fullDisplayName(),
+                         })),
+      },
+    };
+  }
+}

package/front_end/models/ai_assistance/tools/RunLighthouse.ts

@@ -0,0 +1,89 @@
+// 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.
+
+import * as Host from '../../../core/host/host.js';
+import type * as LHModel from '../../lighthouse/lighthouse.js';
+import {LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type LighthouseCapability,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+export interface RunLighthouseArgs extends ToolArgs {
+  explanation: string;
+  category: LHModel.RunTypes.CategoryId;
+  mode?: LHModel.RunTypes.RunMode;
+}
+
+export class RunLighthouseTool implements
+    DataTool<RunLighthouseArgs, {audits: string}, BaseToolCapability&LighthouseCapability> {
+  readonly name = ToolName.RUN_LIGHTHOUSE;
+  readonly description =
+      'Runs Lighthouse audits on the active page. Supports "navigation" (for full initial page load audits), "snapshot" (for inspecting live in-page modifications without reload), and "timespan" (for interactions).';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof RunLighthouseArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Parameters for running Lighthouse audits.',
+    nullable: false,
+    properties: {
+      explanation: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'Reason for running new audits.',
+        nullable: false,
+      },
+      category: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'Lighthouse category. E.g. "accessibility", "performance".',
+        nullable: false,
+      },
+      mode: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description:
+            'Lighthouse execution mode: "navigation", "snapshot", "timespan". Use "navigation" for initial full audits unless the user requested otherwise or in-page changes are being evaluated. Defaults to "snapshot".',
+        nullable: true,
+      },
+    },
+    required: ['explanation', 'category'],
+  };
+
+  displayInfoFromArgs(params: RunLighthouseArgs): {title: string, thought: string, action: string} {
+    return {
+      title: `Running Lighthouse audits: ${params.category} (${params.mode ?? 'snapshot'})`,
+      thought: params.explanation,
+      action: `runLighthouse('${params.category}', '${params.mode ?? 'snapshot'}')`,
+    };
+  }
+
+  async handler(params: RunLighthouseArgs,
+                context: BaseToolCapability&LighthouseCapability): Promise<DataHandlerResult<{audits: string}>> {
+    if (!context.lighthouseRecording) {
+      return {error: 'Error: Lighthouse recording capability is not available.'};
+    }
+    const mode = params.mode ?? 'snapshot';
+    try {
+      const report = await context.lighthouseRecording({
+        mode,
+        categoryIds: [params.category],
+        isAIControlled: true,
+      });
+      if (!report) {
+        return {error: 'Error: Failed to record new audits.'};
+      }
+
+      const audits = new LighthouseFormatter().audits(report, params.category);
+      const isSnapshot = mode === 'snapshot';
+      return {
+        result: {audits},
+        widgets: [{name: 'LIGHTHOUSE_REPORT', data: {report, snapshotReport: isSnapshot}}],
+      };
+    } catch (err) {
+      return {error: `Error: Failed to record new audits: ${err instanceof Error ? err.message : String(err)}`};
+    }
+  }
+}

package/front_end/models/ai_assistance/tools/SelectTraceEventByKey.ts

@@ -0,0 +1,90 @@
+// 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.
+
+import * as Common from '../../../core/common/common.js';
+import * as Host from '../../../core/host/host.js';
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as SDK from '../../../core/sdk/sdk.js';
+import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const UIStringsNotTranslate = {
+  selectingTraceEvent: 'Selecting trace event',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface SelectTraceEventByKeyArgs extends ToolArgs {
+  eventKey: string;
+}
+
+export class SelectTraceEventByKeyTool implements DataTool<SelectTraceEventByKeyArgs, string, BaseToolCapability> {
+  readonly name = ToolName.SELECT_TRACE_EVENT_BY_KEY;
+  readonly description = 'Selects and reveals a specific event by its key in the Performance panel Flamechart.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof SelectTraceEventByKeyArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for selecting a trace event.',
+    nullable: false,
+    properties: {
+      eventKey: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'The key of the event to select.',
+        nullable: false,
+      },
+    },
+    required: ['eventKey'],
+  };
+
+  displayInfoFromArgs(params: SelectTraceEventByKeyArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString(UIStringsNotTranslate.selectingTraceEvent),
+      action: `selectTraceEventByKey('${params.eventKey}')`,
+    };
+  }
+
+  async handler(
+      params: SelectTraceEventByKeyArgs,
+      capabilities: BaseToolCapability,
+      ): Promise<DataHandlerResult<string>> {
+    const conversationContext = capabilities.conversationContext;
+    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+      return {error: 'Performance trace context is not available.'};
+    }
+
+    const focus = conversationContext.getItem();
+    const event = focus.lookupEvent(params.eventKey);
+    if (!event) {
+      return {error: `Could not find event with key "${params.eventKey}".`};
+    }
+
+    const revealable = new SDK.TraceObject.RevealableEvent(event);
+    try {
+      await Common.Revealer.reveal(revealable);
+    } catch {
+      // A failed reveal should not block returning the selected event context.
+    }
+
+    return {
+      result: 'Event selected',
+      widgets: [{
+        name: 'TIMELINE_EVENT_SUMMARY',
+        data: {
+          event,
+          parsedTrace: focus.parsedTrace,
+        },
+      }],
+    };
+  }
+}

package/front_end/models/ai_assistance/tools/Tool.ts

@@ -140,13 +140,18 @@ export interface PerformanceRecordingCapability {
  * Used by the agent to pass a complete context to any tool type-safely.
  */
 export type AllToolsCapabilities = BaseToolCapability&PageExecutionCapability&StyleMutationCapability&TargetCapability&
-    OriginLockCapability&LighthouseCapability&PerformanceRecordingCapability;
+    OriginLockCapability&LighthouseCapability&PerformanceRecordingCapability&ServerLoggingCapability;
 
 /**
  * Base argument type for AI Tools.
  */
 export type ToolArgs = Record<string, unknown>;
 
+// The maximum size (in bytes) of a function execution result.
+// Approximately 16k tokens at ~4 characters per token, designed to limit
+// result sizes to prevent overloading the LLM's context window.
+export const MAX_FUNCTION_RESULT_BYTE_LENGTH = 16384 * 4;
+
 export const enum ToolName {
   EXECUTE_JAVASCRIPT = 'executeJavaScript',
   GET_STYLES = 'getStyles',
@@ -156,6 +161,17 @@ export const enum ToolName {
   RESOLVE_DEVTOOLS_NODE_PATH = 'resolveDevtoolsNodePath',
   GET_ELEMENT_ACCESSIBILITY_DETAILS = 'getElementAccessibilityDetails',
   RECORD_PERFORMANCE_TRACE = 'recordPerformanceTrace',
+  LIST_PAGE_ORIGINS = 'listPageOrigins',
+  GET_TRACE_EVENT_BY_KEY = 'getTraceEventByKey',
+  SELECT_TRACE_EVENT_BY_KEY = 'selectTraceEventByKey',
+  LIST_SOURCES = 'listSources',
+  GET_SOURCE_CONTENT = 'getSourceContent',
+  GET_TRACE_MAIN_THREAD_SUMMARY = 'getTraceMainThreadSummary',
+  GET_TRACE_NETWORK_SUMMARY = 'getTraceNetworkSummary',
+  RUN_LIGHTHOUSE = 'runLighthouse',
+  GET_DETAILED_CALL_TREE = 'getDetailedCallTree',
+  GET_FUNCTION_CODE = 'getFunctionCode',
+  GET_RESOURCE_CONTENT = 'getResourceContent',
 }
 
 /**
@@ -180,6 +196,7 @@ export interface BaseTool<ArgsType extends ToolArgs = ToolArgs> {
       ) => {
     title?: string, thought?: string, action?: string, suggestions?: [string, ...string[]],
   };
+  readonly annotations?: ToolAnnotation[];
 }
 
 /**
@@ -242,3 +259,11 @@ export type Tool<
     ReturnType = unknown,
     CapabilitiesType extends BaseToolCapability = BaseToolCapability,
     > = DataTool<ArgsType, ReturnType, CapabilitiesType>|ContextTool<ArgsType, ReturnType, CapabilitiesType>;
+
+export interface ServerLoggingCapability {
+  setLoggingEnabled(enabled: boolean): void;
+}
+
+export const enum ToolAnnotation {
+  REDACT_FROM_HISTORY = 'redact-from-history',
+}

package/front_end/models/ai_assistance/tools/ToolRegistry.ts

@@ -3,13 +3,24 @@
 // found in the LICENSE file.
 
 import {ExecuteJavaScriptTool} from './ExecuteJavaScript.js';
+import {GetDetailedCallTreeTool} from './GetDetailedCallTree.js';
 import {GetElementAccessibilityDetailsTool} from './GetElementAccessibilityDetails.js';
+import {GetFunctionCodeTool} from './GetFunctionCode.js';
 import {GetLighthouseAuditsTool} from './GetLighthouseAudits.js';
 import {GetNetworkRequestDetailsTool} from './GetNetworkRequestDetails.js';
+import {GetResourceContentTool} from './GetResourceContent.js';
+import {GetSourceContentTool} from './GetSourceContent.js';
 import {GetStylesTool} from './GetStyles.js';
+import {GetTraceEventByKeyTool} from './GetTraceEventByKey.js';
+import {GetTraceMainThreadSummaryTool} from './GetTraceMainThreadSummary.js';
+import {GetTraceNetworkSummaryTool} from './GetTraceNetworkSummary.js';
 import {ListNetworkRequestsTool} from './ListNetworkRequests.js';
+import {ListPageOriginsTool} from './ListPageOrigins.js';
+import {ListSourcesTool} from './ListSources.js';
 import {RecordPerformanceTraceTool} from './RecordPerformanceTrace.js';
 import {ResolveDevtoolsNodePathTool} from './ResolveDevtoolsNodePath.js';
+import {RunLighthouseTool} from './RunLighthouse.js';
+import {SelectTraceEventByKeyTool} from './SelectTraceEventByKey.js';
 import {type AllToolsCapabilities, type Tool, type ToolArgs, ToolName} from './Tool.js';
 
 /**
@@ -29,6 +40,17 @@ export const TOOLS = {
   [ToolName.RESOLVE_DEVTOOLS_NODE_PATH]: new ResolveDevtoolsNodePathTool(),
   [ToolName.GET_ELEMENT_ACCESSIBILITY_DETAILS]: new GetElementAccessibilityDetailsTool(),
   [ToolName.RECORD_PERFORMANCE_TRACE]: new RecordPerformanceTraceTool(),
+  [ToolName.LIST_PAGE_ORIGINS]: new ListPageOriginsTool(),
+  [ToolName.GET_TRACE_EVENT_BY_KEY]: new GetTraceEventByKeyTool(),
+  [ToolName.SELECT_TRACE_EVENT_BY_KEY]: new SelectTraceEventByKeyTool(),
+  [ToolName.LIST_SOURCES]: new ListSourcesTool(),
+  [ToolName.GET_SOURCE_CONTENT]: new GetSourceContentTool(),
+  [ToolName.GET_TRACE_MAIN_THREAD_SUMMARY]: new GetTraceMainThreadSummaryTool(),
+  [ToolName.GET_TRACE_NETWORK_SUMMARY]: new GetTraceNetworkSummaryTool(),
+  [ToolName.RUN_LIGHTHOUSE]: new RunLighthouseTool(),
+  [ToolName.GET_DETAILED_CALL_TREE]: new GetDetailedCallTreeTool(),
+  [ToolName.GET_FUNCTION_CODE]: new GetFunctionCodeTool(),
+  [ToolName.GET_RESOURCE_CONTENT]: new GetResourceContentTool(),
 };
 
 /**

package/front_end/models/bindings/CSSWorkspaceBinding.ts

@@ -143,6 +143,10 @@ export class CSSWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<S
     }
     return rawLocations;
   }
+
+  sourceMapURLsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.UrlString[] {
+    return SASSSourceMapping.sourceMapURLsForUISourceCode(uiSourceCode);
+  }
 }
 
 export interface SourceMapping {

package/front_end/models/bindings/CompilerScriptMapping.ts

@@ -577,6 +577,10 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     return scripts;
   }
 
+  sourceMapURLsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.UrlString[] {
+    return [...this.#uiSourceCodeToSourceMaps.get(uiSourceCode)].map(sourceMap => sourceMap.url());
+  }
+
   private sourceMapAttachedForTest(_sourceMap: SDK.SourceMap.SourceMap): void {
   }
 

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -463,6 +463,14 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     return [...scripts];
   }
 
+  sourceMapURLsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.UrlString[] {
+    const urls = new Set<Platform.DevToolsPath.UrlString>();
+    for (const modelData of this.#debuggerModelToData.values()) {
+      modelData.compilerMapping.sourceMapURLsForUISourceCode(uiSourceCode).forEach(url => urls.add(url));
+    }
+    return [...urls];
+  }
+
   supportsConditionalBreakpoints(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
     const scripts = this.pluginManager.scriptsForUISourceCode(uiSourceCode);
     return scripts.every(script => script.isJavaScript());