Thread ModelReaderWriterOptions through generated clients

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.ClientModel.Primitives;
 using Microsoft.TypeSpec.Generator.Expressions;
 using Microsoft.TypeSpec.Generator.Primitives;
 using Microsoft.TypeSpec.Generator.Snippets;
@@ -20,5 +21,7 @@ protected RequestContentApi(Type type, ValueExpression original) : base(type, or
         public abstract RequestContentApi FromExpression(ValueExpression original);
         public abstract RequestContentApi ToExpression();
         public abstract MethodBodyStatement[] Create(ValueExpression argument);
+        public virtual MethodBodyStatement[] Create(ValueExpression argument, ScopedApi<ModelReaderWriterOptions> options)
+            => Create(argument);
     }
 }

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.ClientModel;
+using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.IO;
 using System.Xml;
@@ -61,10 +62,11 @@ private MethodProvider BuildFromEnumerableTMethod()
             var enumerableTType = typeof(IEnumerable<>);
             CSharpType tType = enumerableTType.GetGenericArguments()[0];
             var enumerableParameter = new ParameterProvider("enumerable", FormattableStringHelpers.Empty, enumerableTType);
+            var optionsParameter = new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions));
             var signature = new MethodSignature(
                 Name: _fromEnumerableName,
                 Modifiers: _methodModifiers,
-                Parameters: [enumerableParameter],
+                Parameters: [enumerableParameter, optionsParameter],
                 ReturnType: _requestBodyType,
                 GenericArguments: [tType],
                 GenericParameterConstraints: [Where.NotNull(tType)],
@@ -81,7 +83,7 @@ private MethodProvider BuildFromEnumerableTMethod()
                 writer.WriteStartArray(),
                 new ForEachStatement("item", enumerableParameter.As(enumerableParameter.Type), out var item)
                 {
-                    writer.WriteObjectValue(item.As(tType), ModelSerializationExtensionsSnippets.Wire)
+                    writer.WriteObjectValue(item.As(tType), optionsParameter.As<ModelReaderWriterOptions>())
                 },
                 writer.WriteEndArray(),
                 MethodBodyStatement.EmptyLine,
@@ -130,10 +132,11 @@ private MethodProvider BuildFromReadOnlySpanMethod()
             var spanType = typeof(ReadOnlySpan<>);
             CSharpType tType = spanType.GetGenericArguments()[0];
             var spanParameter = new ParameterProvider("span", FormattableStringHelpers.Empty, spanType);
+            var optionsParameter = new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions));
             var signature = new MethodSignature(
                 Name: _fromEnumerableName,
                 Modifiers: _methodModifiers,
-                Parameters: [spanParameter],
+                Parameters: [spanParameter, optionsParameter],
                 ReturnType: _requestBodyType,
                 GenericArguments: [tType],
                 GenericParameterConstraints: [Where.NotNull(tType)],
@@ -151,7 +154,7 @@ private MethodProvider BuildFromReadOnlySpanMethod()
                 Declare("i", Int(0), out var i),
                 new ForStatement(null, i.LessThan(spanParameter.Property(nameof(ReadOnlySpan<byte>.Length))), i.Increment())
                 {
-                    writer.WriteObjectValue(new IndexerExpression(spanParameter, i).As(tType), ModelSerializationExtensionsSnippets.Wire)
+                    writer.WriteObjectValue(new IndexerExpression(spanParameter, i).As(tType), optionsParameter.As<ModelReaderWriterOptions>())
                 },
                 writer.WriteEndArray(),
                 MethodBodyStatement.EmptyLine,
@@ -166,10 +169,11 @@ private MethodProvider BuildFromDictionaryTMethod()
             var dictionaryTType = typeof(IDictionary<,>);
             CSharpType valueType = dictionaryTType.GetGenericArguments()[1];
             var dictionaryParameter = new ParameterProvider("dictionary", FormattableStringHelpers.Empty, new CSharpType(dictionaryTType, typeof(string), valueType));
+            var optionsParameter = new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions));
             var signature = new MethodSignature(
                 Name: _fromDictionaryName,
                 Modifiers: _methodModifiers,
-                Parameters: [dictionaryParameter],
+                Parameters: [dictionaryParameter, optionsParameter],
                 ReturnType: _requestBodyType,
                 GenericArguments: [valueType],
                 GenericParameterConstraints: [Where.NotNull(valueType)],
@@ -187,7 +191,7 @@ private MethodProvider BuildFromDictionaryTMethod()
                 new ForEachStatement("item", dictionaryParameter.As(dictionaryParameter.Type), out var item)
                 {
                     writer.WritePropertyName(item.Property("Key")),
-                    writer.WriteObjectValue(item.Property("Value").As(valueType), ModelSerializationExtensionsSnippets.Wire)
+                    writer.WriteObjectValue(item.Property("Value").As(valueType), optionsParameter.As<ModelReaderWriterOptions>())
                 },
                 writer.WriteEndObject(),
                 MethodBodyStatement.EmptyLine,
@@ -235,18 +239,19 @@ private MethodProvider BuildFromDictionaryBinaryDataMethod()
         private MethodProvider BuildFromObjectMethod()
         {
             var valueParameter = new ParameterProvider("value", FormattableStringHelpers.Empty, typeof(object));
+            var optionsParameter = new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions));
             var signature = new MethodSignature(
                 Name: _fromObjectName,
                 Modifiers: _methodModifiers,
-                Parameters: [valueParameter],
+                Parameters: [valueParameter, optionsParameter],
                 ReturnType: _requestBodyType,
                 Description: null,
                 ReturnDescription: null);
 
             MethodBodyStatement[] body =
             [
                 Declare("content", New.Instance<Utf8JsonBinaryContentDefinition>(), out var content),
-                ScmCodeModelGenerator.Instance.TypeFactory.SerializeJsonValue(typeof(object), valueParameter, content.JsonWriter(), ModelSerializationExtensionsSnippets.Wire, SerializationFormat.Default),
+                ScmCodeModelGenerator.Instance.TypeFactory.SerializeJsonValue(typeof(object), valueParameter, content.JsonWriter(), optionsParameter.As<ModelReaderWriterOptions>(), SerializationFormat.Default),
                 Return(content)
             ];
 
