chrome-devtools-frontend 1.0.1599001 → 1.0.1602348

package/.agents/skills/verification/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: devtools-verification
-description: Guidelines for verifying changes in DevTools. Covers npm test, autoninja build, linting, and using fast builds.
+description: MANDATORY: Activate this skill ANY TIME you need to build the project, run tests, or verify code health in DevTools. You MUST use this skill before executing commands like npm test, npm run build, autoninja, or linters, as it contains critical, repository-specific instructions on how to correctly format these commands, filter test runs, and interpret failures.
 ---
 
 # Instructions on how to verify your changes

package/.agents/skills/version-control/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: devtools-version-control
+description: Use when managing branches, creating CLs, or handling stacked changes in the DevTools Gerrit-based workflow.
+---
+
+# DevTools Version Control
+
+## Overview
+Chrome DevTools uses Gerrit for code review. The standard workflow is **one branch per Change List (CL)** and **one commit per branch**. Instead of multiple commits, you amend your single commit locally.
+
+## Core Workflow
+
+### Creating a New CL
+To start a new task, create a new branch from `main`:
+```bash
+git new-branch <branch-name>
+```
+*Note: This automatically sets the upstream to `origin/main`.*
+
+### Making Changes
+1. Make your changes.
+2. Stage them: `git add <files>`.
+3. Create the commit: `git commit -m "Your message"`.
+
+### Updating a CL (Amending)
+To update your CL after feedback or more work:
+1. Make more changes.
+2. Stage them: `git add <files>`.
+3. Amend the commit: `git commit --amend`.
+4. Upload: `git cl upload`.
+
+### Stacked CLs
+If CL B depends on CL A:
+1. While on branch A, create branch B:
+   ```bash
+   git new-branch --upstream_current <branch-B>
+   ```
+2. Develop on branch B.
+3. When uploading B, Gerrit will show the dependency on A.
+
+### Reparenting
+If you need to change the base of a branch (e.g., move CL B to be based on `main` instead of CL A):
+```bash
+git reparent-branch main
+```
+Or to make it depend on another branch C:
+```bash
+git reparent-branch <branch-C>
+```
+
+### Syncing with Upstream
+To update all your branches with the latest changes from `main` and their respective upstreams:
+```bash
+git rebase-update
+```
+
+## Quick Reference
+
+| Action | Command |
+| :--- | :--- |
+| Create new CL from main | `git new-branch <name>` |
+| Create stacked CL | `git new-branch --upstream_current <name>` |
+| Update current CL | `git commit --amend` |
+| Upload to Gerrit | `git cl upload` |
+| Change branch parent | `git reparent-branch <new-parent>` |
+| Sync all branches | `git rebase-update` |
+
+## Common Mistakes
+- **Multiple commits on one branch:** Gerrit expects one commit per CL. Always `commit --amend`.
+- **Using `git checkout -b`:** Does not set up tracking information correctly for `depot_tools`. Use `git new-branch`.
+- **Manual rebasing of stacked branches:** Can be complex. Use `git rebase-update` or `git reparent-branch` to let `depot_tools` handle the tracking updates.

package/front_end/core/common/Settings.ts

@@ -688,7 +688,7 @@ export class VersionController {
   static readonly SYNCED_VERSION_SETTING_NAME = 'syncedInspectorVersion';
   static readonly LOCAL_VERSION_SETTING_NAME = 'localInspectorVersion';
 
-  static readonly CURRENT_VERSION = 41;
+  static readonly CURRENT_VERSION = 42;
 
   readonly #settings: Settings;
   readonly #globalVersionSetting: Setting<number>;
@@ -1480,6 +1480,29 @@ export class VersionController {
     }
   }
 
