Enable Swift 6 checks

Author: renal128

.github/workflows/ci.yml

@@ -4,9 +4,11 @@ on:
   push:
     branches:
       - main
+      - next
   pull_request:
     branches:
       - main
+      - next
 
 permissions:
   contents: read
@@ -52,36 +54,33 @@ jobs:
       - name: Test (release)
         run: swift test --configuration release
 
-  # Swift 6 strict build temporarily disabled because LiveKit pins JWTKit to
-  # 4.13.x, which lacks Sendable annotations. Re-enable after upstream fixes.
-  # Tracking: https://github.com/livekit/client-sdk-swift/issues/846
-  # swift6-strict:
-  #   runs-on: macos-15
-  #   timeout-minutes: 30
-  #   needs: build
-  #   env:
-  #     SWIFT_STRICT_FLAGS: "-Xswiftc -swift-version -Xswiftc 6"
-  #
-  #   steps:
-  #     - name: Checkout
-  #       uses: actions/checkout@v3
-  #
-  #     - name: Set up Xcode 16.4
-  #       run: sudo xcode-select -s /Applications/Xcode_16.4.0.app
-  #
-  #     - name: Cache SwiftPM dependencies (Swift 6 strict)
-  #       uses: actions/cache@v4
-  #       with:
-  #         path: .build
-  #         key: ${{ runner.os }}-spm-strict-${{ hashFiles('Package.resolved') }}
-  #         restore-keys: |
-  #           ${{ runner.os }}-spm-
-  #
-  #     - name: Resolve dependencies
-  #       run: swift package resolve
-  #
-  #     - name: Build (Swift 6 strict)
-  #       run: swift build $SWIFT_STRICT_FLAGS
-  #
-  #     - name: Test (Swift 6 strict)
-  #       run: swift test $SWIFT_STRICT_FLAGS
+  swift6-strict:
+    runs-on: macos-15
+    timeout-minutes: 30
+    needs: build
+    env:
+      SWIFT_STRICT_FLAGS: "-Xswiftc -swift-version -Xswiftc 6"
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Set up Xcode 16.4
+        run: sudo xcode-select -s /Applications/Xcode_16.4.0.app
+
+      - name: Cache SwiftPM dependencies (Swift 6 strict)
+        uses: actions/cache@v4
+        with:
+          path: .build
+          key: ${{ runner.os }}-spm-strict-${{ hashFiles('Package.resolved') }}
+          restore-keys: |
+            ${{ runner.os }}-spm-
+
+      - name: Resolve dependencies
+        run: swift package resolve
+
+      - name: Build (Swift 6 strict)
+        run: swift build $SWIFT_STRICT_FLAGS
+
+      - name: Test (Swift 6 strict)
+        run: swift test $SWIFT_STRICT_FLAGS

Package.swift

