chrome-devtools-frontend 1.0.1669021 → 1.0.1672388

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

@@ -7,12 +7,14 @@ import * as i18n from '../../../core/i18n/i18n.js';
 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 type {ChangeManager} from '../ChangeManager.js';
 import {debugLog} from '../debug.js';
 import {EvaluateAction, formatError, SideEffectError} from '../EvaluateAction.js';
-import {FREESTYLER_WORLD_NAME} from '../injected.js';
+import {FREESTYLER_WORLD_CSP, FREESTYLER_WORLD_NAME} from '../injected.js';
+import type {DataHandlerResult} from '../tools/Tool.js';
 
-import type {AgentOptions as BaseAgentOptions, FunctionCallHandlerResult, FunctionHandlerOptions} from './AiAgent.js';
+import type {AgentOptions as BaseAgentOptions, FunctionHandlerOptions} from './AiAgent.js';
 
 const lockedString = i18n.i18n.lockedString;
 
@@ -26,15 +28,45 @@ export interface ExecuteJsAgentOptions extends BaseAgentOptions {
   execJs?: typeof executeJsCode;
 }
 
+/**
+ * Creates or retrieves the DevTools AI Assistance isolated world for the given frame.
+ *
+ * Page.createIsolatedWorld is idempotent per frame when given a fixed worldName.
+ * If an isolated world with FREESTYLER_WORLD_NAME already exists on the frame,
+ * CDP returns its existing executionContextId rather than re-creating the world.
+ */
+export async function getOrCreateIsolatedWorld(
+    target: SDK.Target.Target,
+    frameId: Protocol.Page.FrameId,
+    ): Promise<SDK.RuntimeModel.ExecutionContext> {
+  const pageAgent = target.pageAgent();
+  const runtimeModel = target.model(SDK.RuntimeModel.RuntimeModel);
+  const {executionContextId} = await pageAgent.invoke_createIsolatedWorld({
+    frameId,
+    worldName: FREESTYLER_WORLD_NAME,
+    contentSecurityPolicy: FREESTYLER_WORLD_CSP,
+  });
+  const executionContext = runtimeModel?.executionContext(executionContextId);
+  if (!executionContext) {
+    throw new Error('Execution context is not found for executing code');
+  }
+  return executionContext;
+}
+
 export async function executeJsCode(
     functionDeclaration: string,
-    {throwOnSideEffect, contextNode}: {throwOnSideEffect: boolean, contextNode: SDK.DOMModel.DOMNode|null}):
-    Promise<string> {
+    options: {
+      contextNode: SDK.DOMModel.DOMNode|null,
+      throwOnSideEffect?: boolean,
+    },
+    ): Promise<string> {
+  const {contextNode, throwOnSideEffect} = options;
+
   if (!contextNode) {
     throw new Error('Cannot execute JavaScript because of missing context node');
   }
-  const target = contextNode.domModel().target();
 
+  const target = contextNode.domModel().target();
   if (!target) {
     throw new Error('Target is not found for executing code');
   }
@@ -46,26 +78,19 @@ export async function executeJsCode(
     throw new Error('Main frame is not found for executing code');
   }
 
-  const runtimeModel = target.model(SDK.RuntimeModel.RuntimeModel);
-  const pageAgent = target.pageAgent();
-
-  // This returns previously created world if it exists for the frame.
-  const {executionContextId} = await pageAgent.invoke_createIsolatedWorld({frameId, worldName: FREESTYLER_WORLD_NAME});
-  const executionContext = runtimeModel?.executionContext(executionContextId);
-  if (!executionContext) {
-    throw new Error('Execution context is not found for executing code');
-  }
+  const executionContext = await getOrCreateIsolatedWorld(target, frameId);
 
   if (executionContext.debuggerModel.selectedCallFrame()) {
     return formatError('Cannot evaluate JavaScript because the execution is paused on a breakpoint.');
   }
 
-  const remoteObject = await contextNode.resolveToObject(undefined, executionContextId);
+  const remoteObject = await contextNode.resolveToObject(undefined, executionContext.id);
   if (!remoteObject) {
     throw new Error('Cannot execute JavaScript because remote object cannot be resolved');
   }
 
-  return await EvaluateAction.execute(functionDeclaration, [remoteObject], executionContext, {throwOnSideEffect});
+  return await EvaluateAction.execute(functionDeclaration, [remoteObject], executionContext,
+                                      {throwOnSideEffect: !!throwOnSideEffect});
 }
 
 const MAX_OBSERVATION_BYTE_LENGTH = 25_000;
@@ -89,7 +114,7 @@ export class JavascriptExecutor {
     this.#execJs = execJs;
   }
 
-  async executeAction(action: string, options?: FunctionHandlerOptions): Promise<FunctionCallHandlerResult<unknown>> {
+  async executeAction(action: string, options?: FunctionHandlerOptions): Promise<DataHandlerResult<unknown>> {
     debugLog(`Action to execute: ${action}`);
 
     if (options?.approved === false) {

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

@@ -30,11 +30,11 @@ import {
   type AiWidget,
   type ContextResponse,
   type ConversationContext,
-  type FunctionCallHandlerResult,
   type ParsedResponse,
   type RequestOptions,
   type ResponseData,
   ResponseType,
+  type ToolResult,
 } from './AiAgent.js';
 
 const UIStringsNotTranslated = {
@@ -248,6 +248,7 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
   constructor(opts: PerformanceAgentOptions) {
     super(opts);
     this.#tracker = opts.tracker ?? Tracing.FreshRecording.Tracker.instance();
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     this.#networkLog = opts.networkLog ?? Logs.NetworkLog.NetworkLog.instance();
   }
   #formatter: PerformanceTraceFormatter|null = null;
@@ -729,7 +730,7 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
       focus: AgentFocus,
       functionName: string,
       cacheKey: string,
-      ): Promise<FunctionCallHandlerResult<{summary: string}>> {
+      ): Promise<ToolResult<{summary: string}>> {
     const formatter = this.#formatter;
     if (!formatter) {
       throw new Error('missing formatter');