feat(talk): add provider-agnostic config with legacy compatibility

apps/android/app/src/main/java/ai/openclaw/android/voice/TalkModeManager.kt

@@ -54,6 +54,47 @@ class TalkModeManager(
     private const val tag = "TalkMode"
     private const val defaultModelIdFallback = "eleven_v3"
     private const val defaultOutputFormatFallback = "pcm_24000"
+    private const val defaultTalkProvider = "elevenlabs"
+
+    internal data class TalkProviderConfigSelection(
+      val provider: String,
+      val config: JsonObject,
+      val normalizedPayload: Boolean,
+    )
+
+    private fun normalizeTalkProviderId(raw: String?): String? {
+      val trimmed = raw?.trim()?.lowercase().orEmpty()
+      return trimmed.takeIf { it.isNotEmpty() }
+    }
+
+    internal fun selectTalkProviderConfig(talk: JsonObject?): TalkProviderConfigSelection? {
+      if (talk == null) return null
+      val rawProvider = talk["provider"].asStringOrNull()
+      val rawProviders = talk["providers"].asObjectOrNull()
+      val hasNormalizedPayload = rawProvider != null || rawProviders != null
+      if (hasNormalizedPayload) {
+        val providers =
+          rawProviders?.entries?.mapNotNull { (key, value) ->
+            val providerId = normalizeTalkProviderId(key) ?: return@mapNotNull null
+            val providerConfig = value.asObjectOrNull() ?: return@mapNotNull null
+            providerId to providerConfig
+          }?.toMap().orEmpty()
+        val providerId =
+          normalizeTalkProviderId(rawProvider)
+            ?: providers.keys.sorted().firstOrNull()
+            ?: defaultTalkProvider
+        return TalkProviderConfigSelection(
+          provider = providerId,
+          config = providers[providerId] ?: buildJsonObject {},
+          normalizedPayload = true,
+        )
+      }
+      return TalkProviderConfigSelection(
+        provider = defaultTalkProvider,
+        config = talk,
+        normalizedPayload = false,
+      )
+    }
   }
 
   private val mainHandler = Handler(Looper.getMainLooper())
