chrome-devtools-frontend 1.0.1603822 → 1.0.1605219

package/front_end/core/host/AidaGcaTranslation.ts

@@ -2,18 +2,19 @@
 // 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 AIDA from './AidaClientTypes.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};
+function createBaseGcaRequest(
+    request: AidaRequest, contents: GCA.Content[], experience: string): GCA.GenerateContentRequest {
+  const gcaRequest: GCA.GenerateContentRequest = {contents, aicode: {experience}};
   mapCommonAidaRequestFields(request, gcaRequest);
   buildLabels(request, gcaRequest);
 
   if ('preamble' in request && request.preamble) {
-    gcaRequest.system_instruction = {
+    gcaRequest.systemInstruction = {
       role: 'user',
       parts: [{text: request.preamble}],
     };
@@ -23,38 +24,41 @@ function createBaseGcaRequest(request: AidaRequest, contents: GCA.Content[]): GC
 }
 
 export function aidaDoConversationRequestToGcaRequest(request: AIDA.DoConversationRequest): GCA.GenerateContentRequest {
-  const contents: GCA.Content[] = [];
+  try {
+    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),
-                                                               })),
-    }];
+    if (request.historical_contexts) {
+      contents.push(...(request.historical_contexts).map(convertAidaContentToGcaContent));
+    }
+    contents.push(convertAidaContentToGcaContent(request.current_message));
+
+    const gcaRequest = createBaseGcaRequest(request, contents, 'chat_console_insights');
+
+    if (request.function_declarations) {
+      gcaRequest.tools = [{
+        functionDeclarations:
+            (request.function_declarations).map(fd => ({
+                                                  name: fd.name,
+                                                  description: fd.description,
+                                                  parameters: convertAidaParamToGcaSchema(fd.parameters),
+                                                })),
+      }];
+    }
+    AIDA.debugLog('Translation succeded:', JSON.stringify(request), JSON.stringify(gcaRequest));
+    return gcaRequest;
+  } catch (e) {
+    AIDA.debugLog('Translation error:', JSON.stringify(request), e);
+    throw e;
   }
-
-  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,
+    gcaRequest.generationConfig = {
+      ...gcaRequest.generationConfig,
       temperature: aidaRequest.options.temperature,
     };
   }
@@ -62,24 +66,23 @@ function mapCommonAidaRequestFields(aidaRequest: AidaRequest, gcaRequest: GCA.Ge
 
 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) {
+  if (response.candidates?.[0].content?.parts) {
+    for (const part of response.candidates[0].content.parts) {
+      if (part.functionCall) {
         functionCalls.push({
-          name: part.function_call.name,
-          args: part.function_call.args || {},
+          name: part.functionCall.name,
+          args: part.functionCall.args || {},
         });
       }
     }
   }
 
   return {
-    explanation: extractTextFromGcaParts(candidate?.content?.parts),
+    explanation: extractTextFromGcaParts(response.candidates[0].content?.parts),
     metadata: {
-      rpcGlobalId: response.response_id,
+      rpcGlobalId: response.responseId,
     },
     functionCalls: functionCalls.length > 0 ?
         (functionCalls as [AIDA.AidaFunctionCallResponse, ...AIDA.AidaFunctionCallResponse[]]) :
@@ -96,33 +99,41 @@ function extractTextFromGcaParts(parts: GCA.Part[]|undefined): string {
 }
 
 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;
+  try {
+    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({
+          eventTime,
+          responseId,
+          suggestionInteraction: {interaction},
+        });
       }
-      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};
+    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));
+    const gcaTelemetryRequest: GCA.SendTelemetryRequest = {
+      feedbackMetrics,
+    };
+    AIDA.debugLog('Translation succeeded:', JSON.stringify(clientEvent), JSON.stringify(gcaTelemetryRequest));
+    return gcaTelemetryRequest;
+  } catch (e) {
+    AIDA.debugLog('Translation error:', JSON.stringify(clientEvent), e);
+    throw e;
+  }
 }
 
 /* eslint-disable @typescript-eslint/naming-convention */
