chrome-devtools-frontend 1.0.1669021 → 1.0.1672388

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

@@ -35,9 +35,10 @@ const preamble =
 
  # Tools & Workflow
 
- -   **Prioritize Top-Level Context**: Always initiate your investigation from the top-level page's storage. Explicitly state if you are analyzing storage from a different context (e.g., an iframe).
+ -   **Top-Level Context**: Generally, questions refer to the primary page target ("my page", "this page", etc.). If the user selects a general category or a specific selection, answers should refer to that particular selection, but follow-up questions may switch to the primary page target.
  -   **Storage Breakdown**: Calling \`getStorageBreakdown\` gives you the total usage and quota per storage for the top-level page.
  -   **Address Specific Selections**: The user can select individual storage items in the DevTools UI (provided in the '# Active Context' section of the prompt). If the query is about a selected item (e.g., "Why is this cookie set?"), focus your response on that specific item.
+ -   **General Category Selection**: If a general storage category (such as Cookies, Local Storage, or Session Storage) is selected in the active context (indicated by an empty context origin), your first step MUST be to look through all cookies or local/session storage entries across all active page origins (by calling \`listPageOrigins\` to discover origins, then passing all discovered origins to \`listCookies\` or \`listStorageKeys\`), unless the user's explicit request hints otherwise.
  -   **Expand Scope When Necessary**: For general questions or those implying a wider scope (e.g., "Check all storages," "Are there related cookies on subdomains?"), proactively use your tools to explore other relevant storage contexts, including iframes and different origins.
  -   **Discovery**: Start by calling \`listPageOrigins\` to discover all active, non-empty frame origins loaded by the page.
  -   **Storage Partitioning (LocalStorage / SessionStorage)**:
@@ -67,7 +68,7 @@ function isSamePrimaryPageOrigin(targetManager: SDK.TargetManager.TargetManager,
   return isSamePageOrigin(primaryPageTarget, context);
 }
 
-function isSamePageOrigin(target: SDK.Target.Target|null, context?: ConversationContext<StorageItem>): boolean {
+export function isSamePageOrigin(target: SDK.Target.Target|null, context?: ConversationContext<StorageItem>): boolean {
   if (!target || !context) {
     return false;
   }
@@ -75,6 +76,15 @@ function isSamePageOrigin(target: SDK.Target.Target|null, context?: Conversation
   return pageOrigin !== '' && context.isOriginAllowed(pageOrigin);
 }
 
+const MAX_TARGET_ORIGINS = 100;
+
+function resolveTargetOrigins(context?: ConversationContext<StorageItem>, origins?: string[]): string[] {
+  const primaryOrigin = context?.getOrigin();
+  const rawList = (origins && origins.length > 0) ? origins : (primaryOrigin ? [primaryOrigin] : []);
+  const uniqueOrigins = Array.from(new Set(rawList));
+  return uniqueOrigins.slice(0, MAX_TARGET_ORIGINS);
+}
+
 export class StorageContext extends ConversationContext<StorageItem> {
   #item: StorageItem;
 
@@ -93,10 +103,17 @@ export class StorageContext extends ConversationContext<StorageItem> {
 
   override getTitle(): string {
     if (this.#item instanceof CookieItem) {
-      return `${this.#item.name ? `cookie: ${this.#item.name}` : 'cookies:'} ${this.#item.origin}`;
+      if (this.#item.name) {
+        return `cookie: ${this.#item.name}${this.#item.origin ? ` ${this.#item.origin}` : ''}`;
+      }
+      return `cookies${this.#item.isGenericContext ? '' : `: ${this.#item.origin}`}`;
     }
     if (this.#item instanceof DOMStorageItem) {
-      return `${this.#item.key ? `entry: ${this.#item.key}` : 'storage:'} ${this.#item.origin}`;
+      if (this.#item.key) {
+        return `entry: ${this.#item.key}${this.#item.origin ? ` ${this.#item.origin}` : ''}`;
+      }
+      const prefix = this.#item.type === 'localStorage' ? 'local storage' : 'session storage';
+      return `${prefix}${this.#item.isGenericContext ? '' : `: ${this.#item.origin}`}`;
     }
     return `Storage: ${this.getOrigin()}`;
   }
@@ -186,7 +203,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
 
     this.declareFunction<Record<string, never>, {origins: string[]}>('listPageOrigins', {
       description:
-          'Lists all active, non-empty frame origins loaded by the page. Use this first to discover what other targets/iframes exist on the page for querying their storage.',
+          'Lists all active, non-empty frame origins loaded by the page. Use this first when generic category context is active to discover all page origins, then pass them to listCookies or listStorageKeys, unless the user\'s explicit request hints at focusing only on the primary page.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
         description: '',
@@ -223,17 +240,15 @@ export class StorageAgent extends AiAgent<StorageItem> {
 
     this.declareFunction<{
       type: 'localStorage' | 'sessionStorage',
-      origin: string,
+      origins: string[],
       storageKey?: string,
     },
                          {
-                           partitions: Array<{
-                             storageKey: string,
-                             keys: string[],
-                           }>,
+                           storageKeysByOrigin: Record<
+                               string, {partitions?: Array<{storageKey: string, keys: string[]}>, error?: string}>,
                          }>('listStorageKeys', {
       description:
-          'Lists all keys for a given storage type for the requested origin. Returns keys grouped by storage partition.',
+          'Lists all keys for a given storage type for requested origins. Returns keys grouped by storage partition under their origin.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
         description: '',
@@ -244,23 +259,24 @@ export class StorageAgent extends AiAgent<StorageItem> {
             description: 'Storage type: localStorage or sessionStorage',
             nullable: false,
           },
-          origin: {
-            type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'Specific origin to list keys for.',
+          origins: {
+            type: Host.AidaClient.ParametersTypes.ARRAY,
+            description: 'List of origins to list keys for.',
+            items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'An origin URL.'},
             nullable: false,
           },
           storageKey: {
             type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'Optional. Specific storageKey to to list keys for.',
+            description: 'Optional. Specific storageKey to list keys for. Only applies if single origin is provided.',
             nullable: true,
           },
         },
-        required: ['type', 'origin'],
+        required: ['type', 'origins'],
       },
       displayInfoFromArgs: args => {
         return {
           title: lockedString('Reading storage keys'),
-          action: `listStorageKeys('${args.type}', '${args.origin}')`,
+          action: `listStorageKeys('${args.type}', ${JSON.stringify(args.origins)})`,
         };
       },
 
@@ -270,41 +286,47 @@ export class StorageAgent extends AiAgent<StorageItem> {
           return {error: 'No origin available or not allowed.'};
         }
 
-        const storages = resolveDOMStorages(this.context, args.type, args.origin, this.targetManager, args.storageKey);
-
-        const keyAndItems = await Promise.all(storages.map(async storage => {
-          const items = await storage.getItems();
-          return {storageKey: storage.storageKey, items};
-        }));
-
-        const partitionsResult = [];
-        for (const {storageKey, items} of keyAndItems) {
-          if (!items) {
-            continue;
-          }
-          const keys = items.map(([key]) => key);
-          if (keys.length > 0) {
-            partitionsResult.push({storageKey, keys});
+        const targetOrigins = resolveTargetOrigins(this.context, args.origins);
+        const storageKey = (targetOrigins.length === 1 && args.storageKey) ? args.storageKey : undefined;
+        const storageKeysByOrigin:
+            Record<string, {partitions?: Array<{storageKey: string, keys: string[]}>, error?: string}> = {};
+
+        await Promise.all(targetOrigins.map(async origin => {
+          const storages = resolveDOMStorages(this.context, args.type, origin, this.targetManager, storageKey);
+          const keyAndItems = await Promise.all(storages.map(async storage => {
+            const items = await storage.getItems();
+            return {storageKey: storage.storageKey, items};
+          }));
+
+          const partitions = [];
+          for (const {storageKey, items} of keyAndItems) {
+            if (!items) {
+              continue;
+            }
+            const keys = items.map(([key]) => key);
+            if (keys.length > 0) {
+              partitions.push({storageKey, keys});
+            }
           }
-        }
+          storageKeysByOrigin[origin] = {partitions};
+        }));
 
-        return {result: {partitions: partitionsResult}};
+        return {result: {storageKeysByOrigin}};
       },
     });
 
-    this.declareFunction<{
-      type: 'localStorage' | 'sessionStorage',
-      keys: string[],
-      origin: string,
-      storageKey?: string,
-    },
-                         {
-                           items: Array<{
-                             storageKey: string,
-                             values: Record<string, string>,
-                           }>,
-                         }>('getStorageValues', {
-      description: 'Retrieve specific string values from storage partitions for requested keys.',
+    this.declareFunction<
+        {
+          type: 'localStorage' | 'sessionStorage',
+          keys: string[],
+          origins: string[],
+          storageKey?: string,
+        },
+        {
+          storageValuesByOrigin:
+              Record<string, {items?: Array<{storageKey: string, values: Record<string, string>}>, error?: string}>,
+        }>('getStorageValues', {
+      description: 'Retrieve specific string values from storage partitions for requested keys across origins.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
         description: '',
@@ -321,23 +343,25 @@ export class StorageAgent extends AiAgent<StorageItem> {
             items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'A storage key.'},
             nullable: false,
           },
-          origin: {
-            type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'Specific origin to get values for.',
+          origins: {
+            type: Host.AidaClient.ParametersTypes.ARRAY,
+            description: 'List of origins to get values for.',
+            items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'An origin URL.'},
             nullable: false,
           },
           storageKey: {
             type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'Optional. Specific storageKey partition to get values for.',
+            description:
+                'Optional. Specific storageKey partition to get values for. Only applies if single origin is provided.',
             nullable: true,
           },
         },
-        required: ['type', 'keys', 'origin'],
+        required: ['type', 'keys', 'origins'],
       },
       displayInfoFromArgs: args => {
         return {
           title: lockedString('Reading storage values'),
-          action: `getStorageValues('${args.type}', ${JSON.stringify(args.keys)}, '${args.origin}'${
+          action: `getStorageValues('${args.type}', ${JSON.stringify(args.keys)}, ${JSON.stringify(args.origins)}${
               args.storageKey ? `, '${args.storageKey}'` : ''})`,
         };
       },
@@ -348,19 +372,26 @@ export class StorageAgent extends AiAgent<StorageItem> {
           return {error: 'No origin available or not allowed.'};
         }
 
-        const storages = resolveDOMStorages(this.context, args.type, args.origin, this.targetManager, args.storageKey);
-        if (storages.length === 0) {
+        const targetOrigins = resolveTargetOrigins(this.context, args.origins);
+        const storageKey = (targetOrigins.length === 1 && args.storageKey) ? args.storageKey : undefined;
+
+        const allStoragesMap: Record<string, SDK.DOMStorageModel.DOMStorage[]> = {};
+        let totalStoragesCount = 0;
+        for (const origin of targetOrigins) {
+          const storages = resolveDOMStorages(this.context, args.type, origin, this.targetManager, storageKey);
+          if (storages.length > 0) {
+            allStoragesMap[origin] = storages;
+            totalStoragesCount += storages.length;
+          }
+        }
+
+        if (totalStoragesCount === 0) {
           return {error: 'No matching storage partitions found.'};
         }
 
         if (options?.approved !== true) {
           const keyString = args.keys.map(k => `\`${k}\``).join(', ');
-
-          const uniqueTargetOrigins = Array.from(new Set(storages.map(storage => {
-            const parsed = SDK.StorageKeyManager.parseStorageKey(storage.storageKey || '');
-            return parsed.origin;
-          })));
-          const targetsDesc = uniqueTargetOrigins.join(', ');
+          const targetsDesc = Object.keys(allStoragesMap).join(', ');
 
           return {
             requiresApproval: true,
@@ -369,60 +400,70 @@ export class StorageAgent extends AiAgent<StorageItem> {
           };
         }
 
-        const itemsResult = [];
+        const storageValuesByOrigin:
+            Record<string, {items?: Array<{storageKey: string, values: Record<string, string>}>, error?: string}> = {};
 
-        const keyAndItems = await Promise.all(storages.map(async storage => {
-          const items = await storage.getItems();
-          return {storageKey: storage.storageKey, items};
-        }));
+        await Promise.all(targetOrigins.map(async origin => {
+          const storages = allStoragesMap[origin] || [];
+          const itemsResult = [];
 
-        for (const {storageKey, items} of keyAndItems) {
-          if (!items) {
-            continue;
-          }
-          const itemMap = new Map<string, string>(items as Array<[string, string]>);
-          const storageValues: Record<string, string> = {};
+          const keyAndItems = await Promise.all(storages.map(async storage => {
+            const items = await storage.getItems();
+            return {storageKey: storage.storageKey, items};
+          }));
 
-          for (const key of args.keys) {
-            const value = itemMap.get(key);
-            if (value === undefined) {
+          for (const {storageKey: partitionKey, items} of keyAndItems) {
+            if (!items) {
               continue;
             }
-            const truncatedValue = value.length > MAX_NUM_CHAR_LENGTH ?
-                value.substring(0, MAX_NUM_CHAR_LENGTH) + '... <truncated>' :
-                value;
-            storageValues[key] = truncatedValue;
-          }
+            const itemMap = new Map<string, string>(items as Array<[string, string]>);
+            const storageValues: Record<string, string> = {};
+
+            for (const key of args.keys) {
+              const value = itemMap.get(key);
+              if (value === undefined) {
+                continue;
+              }
+              const truncatedValue = value.length > MAX_NUM_CHAR_LENGTH ?
+                  value.substring(0, MAX_NUM_CHAR_LENGTH) + '... <truncated>' :
+                  value;
+              storageValues[key] = truncatedValue;
+            }
 
-          itemsResult.push({storageKey, values: storageValues});
-        }
+            itemsResult.push({storageKey: partitionKey, values: storageValues});
+          }
+          storageValuesByOrigin[origin] = {items: itemsResult};
+        }));
 
-        return {result: {items: itemsResult}};
+        return {result: {storageValuesByOrigin}};
       },
     });
 
     this.declareFunction<{
-      origin: string,
+      origins: string[],
     },
-                         {cookies: string[]}>('listCookies', {
-      description: 'Lists all cookies for the requested origin, strictly excluding their values.',
+                         {
+                           cookieNamesByOrigin: Record<string, {cookies?: string[], error?: string}>,
+                         }>('listCookies', {
+      description: 'Lists all cookies for requested origins, strictly excluding their values.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
         description: '',
         nullable: false,
         properties: {
-          origin: {
-            type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'Origin to list cookies for.',
+          origins: {
+            type: Host.AidaClient.ParametersTypes.ARRAY,
+            description: 'List of origins to list cookies for.',
+            items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'An origin URL.'},
             nullable: false,
           },
         },
-        required: ['origin'],
+        required: ['origins'],
       },
       displayInfoFromArgs: args => {
         return {
           title: lockedString('Reading cookies'),
-          action: `listCookies('${args.origin}')`,
+          action: `listCookies(${JSON.stringify(args.origins)})`,
         };
       },
       handler: async args => {
@@ -431,27 +472,34 @@ export class StorageAgent extends AiAgent<StorageItem> {
           return {error: 'No origin available or not allowed.'};
         }
 
-        const frame = findFrameForOrigin(this.context, args.origin, this.targetManager);
-        if (!frame) {
-          return {result: {cookies: []}};
-        }
+        const targetOrigins = resolveTargetOrigins(this.context, args.origins);
+        const cookieNamesByOrigin: Record<string, {cookies?: string[], error?: string}> = {};
+
+        await Promise.all(targetOrigins.map(async origin => {
+          const frame = findFrameForOrigin(this.context, origin, this.targetManager);
+          if (!frame) {
+            cookieNamesByOrigin[origin] = {error: 'Frame not found or origin disallowed'};
+            return;
+          }
 
-        const target = frame.resourceTreeModel().target();
-        const cookies = await getCookiesForDomain(target, args.origin);
-        const uniqueNames = Array.from(new Set(cookies?.map(c => c.name())));
+          const target = frame.resourceTreeModel().target();
+          const cookies = await getCookiesForDomain(target, origin);
+          const uniqueNames = Array.from(new Set(cookies?.map(c => c.name())));
+          cookieNamesByOrigin[origin] = {cookies: uniqueNames};
+        }));
 
-        return {result: {cookies: uniqueNames}};
+        return {result: {cookieNamesByOrigin}};
       },
     });
 
     this.declareFunction<{
       cookieNames: string[],
-      origin: string,
+      origins: string[],
     },
                          {
-                           cookies: CookieDetails[],
+                           cookiesByOrigin: Record<string, {cookies?: CookieDetails[], error?: string}>,
                          }>('getCookieValues', {
-      description: 'Retrieve the values and detailed metadata of specific cookies by their names.',
+      description: 'Retrieve the values and detailed metadata of specific cookies by their names across origins.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
         description: '',
@@ -463,18 +511,19 @@ export class StorageAgent extends AiAgent<StorageItem> {
             items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'A cookie name.'},
             nullable: false,
           },
-          origin: {
-            type: Host.AidaClient.ParametersTypes.STRING,
-            description: 'The specific origin the cookies belong to.',
+          origins: {
+            type: Host.AidaClient.ParametersTypes.ARRAY,
+            description: 'List of origins the cookies belong to.',
+            items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'An origin URL.'},
             nullable: false,
           },
         },
-        required: ['cookieNames', 'origin'],
+        required: ['cookieNames', 'origins'],
       },
       displayInfoFromArgs: args => {
         return {
           title: lockedString('Reading cookie values and metadata'),
-          action: `getCookieValues(${JSON.stringify(args.cookieNames)}, '${args.origin}')`,
+          action: `getCookieValues(${JSON.stringify(args.cookieNames)}, ${JSON.stringify(args.origins)})`,
         };
       },
       handler: async (args, options) => {
@@ -483,61 +532,67 @@ export class StorageAgent extends AiAgent<StorageItem> {
           return {error: 'No origin available or not allowed.'};
         }
 
-        const frame = findFrameForOrigin(this.context, args.origin, this.targetManager);
-        if (!frame) {
-          return {result: {cookies: []}};
-        }
-
-        const target = frame.resourceTreeModel().target();
+        const targetOrigins = resolveTargetOrigins(this.context, args.origins);
 
         if (options?.approved !== true) {
           return {
             requiresApproval: true,
             description: lockedString(`The AI wants to access the value(s) and metadata of cookie(s) ${
-                args.cookieNames.map(name => `\`${name}\``).join(', ')} on ${args.origin}.`),
+                args.cookieNames.map(name => `\`${name}\``).join(', ')} on ${targetOrigins.join(', ')}.`),
           };
         }
 
-        const cookies = await getCookiesForDomain(target, args.origin);
-        if (!cookies) {
-          return {result: {cookies: []}};
-        }
+        const cookiesByOrigin: Record<string, {cookies?: CookieDetails[], error?: string}> = {};
 
-        const matchingCookies = cookies.filter(c => args.cookieNames.includes(c.name()));
-        const cookieData = matchingCookies.map(cookie => {
-          const value = cookie.value();
-          const truncatedValue =
-              value.length > MAX_NUM_CHAR_LENGTH ? value.substring(0, MAX_NUM_CHAR_LENGTH) + '... <truncated>' : value;
+        await Promise.all(targetOrigins.map(async origin => {
+          const frame = findFrameForOrigin(this.context, origin, this.targetManager);
+          if (!frame) {
+            cookiesByOrigin[origin] = {error: 'Frame not found or origin disallowed'};
+            return;
+          }
 
-          return {
-            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(),
-          };
-        });
+          const target = frame.resourceTreeModel().target();
+          const cookies = await getCookiesForDomain(target, origin);
+          if (!cookies) {
+            cookiesByOrigin[origin] = {cookies: []};
+            return;
+          }
 
-        return {result: {cookies: cookieData}};
+          const matchingCookies = cookies.filter(c => args.cookieNames.includes(c.name()));
+          const cookieData = 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 {
+              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}};
       },
     });
 
     this.declareFunction<Record<string, never>, {
-      totalUsage: string,
-      totalQuota: string,
       usageBreakdown: Array<{
         storageType: string,
         usage: string,
       }>,
     }>('getStorageBreakdown', {
-      description:
-          'Retrieves the total storage usage, total storage quota, and a breakdown of active storage usage per storage type for the top-level page.',
+      description: 'Retrieves a breakdown of active storage usage per storage type for the top-level page.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
         description: '',
@@ -557,23 +612,49 @@ export class StorageAgent extends AiAgent<StorageItem> {
           return {error: 'No origin available or not allowed.'};
         }
 
-        const origin = this.context.getOrigin();
+        const origin = this.context.getItem().primaryTargetOrigin;
         const response = await target.storageAgent().invoke_getUsageAndQuota({origin});
         if (response.getError()) {
           return {error: response.getError() || 'Unknown CDP error'};
         }
 
-        const usageBreakdown = response.usageBreakdown.filter(entry => entry.usage > 0)
-                                   .sort((a, b) => b.usage - a.usage)
-                                   .map(entry => ({
-                                          storageType: entry.storageType as string,
-                                          usage: bytes(entry.usage),
-                                        }));
+        const mainStorageKey = target.model(SDK.StorageKeyManager.StorageKeyManager)?.mainStorageKey() || undefined;
+        const localStorages =
+            resolveDOMStorages(this.context, 'localStorage', origin, this.targetManager, mainStorageKey);
+        const localStorageBytes = await calculateDOMStoragesUsage(localStorages);
+
+        const sessionStorages =
+            resolveDOMStorages(this.context, 'sessionStorage', origin, this.targetManager, mainStorageKey);
+        const sessionStorageBytes = await calculateDOMStoragesUsage(sessionStorages);
+
+        const cookies = await getCookiesForDomain(target, origin);
+        let cookieBytes = 0;
+        if (cookies) {
+          for (const cookie of cookies) {
+            cookieBytes += cookie.size();
+          }
+        }
+
+        const rawUsageBreakdown: Array<{storageType: string, rawUsage: number}> =
+            response.usageBreakdown.filter(entry => entry.usage > 0).map(entry => ({
+                                                                           storageType: entry.storageType as string,
+                                                                           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: {
-            totalUsage: bytes(response.usage),
-            totalQuota: bytes(response.quota),
             usageBreakdown,
           },
         };
@@ -586,13 +667,15 @@ export class StorageAgent extends AiAgent<StorageItem> {
     if (item instanceof CookieItem) {
       const parsedURL = Common.ParsedURL.ParsedURL.fromString(item.origin);
       const domain = parsedURL ? parsedURL.host : item.origin;
-      return `${primaryTargetOrigin}\nUser-selected Context: Cookies\nDomain: ${domain}${
-          item.name ? `\nCookie Name: ${item.name}` : ''}`;
+      return `${primaryTargetOrigin}\nUser-selected Context: Cookies${
+          item.isGenericContext ? '' : `\nDomain: ${domain}`}${item.name ? `\nCookie Name: ${item.name}` : ''}`;
     }
 
     if (item instanceof DOMStorageItem) {
-      return `${primaryTargetOrigin}\nUser-selected Context: DOM Storage\n Type: ${item.type}\nStorageKey: ${
-          item.storageKey}\nOrigin: ${item.origin}${item.key ? `\nKey: ${item.key}` : ''}`;
+      return `${primaryTargetOrigin}\nUser-selected Context: DOM Storage\n Type: ${item.type}${
+          item.isGenericContext ?
+              '' :
+              `\nStorageKey: ${item.storageKey}\nOrigin: ${item.origin}`}${item.key ? `\nKey: ${item.key}` : ''}`;
     }
 
     return primaryTargetOrigin;
@@ -670,6 +753,21 @@ export function findFrameForOrigin(
   }
   return null;
 }
+
+async function calculateDOMStoragesUsage(storages: SDK.DOMStorageModel.DOMStorage[]): Promise<number> {
+  let totalBytes = 0;
+  for (const storage of storages) {
+    const items = await storage.getItems();
+    if (items) {
+      for (const [key, value] of items) {
+        // UTF-16 encoded strings use 2 bytes per character.
+        totalBytes += (key.length + value.length) * 2;
+      }
+    }
+  }
+  return totalBytes;
+}
+
 export function resolveDOMStorages(
     context: ConversationContext<StorageItem>|undefined, type: 'localStorage'|'sessionStorage', origin: string,
     targetManager: SDK.TargetManager.TargetManager, storageKey?: string): SDK.DOMStorageModel.DOMStorage[] {