@@ -31,9 +31,6 @@ let package = Package(
             dependencies: [
                 .product(name: "LiveKit", package: "client-sdk-swift")
             ],
-            // TODO: Re-enable StrictConcurrency once LiveKit depends on a JWTKit
-            // release where Sendable annotations are available (4.13.x patch or 5.x).
-            // Tracking: https://github.com/livekit/client-sdk-swift/issues/846
             exclude: [
                 "Internal/Protocol/schemas/agent.asyncapi.yaml"
             ],

Package@swift-6.0.swift

@@ -31,9 +31,6 @@ let package = Package(
             dependencies: [
                 .product(name: "LiveKit", package: "client-sdk-swift")
             ],
-            // TODO: Re-enable StrictConcurrency once LiveKit depends on a JWTKit
-            // release where Sendable annotations are available (4.13.x patch or 5.x).
-            // Tracking: https://github.com/livekit/client-sdk-swift/issues/846
             exclude: [
                 "Internal/Protocol/schemas/agent.asyncapi.yaml"
             ],

Package@swift-6.2.swift

@@ -31,9 +31,6 @@ let package = Package(
             dependencies: [
                 .product(name: "LiveKit", package: "client-sdk-swift")
             ],
-            // TODO: Re-enable StrictConcurrency once LiveKit depends on a JWTKit
-            // release where Sendable annotations are available (4.13.x patch or 5.x).
-            // Tracking: https://github.com/livekit/client-sdk-swift/issues/846
             exclude: [
                 "Internal/Protocol/schemas/agent.asyncapi.yaml"
             ],

Sources/ElevenLabs/Internal/Conversation/Conversation.swift

@@ -387,17 +387,10 @@ final class Conversation: ObservableObject {
 
         setupAgentStateManager()
 
-        connectionManager.onEventReceived = { [weak self, weak connectionManager] event in
-            Task { @MainActor [weak self, weak connectionManager] in
-                guard let self,
-                      let connectionManager,
-                      activeConnectionManager === connectionManager,
-                      state.isConnecting || state.isConnected
-                else {
-                    return
-                }
-
-                await handleIncomingEvent(event)
+        let connectionManagerID = ObjectIdentifier(connectionManager)
+        connectionManager.onEventReceived = { [weak self] event in
+            Task { @MainActor [weak self] in
+                await self?.handleIncomingEvent(event, from: connectionManagerID)
             }
         }
         connectionManager.onDisconnected = { [weak self] in
@@ -406,6 +399,16 @@ final class Conversation: ObservableObject {
         }
     }
 
+    private func handleIncomingEvent(_ event: IncomingEvent, from connectionManagerID: ObjectIdentifier) async {
+        guard let activeConnectionManager,
+              ObjectIdentifier(activeConnectionManager) == connectionManagerID,
+              state.isConnecting || state.isConnected
+        else {
+            return
+        }
+        await handleIncomingEvent(event)
+    }
+
     private func handleStartupFailure(
         _ error: ConversationError,
         disconnecting connectionManager: any ConnectionManaging

Sources/ElevenLabs/Internal/Conversation/ConversationAudioManager.swift

@@ -10,7 +10,6 @@ import LiveKit
 final class ConversationAudioManager {
     private(set) var softwareMuteProcessor: SoftwareMuteProcessor?
 
-    private let audioManager = AudioManager.shared
     private var previousSpeechActivityHandler: AudioManager.OnSpeechActivity?
     private var audioSpeechHandlerInstalled = false
     private let logger: any Logging
@@ -22,7 +21,7 @@ final class ConversationAudioManager {
 
     deinit {
         if audioSpeechHandlerInstalled {
-            audioManager.onMutedSpeechActivity = previousSpeechActivityHandler
+            AudioManager.shared.onMutedSpeechActivity = previousSpeechActivityHandler
         }
     }
 
@@ -34,22 +33,22 @@ final class ConversationAudioManager {
         let muteMode = audioConfig?.microphoneMuteMode ?? .inputMixer
 
         do {
-            try audioManager.set(microphoneMuteMode: muteMode.toLiveKit())
+            try AudioManager.shared.set(microphoneMuteMode: muteMode.toLiveKit())
         } catch {
             logger.warning("Failed to set microphone mute mode", context: ["error": "\(error)"])
         }
 
         if let bypass = audioConfig?.voiceProcessingBypassed {
-            audioManager.isVoiceProcessingBypassed = bypass
+            AudioManager.shared.isVoiceProcessingBypassed = bypass
         }
 
         if let agc = audioConfig?.voiceProcessingAGCEnabled {
-            audioManager.isVoiceProcessingAGCEnabled = agc
+            AudioManager.shared.isVoiceProcessingAGCEnabled = agc
         }
 
         if let prepared = audioConfig?.recordingAlwaysPrepared {
             do {
-                try await audioManager.setRecordingAlwaysPreparedMode(prepared)
+                try await AudioManager.shared.setRecordingAlwaysPreparedMode(prepared)
             } catch {
                 logger.warning("Failed to set recording always prepared mode", context: ["error": "\(error)"])
             }
@@ -70,7 +69,7 @@ final class ConversationAudioManager {
     private func setupInitialConfiguration() {
         // Set initial microphone mute mode
         do {
-            try audioManager.set(microphoneMuteMode: LiveKit.MicrophoneMuteMode.inputMixer)
+            try AudioManager.shared.set(microphoneMuteMode: LiveKit.MicrophoneMuteMode.inputMixer)
         } catch {
             logger.warning("Failed to set initial microphone mute mode", context: ["error": "\(error)"])
         }
@@ -79,7 +78,7 @@ final class ConversationAudioManager {
         Task { [weak self] in
             guard let self else { return }
             do {
-                try await audioManager.setRecordingAlwaysPreparedMode(true)
+                try await AudioManager.shared.setRecordingAlwaysPreparedMode(true)
             } catch {
                 logger.warning("Failed to set recording always prepared mode", context: ["error": "\(error)"])
             }
@@ -89,14 +88,13 @@ final class ConversationAudioManager {
     private func configureSpeechHandler(muteMode: MicrophoneMuteMode, callbacks: ConversationCallbacks) {
         if muteMode == .voiceProcessing, let onSpeechDetectedWhileMuted = callbacks.onSpeechDetectedWhileMuted {
             if !audioSpeechHandlerInstalled {
-                previousSpeechActivityHandler = audioManager.onMutedSpeechActivity
+                previousSpeechActivityHandler = AudioManager.shared.onMutedSpeechActivity
                 audioSpeechHandlerInstalled = true
             }
-            audioManager.onMutedSpeechActivity = { _, event in
+            AudioManager.shared.onMutedSpeechActivity = { _, event in
+                guard event == .started else { return }
                 Task { @MainActor in
-                    if event == .started {
-                        onSpeechDetectedWhileMuted()
-                    }
+                    onSpeechDetectedWhileMuted()
                 }
             }
         } else if audioSpeechHandlerInstalled {
@@ -122,7 +120,7 @@ final class ConversationAudioManager {
 
     private func cleanupSpeechHandler() {
         if audioSpeechHandlerInstalled {
-            audioManager.onMutedSpeechActivity = previousSpeechActivityHandler
+            AudioManager.shared.onMutedSpeechActivity = previousSpeechActivityHandler
             previousSpeechActivityHandler = nil
             audioSpeechHandlerInstalled = false
         }

Sources/ElevenLabs/Internal/Networking/ConnectionManaging.swift

@@ -5,6 +5,7 @@ enum ConnectionManagerError: Error {
     case notConnected
 }
 
+@MainActor
 protocol ConnectionManaging: AnyObject {
     var onEventReceived: (@Sendable (IncomingEvent) -> Void)? { get set }
     var onDisconnected: (() async -> Void)? { get set }
@@ -21,8 +22,10 @@ protocol ConnectionManaging: AnyObject {
     func send(data: Data) async throws
 }
 
+@MainActor
 protocol WebSocketConnectionManaging: ConnectionManaging {}
 
+@MainActor
 protocol WebRTCConnectionManaging: ConnectionManaging {
     var onRemoteSpeakingChanged: (@Sendable (Bool) -> Void)? { get set }
     /// Fired when an audio track is published/subscribed/unpublished/unsubscribed.
@@ -35,17 +38,19 @@ protocol WebRTCConnectionManaging: ConnectionManaging {
 }
 
 extension ConnectionManaging {
-    func handleIncomingData(
+    /// Parses transport data off the main actor before delivering events on it.
+    nonisolated static func handleIncomingData(
         _ data: Data,
         metadataWaiter: ConversationInitiationMetadataWaiter,
-        logger: any Logging
-    ) {
+        logger: any Logging,
+        onEvent: @escaping @MainActor @Sendable (IncomingEvent) -> Void
+    ) async {
         do {
             if let event = try EventParser.parseIncomingEvent(from: data) {
                 if case let .conversationMetadata(metadata) = event {
-                    Task { await metadataWaiter.observe(metadata) }
+                    await metadataWaiter.observe(metadata)
                 }
-                onEventReceived?(event)
+                await onEvent(event)
             }
         } catch let EventParseError.unknownEventType(type) {
             // Unrecognized event types are expected (newer server) — not errors.

Sources/ElevenLabs/Internal/Networking/WebRTCConnectionManager.swift

@@ -24,6 +24,7 @@ enum WebRTCConnectionManagerError: Error {
 ///
 /// LiveKit room/track types stay internal to this manager; consumers observe
 /// audio via ``ConversationAudioObserver`` rather than LiveKit track APIs.
+@MainActor
 final class WebRTCConnectionManager: WebRTCConnectionManaging {
     /// Fired when the remote agent leaves, the room disconnects, or all remote participants are gone.
     var onDisconnected: (() async -> Void)?
@@ -62,6 +63,7 @@ final class WebRTCConnectionManager: WebRTCConnectionManaging {
     private var eventDelegate: LiveKitRoomEventDelegate?
     private var readinessDelegate: LiveKitReadinessDelegate?
     private var initiationMetadataWaiter: ConversationInitiationMetadataWaiter?
+    private var dataTask: Task<Void, Never>?
 
     private static let reliableDataPublishOptions = DataPublishOptions(reliable: true)
 
@@ -185,7 +187,7 @@ final class WebRTCConnectionManager: WebRTCConnectionManaging {
             }
             let first = await group.next()!
             if case .timedOut = first {
-                await delegate.release()
+                delegate.release()
             }
             group.cancelAll()
             return first
@@ -231,23 +233,42 @@ final class WebRTCConnectionManager: WebRTCConnectionManaging {
         networkConfiguration: WebRTCConfiguration,
         metadataWaiter: ConversationInitiationMetadataWaiter
     ) async throws {
-        await readinessDelegate?.release()
+        dataTask?.cancel()
+        readinessDelegate?.release()
 
-        let readinessDelegate = await LiveKitReadinessDelegate(logger: logger)
+        let readinessDelegate = LiveKitReadinessDelegate(logger: logger)
         self.readinessDelegate = readinessDelegate
 
         let logger = logger
+        let (dataStream, dataContinuation) = AsyncStream.makeStream(of: Data.self)
         let eventDelegate = LiveKitRoomEventDelegate(
-            onData: { [weak self] data in
-                self?.handleIncomingData(data, metadataWaiter: metadataWaiter, logger: logger)
+            onData: { dataContinuation.yield($0) },
+            onRemoteSpeaking: { [weak self] isSpeaking in
+                Task { @MainActor [weak self] in
+                    self?.onRemoteSpeakingChanged?(isSpeaking)
+                }
+            },
+            onRemoteDisconnect: { [weak self] in
+                await self?.handleRemoteDisconnect()
             },
-            onRemoteSpeaking: { [weak self] isSpeaking in self?.onRemoteSpeakingChanged?(isSpeaking) },
-            onRemoteDisconnect: { [weak self] in await self?.onDisconnected?() },
             onTracksChanged: { [weak self] in
                 Task { @MainActor in self?.onTracksChanged?() }
             }
         )
         self.eventDelegate = eventDelegate
+        // One consumer preserves packet order while parsing off the main actor.
+        dataTask = Task { [weak self] in
+            for await data in dataStream {
+                await Self.handleIncomingData(
+                    data,
+                    metadataWaiter: metadataWaiter,
+                    logger: logger,
+                    onEvent: { [weak self] event in
+                        self?.onEventReceived?(event)
+                    }
+                )
+            }
+        }
 
         let room = Room(roomOptions: RoomOptions(singlePeerConnection: true))
         self.room = room
@@ -299,21 +320,27 @@ final class WebRTCConnectionManager: WebRTCConnectionManaging {
 
         await initiationMetadataWaiter?.cancel()
         initiationMetadataWaiter = nil
-        await readinessDelegate?.release()
+        dataTask?.cancel()
+        dataTask = nil
+        readinessDelegate?.release()
         readinessDelegate = nil
 
         await room?.disconnect()
         room = nil
         eventDelegate = nil
     }
 
+    private func handleRemoteDisconnect() async {
+        await onDisconnected?()
+    }
+
     // MARK: – Private helpers
 
     /// Run one timed startup phase: record its duration into `metrics[keyPath:]`,
     /// let `CancellationError` propagate unwrapped, and wrap any other error as
     /// `ConversationError` (stamping `total`).
     @MainActor
-    private func runPhase<T>(
+    private func runPhase<T: Sendable>(
         timing keyPath: WritableKeyPath<ConversationStartupMetrics, TimeInterval?>,
         metrics: inout ConversationStartupMetrics,
         startTime: Date,