chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

package/front_end/panels/ai_assistance/agents/PatchAgent.ts

@@ -5,33 +5,28 @@
 import * as Host from '../../../core/host/host.js';
 import * as TextUtils from '../../../models/text_utils/text_utils.js';
 import type * as Workspace from '../../../models/workspace/workspace.js';
-import type * as LitHtml from '../../../ui/lit-html/lit-html.js';
+import type * as Lit from '../../../ui/lit/lit.js';
 
 import {
-  type ActionResponse,
   type AgentOptions as BaseAgentOptions,
   AgentType,
   AiAgent,
   type ContextResponse,
   ConversationContext,
-  debugLog,
-  ErrorType,
-  type ParsedResponse,
   type RequestOptions,
   type ResponseData,
-  ResponseType,
 } from './AiAgent.js';
 
 /* clang-format off */
 const preamble = `You are responsible for changing the source code on behalf of the user.
 The user query defines what changes are to be made.
 You have a number of functions to get information about source files in the project.
-Use those functions to fullful the user query.
+Use those functions to fulfill the user query.
 
 ## Step-by-step instructions
 
 - Think about what the user wants.
-- List all files in the project.
+- List all files in the project or search for relevant files.
 - Identify the files that are likely to be modified.
 - Retrieve the content of those files.
 - Rewrite the files according to the user query.
@@ -42,6 +37,19 @@ Use those functions to fullful the user query.
 - Always prefer changing the true source files and not the build output.
 - The build output is usually in dist/, out/, build/ folders.
 - *CRITICAL* never make the same function call twice.
+- *CRITICAL* do not make any changes if not prompted.
+
+Instead of using the writeFile function you can also produce  the following diff format:
+
+\`\`\`
+src/index.html
+<meta charset="utf-8">
+<title>Test</title>
+\`\`\`
+
+First output the filename (example, src/index.html), then output the SEARCH block,
+followed by the REPLACE block.
+
 `;
 /* clang-format on */
 
@@ -66,13 +74,11 @@ export class ProjectContext extends ConversationContext<Workspace.Workspace.Proj
     return document.createElement('span');
   }
 
-  override getTitle(): string|ReturnType<typeof LitHtml.Directives.until> {
+  override getTitle(): string|ReturnType<typeof Lit.Directives.until> {
     return this.#project.displayName();
   }
 }
 
-const MAX_STEPS = 10;
-
 function getFiles(project: Workspace.Workspace.Project):
     {files: string[], map: Map<string, Workspace.UISourceCode.UISourceCode>} {
   const files = [];
@@ -90,12 +96,14 @@ function getFiles(project: Workspace.Workspace.Project):
 }
 
 export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
-  #aidaClient: Host.AidaClient.AidaClient;
   #project: ConversationContext<Workspace.Workspace.Project>|undefined;
 