+  /**
+   * The recording in recorder panel may have unreasonably long titles
+   * or a lot of steps which can cause renderer crashes.
+   * Similar to https://crbug.com/40918380
+   */
+  updateVersionFrom41To42(): void {
+    const recordingsSetting = this.#settings.createSetting<Array<{flow: {steps: unknown[], title: string}}>>(
+        'recorder-recordings-ng',
+        [],
+    );
+    const recordings = recordingsSetting.get();
+    if (recordings.length === 0) {
+      return;
+    }
+
+    for (const recording of recordings) {
+      recording.flow.title = Platform.StringUtilities.trimEndWithMaxLength(recording.flow.title, 300);
+      recording.flow.steps = recording.flow.steps.slice(0, 4096);
+    }
+
+    recordingsSetting.set(recordings);
+  }
+
   /*
    * Any new migration should be added before this comment.
    *

package/front_end/core/dom_extension/DOMExtension.ts

@@ -36,6 +36,7 @@
 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck This file is not checked by TypeScript Compiler as it has a lot of legacy code.
+/* eslint-disable @devtools/no-imperative-dom-api */
 
 import * as Platform from '../platform/platform.js';
 

package/front_end/core/host/AidaClient.ts

@@ -67,10 +67,10 @@ interface BaseFunctionParam {
 }
 
 export interface FunctionPrimitiveParams extends BaseFunctionParam {
-  type: ParametersTypes.BOOLEAN|ParametersTypes.INTEGER|ParametersTypes.STRING|ParametersTypes.BOOLEAN;
+  type: ParametersTypes.BOOLEAN|ParametersTypes.INTEGER|ParametersTypes.STRING;
 }
 
