chrome-devtools-frontend 1.0.1642899 → 1.0.1643099

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

@@ -81,12 +81,6 @@ If the user asks a question that requires an investigation of a problem, use thi
     - [Suggestion 2]
 `;
 
-const SECURITY_WARNING = `**CRITICAL CONSTRAINT**: This Lighthouse report was imported from a file and is static.
-You do NOT have access to the inspected page.
-Tools like \`executeJavaScript\`, \`getStyles\`, or \`runAccessibilityAudits\` are disabled.
-Do NOT attempt to use them or instruct the user that you will use them.
-Rely ONLY on the static report data below.`;
-
 export class AccessibilityContext extends ConversationContext<LHModel.ReporterTypes.ReportJSON> {
   #lh: LHModel.ReporterTypes.ReportJSON;
 
@@ -126,17 +120,15 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
   #javascriptExecutor: JavascriptExecutor;
   #changes: ChangeManager;
   #createExtensionScope: CreateExtensionScopeFunction;
-  #currentTurnId = 0;
 
   constructor(opts: ExecuteJsAgentOptions) {
     super(opts);
     this.#lighthouseRecording = opts.lighthouseRecording;
     this.#changes = opts.changeManager || new ChangeManager();
     this.#execJs = opts.execJs ?? executeJsCode;
-    this.#createExtensionScope =
-        opts.createExtensionScope ?? ((changes: ChangeManager) => {
-          return new ExtensionScope(changes, this.sessionId, this.#getDocumentBodyNode(), this.#currentTurnId);
-        });
+    this.#createExtensionScope = opts.createExtensionScope ?? ((changes: ChangeManager) => {
+                                   return new ExtensionScope(changes, this.sessionId, this.#getDocumentBodyNode());
+                                 });
     this.#javascriptExecutor = new JavascriptExecutor(
         {
           executionMode: this.executionMode,
@@ -168,7 +160,6 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
   }
 
   protected override async preRun(): Promise<void> {
-    this.#currentTurnId++;
     const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
     const domModel = target?.model(SDK.DOMModel.DOMModel);
     // We need to ensure the document is requested so that #getDocumentBodyNode()
@@ -280,11 +271,18 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
       }
     });
 