-  override handleContextDetails(_select: ConversationContext<Workspace.Workspace.Project>|
-                                null): AsyncGenerator<ContextResponse, void, void> {
-    throw new Error('Method not implemented.');
+  override async *
+      // eslint-disable-next-line require-yield
+      handleContextDetails(_select: ConversationContext<Workspace.Workspace.Project>|null):
+          AsyncGenerator<ContextResponse, void, void> {
+    // TODO: Implement
+    return;
   }
 
   override readonly type = AgentType.PATCH;
@@ -114,12 +122,8 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
   }
 
   constructor(opts: BaseAgentOptions) {
-    super({
-      aidaClient: opts.aidaClient,
-      serverSideLoggingEnabled: false,
-    });
-    this.#aidaClient = opts.aidaClient;
-    this.declareFunction('listFiles', {
+    super(opts);
+    this.declareFunction<Record<never, unknown>>('listFiles', {
       description: 'returns a list of all files in the project.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -136,12 +140,90 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
         const project = this.#project.getItem();
         const {files} = getFiles(project);
         return {
-          files,
+          result: {
+            files,
+          }
         };
       },
     });
 
-    this.declareFunction('readFile', {
+    this.declareFunction<{
+      query: string,
+      caseSensitive: boolean,
+      isRegex: boolean,
+    }>('searchInFiles', {
+      description:
+          'Searches for a query in all files in the project. For each match it returns the positions of matches.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: false,
+        properties: {
+          query: {
+            type: Host.AidaClient.ParametersTypes.STRING,
+            description: 'The query to search for matches in files',
+            nullable: false,
+          },
+          caseSensitive: {
+            type: Host.AidaClient.ParametersTypes.BOOLEAN,
+            description: 'Whether the query is case sensitive or not',
+            nullable: false,
+          },
+          isRegex: {
+            type: Host.AidaClient.ParametersTypes.BOOLEAN,
+            description: 'Whether the query is a regular expression or not',
+            nullable: true,
+          }
+        },
+      },
+      handler: async params => {
+        if (!this.#project) {
+          return {
+            error: 'No project available',
+          };
+        }
+        const project = this.#project.getItem();
+        const {map} = getFiles(project);
+        const matches = [];
+        for (const [filepath, file] of map.entries()) {
+          const results = await project.searchInFileContent(file, params.query, params.caseSensitive, params.isRegex);
+          for (const result of results) {
+            matches.push({
+              filepath,
+              lineNumber: result.lineNumber,
+              columnNumber: result.columnNumber,
+              matchLength: result.matchLength
+            });
+          }
+        }
+        return {
+          result: {
+            matches,
+          }
+        };
+      },
+    });
+
+    this.declareFunction('changeFile', {
+      description: 'returns a list of all files in the project.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: true,
+        properties: {
+          filepath: {
+            type: Host.AidaClient.ParametersTypes.STRING,
+            description: 'A file path that identifies the file to get the content for',
+            nullable: false,
+          },
+        },
+      },
+      handler: async () => {
+        return {result: {}};
+      },
+    });
+
+    this.declareFunction<{filepath: string}>('readFile', {
       description: 'returns the complement content of a file',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -149,12 +231,12 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
         properties: {
           filepath: {
             type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'A file path that idenfities the file to get the content for',
+            description: 'A file path that identifies the file to get the content for',
             nullable: false,
           },
         },
       },
-      handler: async (params: {filepath: string}) => {
+      handler: async params => {
         if (!this.#project) {
           return {
             error: 'No project available',
@@ -180,13 +262,16 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
             error: 'Non-text files are not supported',
           };
         }
+
         return {
-          content: content.text,
+          result: {
+            content: content.text,
+          }
         };
       },
     });
 
-    this.declareFunction('writeFile', {
+    this.declareFunction<{filepath: string, content: string}>('writeFile', {
       description: '(over)writes the file with the provided content',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -194,7 +279,7 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
         properties: {
           filepath: {
             type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'A file path that idenfities the file',
+            description: 'A file path that identifies the file',
             nullable: false,
           },
           content: {
@@ -204,7 +289,7 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
           },
         },
       },
-      handler: async (params: {filepath: string, content: string}) => {
+      handler: async params => {
         if (!this.#project) {
           return {
             error: 'No project available',
@@ -219,187 +304,24 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
           };
         }
         const content = params.content;
-        // TODO: we unespace some characters to restore the original
+        // TODO: we unescape some characters to restore the original
         // content but this should be fixed upstream.
         uiSourceCode.setContent(
             content.replaceAll('\\n', '\n').replaceAll('\\"', '"').replaceAll('\\\'', '\''),
             false,
         );
-        return {};
-      },
-    });
-  }
-
-  override async *
-      aidaFetch(
-          request: Host.AidaClient.AidaRequest,
-          options?: {signal?: AbortSignal},
-          ):
-          AsyncGenerator<
-              {
-                parsedResponse: ParsedResponse,
-                functionCall?: Host.AidaClient.AidaFunctionCallResponse, completed: boolean,
-                rpcId?: Host.AidaClient.RpcGlobalId,
-              },
-              void, void> {
-    let rawResponse: Host.AidaClient.AidaResponse|undefined = undefined;
-    let rpcId: Host.AidaClient.RpcGlobalId|undefined;
-    for await (rawResponse of this.#aidaClient.fetch(request, options)) {
-      rpcId = rawResponse.metadata.rpcGlobalId ?? rpcId;
-
-      if (rawResponse.functionCalls?.length) {
-        debugLog('functionCalls.length', rawResponse.functionCalls.length);
-        yield {
-          rpcId,
-          parsedResponse: {answer: ''},
-          functionCall: rawResponse.functionCalls[0],
-          completed: true,
+        return {
+          result: null,
         };
-        return;
-      }
-
-      const parsedResponse = this.parseResponse(rawResponse);
-      yield {
-        rpcId,
-        parsedResponse,
-        completed: rawResponse.completed,
-      };
-    }
-
-    debugLog({
-      request,
-      response: rawResponse,
+      },
     });
   }
 
-  #history: Host.AidaClient.Content[] = [];
-  override buildChatHistoryForAida(): Host.AidaClient.Content[] {
-    return [...this.#history];
-  }
-
-  override async * run(initalQuery: string, options: {
+  override async * run(initialQuery: string, options: {
     signal?: AbortSignal, selected: ConversationContext<Workspace.Workspace.Project>|null,
   }): AsyncGenerator<ResponseData, void, void> {
-    await options.selected?.refresh();
-
     this.#project = options.selected ?? undefined;
 
-    let query: Host.AidaClient.Part = {text: initalQuery};
-
-    // Request is built here to capture history up to this point.
-    let request = this.buildRequest(query);
-
-    const response = {
-      type: ResponseType.USER_QUERY,
-      query: JSON.stringify(query),
-    } as const;
-    yield response;
-
-    for (let i = 0; i < MAX_STEPS; i++) {
-      const queryResponse = {
-        type: ResponseType.QUERYING,
-        query: JSON.stringify(query),
-      } as const;
-      yield queryResponse;
-      let rpcId: Host.AidaClient.RpcGlobalId|undefined;
-      let parsedResponse: ParsedResponse|undefined = undefined;
-      let functionCall: Host.AidaClient.AidaFunctionCallResponse|undefined = undefined;
-      try {
-        for await (const fetchResult of this.aidaFetch(request, {signal: options.signal})) {
-          rpcId = fetchResult.rpcId;
-          parsedResponse = fetchResult.parsedResponse;
-          functionCall = fetchResult.functionCall;
-        }
-      } catch (err) {
-        debugLog('Error calling the AIDA API', err);
-
-        if (err instanceof Host.AidaClient.AidaAbortError) {
-          const response = {
-            type: ResponseType.ERROR,
-            error: ErrorType.ABORT,
-          } as const;
-          yield response;
-          break;
-        }
-
-        const error = (err instanceof Host.AidaClient.AidaBlockError) ? ErrorType.BLOCK : ErrorType.UNKNOWN;
-        const response = {
-          type: ResponseType.ERROR,
-          error,
-        } as const;
-        Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceError);
-        yield response;
-
-        break;
-      } finally {
-        if (i === 0) {
-          this.#history.push(request.current_message);
-        } else {
-          this.#history.push({
-            ...request.current_message,
-            role: Host.AidaClient.Role.ROLE_UNSPECIFIED,
-          });
-        }
-      }
-
-      if (parsedResponse && 'answer' in parsedResponse && Boolean(parsedResponse.answer)) {
-        const response = {
-          type: ResponseType.ANSWER,
-          text: parsedResponse.answer,
-          rpcId,
-          suggestions: undefined,
-        } as const;
-        Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceAnswerReceived);
-        this.#history.push({
-          parts: [{
-            text: parsedResponse.answer,
-          }],
-          role: Host.AidaClient.Role.MODEL,
-        });
-        yield response;
-        break;
-      } else if (functionCall) {
-        const callResult = await this.callFunction(functionCall.name, functionCall.args);
-        // Capture history state for the next iteration query.
-        query = {
-          functionResponse: {
-            name: functionCall.name,
-            response: callResult,
-          },
-        };
-        this.#history.push({
-          parts: [{
-            functionCall,
-          }],
-          role: Host.AidaClient.Role.MODEL,
-        });
-        request = this.buildRequest(query);
-        const result: ActionResponse = {
-          type: ResponseType.ACTION,
-          code: JSON.stringify(functionCall),
-          output: JSON.stringify(callResult),
-          canceled: false,
-        };
-        yield result;
-      } else {
-        const response = {
-          type: ResponseType.ERROR,
-          error: ErrorType.UNKNOWN,
-        } as const;
-        Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceError);
-        yield response;
-        break;
-      }
-
-      if (i === MAX_STEPS - 1) {
-        const response = {
-          type: ResponseType.ERROR,
-          error: ErrorType.MAX_STEPS,
-        } as const;
-        Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceError);
-        yield response;
-        break;
-      }
-    }
+    return yield* super.run(initialQuery, options);
   }
 }

