Is there a plan to implement a more advanced package for building mcp simply on the current implementation?

[Cupnfish]

Do you have any plans to spend the effort to maintain a package for building a simple mcp service, as mentioned in my title, by converting Rust functions into code like tools using macros?
I am quite looking forward to this, as Rust can be distributed via binaries and doesn't require tools like uvx or npmx to run, making it a very appealing language for mcp clients.

[conikeec]

Pushed many changes today https://github.com/conikeec/mcpr/blob/master/CHANGELOG.md
You can now generate a template client/server project based on transport protocol of choice (stdio & sse at the moment).
Also check out the example project as well.

[Cupnfish]

It looks good, with significant improvements over the previous implementation. However, for the tool_definition part, it would be great if it could be defined using macros (using macros along with Rust's documentation comments to generate the corresponding tool_definition should help improve code implementation efficiency.)
Additionally, I noticed the existence of the register_tool_handler method. Is there a corresponding interface for clearing registered tools? Of course, this is just my personal thought. If an MCP service supports a dynamic toolset, it would be more interesting (for example, requiring login before using other tools, in which case only providing the login tool would help the large language model understand what to do).

[Cupnfish]

Regarding the dynamic toolset design, I propose implementing a state machine-based management mechanism. For example, we can define two system states: Unauthenticated and Authenticated. In the unauthenticated state, the toolset only exposes the login interface for identity verification, while other functional interfaces remain logically isolated. Upon successful login validation, the system state transitions to Authenticated via state.transition_to(Authenticated), dynamically registering the state-bound toolset (e.g., data querying, transaction operations). This design can be achieved through a StateMachine struct containing:

1. State context storage
2. State-to-toolset mapping
3. Hot-reload capability for toolsets during state transitions
   This approach enables LLMs to better understand current operational boundaries while providing infrastructure for extended features like permission tiering and session lifecycle management.