-    if (isImported) {
-      return;
-    }
-
-    this.declareFunction('executeJavaScript', executeJavaScriptFunction(this.#javascriptExecutor));
+    const executeJsDeclaration = executeJavaScriptFunction(this.#javascriptExecutor);
+    this.declareFunction('executeJavaScript', {
+      ...executeJsDeclaration,
+      handler: async (params, options) => {
+        if (isImported) {
+          return {
+            error: 'Cannot use this tool on an imported file.',
+          };
+        }
+        return await executeJsDeclaration.handler(params, options);
+      },
+    });
 
     this.declareFunction<{explanation: string}, {audits: string}>('runAccessibilityAudits', {
       description:
@@ -311,6 +309,11 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
       },
       handler: async params => {
         debugLog('Function call: runAccessibilityAudits', params);
+        if (isImported) {
+          return {
+            error: 'Cannot use this tool on an imported file.',
+          };
+        }
         if (!this.#lighthouseRecording) {
           return {error: 'Lighthouse recording is not available.'};
         }
@@ -375,6 +378,11 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
       },
       handler: async params => {
         debugLog('Function call: getStyles', params);
+        if (isImported) {
+          return {
+            error: 'Cannot use this tool on an imported file.',
+          };
+        }
         const node = await this.#resolvePathToNode(params.path);
         if (!node) {
           return {error: `Could not find the element with path: ${params.path}`};
@@ -445,6 +453,11 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
       },
       handler: async params => {
         debugLog('Function call: getElementAccessibilityDetails', params);
+        if (isImported) {
+          return {
+            error: 'Cannot use this tool on an imported file.',
+          };
+        }
         const node = await this.#resolvePathToNode(params.path);
         if (!node) {
           return {error: `Could not find the element with path: ${params.path}`};
@@ -522,10 +535,7 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
     if (lhr) {
       this.#declareFunctions();
     }
-    let enhancedQuery = lhr ? `${this.#getInitialPayload(lhr)}\n# User request:\n\n` : '';
-    if (lhr?.getItem().isImported) {
-      enhancedQuery = `${SECURITY_WARNING}\n\n${enhancedQuery}`;
-    }
+    const enhancedQuery = lhr ? `${this.#getInitialPayload(lhr)}\n# User request:\n\n` : '';
     return `${enhancedQuery}${query}`;
   }
 

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

@@ -332,6 +332,13 @@ export interface SourceFilesListAiWidget {
   };
 }
 
+export interface NetworkRequestsListAiWidget {
+  name: 'NETWORK_REQUESTS_LIST';
+  data: {
+    requests: SDK.NetworkRequest.NetworkRequest[],
+  };
+}
+
 export interface LighthouseReportAiWidget {
   name: 'LIGHTHOUSE_REPORT';
   data: {
@@ -366,10 +373,10 @@ export interface SourceCodeAiWidget {
   };
 }
 
-export type AiWidget =
-    ComputedStyleAiWidget|CoreVitalsAiWidget|StylePropertiesAiWidget|DomTreeAiWidget|PerformanceTraceAiWidget|
-    PerfInsightAiWidget|TimelineRangeSummaryAiWidget|BottomUpTreeAiWidget|SourceFileAiWidget|LighthouseReportAiWidget|
-    TimelineEventSummaryAiWidget|NetworkRequestGeneralHeadersAiWidget|SourceCodeAiWidget|SourceFilesListAiWidget;
+export type AiWidget = ComputedStyleAiWidget|CoreVitalsAiWidget|StylePropertiesAiWidget|DomTreeAiWidget|
+    PerformanceTraceAiWidget|PerfInsightAiWidget|TimelineRangeSummaryAiWidget|BottomUpTreeAiWidget|SourceFileAiWidget|
+    LighthouseReportAiWidget|TimelineEventSummaryAiWidget|NetworkRequestGeneralHeadersAiWidget|SourceCodeAiWidget|
+    SourceFilesListAiWidget|NetworkRequestsListAiWidget;
 
 export type FunctionCallHandlerResult<Result> = {
   requiresApproval: true,
@@ -463,7 +470,7 @@ export abstract class AiAgent<T> {
 
   readonly #sessionId: string;
   readonly #aidaClient: Host.AidaClient.AidaClient;
-  readonly #serverSideLoggingEnabled: boolean;
+  #serverSideLoggingEnabled: boolean;
   readonly confirmSideEffect: typeof Promise.withResolvers;
   readonly #functionDeclarations = new Map<string, FunctionDeclaration<Record<string, unknown>, unknown>>();
   readonly #allowedOrigin?: () => AllowedOriginResult;
@@ -542,6 +549,10 @@ export abstract class AiAgent<T> {
   clearCache(): void {
   }
 
+  protected disableServerSideLogging(): void {
+    this.#serverSideLoggingEnabled = false;
+  }
+
   popPendingMultimodalInput(): MultimodalInput|undefined {
     return undefined;
   }
@@ -693,6 +704,10 @@ export abstract class AiAgent<T> {
     this.#functionDeclarations.clear();
   }
 
+  /**
+   * Executed immediately after the current context is populated with the selected
+   * context and before the request is built.
+   */
   protected async preRun(): Promise<void> {
   }
 
@@ -705,11 +720,11 @@ export abstract class AiAgent<T> {
           },
           multimodalInput?: MultimodalInput,
           ): AsyncGenerator<ResponseData, void, void> {
-    await this.preRun();
     await options.selected?.refresh();
     if (options.selected) {
       this.context = options.selected;
     }
+    await this.preRun();
 
     const enhancedQuery = await this.enhanceQuery(initialQuery, options.selected, multimodalInput?.type);
     Host.userMetrics.freestylerQueryLength(enhancedQuery.length);

package/front_end/models/ai_assistance/agents/ContextSelectionAgent.snapshot.txt

@@ -129,6 +129,17 @@ Content:
         "required": [],
         "properties": {}
       }
+    },
+    {
+      "name": "analyzeStorage",
+      "description": "Selects the page storage. Use this when asked about browser storage (localStorage, sessionStorage, cookies) and issues related to these.",
+      "parameters": {
+        "type": 6,
+        "description": "",
+        "nullable": true,
+        "required": [],
+        "properties": {}
+      }
     }
   ],
   "options": {},

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

@@ -6,6 +6,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 Root from '../../../core/root/root.js';
+import type {NetworkRequest} from '../../../core/sdk/NetworkRequest.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
 import type * as LHModel from '../../lighthouse/lighthouse.js';
 import * as Logs from '../../logs/logs.js';
@@ -15,6 +16,7 @@ import * as Workspace from '../../workspace/workspace.js';
 import {isOpaqueOrigin} from '../AiOrigins.js';
 import {DOMNodeContext} from '../contexts/DOMNodeContext.js';
 import {debugLog} from '../debug.js';
+import {StorageItem} from '../StorageItem.js';
 
 import {AccessibilityContext} from './AccessibilityAgent.js';
 import {
@@ -27,6 +29,7 @@ import {
 import {FileContext} from './FileAgent.js';
 import {RequestContext} from './NetworkAgent.js';
 import {PerformanceTraceContext} from './PerformanceAgent.js';
+import {StorageContext} from './StorageAgent.js';
 
 const lockedString = i18n.i18n.lockedString;
 /**
@@ -41,12 +44,12 @@ Your role is to understand the user's query, identify the appropriate specialize
 
 # Workflow
 1.  **Analyze**: Understand the user's intent and what they are trying to achieve.
-2.  **Classify**: Determine which specialized agent is best suited for the task (e.g., StylingAgent for CSS/styling issues, NetworkAgent for network requests, FileAgent for source files, PerformanceAgent for performance details, AccessibilityAgent for accessibility reports, or StorageAgent for storage issues).
-3.  **Gather Context**: Identify what information the specialized agent will need. Proactively use your tools to find and select this context (e.g., finding the relevant DOM node, network request, file, or performance trace). Always try to select a single specific context before answering the question.
+2.  **Classify**: Determine which specialized agent is best suited for the task (e.g., StylingAgent for CSS/styling issues, NetworkAgent for network requests, FileAgent for source files, PerformanceAgent for performance details, AccessibilityAgent for accessibility reports, or StorageAgent for analyzing and explaining storage but not editing).
+3.  **Gather Context**: Identify what information the specialized agent will need. Proactively use your tools to find and select this context (e.g., finding the relevant DOM node, network request, file, performance trace, or storage). Always try to select a single specific context before answering the question.
 4.  **Delegate**: Once context is selected, hand over to the specialized agent. If you are unable to delegate or gather more information, provide a comprehensive guide on how to fix the issue using Chrome DevTools, explaining how and why, or suggest any panel/flow that may help.
 
 # Considerations
-* Determine what is the domain of the question - styling, network, sources, performance or other part of DevTools.
+* Determine what is the domain of the question - styling, network, sources, performance, storage, or other part of DevTools.
 * For questions about performance (e.g., general performance issues, page speed, performance metrics like LCP, INP, CLS), use performanceRecordAndReload to record a performance trace.
 * Proactively try to gather additional data. If a specific piece of data can be selected, select it.
 * Always try to select a single specific context before answering the question.
@@ -141,6 +144,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
         }
 
         let hasCrossOriginRequest = false;
+        const requestsToShow: NetworkRequest[] = [];
         for (const request of Logs.NetworkLog.NetworkLog.instance().requests()) {
           const documentOrigin = Common.ParsedURL.ParsedURL.extractOrigin(request.documentURL);
           /**
@@ -163,6 +167,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
             duration: i18n.TimeUtilities.secondsToString(request.duration),
             transferSize: i18n.ByteUtilities.formatBytesToKb(request.transferSize),
           });
+          requestsToShow.push(request);
         }
 
         if (requests.length === 0) {
@@ -175,6 +180,12 @@ export class ContextSelectionAgent extends AiAgent<never> {
 
         return {
           result: requests,
+          widgets: [{
+            name: 'NETWORK_REQUESTS_LIST',
+            data: {
+              requests: requestsToShow,
+            },
+          }],
         };
       },
     });
@@ -478,6 +489,45 @@ export class ContextSelectionAgent extends AiAgent<never> {
         };
       },
     });
+
+    if (Root.Runtime.hostConfig.devToolsAiAssistanceStorageAgent?.enabled) {
+      this.declareFunction<Record<string, never>>('analyzeStorage', {
+        description:
+            'Selects the page storage. Use this when asked about browser storage (localStorage, sessionStorage, cookies) and issues related to these.',
+        parameters: {
+          type: Host.AidaClient.ParametersTypes.OBJECT,
+          description: '',
+          nullable: true,
+          required: [],
+          properties: {},
+        },
+        displayInfoFromArgs: () => {
+          return {
+            title: lockedString('Prepare storage analysis'),
+            action: 'analyzeStorage()',
+          };
+        },
+        handler: async () => {
+          const allowedOriginResult = this.#allowedOrigin();
+          if ('blocked' in allowedOriginResult) {
+            return {
+              error: 'Cross-origin access blocked due to navigation. Please start a new chat.',
+            };
+          }
+          const origin = allowedOriginResult.origin;
+          if (!origin) {
+            return {
+              error: 'Unable to find page storage.',
+            };
+          }
+
+          return {
+            context: new StorageContext(new StorageItem(origin, origin)),
+            description: 'User selected page storage',
+          };
+        },
+      });
+    }
   }
 
   async * handleContextDetails(): AsyncGenerator<ContextResponse, void, void> {

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

@@ -28,6 +28,8 @@ export interface ExecuteJsAgentOptions extends BaseAgentOptions {
   execJs?: typeof executeJsCode;
 }
 
+// TODO(crbug.com/510206549): De-duplicate this function by migrating AccessibilityAgent to use
+// the registry-based ExecuteJavaScriptTool in tools/ExecuteJavaScript.ts.
 export function executeJavaScriptFunction(executor: JavascriptExecutor): FunctionDeclaration<
     {
       title: string,

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

@@ -63,12 +63,6 @@ export type MainThreadSectionLabel = 'nav-to-lcp'|'lcp-ttfb'|'lcp-render-delay'|
  * chrome_preambles.gcl). Sync local changes with the server-side.
  */
 
-const SECURITY_WARNING = `**CRITICAL CONSTRAINT**: This performance trace was loaded from a file and is static.
-You do NOT have access to the live page.
-The tool \`getFunctionCode\` is disabled.
-Do NOT attempt to use it or instruct the user that you will use it.
-Rely only on the trace data and other available tools.`;
-
 const GREEN_DEV_ANNOTATIONS_INSTRUCTIONS = `
 - CRITICAL: You also have access to functions called addElementAnnotation and addNeworkRequestAnnotation,
 which should be used to highlight elements and network requests (respectively).
@@ -710,18 +704,14 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
       }
     }
 
-    const isFresh = Tracing.FreshRecording.Tracker.instance().recordingIsFresh(focus.parsedTrace);
-
     if (!selected.length) {
       this.#additionalSelectionsForDisclosure = [];
-      const finalQuery = query;
-      return isFresh ? finalQuery : `${SECURITY_WARNING}\n\n${finalQuery}`;
+      return query;
     }
 
     selected.push(`# User query\n\n${query}`);
     this.#additionalSelectionsForDisclosure = [...selected];
-    const finalQuery = selected.join('');
-    return isFresh ? finalQuery : `${SECURITY_WARNING}\n\n${finalQuery}`;
+    return selected.join('');
   }
 
   override async * run(initialQuery: string, options: {
@@ -1340,84 +1330,87 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
       });
     }
 
-    if (isFresh) {
-      this.declareFunction<{scriptUrl: UrlString, line: number, column: number}, {result: string}>('getFunctionCode', {
-        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.',
-        parameters: {
-          type: Host.AidaClient.ParametersTypes.OBJECT,
-          description: '',
-          nullable: false,
-          properties: {
-            scriptUrl: {
-              type: Host.AidaClient.ParametersTypes.STRING,
-              description: 'The url of the function.',
-              nullable: false,
-            },
-            line: {
-              type: Host.AidaClient.ParametersTypes.INTEGER,
-              description: 'The line number where the function is defined.',
-              nullable: false,
-            },
-            column: {
-              type: Host.AidaClient.ParametersTypes.INTEGER,
-              description: 'The column number where the function is defined.',
-              nullable: false,
-            },
+    this.declareFunction<{scriptUrl: UrlString, line: number, column: number}, {result: string}>('getFunctionCode', {
+      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.',
+      parameters: {
+        type: Host.AidaClient.ParametersTypes.OBJECT,
+        description: '',
+        nullable: false,
+        properties: {
+          scriptUrl: {
+            type: Host.AidaClient.ParametersTypes.STRING,
+            description: 'The url of the function.',
+            nullable: false,
+          },
+          line: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'The line number where the function is defined.',
+            nullable: false,
+          },
+          column: {
+            type: Host.AidaClient.ParametersTypes.INTEGER,
+            description: 'The column number where the function is defined.',
+            nullable: false,
           },
-          required: ['scriptUrl', 'line', 'column']
         },
-        displayInfoFromArgs: args => {
+        required: ['scriptUrl', 'line', 'column']
+      },
+      displayInfoFromArgs: args => {
+        return {
+          title: lockedString('Looking up function code'),
+          action: `getFunctionCode('${args.scriptUrl}', ${args.line}, ${args.column})`
+        };
+      },
+      handler: async args => {
+        debugLog('Function call: getFunctionCode');
+        if (!isFresh) {
           return {
-            title: lockedString('Looking up function code'),
-            action: `getFunctionCode('${args.scriptUrl}', ${args.line}, ${args.column})`
+            error: 'Cannot use this tool on an imported file.',
           };
-        },
-        handler: async args => {
-          debugLog('Function call: getFunctionCode');
+        }
 
-          if (args.line === undefined) {
-            return {error: 'Missing arg: line'};
-          }
+        if (args.line === undefined) {
+          return {error: 'Missing arg: line'};
+        }
 
-          if (args.column === undefined) {
-            return {error: 'Missing arg: column'};
-          }
+        if (args.column === undefined) {
+          return {error: 'Missing arg: column'};
+        }
 
-          if (!this.#formatter) {
-            throw new Error('missing formatter');
-          }
+        if (!this.#formatter) {
+          throw new Error('missing formatter');
+        }
 
-          const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
-          if (!target) {
-            throw new Error('missing target');
-          }
+        const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+        if (!target) {
+          throw new Error('missing target');
+        }
 
-          const url = args.scriptUrl as Platform.DevToolsPath.UrlString;
-          const code = await this.#formatter.resolveFunctionCodeAtLocation(url, args.line, args.column);
-          if (!code) {
-            return {error: 'Could not find code'};
-          }
+        const url = args.scriptUrl as Platform.DevToolsPath.UrlString;
+        const code = await this.#formatter.resolveFunctionCodeAtLocation(url, args.line, args.column);
+        if (!code) {
+          return {error: 'Could not find code'};
+        }
 
-          const result = this.#formatter.formatFunctionCode(code);
+        const result = this.#formatter.formatFunctionCode(code);
 
-          const key = `getFunctionCode('${args.scriptUrl}', ${args.line}, ${args.column})`;
-          this.#cacheFunctionResult(focus, key, result);
-          return {
-            result: {result},
-            widgets: [{
-              name: 'SOURCE_CODE',
-              data: {
-                url: args.scriptUrl,
-                line: args.line,
-                column: args.column,
-                code: code.code,
-              },
-            }],
-          };
-        },
-      });
-    }
+        const key = `getFunctionCode('${args.scriptUrl}', ${args.line}, ${args.column})`;
+        this.#cacheFunctionResult(focus, key, result);
+        return {
+          result: {result},
+          widgets: [{
+            name: 'SOURCE_CODE',
+            data: {
+              url: args.scriptUrl,
+              line: args.line,
+              column: args.column,
+              code: code.code,
+            },
+          }],
+        };
+      },
+    });
 
     const isTraceApp = Root.Runtime.Runtime.isTraceApp();
 

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

@@ -173,18 +173,17 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
     });
 
-    this.declareFunction<
-        {
-          type: 'localStorage' | 'sessionStorage',
-          origin: string,
-          storageKey?: string,
-        },
-        {
-          partitions: Array<{
-            storageKey: string,
-            keys: string[],
-          }>,
-        }>('listStorageKeys', {
+    this.declareFunction<{
+      type: 'localStorage' | 'sessionStorage',
+      origin: string,
+      storageKey?: string,
+    },
+                         {
+                           partitions: Array<{
+                             storageKey: string,
+                             keys: string[],
+                           }>,
+                         }>('listStorageKeys', {
       description:
           'Lists all keys for a given storage type for the requested origin. Returns keys grouped by storage partition.',
       parameters: {
@@ -218,6 +217,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
 
       handler: async args => {
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -244,19 +244,18 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
     });
 
-    this.declareFunction<
-        {
-          type: 'localStorage' | 'sessionStorage',
-          keys: string[],
-          origin: string,
-          storageKey?: string,
-        },
-        {
-          items: Array<{
-            storageKey: string,
-            values: Record<string, string>,
-          }>,
-        }>('getStorageValues', {
+    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.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -296,6 +295,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
 
       handler: async (args, options) => {
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -353,11 +353,10 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
     });
 
-    this.declareFunction<
-        {
-          origin: string,
-        },
-        {cookies: string[]}>('listCookies', {
+    this.declareFunction<{
+      origin: string,
+    },
+                         {cookies: string[]}>('listCookies', {
       description: 'Lists all cookies for the requested origin, strictly excluding their values.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -379,6 +378,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
         };
       },
       handler: async args => {
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -396,14 +396,13 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
     });
 
-    this.declareFunction<
-        {
-          cookieNames: string[],
-          origin: string,
-        },
-        {
-          cookies: CookieDetails[],
-        }>('getCookieValues', {
+    this.declareFunction<{
+      cookieNames: string[],
+      origin: string,
+    },
+                         {
+                           cookies: CookieDetails[],
+                         }>('getCookieValues', {
       description: 'Retrieve the values and detailed metadata of specific cookies by their names.',
       parameters: {
         type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -431,6 +430,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
         };
       },
       handler: async (args, options) => {
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -498,6 +498,15 @@ export class StorageAgent extends AiAgent<StorageItem> {
     return primaryTargetOrigin;
   }
 
+  protected override async preRun(): Promise<void> {
+    const item = this.context?.getItem();
+    if (item instanceof CookieItem && Boolean(item.name)) {
+      this.disableServerSideLogging();
+    } else if (item instanceof DOMStorageItem && Boolean(item.key)) {
+      this.disableServerSideLogging();
+    }
+  }
+
   async *
       handleContextDetails(context: ConversationContext<StorageItem>|null):
           AsyncGenerator<ContextResponse, void, void> {