I did a quick search on Google to see if there was a nice extant article about it, but alas so here goes:
Essentially the idea of session types is a generalization of the typestate pattern. In the typestate pattern you have a type that is instantiated, and that instance is turned into an instance of a different but related type when some operation is done.
The builder pattern is a special example of this, in that the old and new types are the same.
Session types take that concept and run with it, in that now you have typically 2 instances of complementary types (one client-side, the other server-side) that are necessarily kept in sync because a .send() call turns e.g. the client-side object into a different type (let's say Sent<T>, which only defines a .receive() method). Because of this .send() cannot be called again until the server takes some kind of action (e.g. sending a response). The client then calls e.g. .receive() which turns the client-side object into back into the type that has a .send() method.
A similar process happens server-side.
The detail that makes this work in Rust and not in eg Java or Python is that Rust has a linear type system, which is just a fancy term for saying that the type system can guarantee that an object is used precisely once.
Your project sounds a lot like that to me, except you don't define the types themselves. Does that sound about right?