[AiAgent] Include explanation in function call history entry

When the model provides both a text explanation and a function call
in the same response, ensure both are added to the conversation history
as a single message with multiple parts.

Previously, the explanation was treated as a standalone answer which
caused the explanation from the function calls to be not included
in the history.

This CL:

* Modifies AiAgent.ts to avoid pushing a separate text-only history
entry when a function call is also present.
* Passes the explanation text to `#callFunction`.
* Updates #callFunction to combine the explanation (if present) and
the function call into a single multi-part history entry.
* Adds a unit test in AiAgent.test.ts to verify that the history is
correctly constructed with both the explanation and the function call.

Fixed: 464443653
Change-Id: I2b8e47eb2be7329efe78cd10a0c6b873123f6f23
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7209254
Reviewed-by: Alex Rudenko <alexrudenko@chromium.org>
Auto-Submit: Ergün Erdoğmuş <ergunsh@chromium.org>
Commit-Queue: Nikolay Vitkov <nvitkov@chromium.org>
Reviewed-by: Nikolay Vitkov <nvitkov@chromium.org>

Author: ergunsh

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

@@ -473,5 +473,46 @@ describeWithEnvironment('AiAgent', () => {
           }],
       );
     });
+
+    it('should add explanation to history when function call is present', async () => {
+      const agent = new AgentWithFunction({
+        aidaClient: mockAidaClient([
+          [
+            {
+              explanation: 'This is the explanation',
+              functionCalls: [{
+                name: 'testFn',
+                args: {arg: 'test'},
+              }],
+            },
+          ],
+          [{
+            explanation: 'Final answer',
+          }]
+        ]),
+      });
+
+      await Array.fromAsync(agent.run('query', {selected: mockConversationContext()}));
+
+      const request = agent.buildRequest({text: 'test input'}, Host.AidaClient.Role.USER);
+      // History should contain:
+      // 1. User query
+      // 2. Model explanation + function call
+      // 3. Function result (user role)
+      // 4. Model final answer
+      assert.lengthOf(request.historical_contexts ?? [], 4);
+      assert.deepEqual(request.historical_contexts?.[1], {
+        role: Host.AidaClient.Role.MODEL,
+        parts: [
+          {text: 'This is the explanation'},
+          {
+            functionCall: {
+              name: 'testFn',
+              args: {arg: 'test'},
+            },
+          },
+        ],
+      });
+    });
   });
 });

front_end/models/ai_assistance/agents/AiAgent.ts

@@ -573,12 +573,14 @@ export abstract class AiAgent<T> {
         if (!('answer' in parsedResponse)) {
           throw new Error('Expected a completed response to have an answer');
         }
-        this.#history.push({
-          parts: [{
-            text: parsedResponse.answer,
-          }],
-          role: Host.AidaClient.Role.MODEL,
-        });
+        if (!functionCall) {
+          this.#history.push({
+            parts: [{
+              text: parsedResponse.answer,
+            }],
+            role: Host.AidaClient.Role.MODEL,
+          });
+        }
         Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceAnswerReceived);
         yield {
           type: ResponseType.ANSWER,
@@ -587,12 +589,17 @@ export abstract class AiAgent<T> {
           complete: true,
           rpcId,
         };
-        break;
+        if (!functionCall) {
+          break;
+        }
       }
 
       if (functionCall) {
         try {
-          const result = yield* this.#callFunction(functionCall.name, functionCall.args, options);
+          const result = yield* this.#callFunction(functionCall.name, functionCall.args, {
+            ...options,
+            explanation: textResponse,
+          });
           if (options.signal?.aborted) {
             yield this.#createErrorResponse(ErrorType.ABORT);
             break;
@@ -623,19 +630,26 @@ export abstract class AiAgent<T> {
       #callFunction(
           name: string,
           args: Record<string, unknown>,
-          options?: FunctionHandlerOptions,
+          options?: FunctionHandlerOptions&{explanation?: string},
           ): AsyncGenerator<FunctionCallResponseData, {result: unknown}> {
     const call = this.#functionDeclarations.get(name);
     if (!call) {
       throw new Error(`Function ${name} is not found.`);
     }
+    const parts: Host.AidaClient.Part[] = [];
+    if (options?.explanation) {
+      parts.push({
+        text: options.explanation,
+      });
+    }
+    parts.push({
+      functionCall: {
+        name,
+        args,
+      },
+    });
     this.#history.push({
-      parts: [{
-        functionCall: {
-          name,
-          args,
-        },
-      }],
+      parts,
       role: Host.AidaClient.Role.MODEL,
     });
 
@@ -744,6 +758,7 @@ export abstract class AiAgent<T> {
           rpcId,
           functionCall: aidaResponse.functionCalls[0],
           completed: true,
+          text: aidaResponse.explanation,
         };
         break;
       }

front_end/models/ai_assistance/agents/StylingAgent.snapshot.txt

@@ -398,6 +398,11 @@ Content:
   {
     "type": "querying"
   },
+  {
+    "type": "answer",
+    "text": "this is my text before the actual answer",
+    "complete": true
+  },
   {
     "type": "thought",
     "thought": "I am thinking."

front_end/models/ai_assistance/agents/StylingAgent.test.ts

@@ -530,7 +530,7 @@ describeWithEnvironment('StylingAgent', function() {
               name: 'executeJavaScript',
               args: {thought: 'I am thinking.', code: 'console.log(\'hello\');'},
             }],
-            explanation: 'this is the answer',
+            explanation: 'this is my text before the actual answer',
           }],
           [{
             explanation: 'this is the actual answer',