chrome-devtools-frontend 1.0.1684555 → 1.0.1689415

package/front_end/models/ai_assistance/tools/GetCookieValues.ts

@@ -0,0 +1,146 @@
+// 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 i18n from '../../../core/i18n/i18n.js';
+import * as SDK from '../../../core/sdk/sdk.js';
+import type {FunctionHandlerOptions} from '../agents/AiAgent.js';
+
+import {
+  type CookieDetails,
+  getCookiesForOrigin,
+  resolveAllowedTargetOrigins,
+} from './CookieUtils.js';
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type OriginLockCapability,
+  type ServerLoggingCapability,
+  ToolAnnotation,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const lockedString = i18n.i18n.lockedString;
+
+// Maximum character length allowed per cookie value to prevent oversized cookies
+// from exceeding the LLM context window.
+export const MAX_NUM_CHAR_LENGTH = 10000;
+
+export interface GetCookieValuesArgs extends ToolArgs {
+  cookieNames: string[];
+  origins?: string[];
+}
+
+export interface GetCookieValuesResult {
+  cookiesByOrigin: Record<string, {cookies?: CookieDetails[], error?: string}>;
+}
+
+export class GetCookieValuesTool implements DataTool<GetCookieValuesArgs, GetCookieValuesResult,
+                                                     BaseToolCapability&OriginLockCapability&ServerLoggingCapability> {
+  readonly name: ToolName = ToolName.GET_COOKIE_VALUES;
+  readonly description: string =
+      'Retrieve the values and detailed metadata of specific cookies by their names across origins.';
+
+  readonly annotations: ToolAnnotation[] = [ToolAnnotation.REDACT_FROM_HISTORY];
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetCookieValuesArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: '',
+    nullable: false,
+    properties: {
+      cookieNames: {
+        type: Host.AidaClient.ParametersTypes.ARRAY,
+        description: 'A list of cookie names to retrieve values and metadata for.',
+        items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'A cookie name.'},
+        nullable: false,
+      },
+      origins: {
+        type: Host.AidaClient.ParametersTypes.ARRAY,
+        description: 'Optional list of origins the cookies belong to. Defaults to the current page origin if omitted.',
+        items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'An origin URL.'},
+        nullable: true,
+      },
+    },
+    required: ['cookieNames'],
+  };
+
+  displayInfoFromArgs(args: GetCookieValuesArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString('Reading cookie values and metadata'),
+      action: `getCookieValues(${JSON.stringify(args?.cookieNames ?? [])}, ${JSON.stringify(args?.origins ?? [])})`,
+    };
+  }
+
+  async handler(
+      args: GetCookieValuesArgs,
+      context: BaseToolCapability&OriginLockCapability&ServerLoggingCapability,
+      options?: FunctionHandlerOptions,
+      ): Promise<DataHandlerResult<GetCookieValuesResult>> {
+    context.disableLogging();
+
+    if (!args || !Array.isArray(args.cookieNames) || args.cookieNames.length === 0) {
+      return {error: 'No cookie names provided.'};
+    }
+
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    const targetManager = SDK.TargetManager.TargetManager.instance();
+    const targetOriginsResult = resolveAllowedTargetOrigins(args?.origins, context, targetManager);
+    if ('error' in targetOriginsResult) {
+      return {error: targetOriginsResult.error};
+    }
+    const {targetOrigins, primaryPageTarget} = targetOriginsResult;
+
+    if (options?.approved !== true) {
+      const cookieString = args.cookieNames.map(name => `\`${name}\``).join(', ');
+      const targetsDesc = targetOrigins.join(', ');
+
+      return {
+        requiresApproval: true,
+        description: lockedString(
+            `The AI wants to access the value(s) and metadata of cookie(s) ${cookieString} on ${targetsDesc}.`),
+      };
+    }
+
+    const cookiesByOrigin: GetCookieValuesResult['cookiesByOrigin'] = {};
+
+    await Promise.all(targetOrigins.map(async origin => {
+      const result = await getCookiesForOrigin(origin, targetManager, primaryPageTarget);
+      if ('error' in result) {
+        cookiesByOrigin[origin] = {error: result.error};
+        return;
+      }
+
+      const matchingCookies = result.cookies.filter(c => args.cookieNames.includes(c.name()));
+      const cookieData: CookieDetails[] = matchingCookies.map(cookie => {
+        const value = cookie.value();
+        const truncatedValue =
+            value.length > MAX_NUM_CHAR_LENGTH ? value.substring(0, MAX_NUM_CHAR_LENGTH) + '... <truncated>' : value;
+
+        return {
+          name: cookie.name(),
+          value: truncatedValue,
+          domain: cookie.domain(),
+          path: cookie.path(),
+          expires: cookie.expires(),
+          size: cookie.size(),
+          secure: cookie.secure(),
+          sameSite: cookie.sameSite(),
+          partitioned: cookie.partitioned(),
+          priority: cookie.priority(),
+          sourcePort: cookie.sourcePort(),
+          sourceScheme: cookie.sourceScheme(),
+        };
+      });
+
+      cookiesByOrigin[origin] = {cookies: cookieData};
+    }));
+
+    return {result: {cookiesByOrigin}};
+  }
+}

