revert: keep one generated id per streamed function call

PiperOrigin-RevId: 990259405

Author: Mateusz Krawiec

core/src/commonMain/kotlin/com/google/adk/kt/models/StreamingResponseAggregator.kt

@@ -83,22 +83,23 @@ class StreamingResponseAggregator {
     response.finishReason?.let { finishReason = it }
     response.errorMessage?.let { errorMessage = it }
 
-    val parts =
-      response.content?.parts.orEmpty().map { part ->
-        when {
-          !part.text.isNullOrEmpty() -> part.also { processTextPart(it) }
-          part.functionCall != null -> processFunctionCallPart(part)
-          // An empty text part that carries something else falls through to survive on its own;
-          // one carrying nothing at all just ends a Gemini 3 stream and is dropped.
-          part.isStreamTerminator() -> part
-          else -> {
-            // Other non-text parts (blobs, etc.)
-            flushTextBufferToSequence()
-            partsSequence.add(part)
-            part
-          }
+    // Assign a client id to any function call missing one up front, so the partial chunk and the
+    // final response share it.
+    val parts = (response.content?.parts ?: emptyList()).map { it.ensureFunctionCallId() }
+    for (part in parts) {
+      when {
+        !part.text.isNullOrEmpty() -> processTextPart(part)
+        part.functionCall != null -> processFunctionCallPart(part)
+        // An empty text part that carries something else falls through to survive on its own; one
+        // carrying nothing at all just ends a Gemini 3 stream and is dropped.
+        part.isStreamTerminator() -> {}
+        else -> {
+          // Other non-text parts (blobs, etc.)
+          flushTextBufferToSequence()
+          partsSequence.add(part)
         }
       }
+    }
 
     // In Progressive SSE mode, all intermediate chunks are partial (with any generated ids).
     response.copy(content = response.content?.copy(parts = parts), partial = true)
@@ -173,15 +174,14 @@ class StreamingResponseAggregator {
     currentTextBuffer.append(part.text)
   }
 
-  /** Returns this call, or a copy with a generated client id if it has none. */
-  private fun FunctionCall.ensureId(): FunctionCall =
-    if (id.isNullOrEmpty()) copy(id = FunctionCall.generateId()) else this
+  /** Returns a copy with a generated client id if this is a function call missing one. */
+  private fun Part.ensureFunctionCallId(): Part {
+    val fc = functionCall ?: return this
+    if (!fc.id.isNullOrEmpty()) return this
+    return copy(functionCall = fc.copy(id = FunctionCall.generateId()))
+  }
 
-  /**
-   * Aggregates a function call part and returns it with any generated id. A streamed call gets its
-   * id on its first chunk, so that chunk and the final response share it.
-   */
-  private fun processFunctionCallPart(part: Part): Part {
+  private fun processFunctionCallPart(part: Part) {
     val fc =
       part.functionCall
         ?: throw IllegalStateException(
@@ -197,30 +197,25 @@ class StreamingResponseAggregator {
         fc.willContinue == true ||
         (currentFcName != null && !hasName)
     if (streamedPart) {
-      val call = if (currentFcId == null) fc.ensureId() else fc
       if (part.thoughtSignature?.isNotEmpty() == true && currentThoughtSignature == null) {
         currentThoughtSignature = part.thoughtSignature
       }
-      processStreamingFunctionCall(call)
-      return part.copy(functionCall = call)
+      processStreamingFunctionCall(fc)
     } else if (hasName) {
-      val withId = part.copy(functionCall = fc.ensureId())
       // Non-streaming call. Safety guard: the model should terminate a streamed call with
       // willContinue=false before starting a new one; flush any still-in-progress call so it is
       // neither dropped nor merged.
       flushTextBufferToSequence()
       flushFunctionCallToSequence()
-      partsSequence.add(withId)
-      return withId
+      partsSequence.add(part)
     }
-    return part
   }
 
   private fun processStreamingFunctionCall(fc: FunctionCall) {
     if (fc.name.isNotEmpty()) {
       currentFcName = fc.name
     }
-    if (!fc.id.isNullOrEmpty()) {
+    if (fc.id != null) {
       currentFcId = fc.id
     }
 

core/src/commonTest/kotlin/com/google/adk/kt/models/StreamingResponseAggregatorTest.kt

@@ -31,7 +31,6 @@ import com.google.adk.kt.types.ToolType
 import com.google.adk.kt.types.UsageMetadata
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 import kotlinx.coroutines.Dispatchers
@@ -108,100 +107,6 @@ class StreamingResponseAggregatorTest {
     assertEquals("San Francisco", fc.args["location"])
   }
 
-  @Test
-  fun testStreamingFunctionCall_partialAndFinalResponseShareGeneratedId() = runBlocking {
-    val aggregator = StreamingResponseAggregator()
-
-    val partial1 =
-      aggregator.processResponse(
-        createFcResp(createPartialFc("my_tool", "$.x", "hello", willContinue = true))
-      )
-    val unused =
-      aggregator.processResponse(
-        createFcResp(createPartialFc(null, "$.x", " world", willContinue = false))
-      )
-    val finalResp = aggregator.aggregate()
-
-    val finalFc = finalResp?.content?.parts?.single()?.functionCall
-    assertNotNull(finalFc)
-    assertEquals(mapOf("x" to "hello world"), finalFc.args)
-    val finalId = assertNotNull(finalFc.id)
-    assertTrue(finalId.startsWith(FunctionCall.ADK_FUNCTION_CALL_ID_PREFIX))
-    assertEquals(finalId, partial1.content?.parts?.single()?.functionCall?.id)
-  }
-
-  @Test
-  fun testStreamedCall_continuationChunkWithEmptyId_keepsFirstChunkId() = runBlocking {
-    val aggregator = StreamingResponseAggregator()
-
-    val partial1 =
-      aggregator.processResponse(
-        createFcResp(createPartialFc("my_tool", "$.x", "hello", willContinue = true))
-      )
-    val unused =
-      aggregator.processResponse(
-        createFcResp(createPartialFc(null, "$.x", " world", willContinue = false).copy(id = ""))
-      )
-    val finalResp = aggregator.aggregate()
-
-    val firstId = assertNotNull(partial1.content?.parts?.single()?.functionCall?.id)
-    assertEquals(firstId, finalResp?.content?.parts?.single()?.functionCall?.id)
-  }
-
-  @Test
-  fun testStreamingFunctionCalls_inSeparateChunks_getDifferentIds() = runBlocking {
-    val aggregator = StreamingResponseAggregator()
-
-    val unused1 =
-      aggregator.processResponse(
-        createFcResp(createPartialFc("tool_a", "$.a", "val_a", willContinue = false))
-      )
-    val unused2 =
-      aggregator.processResponse(
-        createFcResp(createPartialFc("tool_b", "$.b", "val_b", willContinue = false))
-      )
-    val finalResp = aggregator.aggregate()
-
-    val ids = finalResp?.content?.parts?.map { it.functionCall?.id }
-    assertNotNull(ids)
-    assertEquals(2, ids.size)
-    assertTrue(ids.all { it != null && it.startsWith(FunctionCall.ADK_FUNCTION_CALL_ID_PREFIX) })
-    assertNotEquals(ids[0], ids[1])
-  }
-
-  @Test
-  fun testStreamedCallEndAndNewSameNameCall_inOneChunk_getDifferentIds() = runBlocking {
-    val aggregator = StreamingResponseAggregator()
-
-    val partial1 =
-      aggregator.processResponse(
-        createFcResp(createPartialFc("get_weather", "$.city", "SF", willContinue = true))
-      )
-    val unused =
-      aggregator.processResponse(
-        LlmResponse(
-          content =
-            Content(
-              parts =
-                listOf(
-                  Part(functionCall = FunctionCall(willContinue = false)),
-                  Part(
-                    functionCall = FunctionCall(name = "get_weather", args = mapOf("city" to "NY"))
-                  ),
-                )
-            )
-        )
-      )
-    val finalResp = aggregator.aggregate()
-
-    val calls = finalResp?.content?.parts?.mapNotNull { it.functionCall }
-    assertNotNull(calls)
-    assertEquals(listOf("SF", "NY"), calls.map { it.args["city"] })
-    assertEquals(partial1.content?.parts?.single()?.functionCall?.id, calls[0].id)
-    assertNotNull(calls[1].id)
-    assertNotEquals(calls[0].id, calls[1].id)
-  }
-
   @Test
   fun testNestedPartialFunctionCallAggregation() = runBlocking {
     val aggregator = StreamingResponseAggregator()