chrome-devtools-frontend 1.0.1675430 → 1.0.1678416

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

@@ -0,0 +1,127 @@
+// 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 type * as Platform from '../../../core/platform/platform.js';
+import * as Root from '../../../core/root/root.js';
+import * as SDK from '../../../core/sdk/sdk.js';
+import * as TextUtils from '../../../core/text_utils/text_utils.js';
+import {canResourceContentsBeReadForTrace} from '../AiOrigins.js';
+import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type TargetCapability,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const UIStringsNotTranslate = {
+  lookingAtResourceContent: 'Looking at resource content',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface GetResourceContentArgs extends ToolArgs {
+  url: string;
+}
+
+export class GetResourceContentTool implements
+    DataTool<GetResourceContentArgs, {content: string}, BaseToolCapability&TargetCapability> {
+  readonly name = ToolName.GET_RESOURCE_CONTENT;
+  readonly description =
+      'Returns the content of the resource with the given url. Only use this for text resource types.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetResourceContentArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for looking up resource content.',
+    nullable: false,
+    properties: {
+      url: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'The url for the resource.',
+        nullable: false,
+      },
+    },
+    required: ['url'],
+  };
+
+  displayInfoFromArgs(params: GetResourceContentArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString(UIStringsNotTranslate.lookingAtResourceContent),
+      action: `getResourceContent('${params.url}')`,
+    };
+  }
+
+  async handler(
+      params: GetResourceContentArgs,
+      capabilities: BaseToolCapability&TargetCapability,
+      ): Promise<DataHandlerResult<{content: string}>> {
+    const conversationContext = capabilities.conversationContext;
+    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+      return {error: 'Performance trace context is not available.'};
+    }
+
+    if (conversationContext.getOrigin().startsWith('imported-trace://')) {
+      return {error: 'Cannot use this tool on an imported file.'};
+    }
+
+    const allowedOrigin = conversationContext.getOrigin();
+    if (!canResourceContentsBeReadForTrace(params.url, allowedOrigin)) {
+      return {error: 'Resource not found'};
+    }
+
+    const focus = conversationContext.getItem();
+    const {parsedTrace} = focus;
+
+    let content: string;
+
+    const url = params.url as Platform.DevToolsPath.UrlString;
+    const script = parsedTrace.data.Scripts?.scripts.find(script => script.url === params.url);
+    if (script?.content !== undefined) {
+      content = script.content;
+    } else {
+      const target = capabilities.getTarget();
+      const isTraceApp = Root.Runtime.Runtime.isTraceApp();
+      if (target || isTraceApp) {
+        const targetManager = target?.targetManager() ??
+            // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+            SDK.TargetManager.TargetManager.instance();
+        const resource = SDK.ResourceTreeModel.ResourceTreeModel.resourceForURL(targetManager, url);
+        if (!resource) {
+          return {error: 'Resource not found'};
+        }
+
+        const data = await resource.requestContentData();
+        if (TextUtils.ContentData.ContentData.isError(data)) {
+          return {error: `Could not get resource content: ${data.error}`};
+        }
+        if (!data.isTextContent) {
+          return {error: 'Cannot retrieve content for non-text resource'};
+        }
+
+        content = data.text;
+      } else {
+        return {error: 'Resource not found'};
+      }
+    }
+
+    return {
+      result: {content},
+      widgets: [{
+        name: 'SOURCE_CODE',
+        data: {
+          url,
+          code: content,
+        },
+      }],
+    };
+  }
+}

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

@@ -0,0 +1,101 @@
+// 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 TextUtils from '../../../core/text_utils/text_utils.js';
+import {FileFormatter} from '../data_formatters/FileFormatter.js';
+
+import {ListSourcesTool} from './ListSources.js';
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type OriginLockCapability,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const UIStringsNotTranslate = {
+  readingSource: 'Reading source content',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface GetSourceContentArgs extends ToolArgs {
+  id: number;
+}
+
+/**
+ * A tool that retrieves the contents of a source file by its unique ID.
+ * Filters access by origin lock to prevent cross-origin leakage.
+ */
+export class GetSourceContentTool implements
+    DataTool<GetSourceContentArgs, {content: string}, BaseToolCapability&OriginLockCapability> {
+  readonly name = ToolName.GET_SOURCE_CONTENT;
+  readonly description = 'Gets the content and metadata of a source file by its ID.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetSourceContentArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: '',
+    properties: {
+      id: {
+        type: Host.AidaClient.ParametersTypes.INTEGER,
+        description: 'The unique numeric ID of the source file to retrieve.',
+        nullable: false,
+      },
+    },
+    required: ['id'],
+  };
+
+  displayInfoFromArgs(args: GetSourceContentArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString(UIStringsNotTranslate.readingSource),
+      action: `getSourceContent(${args.id})`,
+    };
+  }
+
+  async handler(
+      args: GetSourceContentArgs,
+      context: BaseToolCapability&OriginLockCapability,
+      ): Promise<DataHandlerResult<{content: string}>> {
+    const origin = context.getEstablishedOrigin();
+    const file = ListSourcesTool.getUISourceCodes().find(
+        f => ListSourcesTool.uiSourceCodeId.get(f) === args.id,
+    );
+
+    if (!file) {
+      return {
+        error: 'Unable to find file.',
+      };
+    }
+
+    const fileUrl = file.url();
+    const fileOrigin = Common.ParsedURL.ParsedURL.extractOrigin(fileUrl);
+    if (origin && fileOrigin !== origin) {
+      return {
+        error: 'Cross-origin access blocked.',
+      };
+    }
+
+    const contentData = await file.requestContentData();
+    if (TextUtils.ContentData.ContentData.isError(contentData)) {
+      return {
+        error: `Failed to load file content: ${contentData.error}`,
+      };
+    }
+
+    const formatter = new FileFormatter(file);
+
+    return {
+      result: {
+        content: formatter.formatFile(),
+      },
+    };
+  }
+}

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

