chrome-devtools-frontend 1.0.1717196 → 1.0.1721762

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

@@ -8,18 +8,22 @@ import * as Root from '../../../core/root/root.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import type * as TextUtils from '../../../core/text_utils/text_utils.js';
 import type * as Protocol from '../../../generated/protocol.js';
+import * as AiUtils from '../../ai-utils/ai-utils.js';
 import type * as LHModel from '../../lighthouse/lighthouse.js';
 import type * as Trace from '../../trace/trace.js';
 import type * as Workspace from '../../workspace/workspace.js';
-import {debugLog, isStructuredLogEnabled} from '../debug.js';
+import type {AlwaysAllowedTools} from '../AlwaysAllowedTools.js';
 import {dispatchAiAssistanceDoneEvent} from '../DOMHelpers.js';
 import {
   type ContextHandlerResult,
   type DataHandlerResult,
   PermissionDecision,
-  type PermissionPrompt,
+  PermissionPrompt,
+  type ToolName,
 } from '../tools/Tool.js';
 
+const {debugLog, isStructuredLogEnabled} = AiUtils.Debug;
+
 type UrlString = Platform.DevToolsPath.UrlString;
 const MAX_SUGGESTION_LENGTH = 200;
 
@@ -37,12 +41,22 @@ const MAX_SUGGESTION_LENGTH = 200;
  *   QUERYING
  *   one of:
  *     ANSWER (complete: false)*, ANSWER (complete: true)   text-only reply; the run ends
- *     [ANSWER (complete: true)], <tool call events>        function call, optionally with text
+ *     ANSWER (complete: false)*, [ANSWER (complete: true)],
+ *       <tool call events>+                                one or more function calls, optionally with text
  *     ERROR                                                the run ends
  * ```
  *
+ * When a model response contains several function calls,
+ * `AiAgent#runFunctionCalls()` runs them one after another, so each call's
+ * events finish before the next call's events start. A denied call does not
+ * stop the calls after it, and neither does a failed call: an unknown tool
+ * name or an error thrown by the handler becomes an error result for that
+ * call.
+ *
  * An `ERROR` can also follow the tool call events, for example when the user
  * aborts, the page navigates cross-origin, or the run reaches `MAX_STEPS`.
+ * The remaining calls in that model response do not run after an abort or a
+ * cross-origin navigation.
  *
  * ## Events for one tool call
  *
@@ -60,8 +74,18 @@ const MAX_SUGGESTION_LENGTH = 200;
  * ```
  *
  * If the tool switches context instead of returning a result, there is no
- * result `ACTION`. `AiAgent#run()` yields `CONTEXT_CHANGE` and returns, and
- * `AiConversation` starts a new run with the agent for the new context.
+ * result `ACTION`. `AiAgent#runFunctionCalls()` yields `CONTEXT_CHANGE` and
+ * the run ends, and `AiConversation` starts a new run with the agent for the
+ * new context. The remaining calls in that model response do not run.
+ *
+ * ## Model history for function calls
+ *
+ * This is the history sent to the model, separate from the saved history
+ * below. `AiAgent#runFunctionCalls()` stores the model's explanation text and
+ * every function call in a response as one `MODEL` turn. The next request
+ * carries one `functionResponse` per call, in the same order. A denied call
+ * gets a response that says it did not run. After a context change, each call
+ * that did not run gets a "Not executed" response.
  *
  * ## Saved history
  *
@@ -229,6 +253,11 @@ export interface ContextChangeResponse {
   description: string;
   context: ConversationContext<unknown>;
   widgets?: AiWidget[];
+  /**
+   * The name of the tool that triggered this context change. Used by the panel
+   * to emit UI telemetry.
+   */
+  toolName?: string;
 }
 
 interface SerializedSideEffectResponse extends Omit<SideEffectResponse, 'confirm'> {}
