chrome-devtools-frontend 1.0.1669021 → 1.0.1672388

package/front_end/generated/protocol.ts

@@ -1334,6 +1334,7 @@ export namespace Audits {
     TooManyRequests = 'TooManyRequests',
     WellKnownHttpNotFound = 'WellKnownHttpNotFound',
     WellKnownNoResponse = 'WellKnownNoResponse',
+    WellKnownBlockedByConnectionAllowlist = 'WellKnownBlockedByConnectionAllowlist',
     WellKnownInvalidResponse = 'WellKnownInvalidResponse',
     WellKnownListEmpty = 'WellKnownListEmpty',
     WellKnownInvalidContentType = 'WellKnownInvalidContentType',
@@ -1341,6 +1342,7 @@ export namespace Audits {
     WellKnownTooBig = 'WellKnownTooBig',
     ConfigHttpNotFound = 'ConfigHttpNotFound',
     ConfigNoResponse = 'ConfigNoResponse',
+    ConfigBlockedByConnectionAllowlist = 'ConfigBlockedByConnectionAllowlist',
     ConfigInvalidResponse = 'ConfigInvalidResponse',
     ConfigInvalidContentType = 'ConfigInvalidContentType',
     IdpNotPotentiallyTrustworthy = 'IdpNotPotentiallyTrustworthy',
@@ -1350,11 +1352,13 @@ export namespace Audits {
     InvalidSigninResponse = 'InvalidSigninResponse',
     AccountsHttpNotFound = 'AccountsHttpNotFound',
     AccountsNoResponse = 'AccountsNoResponse',
+    AccountsBlockedByConnectionAllowlist = 'AccountsBlockedByConnectionAllowlist',
     AccountsInvalidResponse = 'AccountsInvalidResponse',
     AccountsListEmpty = 'AccountsListEmpty',
     AccountsInvalidContentType = 'AccountsInvalidContentType',
     IdTokenHttpNotFound = 'IdTokenHttpNotFound',
     IdTokenNoResponse = 'IdTokenNoResponse',
+    IdTokenBlockedByConnectionAllowlist = 'IdTokenBlockedByConnectionAllowlist',
     IdTokenInvalidResponse = 'IdTokenInvalidResponse',
     IdTokenIdpErrorResponse = 'IdTokenIdpErrorResponse',
     IdTokenCrossSiteIdpErrorResponse = 'IdTokenCrossSiteIdpErrorResponse',
@@ -10270,11 +10274,6 @@ export namespace Network {
    */
   export type RequestId = OpaqueIdentifier<string, 'Protocol.Network.RequestId'>;
 
-  /**
-   * Unique intercepted request identifier.
-   */
-  export type InterceptionId = OpaqueIdentifier<string, 'Protocol.Network.InterceptionId'>;
-
   /**
    * Network level fetch failure reason.
    */
@@ -11384,34 +11383,6 @@ export namespace Network {
     password?: string;
   }
 
-  /**
-   * Stages of the interception to begin intercepting. Request will intercept before the request is
-   * sent. Response will intercept after the response is received.
-   */
-  export const enum InterceptionStage {
-    Request = 'Request',
-    HeadersReceived = 'HeadersReceived',
-  }
-
-  /**
-   * Request pattern for interception.
-   */
-  export interface RequestPattern {
-    /**
-     * Wildcards (`'*'` -> zero or more, `'?'` -> exactly one) are allowed. Escape character is
-     * backslash. Omitting is equivalent to `"*"`.
-     */
-    urlPattern?: string;
-    /**
-     * If set, only requests for matching resource types will be intercepted.
-     */
-    resourceType?: ResourceType;
-    /**
-     * Stage at which to begin intercepting requests. Default is Request.
-     */
-    interceptionStage?: InterceptionStage;
-  }
-
   /**
    * Information about a signed exchange signature.
    * https://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html#rfc.section.3.1
@@ -12144,6 +12115,7 @@ export namespace Network {
     SigningQuotaExceeded = 'SigningQuotaExceeded',
     RefreshedAsWaiter = 'RefreshedAsWaiter',
     TransientSigningError = 'TransientSigningError',
+    InScopeRefreshNotYetNeeded = 'InScopeRefreshNotYetNeeded',
   }
 
   /**
@@ -12152,9 +12124,11 @@ export namespace Network {
   export interface RefreshEventDetails {
     /**
      * The result of a refresh.
+     * LINT_SKIP.IfChange(DeviceBoundSessionRefreshResult)
      */
     refreshResult: RefreshEventDetailsRefreshResult;
     /**
+     * LINT_SKIP.ThenChange(//net/device_bound_sessions/refresh_result.h:DeviceBoundSessionRefreshResult,//content/browser/devtools/protocol/network_handler.cc:DeviceBoundSessionRefreshResult)
      * If there was a fetch attempt, the result of that.
      */
     fetchResult?: DeviceBoundSessionFetchResult;
@@ -12275,44 +12249,6 @@ export namespace Network {
     result: boolean;
   }
 
-  export interface ContinueInterceptedRequestRequest {
-    interceptionId: InterceptionId;
-    /**
-     * If set this causes the request to fail with the given reason. Passing `Aborted` for requests
-     * marked with `isNavigationRequest` also cancels the navigation. Must not be set in response
-     * to an authChallenge.
-     */
-    errorReason?: ErrorReason;
-    /**
-     * If set the requests completes using with the provided base64 encoded raw response, including
-     * HTTP status line and headers etc... Must not be set in response to an authChallenge.
-     */
-    rawResponse?: binary;
-    /**
-     * If set the request url will be modified in a way that's not observable by page. Must not be
-     * set in response to an authChallenge.
-     */
-    url?: string;
-    /**
-     * If set this allows the request method to be overridden. Must not be set in response to an
-     * authChallenge.
-     */
-    method?: string;
-    /**
-     * If set this allows postData to be set. Must not be set in response to an authChallenge.
-     */
-    postData?: string;
-    /**
-     * If set this allows the request headers to be changed. Must not be set in response to an
-     * authChallenge.
-     */
-    headers?: Headers;
-    /**
-     * Response to a requestIntercepted with an authChallenge. Must not be set otherwise.
-     */
-    authChallengeResponse?: AuthChallengeResponse;
-  }
-
   export interface DeleteCookiesRequest {
     /**
      * Name of the cookies to remove.
@@ -12533,32 +12469,6 @@ export namespace Network {
     base64Encoded: boolean;
   }
 
-  export interface GetResponseBodyForInterceptionRequest {
-    /**
-     * Identifier for the intercepted request to get body for.
-     */
-    interceptionId: InterceptionId;
-  }
-
-  export interface GetResponseBodyForInterceptionResponse extends ProtocolResponseWithError {
-    /**
-     * Response body.
-     */
-    body: string;
-    /**
-     * True, if content was sent as base64.
-     */
-    base64Encoded: boolean;
-  }
-
-  export interface TakeResponseBodyForInterceptionAsStreamRequest {
-    interceptionId: InterceptionId;
-  }
-
-  export interface TakeResponseBodyForInterceptionAsStreamResponse extends ProtocolResponseWithError {
-    stream: IO.StreamHandle;
-  }
-
   export interface ReplayXHRRequest {
     /**
      * Identifier of XHR to replay.
@@ -12706,14 +12616,6 @@ export namespace Network {
     enabled: boolean;
   }
 
-  export interface SetRequestInterceptionRequest {
-    /**
-     * Requests matching any of these patterns will be forwarded and wait for the corresponding
-     * continueInterceptedRequest call.
-     */
-    patterns: RequestPattern[];
-  }
-
   export interface SetUserAgentOverrideRequest {
     /**
      * User agent to use.
@@ -12921,68 +12823,6 @@ export namespace Network {
     encodedDataLength: number;
   }
 
-  /**
-   * Details of an intercepted HTTP request, which must be either allowed, blocked, modified or
-   * mocked.
-   * Deprecated, use Fetch.requestPaused instead.
-   * @deprecated
-   */
-  export interface RequestInterceptedEvent {
-    /**
-     * Each request the page makes will have a unique id, however if any redirects are encountered
-     * while processing that fetch, they will be reported with the same id as the original fetch.
-     * Likewise if HTTP authentication is needed then the same fetch id will be used.
-     */
-    interceptionId: InterceptionId;
-    request: Request;
-    /**
-     * The id of the frame that initiated the request.
-     */
-    frameId: Page.FrameId;
-    /**
-     * How the requested resource will be used.
-     */
-    resourceType: ResourceType;
-    /**
-     * Whether this is a navigation request, which can abort the navigation completely.
-     */
-    isNavigationRequest: boolean;
-    /**
-     * Set if the request is a navigation that will result in a download.
-     * Only present after response is received from the server (i.e. HeadersReceived stage).
-     */
-    isDownload?: boolean;
-    /**
-     * Redirect location, only sent if a redirect was intercepted.
-     */
-    redirectUrl?: string;
-    /**
-     * Details of the Authorization Challenge encountered. If this is set then
-     * continueInterceptedRequest must contain an authChallengeResponse.
-     */
-    authChallenge?: AuthChallenge;
-    /**
-     * Response error if intercepted at response stage or if redirect occurred while intercepting
-     * request.
-     */
-    responseErrorReason?: ErrorReason;
-    /**
-     * Response code if intercepted at response stage or if redirect occurred while intercepting
-     * request or auth retry occurred.
-     */
-    responseStatusCode?: integer;
-    /**
-     * Response headers if intercepted at the response stage or if redirect occurred while
-     * intercepting request or auth retry occurred.
-     */
-    responseHeaders?: Headers;
-    /**
-     * If the intercepted request had a corresponding requestWillBeSent event fired for it, then
-     * this requestId will be the same as the requestId present in the requestWillBeSent event.
-     */
-    requestId?: RequestId;
-  }
-
   /**
    * Fired if request ended up loading from cache.
    */
@@ -13334,7 +13174,7 @@ export namespace Network {
    */
   export interface DirectTCPSocketAbortedEvent {
     identifier: RequestId;
-    errorMessage: string;
+    errorMessage: ErrorReason;
     timestamp: MonotonicTime;
   }
 
@@ -13407,7 +13247,7 @@ export namespace Network {
    */
   export interface DirectUDPSocketAbortedEvent {
     identifier: RequestId;
-    errorMessage: string;
+    errorMessage: ErrorReason;
     timestamp: MonotonicTime;
   }
 

package/front_end/models/ai_assistance/AiAgent2.ts

@@ -4,6 +4,7 @@
 
 import * as Host from '../../core/host/host.js';
 import type * as LHModel from '../lighthouse/lighthouse.js';
+import type * as Trace from '../trace/trace.js';
 
 import {
   AiAgent,
@@ -28,6 +29,7 @@ const SKILL_DISPLAY_NAMES: Record<SkillName, string> = {
   styling: 'CSS and styling',
   network: 'Network requests',
   accessibility: 'Accessibility',
+  performance: 'Performance',
 };
 
 const preamble = `You are the most advanced unified AI assistant integrated into Chrome DevTools.
@@ -59,6 +61,7 @@ If the user asks a question that requires an investigation or debugging, use thi
 
 export interface AiAgent2Options extends ExecuteJsAgentOptions {
   lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
 }
 
 export class AiAgent2 extends AiAgent<unknown> {
@@ -72,6 +75,7 @@ export class AiAgent2 extends AiAgent<unknown> {
   readonly #allowedOrigin?: () => AllowedOriginResult;
   readonly #lighthouseRecording?:
       (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  readonly #performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
 
   get options(): RequestOptions {
     return {};
@@ -84,13 +88,14 @@ export class AiAgent2 extends AiAgent<unknown> {
     super(opts);
     this.#changes = opts.changeManager ?? new ChangeManager(opts.targetManager);
     this.#lighthouseRecording = opts.lighthouseRecording;
+    this.#performanceRecordAndReload = opts.performanceRecordAndReload;
     this.#execJs = opts.execJs ?? executeJsCode;
     this.#allowedOrigin = opts.allowedOrigin;
     this.#declaredTools.add('learnSkills');
     this.declareFunction<{skills: SkillName[]}>('learnSkills', {
       description: () => {
         const unloadedSkills = Object.keys(SKILLS).filter(name => !this.#activeSkills.has(name as SkillName));
-        return `Loads the specified skills to gain access to their specialized tools. Call this if the user's query relates to an available skill that is not yet loaded. Available skills: ${
+        return `Loads the specified skills to gain access to their specialized tools. Call this ONLY for skills listed under Available skills that are not yet loaded. Do not call this for skills that are already loaded. Available skills that are not yet loaded: ${
             unloadedSkills.join(', ')}.`;
       },
       parameters: {
@@ -103,7 +108,7 @@ export class AiAgent2 extends AiAgent<unknown> {
               type: Host.AidaClient.ParametersTypes.STRING,
               description: 'Skill name',
             },
-            description: 'List of skill names to load',
+            description: 'List of unloaded skill names to load',
           },
         },
         required: ['skills'],
@@ -154,6 +159,7 @@ ${skillsManifest}
 
 You must call \`learnSkills\` to load a skill before you can use its tools.
 If the user's request requires a skill that is not currently loaded, you MUST call \`learnSkills\` to load that skill first, instead of attempting to solve the query using tools from other skills.
+Do NOT call \`learnSkills\` for skills that are already loaded.
 
 User query: ${enhancedQuery}`;
   }
@@ -182,7 +188,8 @@ User query: ${enhancedQuery}`;
       debugLog(`AiAgent2: Attempting to load skill ${name}`);
       if (this.#activeSkills.has(name)) {
         debugLog(`AiAgent2: Skill ${name} is already loaded`);
-        response += `Skill ${name} is already loaded.\n`;
+        response += `Error: Skill '${
+            name}' is already loaded. Call its tools directly instead of invoking learnSkills for '${name}' again.\n`;
         continue;
       }
 
@@ -234,6 +241,7 @@ User query: ${enhancedQuery}`;
           getTarget: () => this.targetManager.primaryPageTarget(),
           getEstablishedOrigin: () => this.#getConversationOrigin(),
           lighthouseRecording: this.#lighthouseRecording,
+          performanceRecordAndReload: this.#performanceRecordAndReload,
         };
         return tool.handler(args, context, options);
       },

package/front_end/models/ai_assistance/AiConversation.ts

@@ -128,6 +128,7 @@ export class AiConversation {
       networkTimeCalculator,
       lighthouseRecording,
       aiHistoryStorage = AiHistoryStorage.instance(),
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       targetManager = SDK.TargetManager.TargetManager.instance(),
     } = options;
     this.#changeManager = changeManager;

package/front_end/models/ai_assistance/AiHistoryStorage.ts

@@ -55,6 +55,7 @@ export class AiHistoryStorage extends Common.ObjectWrapper.ObjectWrapper<EventTy
   #maxStorageSize: number;
 
   constructor(
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       settings: Common.Settings.Settings = Common.Settings.Settings.instance(),
       maxStorageSize = DEFAULT_MAX_STORAGE_SIZE,
   ) {
@@ -232,11 +233,13 @@ export class AiHistoryStorage extends Common.ObjectWrapper.ObjectWrapper<EventTy
       ): AiHistoryStorage {
     const {forceNew, maxStorageSize, settings} = opts;
     if (!Root.DevToolsContext.globalInstance().has(AiHistoryStorage) || forceNew) {
-      Root.DevToolsContext.globalInstance().set(AiHistoryStorage,
-                                                new AiHistoryStorage(
-                                                    settings ?? Common.Settings.Settings.instance(),
-                                                    maxStorageSize,
-                                                    ));
+      Root.DevToolsContext.globalInstance().set(
+          AiHistoryStorage,
+          new AiHistoryStorage(
+              // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+              settings ?? Common.Settings.Settings.instance(),
+              maxStorageSize,
+              ));
     }
     return Root.DevToolsContext.globalInstance().get(AiHistoryStorage);
   }

package/front_end/models/ai_assistance/AiSetting.ts

@@ -0,0 +1,108 @@
+// 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 Root from '../../core/root/root.js';
+
+import type {DisabledReason} from './AiUtils.js';
+
+export const enum Events {
+  CHANGED = 'Changed',
+}
+
+export interface EventTypes {
+  [Events.CHANGED]: void;
+}
+
+/**
+ * Wrapper around a plain {@link Common.Settings.Setting} for AI features whose availability
+ * can change dynamically over the lifetime of a DevTools session (e.g., due to changes in
+ * AIDA availability, network connectivity, authentication, or enterprise policy).
+ *
+ * This wrapper listens to {@link Host.AidaClient.Events.AIDA_AVAILABILITY_CHANGED} and emits
+ * {@link Events.CHANGED} when either the underlying setting value changes or when AIDA status
+ * changes, allowing UI components to dynamically react without polluting the plain `Setting`
+ * class with dynamic availability state.
+ */
+export class AiSetting<ValueT> extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  #setting?: Common.Settings.Setting<ValueT>;
+  readonly #descriptor: Common.Settings.ConditionalSettingDescriptor<ValueT, DisabledReason[]>;
+  readonly #hostConfigTracker: Host.AidaClient.HostConfigTracker;
+  readonly #settings: Common.Settings.Settings;
+  readonly #boundOnSettingChanged = this.#onSettingChanged.bind(this);
+  readonly #boundOnAidaAvailabilityChanged = this.#onAidaAvailabilityChanged.bind(this);
+
+  constructor(
+      descriptor: Common.Settings.ConditionalSettingDescriptor<ValueT, DisabledReason[]>,
+      hostConfigTracker: Host.AidaClient.HostConfigTracker,
+      settings: Common.Settings.Settings,
+  ) {
+    super();
+    this.#descriptor = descriptor;
+    this.#hostConfigTracker = hostConfigTracker;
+    this.#settings = settings;
+
+    this.#hostConfigTracker.addEventListener(
+        Host.AidaClient.Events.AIDA_AVAILABILITY_CHANGED,
+        this.#boundOnAidaAvailabilityChanged,
+    );
+    this.#tryResolveSetting();
+  }
+
+  #tryResolveSetting(): void {
+    const result = this.#settings.maybeResolve(this.#descriptor as
+                                               Common.Settings.ConditionalSettingDescriptor<unknown, DisabledReason[]>);
+    if ('setting' in result) {
+      if (this.#setting !== result.setting) {
+        if (this.#setting) {
+          this.#setting.removeChangeListener(this.#boundOnSettingChanged);
+        }
+        this.#setting = result.setting as Common.Settings.Setting<ValueT>;
+        this.#setting.addChangeListener(this.#boundOnSettingChanged);
+      }
+    }
+  }
+
+  get unavailable(): boolean {
+    const availability = this.#descriptor.isAvailable(Root.Runtime.hostConfig);
+    return availability.status === Common.Settings.SettingAvailability.UNAVAILABLE;
+  }
+
+  get disabled(): boolean {
+    const availability = this.#descriptor.isAvailable(Root.Runtime.hostConfig);
+    return availability.status === Common.Settings.SettingAvailability.DISABLED;
+  }
+
+  get disabledReasons(): DisabledReason[] {
+    const availability = this.#descriptor.isAvailable(Root.Runtime.hostConfig);
+    if (availability.status === Common.Settings.SettingAvailability.DISABLED) {
+      return availability.reason;
+    }
+    return [];
+  }
+
+  getIfNotDisabled(): ValueT|undefined {
+    if (this.disabled || this.unavailable) {
+      return undefined;
+    }
+    return this.#setting?.get();
+  }
+
+  setIfNotDisabled(value: ValueT): void {
+    if (this.disabled || this.unavailable) {
+      return;
+    }
+    this.#setting?.set(value);
+  }
+
+  #onSettingChanged(): void {
+    this.dispatchEventToListeners(Events.CHANGED);
+  }
+
+  #onAidaAvailabilityChanged(): void {
+    this.#tryResolveSetting();
+    this.dispatchEventToListeners(Events.CHANGED);
+  }
+}

package/front_end/models/ai_assistance/AiUtils.ts

@@ -72,6 +72,53 @@ export const consoleInsightsEnabledSettingDescriptor:
   },
 };
 
+function isAiAssistanceFeatureAvailable(config?: Root.Runtime.HostConfig): boolean {
+  return Boolean(config?.aidaAvailability?.enabled &&
+                 (config?.devToolsFreestyler?.enabled || config?.devToolsAiAssistanceNetworkAgent?.enabled ||
+                  config?.devToolsAiAssistancePerformanceAgent?.enabled ||
+                  config?.devToolsAiAssistanceFileAgent?.enabled || config?.devToolsAiAssistanceStorageAgent?.enabled));
+}
+
+export const aiAssistanceEnabledSettingDescriptor:
+    Common.Settings.ConditionalSettingDescriptor<boolean, DisabledReason[]> = {
+  name: 'ai-assistance-enabled',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  isAvailable: (config?: Root.Runtime.HostConfig): Common.Settings.SettingAvailabilityStatus<DisabledReason[]> => {
+    if (!isAiAssistanceFeatureAvailable(config)) {
+      return {
+        status: Common.Settings.SettingAvailability.UNAVAILABLE,
+        reason: [DisabledReason.NOT_SUPPORTED],
+      };
+    }
+    const reasons: DisabledReason[] = [];
+    if (isGeoRestricted(config)) {
+      reasons.push(DisabledReason.GEO_RESTRICTED);
+    }
+    if (isPolicyRestricted(config)) {
+      reasons.push(DisabledReason.POLICY_RESTRICTED);
+    }
+    if (isLocaleRestricted()) {
+      reasons.push(DisabledReason.WRONG_LOCALE);
+    }
+    if (reasons.length > 0) {
+      return {
+        status: Common.Settings.SettingAvailability.DISABLED,
+        reason: reasons,
+      };
+    }
+    return {
+      status: Common.Settings.SettingAvailability.AVAILABLE,
+    };
+  },
+};
+
+export const aiAssistanceV2OptInChangeDialogSeenSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'ai-assistance-v2-opt-in-change-dialog-seen',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+};
+
 export function isGeminiBranding(): boolean {
   return !!Root.Runtime.hostConfig.devToolsGeminiRebranding?.enabled;
 }

package/front_end/models/ai_assistance/ChangeManager.ts

@@ -31,6 +31,7 @@ export class ChangeManager {
       new Map<SDK.CSSModel.CSSModel, Map<Protocol.Page.FrameId, Protocol.DOM.StyleSheetId>>();
   readonly #stylesheetChanges = new Map<Protocol.DOM.StyleSheetId, Change[]>();
 
+  // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
   constructor(targetManager: SDK.TargetManager.TargetManager = SDK.TargetManager.TargetManager.instance()) {
     this.#targetManager = targetManager;
     this.#targetManager.addModelListener(

package/front_end/models/ai_assistance/ExtensionScope.ts

@@ -7,12 +7,12 @@ import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 
+import {getOrCreateIsolatedWorld} from './agents/ExecuteJavascript.js';
 import type {ChangeManager} from './ChangeManager.js';
 import {
   AI_ASSISTANCE_CSS_CLASS_NAME,
   type FreestyleCallbackArgs,
   FREESTYLER_BINDING_NAME,
-  FREESTYLER_WORLD_NAME,
   freestylerBinding,
   injectedFunctions,
 } from './injected.js';
@@ -66,24 +66,15 @@ export class ExtensionScope {
   }
 
   async install(): Promise<void> {
+    const isolatedWorldContext = await getOrCreateIsolatedWorld(this.target, this.frameId);
     const runtimeModel = this.target.model(SDK.RuntimeModel.RuntimeModel);
-    const pageAgent = this.target.pageAgent();
-
-    // This returns previously created world if it exists for the frame.
-    const {executionContextId} =
-        await pageAgent.invoke_createIsolatedWorld({frameId: this.frameId, worldName: FREESTYLER_WORLD_NAME});
-
-    const isolatedWorldContext = runtimeModel?.executionContext(executionContextId);
-    if (!isolatedWorldContext) {
-      throw new Error('Execution context is not found for executing code');
-    }
 
     const handler = this.#bindingCalled.bind(this, isolatedWorldContext);
     runtimeModel?.addEventListener(SDK.RuntimeModel.Events.BindingCalled, handler);
     this.#listeners.push(handler);
     await this.target.runtimeAgent().invoke_addBinding({
       name: FREESTYLER_BINDING_NAME,
-      executionContextId,
+      executionContextId: isolatedWorldContext.id,
     });
     await this.#simpleEval(isolatedWorldContext, freestylerBinding);
     await this.#simpleEval(isolatedWorldContext, injectedFunctions);

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

@@ -14,6 +14,7 @@ import type * as Trace from '../../trace/trace.js';
 import type * as Workspace from '../../workspace/workspace.js';
 import {areOriginsEquivalent, extractContextOrigin, isOpaqueOrigin} from '../AiOrigins.js';
 import {debugLog, isStructuredLogEnabled} from '../debug.js';
+import type {ContextHandlerResult, DataHandlerResult} from '../tools/Tool.js';
 
 const MAX_SUGGESTION_LENGTH = 200;
 
@@ -391,23 +392,11 @@ export type AiWidget = ComputedStyleAiWidget|CoreVitalsAiWidget|StylePropertiesA
     LighthouseReportAiWidget|TimelineEventSummaryAiWidget|NetworkRequestGeneralHeadersAiWidget|SourceCodeAiWidget|
     SourceFilesListAiWidget|NetworkRequestsListAiWidget|NetworkTrackAiWidget;
 
-export type FunctionCallHandlerResult<Result> = {
-  requiresApproval: true,
-  /**
-   * Provides extra description of what the required
-   * approval is requesting.
-   */
-  description: string|null,
-}|{
-  result: Result,
-  widgets?: AiWidget[],
-}|{
-  context: ConversationContext<unknown>,
-  description: string,
-  widgets?: AiWidget[],
-}|{
-  error: string,
-};
+/**
+ * @deprecated Used for v1 agents. Once v2 is shipped, this can be removed.
+ * Use `DataHandlerResult` or `ContextHandlerResult` from `Tool.js` instead.
+ */
+export type ToolResult<ResultType> = DataHandlerResult<ResultType>|ContextHandlerResult;
 
 export interface FunctionHandlerOptions {
   /**
@@ -442,7 +431,7 @@ export interface FunctionDeclaration<Args extends Record<string, unknown>, Retur
   /**
    * Function implementation that the LLM will try to execute,
    */
-  handler(args: Args, options?: FunctionHandlerOptions): Promise<FunctionCallHandlerResult<ReturnType>>;
+  handler(args: Args, options?: FunctionHandlerOptions): Promise<ToolResult<ReturnType>>;
 }
 
 interface AidaFetchResult {
@@ -521,6 +510,7 @@ export abstract class AiAgent<T> {
     this.confirmSideEffect = opts.confirmSideEffectForTest ?? (() => Promise.withResolvers());
     this.#history = opts.history ?? [];
     this.#allowedOrigin = opts.allowedOrigin;
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     this.#targetManager = opts.targetManager ?? SDK.TargetManager.TargetManager.instance();
   }
 
@@ -759,6 +749,9 @@ export abstract class AiAgent<T> {
     await this.preRun();
 
     const enhancedQuery = await this.enhanceQuery(initialQuery, options.selected, multimodalInput?.type);
+    if (!enhancedQuery.trim() && !multimodalInput) {
+      return;
+    }
     Host.userMetrics.freestylerQueryLength(enhancedQuery.length);
 
     let query: Host.AidaClient.Part|Host.AidaClient.Part[];

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

@@ -114,7 +114,9 @@ export class ContextSelectionAgent extends AiAgent<never> {
 
   constructor(opts: ContextSelectionAgentOptions) {
     super(opts);
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     this.#networkLog = opts.networkLog ?? Logs.NetworkLog.NetworkLog.instance();
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     this.#workspace = opts.workspace ?? Workspace.Workspace.WorkspaceImpl.instance();
     this.#performanceRecordAndReload = opts.performanceRecordAndReload;
     this.#lighthouseRecording = opts.lighthouseRecording;
@@ -562,6 +564,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
    * coming from SourceMaps (usually only one) as that has simple code and
    * usually is what the user authored.
    */
+  // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
   static getUISourceCodes(workspace: Workspace.Workspace.WorkspaceImpl = Workspace.Workspace.WorkspaceImpl.instance()):
       Workspace.UISourceCode.UISourceCode[] {
     const projects =