@@ -285,10 +290,11 @@ private MethodProvider BuildFromEnumerableXmlMethod()
             var enumerableParameter = new ParameterProvider("enumerable", FormattableStringHelpers.Empty, enumerableTType);
             var rootNameHintParameter = new ParameterProvider("rootNameHint", FormattableStringHelpers.Empty, typeof(string));
             var childNameHintParameter = new ParameterProvider("childNameHint", FormattableStringHelpers.Empty, typeof(string));
+            var optionsParameter = new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions));
             var signature = new MethodSignature(
                 Name: _fromEnumerableName,
                 Modifiers: _methodModifiers,
-                Parameters: [enumerableParameter, rootNameHintParameter, childNameHintParameter],
+                Parameters: [enumerableParameter, rootNameHintParameter, childNameHintParameter, optionsParameter],
                 ReturnType: _requestBodyType,
                 GenericArguments: [tType],
                 GenericParameterConstraints: [Where.NotNull(tType)],
@@ -304,7 +310,7 @@ private MethodProvider BuildFromEnumerableXmlMethod()
                 xmlWriter.WriteStartElement(rootNameHintParameter),
                 new ForEachStatement("item", enumerableParameter.As(enumerableParameter.Type), out var item)
                 {
-                    xmlWriter.WriteObjectValue(item.As(tType), ModelSerializationExtensionsSnippets.Wire, childNameHintParameter)
+                    xmlWriter.WriteObjectValue(item.As(tType), optionsParameter.As<ModelReaderWriterOptions>(), childNameHintParameter)
                 },
                 xmlWriter.WriteEndElement(),
             ]);

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

@@ -2,9 +2,11 @@
 // Licensed under the MIT License.
 
 using System.ClientModel;
+using System.ClientModel.Primitives;
 using Microsoft.TypeSpec.Generator.ClientModel.Snippets;
 using Microsoft.TypeSpec.Generator.Expressions;
 using Microsoft.TypeSpec.Generator.Primitives;
+using Microsoft.TypeSpec.Generator.Snippets;
 using Microsoft.TypeSpec.Generator.Statements;
 using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
 
@@ -28,5 +30,8 @@ public override RequestContentApi FromExpression(ValueExpression original)
 
         public override MethodBodyStatement[] Create(ValueExpression argument)
             => [Return(Static(typeof(BinaryContent)).Invoke(nameof(BinaryContent.Create), [argument, ModelSerializationExtensionsSnippets.Wire]))];
+
+        public override MethodBodyStatement[] Create(ValueExpression argument, ScopedApi<ModelReaderWriterOptions> options)
+            => [Return(Static(typeof(BinaryContent)).Invoke(nameof(BinaryContent.Create), [argument, options]))];
     }
 }

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