@@ -265,6 +294,11 @@ export interface ActionResponse extends ToolCallEvent {
    * output of tools annotated with `REDACT_FROM_HISTORY`.
    */
   toolName?: string;
+  /**
+   * Skills newly loaded by a `learnSkills` call. Used by the panel to emit
+   * `ai-v2-learn-skill` visual logging events.
+   */
+  loadedSkills?: string[];
 }
 
 /**
@@ -317,8 +351,9 @@ export interface AgentOptions {
   onInspectElement?: () => Promise<SDK.DOMModel.DOMNode|null>;
   history?: Host.AidaClient.Content[];
   allowedOrigin?: () => AllowedOriginResult;
-  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.RunTypes.RunResult>;
   targetManager?: SDK.TargetManager.TargetManager;
+  alwaysAllowedTools?: AlwaysAllowedTools;
 }
 
 export interface ParsedAnswer {
@@ -330,6 +365,22 @@ export type ParsedResponse = ParsedAnswer;
 
 export const MAX_STEPS = 20;
 
+/**
+ * The response sent for each function call that did not run because an
+ * earlier call in the same model response switched the context. Every
+ * `functionCall` in the history needs a matching `functionResponse`.
+ */
+const NOT_EXECUTED_AFTER_CONTEXT_CHANGE =
+    'Not executed: the conversation switched to a new context before this call ran.';
+
+/**
+ * The response sent to the model for a call that the user denied. The other
+ * calls in the same model response still run after a denial, so the message
+ * points the model to their responses to see what did run.
+ */
+const USER_DENIED_CALL =
+    'Error: The user denied this call, so it did not run. Other calls in the same response were handled separately; check their responses.';
+
 export interface ConversationSuggestion {
   title: string;
   jslogContext?: string;
@@ -647,9 +698,34 @@ export interface FunctionDeclaration<Args extends Record<string, unknown>, Retur
   handler(args: Args, options?: FunctionHandlerOptions): Promise<ToolResult<ReturnType>>;
 }
 
+/**
+ * The function calls in one model response. A response that has function
+ * calls has at least one.
+ */
+type FunctionCalls = [Host.AidaClient.AidaFunctionCall, ...Host.AidaClient.AidaFunctionCall[]];
+
+/**
+ * What happened after `AiAgent#runFunctionCalls()` ran the calls in one model
+ * response:
+ * - `responses`: every call ran. `functionResponses` go to the model in the
+ *   next request.
+ * - `contextChanged`: a call switched the context. The run ends, and
+ *   `AiConversation` starts a new run in the new context.
+ * - `stopped`: an abort, a cross-origin navigation or an unexpected error
+ *   stopped the run. The ERROR response has already been yielded.
+ */
+type FunctionCallsOutcome = {
+  type: 'responses',
+  functionResponses: Host.AidaClient.Part[],
+}|{
+  type: 'contextChanged',
+}|{
+  type: 'stopped',
+};
+
 interface AidaFetchResult {
   text?: string;
-  functionCall?: Host.AidaClient.AidaFunctionCall;
+  functionCalls?: FunctionCalls;
   completed: boolean;
   rpcId?: Host.AidaClient.RpcGlobalId;
 }
