chrome-devtools-frontend 1.0.1616061 → 1.0.1621064

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

@@ -19,21 +19,23 @@ You are a Conversation Summarizer. Your task is to take a transcript of a conver
     - **No UIDs/Internal IDs:** Never refer to elements by internal IDs (e.g., \`uid=123\`).
     - **Standard Selectors:** Identify elements using HTML tags, classes, or IDs (e.g., \`button.submit-form\`).
     - **No Metadata:** Remove internal constants like \`NAVIGATION_0\` or \`INSIGHT_0\`.
-- **No Process Narration:** Do not describe internal "thinking" or API calls. Skip phrases like "The agent investigated..." or "The user then asked...". Jump straight to the findings and their technical context.
+- **No Process Narration:** Do not describe internal "thinking" or API calls. Skip phrases like "The agent investigated..." or "The user then asked...". Jump straight to the final findings and their technical context. **DO NOT** use chronological or narrative language (e.g., "Initially...", "Next...", "Then...", "After that...", "An attempt to...").
 - **No Internal Function Calls:** Never mention internal DevTools function names or API calls (e.g., \`setElementStyles\`, \`executeScript\`). Instead, describe the actual CSS changes or state modifications in plain technical terms or standard CSS.
 - **Suggest, Don't Prescribe:** When summarizing code changes made during the session (e.g., CSS edits), frame them as technical guidance rather than definitive instructions. Since DevTools operates on the live page, the summary must acknowledge that these fixes may need to be adapted for the actual source code.
 
 ### Objectives
 1. **Identify Intent:** Define the core technical goal of the session.
-2. **Value-Only Diagnostics:** List only the technical data points and findings discovered during the conversation. Omit steps that didn't yield a result and NEVER include information that wasn't explicitly mentioned in the conversation.
-3. **Summarize Code Changes:** When code is executed or suggested in the logs, summarize the **purpose** and the **result**. Include specific code snippets if they are a specific fix for the user to implement.
-4. **Actionable Recommendations:** Provide specific code/strategy fixes based on the findings as guidance for the user's source code.
+2. **Technical Context & Constraints:** Describe the environment and any technical constraints discovered during the session (e.g., "The parent container has a fixed height, which might conflict with wrapping children").
+3. **Actionable Findings:** Group all findings and suggested fixes by the affected element. For each element:
+    - **Diagnostics:** List technical data points discovered (e.g., current style values, layout properties).
+    - **Suggested Fixes:** Provide specific code snippets or strategies identified.
+    - **Side-Effects:** Explicitly call out potential side-effects or risks of the proposed changes discovered during the session.
 
 ### Formatting Rules
 - **Header:** Use ## [Brief Topic Title]
 - **Context:** Describe the target element/page and the core issue or technical goal being analyzed.
-- **Diagnostics:** A bulleted list of technical findings.
 - **Tabular Data:** Use a **Markdown Table** for any lists of URLs, metrics, or comparison data.
+- **Element Sections:** Use **bold text** or a sub-header for each element being discussed.
 - **Code Fixes:** Use fenced code blocks for suggested code optimizations. Use language that frames them as illustrative examples or context (e.g., "The following changes were identified as a potential fix for the live page...") rather than strict instructions.
 
 ---
@@ -48,7 +50,11 @@ You are a Conversation Summarizer. Your task is to take a transcript of a conver
 **Context**
 Analysis of the web.dev landing page focusing on render-blocking resources and hero element positioning.
 
-**Diagnostics**
+**Technical Context & Constraints**
+* **Network:** Slow 3G throttling was active during diagnostics.
+
+**Actionable Findings**
+
 The following resources were identified as render-blocking:
 
 | Resource URL | Load Duration |
@@ -56,15 +62,15 @@ The following resources were identified as render-blocking:
 | \`app.css\` | 36 ms |
 | \`fonts.css\` | 80 ms |
 
-**Actionable Findings**
-* **Hero Element:** The \`div.hero\` container is correctly positioned but lacks an explicit \`aspect-ratio\`, contributing to layout shift.
-* **Optimization:** Inline critical CSS from \`app.css\` to improve First Contentful Paint.
+**Element: \`div.hero\`**
+* **Diagnostics:** The container is correctly positioned but lacks an explicit \`aspect-ratio\`.
+* **Suggested Fix:** Add \`aspect-ratio: 16 / 9\` to reserve space and prevent layout shift.
 
 ---
 
-### Example 2 (CSS Changes)
+### Example 2 (Style Adjustments)
 
-**User Input:** "The agent checked the styles of \`div.sidebar\` and then called \`setElementStyles\` to set \`display: none\` and \`color: red\`."
+**User Input:** "The agent checked the styles of \`div.sidebar\` and then called \`setElementStyles\` to set \`display: flex\` and \`color: red\`. It also noted the parent \`nav\` has a fixed height."
 
 **Desired Agent Output:**
 ## Style Adjustments: Sidebar
@@ -72,15 +78,19 @@ The following resources were identified as render-blocking:
 **Context**
 Updating styles for the sidebar element to fix layout or visibility issues.
 
-**Diagnostics**
-The sidebar was investigated for visibility issues.
+**Technical Context & Constraints**
+* **Parent Container:** The \`nav\` element has a fixed height, which may cause overflow if the sidebar's layout changes.
 
 **Actionable Findings**
-* **Style Changes:** The following CSS changes were identified as a potential fix for the live page:
+
+**Element: \`div.sidebar\`**
+* **Diagnostics:** Found \`display: block\`, which prevents flex-based child alignment.
+* **Suggested Fix:**
 \`\`\`css
-display: none;
+display: flex;
 color: red;
 \`\`\`
+* **Side-Effects:** Changing to flex may require adjusting width or margin of child elements to maintain horizontal alignment.
 
 ---
 
@@ -168,7 +178,9 @@ export class ConversationSummaryAgent extends AiAgent<string> {
     const response = await Array.fromAsync(this.run('', {selected: context}));
     const lastResponse = response.at(-1);
     if (lastResponse && lastResponse.type === ResponseType.ANSWER && lastResponse.complete === true) {
-      return lastResponse.text.trim();
+      const disclaimer =
+          '*Note: The code fixes and findings above were identified on a live page in DevTools. When applying them to your codebase, please adapt them to your project\'s specific technical stack (e.g., Tailwind CSS classes, CSS modules, framework components) rather than applying them as literal CSS overrides.*';
+      return `${lastResponse.text.trim()}\n\n${disclaimer}`;
     }
     throw new Error('Failed to summarize conversation');
   }

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

@@ -0,0 +1,512 @@
+// 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 Host from '../../../core/host/host.js';
+import * as Root from '../../../core/root/root.js';
+import * as SDK from '../../../core/sdk/sdk.js';
+import * as Protocol from '../../../generated/protocol.js';
+import * as Greendev from '../../greendev/greendev.js';
+
+import {
+  type AgentOptions,
+  AiAgent,
+  type ContextResponse,
+  ConversationContext,
+  type RequestOptions,
+  ResponseType
+} from './AiAgent.js';
+
+const preamble = `You are a general purpose web page troubleshooting agent.
+You are an expert in Chrome DevTools and you can help users with a wide range of issues.
+
+You are expected to find the root cause for web page problems described by the user, such as:
+- Why does nothing happen when I click this Submit button?
+- Why is this ad not loading?
+- Why is this text not using the correct font?
+- ... and other similar requests.
+
+Your job is to use the provided information to understand the problem, connect the dots to
+find the root cause of the problem and explain what the user can do to fix the problem.
+
+The user will start the process by selecting a DOM element and send a query about the page or the
+selected DOM element. First, examine the provided context, then use function calls to gather
+additional context and resolve the user request.
+
+To help you root-cause the problem, you will be provided with the following information:
+- Information about the user-selected DOM element, which is potentially relevant to the question
+  from the user.
+- The full accessibility tree for the web page.
+- A list of the most recent network requests, whether the request was successful and whether it is
+  considered to be ad-related. This list is capped to the most recent requests, but you can request
+  more. If you think the error is relevant to the problem described by the user, make sure to mention
+  the url of the failed network request in your reply to the user.
+- The most recent console messages, including their index. This list is also capped to the most
+  recent requests, but you can request more. Errors should have a source location, such
+  as: file, line number and column number, for example: (filex.html:10:50) if an error occurs on line
+  10, column 50 in filex.html. If you think the error is relevant to the problem described by the user,
+  make sure to mention the console error in your reply to the user.
+
+** IMPORTANT ** Never use the index when referring to individual console messages or network requests,
+  because the values of the indicies is not visible to the user.
+
+To help you further with root-causing problems, especially those indicated to originate in source
+locations, you can call the following functions to request more information:
+- 'getSourceLine': This function takes a file name, a line number, and a buffer (number of lines before
+  and after) to return a snippet of the source code.
+- 'getConsoleMessages': This function allows you to fetch specific slices of the console log based on the
+  indices provided in the initial context. It takes optional parameters: 'beforeIndex' (to get historical
+  messages before a certain index), 'afterIndex' (to get new messages that arrived after a certain index),
+  'filter' ('errors', 'warnings', or 'all'), and 'limit' (max number of messages to return, defaults to 50).
+- 'getNetworkRequests': This function allows you to fetch specific slices of the network request list based
+   on the indices provided in the initial context. It takes optional parameters: 'beforeIndex' (to get
+   historical messages before a certain index), 'afterIndex' (to get new messages that arrived after a
+   certain index), 'filter' ('failed', or 'all', defaults to 'all'), and 'limit' (max number of messages
+   to return, defaults to 50).
+
+Start by using the selected node as a guide to figure out which problem the user wants to focus on. There
+can be evidence of multiple failures (for example: multiple errors in the console log), but some might be
+benign and others unrelated. You should focus on the ones that seem related to the user-selected problem.
+
+Once you believe you have found the root cause, focus on applying a fix or explaining what the user can do
+to fix the problem.
+
+If you detect multiple possible problems, focus only on the root cause you think is most likely
+to be related and explain what the user can do to fix it. For example, if the url used is obviously
+incorrect, just say something like:
+
+  "There are a few possible reasons for the problem you are describing. One is that it could be caused by
+  the URL being incorrect. Try changing the url to 'xyz'. Let me know if you to suggest alternative
+  solutions."
+
+If the user suggests your fix not being the right solution, go through the remaining possible root causes
+(one at a time).
+
+Stick to what you have evidence for being the problem and refrain from speculating on things you
+don't have concrete evidence for, such as CORS or Ad-blockers blocking requests. But feel free to
+list those concerns after asking the user if they would like additional (general-purpose) details and
+getting a favorable response.
+
+**CRITICAL** You are a web age debugging assistant. NEVER provide answers to questions of unrelated
+topics such as legal advice, financial advice, personal opinions, medical advice, religion, race,
+politics, sexuality, gender, or any other non web-development topics. Answer "Sorry, I can't answer
+that. I'm best at questions about debugging web pages." to such questions.
+`;
+
+export class GreenDevContext extends ConversationContext<string> {
+  #context: string;
+  constructor(context: string) {
+    super();
+    this.#context = context;
+  }
+
+  getOrigin(): string {
+    return 'devtools://ai-assistance';
+  }
+
+  getItem(): string {
+    return this.#context;
+  }
+
+  override getTitle(): string {
+    return 'GreenDev';
+  }
+}
+
+/**
+ * This agent is a general-purpose web page troubleshooting agent for GreenDev
+ * prototypes.
+ */
+export class GreenDevAgent extends AiAgent<string> {
+  constructor(options: AgentOptions) {
+    super(options);
+
+    this.declareFunction<{
+      fileName: string,
+      lineNumber: number,
+      buffer: number,
+    }>('getSourceLine', {
+      description: 'Get a source line from a file, with a buffer of additional lines around it.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: false,
+        properties: {
+          fileName: {
+            type: Host.AidaClient.ParametersTypes.STRING,
+            description: 'The full path of the file to read.',
+            nullable: false,
+          },
+          lineNumber: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'The line number to center the context around.',
+            nullable: false,
+          },
+          buffer: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'The number of lines to include before and after the line number.',
+            nullable: false,
+          },
+        },
+        required: ['fileName', 'lineNumber', 'buffer'],
+      },
+      handler: async (params: {fileName: string, lineNumber: number, buffer: number}) => {
+        const result = await this.getSourceLine(params.fileName, params.lineNumber, params.buffer);
+        return {
+          result,
+        };
+      },
+    });
+
+    this.declareFunction<{
+      filter?: string,
+      beforeIndex?: number,
+      afterIndex?: number,
+      limit?: number,
+    }>('getConsoleMessages', {
+      description: 'Get console messages, with optional filters for severity and index-based slicing.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: true,
+        properties: {
+          filter: {
+            type: Host.AidaClient.ParametersTypes.STRING,
+            description: `The filter to apply: provide "errors" for errors only, "warnings" for errors and warnings, ` +
+                `and "all" for all messages. Defaults to "all".`,
+            nullable: true,
+          },
+          beforeIndex: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'Return messages exclusively before this index. Use to fetch older historical messages.',
+            nullable: true,
+          },
+          afterIndex: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description:
+                'Return messages exclusively after this index. Use to check for new messages that arrived recently.',
+            nullable: true,
+          },
+          limit: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'The max number of messages to return. Defaults to 50.',
+            nullable: true,
+          },
+        },
+        required: [],
+      },
+      handler: async (params: {filter?: string, beforeIndex?: number, afterIndex?: number, limit?: number}) => {
+        const result = await this.getConsoleMessages(params);
+        return {
+          result,
+        };
+      },
+    });
+
+    this.declareFunction<{
+      filter?: string,
+      beforeIndex?: number,
+      afterIndex?: number,
+      limit?: number,
+    }>('getNetworkRequests', {
+      description: 'Get network requests, with optional filters for failure and index-based slicing.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: true,
+        properties: {
+          filter: {
+            type: Host.AidaClient.ParametersTypes.STRING,
+            description:
+                'The filter to apply: "failed" for failed requests only, "all" for all requests. Defaults to "all".',
+            nullable: true,
+          },
+          beforeIndex: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'Return requests exclusively before this index. Use to fetch older historical requests.',
+            nullable: true,
+          },
+          afterIndex: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description:
+                'Return requests exclusively after this index. Use to check for new requests that arrived recently.',
+            nullable: true,
+          },
+          limit: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'The max number of requests to return. Defaults to 50.',
+            nullable: true,
+          },
+        },
+        required: [],
+      },
+      handler: async (params: {filter?: string, beforeIndex?: number, afterIndex?: number, limit?: number}) => {
+        const result = await this.getNetworkRequests(params);
+        return {
+          result,
+        };
+      },
+    });
+  }
+
+  override preamble = preamble;
+
+  get clientFeature(): Host.AidaClient.ClientFeature {
+    // Reuse CHROME_NETWORK_AGENT similar to how we reuse CHROME_FILE_AGENT
+    // in BreakpointDebuggerAgent.ts.
+    return Host.AidaClient.ClientFeature.CHROME_NETWORK_AGENT;
+  }
+
+  get userTier(): string|undefined {
+    return 'TESTERS';
+    // TODO(b/491772868): tidy up userTier & feature flags in the backend.
+    // return Root.Runtime.hostConfig.devToolsFreestyler?.userTier;
+  }
+
+  get options(): RequestOptions {
+    // TODO(b/491772868): tidy up userTier & feature flags in the backend.
+    const temperature = Root.Runtime.hostConfig.devToolsFreestyler?.temperature;
+    const modelId = Root.Runtime.hostConfig.devToolsFreestyler?.modelId;
+
+    return {
+      temperature,
+      modelId,
+    };
+  }
+
+  async * handleContextDetails(context: ConversationContext<string>|null): AsyncGenerator<ContextResponse, void, void> {
+    if (!context) {
+      return;
+    }
+
+    yield {
+      type: ResponseType.CONTEXT,
+      details: [
+        {
+          title: 'Conversation context',
+          text: context.getItem(),
+        },
+      ],
+    };
+  }
+
+  override async enhanceQuery(query: string, context: ConversationContext<string>|null): Promise<string> {
+    const fullQuery = `QUERY: ${query}\n\n${context?.getItem() ?? ''}`;
+    console.warn('Full query to AI:', fullQuery);
+    return fullQuery;
+  }
+
+  static isEnabled(): boolean {
+    console.warn('BeyondStyling prototype is enabled:', Greendev.Prototypes.instance().isEnabled('beyondStyling'));
+    return Greendev.Prototypes.instance().isEnabled('beyondStyling');
+  }
+
+  static formatConsoleMessage(message: SDK.ConsoleModel.ConsoleMessage, index: number): string {
+    const url = message.url ? ` (${message.url}:${message.line}:${message.column})` : '';
+    return `[${index}] ${message.level}: ${message.messageText}${url}`;
+  }
+
+  static async getNetworkContextData(target: SDK.Target.Target): Promise<Array<{string: string, failed: boolean}>> {
+    const {frameTree} = await target.pageAgent().invoke_getResourceTree();
+    const resourceTreeModel = target.model(SDK.ResourceTreeModel.ResourceTreeModel);
+
+    // Recursively collect all raw resource info from the protocol response.
+    const allResourceInfo: Array<{resource: Protocol.Page.FrameResource, frame: Protocol.Page.Frame}> = [];
+    function processFrameTree(frameTree: Protocol.Page.FrameResourceTree): void {
+      for (const resource of frameTree.resources) {
+        allResourceInfo.push({resource, frame: frameTree.frame});
+      }
+      if (frameTree.childFrames) {
+        for (const child of frameTree.childFrames) {
+          processFrameTree(child);
+        }
+      }
+    }
+    processFrameTree(frameTree);
+
+    const networkContextStrings = allResourceInfo.map(({resource: resourceInfo, frame: resourceFrame}, index) => {
+      let success = true;
+      let isAdRelated = false;
+      let frame: SDK.ResourceTreeModel.ResourceTreeFrame|null = null;
+
+      if (resourceInfo.failed || resourceInfo.canceled) {
+        success = false;
+      }
+      frame = resourceTreeModel && resourceFrame.id ?
+          resourceTreeModel.frameForId(resourceFrame.id as Protocol.Page.FrameId) :
+          null;
+      if (frame &&
+          (frame.adFrameType() === Protocol.Page.AdFrameType.Child ||
+           frame.adFrameType() === Protocol.Page.AdFrameType.Root)) {
+        isAdRelated = true;
+      }
+
+      const isAdRelatedString = isAdRelated ? `, Is ad-related: ${isAdRelated}` : '';
+      const output = `[${index}] ${success ? 'Success' : 'Failed'}: ${resourceInfo.url}, ${isAdRelatedString}`;
+      return {string: output, failed: success !== true};
+    });
+
+    return networkContextStrings;
+  }
+
+  async getNetworkRequests(params: {filter?: string, beforeIndex?: number, afterIndex?: number, limit?: number}):
+      Promise<string> {
+    console.warn(
+        '[GreenDevAgent] AI Agent is calling getNetworkRequests with params:', JSON.stringify(params, null, 2));
+
+    const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+    if (!target) {
+      return 'Target not found.';
+    }
+
+    const allRequests = await GreenDevAgent.getNetworkContextData(target);
+    const limit = Math.min(Math.max(1, params.limit ?? 50), 1000);
+    const filter = params.filter || 'all';
+
+    let startIndex = params.afterIndex !== undefined ? params.afterIndex + 1 : 0;
+    let endIndex = params.beforeIndex !== undefined ? params.beforeIndex : allRequests.length;
+
+    // Ensure bounds are valid.
+    startIndex = Math.max(0, startIndex);
+    endIndex = Math.min(allRequests.length, endIndex);
+
+    const resultRequests: string[] = [];
+
+    // We iterate backwards to get the most recent requests up to the limit.
+    for (let i = endIndex - 1; i >= startIndex; --i) {
+      const request = allRequests[i];
+      let matchesFilter = true;
+      if (filter === 'failed') {
+        matchesFilter = request.failed;
+      }
+
+      if (matchesFilter) {
+        resultRequests.unshift(request.string);
+        if (resultRequests.length >= limit) {
+          break;
+        }
+      }
+    }
+
+    if (resultRequests.length === 0) {
+      console.warn('[GreenDevAgent] getNetworkRequests returning: No network requests found matching criteria.');
+      return 'No network requests found matching criteria.';
+    }
+
+    const resultString = resultRequests.join('\n');
+    console.warn('[GreenDevAgent] getNetworkRequests returning:\n' + resultString);
+    return resultString;
+  }
+
+  async getConsoleMessages(params: {filter?: string, beforeIndex?: number, afterIndex?: number, limit?: number}):
+      Promise<string> {
+    console.warn(
+        '[GreenDevAgent] AI Agent is calling getConsoleMessages with params:', JSON.stringify(params, null, 2));
+    const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+    const consoleModel = target?.model(SDK.ConsoleModel.ConsoleModel);
+    if (!consoleModel) {
+      return 'Console model not found.';
+    }
+
+    const allMessages = consoleModel.messages();
+    const limit = Math.min(Math.max(1, params.limit ?? 50), 1000);
+    const filter = params.filter || 'all';
+
+    let startIndex = params.afterIndex !== undefined ? params.afterIndex + 1 : 0;
+    let endIndex = params.beforeIndex !== undefined ? params.beforeIndex : allMessages.length;
+
+    // Ensure bounds are valid.
+    startIndex = Math.max(0, startIndex);
+    endIndex = Math.min(allMessages.length, endIndex);
+
+    const resultMessages: string[] = [];
+
+    // We iterate backwards to get the most recent messages up to the limit.
+    for (let i = endIndex - 1; i >= startIndex; --i) {
+      const message = allMessages[i];
+      let matchesFilter = true;
+      if (filter === 'errors') {
+        matchesFilter = message.level === Protocol.Log.LogEntryLevel.Error;
+      } else if (filter === 'warnings') {
+        matchesFilter =
+            message.level === Protocol.Log.LogEntryLevel.Error || message.level === Protocol.Log.LogEntryLevel.Warning;
+      }
+
+      if (matchesFilter) {
+        resultMessages.unshift(GreenDevAgent.formatConsoleMessage(message, i));
+        if (resultMessages.length >= limit) {
+          break;
+        }
+      }
+    }
+
+    if (resultMessages.length === 0) {
+      console.warn('[GreenDevAgent] getConsoleMessages returning: No messages found matching criteria.');
+      return 'No messages found matching criteria.';
+    }
+
+    const resultString = resultMessages.join('\n');
+    console.warn('[GreenDevAgent] getConsoleMessages returning:\n' + resultString);
+    return resultString;
+  }
+
+  async getSourceLine(fileName: string, lineNumber: number, buffer: number): Promise<string> {
+    console.warn(`getSourceLine called with fileName: ${fileName}, lineNumber: ${lineNumber}, buffer: ${buffer}`);
+    let url: string;
+    try {
+      new URL(fileName);
+      url = fileName;
+    } catch {
+      const primaryPageTarget = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+      const resourceTreeModel = primaryPageTarget?.model(SDK.ResourceTreeModel.ResourceTreeModel);
+      const mainFrame = resourceTreeModel?.mainFrame;
+      if (mainFrame) {
+        url = new URL(fileName, mainFrame.url).href;
+      } else {
+        return `Could not resolve relative path: ${fileName}`;
+      }
+    }
+
+    let content = '';
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+      try {
+        const response = await fetch(url);
+        if (response.ok) {
+          content = await response.text();
+        } else {
+          console.error(`Failed to load resource ${url}: status ${response.status}`);
+          return `Could not read file content: status ${response.status}`;
+        }
+      } catch (e) {
+        console.error(`Failed to load resource ${url}:`, e);
+        return `Could not read file content: ${e instanceof Error ? e.message : 'Unknown error'}`;
+      }
+    } else {
+      content = await new Promise<string>(resolve => {
+        Host.ResourceLoader.load(
+            url,
+            null,
+            (success, _headers, content, errorDescription) => {
+              if (!success) {
+                console.error(`Failed to load resource ${url}:`, errorDescription);
+                resolve('');
+              } else {
+                resolve(content);
+              }
+            },
+            true /* allowRemoteFilePaths */,
+        );
+      });
+    }
+
+    if (!content) {
+      return 'Could not read file content.';
+    }
+
+    const lines = content.split('\n');
+    const start = Math.max(0, lineNumber - buffer - 1);
+    const end = Math.min(lines.length, lineNumber + buffer);
+    console.warn('AI requested source code for:', lines.slice(start, end));
+    return lines.slice(start, end).join('\n');
+  }
+}