feat(tokt): carry live transcriptions and turnComplete across the interop

tokt/src/main/kotlin/com/google/adk/tokt/codecs/EventCodec.kt

@@ -33,8 +33,9 @@ import kotlin.jvm.optionals.getOrNull
  * skipSummarization, endOfAgent - the requested tool confirmations, the context-compaction summary,
  * the resumable-run `agentState`, and the rewind marker `rewindBeforeInvocationId`), the
  * streaming/error signals (`partial`, `turnComplete`, `interrupted`, `errorMessage`, `errorCode`,
- * `finishReason`), the token `usageMetadata` ([UsageMetadataCodec]) and `groundingMetadata`
- * ([GroundingMetadataCodec]), long-running tool ids, and the timestamp.
+ * `finishReason`), the live transcriptions ([TranscriptionCodec]), the token `usageMetadata`
+ * ([UsageMetadataCodec]) and `groundingMetadata` ([GroundingMetadataCodec]), long-running tool ids,
+ * and the timestamp. Every other field is dropped.
  */
 internal object EventCodec {
 
@@ -54,6 +55,8 @@ internal object EventCodec {
     if (event.partial) builder.partial(true)
     if (event.turnComplete) builder.turnComplete(true)
     if (event.interrupted) builder.interrupted(true)
+    event.inputTranscription?.let { builder.inputTranscription(TranscriptionCodec.toJava(it)) }
+    event.outputTranscription?.let { builder.outputTranscription(TranscriptionCodec.toJava(it)) }
     event.errorMessage?.let { builder.errorMessage(it) }
     event.errorCode?.let { builder.errorCode(GenaiFinishReason(it)) }
     event.finishReason?.let { builder.finishReason(it.toGenai()) }
@@ -98,6 +101,10 @@ internal object EventCodec {
       partial = event.partial().getOrNull() ?: false,
       turnComplete = event.turnComplete().getOrNull() ?: false,
       interrupted = event.interrupted().getOrNull() ?: false,
+      inputTranscription =
+        event.inputTranscription().getOrNull()?.let { TranscriptionCodec.fromJava(it) },
+      outputTranscription =
+        event.outputTranscription().getOrNull()?.let { TranscriptionCodec.fromJava(it) },
       errorMessage = event.errorMessage().getOrNull(),
       // toString() preserves the raw value; knownEnum().name would collapse an unrecognized code to
       // FINISH_REASON_UNSPECIFIED (errorCode is a free-form String on the Kotlin side).

tokt/src/main/kotlin/com/google/adk/tokt/codecs/GroundingMetadataCodec.kt

@@ -49,7 +49,7 @@ internal object GroundingMetadataCodec {
   /** Returns the Kotlin [KtGroundingMetadata] view of the genai [metadata]. */
   fun fromJava(metadata: GenaiGroundingMetadata): KtGroundingMetadata =
     KtGroundingMetadata(
-      imageSearchQueries = metadata.imageSearchQueries().getOrNull().orEmpty(),
+      imageSearchQueries = metadata.imageSearchQueries().getOrNull(),
       groundingChunks = metadata.groundingChunks().getOrNull()?.map { chunkFromJava(it) },
       groundingSupports = metadata.groundingSupports().getOrNull()?.map { supportFromJava(it) },
       webSearchQueries = metadata.webSearchQueries().getOrNull(),
@@ -62,7 +62,8 @@ internal object GroundingMetadataCodec {
 
   /** Returns the genai [GenaiGroundingMetadata] view of the Kotlin [metadata]. */
   fun toJava(metadata: KtGroundingMetadata): GenaiGroundingMetadata {
-    val builder = GenaiGroundingMetadata.builder().imageSearchQueries(metadata.imageSearchQueries)
+    val builder = GenaiGroundingMetadata.builder()
+    metadata.imageSearchQueries?.let { builder.imageSearchQueries(it) }
     metadata.groundingChunks?.let { builder.groundingChunks(it.map { c -> chunkToJava(c) }) }
     metadata.groundingSupports?.let { builder.groundingSupports(it.map { s -> supportToJava(s) }) }
     metadata.webSearchQueries?.let { builder.webSearchQueries(it) }

tokt/src/main/kotlin/com/google/adk/tokt/codecs/LlmResponseCodec.kt

@@ -27,9 +27,9 @@ import kotlin.jvm.optionals.getOrNull
  * ([JavaModelToKt][com.google.adk.tokt.adapters.JavaModelToKt]); Kotlin to Java hands a response to
  * a bridged Java plugin's `afterModel`.
  *
- * Carries content, error message, streaming flags, model version, finish reason, usage metadata,
- * grounding metadata, average log-probs, error code, and custom metadata. Citation metadata and
- * logprobs results have no ADK Java facade field, so they are not mapped.
+ * Carries content, error message, streaming flags, `turnComplete`, the live transcriptions, model
+ * version, finish reason, usage metadata, grounding metadata, average log-probs, error code, and
+ * custom metadata. Every other field, such as citation metadata and logprobs results, is dropped.
  */
 internal object LlmResponseCodec {
 
@@ -40,6 +40,11 @@ internal object LlmResponseCodec {
       errorMessage = response.errorMessage().getOrNull(),
       partial = response.partial().getOrNull() ?: false,
       interrupted = response.interrupted().getOrNull() ?: false,
+      turnComplete = response.turnComplete().getOrNull(),
+      inputTranscription =
+        response.inputTranscription().getOrNull()?.let { TranscriptionCodec.fromJava(it) },
+      outputTranscription =
+        response.outputTranscription().getOrNull()?.let { TranscriptionCodec.fromJava(it) },
       modelVersion = response.modelVersion().getOrNull(),
       finishReason = response.finishReason().getOrNull()?.toKt(),
       usageMetadata = response.usageMetadata().getOrNull()?.let { UsageMetadataCodec.fromJava(it) },
@@ -58,6 +63,9 @@ internal object LlmResponseCodec {
     val builder =
       JavaLlmResponse.builder().partial(response.partial).interrupted(response.interrupted)
     response.content?.let { builder.content(ContentCodec.toJava(it)) }
+    response.turnComplete?.let { builder.turnComplete(it) }
+    response.inputTranscription?.let { builder.inputTranscription(TranscriptionCodec.toJava(it)) }
+    response.outputTranscription?.let { builder.outputTranscription(TranscriptionCodec.toJava(it)) }
     response.errorMessage?.let { builder.errorMessage(it) }
     response.modelVersion?.let { builder.modelVersion(it) }
     response.finishReason?.let { builder.finishReason(it.toGenai()) }

tokt/src/main/kotlin/com/google/adk/tokt/codecs/TranscriptionCodec.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.adk.tokt.codecs
+
+import com.google.adk.kt.types.Transcription as KtTranscription
+import com.google.adk.kt.types.WordInfo as KtWordInfo
+import com.google.genai.types.Transcription as GenaiTranscription
+import com.google.genai.types.WordInfo as GenaiWordInfo
+import kotlin.jvm.optionals.getOrNull
+
+/**
+ * Converts an audio transcription, with its per-word timings, between the ADK Kotlin
+ * [KtTranscription] and the genai [GenaiTranscription] that ADK Java events and LLM responses
+ * carry. The genai `startOffset` and `endOffset` have no ADK Kotlin field, so they are dropped.
+ */
+internal object TranscriptionCodec {
+
+  /** Returns the genai [GenaiTranscription] view of the Kotlin [transcription]. */
+  fun toJava(transcription: KtTranscription): GenaiTranscription {
+    val builder = GenaiTranscription.builder()
+    transcription.text?.let { builder.text(it) }
+    transcription.finished?.let { builder.finished(it) }
+    transcription.languageCode?.let { builder.languageCode(it) }
+    transcription.speakerLabel?.let { builder.speakerLabel(it) }
+    transcription.words?.let { words -> builder.words(words.map(::wordToJava)) }
+    return builder.build()
+  }
+
+  /** Returns the Kotlin [KtTranscription] view of the genai [transcription]. */
+  fun fromJava(transcription: GenaiTranscription): KtTranscription =
+    KtTranscription(
+      text = transcription.text().getOrNull(),
+      finished = transcription.finished().getOrNull(),
+      languageCode = transcription.languageCode().getOrNull(),
+      speakerLabel = transcription.speakerLabel().getOrNull(),
+      words = transcription.words().getOrNull()?.map(::wordFromJava),
+    )
+
+  private fun wordToJava(word: KtWordInfo): GenaiWordInfo {
+    val builder = GenaiWordInfo.builder()
+    word.word?.let { builder.word(it) }
+    word.startOffset?.let { builder.startOffset(it) }
+    word.endOffset?.let { builder.endOffset(it) }
+    return builder.build()
+  }
+
+  private fun wordFromJava(word: GenaiWordInfo): KtWordInfo =
+    KtWordInfo(
+      word = word.word().getOrNull(),
+      startOffset = word.startOffset().getOrNull(),
+      endOffset = word.endOffset().getOrNull(),
+    )
+}