Types with generics do not work with tool macro

[chwzr]

Describe the bug
When I try to use the toolbox macro on a type that has generics, it will not work

To Reproduce

#[tool(tool_box)]
impl<GS: GraphService> GraphMcp<GS> {
    pub fn new(graph_service: GS) -> Self {
        Self {
            graph_service: Arc::new(graph_service),
        }
    }

    #[tool(description = "Get a list of nodes")]
    async fn list_nodes(&self) -> Result<CallToolResult, McpError> {
        Ok(CallToolResult::success(vec![]))
    }
}
// const_string!(Echo = "echo");
#[tool(tool_box)]
impl<GS: GraphService> ServerHandler for GraphMcp<GS> {
    fn get_info(&self) -> ServerInfo {
        ServerInfo {
            protocol_version: ProtocolVersion::V_2024_11_05,
            capabilities: ServerCapabilities::builder().enable_tools().build(),
            server_info: Implementation::from_build_env(),
            instructions: Some("This server provides access to the DataCards API.".to_string()),
        }
    }
}

Expected behavior
macro works with types which have Generics

Logs

17 | impl<GS: GraphService> DataCardsMcp<GS> {
   |                                    ^ no rules expected this token in macro call
   |
note: while trying to match `{`
  --> /Users/work/.cargo/git/checkouts/rust-sdk-773cd6d57c4837f3/6a74451/crates/rmcp/src/handler/server/tool.rs:431:21

Additional context
Add any other context about the problem here.

[jokemanfire]

I will try to add the generic_marco for generics.

[jokemanfire]

Under the current architecture, we are unable to directly design macros for generics because they suffer from the Self mode issue (as generics are loaded after macros) and cannot use static variables for delayed loading. Can visible generic macro initialization methods be accepted, such as:

 impl<DS: DataService> GenericService<DS> {
       pub fn new(data_service: DS) -> Self { /* ... */ }

       #[tool(description = "get memory from service")]
       pub async fn get_data(&self) -> String { /* ... */ } // <- tool 1

       #[tool(description = "set memory to service")]
       pub async fn set_data(&self, #[tool(param)] data: String) -> String { /* ... */ } // <- tool 2
   }

#[tool(tool_box(tools = [get_data, set_data]))] 
   impl<DS: DataService> ServerHandler for GenericService<DS> {
       fn get_info(&self) -> ServerInfo {
            // ...
       }
       // list_tools 和 call_tool marco will be generate
   }

@4t145 please check

[4t145]

I will have a look on this!

[4t145]

It seems we cannot provide static toolbox for a type with generic type parameter.

So how about this, we declare a trait:

pub trait ToolBoxProvider {
    fn tool_box(&self) -> &ToolBox<Self>
    where
        Self: Sized;
}

And impl this trait for types in macro?
@jokemanfire @chwzr

[4t145]

@jokemanfire solved this with a non-staitc toolbox way. I think we still have space to refine the implementation. But for this issue, you can fell free to close it if you think the issue is solved now.

[chwzr]

Will look into this this week and give you feedback. Thx!

[4t145]

@chwzr actually we are considering a refactor on macro #195