@@ -692,6 +768,7 @@ export abstract class AiAgent<T> {
   readonly #functionDeclarations = new Map<string, FunctionDeclaration<Record<string, unknown>, unknown>>();
   readonly #allowedOrigin?: () => AllowedOriginResult;
   readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #alwaysAllowedTools?: AlwaysAllowedTools;
 
   /**
    * Used in the debug mode and evals.
@@ -728,6 +805,7 @@ export abstract class AiAgent<T> {
     this.#allowedOrigin = opts.allowedOrigin;
     // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     this.#targetManager = opts.targetManager ?? SDK.TargetManager.TargetManager.instance();
+    this.#alwaysAllowedTools = opts.alwaysAllowedTools;
   }
 
   async enhanceQuery(query: string, selected: ConversationContext<T>|null,
@@ -785,10 +863,6 @@ export abstract class AiAgent<T> {
     this.#serverSideLoggingActive = false;
   }
 
-  popPendingMultimodalInput(): MultimodalInput|undefined {
-    return undefined;
-  }
-
   /**
    * Preamble features appended to the `client_version` in metadata.
    * This is required ONLY for the Styling Agent for legacy reasons to serve
@@ -990,8 +1064,8 @@ export abstract class AiAgent<T> {
     }
     Host.userMetrics.freestylerQueryLength(enhancedQuery.length);
 
-    let query: Host.AidaClient.Part|Host.AidaClient.Part[];
-    query = multimodalInput ? [{text: enhancedQuery}, multimodalInput.input] : [{text: enhancedQuery}];
+    const query: Host.AidaClient.Part[] =
+        multimodalInput ? [{text: enhancedQuery}, multimodalInput.input] : [{text: enhancedQuery}];
     // Request is built here to capture history up to this point.
     let request = this.buildRequest(query, Host.AidaClient.Role.USER);
 
@@ -1007,23 +1081,20 @@ export abstract class AiAgent<T> {
 
       if (i === 0) {
         debugLog('[AiAgent] Step 1: Sending user prompt to model:', enhancedQuery);
-      } else if (!Array.isArray(query) && 'functionResponse' in query) {
-        debugLog(`[AiAgent] Step ${i + 1}: Sending function response for '${query.functionResponse.name}' to model:`,
-                 query.functionResponse.response);
       } else {
         debugLog(`[AiAgent] Step ${i + 1}: Sending request to model:`, request.current_message);
       }
 
       let rpcId: Host.AidaClient.RpcGlobalId|undefined;
       let textResponse = '';
-      let functionCall: Host.AidaClient.AidaFunctionCall|undefined = undefined;
+      let functionCalls: FunctionCalls|undefined;
       try {
         for await (const fetchResult of this.#aidaFetch(request, {signal: options.signal})) {
           rpcId = fetchResult.rpcId;
           textResponse = fetchResult.text ?? '';
-          functionCall = fetchResult.functionCall;
+          functionCalls = fetchResult.functionCalls;
 
-          if (!functionCall && !fetchResult.completed) {
+          if (!functionCalls && !fetchResult.completed) {
             const parsed = this.parsePartialTextResponse(textResponse);
             const partialAnswer = 'answer' in parsed ? parsed.answer : '';
             if (!partialAnswer) {
@@ -1052,7 +1123,7 @@ export abstract class AiAgent<T> {
         if (!('answer' in parsedResponse)) {
           throw new Error('Expected a completed response to have an answer');
         }
-        if (!functionCall) {
+        if (!functionCalls) {
           debugLog(`[AiAgent] Step ${i + 1}: Model returned text response:`, parsedResponse.answer);
           this.#history.push({
             parts: [{
@@ -1069,135 +1140,184 @@ export abstract class AiAgent<T> {
           complete: true,
           rpcId,
         });
-        if (!functionCall) {
+        if (!functionCalls) {
           break;
         }
       }
 
-      if (functionCall) {
-        debugLog(`[AiAgent] Step ${i + 1}: Model requested function call: ${functionCall.name}`, functionCall.args);
+      if (!functionCalls) {
+        yield this.#createErrorResponse(ErrorType.UNKNOWN);
+        break;
+      }
+
+      debugLog(`[AiAgent] Step ${i + 1}: Model requested function calls:`, functionCalls);
+      const outcome = yield* this.#runFunctionCalls(functionCalls, textResponse, options);
+      if (outcome.type === 'contextChanged') {
+        return;
+      }
+      if (outcome.type === 'stopped') {
+        break;
+      }
+
+      if (i === MAX_STEPS - 1) {
+        // Normally, the functionResponses are pushed at the start of the next
+        // iteration. Since no further iteration will run, push them here so the
+        // last functionCalls are not left unpaired in history.
+        this.#history.push({
+          parts: outcome.functionResponses,
+          role: Host.AidaClient.Role.ROLE_UNSPECIFIED,
+        });
+        yield this.#createErrorResponse(ErrorType.MAX_STEPS);
+        break;
+      }
+
+      request = this.buildRequest(outcome.functionResponses, Host.AidaClient.Role.ROLE_UNSPECIFIED);
+    }
+
+    if (isStructuredLogEnabled()) {
+      dispatchAiAssistanceDoneEvent();
+    }
+    return;
+  }
+
+  /**
+   * Runs every function call in one model response, one after another, in the
+   * order the model returned them.
+   *
+   * The model's text and all calls are stored in history as one MODEL turn.
+   * Every `functionCall` in history gets a matching `functionResponse`: in the
+   * returned `functionResponses`, or, after a context change, in history
+   * directly. When the run stops, the ERROR response removes the run from
+   * history instead.
+   */
+  async *
+      #runFunctionCalls(functionCalls: FunctionCalls, textResponse: string, options: {signal?: AbortSignal}):
+          AsyncGenerator<ResponseData, FunctionCallsOutcome, void> {
+    // Each call keeps its own `thoughtSignature`, if it has one.
+    const modelParts: Host.AidaClient.Part[] = textResponse ? [{text: textResponse}] : [];
+    modelParts.push(...functionCalls.map(functionCall => ({functionCall})));
+    this.#history.push({
+      parts: modelParts,
+      role: Host.AidaClient.Role.MODEL,
+    });
+
+    const functionResponses: Host.AidaClient.Part[] = [];
+    try {
+      for (const [index, functionCall] of functionCalls.entries()) {
         const allowedOriginResult = this.#allowedOrigin?.();
         if (allowedOriginResult && 'blocked' in allowedOriginResult) {
-          // Abort immediately if the page navigated before we could lock the origin.
+          // Stop if the page navigated before the origin was locked.
           // This prevents the AI from accessing data from the new page.
-          yield this.#createErrorResponse(ErrorType.CROSS_ORIGIN);
-          break;
+          throw new CrossOriginError();
         }
-        try {
-          const result = yield*
-              this.#callFunction(
-                  functionCall.name,
-                  functionCall.args,
-                  functionCall.thoughtSignature,
-                  {
-                    ...options,
-                    explanation: textResponse,
-                  },
-              );
-
-          if (options.signal?.aborted) {
-            yield this.#createErrorResponse(ErrorType.ABORT);
-            break;
-          }
 
-          if ('context' in result) {
-            // Pair the functionCall with a functionResponse so history stays valid
-            // if this agent instance is re-run after the context change (AiAgent2).
-            // The new context reaches the model through the next USER query.
-            this.#history.push({
-              parts: [{
-                functionResponse: {
-                  name: functionCall.name,
-                  response: {result: result.description},
-                },
-              }],
-              role: Host.AidaClient.Role.ROLE_UNSPECIFIED,
-            });
-            yield {
-              type: ResponseType.CONTEXT_CHANGE,
-              description: result.description,
-              context: result.context,
-              widgets: result.widgets,
-            };
+        const result = yield* this.#callFunction(functionCall.name, functionCall.args, options);
 
-            return;
-          }
+        if (options.signal?.aborted) {
+          // The remaining calls do not run. The ABORT response removes the run
+          // from history.
+          yield this.#createErrorResponse(ErrorType.ABORT);
+          return {type: 'stopped'};
+        }
 