@@ -818,30 +859,49 @@ class TalkModeManager(
       val root = json.parseToJsonElement(res).asObjectOrNull()
       val config = root?.get("config").asObjectOrNull()
       val talk = config?.get("talk").asObjectOrNull()
+      val selection = selectTalkProviderConfig(talk)
+      val activeProvider = selection?.provider ?: defaultTalkProvider
+      val activeConfig = selection?.config
       val sessionCfg = config?.get("session").asObjectOrNull()
       val mainKey = normalizeMainKey(sessionCfg?.get("mainKey").asStringOrNull())
-      val voice = talk?.get("voiceId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
+      val voice = activeConfig?.get("voiceId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
       val aliases =
-        talk?.get("voiceAliases").asObjectOrNull()?.entries?.mapNotNull { (key, value) ->
+        activeConfig?.get("voiceAliases").asObjectOrNull()?.entries?.mapNotNull { (key, value) ->
           val id = value.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } ?: return@mapNotNull null
           normalizeAliasKey(key).takeIf { it.isNotEmpty() }?.let { it to id }
         }?.toMap().orEmpty()
-      val model = talk?.get("modelId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
-      val outputFormat = talk?.get("outputFormat")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
-      val key = talk?.get("apiKey")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
+      val model = activeConfig?.get("modelId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
+      val outputFormat =
+        activeConfig?.get("outputFormat")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
+      val key = activeConfig?.get("apiKey")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() }
       val interrupt = talk?.get("interruptOnSpeech")?.asBooleanOrNull()
 
       if (!isCanonicalMainSessionKey(mainSessionKey)) {
         mainSessionKey = mainKey
       }
-      defaultVoiceId = voice ?: envVoice?.takeIf { it.isNotEmpty() } ?: sagVoice?.takeIf { it.isNotEmpty() }
+      defaultVoiceId =
+        if (activeProvider == defaultTalkProvider) {
+          voice ?: envVoice?.takeIf { it.isNotEmpty() } ?: sagVoice?.takeIf { it.isNotEmpty() }
+        } else {
+          voice
+        }
       voiceAliases = aliases
       if (!voiceOverrideActive) currentVoiceId = defaultVoiceId
       defaultModelId = model ?: defaultModelIdFallback
       if (!modelOverrideActive) currentModelId = defaultModelId
       defaultOutputFormat = outputFormat ?: defaultOutputFormatFallback
-      apiKey = key ?: envKey?.takeIf { it.isNotEmpty() }
+      apiKey =
+        if (activeProvider == defaultTalkProvider) {
+          key ?: envKey?.takeIf { it.isNotEmpty() }
+        } else {
+          null
+        }
       if (interrupt != null) interruptOnSpeech = interrupt
+      if (activeProvider != defaultTalkProvider) {
+        Log.w(tag, "talk provider $activeProvider unsupported; using system voice fallback")
+      } else if (selection?.normalizedPayload == true) {
+        Log.d(tag, "talk config provider=elevenlabs")
+      }
     } catch (_: Throwable) {
       defaultVoiceId = envVoice?.takeIf { it.isNotEmpty() } ?: sagVoice?.takeIf { it.isNotEmpty() }
       defaultModelId = defaultModelIdFallback

apps/android/app/src/test/java/ai/openclaw/android/voice/TalkModeConfigParsingTest.kt

@@ -0,0 +1,59 @@
+package ai.openclaw.android.voice
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.jsonObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class TalkModeConfigParsingTest {
+  private val json = Json { ignoreUnknownKeys = true }
+
+  @Test
+  fun prefersNormalizedTalkProviderPayload() {
+    val talk =
+      json.parseToJsonElement(
+          """
+          {
+            "provider": "elevenlabs",
+            "providers": {
+              "elevenlabs": {
+                "voiceId": "voice-normalized"
+              }
+            },
+            "voiceId": "voice-legacy"
+          }
+          """.trimIndent(),
+        )
+        .jsonObject
+
+    val selection = TalkModeManager.selectTalkProviderConfig(talk)
+    assertNotNull(selection)
+    assertEquals("elevenlabs", selection?.provider)
+    assertTrue(selection?.normalizedPayload == true)
+    assertEquals("voice-normalized", selection?.config?.get("voiceId")?.jsonPrimitive?.content)
+  }
+
+  @Test
+  fun fallsBackToLegacyTalkFieldsWhenNormalizedPayloadMissing() {
+    val talk =
+      json.parseToJsonElement(
+          """
+          {
+            "voiceId": "voice-legacy",
+            "apiKey": "legacy-key"
+          }
+          """.trimIndent(),
+        )
+        .jsonObject
+
+    val selection = TalkModeManager.selectTalkProviderConfig(talk)
+    assertNotNull(selection)
+    assertEquals("elevenlabs", selection?.provider)
+    assertTrue(selection?.normalizedPayload == false)
+    assertEquals("voice-legacy", selection?.config?.get("voiceId")?.jsonPrimitive?.content)
+    assertEquals("legacy-key", selection?.config?.get("apiKey")?.jsonPrimitive?.content)
+  }
+}

apps/ios/Sources/Gateway/GatewaySettingsStore.swift

@@ -25,7 +25,8 @@ enum GatewaySettingsStore {
     private static let instanceIdAccount = "instanceId"
     private static let preferredGatewayStableIDAccount = "preferredStableID"
     private static let lastDiscoveredGatewayStableIDAccount = "lastDiscoveredStableID"
-    private static let talkElevenLabsApiKeyAccount = "elevenlabs.apiKey"
+    private static let talkProviderApiKeyAccountPrefix = "provider.apiKey."
+    private static let talkElevenLabsApiKeyLegacyAccount = "elevenlabs.apiKey"
 
     static func bootstrapPersistence() {
         self.ensureStableInstanceID()
@@ -145,25 +146,52 @@ enum GatewaySettingsStore {
         case discovered
     }
 
-    static func loadTalkElevenLabsApiKey() -> String? {
+    static func loadTalkProviderApiKey(provider: String) -> String? {
+        guard let providerId = self.normalizedTalkProviderID(provider) else { return nil }
+        let account = self.talkProviderApiKeyAccount(providerId: providerId)
         let value = KeychainStore.loadString(
             service: self.talkService,
-            account: self.talkElevenLabsApiKeyAccount)?
+            account: account)?
             .trimmingCharacters(in: .whitespacesAndNewlines)
         if value?.isEmpty == false { return value }
+
+        if providerId == "elevenlabs" {
+            let legacyValue = KeychainStore.loadString(
+                service: self.talkService,
+                account: self.talkElevenLabsApiKeyLegacyAccount)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if legacyValue?.isEmpty == false {
+                _ = KeychainStore.saveString(legacyValue!, service: self.talkService, account: account)
+                return legacyValue
+            }
+        }
+
         return nil
     }
 
-    static func saveTalkElevenLabsApiKey(_ apiKey: String?) {
+    static func saveTalkProviderApiKey(_ apiKey: String?, provider: String) {
+        guard let providerId = self.normalizedTalkProviderID(provider) else { return }
+        let account = self.talkProviderApiKeyAccount(providerId: providerId)
         let trimmed = apiKey?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
         if trimmed.isEmpty {
-            _ = KeychainStore.delete(service: self.talkService, account: self.talkElevenLabsApiKeyAccount)
+            _ = KeychainStore.delete(service: self.talkService, account: account)
+            if providerId == "elevenlabs" {
+                _ = KeychainStore.delete(service: self.talkService, account: self.talkElevenLabsApiKeyLegacyAccount)
+            }
             return
         }
-        _ = KeychainStore.saveString(
-            trimmed,
-            service: self.talkService,
-            account: self.talkElevenLabsApiKeyAccount)
+        _ = KeychainStore.saveString(trimmed, service: self.talkService, account: account)
+        if providerId == "elevenlabs" {
+            _ = KeychainStore.delete(service: self.talkService, account: self.talkElevenLabsApiKeyLegacyAccount)
+        }
+    }
+
+    static func loadTalkElevenLabsApiKey() -> String? {
+        self.loadTalkProviderApiKey(provider: "elevenlabs")
+    }
+
+    static func saveTalkElevenLabsApiKey(_ apiKey: String?) {
+        self.saveTalkProviderApiKey(apiKey, provider: "elevenlabs")
     }
 
     static func saveLastGatewayConnectionManual(host: String, port: Int, useTLS: Bool, stableID: String) {
@@ -278,6 +306,15 @@ enum GatewaySettingsStore {
         "gateway-password.\(instanceId)"
     }
 
+    private static func talkProviderApiKeyAccount(providerId: String) -> String {
+        self.talkProviderApiKeyAccountPrefix + providerId
+    }
+
+    private static func normalizedTalkProviderID(_ provider: String) -> String? {
+        let trimmed = provider.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
     private static func ensureStableInstanceID() {
         let defaults = UserDefaults.standard
 

apps/ios/Sources/Voice/TalkModeManager.swift

@@ -16,6 +16,7 @@ import Speech
 final class TalkModeManager: NSObject {
     private typealias SpeechRequest = SFSpeechAudioBufferRecognitionRequest
     private static let defaultModelIdFallback = "eleven_v3"
+    private static let defaultTalkProvider = "elevenlabs"
     private static let redactedConfigSentinel = "__OPENCLAW_REDACTED__"
     var isEnabled: Bool = false
     var isListening: Bool = false
@@ -1885,6 +1886,46 @@ extension TalkModeManager {
         return trimmed
     }
 
+    struct TalkProviderConfigSelection {
+        let provider: String
+        let config: [String: Any]
+        let normalizedPayload: Bool
+    }
+
+    private static func normalizedTalkProviderID(_ raw: String?) -> String? {
+        let trimmed = (raw ?? "").trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
+    static func selectTalkProviderConfig(_ talk: [String: Any]?) -> TalkProviderConfigSelection? {
+        guard let talk else { return nil }
+        let rawProvider = talk["provider"] as? String
+        let rawProviders = talk["providers"] as? [String: Any]
+        let hasNormalized = rawProvider != nil || rawProviders != nil
+        if hasNormalized {
+            let providers = rawProviders ?? [:]
+            let normalizedProviders = providers.reduce(into: [String: [String: Any]]()) { acc, entry in
+                guard
+                    let providerID = Self.normalizedTalkProviderID(entry.key),
+                    let config = entry.value as? [String: Any]
+                else { return }
+                acc[providerID] = config
+            }
+            let providerID =
+                Self.normalizedTalkProviderID(rawProvider) ??
+                normalizedProviders.keys.sorted().first ??
+                Self.defaultTalkProvider
+            return TalkProviderConfigSelection(
+                provider: providerID,
+                config: normalizedProviders[providerID] ?? [:],
+                normalizedPayload: true)
+        }
+        return TalkProviderConfigSelection(
+            provider: Self.defaultTalkProvider,
+            config: talk,
+            normalizedPayload: false)
+    }
+
     func reloadConfig() async {
         guard let gateway else { return }
         do {
@@ -1892,8 +1933,12 @@ extension TalkModeManager {
             guard let json = try JSONSerialization.jsonObject(with: res) as? [String: Any] else { return }
             guard let config = json["config"] as? [String: Any] else { return }
             let talk = config["talk"] as? [String: Any]
-            self.defaultVoiceId = (talk?["voiceId"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
-            if let aliases = talk?["voiceAliases"] as? [String: Any] {
+            let selection = Self.selectTalkProviderConfig(talk)
+            let activeProvider = selection?.provider ?? Self.defaultTalkProvider
+            let activeConfig = selection?.config
+            self.defaultVoiceId = (activeConfig?["voiceId"] as? String)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if let aliases = activeConfig?["voiceAliases"] as? [String: Any] {
                 var resolved: [String: String] = [:]
                 for (key, value) in aliases {
                     guard let id = value as? String else { continue }
@@ -1909,22 +1954,28 @@ extension TalkModeManager {
             if !self.voiceOverrideActive {
                 self.currentVoiceId = self.defaultVoiceId
             }
-            let model = (talk?["modelId"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let model = (activeConfig?["modelId"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
             self.defaultModelId = (model?.isEmpty == false) ? model : Self.defaultModelIdFallback
             if !self.modelOverrideActive {
                 self.currentModelId = self.defaultModelId
             }
-            self.defaultOutputFormat = (talk?["outputFormat"] as? String)?
+            self.defaultOutputFormat = (activeConfig?["outputFormat"] as? String)?
                 .trimmingCharacters(in: .whitespacesAndNewlines)
-            let rawConfigApiKey = (talk?["apiKey"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let rawConfigApiKey = (activeConfig?["apiKey"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
             let configApiKey = Self.normalizedTalkApiKey(rawConfigApiKey)
-            let localApiKey = Self.normalizedTalkApiKey(GatewaySettingsStore.loadTalkElevenLabsApiKey())
+            let localApiKey = Self.normalizedTalkApiKey(
+                GatewaySettingsStore.loadTalkProviderApiKey(provider: activeProvider))
             if rawConfigApiKey == Self.redactedConfigSentinel {
                 self.apiKey = (localApiKey?.isEmpty == false) ? localApiKey : nil
                 GatewayDiagnostics.log("talk config apiKey redacted; using local override if present")
             } else {
                 self.apiKey = (localApiKey?.isEmpty == false) ? localApiKey : configApiKey
             }
+            if activeProvider != Self.defaultTalkProvider {
+                self.apiKey = nil
+                GatewayDiagnostics.log(
+                    "talk provider '\(activeProvider)' not yet supported on iOS; using system voice fallback")
+            }
             self.gatewayTalkDefaultVoiceId = self.defaultVoiceId
             self.gatewayTalkDefaultModelId = self.defaultModelId
             self.gatewayTalkApiKeyConfigured = (self.apiKey?.isEmpty == false)
@@ -1932,6 +1983,9 @@ extension TalkModeManager {
             if let interrupt = talk?["interruptOnSpeech"] as? Bool {
                 self.interruptOnSpeech = interrupt
             }
+            if selection?.normalizedPayload == true {
+                GatewayDiagnostics.log("talk config provider=\(activeProvider)")
+            }
         } catch {
             self.defaultModelId = Self.defaultModelIdFallback
             if !self.modelOverrideActive {

apps/ios/Tests/GatewaySettingsStoreTests.swift

@@ -9,9 +9,15 @@ private struct KeychainEntry: Hashable {
 
 private let gatewayService = "ai.openclaw.gateway"
 private let nodeService = "ai.openclaw.node"
+private let talkService = "ai.openclaw.talk"
 private let instanceIdEntry = KeychainEntry(service: nodeService, account: "instanceId")
 private let preferredGatewayEntry = KeychainEntry(service: gatewayService, account: "preferredStableID")
 private let lastGatewayEntry = KeychainEntry(service: gatewayService, account: "lastDiscoveredStableID")
+private let talkElevenLabsLegacyEntry = KeychainEntry(service: talkService, account: "elevenlabs.apiKey")
+private let talkElevenLabsProviderEntry = KeychainEntry(
+    service: talkService,
+    account: "provider.apiKey.elevenlabs")
+private let talkAcmeProviderEntry = KeychainEntry(service: talkService, account: "provider.apiKey.acme")
 
 private func snapshotDefaults(_ keys: [String]) -> [String: Any?] {
     let defaults = UserDefaults.standard
@@ -196,4 +202,34 @@ private func restoreKeychain(_ snapshot: [KeychainEntry: String?]) {
         let loaded = GatewaySettingsStore.loadLastGatewayConnection()
         #expect(loaded == .manual(host: "example.org", port: 18789, useTLS: false, stableID: "manual|example.org|18789"))
     }
+
+    @Test func talkProviderApiKey_genericRoundTrip() {
+        let keychainSnapshot = snapshotKeychain([talkAcmeProviderEntry])
+        defer { restoreKeychain(keychainSnapshot) }
+
+        _ = KeychainStore.delete(service: talkService, account: talkAcmeProviderEntry.account)
+
+        GatewaySettingsStore.saveTalkProviderApiKey("acme-key", provider: "acme")
+        #expect(GatewaySettingsStore.loadTalkProviderApiKey(provider: "acme") == "acme-key")
+
+        GatewaySettingsStore.saveTalkProviderApiKey(nil, provider: "acme")
+        #expect(GatewaySettingsStore.loadTalkProviderApiKey(provider: "acme") == nil)
+    }
+
+    @Test func talkProviderApiKey_elevenlabsLegacyFallbackMigratesToProviderKey() {
+        let keychainSnapshot = snapshotKeychain([talkElevenLabsLegacyEntry, talkElevenLabsProviderEntry])
+        defer { restoreKeychain(keychainSnapshot) }
+
+        _ = KeychainStore.delete(service: talkService, account: talkElevenLabsProviderEntry.account)
+        _ = KeychainStore.saveString(
+            "legacy-eleven-key",
+            service: talkService,
+            account: talkElevenLabsLegacyEntry.account)
+
+        let loaded = GatewaySettingsStore.loadTalkProviderApiKey(provider: "elevenlabs")
+        #expect(loaded == "legacy-eleven-key")
+        #expect(
+            KeychainStore.loadString(service: talkService, account: talkElevenLabsProviderEntry.account)
+                == "legacy-eleven-key")
+    }
 }

apps/ios/Tests/TalkModeConfigParsingTests.swift

@@ -0,0 +1,34 @@
+import Testing
+@testable import OpenClaw
+
+@Suite struct TalkModeConfigParsingTests {
+    @Test func prefersNormalizedTalkProviderPayload() async {
+        let talk: [String: Any] = [
+            "provider": "elevenlabs",
+            "providers": [
+                "elevenlabs": [
+                    "voiceId": "voice-normalized",
+                ],
+            ],
+            "voiceId": "voice-legacy",
+        ]
+
+        let selection = await MainActor.run { TalkModeManager.selectTalkProviderConfig(talk) }
+        #expect(selection?.provider == "elevenlabs")
+        #expect(selection?.normalizedPayload == true)
+        #expect(selection?.config["voiceId"] as? String == "voice-normalized")
+    }
+
+    @Test func fallsBackToLegacyTalkFieldsWhenNormalizedPayloadMissing() async {
+        let talk: [String: Any] = [
+            "voiceId": "voice-legacy",
+            "apiKey": "legacy-key",
+        ]
+
+        let selection = await MainActor.run { TalkModeManager.selectTalkProviderConfig(talk) }
+        #expect(selection?.provider == "elevenlabs")
+        #expect(selection?.normalizedPayload == false)
+        #expect(selection?.config["voiceId"] as? String == "voice-legacy")
+        #expect(selection?.config["apiKey"] as? String == "legacy-key")
+    }
+}

apps/macos/Sources/OpenClaw/TalkModeRuntime.swift

@@ -11,6 +11,7 @@ actor TalkModeRuntime {
     private let logger = Logger(subsystem: "ai.openclaw", category: "talk.runtime")
     private let ttsLogger = Logger(subsystem: "ai.openclaw", category: "talk.tts")
     private static let defaultModelIdFallback = "eleven_v3"
+    private static let defaultTalkProvider = "elevenlabs"
 
     private final class RMSMeter: @unchecked Sendable {
         private let lock = NSLock()
@@ -792,6 +793,48 @@ extension TalkModeRuntime {
         let apiKey: String?
     }
 
+    struct TalkProviderConfigSelection {
+        let provider: String
+        let config: [String: AnyCodable]
+        let normalizedPayload: Bool
+    }
+
+    private static func normalizedTalkProviderID(_ raw: String?) -> String? {
+        let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() ?? ""
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
+    static func selectTalkProviderConfig(
+        _ talk: [String: AnyCodable]?) -> TalkProviderConfigSelection?
+    {
+        guard let talk else { return nil }
+        let rawProvider = talk["provider"]?.stringValue
+        let rawProviders = talk["providers"]?.dictionaryValue
+        let hasNormalizedPayload = rawProvider != nil || rawProviders != nil
+        if hasNormalizedPayload {
+            let normalizedProviders =
+                rawProviders?.reduce(into: [String: [String: AnyCodable]]()) { acc, entry in
+                    guard
+                        let providerID = Self.normalizedTalkProviderID(entry.key),
+                        let providerConfig = entry.value.dictionaryValue
+                    else { return }
+                    acc[providerID] = providerConfig
+                } ?? [:]
+            let providerID =
+                Self.normalizedTalkProviderID(rawProvider) ??
+                normalizedProviders.keys.sorted().first ??
+                Self.defaultTalkProvider
+            return TalkProviderConfigSelection(
+                provider: providerID,
+                config: normalizedProviders[providerID] ?? [:],
+                normalizedPayload: true)
+        }
+        return TalkProviderConfigSelection(
+            provider: Self.defaultTalkProvider,
+            config: talk,
+            normalizedPayload: false)
+    }
+
     private func fetchTalkConfig() async -> TalkRuntimeConfig {
         let env = ProcessInfo.processInfo.environment
         let envVoice = env["ELEVENLABS_VOICE_ID"]?.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -804,13 +847,16 @@ extension TalkModeRuntime {
                 params: ["includeSecrets": AnyCodable(true)],
                 timeoutMs: 8000)
             let talk = snap.config?["talk"]?.dictionaryValue
+            let selection = Self.selectTalkProviderConfig(talk)
+            let activeProvider = selection?.provider ?? Self.defaultTalkProvider
+            let activeConfig = selection?.config
             let ui = snap.config?["ui"]?.dictionaryValue
             let rawSeam = ui?["seamColor"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
             await MainActor.run {
                 AppStateStore.shared.seamColorHex = rawSeam.isEmpty ? nil : rawSeam
             }
-            let voice = talk?["voiceId"]?.stringValue
-            let rawAliases = talk?["voiceAliases"]?.dictionaryValue
+            let voice = activeConfig?["voiceId"]?.stringValue
+            let rawAliases = activeConfig?["voiceAliases"]?.dictionaryValue
             let resolvedAliases: [String: String] =
                 rawAliases?.reduce(into: [:]) { acc, entry in
                     let key = entry.key.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
@@ -818,18 +864,30 @@ extension TalkModeRuntime {
                     guard !key.isEmpty, !value.isEmpty else { return }
                     acc[key] = value
                 } ?? [:]
-            let model = talk?["modelId"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let model = activeConfig?["modelId"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines)
             let resolvedModel = (model?.isEmpty == false) ? model! : Self.defaultModelIdFallback
-            let outputFormat = talk?["outputFormat"]?.stringValue
+            let outputFormat = activeConfig?["outputFormat"]?.stringValue
             let interrupt = talk?["interruptOnSpeech"]?.boolValue
-            let apiKey = talk?["apiKey"]?.stringValue
-            let resolvedVoice =
+            let apiKey = activeConfig?["apiKey"]?.stringValue
+            let resolvedVoice: String? = if activeProvider == Self.defaultTalkProvider {
                 (voice?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ? voice : nil) ??
                 (envVoice?.isEmpty == false ? envVoice : nil) ??
                 (sagVoice?.isEmpty == false ? sagVoice : nil)
-            let resolvedApiKey =
+            } else {
+                (voice?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ? voice : nil)
+            }
+            let resolvedApiKey: String? = if activeProvider == Self.defaultTalkProvider {
                 (envApiKey?.isEmpty == false ? envApiKey : nil) ??
                 (apiKey?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ? apiKey : nil)
+            } else {
+                nil
+            }
+            if activeProvider != Self.defaultTalkProvider {
+                self.ttsLogger
+                    .info("talk provider \(activeProvider, privacy: .public) unsupported; using system voice")
+            } else if selection?.normalizedPayload == true {
+                self.ttsLogger.info("talk config provider elevenlabs")
+            }
             return TalkRuntimeConfig(
                 voiceId: resolvedVoice,
                 voiceAliases: resolvedAliases,

apps/macos/Tests/OpenClawIPCTests/TalkModeConfigParsingTests.swift

@@ -0,0 +1,36 @@
+import OpenClawProtocol
+import Testing
+
+@testable import OpenClaw
+
+@Suite struct TalkModeConfigParsingTests {
+    @Test func prefersNormalizedTalkProviderPayload() {
+        let talk: [String: AnyCodable] = [
+            "provider": AnyCodable("elevenlabs"),
+            "providers": AnyCodable([
+                "elevenlabs": [
+                    "voiceId": "voice-normalized",
+                ],
+            ]),
+            "voiceId": AnyCodable("voice-legacy"),
+        ]
+
+        let selection = TalkModeRuntime.selectTalkProviderConfig(talk)
+        #expect(selection?.provider == "elevenlabs")
+        #expect(selection?.normalizedPayload == true)
+        #expect(selection?.config["voiceId"]?.stringValue == "voice-normalized")
+    }
+
+    @Test func fallsBackToLegacyTalkFieldsWhenNormalizedPayloadMissing() {
+        let talk: [String: AnyCodable] = [
+            "voiceId": AnyCodable("voice-legacy"),
+            "apiKey": AnyCodable("legacy-key"),
+        ]
+
+        let selection = TalkModeRuntime.selectTalkProviderConfig(talk)
+        #expect(selection?.provider == "elevenlabs")
+        #expect(selection?.normalizedPayload == false)
+        #expect(selection?.config["voiceId"]?.stringValue == "voice-legacy")
+        #expect(selection?.config["apiKey"]?.stringValue == "legacy-key")
+    }
+}