package/front_end/models/ai_assistance/tools/GetDetailedCallTree.ts

@@ -5,13 +5,13 @@
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
 import * as Trace from '../../trace/trace.js';
-import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 import {AICallTree} from '../performance/AICallTree.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  type PerformanceTraceCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -26,9 +26,11 @@ export interface GetDetailedCallTreeArgs extends ToolArgs {
   eventKey: string;
 }
 
-export class GetDetailedCallTreeTool implements DataTool<GetDetailedCallTreeArgs, string, BaseToolCapability> {
-  readonly name = ToolName.GET_DETAILED_CALL_TREE;
-  readonly description = 'Returns a detailed call tree for the given main thread event.';
+export class GetDetailedCallTreeTool implements
+    DataTool<GetDetailedCallTreeArgs, string, BaseToolCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.GET_DETAILED_CALL_TREE;
+  readonly description: string =
+      'Retrieves a bottom-up call tree and execution breakdown for a specific main thread event by its eventKey.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetDetailedCallTreeArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -56,10 +58,10 @@ export class GetDetailedCallTreeTool implements DataTool<GetDetailedCallTreeArgs
 
   async handler(
       params: GetDetailedCallTreeArgs,
-      capabilities: BaseToolCapability,
+      capabilities: BaseToolCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<string>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
@@ -67,7 +69,7 @@ export class GetDetailedCallTreeTool implements DataTool<GetDetailedCallTreeArgs
       return {error: 'Missing arg: eventKey'};
     }
 
-    const focus = conversationContext.getItem();
+    const focus = performanceTraceContext.getItem();
     const event = focus.lookupEvent(params.eventKey);
     if (!event) {
       return {error: 'Invalid eventKey'};
@@ -78,7 +80,7 @@ export class GetDetailedCallTreeTool implements DataTool<GetDetailedCallTreeArgs
       return {error: 'No call tree found'};
     }
 
-    const formatter = conversationContext.createFormatter();
+    const formatter = performanceTraceContext.createFormatter();
     const callTree = await formatter.formatCallTree(tree);
 
     const bounds = Trace.Helpers.Timing.traceWindowFromEvent(event);

package/front_end/models/ai_assistance/tools/GetElementAccessibilityDetails.ts

@@ -35,9 +35,9 @@ export interface GetElementAccessibilityDetailsArgs extends ToolArgs {
  */
 export class GetElementAccessibilityDetailsTool implements
     DataTool<GetElementAccessibilityDetailsArgs, string, BaseToolCapability&TargetCapability&OriginLockCapability> {
-  readonly name = ToolName.GET_ELEMENT_ACCESSIBILITY_DETAILS;
-  readonly description =
-      'Get detailed accessibility information for an element on the inspected page by its backend node ID.';
+  readonly name: ToolName = ToolName.GET_ELEMENT_ACCESSIBILITY_DETAILS;
+  readonly description: string =
+      'Retrieves detailed accessibility properties (computed role, accessible name, name source, ARIA attributes, ignored state) and a DOM tree snapshot for an element by backend node ID.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetElementAccessibilityDetailsArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -118,17 +118,29 @@ export class GetElementAccessibilityDetailsTool implements
       return {error: 'Error: AX node details not found.'};
     }
 
-    const properties = {
+    const result = {
       role: axNode.role()?.value,
       name: axNode.name()?.value,
+      nameSource: axNode.name()?.sources?.[0]?.type,
       properties: axNode.properties()?.map(p => ({name: p.name, value: p.value?.value})) ?? [],
+      ariaAttributes: resolved.attributes()
+                          .filter(attr => attr.name.startsWith('aria-') || attr.name === 'role')
+                          .reduce(
+                              (acc, attr) => {
+                                acc[attr.name] = attr.value;
+                                return acc;
+                              },
+                              {} as Record<string, string>),
+      isIgnored: axNode.ignored(),
+      ignoredReasons: axNode.ignoredReasons()?.map(p => ({name: p.name, value: p.value?.value})) ?? [],
+      backendNodeId: resolved.backendNodeId(),
     };
 
     // Take a snapshot of the resolved node's DOM structure. This is required
     // by the DOM_TREE UI widget to render the element's local tree in the AI response panel.
     const snapshot = await resolved.takeSnapshot();
     return {
-      result: JSON.stringify(properties, null, 2),
+      result: JSON.stringify(result, null, 2),
       widgets: [{
         name: 'DOM_TREE',
         data: {

package/front_end/models/ai_assistance/tools/GetFunctionCode.ts

@@ -6,12 +6,12 @@ import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
 import type * as Platform from '../../../core/platform/platform.js';
 import {canResourceContentsBeReadForTrace} from '../AiOrigins.js';
-import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  type PerformanceTraceCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -28,10 +28,11 @@ export interface GetFunctionCodeArgs extends ToolArgs {
   column: number;
 }
 
-export class GetFunctionCodeTool implements DataTool<GetFunctionCodeArgs, string, BaseToolCapability> {
-  readonly name = ToolName.GET_FUNCTION_CODE;
-  readonly description =
-      'Returns the code for a function defined at the given location. The result is annotated with the runtime performance of each line of code.';
+export class GetFunctionCodeTool implements
+    DataTool<GetFunctionCodeArgs, string, BaseToolCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.GET_FUNCTION_CODE;
+  readonly description: string =
+      'Retrieves the code for a function defined at the given location. The result is annotated with the runtime performance of each line of code.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetFunctionCodeArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -69,14 +70,14 @@ export class GetFunctionCodeTool implements DataTool<GetFunctionCodeArgs, string
 
   async handler(
       params: GetFunctionCodeArgs,
-      capabilities: BaseToolCapability,
+      capabilities: BaseToolCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<string>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
-    if (conversationContext.getOrigin().startsWith('imported-trace://')) {
+    if (performanceTraceContext.getOrigin().startsWith('imported-trace://')) {
       return {error: 'Cannot use this tool on an imported file.'};
     }
 
@@ -84,7 +85,7 @@ export class GetFunctionCodeTool implements DataTool<GetFunctionCodeArgs, string
       return {error: 'Missing arg: scriptUrl'};
     }
 
-    const allowedOrigin = conversationContext.getOrigin();
+    const allowedOrigin = performanceTraceContext.getOrigin();
     if (!canResourceContentsBeReadForTrace(params.scriptUrl, allowedOrigin)) {
       return {error: 'Script not found'};
     }
@@ -97,7 +98,7 @@ export class GetFunctionCodeTool implements DataTool<GetFunctionCodeArgs, string
       return {error: 'Missing arg: column'};
     }
 
-    const formatter = conversationContext.createFormatter();
+    const formatter = performanceTraceContext.createFormatter();
     const url = params.scriptUrl as Platform.DevToolsPath.UrlString;
     const code = await formatter.resolveFunctionCodeAtLocation(url, params.line, params.column);
     if (!code) {

package/front_end/models/ai_assistance/tools/GetInsightDetails.ts

@@ -9,7 +9,6 @@ import * as TextUtils from '../../../core/text_utils/text_utils.js';
 import * as Logs from '../../logs/logs.js';
 import * as Trace from '../../trace/trace.js';
 import type {AiWidget} from '../agents/AiAgent.js';
-import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 import {PerformanceInsightFormatter} from '../data_formatters/PerformanceInsightFormatter.js';
 import {debugLog} from '../debug.js';
 
@@ -18,6 +17,7 @@ import {
   type DataHandlerResult,
   type DataTool,
   MAX_FUNCTION_RESULT_BYTE_LENGTH,
+  type PerformanceTraceCapability,
   type TargetCapability,
   type ToolArgs,
   ToolName,
@@ -54,10 +54,10 @@ export interface GetInsightDetailsArgs extends ToolArgs {
 }
 
 export class GetInsightDetailsTool implements
-    DataTool<GetInsightDetailsArgs, string, BaseToolCapability&TargetCapability> {
-  readonly name = ToolName.GET_INSIGHT_DETAILS;
-  readonly description =
-      'Returns detailed information about a specific insight of an insight set. Use this before commenting on any specific issue to get more information.';
+    DataTool<GetInsightDetailsArgs, string, BaseToolCapability&TargetCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.GET_INSIGHT_DETAILS;
+  readonly description: string =
+      'Retrieves detailed metrics, subpart timing breakdowns, related DOM elements, and diagnostic data for a performance insight (e.g., \'LCPBreakdown\', \'LCPDiscovery\', \'RenderBlocking\', \'CLSCulprits\', \'INPBreakdown\', \'ThirdParties\'). Use this before commenting on any specific performance issue.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetInsightDetailsArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -156,10 +156,10 @@ export class GetInsightDetailsTool implements
 
   async handler(
       params: GetInsightDetailsArgs,
-      capabilities: BaseToolCapability&TargetCapability,
+      capabilities: BaseToolCapability&TargetCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<string>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
@@ -167,12 +167,12 @@ export class GetInsightDetailsTool implements
       return {error: 'Missing required arguments: insightSetId and insightName must be provided.'};
     }
 
-    const focus = conversationContext.getItem();
+    const focus = performanceTraceContext.getItem();
     const parsedTrace = focus.parsedTrace;
 
     const insightSet = parsedTrace.insights?.get(params.insightSetId);
     if (!insightSet) {
-      const formatter = conversationContext.createFormatter();
+      const formatter = performanceTraceContext.createFormatter();
       const valid = ([...parsedTrace.insights?.values() ?? []])
                         .map(insightSet => `id: ${insightSet.id}, url: ${insightSet.url}, bounds: ${
                                  formatter.serializeBounds(insightSet.bounds)}`)
@@ -205,7 +205,7 @@ export class GetInsightDetailsTool implements
     }
 
     const widgets: AiWidget[] = [];
-    const isImportedTrace = conversationContext.getOrigin().startsWith('imported-trace://');
+    const isImportedTrace = performanceTraceContext.getOrigin().startsWith('imported-trace://');
     if (!isImportedTrace) {
       const domTreeWidget = await this.#generateDOMTreeWidget(insight, insightSet, capabilities.getTarget());
       if (domTreeWidget) {

package/front_end/models/ai_assistance/tools/GetLighthouseAudits.ts

@@ -21,8 +21,9 @@ export interface GetLighthouseAuditsArgs extends ToolArgs {
 
 export class GetLighthouseAuditsTool implements
     DataTool<GetLighthouseAuditsArgs, {audits: string}, BaseToolCapability&LighthouseReportCapability> {
-  readonly name = ToolName.GET_LIGHTHOUSE_AUDITS;
-  readonly description = 'Returns the audits for a specific Lighthouse category.';
+  readonly name: ToolName = ToolName.GET_LIGHTHOUSE_AUDITS;
+  readonly description: string =
+      'Retrieves audit results and diagnostic details from the active Lighthouse report for a specific category (e.g., \'accessibility\').';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetLighthouseAuditsArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,

package/front_end/models/ai_assistance/tools/GetNetworkRequestDetails.ts

@@ -34,8 +34,8 @@ export interface GetNetworkRequestDetailsArgs extends ToolArgs {
  */
 export class GetNetworkRequestDetailsTool implements
     DataTool<GetNetworkRequestDetailsArgs, unknown, BaseToolCapability&OriginLockCapability> {
-  readonly name = ToolName.GET_NETWORK_REQUEST_DETAILS;
-  readonly description =
+  readonly name: ToolName = ToolName.GET_NETWORK_REQUEST_DETAILS;
+  readonly description: string =
       'Retrieves the full headers, timing, status, and body details of a specific network request by ID.';
 
   readonly #networkLog?: Logs.NetworkLog.NetworkLog;
@@ -51,7 +51,7 @@ export class GetNetworkRequestDetailsTool implements
     properties: {
       id: {
         type: Host.AidaClient.ParametersTypes.STRING,
-        description: 'The id of the network request to inspect.',
+        description: 'The unique requestId obtained from listNetworkRequests.',
         nullable: false,
       },
     },

package/front_end/models/ai_assistance/tools/GetResourceContent.ts

@@ -9,12 +9,12 @@ import * as Root from '../../../core/root/root.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import * as TextUtils from '../../../core/text_utils/text_utils.js';
 import {canResourceContentsBeReadForTrace} from '../AiOrigins.js';
-import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  type PerformanceTraceCapability,
   type TargetCapability,
   type ToolArgs,
   ToolName,
@@ -30,11 +30,11 @@ export interface GetResourceContentArgs extends ToolArgs {
   url: string;
 }
 
-export class GetResourceContentTool implements
-    DataTool<GetResourceContentArgs, {content: string}, BaseToolCapability&TargetCapability> {
-  readonly name = ToolName.GET_RESOURCE_CONTENT;
-  readonly description =
-      'Returns the content of the resource with the given url. Only use this for text resource types.';
+export class GetResourceContentTool implements DataTool<
+    GetResourceContentArgs, {content: string}, BaseToolCapability&TargetCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.GET_RESOURCE_CONTENT;
+  readonly description: string =
+      'Retrieves the content of the resource with the given url. Only use this for text resource types.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetResourceContentArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -62,23 +62,23 @@ export class GetResourceContentTool implements
 
   async handler(
       params: GetResourceContentArgs,
-      capabilities: BaseToolCapability&TargetCapability,
+      capabilities: BaseToolCapability&TargetCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<{content: string}>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
-    if (conversationContext.getOrigin().startsWith('imported-trace://')) {
+    if (performanceTraceContext.getOrigin().startsWith('imported-trace://')) {
       return {error: 'Cannot use this tool on an imported file.'};
     }
 
-    const allowedOrigin = conversationContext.getOrigin();
+    const allowedOrigin = performanceTraceContext.getOrigin();
     if (!canResourceContentsBeReadForTrace(params.url, allowedOrigin)) {
       return {error: 'Resource not found'};
     }
 
-    const focus = conversationContext.getItem();
+    const focus = performanceTraceContext.getItem();
     const {parsedTrace} = focus;
 
     let content: string;

package/front_end/models/ai_assistance/tools/GetSourceContent.ts

@@ -34,8 +34,9 @@ export interface GetSourceContentArgs extends ToolArgs {
  */
 export class GetSourceContentTool implements
     DataTool<GetSourceContentArgs, {content: string}, BaseToolCapability&OriginLockCapability> {
-  readonly name = ToolName.GET_SOURCE_CONTENT;
-  readonly description = 'Gets the content and metadata of a source file by its ID.';
+  readonly name: ToolName = ToolName.GET_SOURCE_CONTENT;
+  readonly description: string =
+      'Retrieves the formatted content and metadata of a source file by its numeric ID obtained from listSources.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetSourceContentArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,

package/front_end/models/ai_assistance/tools/GetStorageBreakdown.ts

@@ -0,0 +1,132 @@
+// 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 i18n from '../../../core/i18n/i18n.js';
+import * as SDK from '../../../core/sdk/sdk.js';
+import {bytes} from '../data_formatters/UnitFormatters.js';
+
+import {getCookiesForOrigin, resolveAllowedTargetOrigins} from './CookieUtils.js';
+import {calculateDOMStoragesUsage, resolveDOMStorages} from './DOMStorageUtils.js';
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type OriginLockCapability,
+  ToolName,
+} from './Tool.js';
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface StorageBreakdownEntry {
+  storageType: string;
+  usage: string;
+}
+
+export interface GetStorageBreakdownResult {
+  usageBreakdown: StorageBreakdownEntry[];
+}
+
+export class GetStorageBreakdownTool implements
+    DataTool<Record<string, never>, GetStorageBreakdownResult, BaseToolCapability&OriginLockCapability> {
+  readonly name: ToolName = ToolName.GET_STORAGE_BREAKDOWN;
+  readonly description: string =
+      'Retrieves total storage usage and quota breakdown across all storage types (IndexedDB, CacheStorage, LocalStorage, SessionStorage, cookies) for the top-level page origin.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<never> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: '',
+    nullable: false,
+    properties: {},
+    required: [],
+  };
+
+  displayInfoFromArgs(): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString('Retrieving storage breakdown'),
+      action: 'getStorageBreakdown()',
+    };
+  }
+
+  async handler(
+      _args: Record<string, never>,
+      context: BaseToolCapability&OriginLockCapability,
+      ): Promise<DataHandlerResult<GetStorageBreakdownResult>> {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    const targetManager = SDK.TargetManager.TargetManager.instance();
+
+    const targetResolution = resolveAllowedTargetOrigins(undefined, context, targetManager);
+    if ('error' in targetResolution) {
+      return {error: targetResolution.error};
+    }
+    const {targetOrigins, primaryPageTarget} = targetResolution;
+    const pageOrigin = targetOrigins[0];
+
+    const mainStorageKey =
+        primaryPageTarget.model(SDK.StorageKeyManager.StorageKeyManager)?.mainStorageKey() || undefined;
+
+    const localStorages =
+        resolveDOMStorages(pageOrigin, 'localStorage', targetManager, primaryPageTarget, mainStorageKey);
+    const sessionStorages =
+        resolveDOMStorages(pageOrigin, 'sessionStorage', targetManager, primaryPageTarget, mainStorageKey);
+
+    const [response, localStorageBytes, sessionStorageBytes, cookieResult] = await Promise.all([
+      primaryPageTarget.storageAgent().invoke_getUsageAndQuota({origin: pageOrigin}),
+      calculateDOMStoragesUsage(localStorages),
+      calculateDOMStoragesUsage(sessionStorages),
+      getCookiesForOrigin(pageOrigin, targetManager, primaryPageTarget),
+    ]);
+
+    if (response.getError()) {
+      return {error: response.getError() || 'Unknown CDP error'};
+    }
+
+    let cookieBytes = 0;
+    if ('cookies' in cookieResult) {
+      for (const cookie of cookieResult.cookies) {
+        cookieBytes += cookie.size();
+      }
+    }
+
+    const rawUsageBreakdown: Array<{storageType: string, rawUsage: number}> =
+        (response.usageBreakdown ?? []).filter(entry => entry.usage > 0).map(entry => ({
+                                                                               storageType: entry.storageType,
+                                                                               rawUsage: entry.usage,
+                                                                             }));
+
+    rawUsageBreakdown.push(
+        {storageType: 'local_storage', rawUsage: localStorageBytes},
+        {storageType: 'session_storage', rawUsage: sessionStorageBytes},
+        {storageType: 'cookies', rawUsage: cookieBytes},
+    );
+
+    rawUsageBreakdown.sort((a, b) => b.rawUsage - a.rawUsage);
+    const usageBreakdown = rawUsageBreakdown.map(entry => ({
+                                                   storageType: entry.storageType,
+                                                   usage: bytes(entry.rawUsage),
+                                                 }));
+
+    return {
+      result: {
+        usageBreakdown,
+      },
+      widgets: [
+        {
+          name: 'STORAGE_BREAKDOWN',
+          data: {
+            totalUsageBytes: response.usage,
+            totalQuotaBytes: response.quota,
+            usageBreakdown: rawUsageBreakdown.map(entry => ({
+                                                    storageType: entry.storageType,
+                                                    bytes: entry.rawUsage,
+                                                  })),
+          },
+        },
+      ],
+    };
+  }
+}