-          query = {
-            functionResponse: {
-              name: functionCall.name,
-              // Widgets are not sent back to the LLM
-              response: {...result, widgets: undefined},
-            },
+        if ('context' in result) {
+          functionResponses.push(
+              ...this.#contextChangeResponses(functionCall, functionCalls.slice(index + 1), result.description));
+          this.#history.push({
+            parts: functionResponses,
+            role: Host.AidaClient.Role.ROLE_UNSPECIFIED,
+          });
+          yield {
+            type: ResponseType.CONTEXT_CHANGE,
+            description: result.description,
+            context: result.context,
+            widgets: result.widgets,
+            toolName: functionCall.name,
           };
-          if (i === MAX_STEPS - 1) {
-            // Normally, the functionResponse is pushed at the start of the next
-            // iteration. Since no further iteration will run, push it here so the
-            // last functionCall is not left unpaired in history.
-            this.#history.push({
-              parts: [query],
-              role: Host.AidaClient.Role.ROLE_UNSPECIFIED,
-            });
-            yield this.#createErrorResponse(ErrorType.MAX_STEPS);
-            break;
-          }
-          request = this.buildRequest(query, Host.AidaClient.Role.ROLE_UNSPECIFIED);
-        } catch (err) {
-          if (err instanceof CrossOriginError) {
-            yield this.#createErrorResponse(ErrorType.CROSS_ORIGIN);
-            break;
-          }
-          debugLog('Error handling function call', err);
-          yield this.#createErrorResponse(ErrorType.UNKNOWN);
-          break;
+          return {type: 'contextChanged'};
         }