-interface FunctionArrayParam extends BaseFunctionParam {
+export interface FunctionArrayParam extends BaseFunctionParam {
   type: ParametersTypes.ARRAY;
   items: FunctionPrimitiveParams;
 }
@@ -301,6 +301,9 @@ export enum UseCase {
 
   // Code generation use case is expected to generate code from scratch
   CODE_GENERATION = 1,
+
+  // Code transformation or code editing use case.
+  CODE_TRANSFORMATION = 2,
 }
 
 /* eslint-disable @typescript-eslint/naming-convention */

package/front_end/core/host/AidaGcaTranslation.ts

@@ -0,0 +1,377 @@
+// 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 AIDA from './AidaClient.js';
+import * as GCA from './GcaTypes.js';
+
+type AidaRequest = AIDA.DoConversationRequest|AIDA.CompletionRequest|AIDA.GenerateCodeRequest;
+
+function createBaseGcaRequest(request: AidaRequest, contents: GCA.Content[]): GCA.GenerateContentRequest {
+  const gcaRequest: GCA.GenerateContentRequest = {contents};
+  mapCommonAidaRequestFields(request, gcaRequest);
+  buildLabels(request, gcaRequest);
+
+  if ('preamble' in request && request.preamble) {
+    gcaRequest.system_instruction = {
+      role: 'user',
+      parts: [{text: request.preamble}],
+    };
+  }
+
+  return gcaRequest;
+}
+
+export function aidaDoConversationRequestToGcaRequest(request: AIDA.DoConversationRequest): GCA.GenerateContentRequest {
+  const contents: GCA.Content[] = [];
+
+  if (request.historical_contexts) {
+    contents.push(...request.historical_contexts.map(convertAidaContentToGcaContent));
+  }
+  contents.push(convertAidaContentToGcaContent(request.current_message));
+
+  const gcaRequest = createBaseGcaRequest(request, contents);
+
+  if (request.function_declarations) {
+    gcaRequest.tools = [{
+      function_declarations: request.function_declarations.map(fd => ({
+                                                                 name: fd.name,
+                                                                 description: fd.description,
+                                                                 parameters: convertAidaParamToGcaSchema(fd.parameters),
+                                                               })),
+    }];
+  }
+
+  return gcaRequest;
+}
+
+function mapCommonAidaRequestFields(aidaRequest: AidaRequest, gcaRequest: GCA.GenerateContentRequest): void {
+  if (aidaRequest.options?.model_id) {
+    gcaRequest.model = aidaRequest.options.model_id;
+  }
+  if (aidaRequest.metadata.string_session_id) {
+    gcaRequest.session_id = aidaRequest.metadata.string_session_id;
+  }
+  if (aidaRequest.options?.temperature !== undefined) {
+    gcaRequest.generation_config = {
+      ...gcaRequest.generation_config,
+      temperature: aidaRequest.options.temperature,
+    };
+  }
+}
+
+export function gcaResponseToAidaDoConversationResponse(response: GCA.GenerateContentResponse):
+    AIDA.DoConversationResponse {
+  const candidate = response.candidates[0];
+  const functionCalls: AIDA.AidaFunctionCallResponse[] = [];
+
+  if (candidate?.content?.parts) {
+    for (const part of candidate.content.parts) {
+      if (part.function_call) {
+        functionCalls.push({
+          name: part.function_call.name,
+          args: part.function_call.args || {},
+        });
+      }
+    }
+  }
+
+  return {
+    explanation: extractTextFromGcaParts(candidate?.content?.parts),
+    metadata: {
+      rpcGlobalId: response.response_id,
+    },
+    functionCalls: functionCalls.length > 0 ?
+        (functionCalls as [AIDA.AidaFunctionCallResponse, ...AIDA.AidaFunctionCallResponse[]]) :
+        undefined,
+    completed: true,
+  };
+}
+
+function extractTextFromGcaParts(parts: GCA.Part[]|undefined): string {
+  if (!parts) {
+    return '';
+  }
+  return parts.map(p => p.text || '').join('');
+}
+
+export function aidaEventToGcaTelemetryRequest(clientEvent: AIDA.AidaRegisterClientEvent): GCA.SendTelemetryRequest {
+  const feedbackMetrics: GCA.FeedbackMetric[] = [];
+  const responseId = String(clientEvent.corresponding_aida_rpc_global_id);
+  const eventTime = new Date().toISOString();
+
+  if (clientEvent.do_conversation_client_event) {
+    const feedback = clientEvent.do_conversation_client_event.user_feedback;
+    if (feedback.sentiment) {
+      let interaction: GCA.InteractionType = GCA.InteractionType.INTERACTION_TYPE_UNSPECIFIED;
+      if (feedback.sentiment === AIDA.Rating.POSITIVE) {
+        interaction = GCA.InteractionType.THUMBS_UP;
+      } else if (feedback.sentiment === AIDA.Rating.NEGATIVE) {
+        interaction = GCA.InteractionType.THUMBS_DOWN;
+      }
+      feedbackMetrics.push({
+        event_time: eventTime,
+        response_id: responseId,
+        suggestion_interaction: {interaction},
+      });
+    }
+  }
+
+  feedbackMetrics.push(
+      ...convertCodeTelemetry(clientEvent.complete_code_client_event, GCA.Method.COMPLETE_CODE, responseId, eventTime));
+  feedbackMetrics.push(
+      ...convertCodeTelemetry(clientEvent.generate_code_client_event, GCA.Method.GENERATE_CODE, responseId, eventTime));
+
+  return {feedback_metrics: feedbackMetrics};
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+function convertCodeTelemetry(
+    event: {user_acceptance?: AIDA.UserAcceptance, user_impression?: AIDA.UserImpression}|undefined, method: GCA.Method,
+    responseId: string, eventTime: string): GCA.FeedbackMetric[] {
+  if (!event) {
+    return [];
+  }
+  if ('user_impression' in event && event.user_impression) {
+    const impression = event.user_impression;
+    return [{
+      event_time: eventTime,
+      response_id: responseId,
+      suggestion_offered: {
+        method,
+        status: GCA.SuggestionStatus.NO_ERROR,
+        response_latency: `${impression.latency.duration.seconds + impression.latency.duration.nanos / 1e9}s`,
+      },
+    }];
+  }
+  if ('user_acceptance' in event && event.user_acceptance) {
+    const acceptance = event.user_acceptance;
+    return [{
+      event_time: eventTime,
+      response_id: responseId,
+      suggestion_interaction: {
+        interaction: GCA.InteractionType.ACCEPT,
+        candidate_index: acceptance.sample.sample_id,
+      },
+    }];
+  }
+  return [];
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+export function aidaCompletionRequestToGcaRequest(request: AIDA.CompletionRequest): GCA.GenerateContentRequest {
+  const contents: GCA.Content[] = [
+    {
+      role: 'user',
+      parts: [{text: request.prefix + (request.suffix || '')}],
+    },
+  ];
+
+  const gcaRequest = createBaseGcaRequest(request, contents);
+
+  if (request.options?.stop_sequences) {
+    gcaRequest.generation_config = {
+      ...gcaRequest.generation_config,
+      stop_sequences: request.options.stop_sequences,
+    };
+  }
+
+  if (request.additional_files) {
+    gcaRequest.aicode = {
+      experience: 'completion',
+      files: request.additional_files.map(f => ({
+                                            file_uri: f.path,
+                                            inclusion_reason: [AidaReasonToGcaInclusionReason[f.included_reason]],
+                                          })),
+    };
+  }
+
+  return gcaRequest;
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+function buildLabels(request: AidaRequest, gcaRequest: GCA.GenerateContentRequest): void {
+  const labels: Record<string, string> = {};
+  if (request.client) {
+    labels['client'] = request.client;
+  }
+  if ('functionality_type' in request && request.functionality_type !== undefined) {
+    labels['functionality_type'] = AIDA.FunctionalityType[request.functionality_type];
+  }
+  if ('client_feature' in request && request.client_feature !== undefined) {
+    labels['client_feature'] = AIDA.ClientFeature[request.client_feature];
+  }
+  if ('last_user_action' in request && request.last_user_action !== undefined) {
+    labels['last_user_action'] = AIDA.EditType[request.last_user_action];
+  }
+  if ('use_case' in request && request.use_case !== undefined) {
+    labels['use_case'] = AIDA.UseCase[request.use_case];
+  }
+  const options = request.options as {
+    inference_language?: string,
+    expect_code_output?: boolean,
+  } | undefined;
+  if (options?.inference_language) {
+    labels['inference_language'] = options.inference_language;
+  }
+  if (options?.expect_code_output !== undefined) {
+    labels['expect_code_output'] = String(options.expect_code_output);
+  }
+
+  if (Object.keys(labels).length > 0) {
+    gcaRequest.labels = labels;
+  }
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+const AidaReasonToGcaInclusionReason: Record<AIDA.Reason, GCA.InclusionReason> = {
+  [AIDA.Reason.UNKNOWN]: GCA.InclusionReason.INCLUSION_REASON_UNSPECIFIED,
+  [AIDA.Reason.CURRENTLY_OPEN]: GCA.InclusionReason.OPEN,
+  // Intentional mapping due to type mismatch
+  // TODO(liviurau): find a way to validate this mapping
+  [AIDA.Reason.RECENTLY_OPENED]: GCA.InclusionReason.RECENTLY_CLOSED,
+  [AIDA.Reason.RECENTLY_EDITED]: GCA.InclusionReason.RECENTLY_EDITED,
+  [AIDA.Reason.COLOCATED]: GCA.InclusionReason.COLOCATED,
+  [AIDA.Reason.RELATED_FILE]: GCA.InclusionReason.RELATED,
+};
+
+export function gcaResponseToAidaCompletionResponse(response: GCA.GenerateContentResponse): AIDA.CompletionResponse {
+  const {samples, metadata} = gcaResponseToAidaSamplesAndMetadata(response);
+  return {
+    generatedSamples: samples,
+    metadata,
+  };
+}
+
+function gcaResponseToAidaSamplesAndMetadata(response: GCA.GenerateContentResponse): {
+  samples: AIDA.GenerationSample[],
+  metadata: AIDA.ResponseMetadata,
+} {
+  return {
+    samples: response.candidates.map(gcaCandidateToAidaGenerationSample),
+    metadata: {
+      rpcGlobalId: response.response_id,
+    },
+  };
+}
+
+export function aidaGenerateCodeRequestToGcaRequest(request: AIDA.GenerateCodeRequest): GCA.GenerateContentRequest {
+  const gcaRequest = createBaseGcaRequest(request, [convertAidaContentToGcaContent(request.current_message)]);
+
+  if (request.context_files) {
+    gcaRequest.aicode = {
+      experience: 'generate_code',
+      files: request.context_files.map(f => ({
+                                         file_uri: f.path,
+                                         programming_language: f.programming_language,
+                                       })),
+    };
+  }
+
+  return gcaRequest;
+}
+
+export function gcaResponseToAidaGenerateCodeResponse(response: GCA.GenerateContentResponse):
+    AIDA.GenerateCodeResponse {
+  return gcaResponseToAidaSamplesAndMetadata(response);
+}
+
+function gcaCandidateToAidaGenerationSample(candidate: GCA.Candidate): AIDA.GenerationSample {
+  const generationSample: AIDA.GenerationSample = {
+    generationString: extractTextFromGcaParts(candidate.content?.parts),
+    score: 0,
+    sampleId: candidate.index,
+  };
+  if (candidate.citation_metadata) {
+    generationSample.attributionMetadata = {
+      attributionAction: AIDA.RecitationAction.CITE,
+      citations: candidate.citation_metadata.citations.map(c => ({
+                                                             startIndex: c.start_index,
+                                                             endIndex: c.end_index,
+                                                             uri: c.uri,
+                                                           })),
+    };
+  }
+  return generationSample;
+}
+
+function convertAidaContentToGcaContent(content: AIDA.Content): GCA.Content {
+  // TODO(liviurau): decide how to map AIDA.Role.SYSTEM
+  // currently it will default to 'user'
+  let role: GCA.Role = 'user';
+
+  if (content.role === AIDA.Role.MODEL) {
+    role = 'model';
+  }
+  return {
+    role,
+    parts: content.parts.map(convertAidaPartToGcaPart),
+  };
+}
+
+function convertAidaPartToGcaPart(part: AIDA.Part): GCA.Part {
+  if ('text' in part) {
+    return {text: part.text};
+  }
+  if ('functionCall' in part) {
+    return {
+      function_call: {
+        name: part.functionCall.name,
+        args: part.functionCall.args,
+      },
+    };
+  }
+  if ('functionResponse' in part) {
+    const fResponse: Record<string, unknown> = {};
+    if ('result' in part.functionResponse.response) {
+      fResponse.output = part.functionResponse.response['result'];
+    } else if ('output' in part.functionResponse.response) {
+      fResponse.output = part.functionResponse.response['output'];
+    } else if (!('error' in part.functionResponse.response)) {
+      fResponse.output = part.functionResponse.response;
+    }
+    if ('error' in part.functionResponse.response) {
+      fResponse.error = part.functionResponse.response['error'];
+    }
+    return {
+      function_response: {
+        name: part.functionResponse.name,
+        response: fResponse,
+      },
+    };
+  }
+  if ('inlineData' in part) {
+    return {
+      inline_data: {
+        mime_type: part.inlineData.mimeType,
+        data: part.inlineData.data,
+      },
+    };
+  }
+  return {};
+}
+
+type FunctionParam<T extends string|number|symbol = string> =
+    AIDA.FunctionObjectParam<T>|AIDA.FunctionArrayParam|AIDA.FunctionPrimitiveParams;
+
+function convertAidaParamToGcaSchema<T extends string|number|symbol = string>(param: FunctionParam<T>): GCA.Schema {
+  const schema: GCA.Schema = {
+    type: param.type as unknown as GCA.Type,
+    description: param.description,
+  };
+  if (param.nullable) {
+    schema.nullable = param.nullable;
+  }
+
+  if (param.type === AIDA.ParametersTypes.ARRAY && param.items) {
+    schema.items = convertAidaParamToGcaSchema(param.items);
+  } else if (param.type === AIDA.ParametersTypes.OBJECT && param.properties) {
+    schema.properties = {};
+    for (const [key, value] of Object.entries(param.properties)) {
+      schema.properties[key] = convertAidaParamToGcaSchema(value as FunctionParam);
+    }
+    schema.required = param.required.map(r => r.toString());
+  }
+
+  return schema;
+}

package/front_end/core/host/GcaTypes.ts

@@ -203,9 +203,11 @@ export interface FileEdit {
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
+export type Role = 'user'|'model';
+
 export interface Content {
   parts?: Part[];
-  role: string;
+  role: Role;
 }
 
 /* eslint-disable @typescript-eslint/naming-convention */

package/front_end/core/host/InspectorFrontendHostStub.ts

@@ -389,11 +389,6 @@ export class InspectorFrontendHostStub implements InspectorFrontendHostAPI {
       devToolsVeLogging: {
         enabled: true,
       },
-      thirdPartyCookieControls: {
-        thirdPartyCookieMetadataEnabled: true,
-        thirdPartyCookieHeuristicsEnabled: true,
-        managedBlockThirdPartyCookies: 'Unset',
-      },
       devToolsFlexibleLayout: {
         verticalDrawerEnabled: true,
       },

package/front_end/core/host/UserMetrics.ts

@@ -823,8 +823,6 @@ export enum DevtoolsExperiments {
   'full-accessibility-tree' = 42,
   'experimental-cookie-features' = 45,
   'instrumentation-breakpoints' = 61,
-  'authored-deployed-grouping' = 63,
-  'just-my-code' = 65,
   'use-source-map-scopes' = 76,
   'timeline-debug-mode' = 93,
   'durable-messages' = 110,

package/front_end/core/host/host.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as AidaClient from './AidaClient.js';
+import * as AidaGcaTranslation from './AidaGcaTranslation.js';
 import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
 import * as GcaTypes from './GcaTypes.js';
 import * as GdpClient from './GdpClient.js';
@@ -14,6 +15,7 @@ import * as UserMetrics from './UserMetrics.js';
 
 export {
   AidaClient,
+  AidaGcaTranslation,
   DispatchHttpRequestClient,
   GcaTypes,
   GdpClient,

package/front_end/core/root/ExperimentNames.ts

@@ -16,8 +16,6 @@ export enum ExperimentName {
   FULL_ACCESSIBILITY_TREE = 'full-accessibility-tree',
   EXPERIMENTAL_COOKIE_FEATURES = 'experimental-cookie-features',
   INSTRUMENTATION_BREAKPOINTS = 'instrumentation-breakpoints',
-  AUTHORED_DEPLOYED_GROUPING = 'authored-deployed-grouping',
-  JUST_MY_CODE = 'just-my-code',
   USE_SOURCE_MAP_SCOPES = 'use-source-map-scopes',
   TIMELINE_DEBUG_MODE = 'timeline-debug-mode',
   DURABLE_MESSAGES = 'durable-messages',

package/front_end/core/root/Runtime.ts

@@ -542,13 +542,6 @@ export interface HostConfigJpegXlImageFormat {
   enabled: boolean;
 }
 
-export interface HostConfigThirdPartyCookieControls {
-  thirdPartyCookieRestrictionEnabled: boolean;
-  thirdPartyCookieMetadataEnabled: boolean;
-  thirdPartyCookieHeuristicsEnabled: boolean;
-  managedBlockThirdPartyCookies: string|boolean;
-}
-
 export interface HostConfigAiAssistanceV2 {
   enabled: boolean;
 }
@@ -651,7 +644,6 @@ export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
   devToolsEnableOriginBoundCookies: HostConfigEnableOriginBoundCookies,
   devToolsAnimationStylesInStylesTab: HostConfigAnimationStylesInStylesTab,
   devToolsJpegXlImageFormat: HostConfigJpegXlImageFormat,
-  thirdPartyCookieControls: HostConfigThirdPartyCookieControls,
   devToolsAiGeneratedTimelineLabels: AiGeneratedTimelineLabels,
   devToolsAllowPopoverForcing: AllowPopoverForcing,
   devToolsGlobalAiButton: GlobalAiButton,