Restore pre-TypedDict JSON dict overload when generate-typeddict is false

When generate-typeddict: false, the opt-out now performs a true revert to
pre-TypedDict behavior by restoring the standalone raw-JSON dict @overload
(and JSON in the impl Union) for both the explicit/model body path and the
spread path, instead of only dropping the TypedDict overload.

- add_overloads_for_body_param: only skip the single-body JSON overload when
  a TypedDict overload was actually inserted; otherwise keep it.
- add_body_param_type: insert the raw-JSON (any-object) overload via new
  _insert_json_overload helper when TypedDict generation is disabled.
- Update test_typeddict_overloads.py opt-out tests to assert the restored
  [model, JSON, binary] / flattened+JSON+binary overload sets.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 753f3788-98a9-4e39-8655-9c6a3ce90536

Author: l0lawrence

packages/http-client-python/generator/pygen/preprocess/__init__.py

@@ -94,9 +94,12 @@ def add_overloads_for_body_param(yaml_data: dict[str, Any]) -> None:
             continue
         if body_type.get("type") == "model" and body_type.get("base") == "json":
             yaml_data["overloads"].append(add_overload(yaml_data, body_type, for_flatten_params=True))
-            # Use the flattened JSON overload and skip the single-body JSON overload.
-            # When TypedDict generation is disabled, this JSON overload remains.
-            continue
+            # When a TypedDict overload was inserted, it replaces the single-body JSON
+            # overload, so skip it. When TypedDict generation is disabled, no TypedDict
+            # overload exists and we keep the single-body raw-JSON overload (pre-TypedDict
+            # behavior) by falling through.
+            if any(t.get("base") == "typeddict" for t in body_parameter["type"]["types"]):
+                continue
         yaml_data["overloads"].append(add_overload(yaml_data, body_type))
     content_type_param = next(p for p in yaml_data["parameters"] if p["wireName"].lower() == "content-type")
     content_type_param["inOverload"] = False
@@ -399,6 +402,25 @@ def _insert_typeddict_overload(
             if not existing_td:
                 code_model["types"].append(td_elem)
 
+    @staticmethod
+    def _insert_json_overload(
+        body_parameter: dict[str, Any],
+        origin_type: str,
+    ) -> None:
+        """Insert a raw-JSON (any-object) type into the body parameter's combined types.
+
+        This restores the pre-TypedDict dict-body overload used when TypedDict
+        generation is disabled.
+        """
+        if origin_type == "model":
+            body_parameter["type"]["types"].insert(1, KNOWN_TYPES["any-object"])
+        else:
+            # dict or list: copy the original container type and swap its element
+            # type for the raw-JSON any-object.
+            any_obj_list_or_dict = copy.deepcopy(body_parameter["type"]["types"][0])
+            any_obj_list_or_dict["elementType"] = KNOWN_TYPES["any-object"]
+            body_parameter["type"]["types"].insert(1, any_obj_list_or_dict)
+
     def add_body_param_type(
         self,
         code_model: dict[str, Any],
@@ -447,11 +469,15 @@ def add_body_param_type(
             if not (self.is_tsp and has_multi_part_content_type(body_parameter)) and not is_typeddict_only:
                 body_parameter["type"]["types"].append(KNOWN_TYPES["binary"])
 
-            # Add typeddict overload for non-spread dpg models
-            if self.options["models-mode"] == "dpg" and self.generate_typeddict and is_dpg_model:
-                cross_lang_id = model_type.get("crossLanguageDefinitionId")
-                existing_td = self._find_existing_typeddict(code_model, cross_lang_id, model_type.get("name"))
-                self._insert_typeddict_overload(code_model, body_parameter, model_type, origin_type, existing_td)
+            # Add the dict-body overload for non-spread dpg models: a TypedDict when
+            # enabled, otherwise the raw-JSON overload (pre-TypedDict behavior).
+            if self.options["models-mode"] == "dpg" and is_dpg_model:
+                if self.generate_typeddict:
+                    cross_lang_id = model_type.get("crossLanguageDefinitionId")
+                    existing_td = self._find_existing_typeddict(code_model, cross_lang_id, model_type.get("name"))
+                    self._insert_typeddict_overload(code_model, body_parameter, model_type, origin_type, existing_td)
+                else:
+                    self._insert_json_overload(body_parameter, origin_type)
 
             # For spread bodies (json base), add a typeddict overload that references
             # the original model. This replaces the JSON single-body overload.

packages/http-client-python/tests/unit/test_typeddict_overloads.py

@@ -105,7 +105,7 @@ def test_dpg_mode_still_emits_multiple_overloads():
 
 
 def test_dpg_mode_can_disable_typeddict_autogeneration():
-    """Opting out keeps the dpg model + binary overloads, but skips typeddict generation."""
+    """Opting out reverts to the pre-TypedDict overloads: model + raw-JSON + binary."""
     plugin = _plugin("dpg", **{"generate-typeddict": False})
     code_model, yaml_data, model_type = _json_model_operation()
     body_parameter = yaml_data["bodyParameter"]
@@ -114,13 +114,16 @@ def test_dpg_mode_can_disable_typeddict_autogeneration():
     add_overloads_for_body_param(yaml_data)
 
     assert body_parameter["type"]["type"] == "combined"
-    assert body_parameter["type"]["types"] == [model_type, {"type": "binary"}]
-    assert len(yaml_data["overloads"]) == 2
+    # The dict-body overload is the raw-JSON ``any-object`` (not a TypedDict).
+    assert body_parameter["type"]["types"] == [model_type, {"type": "any-object"}, {"type": "binary"}]
+    assert len(yaml_data["overloads"]) == 3
+    overload_types = [o["bodyParameter"]["type"]["type"] for o in yaml_data["overloads"]]
+    assert overload_types == ["model", "any-object", "binary"]
     assert not any(t for t in code_model["types"] if t.get("base") == "typeddict")
 
 
 def test_spread_body_opt_out_keeps_json_overload():
-    """Spread bodies keep the flattened JSON overload when TypedDict generation is disabled."""
+    """Spread bodies revert to pre-TypedDict: flattened + single-body JSON + binary."""
     plugin = _plugin("dpg", **{"generate-typeddict": False})
     spread_body = _json_spread_body_parameter("CreateRequest", "Contoso.Widget")
     yaml_data = {
@@ -139,9 +142,11 @@ def test_spread_body_opt_out_keeps_json_overload():
     assert spread_body["type"]["type"] == "combined"
     assert spread_body["type"]["types"][0]["base"] == "json"
     assert spread_body["type"]["types"][1] == {"type": "binary"}
-    assert len(yaml_data["overloads"]) == 2
-    json_overload = next(o for o in yaml_data["overloads"] if o["bodyParameter"]["type"].get("base") == "json")
-    assert json_overload["bodyParameter"]["flattened"] is True
+    assert len(yaml_data["overloads"]) == 3
+    json_overloads = [o for o in yaml_data["overloads"] if o["bodyParameter"]["type"].get("base") == "json"]
+    # Both a flattened (keyword params) overload AND a single-body raw-JSON overload.
+    assert any(o["bodyParameter"].get("flattened") for o in json_overloads)
+    assert any(not o["bodyParameter"].get("flattened") for o in json_overloads)
     assert not any(t for t in code_model["types"] if t.get("base") == "typeddict")