From 496fd6dde09b194d60fc08fa9c6b38f6d16755cc Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Wed, 8 Oct 2025 15:23:52 -0500
Subject: [PATCH 01/15] Fix minor bug in nanosecond conversion

---
 FirebaseAI/CHANGELOG.md                       |  4 +++
 .../Types/Internal/ProtoDuration.swift        | 36 ++++++++++++++++++-
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/FirebaseAI/CHANGELOG.md b/FirebaseAI/CHANGELOG.md
index 06f5f30908d..c32f89d1183 100644
--- a/FirebaseAI/CHANGELOG.md
+++ b/FirebaseAI/CHANGELOG.md
@@ -1,3 +1,7 @@
+# Unreleased
+- [fixed] Fixed minor translation issue for nanosecond conversion when receiving
+  `LiveServerGoingAwayNotice`. (#????) 
+
 # 12.4.0
 - [feature] Added support for the URL context tool, which allows the model to access content
   from provided public web URLs to inform and enhance its responses. (#15221)
diff --git a/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift b/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
index 1dac21d6429..b55075747b8 100644
--- a/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
+++ b/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
@@ -107,6 +107,40 @@ extension ProtoDuration: Decodable {
     }
 
     self.seconds = secs
-    self.nanos = nanos
+    self.nanos = fractionalSecondsToNanoseconds(nanos, digits: nanoseconds.count)
   }
 }
+
+/// Cached powers of 10 for quickly mapping fractional seconds.
+private let pow10: [Int32] = [
+  1, 10, 100, 1_000, 10_000, 100_000,
+  1_000_000, 10_000_000, 100_000_000, 1_000_000_000
+]
+
+/// Converts a fractional second representing a nanosecond to a valid nanosecond value.
+///
+/// ```swift
+/// // 0.123456
+/// XCTAssertEqual(
+///   fractionalSecondsToNanoseconds(123456, 6),
+///   123456000
+/// )
+///
+/// // 0.000123456
+/// XCTAssertEqual(
+///   fractionalSecondsToNanoseconds(123456, 9),
+///   123456
+/// )
+///
+/// // 0.123456789
+/// XCTAssertEqual(
+///   fractionalSecondsToNanoseconds(123456789, 9),
+///   123456789
+/// )
+/// ```
+private func fractionalSecondsToNanoseconds(_ value: Int32, digits: Int) -> Int32 {
+  precondition(digits >= 0 && digits <= 9, "A nanosecond value must fit within 0..9 digits")
+  precondition(value >= 0, "A nanosecond value must be positive")
+
+  return Int32(truncatingIfNeeded: value) &* pow10[9 - digits]
+}

From 6096752d9cd5bb268bb51ab98643d83d8ad1a59f Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Wed, 8 Oct 2025 15:24:04 -0500
Subject: [PATCH 02/15] Add live snippets

---
 .../Tests/Unit/Snippets/LiveSnippets.swift    | 244 ++++++++++++++++++
 1 file changed, 244 insertions(+)
 create mode 100644 FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift

diff --git a/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift b/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
new file mode 100644
index 00000000000..03c06367136
--- /dev/null
+++ b/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
@@ -0,0 +1,244 @@
+// Copyright 2025 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.
+
+import FirebaseAI
+import FirebaseCore
+import XCTest
+
+// These snippet tests are intentionally skipped in CI jobs; see the README file in this directory
+// for instructions on running them manually.
+
+@available(iOS 15.0, macOS 12.0, macCatalyst 15.0, tvOS 15.0, watchOS 8.0, *)
+@available(watchOS, unavailable)
+final class LiveSnippets: XCTestCase {
+  override func setUpWithError() throws {
+    try FirebaseApp.configureDefaultAppForSnippets()
+  }
+
+  override func tearDown() async throws {
+    await FirebaseApp.deleteDefaultAppForSnippets()
+  }
+
+  func sendAudioReceiveAudio() async throws {
+    // Initialize the Vertex AI Gemini API backend service
+    // Set the location to `us-central1` (the flash-live model is only supported in that location)
+    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports the Live API)
+    let model = FirebaseAI.firebaseAI(backend: .vertexAI(location: "us-central1")).liveModel(
+      modelName: "gemini-2.0-flash-exp",
+      // Configure the model to respond with audio
+      generationConfig: LiveGenerationConfig(
+        responseModalities: [.audio]
+      )
+    )
+
+    do {
+      let session = try await model.connect()
+
+      // Load the audio file, or tap a microphone
+      guard let audioFile = NSDataAsset(name: "audio.pcm") else {
+        fatalError("Failed to load audio file")
+      }
+
+      // Provide the audio data
+      await session.sendAudioRealtime(audioFile.data)
+
+      var outputText = ""
+      for try await message in session.responses {
+        if case let .content(content) = message.payload {
+          content.modelTurn?.parts.forEach { part in
+            if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
+              // Handle 16bit pcm audio data at 24khz
+              playAudio(part.data)
+            }
+          }
+          // Optional: if you don't require to send more requests.
+          if content.isTurnComplete {
+            await session.close()
+          }
+        }
+      }
+    } catch {
+      fatalError(error.localizedDescription)
+    }
+  }
+
+  func sendAudioReceiveText() async throws {
+    // Initialize the Vertex AI Gemini API backend service
+    // Set the location to `us-central1` (the flash-live model is only supported in that location)
+    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports the Live API)
+    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
+      modelName: "gemini-live-2.5-flash-preview",
+      // Configure the model to respond with text
+      generationConfig: LiveGenerationConfig(
+        responseModalities: [.text]
+      )
+    )
+
+    do {
+      let session = try await model.connect()
+
+      // Load the audio file, or tap a microphone
+      guard let audioFile = NSDataAsset(name: "audio.pcm") else {
+        fatalError("Failed to load audio file")
+      }
+
+      // Provide the audio data
+      await session.sendAudioRealtime(audioFile.data)
+
+      var outputText = ""
+      for try await message in session.responses {
+        if case let .content(content) = message.payload {
+          content.modelTurn?.parts.forEach { part in
+            if let part = part as? TextPart {
+              outputText += part.text
+            }
+          }
+          // Optional: if you don't require to send more requests.
+          if content.isTurnComplete {
+            await session.close()
+          }
+        }
+      }
+
+      // Output received from the server.
+      print(outputText)
+    } catch {
+      fatalError(error.localizedDescription)
+    }
+  }
+
+  func sendTextReceiveAudio() async throws {
+    // Initialize the Gemini Developer API backend service
+    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
+    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
+      modelName: "gemini-live-2.5-flash-preview",
+      // Configure the model to respond with audio
+      generationConfig: LiveGenerationConfig(
+        responseModalities: [.audio]
+      )
+    )
+
+    do {
+      let session = try await model.connect()
+
+      // Provide a text prompt
+      let text = "tell a short story"
+
+      await session.sendTextRealtime(text)
+
+      var outputText = ""
+      for try await message in session.responses {
+        if case let .content(content) = message.payload {
+          content.modelTurn?.parts.forEach { part in
+            if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
+              // Handle 16bit pcm audio data at 24khz
+              playAudio(part.data)
+            }
+          }
+          // Optional: if you don't require to send more requests.
+          if content.isTurnComplete {
+            await session.close()
+          }
+        }
+      }
+    } catch {
+      fatalError(error.localizedDescription)
+    }
+  }
+
+  func sendTextReceiveText() async throws {
+    // Initialize the Gemini Developer API backend service
+    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
+    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
+      modelName: "gemini-live-2.5-flash-preview",
+      // Configure the model to respond with audio
+      generationConfig: LiveGenerationConfig(
+        responseModalities: [.audio]
+      )
+    )
+
+    do {
+      let session = try await model.connect()
+
+      // Provide a text prompt
+      let text = "tell a short story"
+
+      await session.sendTextRealtime(text)
+
+      var outputText = ""
+      for try await message in session.responses {
+        if case let .content(content) = message.payload {
+          content.modelTurn?.parts.forEach { part in
+            if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
+              // Handle 16bit pcm audio data at 24khz
+              playAudio(part.data)
+            }
+          }
+          // Optional: if you don't require to send more requests.
+          if content.isTurnComplete {
+            await session.close()
+          }
+        }
+      }
+    } catch {
+      fatalError(error.localizedDescription)
+    }
+  }
+
+  func changeVoiceAndLanguage() {
+    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
+      modelName: "gemini-live-2.5-flash-preview",
+      // Configure the model to use a specific voice for its audio response
+      generationConfig: LiveGenerationConfig(
+        responseModalities: [.audio],
+        speech: SpeechConfig(voiceName: "Fenrir")
+      )
+    )
+  }
+
+  func modelParameters() {
+    // ...
+
+    // Set parameter values in a `LiveGenerationConfig` (example values shown here)
+    let config = LiveGenerationConfig(
+      temperature: 0.9,
+      topP: 0.1,
+      topK: 16,
+      maxOutputTokens: 200,
+      responseModalities: [.audio],
+      speech: SpeechConfig(voiceName: "Fenrir"),
+    )
+
+    // Initialize the Vertex AI Gemini API backend service
+    // Specify the config as part of creating the `LiveGenerativeModel` instance
+    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
+      modelName: "gemini-live-2.5-flash-preview",
+      generationConfig: config
+    )
+
+    // ...
+  }
+
+  func systemInstructions() {
+    // Specify the system instructions as part of creating the `LiveGenerativeModel` instance
+    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
+      modelName: "gemini-live-2.5-flash-preview",
+      systemInstruction: ModelContent(role: "system", parts: "You are a cat. Your name is Neko.")
+    )
+  }
+
+  private func playAudio(_ data: Data) {
+    // Use AVAudioPlayerNode or something akin to play back audio
+  }
+}

From cb7796c52d45976a1eb34615666cf19898987361 Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Wed, 8 Oct 2025 15:24:26 -0500
Subject: [PATCH 03/15] Add tests for VoiceConfig encoding

---
 .../Unit/Types/Live/VoiceConfigTests.swift    | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift

diff --git a/FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift b/FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift
new file mode 100644
index 00000000000..707c0088bdc
--- /dev/null
+++ b/FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift
@@ -0,0 +1,62 @@
+// Copyright 2025 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.
+
+import XCTest
+
+@testable import FirebaseAI
+
+@available(iOS 15.0, macOS 12.0, macCatalyst 15.0, tvOS 15.0, *)
+@available(watchOS, unavailable)
+final class VoiceConfigTests: XCTestCase {
+  let encoder = JSONEncoder()
+
+  override func setUp() {
+    super.setUp()
+    encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
+  }
+
+  func testEncodeVoiceConfig_prebuiltVoice() throws {
+    let voice = VoiceConfig.prebuiltVoiceConfig(
+      PrebuiltVoiceConfig(voiceName: "Zephyr")
+    )
+
+    let jsonData = try encoder.encode(voice)
+
+    let json = try XCTUnwrap(String(data: jsonData, encoding: .utf8))
+    XCTAssertEqual(json, """
+    {
+      "prebuiltVoiceConfig" : {
+        "voiceName" : "Zephyr"
+      }
+    }
+    """)
+  }
+
+  func testEncodeVoiceConfig_customVoice() throws {
+    let voice = VoiceConfig.customVoiceConfig(
+      CustomVoiceConfig(customVoiceSample: Data(repeating: 5, count: 5))
+    )
+
+    let jsonData = try encoder.encode(voice)
+
+    let json = try XCTUnwrap(String(data: jsonData, encoding: .utf8))
+    XCTAssertEqual(json, """
+    {
+      "customVoiceConfig" : {
+        "customVoiceSample" : "BQUFBQU="
+      }
+    }
+    """)
+  }
+}

From 72b135c2cd34fba9173050a6dc26221d0b7c55dc Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Wed, 8 Oct 2025 15:24:42 -0500
Subject: [PATCH 04/15] Add tests for BidiGenerateContentServerMessage decoding

---
 ...idiGenerateContentServerMessageTests.swift | 189 ++++++++++++++++++
 1 file changed, 189 insertions(+)
 create mode 100644 FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift

diff --git a/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift b/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
new file mode 100644
index 00000000000..9a5d28b704c
--- /dev/null
+++ b/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
@@ -0,0 +1,189 @@
+// Copyright 2025 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.
+
+import XCTest
+
+@testable import FirebaseAI
+
+final class BidiGenerateContentServerMessageTests: XCTestCase {
+  let decoder = JSONDecoder()
+
+  func testDecodeBidiGenerateContentServerMessage_setupComplete() throws {
+    let json = """
+    {
+      "setupComplete" : {}
+    }
+    """
+    let jsonData = try XCTUnwrap(json.data(using: .utf8))
+
+    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
+    guard case .setupComplete(_) = serverMessage.messageType else {
+      XCTFail("Decoded message is not a setupComplete message.")
+      return
+    }
+  }
+
+  func testDecodeBidiGenerateContentServerMessage_serverContent() throws {
+    let json = """
+    {
+      "serverContent" : {
+        "modelTurn" : {
+          "parts" : [
+            {
+              "inlineData" : {
+                "data" : "BQUFBQU=",
+                "mimeType" : "audio/pcm"
+              }
+            }
+          ],
+          "role" : "model"
+        },
+        "turnComplete": true,
+        "groundingMetadata": {
+          "webSearchQueries": ["query1", "query2"],
+          "groundingChunks": [
+            { "web": { "uri": "uri1", "title": "title1" } }
+          ],
+          "groundingSupports": [
+            { "segment": { "endIndex": 10, "text": "text" }, "groundingChunkIndices": [0] }
+          ],
+          "searchEntryPoint": { "renderedContent": "html" }
+        },
+        "inputTranscription": {
+          "text": "What day of the week is it?"
+        },
+        "outputTranscription": {
+          "text": "Today is friday"
+        }
+      }
+    }
+    """
+    let jsonData = try XCTUnwrap(json.data(using: .utf8))
+
+    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
+    guard case let .serverContent(serverContent) = serverMessage.messageType else {
+      XCTFail("Decoded message is not a serverContent message.")
+      return
+    }
+
+    XCTAssertEqual(serverContent.turnComplete, true)
+    XCTAssertNil(serverContent.interrupted)
+    XCTAssertNil(serverContent.generationComplete)
+
+    let modelTurn = try XCTUnwrap(serverContent.modelTurn)
+    XCTAssertEqual(modelTurn.role, "model")
+    XCTAssertEqual(modelTurn.parts.count, 1)
+    let part = try XCTUnwrap(modelTurn.parts.first as? InlineDataPart)
+    XCTAssertEqual(part.data, Data(repeating: 5, count: 5))
+    XCTAssertEqual(part.mimeType, "audio/pcm")
+
+    let metadata = try XCTUnwrap(serverContent.groundingMetadata)
+    XCTAssertEqual(metadata.webSearchQueries, ["query1", "query2"])
+    XCTAssertEqual(metadata.groundingChunks.count, 1)
+    let groundingChunk = try XCTUnwrap(metadata.groundingChunks.first)
+    let webChunk = try XCTUnwrap(groundingChunk.web)
+    XCTAssertEqual(webChunk.uri, "uri1")
+    XCTAssertEqual(metadata.groundingSupports.count, 1)
+    let groundingSupport = try XCTUnwrap(metadata.groundingSupports.first)
+    XCTAssertEqual(groundingSupport.segment.startIndex, 0)
+    XCTAssertEqual(groundingSupport.segment.partIndex, 0)
+    XCTAssertEqual(groundingSupport.segment.endIndex, 10)
+    XCTAssertEqual(groundingSupport.segment.text, "text")
+    let searchEntryPoint = try XCTUnwrap(metadata.searchEntryPoint)
+    XCTAssertEqual(searchEntryPoint.renderedContent, "html")
+
+    let inputTranscription = try XCTUnwrap(serverContent.inputTranscription)
+    XCTAssertEqual(inputTranscription.text, "What day of the week is it?")
+
+    let outputTranscription = try XCTUnwrap(serverContent.outputTranscription)
+    XCTAssertEqual(outputTranscription.text, "Today is friday")
+  }
+
+  func testDecodeBidiGenerateContentServerMessage_toolCall() throws {
+    let json = """
+    {
+      "toolCall" : {
+        "functionCalls" : [
+          {
+            "name": "changeBackgroundColor",
+            "id": "functionCall-12345-67890",
+            "args" : {
+              "color": "#F54927"
+            }
+          }
+        ]
+      }
+    }
+    """
+    let jsonData = try XCTUnwrap(json.data(using: .utf8))
+
+    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
+    guard case let .toolCall(toolCall) = serverMessage.messageType else {
+      XCTFail("Decoded message is not a toolCall message.")
+      return
+    }
+
+    let functionCalls = try XCTUnwrap(toolCall.functionCalls)
+    XCTAssertEqual(functionCalls.count, 1)
+    let functionCall = try XCTUnwrap(functionCalls.first)
+    XCTAssertEqual(functionCall.name, "changeBackgroundColor")
+    XCTAssertEqual(functionCall.id, "functionCall-12345-67890")
+    let args = try XCTUnwrap(functionCall.args)
+    guard case let .string(color) = args["color"] else {
+      XCTFail("Missing color argument")
+      return
+    }
+    XCTAssertEqual(color, "#F54927")
+  }
+
+  func testDecodeBidiGenerateContentServerMessage_toolCallCancellation() throws {
+    let json = """
+    {
+      "toolCallCancellation" : {
+        "ids" : ["functionCall-12345-67890"]
+      }
+    }
+    """
+    let jsonData = try XCTUnwrap(json.data(using: .utf8))
+
+    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
+    guard case let .toolCallCancellation(toolCallCancellation) = serverMessage.messageType else {
+      XCTFail("Decoded message is not a toolCallCancellation message.")
+      return
+    }
+
+    let ids = try XCTUnwrap(toolCallCancellation.ids)
+    XCTAssertEqual(ids, ["functionCall-12345-67890"])
+  }
+
+  func testDecodeBidiGenerateContentServerMessage_goAway() throws {
+    let json = """
+    {
+      "goAway" : {
+        "timeLeft": "1.23456789s"
+      }
+    }
+    """
+    let jsonData = try XCTUnwrap(json.data(using: .utf8))
+
+    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
+    guard case let .goAway(goAway) = serverMessage.messageType else {
+      XCTFail("Decoded message is not a goAway message.")
+      return
+    }
+
+    XCTAssertEqual(goAway.timeLeft?.seconds, 1)
+    XCTAssertEqual(goAway.timeLeft?.nanos, 234567890)
+  }
+}

From 4cb3054af507eb5e60a2853041b4c42a68d1544a Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Wed, 8 Oct 2025 15:24:51 -0500
Subject: [PATCH 05/15] Add tests for ProtoDuration decoding

---
 .../Unit/TestUtilities/XCTExtensions.swift    | 30 ++++++
 .../Tests/Unit/Types/ProtoDurationTests.swift | 99 +++++++++++++++++++
 2 files changed, 129 insertions(+)
 create mode 100644 FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift
 create mode 100644 FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift

