feat: propagate CancellationToken through ReadAsStringAsync/ReadAsStreamAsync via RuntimeHelpers

Add readContentAsString and readContentAsStream wrappers to RuntimeHelpers
with #if NET5_0_OR_GREATER guards, enabling CancellationToken propagation
in generated quotation code that must compile against netstandard2.0.
Also add explicit CancellationToken integration tests and conditional
CT support in ProvidedApiClientBase error path.

Author: sergey-tihon

AGENTS.md

@@ -1,3 +1,7 @@
+## Git Policy
+
+- **NEVER commit or push unless the user explicitly asks you to.** Only create commits when directly requested.
+
 ## Build, Test & Lint Commands
 
 - **Build**: `dotnet fake build -t Build` (Release configuration)

src/SwaggerProvider.DesignTime/v3/OperationCompiler.fs

@@ -428,32 +428,35 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
 
                             <@
                                 let x = %action
+                                let ct = %ct
 
                                 task {
                                     let! response = x
-                                    let! content = response.ReadAsStringAsync()
+                                    let! content = RuntimeHelpers.readContentAsString response ct
                                     return (%this).Deserialize(content, innerReturnType)
                                 }
                             @>
 
                         let responseStream =
                             <@
                                 let x = %action
+                                let ct = %ct
 
                                 task {
                                     let! response = x
-                                    let! data = response.ReadAsStreamAsync()
+                                    let! data = RuntimeHelpers.readContentAsStream response ct
                                     return data
                                 }
                             @>
 
                         let responseString =
                             <@
                                 let x = %action
+                                let ct = %ct
 
                                 task {
                                     let! response = x
-                                    let! data = response.ReadAsStringAsync()
+                                    let! data = RuntimeHelpers.readContentAsString response ct
                                     return data
                                 }
                             @>

src/SwaggerProvider.Runtime/ProvidedApiClientBase.fs

@@ -63,7 +63,11 @@ type ProvidedApiClientBase(httpClient: HttpClient, options: JsonSerializerOption
                     let! body =
                         task {
                             try
+#if NET5_0_OR_GREATER
+                                return! response.Content.ReadAsStringAsync(cancellationToken)
+#else
                                 return! response.Content.ReadAsStringAsync()
+#endif
                             with _ ->
                                 // If reading the body fails (e.g., disposed stream or invalid charset),
                                 // fall back to an empty body so we can still throw OpenApiException.

src/SwaggerProvider.Runtime/RuntimeHelpers.fs

@@ -273,6 +273,20 @@ module RuntimeHelpers =
 
         castFn.MakeGenericMethod([| runtimeTy |]).Invoke(null, [| asyncOp |])
 
+    let readContentAsString (content: HttpContent) (ct: System.Threading.CancellationToken) : Task<string> =
+#if NET5_0_OR_GREATER
+        content.ReadAsStringAsync(ct)
+#else
+        content.ReadAsStringAsync()
+#endif
+
+    let readContentAsStream (content: HttpContent) (ct: System.Threading.CancellationToken) : Task<IO.Stream> =
+#if NET5_0_OR_GREATER
+        content.ReadAsStreamAsync(ct)
+#else
+        content.ReadAsStreamAsync()
+#endif
+
     let taskCast runtimeTy (task: Task<obj>) =
         let castFn = typeof<TaskExtensions>.GetMethod "cast"
 

tests/SwaggerProvider.ProviderTests/v3/Swashbuckle.CancellationToken.Tests.fs

@@ -68,3 +68,27 @@ let ``Call async generated method without CancellationToken uses default token``
         let! result = apiAsync.GetApiReturnBoolean()
         result |> shouldEqual true
     }
+
+[<Fact>]
+let ``Call method with required param and explicit CancellationToken``() =
+    task {
+        use cts = new CancellationTokenSource()
+        let! result = api.GetApiUpdateString("Serge", cts.Token)
+        result |> shouldEqual "Hello, Serge"
+    }
+
+[<Fact>]
+let ``Call method with optional param and explicit CancellationToken``() =
+    task {
+        use cts = new CancellationTokenSource()
+        let! result = api.GetApiUpdateBool(Some true, cts.Token)
+        result |> shouldEqual false
+    }
+
+[<Fact>]
+let ``Call async generated method with explicit CancellationToken``() =
+    async {
+        use cts = new CancellationTokenSource()
+        let! result = apiAsync.GetApiReturnInt32(cts.Token)
+        result |> shouldEqual 42
+    }