The client does not have the concept of session, but does have a concept of connection to a server. Once established it does not change unless the connection is manually dropped or the server it is connected to goes out of service.
Are you making a new connection for every request? I'm assuming we are talking about some web request with the backend connecting to a NATS server. Your backend can keep a connection open and re-use it for multiple request. Making a connection is relatively expensive just considering the networking. Your backend could keep multiple connections open I suppose and map the connection to a session.
I suppose another way, assuming you provide multiple servers as the bootstrap to a connection, once you get a connection, you can query the ServerInfo from the connection, then use the host and port properties of the actual connected server and build a url. You could then use this url by itself for your next connection bootstrap.
Some additional information about your use case might be helpful.

Thanks @scottf . Let me give more details on my usecase:

I'm talking about actual server the gets the request from nats. We will be having cluster of nats servers and cluster of actual servers for a service. So when client (in my case, some backend X service with multiple servers) make a request to another backend service ( some Y service with multiple servers), lets say with username xyz/xyzsessionkey, request hits one of natsservers and then delegates request to actual Y service server first time randomly right. Next time, if we get another request with same sessionkey(or identifier) in next 10/15mins(for example), i want to land it under same actual Y server from nats-server.

Hope its clear. Let me know if you need further information.

It's not per request. The client makes a connection to a specific random server from the list of servers (bootstrap) you give the connection. You can configure the bootstrap with one or more servers. You can configure it to not be random, meaning it will always try the first server in the list without shuffling the list.
If you have a webserver, your backend can make as many connections to NATS servers as you like. Each JNATS client connection is fixed to a specific server. If you want a web session to stick to a specific connection, then maintain that mapping in your user's session.
But I don't think you should bother? The client does not maintain any state unless you are consuming messages. If that is your use case, then you will have to manually track your webserver session to the connection/consumer.
So for your use case, are you doing a request-reply through NATS, to try to resolve some question for the web request? If you are you, do not care which connection makes the request, since all servers in the cluster will give the same answer.
The only other thing, I suppose is your backend listeners could be designed to listen to specific subjects and only those instances would respond. See next message.

You could make a general request on a subject like "who-can-handle-foo-requests" and each queue listener would respond with a subject, for instance their unique id in the payload "foo-handler-123-session-42"
Maybe there are 7 instances of listeners to "who-can-handle-foo-requests". Each will respond. For basic request-replies, only the very first response will get to you. If you need to see all 7 responses and pick from there you need to do something you would probably just publish a message (versus request-reply) and provide your own "reply-to", i.e. maybe "web-server-789-foo" and your webserver client subscribes to that, get's all responses to "who-can-handle" and decides from there.

The responder server would then listen (subscribe) to the subject they told the web-server-789 that they would listen on, maybe some unique guid ""foo-handler-123-session-42". You can then maintain that subject in your session and always publish to that specific subject. Only that server instance will respond since they are the only one listening.

So a couple things to consider. If you absolutely have to maintain state at the foo handler, I think this is what you need. But if you don't need to maintain state, just make a request reply and let the faster response be your answer, or get all the responses and pick the one you like.

Some examples you can look at are here:
https://github.com/nats-io/java-nats-examples/tree/main/core-reply-request-patterns/src/main/java/io/nats/example

and here:
https://github.com/nats-io/java-nats-examples/tree/main/multi-subject-worker