diff --git a/FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift b/FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift
new file mode 100644
index 00000000000..33ef11de6a7
--- /dev/null
+++ b/FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift
@@ -0,0 +1,30 @@
+// Copyright 2025 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.
+
+import XCTest
+
+/// Asserts that a string contains another string.
+///
+/// ```swift
+/// XCTAssertContains("my name is", "name")
+/// ```
+///
+/// - Parameters:
+///   - string: The source string that should contain the other.
+///   - contains: The string that should be contained in the source string.
+func XCTAssertContains(_ string: String, _ contains: String) {
+  if !string.contains(contains) {
+    XCTFail("(\"\(string)\") does not contain (\"\(contains)\")")
+  }
+}
diff --git a/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift b/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift
new file mode 100644
index 00000000000..dd73fdca3dc
--- /dev/null
+++ b/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift
@@ -0,0 +1,99 @@
+// Copyright 2025 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.
+
+import XCTest
+
+@testable import FirebaseAI
+
+final class ProtoDurationTests: XCTestCase {
+  let decoder = JSONDecoder()
+
+  private func decodeProtoDuration(_ jsonString: String) throws -> ProtoDuration {
+    let escapedString = "\"\(jsonString)\""
+    let jsonData = try XCTUnwrap(escapedString.data(using: .utf8))
+
+    return try decoder.decode(ProtoDuration.self, from: jsonData)
+  }
+
+  private func expectDecodeFailure(_ jsonString: String) throws -> DecodingError.Context? {
+    do {
+      let _ = try decodeProtoDuration(jsonString)
+      XCTFail("Expected decoding to fail")
+      return nil
+    } catch {
+      let decodingError = try XCTUnwrap(error as? DecodingError)
+      guard case let .dataCorrupted(dataCorrupted) = decodingError else {
+        XCTFail("Error was not a data corrupted error")
+        return nil
+      }
+
+      return dataCorrupted
+    }
+  }
+
+  func testDecodeProtoDuration_standardDuration() throws {
+    let duration = try decodeProtoDuration("120.000000123s")
+    XCTAssertEqual(duration.seconds, 120)
+    XCTAssertEqual(duration.nanos, 123)
+
+    XCTAssertEqual(duration.timeInterval, 120.000000123)
+  }
+
+  func testDecodeProtoDuration_withoutNanoseconds() throws {
+    let duration = try decodeProtoDuration("120s")
+    XCTAssertEqual(duration.seconds, 120)
+    XCTAssertEqual(duration.nanos, 0)
+
+    XCTAssertEqual(duration.timeInterval, 120)
+  }
+
+  func testDecodeProtoDuration_maxNanosecondDigits() throws {
+    let duration = try decodeProtoDuration("15.123456789s")
+    XCTAssertEqual(duration.seconds, 15)
+    XCTAssertEqual(duration.nanos, 123456789)
+
+    XCTAssertEqual(duration.timeInterval, 15.123456789)
+  }
+
+  func testDecodeProtoDuration_withMilliseconds() throws {
+    let duration = try decodeProtoDuration("15.123s")
+    XCTAssertEqual(duration.seconds, 15)
+    XCTAssertEqual(duration.nanos, 123000000)
+
+    XCTAssertEqual(duration.timeInterval, 15.123000000)
+  }
+
+  func testDecodeProtoDuration_invalidSeconds() throws {
+    guard let error = try expectDecodeFailure("invalid.123s") else { return }
+    XCTAssertContains(error.debugDescription, "Invalid proto duration seconds")
+  }
+
+  func testDecodeProtoDuration_invalidNanoseconds() throws {
+    guard let error = try expectDecodeFailure("123.invalid") else { return }
+    XCTAssertContains(error.debugDescription, "Invalid proto duration nanoseconds")
+  }
+
+  func testDecodeProtoDuration_tooManyDecimals() throws {
+    guard let error = try expectDecodeFailure("123.45.67") else { return }
+    XCTAssertContains(error.debugDescription, "Invalid proto duration string")
+  }
+
+  func testDecodeProtoDuration_withoutSuffix() throws {
+    let duration = try decodeProtoDuration("123.456")
+    XCTAssertEqual(duration.seconds, 123)
+    XCTAssertEqual(duration.nanos, 456000000)
+
+    XCTAssertEqual(duration.timeInterval, 123.456)
+  }
+}

From a1636c93fb3fa2e59b7408440a651c073a1de13b Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Wed, 8 Oct 2025 15:25:55 -0500
Subject: [PATCH 06/15] formatting

---
 FirebaseAI/CHANGELOG.md                              |  2 +-
 .../Sources/Types/Internal/ProtoDuration.swift       |  4 ++--
 FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift    | 12 ++++++++----
 .../Live/BidiGenerateContentServerMessageTests.swift |  4 ++--
 FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift |  6 +++---
 5 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/FirebaseAI/CHANGELOG.md b/FirebaseAI/CHANGELOG.md
index c32f89d1183..c7d39a4dd2e 100644
--- a/FirebaseAI/CHANGELOG.md
+++ b/FirebaseAI/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Unreleased
 - [fixed] Fixed minor translation issue for nanosecond conversion when receiving
