chrome-devtools-frontend 1.0.1674545 → 1.0.1676824

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

@@ -0,0 +1,104 @@
+// 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 * as i18n from '../../../core/i18n/i18n.js';
+import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  MAX_FUNCTION_RESULT_BYTE_LENGTH,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const UIStringsNotTranslate = {
+  networkActivitySummary: 'Network activity summary',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface GetTraceNetworkSummaryArgs extends ToolArgs {
+  min?: number;
+  max?: number;
+}
+
+export class GetTraceNetworkSummaryTool implements DataTool<GetTraceNetworkSummaryArgs, string, BaseToolCapability> {
+  readonly name = ToolName.GET_TRACE_NETWORK_SUMMARY;
+  readonly description = 'Returns a summary of the network requests for the given bounds.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetTraceNetworkSummaryArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for looking up a network track summary.',
+    nullable: false,
+    properties: {
+      min: {
+        type: Host.AidaClient.ParametersTypes.INTEGER,
+        description: 'The minimum time of the bounds, in microseconds.',
+        nullable: true,
+      },
+      max: {
+        type: Host.AidaClient.ParametersTypes.INTEGER,
+        description: 'The maximum time of the bounds, in microseconds.',
+        nullable: true,
+      },
+    },
+    required: [],
+  };
+
+  displayInfoFromArgs(params: GetTraceNetworkSummaryArgs): {
+    title: string,
+    action: string,
+  } {
+    const parts = [];
+    if (params.min !== undefined) {
+      parts.push(`min: ${params.min}`);
+    }
+    if (params.max !== undefined) {
+      parts.push(`max: ${params.max}`);
+    }
+    return {
+      title: lockedString(UIStringsNotTranslate.networkActivitySummary),
+      action: `getTraceNetworkSummary({${parts.join(', ')}})`,
+    };
+  }
+
+  async handler(
+      params: GetTraceNetworkSummaryArgs,
+      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 bounds = conversationContext.createBounds(params.min, params.max);
+    if (!bounds) {
+      return {error: 'Invalid bounds.'};
+    }
+
+    const formatter = conversationContext.createFormatter();
+    const summary = formatter.formatNetworkTrackSummary(bounds);
+    if (summary.length > MAX_FUNCTION_RESULT_BYTE_LENGTH) {
+      return {
+        error:
+            'getTraceNetworkSummary response is too large. Try investigating using other functions, or a more narrow bounds',
+      };
+    }
+
+    return {
+      result: summary,
+      widgets: [{
+        name: 'NETWORK_TRACK',
+        data: {
+          parsedTrace: focus.parsedTrace,
+          bounds,
+        },
+      }],
+    };
+  }
+}

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

@@ -0,0 +1,81 @@
+// 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 {areOriginsEquivalent, isOpaqueOrigin} from '../AiOrigins.js';
+import {isSamePageOrigin} from '../contexts/StorageContext.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type OriginLockCapability,
+  ToolName,
+} from './Tool.js';
+
+const lockedString = i18n.i18n.lockedString;
+
+export class ListPageOriginsTool implements
+    DataTool<Record<string, never>, {origins: string[]}, BaseToolCapability&OriginLockCapability> {
+  readonly name = ToolName.LIST_PAGE_ORIGINS;
+  readonly description =
+      'Lists all active, non-empty frame origins loaded by the page. Use this first when generic category context is active to discover all page origins, then pass them to listCookies or listStorageKeys, unless the user\'s explicit request hints at focusing only on the primary page.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<never> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: '',
+    nullable: false,
+    properties: {},
+    required: [],
+  };
+
+  displayInfoFromArgs(): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString('Listing page origins'),
+      action: 'listPageOrigins()',
+    };
+  }
+
+  async handler(
+      _args: Record<string, never>,
+      context: BaseToolCapability&OriginLockCapability,
+      ): Promise<DataHandlerResult<{origins: string[]}>> {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    const targetManager = SDK.TargetManager.TargetManager.instance();
+    const primaryPageTarget = targetManager.primaryPageTarget();
+
+    const allowedOrigin = context.getEstablishedOrigin();
+    if (!allowedOrigin || isOpaqueOrigin(allowedOrigin)) {
+      return {error: 'No origin available or not allowed.'};
+    }
+
+    const pageOrigin =
+        primaryPageTarget ? Common.ParsedURL.ParsedURL.extractOrigin(primaryPageTarget.inspectedURL()) : '';
+    const isAllowed = pageOrigin !== '' && areOriginsEquivalent(pageOrigin, allowedOrigin);
+
+    if (!isAllowed) {
+      return {error: 'No origin available or not allowed.'};
+    }
+
+    const origins = new Set<string>();
+    for (const frame of SDK.ResourceTreeModel.ResourceTreeModel.frames(targetManager)) {
+      if (!isSamePageOrigin(frame.resourceTreeModel().target().outermostTarget(), allowedOrigin)) {
+        continue;
+      }
+      const origin = frame.securityOrigin;
+      if (!origin || isOpaqueOrigin(origin) || origins.has(origin)) {
+        continue;
+      }
+      origins.add(origin);
+    }
+
+    return {result: {origins: Array.from(origins)}};
+  }
+}

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/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,13 @@ 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',
 }
 
 /**
@@ -180,6 +192,7 @@ export interface BaseTool<ArgsType extends ToolArgs = ToolArgs> {
       ) => {
     title?: string, thought?: string, action?: string, suggestions?: [string, ...string[]],
   };
+  readonly annotations?: ToolAnnotation[];
 }
 
 /**
@@ -242,3 +255,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

@@ -6,10 +6,17 @@ import {ExecuteJavaScriptTool} from './ExecuteJavaScript.js';
 import {GetElementAccessibilityDetailsTool} from './GetElementAccessibilityDetails.js';
 import {GetLighthouseAuditsTool} from './GetLighthouseAudits.js';
 import {GetNetworkRequestDetailsTool} from './GetNetworkRequestDetails.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 {SelectTraceEventByKeyTool} from './SelectTraceEventByKey.js';
 import {type AllToolsCapabilities, type Tool, type ToolArgs, ToolName} from './Tool.js';
 
 /**
@@ -29,6 +36,13 @@ 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(),
 };
 
 /**

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());