-      } else {
-        yield this.#createErrorResponse(ErrorType.UNKNOWN);
-        break;
+
+        functionResponses.push({
+          functionResponse: {
+            name: functionCall.name,
+            // Widgets and UI telemetry metadata are not sent back to the LLM.
+            response: {
+              ...result,
+              widgets: undefined,
+              ...('loadedSkills' in result ? {loadedSkills: undefined} : {}),
+            },
+          },
+        });
+      }
+    } catch (err) {
+      if (err instanceof CrossOriginError) {
+        yield this.#createErrorResponse(ErrorType.CROSS_ORIGIN);
+        return {type: 'stopped'};
       }
+      debugLog('Error handling function call', err);
+      yield this.#createErrorResponse(ErrorType.UNKNOWN);
+      return {type: 'stopped'};
     }
 
-    if (isStructuredLogEnabled()) {
-      dispatchAiAssistanceDoneEvent();
-    }
-    return;
+    return {type: 'responses', functionResponses};
+  }
+
+  /**
+   * Returns the function responses for `switchingCall`, which switched the
+   * context, and for `skippedCalls`, which come after it and do not run.
+   *
+   * Pairing every `functionCall` with a `functionResponse` keeps the history
+   * valid if this agent instance runs again after the context change
+   * (`AiAgent2`). The new context reaches the model through the next USER
+   * query.
+   */
+  #contextChangeResponses(switchingCall: Host.AidaClient.AidaFunctionCall,
+                          skippedCalls: Host.AidaClient.AidaFunctionCall[],
+                          description: string): Host.AidaClient.Part[] {
+    return [
+      {
+        functionResponse: {
+          name: switchingCall.name,
+          response: {result: description},
+        },
+      },
+      ...skippedCalls.map(skippedCall => ({
+                            functionResponse: {
+                              name: skippedCall.name,
+                              response: {result: NOT_EXECUTED_AFTER_CONTEXT_CHANGE},
+                            },
+                          })),
+    ];
   }
 
   async *
       #callFunction(
           name: string,
           args: Record<string, unknown>,
-          thoughtSignature?: string,
-          options?: FunctionHandlerOptions&{explanation?: string},
+          options?: FunctionHandlerOptions,
           ): AsyncGenerator<FunctionCallResponseData, {
         result: unknown,
         widgets?: AiWidget[],
-      }|{context: ConversationContext<unknown>, description: string, widgets?: AiWidget[]}> {
+        loadedSkills?: string[],
+      }|{error: string}|{context: ConversationContext<unknown>, description: string, widgets?: AiWidget[]}> {
+    const callId = crypto.randomUUID();
     const call = this.#functionDeclarations.get(name);
     if (!call) {
-      throw new Error(`Function ${name} is not found.`);
+      // Answer with an error instead of throwing, so the other calls in the
+      // same model response still run and the history keeps their results.
+      const error = `Error: Function ${name} is not found.`;
+      debugLog(`[AiAgent] Tool '${name}' is not declared.`);
+      yield {
+        type: ResponseType.ACTION,
+        callId,
+        output: error,
+        canceled: false,
+        toolName: name,
+      };
+      return {error};
     }
     debugLog(`[AiAgent] Executing tool '${name}' with args:`, args);
-    const parts: Host.AidaClient.Part[] = [];
-    if (options?.explanation) {
-      parts.push({
-        text: options.explanation,
-      });
-    }
-    const functionCall: Host.AidaClient.AidaFunctionCall = {
-      name,
-      args,
-    };
-    if (thoughtSignature) {
-      functionCall.thoughtSignature = thoughtSignature;
-    }
-    parts.push({functionCall});
-    this.#history.push({
-      parts,
-      role: Host.AidaClient.Role.MODEL,
-    });
 
