chrome-devtools-frontend 1.0.1690531 → 1.0.1695017

package/front_end/models/ai_assistance/data_formatters/NetworkRequestFormatter.ts

@@ -2,9 +2,8 @@
 // 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 type * as Platform from '../../../core/platform/platform.js';
-import type * as SDK from '../../../core/sdk/sdk.js';
+import * as SDK from '../../../core/sdk/sdk.js';
 import * as TextUtils from '../../../core/text_utils/text_utils.js';
 import * as Protocol from '../../../generated/protocol.js';
 import * as Logs from '../../logs/logs.js';
@@ -16,7 +15,10 @@ const MAX_HEADERS_SIZE = 1000;
 const MAX_BODY_SIZE = 10000;
 
 /**
- * Sanitizes the set of headers, removing values that are not on the allow-list and replacing them with '<redacted>'.
+ * Sanitizes headers by replacing unapproved header values with '<redacted>'.
+ *
+ * @param headers List of header name/value pairs to sanitize.
+ * @returns Sanitized list of headers with unapproved values redacted.
  */
 export function sanitizeHeaders(headers: Array<{name: string, value: string}>): Array<{name: string, value: string}> {
   return headers.map(header => {
@@ -27,9 +29,60 @@ export function sanitizeHeaders(headers: Array<{name: string, value: string}>):
   });
 }
 