package/front_end/panels/ai_assistance/agents/PerformanceAgent.test.ts

@@ -3,6 +3,8 @@
 // found in the LICENSE file.
 
 import * as Host from '../../../core/host/host.js';
+import * as Trace from '../../../models/trace/trace.js';
+import {mockAidaClient} from '../../../testing/AiAssistanceHelpers.js';
 import {describeWithEnvironment, getGetHostConfigStub} from '../../../testing/EnvironmentHelpers.js';
 import {TraceLoader} from '../../../testing/TraceLoader.js';
 import * as TimelineUtils from '../../timeline/utils/utils.js';
@@ -18,14 +20,31 @@ describeWithEnvironment('PerformanceAgent', () => {
     });
   }
 
-  function mockAidaClient(
-      fetch: () => AsyncGenerator<Host.AidaClient.AidaResponse, void, void>,
-      ): Host.AidaClient.AidaClient {
-    return {
-      fetch,
-      registerClientEvent: () => Promise.resolve({}),
-    };
-  }
+  describe('getOrigin()', () => {
+    it('calculates the origin of the selected node when it has a URL associated with it', async function() {
+      const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
+      // An Evaluate Script event, picked because it has a URL of googletagmanager.com/...
+      const evalScriptEvent = parsedTrace.Renderer.allTraceEntries.find(
+          event => event.name === Trace.Types.Events.Name.EVALUATE_SCRIPT && event.ts === 122411195649);
+      assert.exists(evalScriptEvent);
+      const aiCallTree = TimelineUtils.AICallTree.AICallTree.from(evalScriptEvent, parsedTrace);
+      assert.isOk(aiCallTree);
+      const callTreeContext = new CallTreeContext(aiCallTree);
+      assert.strictEqual(callTreeContext.getOrigin(), 'https://www.googletagmanager.com');
+    });
+
+    it('returns a random but deterministic "origin" for nodes that have no URL associated', async function() {
+      const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
+      // A random layout event with no URL associated
+      const layoutEvent = parsedTrace.Renderer.allTraceEntries.find(
+          event => event.name === Trace.Types.Events.Name.LAYOUT && event.ts === 122411130078);
+      assert.exists(layoutEvent);
+      const aiCallTree = TimelineUtils.AICallTree.AICallTree.from(layoutEvent, parsedTrace);
+      assert.isOk(aiCallTree);
+      const callTreeContext = new CallTreeContext(aiCallTree);
+      assert.strictEqual(callTreeContext.getOrigin(), 'Layout_90829_259_122411130078');
+    });
+  });
 
   describe('buildRequest', () => {
     beforeEach(() => {
@@ -38,7 +57,7 @@ describeWithEnvironment('PerformanceAgent', () => {
         aidaClient: {} as Host.AidaClient.AidaClient,
       });
       assert.strictEqual(
-          agent.buildRequest({text: 'test input'}).options?.model_id,
+          agent.buildRequest({text: 'test input'}, Host.AidaClient.Role.USER).options?.model_id,
           'test model',
       );
     });
@@ -49,37 +68,28 @@ describeWithEnvironment('PerformanceAgent', () => {
         aidaClient: {} as Host.AidaClient.AidaClient,
       });
       assert.strictEqual(
-          agent.buildRequest({text: 'test input'}).options?.temperature,
+          agent.buildRequest({text: 'test input'}, Host.AidaClient.Role.USER).options?.temperature,
           1,
       );
     });
 