@@ -135,23 +146,23 @@ function convertCodeTelemetry(
   if ('user_impression' in event && event.user_impression) {
     const impression = event.user_impression;
     return [{
-      event_time: eventTime,
-      response_id: responseId,
-      suggestion_offered: {
+      eventTime,
+      responseId,
+      suggestionOffered: {
         method,
         status: GCA.SuggestionStatus.NO_ERROR,
-        response_latency: `${impression.latency.duration.seconds + impression.latency.duration.nanos / 1e9}s`,
+        responseLatency: `${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: {
+      eventTime,
+      responseId,
+      suggestionInteraction: {
         interaction: GCA.InteractionType.ACCEPT,
-        candidate_index: acceptance.sample.sample_id,
+        candidateIndex: acceptance.sample.sample_id,
       },
     }];
   }
@@ -160,33 +171,56 @@ function convertCodeTelemetry(
 /* 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);
+  try {
+    let additionalFiles: GCA.SourceFile[] =
+        (request.additional_files ?? []).map(f => ({
+                                               fileUri: f.path,
+                                               inclusionReason: [AidaReasonToGcaInclusionReason[f.included_reason]],
+                                             }));
+
+    const inEditorFile: GCA.SourceFile = inFileEditRequestToSourceFile(request);
+    if (inEditorFile) {
+      additionalFiles = [inEditorFile, ...additionalFiles];
+    }
 
-  if (request.options?.stop_sequences) {
-    gcaRequest.generation_config = {
-      ...gcaRequest.generation_config,
-      stop_sequences: request.options.stop_sequences,
-    };
+    const gcaRequest = createBaseGcaRequest(request, [], 'complete_code');
+    gcaRequest.aicode.files = additionalFiles;
+    if (request.options?.stop_sequences) {
+      gcaRequest.generationConfig = {
+        ...gcaRequest.generationConfig,
+        stopSequences: request.options.stop_sequences,
+      };
+    }
+    AIDA.debugLog('Translation succeeded:', JSON.stringify(request), JSON.stringify(gcaRequest));
+    return gcaRequest;
+  } catch (e) {
+    AIDA.debugLog('Translation error:', JSON.stringify(request), e);
+    throw e;
   }
+}
 
-  if (request.additional_files) {
-    gcaRequest.aicode = {
-      experience: 'completion',
-      files: request.additional_files.map(f => ({
-                                            file_uri: f.path,
-                                            inclusion_reason: [AidaReasonToGcaInclusionReason[f.included_reason]],
-                                          })),
-    };
+function inFileEditRequestToSourceFile(request: AIDA.CompletionRequest): GCA.SourceFile {
+  const sourceFile: GCA.SourceFile = {
+    inclusionReason: [GCA.InclusionReason.ACTIVE],
+    fileUri: 'devtools-code-completion',
+    segments: [
+      {
+        content: request.prefix,
+        isSelected: false,
+      },
+      {
+        content: '',
+        isSelected: true,  // Cursor position
+      }
+    ],
+  };
+  if (request.suffix) {
+    sourceFile.segments?.push({
+      content: request.suffix,
+      isSelected: false,
+    });
   }
-
-  return gcaRequest;
+  return sourceFile;
 }
 
 /* eslint-disable @typescript-eslint/naming-convention */
@@ -207,6 +241,9 @@ function buildLabels(request: AidaRequest, gcaRequest: GCA.GenerateContentReques
   if ('use_case' in request && request.use_case !== undefined) {
     labels['use_case'] = AIDA.UseCase[request.use_case];
   }
+  if (request.metadata.string_session_id) {
+    labels['session_id'] = request.metadata.string_session_id;
+  }
   const options = request.options as {
     inference_language?: string,
     expect_code_output?: boolean,
@@ -217,6 +254,12 @@ function buildLabels(request: AidaRequest, gcaRequest: GCA.GenerateContentReques
   if (options?.expect_code_output !== undefined) {
     labels['expect_code_output'] = String(options.expect_code_output);
   }
+  if (request.metadata.disable_user_content_logging !== undefined) {
+    labels['disable_user_content_logging'] = String(request.metadata.disable_user_content_logging);
+  }
+  if (request.metadata.client_version) {
+    labels['client_version'] = request.metadata.client_version;
+  }
 
   if (Object.keys(labels).length > 0) {
     gcaRequest.labels = labels;
@@ -236,11 +279,18 @@ const AidaReasonToGcaInclusionReason: Record<AIDA.Reason, GCA.InclusionReason> =
 };
 
 export function gcaResponseToAidaCompletionResponse(response: GCA.GenerateContentResponse): AIDA.CompletionResponse {
-  const {samples, metadata} = gcaResponseToAidaSamplesAndMetadata(response);
-  return {
-    generatedSamples: samples,
-    metadata,
-  };
+  try {
+    const {samples, metadata} = gcaResponseToAidaSamplesAndMetadata(response);
+    const aidaResponse: AIDA.CompletionResponse = {
+      generatedSamples: samples,
+      metadata,
+    };
+    AIDA.debugLog('Translation succeeded:', JSON.stringify(response), JSON.stringify(aidaResponse));
+    return aidaResponse;
+  } catch (e) {
+    AIDA.debugLog('Translation error', JSON.stringify(response), e);
+    throw e;
+  }
 }
 
 function gcaResponseToAidaSamplesAndMetadata(response: GCA.GenerateContentResponse): {
@@ -248,32 +298,41 @@ function gcaResponseToAidaSamplesAndMetadata(response: GCA.GenerateContentRespon
   metadata: AIDA.ResponseMetadata,
 } {
   return {
-    samples: response.candidates.map(gcaCandidateToAidaGenerationSample),
+    samples: (response.candidates ?? []).map(gcaCandidateToAidaGenerationSample),
     metadata: {
-      rpcGlobalId: response.response_id,
+      rpcGlobalId: response.responseId,
     },
   };
 }
 
 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,
-                                       })),
-    };
+  try {
+    const gcaRequest =
+        createBaseGcaRequest(request, [convertAidaContentToGcaContent(request.current_message)], 'generate_code');
+    if (request.context_files) {
+      gcaRequest.aicode.files = (request.context_files).map(f => ({
+                                                              fileUri: f.path,
+                                                              programmingLanguage: f.programming_language,
+                                                            }));
+    }
+    AIDA.debugLog('Translation succeeded:', JSON.stringify(request), JSON.stringify(gcaRequest));
+    return gcaRequest;
+  } catch (e) {
+    AIDA.debugLog('Translation error', JSON.stringify(request), e);
+    throw e;
   }
-
-  return gcaRequest;
 }
 
 export function gcaResponseToAidaGenerateCodeResponse(response: GCA.GenerateContentResponse):
     AIDA.GenerateCodeResponse {
-  return gcaResponseToAidaSamplesAndMetadata(response);
+  try {
+    const aidaResponse: AIDA.GenerateCodeResponse = gcaResponseToAidaSamplesAndMetadata(response);
+    AIDA.debugLog('Translation succeeded:', JSON.stringify(response), JSON.stringify(aidaResponse));
+    return aidaResponse;
+  } catch (e) {
+    AIDA.debugLog('translation error', JSON.stringify(response), e);
+    throw e;
+  }
 }
 
 function gcaCandidateToAidaGenerationSample(candidate: GCA.Candidate): AIDA.GenerationSample {
@@ -282,14 +341,14 @@ function gcaCandidateToAidaGenerationSample(candidate: GCA.Candidate): AIDA.Gene
     score: 0,
     sampleId: candidate.index,
   };
-  if (candidate.citation_metadata) {
+  if (candidate.citationMetadata) {
     generationSample.attributionMetadata = {
       attributionAction: AIDA.RecitationAction.CITE,
-      citations: candidate.citation_metadata.citations.map(c => ({
-                                                             startIndex: c.start_index,
-                                                             endIndex: c.end_index,
-                                                             uri: c.uri,
-                                                           })),
+      citations: (candidate.citationMetadata.citations ?? []).map(c => ({
+                                                                    startIndex: c.startIndex,
+                                                                    endIndex: c.endIndex,
+                                                                    uri: c.uri,
+                                                                  })),
     };
   }
   return generationSample;
@@ -305,7 +364,7 @@ function convertAidaContentToGcaContent(content: AIDA.Content): GCA.Content {
   }
   return {
     role,
-    parts: content.parts.map(convertAidaPartToGcaPart),
+    parts: (content.parts ?? []).map(convertAidaPartToGcaPart),
   };
 }
 
@@ -315,7 +374,7 @@ function convertAidaPartToGcaPart(part: AIDA.Part): GCA.Part {
   }
   if ('functionCall' in part) {
     return {
-      function_call: {
+      functionCall: {
         name: part.functionCall.name,
         args: part.functionCall.args,
       },
@@ -334,7 +393,7 @@ function convertAidaPartToGcaPart(part: AIDA.Part): GCA.Part {
       fResponse.error = part.functionResponse.response['error'];
     }
     return {
-      function_response: {
+      functionResponse: {
         name: part.functionResponse.name,
         response: fResponse,
       },
@@ -342,8 +401,8 @@ function convertAidaPartToGcaPart(part: AIDA.Part): GCA.Part {
   }
   if ('inlineData' in part) {
     return {
-      inline_data: {
-        mime_type: part.inlineData.mimeType,
+      inlineData: {
+        mimeType: part.inlineData.mimeType,
         data: part.inlineData.data,
       },
     };
@@ -370,8 +429,58 @@ function convertAidaParamToGcaSchema<T extends string|number|symbol = string>(pa
     for (const [key, value] of Object.entries(param.properties)) {
       schema.properties[key] = convertAidaParamToGcaSchema(value as FunctionParam);
     }
-    schema.required = param.required.map(r => r.toString());
+    schema.required = (param.required ?? []).map(r => r.toString());
   }
 
   return schema;
 }
+
+export function gcaChunkResponseToAidaChunkResponse(response: GCA.GenerateContentResponse): AIDA.AidaChunkResponse[] {
+  try {
+    const candidate = response.candidates?.[0];
+    const parts = candidate?.content?.parts || [];
+    const metadata: AIDA.ResponseMetadata = {
+      rpcGlobalId: response.responseId,
+    };
+
+    if (candidate?.citationMetadata?.citations) {
+      metadata.attributionMetadata = {
+        attributionAction: AIDA.RecitationAction.CITE,
+        citations: candidate.citationMetadata.citations.map(c => ({
+                                                              startIndex: c.startIndex,
+                                                              endIndex: c.endIndex,
+                                                              uri: c.uri,
+                                                            })),
+      };
+    }
+    const chunks: AIDA.AidaChunkResponse[] = (parts).map(part => {
+      const aidaChunkResponse: AIDA.AidaChunkResponse = {metadata};
+      if (part.text) {
+        aidaChunkResponse.textChunk = {
+          text: extractTextFromGcaParts(parts),
+        };
+      }
+      if (part.functionCall) {
+        aidaChunkResponse.functionCallChunk = {
+          functionCall: {
+            name: part.functionCall.name,
+            args: part.functionCall.args || {},
+          },
+        };
+      }
+      if (part.executableCode) {
+        aidaChunkResponse.codeChunk = {
+          code: part.executableCode.code,
+          inferenceLanguage: part.executableCode.language ? AIDA.AidaInferenceLanguage.PYTHON :
+                                                            AIDA.AidaInferenceLanguage.UNKNOWN,
+        };
+      }
+      return aidaChunkResponse;
+    });
+    AIDA.debugLog('Translation succeeded:', JSON.stringify(response), JSON.stringify(chunks));
+    return chunks;
+  } catch (e) {
+    AIDA.debugLog('Translation error', JSON.stringify(response), e);
+    throw e;
+  }
+}

package/front_end/core/host/GcaClient.ts

@@ -0,0 +1,112 @@
+// 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 Root from '../root/root.js';
+
+import {
+  type AidaRegisterClientEvent,
+  type CompletionRequest,
+  type CompletionResponse,
+  debugLog,
+  type DoConversationRequest,
+  type GenerateCodeRequest,
+  type GenerateCodeResponse
+} from './AidaClientTypes.js';
+import {
+  aidaCompletionRequestToGcaRequest,
+  aidaDoConversationRequestToGcaRequest,
+  aidaEventToGcaTelemetryRequest,
+  aidaGenerateCodeRequestToGcaRequest,
+  gcaResponseToAidaCompletionResponse,
+  gcaResponseToAidaGenerateCodeResponse
+} from './AidaGcaTranslation.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+import type {GenerateContentRequest, GenerateContentResponse} from './GcaTypes.js';
+import type {AidaClientResult} from './InspectorFrontendHostAPI.js';
+
+const SERVICE_NAME = 'gcaService';
+
+const ENDPOINTS = {
+  CONTENT: '/v1beta:generateContent',
+  SEND_TELEMETRY: '/v1beta:sendTelemetry',
+  STREAM_CONTENT: '/v1beta:streamGenerateContent',
+};
+
+export class GcaClient {
+  enabled(): boolean|undefined {
+    return Root.Runtime.hostConfig.devToolsUseGcaApi?.enabled;
+  }
+
+  async conversationRequest(request: DoConversationRequest, streamId: number, options?: {signal?: AbortSignal}):
+      Promise<void> {
+    try {
+      const gcaRequest = aidaDoConversationRequestToGcaRequest(request);
+      const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateContentResponse>(
+          {
+            service: SERVICE_NAME,
+            path: ENDPOINTS.STREAM_CONTENT,
+            method: 'POST',
+            body: JSON.stringify(gcaRequest),
+            streamId,
+          },
+          options);
+      debugLog('GCA conversation request succeeded:', JSON.stringify(request), JSON.stringify(response));
+    } catch (err) {
+      debugLog('GCA request failed:', JSON.stringify(request), err);
+      throw err;
+    }
+  }
+
+  registerClientEvent(clientEvent: AidaRegisterClientEvent): Promise<AidaClientResult> {
+    const gcaEvent = aidaEventToGcaTelemetryRequest(clientEvent);
+    const response = DispatchHttpRequestClient.makeHttpRequest({
+      service: SERVICE_NAME,
+      path: ENDPOINTS.SEND_TELEMETRY,
+      method: 'POST',
+      body: JSON.stringify(gcaEvent),
+    });
+    return response.then(
+        result => {
+          debugLog('GCA register event succeeded:', JSON.stringify(gcaEvent), JSON.stringify(result));
+          return {} as AidaClientResult;
+        },
+        err => {
+          debugLog('GCA register event failed:', JSON.stringify(gcaEvent), err);
+          return {error: JSON.stringify(err)} as AidaClientResult;
+        });
+  }
+
+  async completeCode(request: CompletionRequest): Promise<CompletionResponse|null> {
+    const gcaRequest = aidaCompletionRequestToGcaRequest(request);
+    const result = await this.#requestContent(gcaRequest);
+    const aidaResult = result ? gcaResponseToAidaCompletionResponse(result) : null;
+    return aidaResult;
+  }
+
+  async generateCode(request: GenerateCodeRequest, options?: {signal?: AbortSignal}):
+      Promise<GenerateCodeResponse|null> {
+    const gcaRequest = aidaGenerateCodeRequestToGcaRequest(request);
+    const result = await this.#requestContent(gcaRequest, options);
+    return result ? gcaResponseToAidaGenerateCodeResponse(result) : null;
+  }
+
+  async #requestContent(request: GenerateContentRequest, options?: {signal?: AbortSignal}):
+      Promise<GenerateContentResponse|null> {
+    try {
+      const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateContentResponse>(
+          {
+            service: SERVICE_NAME,
+            path: ENDPOINTS.CONTENT,
+            method: 'POST',
+            body: JSON.stringify(request),
+          },
+          options);
+      debugLog('GCA request succeeded:', JSON.stringify(request), JSON.stringify(response));
+      return response;
+    } catch (err) {
+      debugLog('GCA request failed:', JSON.stringify(request), err);
+      return null;
+    }
+  }
+}