+/**
+ * Options for configuring {@link NetworkRequestFormatter}.
+ */
+export interface NetworkRequestFormatterOptions {
+  /**
+   * The security origin used to evaluate Same-Origin Policy (SOP) and Cross-Origin
+   * Resource Sharing (CORS) access.
+   *
+   * This is required because evaluating access solely against `request.initiatorSecurityOrigin()`
+   * is unsafe in cross-origin embedded contexts.
+   *
+   * Example:
+   * When debugging a page at `https://example.com` (the active conversation origin), an embedded
+   * `<iframe>` at `https://third-party.com` may fetch `https://third-party.com/api/user.json`.
+   * Relative to the iframe, that request is same-origin (`request.initiatorSecurityOrigin() === https://third-party.com`).
+   * However, from the perspective of the top-level conversation (`https://example.com`), that request
+   * is cross-origin. Its response body and unexposed headers must be redacted to prevent leaking
+   * unauthorized data into the prompt.
+   */
+  accessingSecurityOrigin: SDK.SecurityOrigin.SecurityOrigin;
+  /** Optional network log instance for resolving initiator graphs. */
+  networkLog?: Logs.NetworkLog.NetworkLog;
+}
+
 export class NetworkRequestFormatter {
   #calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator;
   #request: SDK.NetworkRequest.NetworkRequest;
+  readonly #networkLog?: Logs.NetworkLog.NetworkLog;
+  readonly #accessingSecurityOrigin: SDK.SecurityOrigin.SecurityOrigin;
+
+  /**
+   * @param request The network request to format.
+   * @param calculator Calculator for request timing metrics.
+   * @param options Configuration options specifying the accessing security origin.
+   */
+  constructor(
+      request: SDK.NetworkRequest.NetworkRequest,
+      calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator,
+      options: NetworkRequestFormatterOptions,
+  ) {
+    this.#request = request;
+    this.#calculator = calculator;
+    this.#networkLog = options.networkLog;
+    this.#accessingSecurityOrigin = options.accessingSecurityOrigin;
+  }
+
+  /**
+   * Evaluates the response access mode for this network request relative to the accessing security origin.
+   *
+   * @returns The evaluated `ResponseAccessMode`.
+   */
+  responseAccessMode(): SDK.NetworkRequestAccess.ResponseAccessMode {
+    return SDK.NetworkRequestAccess.evaluateResponseAccessMode(this.#request, this.#accessingSecurityOrigin);
+  }
 
   static allowHeader(headerName: string): boolean {
     return allowedHeaders.has(headerName.toLowerCase().trim());
@@ -73,9 +126,9 @@ export class NetworkRequestFormatter {
       initiatorUrl: Platform.DevToolsPath.UrlString,
       allowedOrigin: Platform.DevToolsPath.UrlString,
       ): string {
-    // We extract the origin, and if it is invalid/empty we default to redacting.
-    const initiatorOrigin = Common.ParsedURL.ParsedURL.extractOrigin(initiatorUrl);
-    if (initiatorOrigin && initiatorOrigin === allowedOrigin) {
+    const initiatorOrigin = SDK.SecurityOrigin.SecurityOrigin.create(initiatorUrl);
+    const targetOrigin = SDK.SecurityOrigin.SecurityOrigin.create(allowedOrigin);
+    if (initiatorOrigin.isSameOriginWith(targetOrigin)) {
       return initiatorUrl;
     }
     return '<redacted cross-origin initiator URL>';
@@ -131,28 +184,35 @@ export class NetworkRequestFormatter {
     return lines.length > 0 ? `${lines.join('\n')}\n` : '';
   }
 
-  readonly #networkLog: Logs.NetworkLog.NetworkLog;
-
-  constructor(
-      request: SDK.NetworkRequest.NetworkRequest,
-      calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator,
-      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
-      networkLog: Logs.NetworkLog.NetworkLog = Logs.NetworkLog.NetworkLog.instance(),
-  ) {
-    this.#request = request;
-    this.#calculator = calculator;
-    this.#networkLog = networkLog;
-  }
-
   formatRequestHeaders(): string {
     return NetworkRequestFormatter.formatHeaders('Request headers:', this.#request.requestHeaders());
   }
 
+  /**
+   * Formats response headers for the AI prompt.
+   *
+   * Headers are filtered based on the request's evaluated ResponseAccessMode:
+   * - Opaque cross-origin requests only include CORS-safelisted response headers.
+   * - CORS-authorized requests include CORS-safelisted and Access-Control-Expose-Headers.
+   * - Same-origin requests include all response headers.
+   * Values of headers not present on the global allowedHeaders list are then redacted.
+   */
   formatResponseHeaders(): string {
-    return NetworkRequestFormatter.formatHeaders('Response headers:', this.#request.responseHeaders);
+    const accessMode = this.responseAccessMode();
+    const headers = SDK.NetworkRequestAccess.getFilterableResponseHeaders(this.#request, accessMode);
+    return NetworkRequestFormatter.formatHeaders('Response headers:', headers);
   }
 
+  /**
+   * Formats the response body for the AI prompt.
+   *
+   * For opaque cross-origin requests, the response body is redacted because the accessing
+   * security origin is forbidden by the Same-Origin Policy from reading it.
+   */
   async formatResponseBody(): Promise<string> {
+    if (this.responseAccessMode() === SDK.NetworkRequestAccess.ResponseAccessMode.OPAQUE_CROSS_ORIGIN) {
+      return SDK.NetworkRequestAccess.REDACTED_RESPONSE_BODY;
+    }
     return await NetworkRequestFormatter.formatBody('Response body:', this.#request, MAX_BODY_SIZE);
   }
 
@@ -203,22 +263,9 @@ Request initiator chain:\n${this.formatRequestInitiatorChain()}`;
    * the request's origin.
    */
   formatRequestInitiatorChain(): string {
-    const allowedOrigin = Common.ParsedURL.ParsedURL.extractOrigin(this.#request.url());
-    let initiatorChain = '';
-    let lineStart = '- URL: ';
-    const graph = this.#networkLog.initiatorGraphForRequest(this.#request);
-
-    for (const initiator of Array.from(graph.initiators).reverse()) {
-      initiatorChain = initiatorChain + lineStart +
-          NetworkRequestFormatter.formatInitiatorUrl(initiator.url(), allowedOrigin) + '\n';
-      lineStart = '\t' + lineStart;
-      if (initiator === this.#request) {
-        initiatorChain =
-            this.#formatRequestInitiated(graph.initiated, this.#request, initiatorChain, lineStart, allowedOrigin);
-      }
-    }
-
-    return initiatorChain.trim();
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    const networkLog = this.#networkLog ?? Logs.NetworkLog.NetworkLog.instance();
+    return formatRequestInitiatorChain(this.#request, networkLog);
   }
 
   formatNetworkRequestTiming(): string {
@@ -269,32 +316,62 @@ Request initiator chain:\n${this.formatRequestInitiatorChain()}`;
 
     return labels.filter(label => !!label.value).map(label => `${label.label}: ${label.value}`).join('\n');
   }
+}
 
-  #formatRequestInitiated(
-      initiated: Map<SDK.NetworkRequest.NetworkRequest, SDK.NetworkRequest.NetworkRequest>,
-      parentRequest: SDK.NetworkRequest.NetworkRequest,
-      initiatorChain: string,
-      lineStart: string,
-      allowedOrigin: Platform.DevToolsPath.UrlString,
-      ): string {
-    const visited = new Set<SDK.NetworkRequest.NetworkRequest>();
-
-    // this.request should be already in the tree when build initiator part
-    visited.add(this.#request);
-    for (const [keyRequest, initiatedRequest] of initiated.entries()) {
-      if (initiatedRequest === parentRequest) {
-        if (!visited.has(keyRequest)) {
-          visited.add(keyRequest);
-          initiatorChain = initiatorChain + lineStart +
-              NetworkRequestFormatter.formatInitiatorUrl(keyRequest.url(), allowedOrigin) + '\n';
-          initiatorChain =
-              this.#formatRequestInitiated(initiated, keyRequest, initiatorChain, '\t' + lineStart, allowedOrigin);
-        }
-      }
+/**
+ * Formats the initiator chain for a given network request into a formatted string.
+ *
+ * @param request The network request to format the initiator chain for.
+ * @param networkLog Network log instance used to build the initiator graph.
+ * @returns Formatted initiator chain.
+ */
+export function formatRequestInitiatorChain(
+    request: SDK.NetworkRequest.NetworkRequest,
+    networkLog: Logs.NetworkLog.NetworkLog,
+    ): string {
+  const allowedOrigin = request.url();
+  let initiatorChain = '';
+  let lineStart = '- URL: ';
+  const graph = networkLog.initiatorGraphForRequest(request);
+
+  for (const initiator of Array.from(graph.initiators).reverse()) {
+    initiatorChain =
+        initiatorChain + lineStart + NetworkRequestFormatter.formatInitiatorUrl(initiator.url(), allowedOrigin) + '\n';
+    lineStart = '\t' + lineStart;
+    if (initiator === request) {
+      initiatorChain =
+          formatRequestInitiated(graph.initiated, request, request, initiatorChain, lineStart, allowedOrigin);
     }
+  }
 
-    return initiatorChain;
+  return initiatorChain.trim();
+}
+
+function formatRequestInitiated(
+    initiated: Map<SDK.NetworkRequest.NetworkRequest, SDK.NetworkRequest.NetworkRequest>,
+    rootRequest: SDK.NetworkRequest.NetworkRequest,
+    parentRequest: SDK.NetworkRequest.NetworkRequest,
+    initiatorChain: string,
+    lineStart: string,
+    allowedOrigin: Platform.DevToolsPath.UrlString,
+    ): string {
+  const visited = new Set<SDK.NetworkRequest.NetworkRequest>();
+
+  // rootRequest should be already in the tree when building initiator part
+  visited.add(rootRequest);
+  for (const [keyRequest, initiatedRequest] of initiated.entries()) {
+    if (initiatedRequest === parentRequest) {
+      if (!visited.has(keyRequest)) {
+        visited.add(keyRequest);
+        initiatorChain = initiatorChain + lineStart +
+            NetworkRequestFormatter.formatInitiatorUrl(keyRequest.url(), allowedOrigin) + '\n';
+        initiatorChain =
+            formatRequestInitiated(initiated, rootRequest, keyRequest, initiatorChain, '\t' + lineStart, allowedOrigin);
+      }
+    }
   }
+
+  return initiatorChain;
 }
 
 // Header names that could be included in the prompt, lowercase.

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

@@ -2,10 +2,8 @@
 // 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 SDK from '../../../core/sdk/sdk.js';
 import type * as Protocol from '../../../generated/protocol.js';
-import {areOriginsEquivalent, extractContextOrigin, isOpaqueOrigin} from '../AiOrigins.js';
 
 import {MAX_TARGET_ORIGINS} from './DOMStorageUtils.js';
 import type {OriginLockCapability} from './Tool.js';
@@ -27,8 +25,16 @@ export interface CookieDetails {
 }
 
 /**
- * Resolves and validates target origins against origin-lock constraints and primary page target.
- * If `requestedOrigins` is omitted or empty, defaults to the established context origin.
+ * Resolves and validates target origins against the established context origin and primary page target.
+ *
+ * When `requestedOrigins` is empty or omitted, defaults to the established context origin.
+ * Rejects opaque origins, mismatches with the primary page origin, and cross-origin targets.
+ * Limits results to at most `MAX_TARGET_ORIGINS` unique origins.
+ *
+ * @param requestedOrigins Optional list of origin URLs to validate.
+ * @param context The origin lock capability containing the established origin.
+ * @param targetManager The target manager used to resolve the primary page target.
+ * @returns An object with validated target origins and the primary page target, or an error object.
  */
 export function resolveAllowedTargetOrigins(
     requestedOrigins: string[]|undefined,
@@ -38,8 +44,8 @@ export function resolveAllowedTargetOrigins(
   error: string,
 }
 {
-  const allowedOrigin = context.getEstablishedOrigin();
-  if (!allowedOrigin || isOpaqueOrigin(allowedOrigin) || isOpaqueOrigin(extractContextOrigin(allowedOrigin))) {
+  const establishedOrigin = context.getEstablishedOrigin();
+  if (!establishedOrigin || establishedOrigin.isOpaque()) {
     return {error: 'No origin available or not allowed.'};
   }
 
@@ -48,15 +54,19 @@ export function resolveAllowedTargetOrigins(
     return {error: 'Primary page target not found.'};
   }
 
-  const pageOrigin = Common.ParsedURL.ParsedURL.extractOrigin(primaryPageTarget.inspectedURL());
-  if (!pageOrigin || !areOriginsEquivalent(pageOrigin, allowedOrigin)) {
+  const pageOrigin = primaryPageTarget.inspectedSecurityOrigin();
+  if (!pageOrigin.isSameOriginWith(establishedOrigin)) {
     return {error: 'Page origin does not match allowed origin.'};
   }
 
-  const rawOrigins =
-      (Array.isArray(requestedOrigins) && requestedOrigins.length > 0) ? requestedOrigins : [allowedOrigin];
-  const validOrigins = rawOrigins.map(origin => extractContextOrigin(origin))
-                           .filter(origin => areOriginsEquivalent(origin, allowedOrigin));
+  const candidateOrigins: SDK.SecurityOrigin.SecurityOrigin[] =
+      (Array.isArray(requestedOrigins) && requestedOrigins.length > 0) ?
+      requestedOrigins.map(origin => SDK.SecurityOrigin.SecurityOrigin.create(origin)) :
+      [establishedOrigin];
+
+  const validOrigins =
+      candidateOrigins.filter(origin => origin.isSameOriginWith(establishedOrigin)).map(origin => origin.siteId());
+
   const targetOrigins = Array.from(new Set(validOrigins)).slice(0, MAX_TARGET_ORIGINS);
   if (targetOrigins.length === 0) {
     return {error: 'No valid origins found.'};
@@ -72,36 +82,16 @@ export type GetCookiesForOriginResult = {
 };
 
 /**
- * Finds the resource tree frame matching the target origin within the primary page's outermost target tree.
- */
-export function findFrameForOrigin(
-    origin: string,
-    targetManager: SDK.TargetManager.TargetManager,
-    primaryPageTarget: SDK.Target.Target,
-    ): SDK.ResourceTreeModel.ResourceTreeFrame|null {
-  const targetOrigin = extractContextOrigin(origin);
-  for (const frame of SDK.ResourceTreeModel.ResourceTreeModel.frames(targetManager)) {
-    if (frame.resourceTreeModel().target().outermostTarget() !== primaryPageTarget) {
-      continue;
-    }
-    if (frame.securityOrigin && areOriginsEquivalent(frame.securityOrigin, targetOrigin)) {
-      return frame;
-    }
-  }
-  return null;
-}
-
-/**
- * Retrieves all cookies accessible to the target origin, strictly excluding HttpOnly cookies.
+ * Retrieves all cookies accessible to the target origin, excluding HttpOnly cookies.
  * Locates the matching frame within the primary page target tree, queries its CookieModel,
  * and filters cookies by security origin.
  */
 export async function getCookiesForOrigin(
     origin: string,
-    targetManager: SDK.TargetManager.TargetManager,
     primaryPageTarget: SDK.Target.Target,
     ): Promise<GetCookiesForOriginResult> {
-  const frame = findFrameForOrigin(origin, targetManager, primaryPageTarget);
+  const targetOrigin = SDK.SecurityOrigin.SecurityOrigin.create(origin);
+  const frame = SDK.ResourceTreeModel.ResourceTreeModel.frameForOrigin(primaryPageTarget, targetOrigin);
   if (!frame) {
     return {error: `Frame not found or origin disallowed for ${origin}`};
   }

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

@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 import * as SDK from '../../../core/sdk/sdk.js';
-import {areOriginsEquivalent, extractContextOrigin} from '../AiOrigins.js';
 
 /**
  * Maximum number of target origins allowed in a single batch query to bound
@@ -42,7 +41,10 @@ export function resolveDOMStorages(
   const resolvedStorages: SDK.DOMStorageModel.DOMStorage[] = [];
   const seenStorageKeys = new Set<string>();
   const isLocalStorage = type === 'localStorage';
-  const targetOrigin = extractContextOrigin(origin);
+  const targetOrigin = SDK.SecurityOrigin.SecurityOrigin.create(origin);
+  if (targetOrigin.isOpaque()) {
+    return [];
+  }
 
   const domStorageModels = targetManager.models(SDK.DOMStorageModel.DOMStorageModel);
   for (const domStorageModel of domStorageModels) {
@@ -78,7 +80,8 @@ export function resolveDOMStorages(
       // Parse the serialized StorageKey (e.g. "https://example.com/^0https://top.com") to
       // extract the partition's origin for equivalence comparison.
       const parsedKey = SDK.StorageKeyManager.parseStorageKey(currentStorageKey);
-      if (areOriginsEquivalent(parsedKey.origin, targetOrigin)) {
+      const parsedOrigin = SDK.SecurityOrigin.SecurityOrigin.create(parsedKey.origin);
+      if (parsedOrigin.isSameOriginWith(targetOrigin)) {
         resolvedStorages.push(storage);
       }
     }

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

@@ -13,6 +13,8 @@ import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  isOriginAllowedByLock,
+  type OriginLockCapability,
   type PageExecutionCapability,
   type StyleMutationCapability,
   type ToolArgs,
@@ -30,7 +32,8 @@ export interface ExecuteJavaScriptArgs extends ToolArgs {
 }
 
 export class ExecuteJavaScriptTool implements
-    DataTool<ExecuteJavaScriptArgs, unknown, BaseToolCapability&PageExecutionCapability&StyleMutationCapability> {
+    DataTool<ExecuteJavaScriptArgs, unknown,
+             BaseToolCapability&PageExecutionCapability&StyleMutationCapability&OriginLockCapability> {
   readonly name: ToolName = ToolName.EXECUTE_JAVASCRIPT;
 
   readonly description: string =
@@ -120,7 +123,7 @@ const data = {
 
   async handler(
       params: ExecuteJavaScriptArgs,
-      context: BaseToolCapability&PageExecutionCapability&StyleMutationCapability,
+      context: BaseToolCapability&PageExecutionCapability&StyleMutationCapability&OriginLockCapability,
       options?: FunctionHandlerOptions,
       ): Promise<DataHandlerResult<unknown>> {
     const executionNode = context.getExecutionContextNode();
@@ -128,6 +131,10 @@ const data = {
       return {error: 'Error: Could not find the context node for execution.'};
     }
 
+    if (!isOriginAllowedByLock(context.getEstablishedOrigin(), executionNode.securityOrigin())) {
+      return {error: 'Error: Cannot execute JavaScript on cross-origin target.'};
+    }
+
     if (Root.Runtime.hostConfig.devToolsAiV2Architecture?.enabled) {
       const validationResult = await ExecuteJavaScriptTool.validateAndFormatCode(params.code);
       if (validationResult.error) {

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

@@ -110,7 +110,7 @@ export class GetCookieValuesTool implements DataTool<GetCookieValuesArgs, GetCoo
     const cookiesByOrigin: GetCookieValuesResult['cookiesByOrigin'] = {};
 
     await Promise.all(targetOrigins.map(async origin => {
-      const result = await getCookiesForOrigin(origin, targetManager, primaryPageTarget);
+      const result = await getCookiesForOrigin(origin, primaryPageTarget);
       if ('error' in result) {
         cookiesByOrigin[origin] = {error: result.error};
         return;

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

@@ -12,6 +12,7 @@ import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  isOriginAllowedByLock,
   type OriginLockCapability,
   type TargetCapability,
   type ToolArgs,
@@ -81,7 +82,7 @@ export class GetElementAccessibilityDetailsTool implements
       context: BaseToolCapability&TargetCapability&OriginLockCapability,
       ): Promise<DataHandlerResult<string>> {
     const establishedOrigin = context.getEstablishedOrigin();
-    if (!establishedOrigin) {
+    if (!establishedOrigin || establishedOrigin.isOpaque()) {
       return {error: 'Error: Origin lock is not established.'};
     }
 
@@ -101,7 +102,7 @@ export class GetElementAccessibilityDetailsTool implements
 
     const nodeContext = new DOMNodeContext(resolved);
     // Security check: Ensure the element matches the active conversation's origin lock.
-    if (!nodeContext.isOriginAllowed(establishedOrigin)) {
+    if (!isOriginAllowedByLock(establishedOrigin, nodeContext.getOrigin())) {
       return {error: 'Error: Node does not belong to the locked origin.'};
     }
 

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

@@ -5,7 +5,6 @@
 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 {canResourceContentsBeReadForTrace} from '../AiOrigins.js';
 
 import {
   type BaseToolCapability,
@@ -77,7 +76,7 @@ export class GetFunctionCodeTool implements
       return {error: 'Performance trace context is not available.'};
     }
 
-    if (performanceTraceContext.getOrigin().startsWith('imported-trace://')) {
+    if (performanceTraceContext.isImported()) {
       return {error: 'Cannot use this tool on an imported file.'};
     }
 
@@ -85,9 +84,8 @@ export class GetFunctionCodeTool implements
       return {error: 'Missing arg: scriptUrl'};
     }
 
-    const allowedOrigin = performanceTraceContext.getOrigin();
-    if (!canResourceContentsBeReadForTrace(params.scriptUrl, allowedOrigin)) {
-      return {error: 'Script not found'};
+    if (!performanceTraceContext.canAccessResource(params.scriptUrl)) {
+      return {error: 'Resource not found'};
     }
 
     if (params.line === undefined) {

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

@@ -205,7 +205,7 @@ export class GetInsightDetailsTool implements
     }
 
     const widgets: AiWidget[] = [];
-    const isImportedTrace = performanceTraceContext.getOrigin().startsWith('imported-trace://');
+    const isImportedTrace = performanceTraceContext.isImported();
     if (!isImportedTrace) {
       const domTreeWidget = await this.#generateDOMTreeWidget(insight, insightSet, capabilities.getTarget());
       if (domTreeWidget) {

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

@@ -6,14 +6,13 @@ import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
 import * as Logs from '../../logs/logs.js';
 import * as NetworkTimeCalculator from '../../network_time_calculator/network_time_calculator.js';
-import {isOpaqueOrigin} from '../AiOrigins.js';
-import {getRequestContextOrigin} from '../contexts/RequestContext.js';
 import {NetworkRequestFormatter} from '../data_formatters/NetworkRequestFormatter.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  isOriginAllowedByLock,
   type OriginLockCapability,
   type ToolArgs,
   ToolName,
@@ -78,10 +77,10 @@ export class GetNetworkRequestDetailsTool implements
       ): Promise<DataHandlerResult<unknown>> {
     // A conversation is locked to an origin once the first query is made.
     // We only allow inspecting requests matching the conversation's established origin.
-    const origin = context.getEstablishedOrigin();
+    const establishedOrigin = context.getEstablishedOrigin();
 
     // Opaque origins are never allowed to be used as context.
-    if (origin && isOpaqueOrigin(origin)) {
+    if (!establishedOrigin || establishedOrigin.isOpaque()) {
       return {
         error: 'Opaque origin not allowed',
       };
@@ -94,13 +93,8 @@ export class GetNetworkRequestDetailsTool implements
         return false;
       }
 
-      // To prevent cross-origin prompt injection attacks, HAR-imported requests
-      // are assigned a virtual origin (e.g., `imported-har://${domain}`) rather than
-      // sharing the origin of live pages.
-      const requestOrigin = getRequestContextOrigin(req);
-
       // If the conversation is locked to an origin, only allow accessing requests from that origin.
-      return !origin || requestOrigin === origin;
+      return isOriginAllowedByLock(establishedOrigin, req.initiatorSecurityOrigin());
     });
 
     if (!request) {
@@ -110,7 +104,10 @@ export class GetNetworkRequestDetailsTool implements
     }
 
     const calculator = new NetworkTimeCalculator.NetworkTransferTimeCalculator();
-    const formatter = new NetworkRequestFormatter(request, calculator, networkLog);
+    const formatter = new NetworkRequestFormatter(request, calculator, {
+      accessingSecurityOrigin: establishedOrigin,
+      networkLog,
+    });
     const formattedDetails = await formatter.formatNetworkRequest();
 
     return {

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

@@ -8,7 +8,6 @@ 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 {
   type BaseToolCapability,
@@ -69,12 +68,11 @@ export class GetResourceContentTool implements DataTool<
       return {error: 'Performance trace context is not available.'};
     }
 
-    if (performanceTraceContext.getOrigin().startsWith('imported-trace://')) {
+    if (performanceTraceContext.isImported()) {
       return {error: 'Cannot use this tool on an imported file.'};
     }
 
-    const allowedOrigin = performanceTraceContext.getOrigin();
-    if (!canResourceContentsBeReadForTrace(params.url, allowedOrigin)) {
+    if (!performanceTraceContext.canAccessResource(params.url)) {
       return {error: 'Resource not found'};
     }
 

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

@@ -2,10 +2,10 @@
 // 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 {FileContext} from '../contexts/FileContext.js';
 import {FileFormatter} from '../data_formatters/FileFormatter.js';
 
 import {ListSourcesTool} from './ListSources.js';
@@ -13,6 +13,7 @@ import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  isOriginAllowedByLock,
   type OriginLockCapability,
   type ToolArgs,
   ToolName,
@@ -65,10 +66,10 @@ export class GetSourceContentTool implements
       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,
-    );
+    const establishedOrigin = context.getEstablishedOrigin();
+    const file = ListSourcesTool.getUISourceCodes()
+                     .filter(f => isOriginAllowedByLock(establishedOrigin, FileContext.originForUISourceCode(f)))
+                     .find(f => ListSourcesTool.uiSourceCodeId.get(f) === args.id);
 
     if (!file) {
       return {
@@ -76,14 +77,6 @@ export class GetSourceContentTool implements
       };
     }
 
-    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 {

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

@@ -78,7 +78,7 @@ export class GetStorageBreakdownTool implements
       primaryPageTarget.storageAgent().invoke_getUsageAndQuota({origin: pageOrigin}),
       calculateDOMStoragesUsage(localStorages),
       calculateDOMStoragesUsage(sessionStorages),
-      getCookiesForOrigin(pageOrigin, targetManager, primaryPageTarget),
+      getCookiesForOrigin(pageOrigin, primaryPageTarget),
     ]);
 
     if (response.getError()) {