-    it('structure matches the snapshot', () => {
+    it('structure matches the snapshot', async () => {
       mockHostConfig('test model');
       sinon.stub(crypto, 'randomUUID').returns('sessionId' as `${string}-${string}-${string}-${string}-${string}`);
       const agent = new PerformanceAgent({
-        aidaClient: {} as Host.AidaClient.AidaClient,
+        aidaClient: mockAidaClient([[{explanation: 'answer'}]]),
         serverSideLoggingEnabled: true,
       });
       sinon.stub(agent, 'preamble').value('preamble');
-      agent.chatNewHistoryForTesting = [
-        {
-          type: ResponseType.USER_QUERY,
-          query: 'question',
-        },
-        {
-          type: ResponseType.QUERYING,
-          query: 'question',
-        },
-        {
-          type: ResponseType.ANSWER,
-          text: 'answer',
-        },
-      ];
+
+      await Array.fromAsync(agent.run('question', {selected: null}));
+
       assert.deepEqual(
-          agent.buildRequest({
-            text: 'test input',
-          }),
+          agent.buildRequest(
+              {
+                text: 'test input',
+              },
+              Host.AidaClient.Role.USER),
           {
             current_message: {role: Host.AidaClient.Role.USER, parts: [{text: 'test input'}]},
             client: 'CHROME_DEVTOOLS',
@@ -115,22 +125,16 @@ describeWithEnvironment('PerformanceAgent', () => {
       // A basic Layout.
       const layoutEvt = parsedTrace.Renderer.allTraceEntries.find(event => event.ts === 465457096322);
       assert.exists(layoutEvt);
-      const aiCallTree =
-          TimelineUtils.AICallTree.AICallTree.from(layoutEvt, parsedTrace.Renderer.allTraceEntries, parsedTrace);
+      const aiCallTree = TimelineUtils.AICallTree.AICallTree.from(layoutEvt, parsedTrace);
       assert.exists(aiCallTree);
 
-      async function* generateAnswer() {
-        yield {
+      const agent = new PerformanceAgent({
+        aidaClient: mockAidaClient([[{
           explanation: 'This is the answer',
           metadata: {
             rpcGlobalId: 123,
           },
-          completed: true,
-        };
-      }
-
-      const agent = new PerformanceAgent({
-        aidaClient: mockAidaClient(generateAnswer),
+        }]]),
       });
 
       const responses = await Array.fromAsync(agent.run('test', {selected: new CallTreeContext(aiCallTree)}));
@@ -165,7 +169,6 @@ self: 3
         },
         {
           type: ResponseType.QUERYING,
-          query: `${expectedData}\n\n# User request\n\ntest`,
         },
         {
           type: ResponseType.ANSWER,
@@ -175,7 +178,7 @@ self: 3
         },
       ]);
 
-      assert.deepEqual(agent.chatHistoryForTesting, [
+      assert.deepEqual(agent.buildRequest({text: ''}, Host.AidaClient.Role.USER).historical_contexts, [
         {
           role: 1,
           parts: [{text: `${aiCallTree.serialize()}\n\n# User request\n\ntest`}],
@@ -201,32 +204,6 @@ self: 3
       const enhancedQuery1 = await agent.enhanceQuery('What is this?', new CallTreeContext(mockAiCallTree));
       assert.strictEqual(enhancedQuery1, 'Mock call tree\n\n# User request\n\nWhat is this?');
 
-      // Create history state of the above query
-      agent.chatNewHistoryForTesting = [
-        {
-          type: ResponseType.USER_QUERY,
-          query: 'What is this?',
-        },
-        {
-          type: ResponseType.CONTEXT,
-          title: 'Analyzing call tree',
-          details: [
-            {
-              title: 'Selected call tree',
-              text: mockAiCallTree.serialize(),
-            },
-          ],
-        },
-        {
-          type: ResponseType.QUERYING,
-          query: enhancedQuery1,
-        },
-        {
-          type: ResponseType.ANSWER,
-          text: 'test answer',
-        },
-      ];
-
       const query2 = 'But what about this follow-up question?';
       const enhancedQuery2 = await agent.enhanceQuery(query2, new CallTreeContext(mockAiCallTree));
       assert.strictEqual(enhancedQuery2, query2);

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

@@ -5,6 +5,7 @@
 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 Trace from '../../../models/trace/trace.js';
 import * as TimelineUtils from '../../timeline/utils/utils.js';
 import * as PanelUtils from '../../utils/utils.js';
 
@@ -130,8 +131,25 @@ export class CallTreeContext extends ConversationContext<TimelineUtils.AICallTre
   }
 
   override getOrigin(): string {
-    // TODO: implement cross-origin checks for the PerformanceAgent.
-    return '';
+    const selectedEvent = this.#callTree.selectedNode.event;
+    // Get the non-resolved (ignore sourcemaps) URL for the event. We use the
+    // non-resolved URL as in the context of the AI Assistance panel, we care
+    // about the origin it was served on.
+    const nonResolvedURL = Trace.Handlers.Helpers.getNonResolvedURL(selectedEvent, this.#callTree.parsedTrace);
+    if (nonResolvedURL) {
+      const origin = Common.ParsedURL.ParsedURL.extractOrigin(nonResolvedURL);
+      if (origin) {  // origin could be the empty string.
+        return origin;
+      }
+    }
+    // Generate a random "origin". We do this rather than return an empty
+    // string or some "unknown" string so that each event without a definite
+    // URL is considered a new, standalone origin. This is safer from a privacy
+    // & security perspective, else we risk bucketing events together that
+    // should not be. We also don't want to make it entirely random so we
+    // cannot calculate it deterministically.
+    const uuid = `${selectedEvent.name}_${selectedEvent.pid}_${selectedEvent.tid}_${selectedEvent.ts}`;
+    return uuid;
   }
 
   override getItem(): TimelineUtils.AICallTree.AICallTree {
@@ -196,24 +214,25 @@ export class PerformanceAgent extends AiAgent<TimelineUtils.AICallTree.AICallTre
     };
   }
 
+  #contextSet = new WeakSet();
+
   override async enhanceQuery(query: string, aiCallTree: ConversationContext<TimelineUtils.AICallTree.AICallTree>|null):
       Promise<string> {
-    const treeStr = aiCallTree?.getItem().serialize();
+    const treeItem = aiCallTree?.getItem();
+    let treeStr = treeItem?.serialize();
 
     // Collect the queries from previous messages in this session
-    const prevQueries: string[] = [];
-    for await (const data of this.runFromHistory()) {
-      if (data.type === ResponseType.QUERYING) {
-        prevQueries.push(data.query);
-      }
-    }
+
     // If this is a followup chat about the same call tree, don't include the call tree serialization again.
     // We don't need to repeat it and we'd rather have more the context window space.
-    if (prevQueries.length && treeStr && prevQueries.find(q => q.startsWith(treeStr))) {
-      aiCallTree = null;
+    if (treeItem && this.#contextSet.has(treeItem) && treeStr) {
+      treeStr = undefined;
+    }
+    if (treeItem && !this.#contextSet.has(treeItem)) {
+      this.#contextSet.add(treeItem);
     }
 
-    const perfEnhancementQuery = aiCallTree ? `${treeStr}\n\n# User request\n\n` : '';
+    const perfEnhancementQuery = treeStr ? `${treeStr}\n\n# User request\n\n` : '';
     return `${perfEnhancementQuery}${query}`;
   }
 }