-    const callId = crypto.randomUUID();
     let code;
     if (call.displayInfoFromArgs) {
       const {title, thought, action: callCode} = call.displayInfoFromArgs(args);
@@ -1224,7 +1344,21 @@ export abstract class AiAgent<T> {
       return Boolean(allowedOriginResult && 'blocked' in allowedOriginResult);
     };
 
-    let result = await call.handler(args, options);
+    // Turns an error thrown by the handler into an error result, so the other
+    // calls in the same model response still run and the history keeps their
+    // results.
+    const runHandler = async(handlerOptions?: FunctionHandlerOptions): Promise<ToolResult<unknown>> => {
+      try {
+        const isAlwaysAllowed = call.permissionPrompt === PermissionPrompt.ALLOW_ONCE_OR_ALWAYS &&
+            this.#alwaysAllowedTools?.isAllowed(name as ToolName);
+        return await call.handler(args, isAlwaysAllowed ? {...handlerOptions, approved: true} : handlerOptions);
+      } catch (err) {
+        debugLog(`[AiAgent] Tool '${name}' threw:`, err);
+        return {error: `Error: ${err instanceof Error ? err.message : String(err)}`};
+      }
+    };
+
+    let result = await runHandler(options);
 
     // Check 1: After first handler execution.
     // Navigation could have occurred during the async handler execution.
@@ -1276,6 +1410,9 @@ export abstract class AiAgent<T> {
       } finally {
         options?.signal?.removeEventListener('abort', onAbort);
       }
+      if (decision === PermissionDecision.ALLOW_ALWAYS) {
+        this.#alwaysAllowedTools?.allow(name as ToolName);
+      }
       if (decision === PermissionDecision.REJECT) {
         yield {
           type: ResponseType.ACTION,
@@ -1286,7 +1423,7 @@ export abstract class AiAgent<T> {
         };
         debugLog(`[AiAgent] Tool '${name}' denied by user.`);
         return {
-          result: 'Error: User denied code execution with side effects.',
+          result: USER_DENIED_CALL,
         };
       }
 
@@ -1298,7 +1435,7 @@ export abstract class AiAgent<T> {
         throw new CrossOriginError();
       }
 
-      result = await call.handler(args, {
+      result = await runHandler({
         ...options,
         approved: true,
       });
@@ -1319,6 +1456,7 @@ export abstract class AiAgent<T> {
         widgets: result.widgets,
         canceled: false,
         toolName: name,
+        ...(result.loadedSkills ? {loadedSkills: result.loadedSkills} : {}),
       };
     }
 
@@ -1350,13 +1488,9 @@ export abstract class AiAgent<T> {
 
     for await (aidaResponse of this.#aidaClient.doConversation(request, options)) {
       if (aidaResponse.functionCalls?.length) {
-        if (aidaResponse.functionCalls.length > 1) {
-          debugLog(`[AiAgent] Unexpected: received ${aidaResponse.functionCalls.length} function calls in response:`,
-                   aidaResponse.functionCalls);
-        }
         yield {
           rpcId,
-          functionCall: aidaResponse.functionCalls[0],
+          functionCalls: aidaResponse.functionCalls,
           completed: true,
           text: aidaResponse.explanation,
         };

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

@@ -6,6 +6,7 @@ import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
 import * as Root from '../../../core/root/root.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
+import * as AiUtils from '../../ai-utils/ai-utils.js';
 import type * as LHModel from '../../lighthouse/lighthouse.js';
 import * as Logs from '../../logs/logs.js';
 import * as NetworkTimeCalculator from '../../network_time_calculator/network_time_calculator.js';
@@ -18,7 +19,6 @@ import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 import {RequestContext} from '../contexts/RequestContext.js';
 import {StorageContext} from '../contexts/StorageContext.js';
 import {formatBytesToKb, seconds} from '../data_formatters/UnitFormatters.js';
-import {debugLog} from '../debug.js';
 import {StorageItem} from '../StorageItem.js';
 import {isOriginAllowedByLock} from '../tools/Tool.js';
 
@@ -30,6 +30,8 @@ import {
   type RequestOptions,
 } from './AiAgent.js';
 
+const {debugLog} = AiUtils.Debug;
+
 type NetworkRequest = SDK.NetworkRequest.NetworkRequest;
 
 const lockedString = i18n.i18n.lockedString;
@@ -106,8 +108,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
   readonly #performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
   readonly #onInspectElement?: () => Promise<SDK.DOMModel.DOMNode|null>;
   readonly #networkTimeCalculator?: NetworkTimeCalculator.NetworkTransferTimeCalculator;
-  readonly #lighthouseRecording?:
-      (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  readonly #lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.RunTypes.RunResult>;
   #allowedOrigin: () => AllowedOriginResult;
   readonly #networkLog: Logs.NetworkLog.NetworkLog;
   readonly #workspace: Workspace.Workspace.WorkspaceImpl;
@@ -439,14 +440,19 @@ export class ContextSelectionAgent extends AiAgent<never> {
         const mode = parseLighthouseMode(params.mode);
         debugLog(`Recording with Lighthouse; runMode=${mode}`);
         const result = await this.#lighthouseRecording({mode});
-        if (!result) {
+        if (result.status === 'cancelled') {
+          return {
+            error: 'The user cancelled the Lighthouse audit. Do not run it again unless the user asks you to.',
+          };
+        }
+        if (result.status === 'failed') {
           return {error: 'Failed to generate Lighthouse report.'};
         }
 
         return {
-          context: new LighthouseContext(result),
+          context: new LighthouseContext(result.report),
           description: 'User has selected a Lighthouse report',
-          widgets: [{name: 'LIGHTHOUSE_REPORT', data: {report: result}}],
+          widgets: [{name: 'LIGHTHOUSE_REPORT', data: {report: result.report}}],
         };
       },
     });

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

@@ -8,7 +8,7 @@ import * as Platform from '../../../core/platform/platform.js';
 import * as Root from '../../../core/root/root.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import type * as Protocol from '../../../generated/protocol.js';
-import {isNaturalLanguageInterfaceEnabled} from '../AiUtils.js';
+import * as AiUtils from '../../ai-utils/ai-utils.js';
 import type {ChangeManager} from '../ChangeManager.js';
 import {EvaluateAction, formatError, SideEffectError} from '../EvaluateAction.js';
 import {FREESTYLER_WORLD_CSP, FREESTYLER_WORLD_NAME} from '../injected.js';
@@ -16,6 +16,8 @@ import type {DataHandlerResult} from '../tools/Tool.js';
 
 import type {AgentOptions as BaseAgentOptions, FunctionHandlerOptions} from './AiAgent.js';
 
+const {isNaturalLanguageInterfaceEnabled} = AiUtils.AiUtils;
+
 const lockedString = i18n.i18n.lockedString;
 
 export type CreateExtensionScopeFunction = (changes: ChangeManager) => {

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

@@ -39,7 +39,7 @@ Content:
           "  - LCP breakdown:",
           "    - TTFB: 553 ms, bounds: {min: 465456489730µs, max: 465457042737µs}",
           "    - Render delay: 123 ms, bounds: {min: 465457042737µs, max: 465457166052µs}",
-          "  - CLS: 0.02, event: (eventKey: s-14250, ts: 465457121239)",
+          "  - CLS: 0.02, event: (eventKey: c-14250, ts: 465457121239)",
           "Metrics (field / real users): n/a – no data for this page in CrUX",
           "Available insights:",
           "  - insight name: RenderBlocking",