@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.TypeSpec.Generator.ClientModel.Primitives;
+using Microsoft.TypeSpec.Generator.ClientModel.Snippets;
 using Microsoft.TypeSpec.Generator.ClientModel.Utilities;
 using Microsoft.TypeSpec.Generator.EmitterRpc;
 using Microsoft.TypeSpec.Generator.Expressions;
@@ -40,6 +41,7 @@ private record ApiVersionFields(FieldProvider Field, PropertyProvider? Correspon
         private const string TokenProviderFieldName = "_tokenProvider";
         private const string TokenCredentialFieldName = "_tokenCredential";
         private const string EndpointFieldName = "_endpoint";
+        private const string ModelReaderWriterOptionsFieldName = "_modelReaderWriterOptions";
         private const string CredentialParamName = "credential";
         private const string SettingsParamName = "settings";
         private const string ClientSuffix = "Client";
@@ -174,6 +176,11 @@ public ClientProvider(InputClient inputClient)
                 typeof(Uri),
                 EndpointFieldName,
                 this);
+            ModelReaderWriterOptionsField = new(
+                FieldModifiers.Private | FieldModifiers.ReadOnly,
+                typeof(ModelReaderWriterOptions),
+                ModelReaderWriterOptionsFieldName,
+                this);
             PipelineProperty = new(
                 description: $"The HTTP pipeline for sending and receiving REST requests and responses.",
                 modifiers: MethodSignatureModifiers.Public,
@@ -311,7 +318,8 @@ private IReadOnlyList<ParameterProvider> GetSubClientInternalConstructorParamete
         {
             var subClientParameters = new List<ParameterProvider>
             {
-                PipelineProperty.AsParameter
+                PipelineProperty.AsParameter,
+                ModelReaderWriterOptionsField.AsParameter
             };
 
             // Auth credentials are NOT included here — the parent passes its authenticated
@@ -422,6 +430,7 @@ private IReadOnlyList<ParameterProvider> GetClientParameters()
 
         public PropertyProvider PipelineProperty { get; }
         public FieldProvider EndpointField { get; }
+        public FieldProvider ModelReaderWriterOptionsField { get; }
 
         public IReadOnlyList<ClientProvider> SubClients => _subClients.Value;
 
@@ -467,7 +476,7 @@ protected override IReadOnlyList<CSharpType> BuildBodyDependencyTypes()
 
         protected override FieldProvider[] BuildFields()
         {
-            List<FieldProvider> fields = [EndpointField];
+            List<FieldProvider> fields = [EndpointField, ModelReaderWriterOptionsField];
 
             if (_apiKeyAuthFields != null)
             {
@@ -1022,6 +1031,17 @@ private MethodBodyStatement[] BuildPrimaryConstructorBody(IReadOnlyList<Paramete
             body.Add(clientOptionsParameter.Assign(clientOptionsParameter.InitializationValue!, nullCoalesce: true).Terminate());
             body.Add(MethodBodyStatement.EmptyLine);
             body.Add(endpointAssignment.Terminate());
+            var configuredModelReaderWriterOptions = clientOptionsParameter
+                .Property("ModelReaderWriterOptions")
+                .As<ModelReaderWriterOptions>();
+            body.Add(ModelReaderWriterOptionsField.Assign(
+                new TernaryConditionalExpression(
+                    configuredModelReaderWriterOptions.Equal(Null),
+                    ModelSerializationExtensionsSnippets.Wire,
+                    New.Instance(
+                        typeof(ModelReaderWriterOptions),
+                        ModelReaderWriterOptionsSnippets.WireFormat,
+                        configuredModelReaderWriterOptions))).Terminate());
 
             // add other parameter assignments to their corresponding fields
             foreach (var p in primaryConstructorParameters)

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

@@ -27,6 +27,7 @@ public class CollectionResultDefinition : TypeProvider
         protected bool IsAsync { get; }
         protected ClientProvider Client { get; }
         protected FieldProvider ClientField { get; }
+        protected FieldProvider ModelReaderWriterOptionsField { get; }
 
         protected InputOperation Operation { get; }
         protected InputPagingServiceMetadata Paging { get; }
@@ -75,6 +76,11 @@ public CollectionResultDefinition(ClientProvider client, InputPagingServiceMetho
                 Client.Type,
                 "_client",
                 this);
+            ModelReaderWriterOptionsField = new FieldProvider(
+                FieldModifiers.Private | FieldModifiers.ReadOnly,
+                typeof(ModelReaderWriterOptions),
+                "_modelReaderWriterOptions",
+                this);
             Operation = serviceMethod.Operation;
             Paging = serviceMethod.PagingMetadata;
             IsAsync = isAsync;
@@ -233,7 +239,7 @@ protected override IReadOnlyList<CSharpType> BuildBodyDependencyTypes()
             return dependencies;
         }
 
-        protected override FieldProvider[] BuildFields() => [ClientField, .. RequestFields];
+        protected override FieldProvider[] BuildFields() => [ClientField, ModelReaderWriterOptionsField, .. RequestFields];
 
         protected override CSharpType[] BuildImplements() =>
          (_modelType: ItemModelType, IsAsync) switch
@@ -250,6 +256,10 @@ protected override ConstructorProvider[] BuildConstructors()
                 "client",
                 $"The {Client.Type.Name} client used to send requests.",
                 Client.Type);
+            var modelReaderWriterOptionsParameter = new ParameterProvider(
+                "modelReaderWriterOptions",
+                $"The options used to serialize and deserialize models.",
+                typeof(ModelReaderWriterOptions));
             return
             [
                 new ConstructorProvider(
@@ -259,28 +269,40 @@ protected override ConstructorProvider[] BuildConstructors()
                         MethodSignatureModifiers.Public,
                         [
                             clientParameter,
+                            modelReaderWriterOptionsParameter,
                             .. CreateRequestParameters
                         ]),
-                    BuildConstructorBody(clientParameter),
+                    BuildConstructorBody(clientParameter, modelReaderWriterOptionsParameter),
                     this)
             ];
         }
 
         private ValueExpression GetPropertyExpression(IReadOnlyList<string> segments, ValueExpression response)
         {
-            return BuildGetPropertyExpression(segments, response.CastTo(ResponseModelType));
+            var responseModel = Static(typeof(ModelReaderWriter)).Invoke(
+                nameof(ModelReaderWriter.Read),
+                [
+                    response.ToApi<ClientResponseApi>().GetRawResponse().Content(),
+                    ModelReaderWriterOptionsField,
+                    ModelReaderWriterContextSnippets.Default
+                ],
+                [ResponseModelType]).CastTo(ResponseModelType);
+            return BuildGetPropertyExpression(segments, responseModel);
         }
 
         protected ValueExpression BuildGetPropertyExpression(IReadOnlyList<string> segments, ValueExpression responseModel)
         {
             return ResponseModel.GetPropertyExpression(responseModel, segments);
         }
 
-        private MethodBodyStatement[] BuildConstructorBody(ParameterProvider clientParameter)
+        private MethodBodyStatement[] BuildConstructorBody(
+            ParameterProvider clientParameter,
+            ParameterProvider modelReaderWriterOptionsParameter)
         {
-            var statements = new List<MethodBodyStatement>(CreateRequestParameters.Count + 1);
+            var statements = new List<MethodBodyStatement>(CreateRequestParameters.Count + 2);
 
             statements.Add(ClientField.Assign(clientParameter).Terminate());
+            statements.Add(ModelReaderWriterOptionsField.Assign(modelReaderWriterOptionsParameter).Terminate());
 
             for (int parameterNumber = 0; parameterNumber < CreateRequestParameters.Count; parameterNumber++)
             {

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

@@ -582,8 +582,10 @@ private MethodProvider BuildWriteObjectValueMethodGeneric()
                 BuildWriteObjectValueSwitchCase(new CSharpType(typeof(IJsonModel<>), _t), "jsonModel",
                     jsonModel => new MethodBodyStatement[]
                     {
-                        jsonModel.Invoke(nameof(IJsonModel<object>.Write), writer,
-                            options.NullCoalesce(ModelSerializationExtensionsSnippets.Wire)).Terminate(),
+                        options.As<ModelReaderWriterOptions>()
+                            .Invoke("ResolveProxy", jsonModel)
+                            .Invoke(nameof(IJsonModel<object>.Write), writer, options)
+                            .Terminate(),
                         Break
                     }));
             cases.AddRange(new[]
@@ -678,7 +680,15 @@ private MethodProvider BuildWriteObjectValueMethodGeneric()
             cases.Add(SwitchCaseStatement.Default(Throw(New.NotSupportedException(
                 new FormattableStringExpression("Not supported type {0}", [value.InvokeGetType()])))));
 
-            return new MethodProvider(signature, new SwitchStatement(value, cases), this, XmlDocProvider.Empty);
+            return new MethodProvider(
+                signature,
+                new MethodBodyStatement[]
+                {
+                    options.Assign(ModelSerializationExtensionsSnippets.Wire, nullCoalesce: true).Terminate(),
+                    new SwitchStatement(value, cases)
+                },
+                this,
+                XmlDocProvider.Empty);
 
             static SwitchCaseStatement BuildWriteObjectValueSwitchCase(CSharpType type,
                 string varName,