refactor: require canonical talk resolved payload

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

@@ -93,29 +93,7 @@ class TalkModeManager(
       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 explicitProviderId = normalizeTalkProviderId(rawProvider)
-        if (explicitProviderId != null) {
-          if (providers.isNotEmpty() && providers[explicitProviderId] == null) {
-            return null
-          }
-          return TalkProviderConfigSelection(
-            provider = explicitProviderId,
-            config = providers[explicitProviderId] ?: buildJsonObject {},
-            normalizedPayload = true,
-          )
-        }
-        val providerId = providers.keys.singleOrNull() ?: return null
-        return TalkProviderConfigSelection(
-          provider = providerId,
-          config = providers[providerId] ?: buildJsonObject {},
-          normalizedPayload = true,
-        )
+        return null
       }
       return TalkProviderConfigSelection(
         provider = defaultTalkProvider,
@@ -1425,6 +1403,9 @@ class TalkModeManager(
       val config = root?.get("config").asObjectOrNull()
       val talk = config?.get("talk").asObjectOrNull()
       val selection = selectTalkProviderConfig(talk)
+      if (talk != null && selection == null) {
+        Log.w(tag, "talk config ignored: normalized payload missing talk.resolved")
+      }
       val activeProvider = selection?.provider ?: defaultTalkProvider
       val activeConfig = selection?.config
       val sessionCfg = config?.get("session").asObjectOrNull()

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

@@ -62,10 +62,7 @@ class TalkModeConfigParsingTest {
         .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)
+    assertEquals(null, selection)
   }
 
   @Test

apps/ios/Sources/Voice/TalkModeManager.swift

@@ -1996,7 +1996,7 @@ extension TalkModeManager {
             let selection = Self.selectTalkProviderConfig(talk)
             if talk != nil, selection == nil {
                 GatewayDiagnostics.log(
-                    "talk config ignored: legacy payload unsupported on iOS beta; expected talk.provider/providers")
+                    "talk config ignored: normalized payload missing talk.resolved")
             }
             let activeProvider = selection?.provider ?? Self.defaultTalkProvider
             let activeConfig = selection?.config

apps/ios/Tests/Logic/TalkConfigParsingTests.swift

@@ -5,7 +5,7 @@ import Testing
 private let iOSSilenceTimeoutMs = 900
 
 @Suite struct TalkConfigParsingTests {
-    @Test func prefersNormalizedTalkProviderPayload() {
+    @Test func rejectsNormalizedTalkProviderPayloadWithoutResolved() {
         let talk: [String: Any] = [
             "provider": "elevenlabs",
             "providers": [
@@ -20,8 +20,7 @@ private let iOSSilenceTimeoutMs = 900
             TalkConfigParsing.bridgeFoundationDictionary(talk),
             defaultProvider: "elevenlabs",
             allowLegacyFallback: false)
-        #expect(selection?.provider == "elevenlabs")
-        #expect(selection?.config["voiceId"]?.stringValue == "voice-normalized")
+        #expect(selection == nil)
     }
 
     @Test func ignoresLegacyTalkFieldsWhenNormalizedPayloadMissing() {

apps/macos/Sources/OpenClaw/TalkModeRuntime.swift

@@ -831,6 +831,9 @@ extension TalkModeRuntime {
                 timeoutMs: 8000)
             let talk = snap.config?["talk"]?.dictionaryValue
             let selection = Self.selectTalkProviderConfig(talk)
+            if talk != nil, selection == nil {
+                self.ttsLogger.info("talk config ignored: normalized payload missing talk.resolved")
+            }
             let activeProvider = selection?.provider ?? Self.defaultTalkProvider
             let activeConfig = selection?.config
             let silenceTimeoutMs = Self.resolvedSilenceTimeoutMs(talk)
@@ -870,7 +873,7 @@ extension TalkModeRuntime {
                 self.ttsLogger
                     .info("talk provider \(activeProvider, privacy: .public) unsupported; using system voice")
             } else if selection?.normalizedPayload == true {
-                self.ttsLogger.info("talk config provider elevenlabs")
+                self.ttsLogger.info("talk config provider from talk.resolved")
             }
             return TalkRuntimeConfig(
                 voiceId: resolvedVoice,

apps/macos/Tests/OpenClawIPCTests/TalkModeConfigParsingTests.swift

@@ -3,7 +3,7 @@ import Testing
 @testable import OpenClaw
 
 struct TalkModeConfigParsingTests {
-    @Test func `prefers normalized talk provider payload`() {
+    @Test func `rejects normalized talk provider payload without resolved`() {
         let talk: [String: AnyCodable] = [
             "provider": AnyCodable("elevenlabs"),
             "providers": AnyCodable([
@@ -15,9 +15,7 @@ struct TalkModeConfigParsingTests {
         ]
 
         let selection = TalkModeRuntime.selectTalkProviderConfig(talk)
-        #expect(selection?.provider == "elevenlabs")
-        #expect(selection?.normalizedPayload == true)
-        #expect(selection?.config["voiceId"]?.stringValue == "voice-normalized")
+        #expect(selection == nil)
     }
 
     @Test func `falls back to legacy talk fields when normalized payload missing`() {

apps/shared/OpenClawKit/Sources/OpenClawKit/TalkConfigParsing.swift

@@ -26,28 +26,9 @@ public enum TalkConfigParsing {
         if let resolvedSelection = self.resolvedProviderConfig(talk) {
             return resolvedSelection
         }
-        let rawProvider = talk["provider"]?.stringValue
-        let rawProviders = talk["providers"]
-        let hasNormalizedPayload = rawProvider != nil || rawProviders != nil
+        let hasNormalizedPayload = talk["provider"] != nil || talk["providers"] != nil
         if hasNormalizedPayload {
-            let normalizedProviders = self.normalizedTalkProviders(rawProviders)
-            let explicitProviderID = self.normalizedTalkProviderID(rawProvider)
-            if let explicitProviderID {
-                if !normalizedProviders.isEmpty, normalizedProviders[explicitProviderID] == nil {
-                    return nil
-                }
-                return TalkProviderConfigSelection(
-                    provider: explicitProviderID,
-                    config: normalizedProviders[explicitProviderID] ?? [:],
-                    normalizedPayload: true)
-            }
-            guard normalizedProviders.count == 1, let providerID = normalizedProviders.keys.first else {
-                return nil
-            }
-            return TalkProviderConfigSelection(
-                provider: providerID,
-                config: normalizedProviders[providerID] ?? [:],
-                normalizedPayload: true)
+            return nil
         }
         guard allowLegacyFallback else { return nil }
         return TalkProviderConfigSelection(
@@ -92,15 +73,4 @@ public enum TalkConfigParsing {
             config: resolved["config"]?.dictionaryValue ?? [:],
             normalizedPayload: true)
     }
-
-    private static func normalizedTalkProviders(_ raw: AnyCodable?) -> [String: [String: AnyCodable]] {
-        guard let providerMap = raw?.dictionaryValue else { return [:] }
-        return providerMap.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
-        }
-    }
 }

apps/shared/OpenClawKit/Tests/OpenClawKitTests/TalkConfigParsingTests.swift

@@ -24,7 +24,7 @@ struct TalkConfigParsingTests {
         #expect(selection?.config["voiceId"]?.stringValue == "voice-resolved")
     }
 
-    @Test func prefersNormalizedTalkProviderPayload() {
+    @Test func rejectsNormalizedTalkProviderPayloadWithoutResolved() {
         let talk: [String: AnyCodable] = [
             "provider": AnyCodable("elevenlabs"),
             "providers": AnyCodable([
@@ -36,9 +36,7 @@ struct TalkConfigParsingTests {
         ]
 
         let selection = TalkConfigParsing.selectProviderConfig(talk, defaultProvider: "elevenlabs")
-        #expect(selection?.provider == "elevenlabs")
-        #expect(selection?.normalizedPayload == true)
-        #expect(selection?.config["voiceId"]?.stringValue == "voice-normalized")
+        #expect(selection == nil)
     }
 
     @Test func fallsBackToLegacyTalkFieldsWhenNormalizedPayloadMissing() {