Fix single-body JSON overload skip for models-mode: typeddict spread bodies

The skip condition sniffed for a combined-type member with base == typeddict,
but in models-mode: typeddict a spread body inserts the original base: dpg
model as its overload (it renders as a TypedDict via models-mode). That made
the sniff false, so the single-body JSON overload was wrongly kept, regressing
the prior behavior where the TypedDict overload replaced it.

Track this explicitly with a jsonOverloadReplacedByTypeddict flag set by
add_body_param_type wherever a TypedDict-style overload is inserted (both the
generate-typeddict dpg path via _insert_typeddict_overload and the
typeddict-only spread branch). add_overloads_for_body_param now checks the flag
instead of sniffing base == typeddict, so:
- models-mode: dpg (generate-typeddict on) and models-mode: typeddict both skip
  the single-body JSON overload, and
- only the generate-typeddict: false opt-out keeps it (pre-TypedDict behavior).

Addresses the PR reviewer comment.

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,11 +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))
-            # 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"]):
+            # When a TypedDict-style overload was inserted, it replaces the single-body
+            # JSON overload, so skip it. add_body_param_type sets this flag for both
+            # models-mode: dpg (generate-typeddict on) and models-mode: typeddict. When
+            # TypedDict generation is disabled the flag is absent and we keep the
+            # single-body raw-JSON overload (pre-TypedDict behavior) by falling through.
+            if body_parameter["type"].get("jsonOverloadReplacedByTypeddict"):
                 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")
@@ -389,6 +390,9 @@ def _insert_typeddict_overload(
         existing_td: Optional[dict[str, Any]],
     ) -> None:
         """Insert a typeddict type into the body parameter's combined types."""
+        # Mark that a TypedDict-style overload now stands in for the single-body JSON
+        # overload, so add_overloads_for_body_param knows to skip re-adding it.
+        body_parameter["type"]["jsonOverloadReplacedByTypeddict"] = True
         if origin_type == "model":
             td_type = existing_td or {**source, "base": "typeddict"}
             body_parameter["type"]["types"].insert(1, td_type)
@@ -487,7 +491,9 @@ def add_body_param_type(
 
                 if is_typeddict_only and original:
                     # In typeddict-only mode, the original dpg model already renders
-                    # as a TypedDict — reference it directly, no copy needed.
+                    # as a TypedDict — reference it directly, no copy needed. It also
+                    # replaces the single-body JSON overload.
+                    body_parameter["type"]["jsonOverloadReplacedByTypeddict"] = True
                     if origin_type == "model":
                         body_parameter["type"]["types"].insert(1, original)
                     else:

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

@@ -150,6 +150,70 @@ def test_spread_body_opt_out_keeps_json_overload():
     assert not any(t for t in code_model["types"] if t.get("base") == "typeddict")
 
 
+def test_spread_body_dpg_typeddict_on_skips_single_json_overload():
+    """dpg + generate-typeddict on: the TypedDict overload replaces the single-body JSON one."""
+    plugin = _plugin("dpg")
+    clid = "Contoso.Widget"
+    original = _dpg_body_parameter("Widget", clid)["type"]
+    spread_body = _json_spread_body_parameter("CreateRequest", clid)
+    yaml_data = {
+        "name": "create",
+        "bodyParameter": spread_body,
+        "parameters": [_content_type_param()],
+        "overloads": [],
+        "responses": [],
+        "exceptions": [],
+    }
+    code_model = {"types": [original, spread_body["type"]]}
+
+    plugin.add_body_param_type(code_model, spread_body)
+    add_overloads_for_body_param(yaml_data)
+
+    # Combined types: [json_model, typeddict, binary]; the single-body JSON overload is
+    # replaced by the TypedDict, so only the flattened JSON overload remains.
+    assert spread_body["type"].get("jsonOverloadReplacedByTypeddict") is True
+    json_overloads = [o for o in yaml_data["overloads"] if o["bodyParameter"]["type"].get("base") == "json"]
+    assert all(o["bodyParameter"].get("flattened") for o in json_overloads)
+    assert not any(not o["bodyParameter"].get("flattened") for o in json_overloads)
+
+
+def test_spread_body_typeddict_mode_skips_single_json_overload():
+    """models-mode: typeddict spread bodies must NOT keep the single-body JSON overload.
+
+    The inserted overload is the original ``base: dpg`` model (it renders as a TypedDict
+    via models-mode), so a ``base == "typeddict"`` sniff would miss it. The flag set by
+    ``add_body_param_type`` ensures the single-body JSON overload is still skipped.
+    """
+    plugin = _plugin("typeddict")
+    clid = "Contoso.Widget"
+    original = _dpg_body_parameter("Widget", clid)["type"]
+    spread_body = _json_spread_body_parameter("CreateRequest", clid)
+    yaml_data = {
+        "name": "create",
+        "bodyParameter": spread_body,
+        "parameters": [_content_type_param()],
+        "overloads": [],
+        "responses": [],
+        "exceptions": [],
+    }
+    code_model = {"types": [original, spread_body["type"]]}
+
+    plugin.add_body_param_type(code_model, spread_body)
+    add_overloads_for_body_param(yaml_data)
+
+    assert spread_body["type"]["type"] == "combined"
+    assert spread_body["type"].get("jsonOverloadReplacedByTypeddict") is True
+    # typeddict-only mode omits the binary overload; the inserted overload is the
+    # original dpg model referenced directly.
+    assert spread_body["type"]["types"][0]["base"] == "json"
+    assert spread_body["type"]["types"][1] is original
+    # Exactly the flattened JSON overload plus the original-model overload; the
+    # single-body JSON overload must be absent.
+    json_overloads = [o for o in yaml_data["overloads"] if o["bodyParameter"]["type"].get("base") == "json"]
+    assert len(json_overloads) == 1
+    assert json_overloads[0]["bodyParameter"].get("flattened") is True
+
+
 def _dpg_body_parameter(name: str, cross_lang_id: str) -> dict:
     """A JSON dpg-model body parameter for the given model name and cross-language id."""
     model_type = {