@@ -0,0 +1,83 @@
+// 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 {formatEventForAI} from '../data_formatters/PerformanceTraceFormatter.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const UIStringsNotTranslate = {
+  lookingAtTraceEvent: 'Looking at trace event',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface GetTraceEventByKeyArgs extends ToolArgs {
+  eventKey: string;
+}
+
+export class GetTraceEventByKeyTool implements DataTool<GetTraceEventByKeyArgs, string, BaseToolCapability> {
+  readonly name = ToolName.GET_TRACE_EVENT_BY_KEY;
+  readonly description = 'Get details for a specific trace event by its event key.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetTraceEventByKeyArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for looking up a trace event.',
+    nullable: false,
+    properties: {
+      eventKey: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'The key of the event to look up.',
+        nullable: false,
+      },
+    },
+    required: ['eventKey'],
+  };
+
+  displayInfoFromArgs(params: GetTraceEventByKeyArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString(UIStringsNotTranslate.lookingAtTraceEvent),
+      action: `getTraceEventByKey('${params.eventKey}')`,
+    };
+  }
+
+  async handler(
+      params: GetTraceEventByKeyArgs,
+      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 details = formatEventForAI(event);
+    return {
+      result: details,
+      widgets: [{
+        name: 'TIMELINE_EVENT_SUMMARY',
+        data: {
+          event,
+          parsedTrace: focus.parsedTrace,
+        },
+      }],
+    };
+  }
+}

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

@@ -0,0 +1,106 @@
+// 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 {
+  type MainThreadSectionLabel,
+  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 = {
+  mainThreadActivity: 'Main thread activity',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface GetTraceMainThreadSummaryArgs extends ToolArgs {
+  label: MainThreadSectionLabel;
+}
+
+export class GetTraceMainThreadSummaryTool implements
+    DataTool<GetTraceMainThreadSummaryArgs, string, BaseToolCapability> {
+  readonly name = ToolName.GET_TRACE_MAIN_THREAD_SUMMARY;
+  readonly description = 'Returns a focused, detailed summary of the main thread for a predefined labeled period.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetTraceMainThreadSummaryArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for looking up a main thread summary.',
+    nullable: false,
+    properties: {
+      label: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description:
+            'The label of the period to investigate (e.g., \'LCPBreakdown\', \'CLSCulprits\', \'nav-to-lcp\').',
+        nullable: false,
+      },
+    },
+    required: ['label'],
+  };
+
+  displayInfoFromArgs(params: GetTraceMainThreadSummaryArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: `${lockedString(UIStringsNotTranslate.mainThreadActivity)}: ${params.label}`,
+      action: `getTraceMainThreadSummary('${params.label}')`,
+    };
+  }
+
+  async handler(
+      params: GetTraceMainThreadSummaryArgs,
+      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.getBoundsForLabel(params.label);
+    if (!bounds) {
+      return {error: `Invalid label: ${params.label}`};
+    }
+
+    const formatter = conversationContext.createFormatter();
+    const summary = await formatter.formatMainThreadTrackSummary(bounds);
+    if (summary.length > MAX_FUNCTION_RESULT_BYTE_LENGTH) {
+      return {
+        error:
+            'getTraceMainThreadSummary response is too large. Try investigating using other functions, or a more narrow bounds',
+      };
+    }
+
+    return {
+      result: summary,
+      widgets: [
+        {
+          name: 'TIMELINE_RANGE_SUMMARY',
+          data: {
+            parsedTrace: focus.parsedTrace,
+            bounds,
+            track: 'main',
+          },
+        },
+        {
+          name: 'BOTTOM_UP_TREE',
+          data: {
+            bounds,
+            parsedTrace: focus.parsedTrace,
+          },
+        },
+      ],
+    };
+  }
+}

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,95 @@
+// 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 {
+  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()',
+    };
+  }
+
+  /**
+   * Retrieves the set of unique frame origins loaded within the primary page's target tree.
+   *
+   * To prevent data leakage across different tabs/windows, this tool:
+   * 1. Restricts the frame search to those belonging to the `primaryPageTarget`'s outermost target tree.
+   * 2. Filters out any origins that are not equivalent to the established allowed origin.
+   *    Note: Under site isolation, frames may be hosted on different sub-targets or processes,
+   *    so we check `frame.securityOrigin` directly instead of the frame's target origin.
+   */
+  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 (frame.resourceTreeModel().target().outermostTarget() !== primaryPageTarget) {
+        continue;
+      }
+      const origin = frame.securityOrigin;
+      // Filter out frames that are not same-origin to the page's allowed origin.
+      // Under site isolation, frames can be hosted on different targets/processes,
+      // so we check the security origin of the frame directly instead of the target.
+      if (!origin || !areOriginsEquivalent(origin, allowedOrigin)) {
+        continue;
+      }
+      if (origins.has(origin)) {
+        continue;
+      }
+      origins.add(origin);
+    }
+
+    return {result: {origins: Array.from(origins)}};
+  }
+}