chrome-devtools-frontend 1.0.1643099 → 1.0.1643855

package/eslint.config.mjs

@@ -721,7 +721,8 @@ export default defineConfig([
       'test/**/*.ts',
       '**/testing/*.ts',
       'scripts/eslint_rules/test/**/*',
-      'extensions/cxx_debugging/e2e/**',
+      'extensions/cxx_debugging/e2e/**/*.ts',
+      'extensions/cxx_debugging/tests/**/*.ts',
     ],
 
     rules: {
@@ -750,6 +751,7 @@ export default defineConfig([
       ],
 
       '@devtools/check-test-definitions': 'error',
+      '@devtools/prefer-chai-assert': 'error',
       '@devtools/no-assert-strict-equal-for-arrays-and-objects': 'error',
       '@devtools/no-assert-deep-strict-equal': 'error',
       '@devtools/no-assert-equal': 'error',

package/extension-api/ExtensionAPI.d.ts

@@ -19,8 +19,35 @@ export namespace Chrome {
        */
       readonly buildId?: string;
 
+      /**
+       * Returns the `content` and `encoding` of the resource. If a `callback`
+       * is provided, it is invoked with the `content` and `encoding` and the
+       * method returns `void`. If no `callback` is provided, the method returns
+       * a `Promise`.
+       *
+       * @param callback Optional callback to be invoked with the content and
+       * encoding.
+       * @returns A Promise that resolves to an object containing the content
+       * and encoding if no callback is provided, otherwise void. Rejects with
+       * an error object on failure.
+       */
+      getContent(): Promise<{content: string, encoding: string}>;
       getContent(callback: (content: string, encoding: string) => unknown): void;
-      setContent(content: string, commit: boolean, callback?: (error?: Object) => unknown): void;
+
+      /**
+       * Sets the content of the resource. If a `callback` is provided, it is
+       * invoked when the content is set and the method returns `void`. If no
+       * `callback` is provided, the method returns a `Promise`.
+       *
+       * @param content The new content of the resource.
+       * @param commit Whether to commit the changes.
+       * @param callback Optional callback to be invoked when the content is
+       * set.
+       * @returns A Promise that resolves when the content is set if no callback
+       * is provided, otherwise void. Rejects with an error object on failure.
+       */
+      setContent(content: string, commit: boolean): Promise<void>;
+      setContent(content: string, commit: boolean, callback: (error?: object) => unknown): void;
       /**
        * Augments this resource's scopes information based on the list of {@link NamedFunctionRange}s
        * for improved debuggability and function naming.
@@ -40,18 +67,62 @@ export namespace Chrome {
       onResourceAdded: EventSink<(resource: Resource) => unknown>;
       onResourceContentCommitted: EventSink<(resource: Resource, content: string) => unknown>;
 
-      eval(
-          expression: string,
-          options?: {scriptExecutionContext?: string, frameURL?: string, useContentScriptContext?: boolean},
-          callback?: (result: unknown, exceptioninfo: {
-            code: string,
-            description: string,
-            details: unknown[],
-            isError: boolean,
-            isException: boolean,
-            value: string,
-          }) => unknown): void;
+      /**
+       * Evaluates a JavaScript expression in the context of the inspected page.
+       *
+       * If a `callback` is provided, it is invoked with the result and
+       * exception information and the method returns `void`. If no `callback`
+       * is provided, the method returns a `Promise`.
+       *
+       * @template E The type of the value that the Promise resolves to.
+       * @param expression The JavaScript expression to evaluate.
+       * @param optionsOrCallback Optional options for evaluation, or a callback
+       * function.
+       * @param callback Optional callback to be invoked with the evaluation
+       * result and exception information.
+       * @returns A Promise that resolves to the result if no callback is
+       * provided, otherwise void. Rejects with an error object on failure.
+       */
+      eval<E = unknown>(expression: string, options?: {
+        scriptExecutionContext?: string,
+        frameURL?: string,
+        useContentScriptContext?: boolean,
+      }): Promise<E>;
+      eval(expression: string,
+           optionsOrCallback: {scriptExecutionContext?: string, frameURL?: string, useContentScriptContext?: boolean}|
+           undefined|((result: unknown, exceptioninfo: {
+                        code: string,
+                        description: string,
+                        details: unknown[],
+                        isError: boolean,
+                        isException: boolean,
+                        value: string,
+                      }) => unknown),
+           callback?: (result: unknown, exceptioninfo: {
+             code: string,
+             description: string,
+             details: unknown[],
+             isError: boolean,
+             isException: boolean,
+             value: string,
+           }) => unknown): void;
+
+      /**
+       * Retrieves all resources within the inspected window.
+       *
+       * If a `callback` is provided, it is invoked with the array of resources
+       * and the method returns `void`. If no `callback` is provided, the method
+       * returns a `Promise`.
+       *
+       * @param callback Optional callback to be invoked with the array of
+       * resources.
+       * @returns A Promise that resolves to an array of resources if no
+       * callback is provided, otherwise void. Rejects with an error object on
+       * failure.
+       */
+      getResources(): Promise<Resource[]>;
       getResources(callback: (resources: Resource[]) => unknown): void;
+
       reload(reloadOptions?: {ignoreCache?: boolean, injectedScript?: string, userAgent?: string}): void;
     }
 

package/front_end/core/host/UserMetrics.ts

@@ -767,7 +767,6 @@ export enum DevtoolsExperiments {
   /* eslint-disable @typescript-eslint/naming-convention */
   'protocol-monitor' = 13,
   'instrumentation-breakpoints' = 61,
-  'use-source-map-scopes' = 76,
   'durable-messages' = 110,
   'jpeg-xl' = 111,
   'plus-button' = 112,

package/front_end/core/root/ExperimentNames.ts

@@ -6,7 +6,6 @@ export enum ExperimentName {
   ALL = '*',
   PROTOCOL_MONITOR = 'protocol-monitor',
   INSTRUMENTATION_BREAKPOINTS = 'instrumentation-breakpoints',
-  USE_SOURCE_MAP_SCOPES = 'use-source-map-scopes',
   DURABLE_MESSAGES = 'durable-messages',
   JPEG_XL = 'jpeg-xl',
   PLUS_BUTTON = 'plus-button',

package/front_end/core/sdk/ConsoleModel.ts

@@ -547,6 +547,7 @@ export interface ConsoleMessageDetails {
   context?: string;
   affectedResources?: AffectedResources;
   category?: Protocol.Log.LogEntryCategory;
+  exceptionDetails?: Protocol.Runtime.ExceptionDetails;
 }
 
 export class ConsoleMessage {
@@ -570,6 +571,7 @@ export class ConsoleMessage {
   #exceptionId?: number = undefined;
   #affectedResources?: AffectedResources;
   category?: Protocol.Log.LogEntryCategory;
+  readonly exceptionDetails?: Protocol.Runtime.ExceptionDetails;
 
   /**
    * The parent frame of the `console.log` call of logpoints or conditional breakpoints
@@ -600,6 +602,7 @@ export class ConsoleMessage {
     this.workerId = details?.workerId;
     this.#affectedResources = details?.affectedResources;
     this.category = details?.category;
+    this.exceptionDetails = details?.exceptionDetails;
 
     if (!this.#executionContextId && this.#runtimeModel) {
       if (this.scriptId) {
@@ -646,6 +649,7 @@ export class ConsoleMessage {
       executionContextId: exceptionDetails.executionContextId,
       scriptId: exceptionDetails.scriptId,
       affectedResources,
+      exceptionDetails,
     };
     return new ConsoleMessage(
         runtimeModel, Protocol.Log.LogEntrySource.Javascript, Protocol.Log.LogEntryLevel.Error,

package/front_end/core/sdk/NetworkRequest.ts

@@ -299,6 +299,10 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
   #contentDataProvider?: () => Promise<TextUtils.ContentData.ContentDataOrError>;
   #isSameSite: boolean|null = null;
   #wasIntercepted = false;
+  /**
+   * Whether this request was imported from a HAR file.
+   */
+  #isImportedHar = false;
   #associatedData = new Map<string, object>();
   #hasOverriddenContent = false;
   #hasThirdPartyCookiePhaseoutIssue = false;
@@ -1148,6 +1152,14 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.#wasIntercepted = wasIntercepted;
   }
 
+  isImportedHar(): boolean {
+    return this.#isImportedHar;
+  }
+
+  setIsImportedHar(isImportedHar: boolean): void {
+    this.#isImportedHar = isImportedHar;
+  }
+
   setEarlyHintsHeaders(headers: NameValue[]): void {
     this.earlyHintsHeaders = headers;
   }

package/front_end/core/sdk/SourceMap.ts

@@ -6,7 +6,6 @@ import * as TextUtils from '../../models/text_utils/text_utils.js';
 import * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-map-scopes-codec.js';
 import * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
-import * as Root from '../root/root.js';
 
 import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
 import {scopeTreeForScript} from './ScopeTreeCache.js';
@@ -584,23 +583,21 @@ export class SourceMap {
           lineNumber, columnNumber, sourceIndex, sourceURL, sourceLineNumber, sourceColumnNumber, names[nameIndex]));
     }
 
-    if (Root.Runtime.experiments.isEnabled(Root.ExperimentNames.ExperimentName.USE_SOURCE_MAP_SCOPES)) {
-      if (!this.#scopesInfo) {
-        this.#scopesInfo = new SourceMapScopesInfo(this, {scopes: [], ranges: []});
-      }
-      if (map.scopes) {
-        const {scopes, ranges} = ScopesCodec.decode(
-            map as ScopesCodec.SourceMapJson,
-            {mode: ScopesCodec.DecodeMode.LAX, generatedOffset: {line: baseLineNumber, column: baseColumnNumber}});
-        this.#scopesInfo.addOriginalScopes(scopes);
-        this.#scopesInfo.addGeneratedRanges(ranges);
-      } else if (map.x_com_bloomberg_sourcesFunctionMappings) {
-        const originalScopes = this.parseBloombergScopes(map);
-        this.#scopesInfo.addOriginalScopes(originalScopes);
-      } else {
-        // Keep the OriginalScope[] tree array consistent with sources.
-        this.#scopesInfo.addOriginalScopes(new Array(map.sources.length).fill(null));
-      }
+    if (!this.#scopesInfo) {
+      this.#scopesInfo = new SourceMapScopesInfo(this, {scopes: [], ranges: []});
+    }
+    if (map.scopes) {
+      const {scopes, ranges} = ScopesCodec.decode(
+          map as ScopesCodec.SourceMapJson,
+          {mode: ScopesCodec.DecodeMode.LAX, generatedOffset: {line: baseLineNumber, column: baseColumnNumber}});
+      this.#scopesInfo.addOriginalScopes(scopes);
+      this.#scopesInfo.addGeneratedRanges(ranges);
+    } else if (map.x_com_bloomberg_sourcesFunctionMappings) {
+      const originalScopes = this.parseBloombergScopes(map);
+      this.#scopesInfo.addOriginalScopes(originalScopes);
+    } else {
+      // Keep the OriginalScope[] tree array consistent with sources.
+      this.#scopesInfo.addOriginalScopes(new Array(map.sources.length).fill(null));
     }
   }
 

package/front_end/entrypoints/greendev_floaty/FloatyEntrypoint.ts

@@ -593,8 +593,6 @@ async function init(): Promise<void> {
 
     safeRegisterExperiment(
         Root.ExperimentNames.ExperimentName.INSTRUMENTATION_BREAKPOINTS, 'Enable instrumentation breakpoints');
-    safeRegisterExperiment(
-        Root.ExperimentNames.ExperimentName.USE_SOURCE_MAP_SCOPES, 'Use scope information from source maps');
     safeRegisterExperiment(Root.ExperimentNames.ExperimentName.PROTOCOL_MONITOR, 'Protocol Monitor');
 
     const hostUnsyncedStorage: Common.Settings.SettingsBackingStore = {

package/front_end/entrypoints/greendev_floaty/greendev_floaty.ts

@@ -247,8 +247,6 @@ async function init(): Promise<void> {
     // Register necessary experiments to avoid "Unknown experiment" errors.
     Root.Runtime.experiments.register(
         Root.ExperimentNames.ExperimentName.INSTRUMENTATION_BREAKPOINTS, 'Enable instrumentation breakpoints');
-    Root.Runtime.experiments.register(
-        Root.ExperimentNames.ExperimentName.USE_SOURCE_MAP_SCOPES, 'Use scope information from source maps');
     Root.Runtime.experiments.register(Root.ExperimentNames.ExperimentName.PROTOCOL_MONITOR, 'Protocol Monitor');
 
     const WINDOW_LOCAL_STORAGE: Common.Settings.SettingsBackingStore = {

package/front_end/entrypoints/main/MainImpl.ts

@@ -365,8 +365,6 @@ export class MainImpl {
     // Debugging
     Root.Runtime.experiments.register(
         Root.ExperimentNames.ExperimentName.INSTRUMENTATION_BREAKPOINTS, 'Instrumentation breakpoints');
-    Root.Runtime.experiments.register(
-        Root.ExperimentNames.ExperimentName.USE_SOURCE_MAP_SCOPES, 'Use scope information from source maps');
 
     Root.Runtime.experiments.registerHostExperiment({
       name: Root.ExperimentNames.ExperimentName.DURABLE_MESSAGES,
@@ -392,10 +390,6 @@ export class MainImpl {
       requiresChromeRestart: false,
     });
 
-    Root.Runtime.experiments.enableExperimentsByDefault([
-      Root.ExperimentNames.ExperimentName.USE_SOURCE_MAP_SCOPES,
-    ]);
-
     const enabledExperiments = Root.Runtime.Runtime.queryParam('enabledExperiments');
     if (enabledExperiments) {
       Root.Runtime.experiments.setServerEnabledExperiments(enabledExperiments.split(';'));

package/front_end/models/ai_assistance/AiAgent2.ts

@@ -186,6 +186,7 @@ User query: ${enhancedQuery}`;
             changeManager: this.#changes,
             createExtensionScope: this.#createExtensionScope.bind(this),
             execJs: this.#execJs,
+            getExecutionContextNode: () => this.context instanceof DOMNodeContext ? this.context.getItem() : null,
           },
           options,
           ),

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

@@ -13,6 +13,8 @@ import {ChangeManager} from '../ChangeManager.js';
 import {LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
 import {debugLog} from '../debug.js';
 import {ExtensionScope} from '../ExtensionScope.js';
+import {ToolName} from '../tools/Tool.js';
+import {ToolRegistry} from '../tools/ToolRegistry.js';
 
 import {
   AiAgent,
@@ -25,10 +27,8 @@ import {
 } from './AiAgent.js';
 import {
   type CreateExtensionScopeFunction,
-  executeJavaScriptFunction,
   type ExecuteJsAgentOptions,
   executeJsCode,
-  JavascriptExecutor
 } from './ExecuteJavascript.js';
 
 /**
@@ -117,7 +117,6 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
       (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
 
   #execJs: typeof executeJsCode;
-  #javascriptExecutor: JavascriptExecutor;
   #changes: ChangeManager;
   #createExtensionScope: CreateExtensionScopeFunction;
 
@@ -129,14 +128,6 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
     this.#createExtensionScope = opts.createExtensionScope ?? ((changes: ChangeManager) => {
                                    return new ExtensionScope(changes, this.sessionId, this.#getDocumentBodyNode());
                                  });
-    this.#javascriptExecutor = new JavascriptExecutor(
-        {
-          executionMode: this.executionMode,
-          getContextNode: () => this.#getDocumentBodyNode(),
-          createExtensionScope: this.#createExtensionScope.bind(this),
-          changes: this.#changes,
-        },
-        this.#execJs);
   }
 
   get userTier(): string|undefined {
@@ -271,16 +262,31 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
       }
     });
 
-    const executeJsDeclaration = executeJavaScriptFunction(this.#javascriptExecutor);
-    this.declareFunction('executeJavaScript', {
-      ...executeJsDeclaration,
-      handler: async (params, options) => {
+    const executeJsTool = ToolRegistry.get(ToolName.EXECUTE_JAVASCRIPT);
+    if (!executeJsTool) {
+      throw new Error('Required tool "executeJavaScript" not found');
+    }
+    this.declareFunction(executeJsTool.name, {
+      description: executeJsTool.description,
+      parameters: executeJsTool.parameters,
+      displayInfoFromArgs: executeJsTool.displayInfoFromArgs,
+      handler: async (args, options) => {
         if (isImported) {
           return {
             error: 'Cannot use this tool on an imported file.',
           };
         }
-        return await executeJsDeclaration.handler(params, options);
+        return await executeJsTool.handler(
+            args,
+            {
+              conversationContext: this.context ?? null,
+              changeManager: this.#changes,
+              createExtensionScope: this.#createExtensionScope.bind(this),
+              execJs: this.#execJs,
+              getExecutionContextNode: () => this.#getDocumentBodyNode(),
+            },
+            options,
+        );
       },
     });
 

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

@@ -509,8 +509,8 @@ export abstract class AiAgent<T> {
     this.#allowedOrigin = opts.allowedOrigin;
   }
 
-  async enhanceQuery(query: string, selected: ConversationContext<T>|null, multimodalInputType?: MultimodalInputType):
-      Promise<string>;
+  async enhanceQuery(query: string, selected: ConversationContext<T>|null,
+                     multimodalInputType?: MultimodalInputType): Promise<string>;
   async enhanceQuery(query: string): Promise<string> {
     return query;
   }
@@ -557,9 +557,21 @@ export abstract class AiAgent<T> {
     return undefined;
   }
 
-  buildRequest(
-      part: Host.AidaClient.Part|Host.AidaClient.Part[],
-      role: Host.AidaClient.Role.USER|Host.AidaClient.Role.ROLE_UNSPECIFIED): Host.AidaClient.DoConversationRequest {
+  /**
+   * Preamble features appended to the `client_version` in metadata.
+   * This is required ONLY for the Styling Agent for legacy reasons to serve
+   * different server-side preambles based on the Chrome version.
+   * Other agents should NOT set or override this.
+   * If you are curious about this, look for `do_conversation_handler.cc` in
+   * Google3 or chat to @jacktfranklin.
+   */
+  preambleFeatures(): string[] {
+    return [];
+  }
+
+  buildRequest(part: Host.AidaClient.Part|Host.AidaClient.Part[],
+               role: Host.AidaClient.Role.USER|
+               Host.AidaClient.Role.ROLE_UNSPECIFIED): Host.AidaClient.DoConversationRequest {
     const parts = Array.isArray(part) ? part : [part];
     const currentMessage: Host.AidaClient.Content = {
       parts,
@@ -600,7 +612,8 @@ export abstract class AiAgent<T> {
         disable_user_content_logging: !(this.#serverSideLoggingEnabled ?? false),
         string_session_id: this.#sessionId,
         user_tier: userTier,
-        client_version: Root.Runtime.getChromeVersion(),
+        client_version:
+            Root.Runtime.getChromeVersion() + this.preambleFeatures().map(feature => `+${feature}`).join(''),
       },
 
       functionality_type: enableAidaFunctionCalling ? Host.AidaClient.FunctionalityType.AGENTIC_CHAT :

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

@@ -27,7 +27,7 @@ import {
   type RequestOptions,
 } from './AiAgent.js';
 import {FileContext} from './FileAgent.js';
-import {RequestContext} from './NetworkAgent.js';
+import {getRequestContextOrigin, RequestContext} from './NetworkAgent.js';
 import {PerformanceTraceContext} from './PerformanceAgent.js';
 import {StorageContext} from './StorageAgent.js';
 
@@ -146,7 +146,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
         let hasCrossOriginRequest = false;
         const requestsToShow: NetworkRequest[] = [];
         for (const request of Logs.NetworkLog.NetworkLog.instance().requests()) {
-          const documentOrigin = Common.ParsedURL.ParsedURL.extractOrigin(request.documentURL);
+          const requestOrigin = getRequestContextOrigin(request);
           /**
            * NOTE: this origin check does not ensure that all the requests are
            * from the same origin as the target page. Instead, it ensures that
@@ -155,7 +155,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
            * during the loading of the target page, and do not leak URLs from
            * other pages.
            */
-          if (origin && documentOrigin !== origin) {
+          if (origin && requestOrigin !== origin) {
             hasCrossOriginRequest = true;
             continue;
           }
@@ -230,8 +230,8 @@ export class ContextSelectionAgent extends AiAgent<never> {
             return false;
           }
 
-          const documentOrigin = Common.ParsedURL.ParsedURL.extractOrigin(req.documentURL);
-          return !origin || documentOrigin === origin;
+          const requestOrigin = getRequestContextOrigin(req);
+          return !origin || requestOrigin === origin;
         });
 
         if (request) {

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

@@ -12,9 +12,7 @@ import {debugLog} from '../debug.js';
 import {EvaluateAction, formatError, SideEffectError} from '../EvaluateAction.js';
 import {FREESTYLER_WORLD_NAME} from '../injected.js';
 
-import type {
-  AgentOptions as BaseAgentOptions, FunctionCallHandlerResult, FunctionDeclaration, FunctionHandlerOptions,} from
-  './AiAgent.js';
+import type {AgentOptions as BaseAgentOptions, FunctionCallHandlerResult, FunctionHandlerOptions,} from './AiAgent.js';
 
 const lockedString = i18n.i18n.lockedString;
 
@@ -28,97 +26,6 @@ export interface ExecuteJsAgentOptions extends BaseAgentOptions {
   execJs?: typeof executeJsCode;
 }
 
-// TODO(crbug.com/510206549): De-duplicate this function by migrating AccessibilityAgent to use
-// the registry-based ExecuteJavaScriptTool in tools/ExecuteJavaScript.ts.
-export function executeJavaScriptFunction(executor: JavascriptExecutor): FunctionDeclaration<
-    {
-      title: string,
-      explanation: string,
-      code: string,
-    },
-    unknown> {
-  return {
-    description:
-        'This function allows you to run JavaScript code on the inspected page to access the element styles and page content.\nCall this function to gather additional information or modify the page state. Call this function enough times to investigate the user request.',
-    parameters: {
-      type: Host.AidaClient.ParametersTypes.OBJECT,
-      description: '',
-      nullable: false,
-      properties: {
-        code: {
-          type: Host.AidaClient.ParametersTypes.STRING,
-          description:
-              `JavaScript code snippet to run on the inspected page. Make sure the code is formatted for readability.
-
-# Instructions
-
-* To return data, define a top-level \`data\` variable and populate it with data you want to get. Only JSON-serializable objects can be assigned to \`data\`.
-* If you modify styles on an element, ALWAYS call the pre-defined global \`async setElementStyles(el: Element, styles: object)\` function. This function is an internal mechanism for you and should never be presented as a command/advice to the user.
-* **CRITICAL** Only get styles that might be relevant to the user request.
-* **CRITICAL** Never assume a selector for the elements unless you verified your knowledge.
-* **CRITICAL** Consider that \`data\` variable from the previous function calls are not available in a new function call.
-
-For example, the code to change element styles:
-
-\`\`\`
-await setElementStyles($0, {
-  color: 'blue',
-});
-\`\`\`
-
-For example, the code to get overlapping elements:
-
-\`\`\`
-const data = {
-  overlappingElements: Array.from(document.querySelectorAll('*'))
-    .filter(el => {
-      const rect = el.getBoundingClientRect();
-      const popupRect = $0.getBoundingClientRect();
-      return (
-        el !== $0 &&
-        rect.left < popupRect.right &&
-        rect.right > popupRect.left &&
-        rect.top < popupRect.bottom &&
-        rect.bottom > popupRect.top
-      );
-    })
-    .map(el => ({
-      tagName: el.tagName,
-      id: el.id,
-      className: el.className,
-      zIndex: window.getComputedStyle(el)['z-index']
-    }))
-};
-\`\`\`
-`,
-        },
-        explanation: {
-          type: Host.AidaClient.ParametersTypes.STRING,
-          description: 'Explain why you want to run this code',
-        },
-        title: {
-          type: Host.AidaClient.ParametersTypes.STRING,
-          description: 'Provide a summary of what the code does. For example, "Checking related element styles".',
-        },
-      },
-      required: ['code', 'explanation', 'title']
-    },
-    displayInfoFromArgs: params => {
-      return {
-        title: params.title,
-        thought: params.explanation,
-        action: params.code,
-      };
-    },
-    handler: async (
-        params,
-        options,
-        ) => {
-      return await executor.executeAction(params.code, options);
-    },
-  };
-}
-
 export async function executeJsCode(
     functionDeclaration: string,
     {throwOnSideEffect, contextNode}: {throwOnSideEffect: boolean, contextNode: SDK.DOMModel.DOMNode|null}):

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

@@ -2,11 +2,14 @@
 // 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 type * as Platform from '../../../core/platform/platform.js';
 import * as Root from '../../../core/root/root.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
 import type * as NetworkTimeCalculator from '../../network_time_calculator/network_time_calculator.js';
+import {extractContextOrigin} from '../AiOrigins.js';
 import {NetworkRequestFormatter} from '../data_formatters/NetworkRequestFormatter.js';
 
 import {
@@ -98,6 +101,24 @@ const UIStringsNotTranslate = {
 
 const lockedString = i18n.i18n.lockedString;
 
+/**
+ * Returns the origin for a network request in the AI context.
+ *
+ * To prevent cross-origin prompt injection attacks, HAR-imported requests
+ * are isolated from live pages. We assign them a virtual origin
+ * (`imported-har://${domain}`) so they do not share the origin of live pages
+ * (e.g., `https://${domain}`). This forces a conversation reset when transitioning
+ * between imported HAR data and live pages.
+ */
+export function getRequestContextOrigin(request: SDK.NetworkRequest.NetworkRequest): string {
+  const origin = extractContextOrigin(request.documentURL);
+  if (request.isImportedHar()) {
+    const parsed = Common.ParsedURL.ParsedURL.fromString(origin as Platform.DevToolsPath.UrlString);
+    return `imported-har://${parsed ? parsed.domain() : origin}`;
+  }
+  return origin;
+}
+
 export class RequestContext extends ConversationContext<SDK.NetworkRequest.NetworkRequest> {
   #request: SDK.NetworkRequest.NetworkRequest;
   #calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator;
@@ -119,6 +140,10 @@ export class RequestContext extends ConversationContext<SDK.NetworkRequest.Netwo
     return this.#request.documentURL;
   }
 
+  override getOrigin(): string {
+    return getRequestContextOrigin(this.#request);
+  }
+
   override getItem(): SDK.NetworkRequest.NetworkRequest {
     return this.#request;
   }

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

@@ -15,6 +15,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 {extractContextOrigin} from '../AiOrigins.js';
 import {sanitizeHeaders} from '../data_formatters/NetworkRequestFormatter.js';
 import {
   PerformanceInsightFormatter,
@@ -256,6 +257,27 @@ export class PerformanceTraceContext extends ConversationContext<AgentFocus> {
     }
   }
 
+  /**
+   * Returns the origin for a performance trace in the AI context.
+   *
+   * To prevent cross-origin prompt injection attacks, imported traces
+   * are isolated from live pages. We assign them a virtual origin
+   * (`imported-trace://${domain}`) so they do not share the origin of live pages
+   * (e.g., `https://${domain}`). This forces a conversation reset when transitioning
+   * between imported trace data and live pages.
+   */
+  override getOrigin(): string {
+    const parsedTrace = this.#focus.parsedTrace;
+    const url = this.getURL();
+    const origin = extractContextOrigin(url);
+    const isFresh = Tracing.FreshRecording.Tracker.instance().recordingIsFresh(parsedTrace);
+    if (!isFresh) {
+      const parsed = Common.ParsedURL.ParsedURL.fromString(origin as Platform.DevToolsPath.UrlString);
+      return `imported-trace://${parsed ? parsed.domain() : origin}`;
+    }
+    return origin;
+  }
+
   override getItem(): AgentFocus {
     return this.#focus;
   }