chrome-devtools-frontend 1.0.1675430 → 1.0.1676824

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.ts

@@ -501,21 +501,11 @@ export class HeapSnapshotNode implements HeapSnapshotItem {
   }
 
   #detachednessAndClassIndex(): number {
-    const {snapshot, nodeIndex} = this;
-    const nodeDetachednessAndClassIndexOffset = snapshot.nodeDetachednessAndClassIndexOffset;
-    return nodeDetachednessAndClassIndexOffset !== -1 ?
-        snapshot.nodes.getValue(nodeIndex + nodeDetachednessAndClassIndexOffset) :
-        (snapshot.detachednessAndClassIndexArray as Uint32Array)[nodeIndex / snapshot.nodeFieldCount];
+    return this.snapshot.detachednessAndClassIndexArray[this.nodeIndex / this.snapshot.nodeFieldCount];
   }
 
   #setDetachednessAndClassIndex(value: number): void {
-    const {snapshot, nodeIndex} = this;
-    const nodeDetachednessAndClassIndexOffset = snapshot.nodeDetachednessAndClassIndexOffset;
-    if (nodeDetachednessAndClassIndexOffset !== -1) {
-      snapshot.nodes.setValue(nodeIndex + nodeDetachednessAndClassIndexOffset, value);
-    } else {
-      (snapshot.detachednessAndClassIndexArray as Uint32Array)[nodeIndex / snapshot.nodeFieldCount] = value;
-    }
+    this.snapshot.detachednessAndClassIndexArray[this.nodeIndex / this.snapshot.nodeFieldCount] = value;
   }
 
   detachedness(): HeapSnapshotModel.HeapSnapshotModel.DOMLinkState {
@@ -1010,7 +1000,7 @@ export abstract class HeapSnapshot {
   #ignoredEdgesInRetainersView = new Set<number>();
   #nodeDistancesForRetainersView: Int32Array|undefined;
   #edgeNamesThatAreNotWeakMaps: Platform.TypedArrayUtilities.BitVector;
-  detachednessAndClassIndexArray?: Uint32Array;
+  detachednessAndClassIndexArray!: Uint32Array;
   nodeNativeContextAttribution!: Int32Array;
   #nativeContextSizes!: HeapSnapshotModel.HeapSnapshotModel.NativeContextSizes;
   #nativeContextOrdinals!: number[];
@@ -1092,6 +1082,7 @@ export abstract class HeapSnapshot {
     this.#progress.updateStatus('Building retainers…');
     const resultsFromSecondWorker = this.startInitStep1InSecondThread(secondWorker);
     this.#progress.updateStatus('Propagating DOM state…');
+    this.initDetachednessAndClassIndex();
     this.propagateDOMState();
     this.#progress.updateStatus('Calculating node flags…');
     this.calculateFlags();
@@ -2400,12 +2391,6 @@ export abstract class HeapSnapshot {
       nodeRegExpType,
     } = this;
 
-    // If the snapshot doesn't contain a detachedness field in each node, then
-    // allocate a separate array so there is somewhere to store the class index.
-    if (this.nodeDetachednessAndClassIndexOffset === -1) {
-      this.detachednessAndClassIndexArray = new Uint32Array(nodeCount);
-    }
-
     // We'll add some new values to the `strings` array during the processing below.
     // This map lets us easily find the index for each added string.
     const stringTable = new Map<string, number>();
@@ -2707,6 +2692,49 @@ export abstract class HeapSnapshot {
     return this.#nativeContextSizes;
   }
 
+  getRetainedByContextSummary(): HeapSnapshotModel.HeapSnapshotModel.RetainedByContextSummary {
+    // Use the exact same implementation here as aggregateWithFilter('objectsRetainedByContexts').
+    const isRetainedByContext = this.createNamedFilter('objectsRetainedByContexts');
+
+    let contextCount = 0;
+    let retainedByContextSize = 0;
+    let retainedByContextCount = 0;
+    let notRetainedByContextSize = 0;
+    let notRetainedByContextCount = 0;
+
+    const node = this.rootNode();
+    const {nodes, nodeFieldCount, nodeSelfSizeOffset: selfSizeOffset} = this;
+    const nodesLength = nodes.length;
+
+    for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+      const selfSize = nodes.getValue(nodeIndex + selfSizeOffset);
+      if (!selfSize) {
+        continue;
+      }
+      node.nodeIndex = nodeIndex;
+      if (isRetainedByContext(node)) {
+        retainedByContextCount++;
+        retainedByContextSize += selfSize;
+      } else {
+        notRetainedByContextCount++;
+        notRetainedByContextSize += selfSize;
+      }
+
+      if (this.isContextObject(node)) {
+        contextCount++;
+      }
+    }
+
+    return {
+      contextCount,
+      retainedByContextSize,
+      retainedByContextCount,
+      notRetainedByContextSize,
+      notRetainedByContextCount,
+      totalSize: retainedByContextSize + notRetainedByContextSize,
+    };
+  }
+
   nodeNativeContext(nodeIndex: number): number {
     const ordinal = nodeIndex / this.nodeFieldCount;
     const nativeContextOrdinal = this.nodeNativeContextAttribution[ordinal];
@@ -2987,6 +3015,30 @@ export abstract class HeapSnapshot {
     return null;
   }
 
+  private initDetachednessAndClassIndex(): void {
+    this.detachednessAndClassIndexArray = new Uint32Array(this.nodeCount);
+    if (this.nodeDetachednessAndClassIndexOffset !== -1) {
+      // Seed this array from the detachedness field of the snapshot.
+      const {nodeFieldCount, nodeDetachednessAndClassIndexOffset: offset} = this;
+      for (let i = 0; i < this.nodeCount; ++i) {
+        this.detachednessAndClassIndexArray[i] = Number(this.nodes.getValue(i * nodeFieldCount + offset));
+      }
+    } else {
+      // For old snapshots, treat native objects named 'Detached ...' as detached.
+      const node = this.rootNode();
+      const nodesLength = this.nodes.length;
+      const {nodeFieldCount, nodeNativeType, nodeTypeOffset} = this;
+      for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+        if (this.nodes.getValue(nodeIndex + nodeTypeOffset) === nodeNativeType) {
+          node.nodeIndex = nodeIndex;
+          if (node.name().startsWith('Detached ')) {
+            node.setDetachedness(HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.DETACHED);
+          }
+        }
+      }
+    }
+  }
+
   /**
    * The phase propagates whether a node is attached or detached through the
    * graph and adjusts the low-level representation of nodes.
@@ -3292,11 +3344,58 @@ export abstract class HeapSnapshot {
     return null;
   }
 
-  createEdgesProvider(nodeIndex: number): HeapSnapshotEdgesProvider {
+  createEdgesProvider(nodeIndex: number,
+                      options?: HeapSnapshotModel.HeapSnapshotModel.HeapEdgesQueryOptions): HeapSnapshotEdgesProvider {
     const node = this.createNode(nodeIndex);
-    const filter = this.containmentEdgesFilter();
+    const defaultFilter = this.containmentEdgesFilter();
+    const minRetainedSize = options?.minRetainedSize;
+    const excludePrimitives = options?.excludePrimitives ?? false;
+
+    let filter: ((arg0: HeapSnapshotEdge) => boolean)|null = defaultFilter;
+
+    if (minRetainedSize !== undefined || excludePrimitives) {
+      filter = (edge: HeapSnapshotEdge): boolean => {
+        if (defaultFilter && !defaultFilter(edge)) {
+          return false;
+        }
+        const targetNode = edge.node();
+        if (minRetainedSize !== undefined && targetNode.retainedSize() < minRetainedSize) {
+          return false;
+        }
+        if (excludePrimitives) {
+          const rawType = targetNode.rawType();
+          if (rawType === this.nodeNumberType) {
+            return false;
+          }
+          if (rawType === this.nodeNativeType) {
+            const targetName = targetNode.rawName();
+            if (targetName === 'undefined' || targetName === 'null' || targetName === 'true' ||
+                targetName === 'false') {
+              return false;
+            }
+          }
+        }
+        return true;
+      };
+    }
+
     const indexProvider = new HeapSnapshotEdgeIndexProvider(this);
-    return new HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
+    const provider = new HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
+
+    if (options?.sortBy) {
+      const sortBy = options.sortBy;
+      let comparator: HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig;
+      if (sortBy === 'selfSize') {
+        comparator = new HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig('selfSize', false, '!edgeName', true);
+      } else if (sortBy === 'name') {
+        comparator = new HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig('!edgeName', true, 'retainedSize', false);
+      } else {
+        comparator = new HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig('retainedSize', false, '!edgeName', true);
+      }
+      provider.sortAndRewind(comparator);
+    }
+
+    return provider;
   }
 
   createEdgesProviderForTest(nodeIndex: number, filter: ((arg0: HeapSnapshotEdge) => boolean)|null):
@@ -3512,6 +3611,97 @@ export abstract class HeapSnapshot {
     return new HeapSnapshotNodesProvider(this, this.aggregatesWithFilter(nodeFilter)[classKey].idxs);
   }
 
+  queryObjects(queryOptions: HeapSnapshotModel.HeapSnapshotModel.HeapQueryOptions): HeapSnapshotNodesProvider {
+    const {nodes, nodeFieldCount, retainedSizes} = this;
+    const nodesLength = nodes.length;
+
+    const matchingIndexes: number[] = [];
+
+    const classNamePattern = queryOptions.className ? new RegExp(queryOptions.className, 'i') : null;
+    const propertyNamePattern = queryOptions.propertyName ? new RegExp(queryOptions.propertyName, 'i') : null;
+    const targetNodeType = queryOptions.nodeType ? queryOptions.nodeType.toLowerCase() : null;
+
+    const node = this.rootNode();
+
+    for (let nodeIndex = 0, ordinal = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount, ordinal++) {
+      node.nodeIndex = nodeIndex;
+
+      if (queryOptions.minSelfSize !== undefined && node.selfSize() < queryOptions.minSelfSize) {
+        continue;
+      }
+      if (queryOptions.maxSelfSize !== undefined && node.selfSize() > queryOptions.maxSelfSize) {
+        continue;
+      }
+
+      const retainedSize = retainedSizes[ordinal];
+      if (queryOptions.minRetainedSize !== undefined && retainedSize < queryOptions.minRetainedSize) {
+        continue;
+      }
+      if (queryOptions.maxRetainedSize !== undefined && retainedSize > queryOptions.maxRetainedSize) {
+        continue;
+      }
+
+      if (queryOptions.isDetached !== undefined) {
+        const isDetached = node.detachedness() === HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.DETACHED;
+        if (isDetached !== queryOptions.isDetached) {
+          continue;
+        }
+      }
+
+      if (classNamePattern) {
+        const name = node.name();
+        if (!classNamePattern.test(name)) {
+          continue;
+        }
+      }
+
+      if (targetNodeType) {
+        const typeStr = node.type();
+        if (typeStr.toLowerCase() !== targetNodeType) {
+          continue;
+        }
+      }
+
+      if (propertyNamePattern) {
+        let propMatch = false;
+        for (const iter = node.edges(); iter.hasNext(); iter.next()) {
+          if (propertyNamePattern.test(iter.edge.name())) {
+            propMatch = true;
+            break;
+          }
+        }
+        if (!propMatch) {
+          continue;
+        }
+      }
+
+      matchingIndexes.push(nodeIndex);
+    }
+
+    const sortBy = queryOptions.sortBy ?? 'retainedSize';
+    if (sortBy === 'retainedSize') {
+      matchingIndexes.sort((a, b) => retainedSizes[b / nodeFieldCount] - retainedSizes[a / nodeFieldCount]);
+    } else if (sortBy === 'selfSize') {
+      matchingIndexes.sort((a, b) => {
+        node.nodeIndex = b;
+        const sizeB = node.selfSize();
+        node.nodeIndex = a;
+        const sizeA = node.selfSize();
+        return sizeB - sizeA;
+      });
+    } else if (sortBy === 'id') {
+      matchingIndexes.sort((a, b) => {
+        node.nodeIndex = b;
+        const idB = node.id();
+        node.nodeIndex = a;
+        const idA = node.id();
+        return idA - idB;
+      });
+    }
+
+    return new HeapSnapshotNodesProvider(this, matchingIndexes);
+  }
+
   private maxJsNodeId(): number {
     const nodeFieldCount = this.nodeFieldCount;
     const nodes = this.nodes;
@@ -4196,7 +4386,7 @@ export class JSHeapSnapshot extends HeapSnapshot {
         continue;
       }
       node.nodeIndex = nodeIndex;
-      if (node.name().startsWith('Detached ')) {
+      if (node.detachedness() === HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.DETACHED) {
         this.flags[ordinal] |= flag;
       }
     }

package/front_end/entrypoints/main/MainImpl.ts

@@ -49,6 +49,7 @@ import * as Persistence from '../../models/persistence/persistence.js';
 import * as Workspace from '../../models/workspace/workspace.js';
 import * as PanelCommon from '../../panels/common/common.js';
 import * as Snippets from '../../panels/snippets/snippets.js';
+import type * as Comments from '../../ui/comments/comments.js';
 import * as Buttons from '../../ui/components/buttons/buttons.js';
 import * as Snackbar from '../../ui/components/snackbars/snackbars.js';
 import * as UIHelpers from '../../ui/helpers/helpers.js';
@@ -998,3 +999,33 @@ export class ReloadActionDelegate implements UI.ActionRegistration.ActionDelegat
     return false;
   }
 }
+
+let activeCommentManager: Comments.CommentManager.CommentManager|null = null;
+let activeOverlayWidget: Comments.CommentsOverlayWidget.CommentsOverlayWidget|null = null;
+
+// Temporary for manual testing and experimentation.
+export async function comments(): Promise<Comments.CommentManager.CommentManager> {
+  const Comments = await import('../../ui/comments/comments.js');
+  if (!activeCommentManager || !activeOverlayWidget) {
+    activeCommentManager = new Comments.CommentManager.CommentManager();
+    activeCommentManager.start();
+
+    activeOverlayWidget = new Comments.CommentsOverlayWidget.CommentsOverlayWidget(activeCommentManager);
+    activeOverlayWidget.markAsRoot();
+    activeOverlayWidget.show(document.body);
+    activeCommentManager.setCommentMode(true);
+    return activeCommentManager;
+  }
+
+  const newMode = !activeCommentManager.isCommentMode();
+  activeCommentManager.setCommentMode(newMode);
+  if (newMode) {
+    activeOverlayWidget.show(document.body);
+  } else {
+    activeOverlayWidget.detach();
+  }
+  return activeCommentManager;
+}
+
+// @ts-expect-error global helper for manual testing
+globalThis.comments = comments;

package/front_end/generated/InspectorBackendCommands.ts

@@ -1136,6 +1136,8 @@ inspectorBackend.registerEnum("Page.SetTouchEmulationEnabledRequestConfiguration
 inspectorBackend.registerCommand("Page.setTouchEmulationEnabled", [{"name": "enabled", "type": "boolean", "optional": false, "description": "Whether the touch event emulation should be enabled.", "typeRef": null}, {"name": "configuration", "type": "string", "optional": true, "description": "Touch/gesture events configuration. Default: current platform.", "typeRef": "Page.SetTouchEmulationEnabledRequestConfiguration"}], [], "Toggles mouse event-based touch event emulation.");
 inspectorBackend.registerEnum("Page.StartScreencastRequestFormat", {Jpeg: "jpeg", Png: "png"});
 inspectorBackend.registerCommand("Page.startScreencast", [{"name": "format", "type": "string", "optional": true, "description": "Image compression format.", "typeRef": "Page.StartScreencastRequestFormat"}, {"name": "quality", "type": "number", "optional": true, "description": "Compression quality from range [0..100].", "typeRef": null}, {"name": "maxWidth", "type": "number", "optional": true, "description": "Maximum screenshot width.", "typeRef": null}, {"name": "maxHeight", "type": "number", "optional": true, "description": "Maximum screenshot height.", "typeRef": null}, {"name": "everyNthFrame", "type": "number", "optional": true, "description": "Send every n-th frame.", "typeRef": null}], [], "Starts sending each frame using the `screencastFrame` event.");
+inspectorBackend.registerCommand("Page.startScreenRecording", [{"name": "audio", "type": "boolean", "optional": true, "description": "", "typeRef": null}, {"name": "maxWidth", "type": "number", "optional": true, "description": "Maximum frame width in pixels.", "typeRef": null}, {"name": "maxHeight", "type": "number", "optional": true, "description": "Maximum frame height in pixels.", "typeRef": null}, {"name": "frameRate", "type": "number", "optional": true, "description": "Maximum frame rate in frames per second.", "typeRef": null}], ["stream"], "Starts screencast video recording.");
+inspectorBackend.registerCommand("Page.stopScreenRecording", [], ["stream"], "Stops screencast video recording.");
 inspectorBackend.registerCommand("Page.stopLoading", [], [], "Force the page stop all navigations and pending resource fetches.");
 inspectorBackend.registerCommand("Page.crash", [], [], "Crashes renderer on the IO thread, generates minidumps.");
 inspectorBackend.registerCommand("Page.close", [], [], "Tries to close page, running its beforeunload hooks, if any.");
@@ -1464,7 +1466,7 @@ inspectorBackend.registerType("WebAudio.AudioParam", [{"name": "paramId", "type"
 // WebAuthn.
 inspectorBackend.registerEnum("WebAuthn.AuthenticatorProtocol", {U2f: "u2f", Ctap2: "ctap2"});
 inspectorBackend.registerEnum("WebAuthn.Ctap2Version", {Ctap2_0: "ctap2_0", Ctap2_1: "ctap2_1", Ctap2_2: "ctap2_2"});
-inspectorBackend.registerEnum("WebAuthn.AuthenticatorTransport", {Usb: "usb", Nfc: "nfc", Ble: "ble", Cable: "cable", Internal: "internal"});
+inspectorBackend.registerEnum("WebAuthn.AuthenticatorTransport", {Usb: "usb", Nfc: "nfc", Ble: "ble", Cable: "cable", Hybrid: "hybrid", SmartCard: "smart-card", Internal: "internal"});
 inspectorBackend.registerEvent("WebAuthn.credentialAdded", ["authenticatorId", "credential"]);
 inspectorBackend.registerEvent("WebAuthn.credentialDeleted", ["authenticatorId", "credentialId"]);
 inspectorBackend.registerEvent("WebAuthn.credentialUpdated", ["authenticatorId", "credential"]);

package/front_end/generated/SupportedCSSProperties.ts

@@ -1026,6 +1026,11 @@ export const generatedProperties = [
   "runtime_flag_status": "stable"
  },
  {
+  "devtools_keywords": [
+   "none",
+   "move",
+   "no-drag"
+  ],
   "name": "app-region"
  },
  {
@@ -5163,7 +5168,8 @@ export const generatedProperties = [
    "inline",
    "both",
    "mandatory",
-   "proximity"
+   "proximity",
+   "pair"
   ],
   "name": "scroll-snap-type"
  },
@@ -6078,6 +6084,10 @@ export const generatedProperties = [
   "name": "will-change"
  },
  {
+  "devtools_keywords": [
+   "none",
+   "move"
+  ],
   "inherited": true,
   "keywords": [
    "none",
@@ -6415,6 +6425,13 @@ export const generatedPropertyValues = {
    "none"
   ]
  },
+ "app-region": {
+  "values": [
+   "none",
+   "move",
+   "no-drag"
+  ]
+ },
  "appearance": {
   "values": [
    "auto",
@@ -8694,7 +8711,8 @@ export const generatedPropertyValues = {
    "inline",
    "both",
    "mandatory",
-   "proximity"
+   "proximity",
+   "pair"
   ]
  },
  "scroll-target-group": {
@@ -9208,8 +9226,7 @@ export const generatedPropertyValues = {
  "window-drag": {
   "values": [
    "none",
-   "move",
-   "no-drag"
+   "move"
   ]
  },
  "word-break": {

package/front_end/generated/protocol-mapping.d.ts

@@ -4323,6 +4323,20 @@ export namespace ProtocolMapping {
       paramsType: [Protocol.Page.StartScreencastRequest?];
       returnType: void;
     };
+    /**
+     * Starts screencast video recording.
+     */
+    'Page.startScreenRecording': {
+      paramsType: [Protocol.Page.StartScreenRecordingRequest?];
+      returnType: Protocol.Page.StartScreenRecordingResponse;
+    };
+    /**
+     * Stops screencast video recording.
+     */
+    'Page.stopScreenRecording': {
+      paramsType: [];
+      returnType: Protocol.Page.StopScreenRecordingResponse;
+    };
     /**
      * Force the page stop all navigations and pending resource fetches.
      */

package/front_end/generated/protocol-proxy-api.d.ts

@@ -3478,6 +3478,16 @@ declare namespace ProtocolProxyApi {
      */
     invoke_startScreencast(params: Protocol.Page.StartScreencastRequest): Promise<Protocol.ProtocolResponseWithError>;
 
+    /**
+     * Starts screencast video recording.
+     */
+    invoke_startScreenRecording(params: Protocol.Page.StartScreenRecordingRequest): Promise<Protocol.Page.StartScreenRecordingResponse>;
+
+    /**
+     * Stops screencast video recording.
+     */
+    invoke_stopScreenRecording(): Promise<Protocol.Page.StopScreenRecordingResponse>;
+
     /**
      * Force the page stop all navigations and pending resource fetches.
      */

package/front_end/generated/protocol.ts

@@ -16288,6 +16288,36 @@ export namespace Page {
     everyNthFrame?: integer;
   }
 
+  export interface StartScreenRecordingRequest {
+    audio?: boolean;
+    /**
+     * Maximum frame width in pixels.
+     */
+    maxWidth?: integer;
+    /**
+     * Maximum frame height in pixels.
+     */
+    maxHeight?: integer;
+    /**
+     * Maximum frame rate in frames per second.
+     */
+    frameRate?: integer;
+  }
+
+  export interface StartScreenRecordingResponse extends ProtocolResponseWithError {
+    /**
+     * A handle of the stream that holds resulting screencast data.
+     */
+    stream: IO.StreamHandle;
+  }
+
+  export interface StopScreenRecordingResponse extends ProtocolResponseWithError {
+    /**
+     * A handle of the stream that holds resulting screencast data.
+     */
+    stream: IO.StreamHandle;
+  }
+
   export const enum SetWebLifecycleStateRequestState {
     Frozen = 'frozen',
     Active = 'active',
@@ -20069,11 +20099,16 @@ export namespace WebAuthn {
     Ctap2_2 = 'ctap2_2',
   }
 
+  /**
+   * LINT_SKIP.IfChange(AuthenticatorTransport)
+   */
   export const enum AuthenticatorTransport {
     Usb = 'usb',
     Nfc = 'nfc',
     Ble = 'ble',
     Cable = 'cable',
+    Hybrid = 'hybrid',
+    SmartCard = 'smart-card',
     Internal = 'internal',
   }
 

package/front_end/models/ai_assistance/AiAgent2.ts

@@ -30,6 +30,8 @@ const SKILL_DISPLAY_NAMES: Record<SkillName, string> = {
   network: 'Network requests',
   accessibility: 'Accessibility',
   performance: 'Performance',
+  storage: 'Storage',
+  sources: 'Workspace files and sources',
 };
 
 const preamble = `You are the most advanced unified AI assistant integrated into Chrome DevTools.
@@ -81,6 +83,12 @@ export class AiAgent2 extends AiAgent<unknown> {
     return {};
   }
 
+  protected override async preRun(): Promise<void> {
+    if (this.context && !this.context.isLoggingEnabled()) {
+      this.setServerSideLoggingActive(false);
+    }
+  }
+
   readonly #activeSkills = new Set<SkillName>();
   readonly #declaredTools = new Set<string>();
 
@@ -242,6 +250,9 @@ User query: ${enhancedQuery}`;
           getEstablishedOrigin: () => this.#getConversationOrigin(),
           lighthouseRecording: this.#lighthouseRecording,
           performanceRecordAndReload: this.#performanceRecordAndReload,
+          setLoggingEnabled: (enabled: boolean) => {
+            this.setServerSideLoggingActive(enabled);
+          },
         };
         return tool.handler(args, context, options);
       },

package/front_end/models/ai_assistance/AiConversation.ts

@@ -27,7 +27,7 @@ import {ContextSelectionAgent} from './agents/ContextSelectionAgent.js';
 import {FileAgent} from './agents/FileAgent.js';
 import {NetworkAgent} from './agents/NetworkAgent.js';
 import {PerformanceAgent} from './agents/PerformanceAgent.js';
-import {StorageAgent, StorageContext} from './agents/StorageAgent.js';
+import {StorageAgent} from './agents/StorageAgent.js';
 import {StylingAgent} from './agents/StylingAgent.js';
 import {AiAgent2} from './AiAgent2.js';
 import {AiHistoryStorage, ConversationType, type SerializedConversation} from './AiHistoryStorage.js';
@@ -37,6 +37,9 @@ import {DOMNodeContext} from './contexts/DOMNodeContext.js';
 import {FileContext} from './contexts/FileContext.js';
 import {PerformanceTraceContext} from './contexts/PerformanceTraceContext.js';
 import {RequestContext} from './contexts/RequestContext.js';
+import {StorageContext} from './contexts/StorageContext.js';
+import {ToolAnnotation} from './tools/Tool.js';
+import {ToolRegistry} from './tools/ToolRegistry.js';
 
 export const NOT_FOUND_IMAGE_DATA = '';
 export const CONTEXT_TITLE = 'Analyzing data';
@@ -324,10 +327,18 @@ export class AiConversation {
                        case ResponseType.SIDE_EFFECT: {
                          return {...item, confirm: undefined};
                        }
-                       case ResponseType.CONTEXT:
-                       case ResponseType.ACTION: {
+                       case ResponseType.CONTEXT: {
                          return {...item, widgets: undefined};
                        }
+                       case ResponseType.ACTION: {
+                         const tool = item.toolName ? ToolRegistry.get(item.toolName) : undefined;
+                         const shouldRedact = tool?.annotations?.includes(ToolAnnotation.REDACT_FROM_HISTORY);
+                         return {
+                           ...item,
+                           output: shouldRedact ? '<redacted>' : item.output,
+                           widgets: undefined,
+                         };
+                       }
                        default:
                          return item;
                      }
@@ -361,7 +372,7 @@ export class AiConversation {
 
     const options = {
       aidaClient: this.#aidaClient,
-      serverSideLoggingEnabled: isAiAssistanceServerSideLoggingEnabled(),
+      serverSideLoggingAllowed: isAiAssistanceServerSideLoggingAllowed(),
       sessionId: this.id,
       changeManager: this.#changeManager,
       performanceRecordAndReload: this.#performanceRecordAndReload,
@@ -540,7 +551,13 @@ export class AiConversation {
   };
 }
 
-function isAiAssistanceServerSideLoggingEnabled(): boolean {
+/**
+ * Checks whether server-side logging is allowed by the global system policy.
+ * Note that even if this returns true, individual agents can still dynamically
+ * deactivate/activate logging during their execution (e.g., when handling
+ * sensitive tools).
+ */
+function isAiAssistanceServerSideLoggingAllowed(): boolean {
   return !Root.Runtime.hostConfig.aidaAvailability?.disallowLogging;
 }