Propagate tcgc SerializationOptions for body parameters and responses (#10730)

tcgc 0.68.0 added `serializationOptions` to `SdkBodyParameter` and
`SdkHttpResponse`, but the C# emitter and MTG were still inferring wire
format from the content-type header. This PR plumbs that data through so
MTG can consume it directly, and switches the first XML wire-format
detection site to use the new metadata.

### Emitter (TypeScript)
- Added `serializationOptions: SerializationOptions` (required) to
`InputBodyParameter` and `OperationResponse`, matching the existing
shape on `InputModelType` / `InputModelProperty`.
- Populated the field in `fromBodyParameter` and
`fromSdkHttpOperationResponse` by copying straight from tcgc.

### MTG (`Microsoft.TypeSpec.Generator.Input`)
- Added nullable `SerializationOptions` (of type
`InputSerializationOptions`) to `InputBodyParameter` and
`InputOperationResponse`, with constructor parameters defaulted to
`null` for back-compat.
- Updated `InputBodyParameterConverter` and
`InputOperationResponseConverter` to read the new `serializationOptions`
JSON field.
- Added a new `InputBinarySerializationOptions` type (`IsFile`,
`IsText`, `ContentTypes`, `Filename`) and
`InputBinarySerializationOptionsConverter`, plumbed through
`InputSerializationOptions` / `InputSerializationOptionsConverter` so
that binary payload metadata emitted by tcgc on model types can be
deserialized in MTG. `Filename` is typed as `InputModelProperty?`,
matching `InputMultipartOptions.Filename`.

### MTG (`Microsoft.TypeSpec.Generator.ClientModel`)
- `ScmMethodProviderCollection.TryGetXmlCollectionNamesForResponse` now
gates on `response.SerializationOptions?.Xml` instead of scanning
`response.ContentTypes` for `application/xml`, consuming the propagated
metadata directly.
- Extended the test-only `InputFactory.OperationResponse` helper with an
optional `serializationOptions` parameter and updated the affected XML
list response test to supply it.

### Tests
- Emitter unit tests in `model-type.test.ts` covering body parameter
`serializationOptions` propagation:
- `application/json` + `string` body — asserts
`bodyParam.serializationOptions.json` is populated.
- `Http.File` (`application/octet-stream`) body — asserts the body's
model type carries `serializationOptions.binary` with the full set of
properties: `isFile === true`, `isText === false`, `contentTypes ===
["application/octet-stream"]`, and `filename.name === "filename"`. Also
asserts that the body parameter's own `serializationOptions` has neither
`json` nor `xml` set (tcgc only derives `json`/`xml` for body params
from content types; `binary` lives on the model type).
- Added serialization-options deserialization tests directly inside
`TypeSpecInputConverterTests` in
`Microsoft.TypeSpec.Generator.Input.Tests` validating JSON
deserialization of `InputSerializationOptions` (empty, json, xml, binary
with all properties including `filename`, binary defaults, unknown
property tolerance), `InputBodyParameter.SerializationOptions` (json,
binary with `filename`, absent → null), and
`InputOperationResponse.SerializationOptions` (xml, binary with
`filename`, absent → null).

### Follow-up
One header/content-type-based wire-format site remains for a separate
change: `MrwSerializationTypeDefinition.Xml.cs` reads the `Content-Type`
response header at runtime to branch between `application/json` and
`application/xml`; converting that to consume `SerializationOptions` is
the natural next step.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: jorgerangel-msft <102122018+jorgerangel-msft@users.noreply.github.com>

Author: Copilot

packages/http-client-csharp/emitter/src/lib/operation-converter.ts

@@ -604,6 +604,7 @@ function fromBodyParameter(
     readOnly: isReadOnly(p),
     crossLanguageDefinitionId: p.crossLanguageDefinitionId,
     methodParameterSegments: diagnostics.pipe(getMethodParameterSegments(sdkContext, p)),
+    serializationOptions: p.serializationOptions,
   };
 
   sdkContext.__typeCache.updateSdkOperationParameterReferences(p, retVar);
@@ -706,6 +707,7 @@ export function fromSdkHttpOperationResponse(
     isErrorResponse:
       sdkResponse.type !== undefined && isErrorModel(sdkContext.program, sdkResponse.type.__raw!),
     contentTypes: sdkResponse.contentTypes,
+    serializationOptions: sdkResponse.serializationOptions,
   };
 
   sdkContext.__typeCache.updateSdkResponseReferences(sdkResponse, retVar);

packages/http-client-csharp/emitter/src/type/input-type.ts

@@ -242,6 +242,7 @@ export interface InputBodyParameter extends InputPropertyTypeBase {
   scope: InputParameterScope;
   serializedName: string;
   methodParameterSegments?: InputMethodParameter[];
+  serializationOptions: SerializationOptions;
 }
 
 export interface InputEndpointParameter extends InputPropertyTypeBase {

packages/http-client-csharp/emitter/src/type/operation-response.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+import { SerializationOptions } from "@azure-tools/typespec-client-generator-core";
 import { HttpResponseHeader } from "./http-response-header.js";
 import { InputType } from "./input-type.js";
 
@@ -10,4 +11,5 @@ export interface OperationResponse {
   headers: HttpResponseHeader[];
   contentTypes?: string[];
   isErrorResponse: boolean;
+  serializationOptions: SerializationOptions;
 }

packages/http-client-csharp/emitter/test/Unit/model-type.test.ts

@@ -5,6 +5,7 @@ import { TestHost } from "@typespec/compiler/testing";
 import assert, { deepStrictEqual, ok, strictEqual } from "assert";
 import { beforeEach, describe, it, vi } from "vitest";
 import { createModel } from "../../src/lib/client-model-builder.js";
+import { InputModelType } from "../../src/type/input-type.js";
 import {
   createCSharpSdkContext,
   createEmitterContext,
@@ -1094,4 +1095,72 @@ describe("XML serialization options", () => {
     ok(itemsProperty.serializationOptions.xml.itemsName);
     strictEqual(itemsProperty.serializationOptions.xml.itemsName, "Item");
   });
+
+  it("Body parameter with file payload should have binary serializationOptions populated on the body type", async function () {
+    const program = await typeSpecCompile(
+      `
+      model RawData extends File {
+        contentType: "application/octet-stream";
+        contents: bytes;
+      }
+
+      @route("/upload")
+      @post
+      op uploadRawData(@bodyRoot data: RawData): void;
+      `,
+      runner,
+      { IsTCGCNeeded: true },
+    );
+
+    const context = createEmitterContext(program);
+    const sdkContext = await createCSharpSdkContext(context);
+    const [root] = createModel(sdkContext);
+
+    const method = root.clients[0].methods[0];
+    ok(method);
+    const bodyParam = method.operation.parameters.find((p) => p.kind === "body");
+    ok(bodyParam);
+    // The body parameter itself always has serializationOptions (tcgc populates
+    // json/xml options from content types; for a binary file body neither is set).
+    ok(bodyParam.serializationOptions);
+    strictEqual(bodyParam.serializationOptions.json, undefined);
+    strictEqual(bodyParam.serializationOptions.xml, undefined);
+    // The body's model type carries the binary serialization options.
+    const bodyType = bodyParam.type as InputModelType;
+    ok(bodyType.serializationOptions);
+    ok(bodyType.serializationOptions.binary);
+    strictEqual(bodyType.serializationOptions.binary.isFile, true);
+    // bytes contents → not text
+    strictEqual(bodyType.serializationOptions.binary.isText, false);
+    // contentTypes should be populated from the model's contentType property
+    ok(bodyType.serializationOptions.binary.contentTypes);
+    strictEqual(bodyType.serializationOptions.binary.contentTypes.length, 1);
+    strictEqual(bodyType.serializationOptions.binary.contentTypes[0], "application/octet-stream");
+    // filename should be populated for an Http.File-derived model
+    ok(bodyType.serializationOptions.binary.filename);
+    strictEqual(bodyType.serializationOptions.binary.filename.name, "filename");
+  });
+
+  it("Body parameter with JSON content type should have json serializationOptions populated", async function () {
+    const program = await typeSpecCompile(
+      `
+      @route("/messages")
+      @post
+      op sendMessage(@header contentType: "application/json", @body message: string): void;
+      `,
+      runner,
+      { IsTCGCNeeded: true },
+    );
+
+    const context = createEmitterContext(program);
+    const sdkContext = await createCSharpSdkContext(context);
+    const [root] = createModel(sdkContext);
+
+    const method = root.clients[0].methods[0];
+    ok(method);
+    const bodyParam = method.operation.parameters.find((p) => p.kind === "body");
+    ok(bodyParam);
+    ok(bodyParam.serializationOptions);
+    ok(bodyParam.serializationOptions.json);
+  });
 });

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs

@@ -1380,9 +1380,9 @@ private bool TryGetXmlCollectionNamesForResponse(
             rootName = null;
             childName = null;
 
-            // Check if the response uses XML content type
+            // Check if the response is serialized as XML using the propagated serialization options
             var response = ServiceMethod.Operation.Responses.FirstOrDefault(r => !r.IsErrorResponse);
-            if (response == null || !response.ContentTypes.Any(c => c.Contains(XmlMediaType, StringComparison.OrdinalIgnoreCase)))
+            if (response?.SerializationOptions?.Xml is null)
             {
                 return false;
             }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ScmMethodProviderCollectionTests.cs

@@ -1924,7 +1924,12 @@ public void ConvenienceMethod_XmlListResponse_UsesXDocumentDeserialization()
             var operation = InputFactory.Operation(
                 "GetFoo",
                 httpMethod: "GET",
-                responses: [InputFactory.OperationResponse([200], bodytype: arrayType, contentTypes: ["application/xml"])]);
+                responses: [InputFactory.OperationResponse(
+                    [200],
+                    bodytype: arrayType,
+                    contentTypes: ["application/xml"],
+                    serializationOptions: InputFactory.Serialization.Options(
+                        xml: InputFactory.Serialization.Xml("SignedIdentifier")))]);
 
             var serviceMethod = InputFactory.BasicServiceMethod(
                 "GetFoo",

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputBinarySerializationOptions.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+
+namespace Microsoft.TypeSpec.Generator.Input
+{
+    /// <summary>
+    /// Describes how a body is serialized as a binary payload (e.g. a file or raw stream).
+    /// </summary>
+    public class InputBinarySerializationOptions
+    {
+        public InputBinarySerializationOptions(bool isFile = false, bool? isText = null, IReadOnlyList<string>? contentTypes = null, InputModelProperty? filename = null)
+        {
+            IsFile = isFile;
+            IsText = isText;
+            ContentTypes = contentTypes;
+            Filename = filename;
+        }
+
+        /// <summary>
+        /// Whether this is a file/stream input.
+        /// </summary>
+        public bool IsFile { get; internal set; }
+
+        /// <summary>
+        /// Whether the file contents should be represented as a string or a raw byte stream.
+        /// Only set when <see cref="IsFile"/> is <c>true</c>.
+        /// </summary>
+        public bool? IsText { get; internal set; }
+
+        /// <summary>
+        /// The list of inner media types of the file.
+        /// Only set when <see cref="IsFile"/> is <c>true</c>.
+        /// </summary>
+        public IReadOnlyList<string>? ContentTypes { get; internal set; }
+
+        /// <summary>
+        /// The model property that represents the filename in the file model.
+        /// Only set when <see cref="IsFile"/> is <c>true</c>.
+        /// </summary>
+        public InputModelProperty? Filename { get; internal set; }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputBodyParameter.cs

@@ -20,14 +20,21 @@ public InputBodyParameter(
             InputConstant? defaultValue,
             InputParameterScope scope,
             IReadOnlyList<string> contentTypes,
-            string defaultContentType)
+            string defaultContentType,
+            InputSerializationOptions? serializationOptions = null)
             : base(name, summary, doc, type, isRequired, isReadOnly, access, serializedName, isApiVersion, defaultValue, scope)
         {
             ContentTypes = contentTypes;
             DefaultContentType = defaultContentType;
+            SerializationOptions = serializationOptions;
         }
 
         public IReadOnlyList<string> ContentTypes { get; internal set; }
         public string DefaultContentType { get; internal set; }
+
+        /// <summary>
+        /// Options describing how the body is serialized on the wire.
+        /// </summary>
+        public InputSerializationOptions? SerializationOptions { get; internal set; }
     }
 }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputOperationResponse.cs

@@ -11,13 +11,14 @@ namespace Microsoft.TypeSpec.Generator.Input
     /// </summary>
     public sealed class InputOperationResponse
     {
-        public InputOperationResponse(IReadOnlyList<int> statusCodes, InputType? bodyType, IReadOnlyList<InputOperationResponseHeader> headers, bool isErrorResponse, IReadOnlyList<string> contentTypes)
+        public InputOperationResponse(IReadOnlyList<int> statusCodes, InputType? bodyType, IReadOnlyList<InputOperationResponseHeader> headers, bool isErrorResponse, IReadOnlyList<string> contentTypes, InputSerializationOptions? serializationOptions = null)
         {
             StatusCodes = statusCodes;
             BodyType = bodyType;
             Headers = headers;
             IsErrorResponse = isErrorResponse;
             ContentTypes = contentTypes;
+            SerializationOptions = serializationOptions;
         }
 
         public InputOperationResponse() : this(Array.Empty<int>(), null,  Array.Empty<InputOperationResponseHeader>(), false, Array.Empty<string>()) { }
@@ -27,5 +28,10 @@ public InputOperationResponse() : this(Array.Empty<int>(), null,  Array.Empty<In
         public IReadOnlyList<InputOperationResponseHeader> Headers { get; }
         public bool IsErrorResponse { get; }
         public IReadOnlyList<string> ContentTypes { get; }
+
+        /// <summary>
+        /// Options describing how the response body is deserialized from the wire.
+        /// </summary>
+        public InputSerializationOptions? SerializationOptions { get; }
     }
 }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputSerializationOptions.cs

@@ -5,17 +5,20 @@ namespace Microsoft.TypeSpec.Generator.Input
 {
     public class InputSerializationOptions
     {
-        public InputSerializationOptions(InputJsonSerializationOptions? json = null, InputXmlSerializationOptions? xml = null, InputMultipartOptions? multipart = null)
+        public InputSerializationOptions(InputJsonSerializationOptions? json = null, InputXmlSerializationOptions? xml = null, InputMultipartOptions? multipart = null, InputBinarySerializationOptions? binary = null)
         {
             Json = json;
             Xml = xml;
             Multipart = multipart;
+            Binary = binary;
         }
 
         public InputJsonSerializationOptions? Json { get; internal set; }
 
         public InputXmlSerializationOptions? Xml { get; internal set; }
 
         public InputMultipartOptions? Multipart { get; internal set; }
+
+        public InputBinarySerializationOptions? Binary { get; internal set; }
     }
 }