chrome-devtools-frontend 1.0.1643099 → 1.0.1643855

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

@@ -23,7 +23,7 @@ const lockedString = i18n.i18n.lockedString;
 const preamble =
     `You are a Senior Software Engineer specializing in state audit and storage analysis within Chrome DevTools. Your mission is to help developers debug storage-related issues faster by analyzing the evidence in LocalStorage, SessionStorage, and Cookies.
 
- You have access to the site's storage using tools like \`listPageOrigins\`, \`listStorageKeys\`, \`getStorageValues\`, \`listCookies\`, and \`getCookieValues\`.
+ You have access to the site's storage using tools like \`getStorageBreakdown\`, \`listPageOrigins\`, \`listStorageKeys\`, \`getStorageValues\`, \`listCookies\`, and \`getCookieValues\`.
 
  # Goals
 
@@ -34,6 +34,7 @@ const preamble =
  # Tools & Workflow
 
  -   **Prioritize Top-Level Context**: Always initiate your investigation from the top-level page's storage. Explicitly state if you are analyzing storage from a different context (e.g., an iframe).
+ -   **Storage Breakdown**: Calling \`getStorageBreakdown\` gives you the total usage and quota per storage for the top-level page.
  -   **Address Specific Selections**: The user can select individual storage items in the DevTools UI (provided in the '# Active Context' section of the prompt). If the query is about a selected item (e.g., "Why is this cookie set?"), focus your response on that specific item.
  -   **Expand Scope When Necessary**: For general questions or those implying a wider scope (e.g., "Check all storages," "Are there related cookies on subdomains?"), proactively use your tools to explore other relevant storage contexts, including iframes and different origins.
  -   **Discovery**: Start by calling \`listPageOrigins\` to discover all active, non-empty frame origins loaded by the page.
@@ -479,6 +480,58 @@ export class StorageAgent extends AiAgent<StorageItem> {
         return {result: {cookies: cookieData}};
       },
     });
+
+    this.declareFunction<Record<string, never>, {
+      totalUsage: string,
+      totalQuota: string,
+      usageBreakdown: Array<{
+        storageType: string,
+        usage: string,
+      }>,
+    }>('getStorageBreakdown', {
+      description:
+          'Retrieves the total storage usage, total storage quota, and a breakdown of active storage usage per storage type for the top-level page.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: false,
+        properties: {},
+        required: [],
+      },
+      displayInfoFromArgs: () => {
+        return {
+          title: lockedString('Retrieving storage breakdown'),
+          action: 'getStorageBreakdown()',
+        };
+      },
+      handler: async () => {
+        const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+        if (!target || !this.context || !isSamePageOrigin(target, this.context)) {
+          return {error: 'No origin available or not allowed.'};
+        }
+
+        const origin = this.context.getOrigin();
+        const response = await target.storageAgent().invoke_getUsageAndQuota({origin});
+        if (response.getError()) {
+          return {error: response.getError() || 'Unknown CDP error'};
+        }
+
+        const usageBreakdown = response.usageBreakdown.filter(entry => entry.usage > 0)
+                                   .sort((a, b) => b.usage - a.usage)
+                                   .map(entry => ({
+                                          storageType: entry.storageType as string,
+                                          usage: i18n.ByteUtilities.bytesToString(entry.usage),
+                                        }));
+
+        return {
+          result: {
+            totalUsage: i18n.ByteUtilities.bytesToString(response.usage),
+            totalQuota: i18n.ByteUtilities.bytesToString(response.quota),
+            usageBreakdown,
+          },
+        };
+      },
+    });
   }
 
   static #formatContext(item: StorageItem): string {

package/front_end/models/ai_assistance/agents/StylingAgent.snapshot.txt

@@ -1,4 +1,3 @@
-
 Title: StylingAgent buildRequest structure matches the snapshot
 Content:
 {
@@ -129,7 +128,7 @@ Content:
     "disable_user_content_logging": false,
     "string_session_id": "sessionId",
     "user_tier": 3,
-    "client_version": "unit_test"
+    "client_version": "unit_test+function_calling"
   },
   "functionality_type": 5,
   "client_feature": 2

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

@@ -211,6 +211,7 @@ export class StylingAgent extends AiAgent<SDK.DOMModel.DOMNode> {
             changeManager: this.#changes,
             createExtensionScope: this.#createExtensionScope.bind(this),
             execJs: this.#execJs,
+            getExecutionContextNode: () => this.context?.getItem() ?? null,
           },
           options,
           ),
@@ -280,6 +281,10 @@ export class StylingAgent extends AiAgent<SDK.DOMModel.DOMNode> {
     });
   }
 
+  override preambleFeatures(): string[] {
+    return ['function_calling'];
+  }
+
   #getSelectedNode(): SDK.DOMModel.DOMNode|null {
     return this.context?.getItem() ?? null;
   }

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

@@ -6,7 +6,6 @@ import * as Host from '../../../core/host/host.js';
 import * as Root from '../../../core/root/root.js';
 import type {FunctionCallHandlerResult, FunctionHandlerOptions,} from '../agents/AiAgent.js';
 import {JavascriptExecutor} from '../agents/ExecuteJavascript.js';
-import {DOMNodeContext} from '../contexts/DOMNodeContext.js';
 
 import {
   type Tool,
@@ -108,14 +107,9 @@ const data = {
       context: ToolContext,
       options?: FunctionHandlerOptions,
       ): Promise<FunctionCallHandlerResult<unknown>> {
-    const activeContext = context.conversationContext;
-    if (!activeContext || !(activeContext instanceof DOMNodeContext)) {
-      return {error: 'Error: Could not find the currently selected element.'};
-    }
-
-    const selectedNode = activeContext.getItem();
-    if (!selectedNode) {
-      return {error: 'Error: Could not find the currently selected element.'};
+    const executionNode = context.getExecutionContextNode?.() ?? null;
+    if (!executionNode) {
+      return {error: 'Error: Could not find the context node for execution.'};
     }
 
     const executionMode = Root.Runtime.hostConfig.devToolsFreestyler?.executionMode ??
@@ -129,7 +123,7 @@ const data = {
 
     const executor = new JavascriptExecutor({
       executionMode,
-      getContextNode: () => selectedNode,
+      getContextNode: () => executionNode,
       createExtensionScope,
       changes,
     },

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

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import type * as Host from '../../../core/host/host.js';
+import type * as SDK from '../../../core/sdk/sdk.js';
 import type {ConversationContext, FunctionCallHandlerResult, FunctionHandlerOptions} from '../agents/AiAgent.js';
 import type {executeJsCode} from '../agents/ExecuteJavascript.js';
 import type {ChangeManager} from '../ChangeManager.js';
@@ -17,6 +18,11 @@ export interface ToolContext {
     install(): Promise<void>, uninstall(): Promise<void>,
   };
   execJs?: typeof executeJsCode;
+  /**
+   * Returns the DOM node that acts as the execution context (i.e. `$0` inside the execution context)
+   * for running JavaScript.
+   */
+  getExecutionContextNode?: () => SDK.DOMModel.DOMNode | null;
 }
 
 /**

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -24,7 +24,6 @@ import {
   isErrorLike,
   type SymbolizedError,
   SymbolizedErrorObject,
-  SymbolizedSyntaxError,
   UnparsableError,
 } from './SymbolizedError.js';
 
@@ -238,14 +237,6 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
       ]);
       fetchedExceptionDetails = details;
       causeRemoteObject = causeRemote;
-
-      if (remoteObject.className === 'SyntaxError' && fetchedExceptionDetails) {
-        const syntaxError = await SymbolizedSyntaxError.fromExceptionDetails(
-            remoteObject.runtimeModel().target(), this, fetchedExceptionDetails);
-        if (syntaxError) {
-          return syntaxError;
-        }
-      }
     } else if (remoteObject.type === 'string') {
       errorStack = remoteObject.description || '';
       if (!isErrorLike(errorStack)) {
@@ -271,6 +262,12 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     }
 
     const message = StackTraceImpl.DetailedErrorStackParser.parseMessage(errorStack);
+
+    if (remoteObject.subtype === 'error' && remoteObject.className === 'SyntaxError' && fetchedExceptionDetails) {
+      return await SymbolizedErrorObject.createForSyntaxError(remoteObject.runtimeModel().target(), this, message,
+                                                              fetchedExceptionDetails, stackTrace, cause);
+    }
+
     return new SymbolizedErrorObject(message, stackTrace, cause);
   }
 

package/front_end/models/bindings/DefaultScriptMapping.ts

@@ -107,7 +107,8 @@ export class DefaultScriptMapping implements DebuggerSourceMapping {
     }
     this.#uiSourceCodeToScript.set(uiSourceCode, script);
     this.#scriptToUISourceCode.set(script, uiSourceCode);
-    this.#project.addUISourceCodeWithProvider(uiSourceCode, script, null, 'text/javascript');
+    const mimeType = script.isWasm() ? 'application/wasm' : 'text/javascript';
+    this.#project.addUISourceCodeWithProvider(uiSourceCode, script, null, mimeType);
     void this.#debuggerWorkspaceBinding.updateLocations(script);
   }
 

package/front_end/models/bindings/SymbolizedError.ts

@@ -15,7 +15,7 @@ export function isErrorLike(stack: string): boolean {
   return /\n\s*at\s/.test(stack) || stack.startsWith('SyntaxError:');
 }
 
-export type SymbolizedError = SymbolizedErrorObject|SymbolizedSyntaxError|UnparsableError;
+export type SymbolizedError = SymbolizedErrorObject|UnparsableError;
 
 export class UnparsableError extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly errorStack: string;
@@ -45,6 +45,7 @@ export class SymbolizedErrorObject extends Common.ObjectWrapper.ObjectWrapper<Ev
   readonly message: string;
   readonly stackTrace: StackTrace.StackTrace.ParsedErrorStackTrace;
   readonly cause: SymbolizedError|null;
+  #syntaxErrorLocation: Workspace.UISourceCode.UILocation|null = null;
 
   constructor(message: string, stackTrace: StackTrace.StackTrace.ParsedErrorStackTrace, cause: SymbolizedError|null) {
     super();
@@ -64,53 +65,62 @@ export class SymbolizedErrorObject extends Common.ObjectWrapper.ObjectWrapper<Ev
     }
   }
 
-  #fireUpdated(): void {
-    this.dispatchEventToListeners(Events.UPDATED);
-  }
-}
-
-export class SymbolizedSyntaxError extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
-  readonly message: string;
-  #uiLocation: Workspace.UISourceCode.UILocation|null = null;
-
-  constructor(message: string) {
-    super();
-    this.message = message;
+  get syntaxErrorLocation(): Workspace.UISourceCode.UILocation|null {
+    return this.#syntaxErrorLocation;
   }
 
-  get uiLocation(): Workspace.UISourceCode.UILocation|null {
-    return this.#uiLocation;
-  }
-
-  static async fromExceptionDetails(
-      target: SDK.Target.Target, debuggerWorkspaceBinding: DebuggerWorkspaceBinding,
-      exceptionDetails: Protocol.Runtime.ExceptionDetails): Promise<SymbolizedSyntaxError|null> {
+  /**
+   * Evaluates if we should populate the `syntaxErrorLocation` based on the provided exception details.
+   *
+   * There are three primary cases for SyntaxError:
+   * 1. Programmatic `SyntaxError`: Thrown via `throw new SyntaxError('...', {cause: ...})`. Has a full stack trace,
+   *    and an optional cause. The exception details point to the `throw` statement, which is identical to the top frame.
+   *    We do NOT want to populate `syntaxErrorLocation` here to avoid redundant location rendering in the UI.
+   * 2. Script parse failure: Failed to parse a script. Has no stack trace but possesses a compile-time location.
+   *    We DO want to populate `syntaxErrorLocation` to highlight where the parse failed.
+   * 3. `eval` parse failure: Failed to parse an eval string. Has a stack trace pointing to the `eval` call site
+   *    and a compile-time location of the parse failure within the string. The exception details location differs
+   *    from the top frame. We DO want to populate `syntaxErrorLocation` here.
+   */
+  static async createForSyntaxError(target: SDK.Target.Target, debuggerWorkspaceBinding: DebuggerWorkspaceBinding,
+                                    message: string, exceptionDetails: Protocol.Runtime.ExceptionDetails,
+                                    stackTrace: StackTrace.StackTrace.ParsedErrorStackTrace,
+                                    cause: SymbolizedError|null): Promise<SymbolizedErrorObject> {
     const {exception, scriptId, lineNumber, columnNumber} = exceptionDetails;
     if (!exception || exception.subtype !== 'error' || exception.className !== 'SyntaxError') {
-      throw new Error('SymbolizedSyntaxError.fromExceptionDetails expects a SyntaxError');
+      throw new Error('SymbolizedErrorObject.createForSyntaxError expects a SyntaxError');
     }
+
+    const symbolizedError = new SymbolizedErrorObject(message, stackTrace, cause);
+
     if (!scriptId) {
-      return null;
+      return symbolizedError;
     }
 
-    const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
-    if (!debuggerModel) {
-      return null;
+    const topFrame = exceptionDetails.stackTrace?.callFrames[0];
+    const isProgrammaticThrow = topFrame && topFrame.scriptId === scriptId && topFrame.lineNumber === lineNumber &&
+        topFrame.columnNumber === columnNumber;
+
+    if (!isProgrammaticThrow) {
+      const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
+      if (debuggerModel) {
+        const rawLocation = debuggerModel.createRawLocationByScriptId(scriptId, lineNumber, columnNumber);
+        // We don't implement dispose here. We won't create many of these so a couple
+        // LiveLocationPools and SymbolizedErrorObject instances leaking is fine.
+        await debuggerWorkspaceBinding.createLiveLocation(
+            rawLocation, symbolizedError.#updateSyntaxErrorLocation.bind(symbolizedError), new LiveLocationPool());
+      }
     }
 
-    const rawLocation = debuggerModel.createRawLocationByScriptId(scriptId, lineNumber, columnNumber);
-    const symbolizedSyntaxError = new SymbolizedSyntaxError(exception.description || '');
-
-    // We don't implement dispose here. We won't create many of these so a couple
-    // LiveLocationPools and SymbolizedSyntaxError instances leaking is fine.
-    await debuggerWorkspaceBinding.createLiveLocation(
-        rawLocation, symbolizedSyntaxError.#update.bind(symbolizedSyntaxError), new LiveLocationPool());
+    return symbolizedError;
+  }
 
-    return symbolizedSyntaxError;
+  async #updateSyntaxErrorLocation(liveLocation: LiveLocation): Promise<void> {
+    this.#syntaxErrorLocation = await liveLocation.uiLocation();
+    this.dispatchEventToListeners(Events.UPDATED);
   }
 
-  async #update(liveLocation: LiveLocation): Promise<void> {
-    this.#uiLocation = await liveLocation.uiLocation();
+  #fireUpdated(): void {
     this.dispatchEventToListeners(Events.UPDATED);
   }
 }

package/front_end/models/extensions/ExtensionAPI.ts

@@ -1067,6 +1067,46 @@ self.injectedExtensionAPI = function(
     return typeof lastArgument === 'function' ? lastArgument as (...args: unknown[]) => unknown : undefined;
   }
 
+  /**
+   * Helper to support both callback and Promise-based APIs.
+   *
+   * @param args The arguments object of the calling function.
+   * @returns An object containing either the `callback` function, or the
+   *    `promise` and its `resolve`/`reject` functions.
+   */
+  function callbackOrPromise<ResolveT, CallbackArgsT extends unknown[] = [ResolveT]>(args: IArguments): {
+    callback?: (...args: CallbackArgsT) => void,
+    promise?: Promise<ResolveT>,
+    resolve?: (value: ResolveT) => void,
+    reject?: (error: unknown) => void,
+  } {
+    const callback = extractCallbackArgument(args);
+    if (callback) {
+      return {callback: callback as (...args: CallbackArgsT) => void};
+    }
+    const {promise, resolve, reject} = Promise.withResolvers<ResolveT>();
+    return {promise, resolve, reject};
+  }
+
+  /**
+   * Checks if the `response` from the ExtensionServer indicates an error. If an
+   * error occurred and a `Promise` `reject` function is provided, this function
+   * will reject the promise with a generic 'DevTools API encountered an error' Error.
+   *
+   * @param response The response object from the ExtensionServer.
+   * @param reject The promise reject function, if applicable.
+   * @returns `true` if an error occurred and the promise was rejected, `false`
+   *    otherwise.
+   */
+  function checkErrorAndReject(response: unknown, reject?: (error: Error) => void): boolean {
+    const res = response as {isError?: boolean, description?: string, details?: unknown[]};
+    if (res.isError && reject) {
+      reject(new Error('DevTools API encountered an error'));
+      return true;
+    }
+    return false;
+  }
+
   const LanguageServicesAPI = declareInterfaceClass(LanguageServicesAPIImpl);
   const RecorderServicesAPI = declareInterfaceClass(RecorderServicesAPIImpl);
   const Performance = declareInterfaceClass(PerformanceImpl);
@@ -1247,43 +1287,68 @@ self.injectedExtensionAPI = function(
       extensionServer.sendRequest({command: PrivateAPI.Commands.Reload, options});
     },
 
-    eval: function(
-              expression: string,
-              evaluateOptions: {scriptExecutionContext?: string, frameURL?: string, useContentScriptContext?: boolean}):
-              Object |
-        null {
-          const callback = extractCallbackArgument(arguments);
+    eval: function<E = unknown>(this: PublicAPI.Chrome.DevTools.InspectedWindow, expression: string,
+                                optionsOrCallback?: unknown,
+                                _callback?: (result: unknown, exceptionInfo: object) => void): Promise<E>|
+        void {
+          const options = (typeof optionsOrCallback === 'object' && optionsOrCallback !== null) ?
+              optionsOrCallback as PrivateAPI.EvaluateOptions :
+              undefined;
+
+          const {callback: callbackArg, promise, resolve, reject} = callbackOrPromise<E, [unknown, object?]>(arguments);
+
           function callbackWrapper(result: unknown): void {
-            const {isError, isException, value} = result as {
-              value: unknown,
+            if (checkErrorAndReject(result, reject)) {
+              return;
+            }
+
+            const res = result as {
+              value?: unknown,
               isError?: boolean,
               isException?: boolean,
             };
-            if (isError || isException) {
-              callback?.(undefined, result);
+
+            if (res.isException) {
+              reject?.(res);
+            } else {
+              resolve?.(res.value as E);
+            }
+
+            if (res.isError || res.isException) {
+              callbackArg?.(undefined, res);
             } else {
-              callback?.(value);
+              callbackArg?.(res.value);
             }
           }
           extensionServer.sendRequest(
-              {
-                command: PrivateAPI.Commands.EvaluateOnInspectedPage,
-                expression,
-                evaluateOptions: (typeof evaluateOptions === 'object' ? evaluateOptions : undefined),
-              },
-              callback && callbackWrapper);
-          return null;
-        },
+              {command: PrivateAPI.Commands.EvaluateOnInspectedPage, expression, evaluateOptions: options},
+              callbackWrapper);
 
-    getResources: function(callback?: (resources: PublicAPI.Chrome.DevTools.Resource[]) => unknown): void {
-      function wrapResource(resourceData: APIImpl.ResourceData): APIImpl.Resource {
-        return new (Constructor(Resource))(resourceData);
-      }
-      function callbackWrapper(resources: unknown): void {
-        callback?.((resources as APIImpl.ResourceData[]).map(wrapResource));
-      }
-      extensionServer.sendRequest({command: PrivateAPI.Commands.GetPageResources}, callback && callbackWrapper);
-    },
+          return promise;
+        } as PublicAPI.Chrome.DevTools.InspectedWindow['eval'],
+
+    getResources: function(this: PublicAPI.Chrome.DevTools.InspectedWindow,
+                           _callback?: (resources: PublicAPI.Chrome.DevTools.Resource[]) => void):
+                      Promise<PublicAPI.Chrome.DevTools.Resource[]>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} =
+              callbackOrPromise<PublicAPI.Chrome.DevTools.Resource[]>(arguments);
+
+          function callbackWrapper(response: unknown): void {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+
+            const wrappedResources =
+                ((response || []) as APIImpl.ResourceData[]).map(r => new (Constructor(Resource))(r));
+            resolve?.(wrappedResources);
+            callbackArg?.(wrappedResources);
+          }
+
+          extensionServer.sendRequest({command: PrivateAPI.Commands.GetPageResources}, callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.InspectedWindow['getResources'],
   };
 
   function ResourceImpl(this: APIImpl.Resource, resourceData: APIImpl.ResourceData): void {
@@ -1292,9 +1357,9 @@ self.injectedExtensionAPI = function(
     this._buildId = resourceData.buildId;
   }
 
-  (ResourceImpl.prototype as Pick<
-       APIImpl.Resource,
-       'url'|'type'|'buildId'|'getContent'|'setContent'|'setFunctionRangesForScript'|'attachSourceMapURL'>) = {
+  (ResourceImpl.prototype as
+   Pick<APIImpl.Resource,
+        'url'|'type'|'buildId'|'getContent'|'setContent'|'setFunctionRangesForScript'|'attachSourceMapURL'>) = {
     get url(): string {
       return (this as APIImpl.Resource)._url;
     },
@@ -1307,25 +1372,51 @@ self.injectedExtensionAPI = function(
       return (this as APIImpl.Resource)._buildId;
     },
 
-    getContent: function(this: APIImpl.Resource, callback?: (content: string, encoding: string) => unknown): void {
-      function callbackWrapper(response: unknown): void {
-        const {content, encoding} = response as {content: string, encoding: string};
-        callback?.(content, encoding);
-      }
+    getContent: function(this: APIImpl.Resource, _callback?: (content: string, encoding: string) => void): Promise<{
+                  content: string, encoding: string,
+                }>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} =
+              callbackOrPromise<{content: string, encoding: string}, [string, string]>(arguments);
 
-      extensionServer.sendRequest(
-          {command: PrivateAPI.Commands.GetResourceContent, url: this._url}, callback && callbackWrapper);
-    },
+          function callbackWrapper(response: unknown): void {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
 
-    setContent: function(
-        this: APIImpl.Resource, content: string, commit: boolean, callback: (error?: Object) => unknown): void {
-      extensionServer.sendRequest(
-          {command: PrivateAPI.Commands.SetResourceContent, url: this._url, content, commit},
-          callback as (response: unknown) => unknown);
-    },
+            const {content, encoding} = response as {content: string, encoding: string};
+            resolve?.({content, encoding});
+            callbackArg?.(content, encoding);
+          }
+
+          extensionServer.sendRequest({command: PrivateAPI.Commands.GetResourceContent, url: this._url},
+                                      callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.Resource['getContent'],
+
+    setContent: function(this: APIImpl.Resource, content: string, commit: boolean,
+                         _callback?: (status?: object) => void): Promise<void>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} = callbackOrPromise<void, [object]>(arguments);
+
+          function callbackWrapper(response: unknown): void {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+
+            resolve?.();
+            callbackArg?.(response as object);
+          }
+
+          extensionServer.sendRequest(
+              {command: PrivateAPI.Commands.SetResourceContent, url: this._url, content, commit}, callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.Resource['setContent'],
 
-    setFunctionRangesForScript: function(
-        this: APIImpl.Resource, ranges: PublicAPI.Chrome.DevTools.NamedFunctionRange[]): Promise<void> {
+    setFunctionRangesForScript: function(this: APIImpl.Resource,
+                                         ranges: PublicAPI.Chrome.DevTools.NamedFunctionRange[]): Promise<void> {
       return new Promise(
           (resolve, reject) => extensionServer.sendRequest(
               {

package/front_end/models/har/Importer.ts

@@ -40,6 +40,7 @@ export class Importer {
       }
       const request = SDK.NetworkRequest.NetworkRequest.createWithoutBackendRequest(
           'har-' + requests.length, entry.request.url, documentURL, initiator);
+      request.setIsImportedHar(true);
       const page = pageref ? pages.get(pageref) : undefined;
       if (!pageLoad && pageref && page) {
         pageLoad = Importer.buildPageLoad(page, request);

package/front_end/models/source_map_scopes/FunctionCodeResolver.ts

@@ -203,7 +203,14 @@ function createFunctionCode(
 }
 
 /**
- * The input location may be a source mapped location or a raw location.
+ * Resolves the function code and its surrounding context for a given location.
+ *
+ * The input location (line, column) may be either an authored (source-mapped)
+ * location or a raw location. The function will attempt to resolve it to a
+ * raw location regardless. This is necessary because callers (such as AI
+ * assistance) may work with either format.
+ *
+ * We filter projects by `target` to prevent cross-origin leaks.
  */
 export async function getFunctionCodeFromLocation(
     target: SDK.Target.Target, url: Platform.DevToolsPath.UrlString, line: number, column: number,
@@ -213,10 +220,13 @@ export async function getFunctionCodeFromLocation(
     throw new Error('missing debugger model');
   }
 
-  let uiSourceCode;
+  let uiSourceCode: Workspace.UISourceCode.UISourceCode|null = null;
   const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
   const projects = debuggerWorkspaceBinding.workspace.projectsForType(Workspace.Workspace.projectTypes.Network);
   for (const project of projects) {
+    if (Bindings.NetworkProject.NetworkProject.getTargetForProject(project) !== target) {
+      continue;
+    }
     uiSourceCode = project.uiSourceCodeForURL(url);
     if (uiSourceCode) {
       break;