-  `LiveServerGoingAwayNotice`. (#????) 
+  `LiveServerGoingAwayNotice`. (#????)
 
 # 12.4.0
 - [feature] Added support for the URL context tool, which allows the model to access content
diff --git a/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift b/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
index b55075747b8..d4af71b0346 100644
--- a/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
+++ b/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
@@ -113,8 +113,8 @@ extension ProtoDuration: Decodable {
 
 /// Cached powers of 10 for quickly mapping fractional seconds.
 private let pow10: [Int32] = [
-  1, 10, 100, 1_000, 10_000, 100_000,
-  1_000_000, 10_000_000, 100_000_000, 1_000_000_000
+  1, 10, 100, 1000, 10000, 100_000,
+  1_000_000, 10_000_000, 100_000_000, 1_000_000_000,
 ]
 
 /// Converts a fractional second representing a nanosecond to a valid nanosecond value.
diff --git a/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift b/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
index 03c06367136..f2dc67f74dc 100644
--- a/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
+++ b/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
@@ -33,7 +33,8 @@ final class LiveSnippets: XCTestCase {
   func sendAudioReceiveAudio() async throws {
     // Initialize the Vertex AI Gemini API backend service
     // Set the location to `us-central1` (the flash-live model is only supported in that location)
-    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports the Live API)
+    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports
+    // the Live API)
     let model = FirebaseAI.firebaseAI(backend: .vertexAI(location: "us-central1")).liveModel(
       modelName: "gemini-2.0-flash-exp",
       // Configure the model to respond with audio
@@ -76,7 +77,8 @@ final class LiveSnippets: XCTestCase {
   func sendAudioReceiveText() async throws {
     // Initialize the Vertex AI Gemini API backend service
     // Set the location to `us-central1` (the flash-live model is only supported in that location)
-    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports the Live API)
+    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports
+    // the Live API)
     let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
       modelName: "gemini-live-2.5-flash-preview",
       // Configure the model to respond with text
@@ -120,7 +122,8 @@ final class LiveSnippets: XCTestCase {
 
   func sendTextReceiveAudio() async throws {
     // Initialize the Gemini Developer API backend service
-    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
+    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live
+    // API)
     let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
       modelName: "gemini-live-2.5-flash-preview",
       // Configure the model to respond with audio
@@ -159,7 +162,8 @@ final class LiveSnippets: XCTestCase {
 
   func sendTextReceiveText() async throws {
     // Initialize the Gemini Developer API backend service
-    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
+    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live
+    // API)
     let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
       modelName: "gemini-live-2.5-flash-preview",
       // Configure the model to respond with audio
diff --git a/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift b/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
index 9a5d28b704c..2646e980421 100644
--- a/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
+++ b/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
@@ -28,7 +28,7 @@ final class BidiGenerateContentServerMessageTests: XCTestCase {
     let jsonData = try XCTUnwrap(json.data(using: .utf8))
 
     let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
-    guard case .setupComplete(_) = serverMessage.messageType else {
+    guard case .setupComplete = serverMessage.messageType else {
       XCTFail("Decoded message is not a setupComplete message.")
       return
     }
@@ -184,6 +184,6 @@ final class BidiGenerateContentServerMessageTests: XCTestCase {
     }
 
     XCTAssertEqual(goAway.timeLeft?.seconds, 1)
-    XCTAssertEqual(goAway.timeLeft?.nanos, 234567890)
+    XCTAssertEqual(goAway.timeLeft?.nanos, 234_567_890)
   }
 }
diff --git a/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift b/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift
index dd73fdca3dc..bddb50eef1d 100644
--- a/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift
+++ b/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift
@@ -61,7 +61,7 @@ final class ProtoDurationTests: XCTestCase {
   func testDecodeProtoDuration_maxNanosecondDigits() throws {
     let duration = try decodeProtoDuration("15.123456789s")
     XCTAssertEqual(duration.seconds, 15)
-    XCTAssertEqual(duration.nanos, 123456789)
+    XCTAssertEqual(duration.nanos, 123_456_789)
 
     XCTAssertEqual(duration.timeInterval, 15.123456789)
   }
@@ -69,7 +69,7 @@ final class ProtoDurationTests: XCTestCase {
   func testDecodeProtoDuration_withMilliseconds() throws {
     let duration = try decodeProtoDuration("15.123s")
     XCTAssertEqual(duration.seconds, 15)
-    XCTAssertEqual(duration.nanos, 123000000)
+    XCTAssertEqual(duration.nanos, 123_000_000)
 
     XCTAssertEqual(duration.timeInterval, 15.123000000)
   }
@@ -92,7 +92,7 @@ final class ProtoDurationTests: XCTestCase {
   func testDecodeProtoDuration_withoutSuffix() throws {
     let duration = try decodeProtoDuration("123.456")
     XCTAssertEqual(duration.seconds, 123)
-    XCTAssertEqual(duration.nanos, 456000000)
+    XCTAssertEqual(duration.nanos, 456_000_000)
 
     XCTAssertEqual(duration.timeInterval, 123.456)
   }

From ba35be4e3d0cfb3434b5e85bc3c1685b0d4fc0ab Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Wed, 8 Oct 2025 15:31:57 -0500
Subject: [PATCH 07/15] Add PR number to changelog entry

---
 FirebaseAI/CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/FirebaseAI/CHANGELOG.md b/FirebaseAI/CHANGELOG.md
index c7d39a4dd2e..b7999b9fa4a 100644
--- a/FirebaseAI/CHANGELOG.md
+++ b/FirebaseAI/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Unreleased
 - [fixed] Fixed minor translation issue for nanosecond conversion when receiving
-  `LiveServerGoingAwayNotice`. (#????)
+  `LiveServerGoingAwayNotice`. (#15396)
 
 # 12.4.0
 - [feature] Added support for the URL context tool, which allows the model to access content

From 7d998a31c1d06bc754b1c38c4039ff6b3139942c Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Thu, 9 Oct 2025 14:52:20 -0500
Subject: [PATCH 08/15] Add missing available marker

---
 .../Unit/Types/Live/BidiGenerateContentServerMessageTests.swift | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift b/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
index 2646e980421..710f7510ff0 100644
--- a/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
+++ b/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
@@ -16,6 +16,8 @@ import XCTest
 
 @testable import FirebaseAI
 
+@available(iOS 15.0, macOS 12.0, macCatalyst 15.0, tvOS 15.0, *)
+@available(watchOS, unavailable)
 final class BidiGenerateContentServerMessageTests: XCTestCase {
   let decoder = JSONDecoder()
 

From 6f5038ae75387add22aff10eecbce583d2997bd0 Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Thu, 9 Oct 2025 14:57:00 -0500
Subject: [PATCH 09/15] Fix warnings

---
 .../Tests/Unit/Snippets/LiveSnippets.swift      | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift b/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
index f2dc67f74dc..8c61da91d50 100644
--- a/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
+++ b/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
@@ -54,7 +54,6 @@ final class LiveSnippets: XCTestCase {
       // Provide the audio data
       await session.sendAudioRealtime(audioFile.data)
 
-      var outputText = ""
       for try await message in session.responses {
         if case let .content(content) = message.payload {
           content.modelTurn?.parts.forEach { part in
@@ -140,7 +139,6 @@ final class LiveSnippets: XCTestCase {
 
       await session.sendTextRealtime(text)
 
-      var outputText = ""
       for try await message in session.responses {
         if case let .content(content) = message.payload {
           content.modelTurn?.parts.forEach { part in
@@ -180,7 +178,6 @@ final class LiveSnippets: XCTestCase {
 
       await session.sendTextRealtime(text)
 
-      var outputText = ""
       for try await message in session.responses {
         if case let .content(content) = message.payload {
           content.modelTurn?.parts.forEach { part in
@@ -209,6 +206,9 @@ final class LiveSnippets: XCTestCase {
         speech: SpeechConfig(voiceName: "Fenrir")
       )
     )
+
+    // Not part of snippet
+    silenceWarning(model)
   }
 
   func modelParameters() {
@@ -232,6 +232,9 @@ final class LiveSnippets: XCTestCase {
     )
 
     // ...
+
+    // Not part of snippet
+    silenceWarning(model)
   }
 
   func systemInstructions() {
@@ -240,9 +243,17 @@ final class LiveSnippets: XCTestCase {
       modelName: "gemini-live-2.5-flash-preview",
       systemInstruction: ModelContent(role: "system", parts: "You are a cat. Your name is Neko.")
     )
+
+    // Not part of snippet
+    silenceWarning(model)
   }
 
   private func playAudio(_ data: Data) {
     // Use AVAudioPlayerNode or something akin to play back audio
   }
+
+  /// This function only exists to silence the "unused value" warnings.
+  ///
+  /// This allows us to ensure the snippets match devsite.
+  private func silenceWarning(_ model: LiveGenerativeModel) {}
 }

From c29c5c925fb82ae69e8942c139d7a192d3ae6c13 Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Thu, 9 Oct 2025 15:03:53 -0500
Subject: [PATCH 10/15] Delete LiveSnippets.swift

---
 .../Tests/Unit/Snippets/LiveSnippets.swift    | 259 ------------------
 1 file changed, 259 deletions(-)
 delete mode 100644 FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift

diff --git a/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift b/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
deleted file mode 100644
index 8c61da91d50..00000000000
--- a/FirebaseAI/Tests/Unit/Snippets/LiveSnippets.swift
+++ /dev/null
@@ -1,259 +0,0 @@
-// Copyright 2025 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.
-
-import FirebaseAI
-import FirebaseCore
-import XCTest
-
-// These snippet tests are intentionally skipped in CI jobs; see the README file in this directory
-// for instructions on running them manually.
-
-@available(iOS 15.0, macOS 12.0, macCatalyst 15.0, tvOS 15.0, watchOS 8.0, *)
-@available(watchOS, unavailable)
-final class LiveSnippets: XCTestCase {
-  override func setUpWithError() throws {
-    try FirebaseApp.configureDefaultAppForSnippets()
-  }
-
-  override func tearDown() async throws {
-    await FirebaseApp.deleteDefaultAppForSnippets()
-  }
-
-  func sendAudioReceiveAudio() async throws {
-    // Initialize the Vertex AI Gemini API backend service
-    // Set the location to `us-central1` (the flash-live model is only supported in that location)
-    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports
-    // the Live API)
-    let model = FirebaseAI.firebaseAI(backend: .vertexAI(location: "us-central1")).liveModel(
-      modelName: "gemini-2.0-flash-exp",
-      // Configure the model to respond with audio
-      generationConfig: LiveGenerationConfig(
-        responseModalities: [.audio]
-      )
-    )
-
-    do {
-      let session = try await model.connect()
-
-      // Load the audio file, or tap a microphone
-      guard let audioFile = NSDataAsset(name: "audio.pcm") else {
-        fatalError("Failed to load audio file")
-      }
-
-      // Provide the audio data
-      await session.sendAudioRealtime(audioFile.data)
-
-      for try await message in session.responses {
-        if case let .content(content) = message.payload {
-          content.modelTurn?.parts.forEach { part in
-            if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
-              // Handle 16bit pcm audio data at 24khz
-              playAudio(part.data)
-            }
-          }
-          // Optional: if you don't require to send more requests.
-          if content.isTurnComplete {
-            await session.close()
-          }
-        }
-      }
-    } catch {
-      fatalError(error.localizedDescription)
-    }
-  }
-
-  func sendAudioReceiveText() async throws {
-    // Initialize the Vertex AI Gemini API backend service
-    // Set the location to `us-central1` (the flash-live model is only supported in that location)
-    // Create a `LiveGenerativeModel` instance with the flash-live model (only model that supports
-    // the Live API)
-    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
-      modelName: "gemini-live-2.5-flash-preview",
-      // Configure the model to respond with text
-      generationConfig: LiveGenerationConfig(
-        responseModalities: [.text]
-      )
-    )
-
-    do {
-      let session = try await model.connect()
-
-      // Load the audio file, or tap a microphone
-      guard let audioFile = NSDataAsset(name: "audio.pcm") else {
-        fatalError("Failed to load audio file")
-      }
-
-      // Provide the audio data
-      await session.sendAudioRealtime(audioFile.data)
-
-      var outputText = ""
-      for try await message in session.responses {
-        if case let .content(content) = message.payload {
-          content.modelTurn?.parts.forEach { part in
-            if let part = part as? TextPart {
-              outputText += part.text
-            }
-          }
-          // Optional: if you don't require to send more requests.
-          if content.isTurnComplete {
-            await session.close()
-          }
-        }
-      }
-
-      // Output received from the server.
-      print(outputText)
-    } catch {
-      fatalError(error.localizedDescription)
-    }
-  }
-
-  func sendTextReceiveAudio() async throws {
-    // Initialize the Gemini Developer API backend service
-    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live
-    // API)
-    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
-      modelName: "gemini-live-2.5-flash-preview",
-      // Configure the model to respond with audio
-      generationConfig: LiveGenerationConfig(
-        responseModalities: [.audio]
-      )
-    )
-
-    do {
-      let session = try await model.connect()
-
-      // Provide a text prompt
-      let text = "tell a short story"
-
-      await session.sendTextRealtime(text)
-
-      for try await message in session.responses {
-        if case let .content(content) = message.payload {
-          content.modelTurn?.parts.forEach { part in
-            if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
-              // Handle 16bit pcm audio data at 24khz
-              playAudio(part.data)
-            }
-          }
-          // Optional: if you don't require to send more requests.
-          if content.isTurnComplete {
-            await session.close()
-          }
-        }
-      }
-    } catch {
-      fatalError(error.localizedDescription)
-    }
-  }
-
-  func sendTextReceiveText() async throws {
-    // Initialize the Gemini Developer API backend service
-    // Create a `LiveModel` instance with the flash-live model (only model that supports the Live
-    // API)
-    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
-      modelName: "gemini-live-2.5-flash-preview",
-      // Configure the model to respond with audio
-      generationConfig: LiveGenerationConfig(
-        responseModalities: [.audio]
-      )
-    )
-
-    do {
-      let session = try await model.connect()
-
-      // Provide a text prompt
-      let text = "tell a short story"
-
-      await session.sendTextRealtime(text)
-
-      for try await message in session.responses {
-        if case let .content(content) = message.payload {
-          content.modelTurn?.parts.forEach { part in
-            if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
-              // Handle 16bit pcm audio data at 24khz
-              playAudio(part.data)
-            }
-          }
-          // Optional: if you don't require to send more requests.
-          if content.isTurnComplete {
-            await session.close()
-          }
-        }
-      }
-    } catch {
-      fatalError(error.localizedDescription)
-    }
-  }
-
-  func changeVoiceAndLanguage() {
-    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
-      modelName: "gemini-live-2.5-flash-preview",
-      // Configure the model to use a specific voice for its audio response
-      generationConfig: LiveGenerationConfig(
-        responseModalities: [.audio],
-        speech: SpeechConfig(voiceName: "Fenrir")
-      )
-    )
-
-    // Not part of snippet
-    silenceWarning(model)
-  }
-
-  func modelParameters() {
-    // ...
-
-    // Set parameter values in a `LiveGenerationConfig` (example values shown here)
-    let config = LiveGenerationConfig(
-      temperature: 0.9,
-      topP: 0.1,
-      topK: 16,
-      maxOutputTokens: 200,
-      responseModalities: [.audio],
-      speech: SpeechConfig(voiceName: "Fenrir"),
-    )
-
-    // Initialize the Vertex AI Gemini API backend service
-    // Specify the config as part of creating the `LiveGenerativeModel` instance
-    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
-      modelName: "gemini-live-2.5-flash-preview",
-      generationConfig: config
-    )
-
-    // ...
-
-    // Not part of snippet
-    silenceWarning(model)
-  }
-
-  func systemInstructions() {
-    // Specify the system instructions as part of creating the `LiveGenerativeModel` instance
-    let model = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
-      modelName: "gemini-live-2.5-flash-preview",
-      systemInstruction: ModelContent(role: "system", parts: "You are a cat. Your name is Neko.")
-    )
-
-    // Not part of snippet
-    silenceWarning(model)
-  }
-
-  private func playAudio(_ data: Data) {
-    // Use AVAudioPlayerNode or something akin to play back audio
-  }
-
-  /// This function only exists to silence the "unused value" warnings.
-  ///
-  /// This allows us to ensure the snippets match devsite.
-  private func silenceWarning(_ model: LiveGenerativeModel) {}
-}

From 9acee670d330501656c3c03cbe20a30d42ce523d Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Fri, 10 Oct 2025 17:03:27 -0500
Subject: [PATCH 11/15] Add integration tests

---
 .../project.pbxproj                           |   6 +
 .../hello.dataset/Contents.json               |  12 +
 .../Assets.xcassets/hello.dataset/hello.wav   | Bin 0 -> 27164 bytes
 .../Tests/TestApp/Sources/Constants.swift     |   2 +
 .../Tests/Integration/LiveSessionTests.swift  | 481 ++++++++++++++++++
 .../Tests/Utilities/InstanceConfig.swift      |  15 +
 6 files changed, 516 insertions(+)
 create mode 100644 FirebaseAI/Tests/TestApp/Resources/Assets.xcassets/hello.dataset/Contents.json
 create mode 100644 FirebaseAI/Tests/TestApp/Resources/Assets.xcassets/hello.dataset/hello.wav
 create mode 100644 FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift

diff --git a/FirebaseAI/Tests/TestApp/FirebaseAITestApp.xcodeproj/project.pbxproj b/FirebaseAI/Tests/TestApp/FirebaseAITestApp.xcodeproj/project.pbxproj
index fc62b25f132..8b1b80e54d8 100644
--- a/FirebaseAI/Tests/TestApp/FirebaseAITestApp.xcodeproj/project.pbxproj
+++ b/FirebaseAI/Tests/TestApp/FirebaseAITestApp.xcodeproj/project.pbxproj
@@ -7,6 +7,8 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		0E460FAB2E9858E4007E26A6 /* LiveSessionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0E460FAA2E9858E4007E26A6 /* LiveSessionTests.swift */; };
+		0EC8BAE22E98784E0075A4E0 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 868A7C532CCC26B500E449DD /* Assets.xcassets */; };
 		862218812D04E098007ED2D4 /* IntegrationTestUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 862218802D04E08D007ED2D4 /* IntegrationTestUtils.swift */; };
 		864F8F712D4980DD0002EA7E /* ImagenIntegrationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 864F8F702D4980D60002EA7E /* ImagenIntegrationTests.swift */; };
 		8661385C2CC943DD00F4B78E /* TestApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8661385B2CC943DD00F4B78E /* TestApp.swift */; };
@@ -42,6 +44,7 @@
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXFileReference section */
+		0E460FAA2E9858E4007E26A6 /* LiveSessionTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LiveSessionTests.swift; sourceTree = "<group>"; };
 		862218802D04E08D007ED2D4 /* IntegrationTestUtils.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = IntegrationTestUtils.swift; sourceTree = "<group>"; };
 		864F8F702D4980D60002EA7E /* ImagenIntegrationTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ImagenIntegrationTests.swift; sourceTree = "<group>"; };
 		866138582CC943DD00F4B78E /* FirebaseAITestApp-SPM.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "FirebaseAITestApp-SPM.app"; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -141,6 +144,7 @@
 		868A7C572CCC27AF00E449DD /* Integration */ = {
 			isa = PBXGroup;
 			children = (
+				0E460FAA2E9858E4007E26A6 /* LiveSessionTests.swift */,
 				DEF0BB502DA9B7400093E9F4 /* SchemaTests.swift */,
 				DEF0BB4E2DA74F460093E9F4 /* TestHelpers.swift */,
 				8689CDCB2D7F8BCF00BF426B /* CountTokensIntegrationTests.swift */,
@@ -271,6 +275,7 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				0EC8BAE22E98784E0075A4E0 /* Assets.xcassets in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -295,6 +300,7 @@
 			files = (
 				8689CDCC2D7F8BD700BF426B /* CountTokensIntegrationTests.swift in Sources */,
 				86D77E042D7B6C9D003D155D /* InstanceConfig.swift in Sources */,
+				0E460FAB2E9858E4007E26A6 /* LiveSessionTests.swift in Sources */,
 				DEF0BB512DA9B7450093E9F4 /* SchemaTests.swift in Sources */,
 				DEF0BB4F2DA74F680093E9F4 /* TestHelpers.swift in Sources */,
 				868A7C4F2CCC229F00E449DD /* Credentials.swift in Sources */,
diff --git a/FirebaseAI/Tests/TestApp/Resources/Assets.xcassets/hello.dataset/Contents.json b/FirebaseAI/Tests/TestApp/Resources/Assets.xcassets/hello.dataset/Contents.json
new file mode 100644
index 00000000000..7e31b8c1616
--- /dev/null
+++ b/FirebaseAI/Tests/TestApp/Resources/Assets.xcassets/hello.dataset/Contents.json
@@ -0,0 +1,12 @@
+{
+  "data" : [
+    {
+      "filename" : "hello.wav",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/FirebaseAI/Tests/TestApp/Resources/Assets.xcassets/hello.dataset/hello.wav b/FirebaseAI/Tests/TestApp/Resources/Assets.xcassets/hello.dataset/hello.wav
new file mode 100644
index 0000000000000000000000000000000000000000..c065afa21c3b722c357b7d8f2d004392c8dcf12e
GIT binary patch
literal 27164
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
H&`$dwRd}6t

literal 0
HcmV?d00001

diff --git a/FirebaseAI/Tests/TestApp/Sources/Constants.swift b/FirebaseAI/Tests/TestApp/Sources/Constants.swift
index bedd6a42053..6c314ebedb8 100644
--- a/FirebaseAI/Tests/TestApp/Sources/Constants.swift
+++ b/FirebaseAI/Tests/TestApp/Sources/Constants.swift
@@ -24,9 +24,11 @@ public enum ModelNames {
   public static let gemini2Flash = "gemini-2.0-flash-001"
   public static let gemini2FlashLite = "gemini-2.0-flash-lite-001"
   public static let gemini2FlashPreviewImageGeneration = "gemini-2.0-flash-preview-image-generation"
+  public static let gemini2FlashLivePreview = "gemini-2.0-flash-live-preview-04-09"
   public static let gemini2_5_FlashImagePreview = "gemini-2.5-flash-image-preview"
   public static let gemini2_5_Flash = "gemini-2.5-flash"
   public static let gemini2_5_FlashLite = "gemini-2.5-flash-lite"
+  public static let gemini2_5_FlashLivePreview = "gemini-live-2.5-flash-preview"
   public static let gemini2_5_Pro = "gemini-2.5-pro"
   public static let gemma3_4B = "gemma-3-4b-it"
 }
diff --git a/FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift b/FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift
new file mode 100644
index 00000000000..119ee638dc6
--- /dev/null
+++ b/FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift
@@ -0,0 +1,481 @@
+// Copyright 2025 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.
+
+import FirebaseAI
+import FirebaseAITestApp
+import SwiftUI
+import Testing
+
+@testable import struct FirebaseAI.APIConfig
+
+@Suite(.serialized)
+struct LiveSessionTests {
+  private let OneSecondInNanoseconds = UInt64(1e+9)
+  private let tools: [Tool] = [
+    .functionDeclarations([
+      FunctionDeclaration(
+        name: "getLastName",
+        description: "Gets the last name of a person.",
+        parameters: [
+          "firstName": .string(
+            description: "The first name of the person to lookup."
+          ),
+        ]
+      ),
+    ]),
+  ]
+  private let textConfig = LiveGenerationConfig(
+    responseModalities: [.text]
+  )
+  private let audioConfig = LiveGenerationConfig(
+    responseModalities: [.audio],
+    outputAudioTranscription: AudioTranscriptionConfig()
+  )
+
+  private enum systemInstructions {
+    static let yesOrNo = ModelContent(
+      role: "system",
+      parts: """
+        You can only respond with "yes" or "no".
+      """.trimmingCharacters(in: .whitespacesAndNewlines)
+    )
+
+    static let helloGoodbye = ModelContent(
+      role: "system",
+      parts: """
+        When you hear "Hello" say "Goodbye". If you hear anything else, say "The audio file is broken".
+      """.trimmingCharacters(in: .whitespacesAndNewlines)
+    )
+
+    static let lastNames = ModelContent(
+      role: "system",
+      parts: "When you receive a message, if the message is a single word, assume it's the first name of a person, and call the getLastName tool to get the last name of said person. Only respond with the last name."
+    )
+  }
+
+  private func modelForBackend(_ config: InstanceConfig) -> String {
+    switch config.apiConfig.service {
+    case .vertexAI:
+      ModelNames.gemini2FlashLivePreview
+    case .googleAI:
+      ModelNames.gemini2_5_FlashLivePreview
+    }
+  }
+
+  @Test(arguments: InstanceConfig.liveConfigs)
+  func sendTextRealtime_receiveText(_ config: InstanceConfig) async throws {
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: textConfig,
+      systemInstruction: systemInstructions.yesOrNo
+    )
+
+    let session = try await model.connect()
+    await session.sendTextRealtime("Does five plus five equal ten?")
+
+    let text = try await session.collectNextTextResponse()
+
+    await session.close()
+    let modelResponse = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .trimmingCharacters(in: .punctuationCharacters)
+      .lowercased()
+
+    #expect(modelResponse == "yes")
+  }
+
+  @Test(arguments: InstanceConfig.liveConfigs)
+  func sendTextRealtime_receiveAudioOutputTranscripts(_ config: InstanceConfig) async throws {
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: audioConfig,
+      systemInstruction: systemInstructions.yesOrNo
+    )
+
+    let session = try await model.connect()
+    await session.sendTextRealtime("Does five plus five equal ten?")
+
+    let text = try await session.collectNextAudioOutputTranscript()
+
+    await session.close()
+    let modelResponse = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .trimmingCharacters(in: .punctuationCharacters)
+      .lowercased()
+
+    #expect(modelResponse == "yes")
+  }
+
+  @Test(arguments: InstanceConfig.liveConfigs)
+  func sendAudioRealtime_receiveAudioOutputTranscripts(_ config: InstanceConfig) async throws {
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: audioConfig,
+      systemInstruction: systemInstructions.helloGoodbye
+    )
+
+    let session = try await model.connect()
+
+    guard let audioFile = NSDataAsset(name: "hello") else {
+      Issue.record("Missing audio file 'hello.wav' in Assets")
+      return
+    }
+    await session.sendAudioRealtime(audioFile.data)
+    await session.sendAudioRealtime(Data(repeating: 0, count: audioFile.data.count))
+
+    let text = try await session.collectNextAudioOutputTranscript()
+
+    await session.close()
+    let modelResponse = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .trimmingCharacters(in: .punctuationCharacters)
+      .lowercased()
+
+    #expect(modelResponse == "goodbye")
+  }
+
+  @Test(arguments: InstanceConfig.liveConfigs)
+  func sendAudioRealtime_receiveText(_ config: InstanceConfig) async throws {
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: textConfig,
+      systemInstruction: systemInstructions.helloGoodbye
+    )
+
+    let session = try await model.connect()
+
+    guard let audioFile = NSDataAsset(name: "hello") else {
+      Issue.record("Missing audio file 'hello.wav' in Assets")
+      return
+    }
+    await session.sendAudioRealtime(audioFile.data)
+    await session.sendAudioRealtime(Data(repeating: 0, count: audioFile.data.count))
+
+    let text = try await session.collectNextTextResponse()
+
+    await session.close()
+    let modelResponse = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .trimmingCharacters(in: .punctuationCharacters)
+      .lowercased()
+
+    #expect(modelResponse == "goodbye")
+  }
+
+  @Test(arguments: InstanceConfig.liveConfigs)
+  func realtime_functionCalling(_ config: InstanceConfig) async throws {
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: textConfig,
+      tools: tools,
+      systemInstruction: systemInstructions.lastNames
+    )
+
+    let session = try await model.connect()
+    await session.sendTextRealtime("Alex")
+
+    guard let toolCall = try await session.collectNextToolCall() else {
+      return
+    }
+
+    let functionCalls = try #require(toolCall.functionCalls)
+
+    #expect(functionCalls.count == 1)
+    let functionCall = try #require(functionCalls.first)
+
+    #expect(functionCall.name == "getLastName")
+    guard let response = getLastName(args: functionCall.args) else {
+      return
+    }
+    await session.sendFunctionResponses([
+      FunctionResponsePart(
+        name: functionCall.name,
+        response: ["lastName": .string(response)],
+        functionId: functionCall.functionId
+      ),
+    ])
+
+    var text = try await session.collectNextTextResponse()
+    if text.isEmpty {
+      // The model sometimes sends an empty text response first
+      text = try await session.collectNextTextResponse()
+    }
+
+    await session.close()
+    let modelResponse = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .trimmingCharacters(in: .punctuationCharacters)
+      .lowercased()
+
+    #expect(modelResponse == "smith")
+  }
+
+  @Test(arguments: InstanceConfig.liveConfigs.filter {
+    // TODO: (b/XXXX) Remove when vertex adds support
+    switch $0.apiConfig.service {
+    case .googleAI:
+      true
+    case .vertexAI:
+      false
+    }
+  })
+  func realtime_functionCalling_cancellation(_ config: InstanceConfig) async throws {
+    // TODO: (b/XXXX) Remove when vertex adds support
+    guard case .googleAI = config.apiConfig.service else {
+      Issue.record("Vertex does not currently support function ids or function cancellation.")
+      return
+    }
+
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: textConfig,
+      tools: tools,
+      systemInstruction: systemInstructions.lastNames
+    )
+
+    let session = try await model.connect()
+    await session.sendTextRealtime("Alex")
+
+    guard let toolCall = try await session.collectNextToolCall() else {
+      return
+    }
+
+    let functionCalls = try #require(toolCall.functionCalls)
+
+    #expect(functionCalls.count == 1)
+    let functionCall = try #require(functionCalls.first)
+    let id = try #require(functionCall.functionId)
+
+    await session.sendTextRealtime("Actually, I don't care about the last name of Alex anymore.")
+
+    for try await cancellation in session.responsesOf(LiveServerToolCallCancellation.self) {
+      #expect(cancellation.ids == [id])
+      break
+    }
+
+    await session.close()
+  }
+
+  // Getting a limited use token adds too much of an overhead; we can't interrupt the model in time
+  @Test(
+    arguments: InstanceConfig.liveConfigs.filter { !$0.useLimitedUseAppCheckTokens }
+  )
+  func realtime_interruption(_ config: InstanceConfig) async throws {
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: audioConfig
+    )
+
+    let session = try await model.connect()
+
+    guard let audioFile = NSDataAsset(name: "hello") else {
+      Issue.record("Missing audio file 'hello.wav' in Assets")
+      return
+    }
+    await session.sendAudioRealtime(audioFile.data)
+    await session.sendAudioRealtime(Data(repeating: 0, count: audioFile.data.count))
+
+    // wait a second to allow the model to start generating (and cuase a proper interruption)
+    try await Task.sleep(nanoseconds: OneSecondInNanoseconds)
+    await session.sendAudioRealtime(audioFile.data)
+    await session.sendAudioRealtime(Data(repeating: 0, count: audioFile.data.count))
+
+    for try await content in session.responsesOf(LiveServerContent.self) {
+      if content.wasInterrupted {
+        break
+      }
+
+      if content.isTurnComplete {
+        Issue.record("The model never sent an interrupted message.")
+        return
+      }
+    }
+  }
+
+  @Test(arguments: InstanceConfig.liveConfigs)
+  func incremental_works(_ config: InstanceConfig) async throws {
+    let model = FirebaseAI.componentInstance(config).liveModel(
+      modelName: modelForBackend(config),
+      generationConfig: textConfig,
+      systemInstruction: systemInstructions.yesOrNo
+    )
+
+    let session = try await model.connect()
+    await session.sendContent("Does five plus")
+    await session.sendContent(" five equal ten?", turnComplete: true)
+
+    let text = try await session.collectNextTextResponse()
+
+    await session.close()
+    let modelResponse = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .trimmingCharacters(in: .punctuationCharacters)
+      .lowercased()
+
+    #expect(modelResponse == "yes")
+  }
+
+  private func getLastName(args: JSONObject) -> String? {
+    guard case let .string(firstName) = args["firstName"] else {
+      Issue.record("Missing 'firstName' argument: \(String(describing: args))")
+      return nil
+    }
+
+    switch firstName {
+    case "Alex": return "Smith"
+    case "Bob": return "Johnson"
+    default:
+      Issue.record("Unsupported 'firstName': \(firstName)")
+      return nil
+    }
+  }
+}
+
+private extension LiveSession {
+  /// Collects the text that the model sends for the next turn.
+  ///
+  /// Will listen for `LiveServerContent` messages from the model,
+  /// incrementally keeping track of any `TextPart`s it sends. Once
+  /// the model signals that its turn is complete, the function will return
+  /// a string concatenated of all the `TextPart`s.
+  func collectNextTextResponse() async throws -> String {
+    var text = ""
+
+    for try await content in responsesOf(LiveServerContent.self) {
+      text += content.modelTurn?.allText() ?? ""
+
+      if content.isTurnComplete {
+        break
+      }
+    }
+
+    return text
+  }
+
+  /// Collects the audio output transcripts that the model sends for the next turn.
+  ///
+  /// Will listen for `LiveServerContent` messages from the model,
+  /// incrementally keeping track of any `LiveAudioTranscription`s it sends.
+  /// Once the model signals that its turn is complete, the function will return
+  /// a string concatenated of all the `LiveAudioTranscription`s.
+  func collectNextAudioOutputTranscript() async throws -> String {
+    var text = ""
+
+    for try await content in responsesOf(LiveServerContent.self) {
+      text += content.outputAudioText()
+
+      if content.isTurnComplete {
+        break
+      }
+    }
+
+    return text
+  }
+
+  /// Waits for the next `LiveServerToolCall` message from the model, and will return it.
+  ///
+  /// If the model instead sends `LiveServerContent`, the function will attempt to keep track of
+  /// any messages it sends (either via `LiveAudioTranscription` or `TextPart`), and will
+  /// record an issue describing the message.
+  ///
+  /// This is useful when testing function calling, as sometimes the model sends an error message, does
+  /// something unexpected, or will attempt to get clarification. Logging the message (instead of just timing out),
+  /// allows us to more easily debug such situations.
+  func collectNextToolCall() async throws -> LiveServerToolCall? {
+    var error = ""
+    for try await response in responses {
+      switch response.payload {
+      case let .toolCall(toolCall):
+        return toolCall
+      case let .content(content):
+        if let text = content.modelTurn?.allText() {
+          error += text
+        } else {
+          error += content.outputAudioText()
+        }
+
+        if content.isTurnComplete {
+          Issue.record("The model didn't send a tool call. Text received: \(error)")
+          return nil
+        }
+      default:
+        continue
+      }
+    }
+    Issue.record("Failed to receive any responses")
+    return nil
+  }
+
+  /// Filters responses from the model to a certain type.
+  ///
+  /// Useful when you only expect (or care about) certain types.
+  ///
+  /// ```swift
+  /// for try await content in session.responsesOf(LiveServerContent.self) {
+  ///   // ...
+  /// }
+  /// ```
+  ///
+  /// Is the equivelent to manually doing:
+  /// ```swift
+  /// for try await response in session.responses {
+  ///   if case let .content(content) = response.payload {
+  ///     // ...
+  ///   }
+  /// }
+  /// ```
+  func responsesOf<T>(_: T.Type) -> AsyncCompactMapSequence<AsyncThrowingStream<
+    LiveServerMessage,
+    any Error
+  >, T> {
+    responses.compactMap { response in
+      switch response.payload {
+      case let .content(content):
+        if let casted = content as? T {
+          return casted
+        }
+      case let .toolCall(toolCall):
+        if let casted = toolCall as? T {
+          return casted
+        }
+      case let .toolCallCancellation(cancellation):
+        if let casted = cancellation as? T {
+          return casted
+        }
+      case let .goingAwayNotice(goingAway):
+        if let casted = goingAway as? T {
+          return casted
+        }
+      }
+      return nil
+    }
+  }
+}
+
+private extension ModelContent {
+  /// A collection of text from all parts.
+  ///
+  /// If this doesn't contain any `TextPart`, then an empty
+  /// string will be returned instead.
+  func allText() -> String {
+    parts.compactMap { ($0 as? TextPart)?.text }.joined()
+  }
+}
+
+extension LiveServerContent {
+  /// Text of the output `LiveAudioTranscript`, or an empty string if it's missing.
+  func outputAudioText() -> String {
+    outputAudioTranscription?.text ?? ""
+  }
+}
diff --git a/FirebaseAI/Tests/TestApp/Tests/Utilities/InstanceConfig.swift b/FirebaseAI/Tests/TestApp/Tests/Utilities/InstanceConfig.swift
index bf9d32c6e0d..4a91b00456d 100644
--- a/FirebaseAI/Tests/TestApp/Tests/Utilities/InstanceConfig.swift
+++ b/FirebaseAI/Tests/TestApp/Tests/Utilities/InstanceConfig.swift
@@ -26,6 +26,13 @@ struct InstanceConfig: Equatable, Encodable {
       version: .v1beta
     )
   )
+  static let vertexAI_v1beta_appCheckLimitedUse = InstanceConfig(
+    useLimitedUseAppCheckTokens: true,
+    apiConfig: APIConfig(
+      service: .vertexAI(endpoint: .firebaseProxyProd, location: "us-central1"),
+      version: .v1beta
+    )
+  )
   static let vertexAI_v1beta_global = InstanceConfig(
     apiConfig: APIConfig(
       service: .vertexAI(endpoint: .firebaseProxyProd, location: "global"),
@@ -76,6 +83,14 @@ struct InstanceConfig: Equatable, Encodable {
     // googleAI_v1beta_freeTier_bypassProxy,
   ]
 
+  static let liveConfigs = [
+    vertexAI_v1beta,
+    vertexAI_v1beta_appCheckLimitedUse,
+    googleAI_v1beta,
+    googleAI_v1beta_appCheckLimitedUse,
+    googleAI_v1beta_freeTier,
+  ]
+
   static let vertexAI_v1beta_appCheckNotConfigured = InstanceConfig(
     appName: FirebaseAppNames.appCheckNotConfigured,
     apiConfig: APIConfig(

From b73d18843274afd148afb5179a0e459c13a4b630 Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Fri, 10 Oct 2025 17:37:32 -0500
Subject: [PATCH 12/15] Remove unit tests

---
 .../Unit/TestUtilities/XCTExtensions.swift    |  30 ---
 ...idiGenerateContentServerMessageTests.swift | 191 ------------------
 .../Unit/Types/Live/VoiceConfigTests.swift    |  62 ------
 .../Tests/Unit/Types/ProtoDurationTests.swift |  99 ---------
 4 files changed, 382 deletions(-)
 delete mode 100644 FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift
 delete mode 100644 FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
 delete mode 100644 FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift
 delete mode 100644 FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift

diff --git a/FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift b/FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift
deleted file mode 100644
index 33ef11de6a7..00000000000
--- a/FirebaseAI/Tests/Unit/TestUtilities/XCTExtensions.swift
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2025 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.
-
-import XCTest
-
-/// Asserts that a string contains another string.
-///
-/// ```swift
-/// XCTAssertContains("my name is", "name")
-/// ```
-///
-/// - Parameters:
-///   - string: The source string that should contain the other.
-///   - contains: The string that should be contained in the source string.
-func XCTAssertContains(_ string: String, _ contains: String) {
-  if !string.contains(contains) {
-    XCTFail("(\"\(string)\") does not contain (\"\(contains)\")")
-  }
-}
diff --git a/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift b/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
deleted file mode 100644
index 710f7510ff0..00000000000
--- a/FirebaseAI/Tests/Unit/Types/Live/BidiGenerateContentServerMessageTests.swift
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright 2025 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.
-
-import XCTest
-
-@testable import FirebaseAI
-
-@available(iOS 15.0, macOS 12.0, macCatalyst 15.0, tvOS 15.0, *)
-@available(watchOS, unavailable)
-final class BidiGenerateContentServerMessageTests: XCTestCase {
-  let decoder = JSONDecoder()
-
-  func testDecodeBidiGenerateContentServerMessage_setupComplete() throws {
-    let json = """
-    {
-      "setupComplete" : {}
-    }
-    """
-    let jsonData = try XCTUnwrap(json.data(using: .utf8))
-
-    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
-    guard case .setupComplete = serverMessage.messageType else {
-      XCTFail("Decoded message is not a setupComplete message.")
-      return
-    }
-  }
-
-  func testDecodeBidiGenerateContentServerMessage_serverContent() throws {
-    let json = """
-    {
-      "serverContent" : {
-        "modelTurn" : {
-          "parts" : [
-            {
-              "inlineData" : {
-                "data" : "BQUFBQU=",
-                "mimeType" : "audio/pcm"
-              }
-            }
-          ],
-          "role" : "model"
-        },
-        "turnComplete": true,
-        "groundingMetadata": {
-          "webSearchQueries": ["query1", "query2"],
-          "groundingChunks": [
-            { "web": { "uri": "uri1", "title": "title1" } }
-          ],
-          "groundingSupports": [
-            { "segment": { "endIndex": 10, "text": "text" }, "groundingChunkIndices": [0] }
-          ],
-          "searchEntryPoint": { "renderedContent": "html" }
-        },
-        "inputTranscription": {
-          "text": "What day of the week is it?"
-        },
-        "outputTranscription": {
-          "text": "Today is friday"
-        }
-      }
-    }
-    """
-    let jsonData = try XCTUnwrap(json.data(using: .utf8))
-
-    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
-    guard case let .serverContent(serverContent) = serverMessage.messageType else {
-      XCTFail("Decoded message is not a serverContent message.")
-      return
-    }
-
-    XCTAssertEqual(serverContent.turnComplete, true)
-    XCTAssertNil(serverContent.interrupted)
-    XCTAssertNil(serverContent.generationComplete)
-
-    let modelTurn = try XCTUnwrap(serverContent.modelTurn)
-    XCTAssertEqual(modelTurn.role, "model")
-    XCTAssertEqual(modelTurn.parts.count, 1)
-    let part = try XCTUnwrap(modelTurn.parts.first as? InlineDataPart)
-    XCTAssertEqual(part.data, Data(repeating: 5, count: 5))
-    XCTAssertEqual(part.mimeType, "audio/pcm")
-
-    let metadata = try XCTUnwrap(serverContent.groundingMetadata)
-    XCTAssertEqual(metadata.webSearchQueries, ["query1", "query2"])
-    XCTAssertEqual(metadata.groundingChunks.count, 1)
-    let groundingChunk = try XCTUnwrap(metadata.groundingChunks.first)
-    let webChunk = try XCTUnwrap(groundingChunk.web)
-    XCTAssertEqual(webChunk.uri, "uri1")
-    XCTAssertEqual(metadata.groundingSupports.count, 1)
-    let groundingSupport = try XCTUnwrap(metadata.groundingSupports.first)
-    XCTAssertEqual(groundingSupport.segment.startIndex, 0)
-    XCTAssertEqual(groundingSupport.segment.partIndex, 0)
-    XCTAssertEqual(groundingSupport.segment.endIndex, 10)
-    XCTAssertEqual(groundingSupport.segment.text, "text")
-    let searchEntryPoint = try XCTUnwrap(metadata.searchEntryPoint)
-    XCTAssertEqual(searchEntryPoint.renderedContent, "html")
-
-    let inputTranscription = try XCTUnwrap(serverContent.inputTranscription)
-    XCTAssertEqual(inputTranscription.text, "What day of the week is it?")
-
-    let outputTranscription = try XCTUnwrap(serverContent.outputTranscription)
-    XCTAssertEqual(outputTranscription.text, "Today is friday")
-  }
-
-  func testDecodeBidiGenerateContentServerMessage_toolCall() throws {
-    let json = """
-    {
-      "toolCall" : {
-        "functionCalls" : [
-          {
-            "name": "changeBackgroundColor",
-            "id": "functionCall-12345-67890",
-            "args" : {
-              "color": "#F54927"
-            }
-          }
-        ]
-      }
-    }
-    """
-    let jsonData = try XCTUnwrap(json.data(using: .utf8))
-
-    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
-    guard case let .toolCall(toolCall) = serverMessage.messageType else {
-      XCTFail("Decoded message is not a toolCall message.")
-      return
-    }
-
-    let functionCalls = try XCTUnwrap(toolCall.functionCalls)
-    XCTAssertEqual(functionCalls.count, 1)
-    let functionCall = try XCTUnwrap(functionCalls.first)
-    XCTAssertEqual(functionCall.name, "changeBackgroundColor")
-    XCTAssertEqual(functionCall.id, "functionCall-12345-67890")
-    let args = try XCTUnwrap(functionCall.args)
-    guard case let .string(color) = args["color"] else {
-      XCTFail("Missing color argument")
-      return
-    }
-    XCTAssertEqual(color, "#F54927")
-  }
-
-  func testDecodeBidiGenerateContentServerMessage_toolCallCancellation() throws {
-    let json = """
-    {
-      "toolCallCancellation" : {
-        "ids" : ["functionCall-12345-67890"]
-      }
-    }
-    """
-    let jsonData = try XCTUnwrap(json.data(using: .utf8))
-
-    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
-    guard case let .toolCallCancellation(toolCallCancellation) = serverMessage.messageType else {
-      XCTFail("Decoded message is not a toolCallCancellation message.")
-      return
-    }
-
-    let ids = try XCTUnwrap(toolCallCancellation.ids)
-    XCTAssertEqual(ids, ["functionCall-12345-67890"])
-  }
-
-  func testDecodeBidiGenerateContentServerMessage_goAway() throws {
-    let json = """
-    {
-      "goAway" : {
-        "timeLeft": "1.23456789s"
-      }
-    }
-    """
-    let jsonData = try XCTUnwrap(json.data(using: .utf8))
-
-    let serverMessage = try decoder.decode(BidiGenerateContentServerMessage.self, from: jsonData)
-    guard case let .goAway(goAway) = serverMessage.messageType else {
-      XCTFail("Decoded message is not a goAway message.")
-      return
-    }
-
-    XCTAssertEqual(goAway.timeLeft?.seconds, 1)
-    XCTAssertEqual(goAway.timeLeft?.nanos, 234_567_890)
-  }
-}
diff --git a/FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift b/FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift
deleted file mode 100644
index 707c0088bdc..00000000000
--- a/FirebaseAI/Tests/Unit/Types/Live/VoiceConfigTests.swift
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2025 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.
-
-import XCTest
-
-@testable import FirebaseAI
-
-@available(iOS 15.0, macOS 12.0, macCatalyst 15.0, tvOS 15.0, *)
-@available(watchOS, unavailable)
-final class VoiceConfigTests: XCTestCase {
-  let encoder = JSONEncoder()
-
-  override func setUp() {
-    super.setUp()
-    encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
-  }
-
-  func testEncodeVoiceConfig_prebuiltVoice() throws {
-    let voice = VoiceConfig.prebuiltVoiceConfig(
-      PrebuiltVoiceConfig(voiceName: "Zephyr")
-    )
-
-    let jsonData = try encoder.encode(voice)
-
-    let json = try XCTUnwrap(String(data: jsonData, encoding: .utf8))
-    XCTAssertEqual(json, """
-    {
-      "prebuiltVoiceConfig" : {
-        "voiceName" : "Zephyr"
-      }
-    }
-    """)
-  }
-
-  func testEncodeVoiceConfig_customVoice() throws {
-    let voice = VoiceConfig.customVoiceConfig(
-      CustomVoiceConfig(customVoiceSample: Data(repeating: 5, count: 5))
-    )
-
-    let jsonData = try encoder.encode(voice)
-
-    let json = try XCTUnwrap(String(data: jsonData, encoding: .utf8))
-    XCTAssertEqual(json, """
-    {
-      "customVoiceConfig" : {
-        "customVoiceSample" : "BQUFBQU="
-      }
-    }
-    """)
-  }
-}
diff --git a/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift b/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift
deleted file mode 100644
index bddb50eef1d..00000000000
--- a/FirebaseAI/Tests/Unit/Types/ProtoDurationTests.swift
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2025 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.
-
-import XCTest
-
-@testable import FirebaseAI
-
-final class ProtoDurationTests: XCTestCase {
-  let decoder = JSONDecoder()
-
-  private func decodeProtoDuration(_ jsonString: String) throws -> ProtoDuration {
-    let escapedString = "\"\(jsonString)\""
-    let jsonData = try XCTUnwrap(escapedString.data(using: .utf8))
-
-    return try decoder.decode(ProtoDuration.self, from: jsonData)
-  }
-
-  private func expectDecodeFailure(_ jsonString: String) throws -> DecodingError.Context? {
-    do {
-      let _ = try decodeProtoDuration(jsonString)
-      XCTFail("Expected decoding to fail")
-      return nil
-    } catch {
-      let decodingError = try XCTUnwrap(error as? DecodingError)
-      guard case let .dataCorrupted(dataCorrupted) = decodingError else {
-        XCTFail("Error was not a data corrupted error")
-        return nil
-      }
-
-      return dataCorrupted
-    }
-  }
-
-  func testDecodeProtoDuration_standardDuration() throws {
-    let duration = try decodeProtoDuration("120.000000123s")
-    XCTAssertEqual(duration.seconds, 120)
-    XCTAssertEqual(duration.nanos, 123)
-
-    XCTAssertEqual(duration.timeInterval, 120.000000123)
-  }
-
-  func testDecodeProtoDuration_withoutNanoseconds() throws {
-    let duration = try decodeProtoDuration("120s")
-    XCTAssertEqual(duration.seconds, 120)
-    XCTAssertEqual(duration.nanos, 0)
-
-    XCTAssertEqual(duration.timeInterval, 120)
-  }
-
-  func testDecodeProtoDuration_maxNanosecondDigits() throws {
-    let duration = try decodeProtoDuration("15.123456789s")
-    XCTAssertEqual(duration.seconds, 15)
-    XCTAssertEqual(duration.nanos, 123_456_789)
-
-    XCTAssertEqual(duration.timeInterval, 15.123456789)
-  }
-
-  func testDecodeProtoDuration_withMilliseconds() throws {
-    let duration = try decodeProtoDuration("15.123s")
-    XCTAssertEqual(duration.seconds, 15)
-    XCTAssertEqual(duration.nanos, 123_000_000)
-
-    XCTAssertEqual(duration.timeInterval, 15.123000000)
-  }
-
-  func testDecodeProtoDuration_invalidSeconds() throws {
-    guard let error = try expectDecodeFailure("invalid.123s") else { return }
-    XCTAssertContains(error.debugDescription, "Invalid proto duration seconds")
-  }
-
-  func testDecodeProtoDuration_invalidNanoseconds() throws {
-    guard let error = try expectDecodeFailure("123.invalid") else { return }
-    XCTAssertContains(error.debugDescription, "Invalid proto duration nanoseconds")
-  }
-
-  func testDecodeProtoDuration_tooManyDecimals() throws {
-    guard let error = try expectDecodeFailure("123.45.67") else { return }
-    XCTAssertContains(error.debugDescription, "Invalid proto duration string")
-  }
-
-  func testDecodeProtoDuration_withoutSuffix() throws {
-    let duration = try decodeProtoDuration("123.456")
-    XCTAssertEqual(duration.seconds, 123)
-    XCTAssertEqual(duration.nanos, 456_000_000)
-
-    XCTAssertEqual(duration.timeInterval, 123.456)
-  }
-}

From 9d2dfa11cf5bac7ea91e93048db491cf8df574cf Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Fri, 10 Oct 2025 17:38:06 -0500
Subject: [PATCH 13/15] Revert ProtoDuration change

---
 .../Types/Internal/ProtoDuration.swift        | 36 +------------------
 1 file changed, 1 insertion(+), 35 deletions(-)

diff --git a/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift b/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
index d4af71b0346..1dac21d6429 100644
--- a/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
+++ b/FirebaseAI/Sources/Types/Internal/ProtoDuration.swift
@@ -107,40 +107,6 @@ extension ProtoDuration: Decodable {
     }
 
     self.seconds = secs
-    self.nanos = fractionalSecondsToNanoseconds(nanos, digits: nanoseconds.count)
+    self.nanos = nanos
   }
 }
-
-/// Cached powers of 10 for quickly mapping fractional seconds.
-private let pow10: [Int32] = [
-  1, 10, 100, 1000, 10000, 100_000,
-  1_000_000, 10_000_000, 100_000_000, 1_000_000_000,
-]
-
-/// Converts a fractional second representing a nanosecond to a valid nanosecond value.
-///
-/// ```swift
-/// // 0.123456
-/// XCTAssertEqual(
-///   fractionalSecondsToNanoseconds(123456, 6),
-///   123456000
-/// )
-///
-/// // 0.000123456
-/// XCTAssertEqual(
-///   fractionalSecondsToNanoseconds(123456, 9),
-///   123456
-/// )
-///
-/// // 0.123456789
-/// XCTAssertEqual(
-///   fractionalSecondsToNanoseconds(123456789, 9),
-///   123456789
-/// )
-/// ```
-private func fractionalSecondsToNanoseconds(_ value: Int32, digits: Int) -> Int32 {
-  precondition(digits >= 0 && digits <= 9, "A nanosecond value must fit within 0..9 digits")
-  precondition(value >= 0, "A nanosecond value must be positive")
-
-  return Int32(truncatingIfNeeded: value) &* pow10[9 - digits]
-}

From 1e3c02e7675f034dd0eec254deaccac017f741f7 Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Fri, 10 Oct 2025 17:38:26 -0500
Subject: [PATCH 14/15] Remove changelog entry

---
 FirebaseAI/CHANGELOG.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/FirebaseAI/CHANGELOG.md b/FirebaseAI/CHANGELOG.md
index b7999b9fa4a..06f5f30908d 100644
--- a/FirebaseAI/CHANGELOG.md
+++ b/FirebaseAI/CHANGELOG.md
@@ -1,7 +1,3 @@
-# Unreleased
-- [fixed] Fixed minor translation issue for nanosecond conversion when receiving
-  `LiveServerGoingAwayNotice`. (#15396)
-
 # 12.4.0
 - [feature] Added support for the URL context tool, which allows the model to access content
   from provided public web URLs to inform and enhance its responses. (#15221)

From 96730a75218b4ddcf824b5a5bc23ecf5df93cad7 Mon Sep 17 00:00:00 2001
From: Daymon <daymxn@google.com>
Date: Fri, 10 Oct 2025 17:45:54 -0500
Subject: [PATCH 15/15] Add bug link

---
 .../Tests/TestApp/Tests/Integration/LiveSessionTests.swift    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift b/FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift
index 119ee638dc6..599d98c0d06 100644
--- a/FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift
+++ b/FirebaseAI/Tests/TestApp/Tests/Integration/LiveSessionTests.swift
@@ -222,7 +222,7 @@ struct LiveSessionTests {
   }
 
   @Test(arguments: InstanceConfig.liveConfigs.filter {
-    // TODO: (b/XXXX) Remove when vertex adds support
+    // TODO: (b/450982184) Remove when vertex adds support
     switch $0.apiConfig.service {
     case .googleAI:
       true
@@ -231,7 +231,7 @@ struct LiveSessionTests {
     }
   })
   func realtime_functionCalling_cancellation(_ config: InstanceConfig) async throws {
-    // TODO: (b/XXXX) Remove when vertex adds support
+    // TODO: (b/450982184) Remove when vertex adds support
     guard case .googleAI = config.apiConfig.service else {
       Issue.record("Vertex does not currently support function ids or function cancellation.")
       return