Merge pull request #121 from guyernest/feat/cargo-pmcp-oauth

fix: resolve test compilation errors across workspace

Author: guyernest

Cargo.toml

@@ -378,8 +378,9 @@ required-features = ["schema-generation"]
 name = "comprehensive_benchmarks"
 harness = false
 [workspace]
-members = ["pmcp-macros", "crates/mcp-tester", "examples/wasm-client", "examples/25-oauth-basic", "examples/test-basic", "cargo-pmcp"]
-exclude = ["fuzz", "examples/cloudflare-worker-mcp", "examples/26-server-tester"]
+members = ["pmcp-macros", "crates/mcp-tester", "examples/25-oauth-basic", "examples/test-basic", "cargo-pmcp"]
+# WASM examples require wasm32-unknown-unknown target and are excluded from regular workspace tests
+exclude = ["fuzz", "examples/cloudflare-worker-mcp", "examples/26-server-tester", "examples/wasm-client"]
 
 [package.metadata.docs.rs]
 all-features = true

cargo-pmcp/src/deployment/registry.rs

@@ -187,7 +187,10 @@ mod tests {
 
     #[test]
     fn test_registry_register_and_get() {
-        let mut registry = TargetRegistry::new();
+        // Use empty registry for isolated test (not new() which pre-populates)
+        let mut registry = TargetRegistry {
+            targets: std::collections::HashMap::new(),
+        };
         let target = Arc::new(MockTarget {
             id: "test".to_string(),
             name: "Test Target".to_string(),

examples/25-oauth-basic/src/main.rs

@@ -101,7 +101,7 @@ async fn main() -> Result<()> {
     // Create a scope-based authorizer that defines access rules
     let authorizer = ScopeBasedAuthorizer::new()
         // Public tool - no scopes required (anyone can access)
-        .require_scopes("public_info", vec![])
+        .require_scopes("public_info", Vec::<String>::new())
         // Protected tool - requires basic read scope
         .require_scopes("protected_data", vec!["read".to_string()])
         // Admin tool - requires admin scope

examples/25-oauth-basic/stdio-minimal.rs

@@ -67,8 +67,8 @@ impl ToolHandler for AdminTool {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create scope-based authorizer
     let authorizer = ScopeBasedAuthorizer::new()
-        .require_scopes("public_info", vec![])  // No scopes required
-        .require_scopes("protected_data", vec!["read".to_string()])  // Read scope required  
+        .require_scopes("public_info", Vec::<String>::new())  // No scopes required
+        .require_scopes("protected_data", vec!["read".to_string()])  // Read scope required
         .require_scopes("admin_action", vec!["admin".to_string()])   // Admin scope required
         .default_scopes(vec!["mcp:tools:use".to_string()]); // Default for other tools
 

examples/25-oauth-basic/test-client.rs

@@ -28,6 +28,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         session_id: None,
         enable_json_response: true,
         on_resumption_token: None,
+        http_middleware_chain: None,
     };
 
     // Create the transport

pmcp-macros/Cargo.toml

@@ -32,7 +32,10 @@ tokio = { version = "1.46", features = ["full"] }
 trybuild = "1.0"
 pretty_assertions = "1.4"
 insta = { version = "1.43", features = ["json"] }
+async-trait = "0.1"
+proptest = "1.6"
 
 [features]
 default = []
 debug = []  # Enable debug output in macros
+tool_router_dev = []  # Enable WIP tool_router tests

pmcp-macros/src/tool.rs

@@ -109,12 +109,12 @@ pub fn expand_tool(args: TokenStream, input: ItemFn) -> syn::Result<TokenStream>
 
         impl #wrapper_name {
             /// Get tool definition
-            pub fn definition() -> pmcp::types::Tool {
-                pmcp::types::Tool {
-                    name: #tool_name.to_string(),
-                    description: Some(#description.to_string()),
-                    input_schema: Some(Self::input_schema()),
-                }
+            pub fn definition() -> pmcp::types::ToolInfo {
+                pmcp::types::ToolInfo::new(
+                    #tool_name,
+                    Some(#description.to_string()),
+                    Self::input_schema(),
+                )
             }
 
             /// Generate input schema
@@ -192,7 +192,7 @@ fn generate_param_extraction(params: &[ParamInfo]) -> syn::Result<TokenStream> {
             extractions.push(quote! {
                 let #name: #ty = args.get(#name_str)
                     .and_then(|v| serde_json::from_value(v.clone()).ok())
-                    .ok_or_else(|| pmcp::Error::InvalidParams(
+                    .ok_or_else(|| pmcp::Error::invalid_params(
                         format!("Missing required parameter: {}", #name_str)
                     ))?;
             });
@@ -212,16 +212,16 @@ fn generate_result_conversion(return_type: &Type) -> syn::Result<TokenStream> {
             match result {
                 Ok(value) => {
                     let json_value = serde_json::to_value(value)
-                        .map_err(|e| pmcp::Error::InternalError(e.to_string()))?;
+                        .map_err(|e| pmcp::Error::internal(e.to_string()))?;
                     Ok(json_value)
                 }
-                Err(e) => Err(pmcp::Error::ToolError(e.to_string()))
+                Err(e) => Err(pmcp::Error::internal(format!("Tool error: {}", e)))
             }
         })
     } else {
         Ok(quote! {
             let json_value = serde_json::to_value(result)
-                .map_err(|e| pmcp::Error::InternalError(e.to_string()))?;
+                .map_err(|e| pmcp::Error::internal(e.to_string()))?;
             Ok(json_value)
         })
     }

pmcp-macros/src/tool_router.rs

@@ -72,26 +72,16 @@ pub fn expand_tool_router(args: TokenStream, mut input: ItemImpl) -> syn::Result
     // Generate handle_tool method
     let handle_tool_method = generate_handle_tool_method(&tool_methods, &vis);
 
-    // Generate router initialization method
-    let router_init = generate_router_init(&router_field, &vis);
-
     // Add generated methods to the impl block
+    // Note: init_tool_router is not generated as the router field management is left to the user
     input.items.push(ImplItem::Fn(tools_method));
     input.items.push(ImplItem::Fn(handle_tool_method));
-    input.items.push(ImplItem::Fn(router_init));
 
     // Add router field to the struct (this would need to be done separately)
     // For now, we'll document that the user needs to add it manually
 
-    let expanded = quote! {
-        #input
-
-        impl ToolRouterInfo for Self {
-            const ROUTER_FIELD: &'static str = stringify!(#router_field);
-        }
-    };
-
-    Ok(expanded)
+    // Just output the modified impl block with the generated methods
+    Ok(quote! { #input })
 }
 
 /// Collect all methods marked with #[tool] from the impl block
@@ -173,21 +163,21 @@ fn generate_tools_method(methods: &[ToolMethod], vis: &Visibility) -> ImplItemFn
             let name = &method.tool_name;
             let description = &method.description;
             quote! {
-                pmcp::types::Tool {
-                    name: #name.to_string(),
-                    description: Some(#description.to_string()),
-                    input_schema: Some(serde_json::json!({
+                pmcp::types::ToolInfo::new(
+                    #name,
+                    Some(#description.to_string()),
+                    serde_json::json!({
                         "type": "object",
                         "properties": {},
                         "required": []
-                    })),
-                }
+                    }),
+                )
             }
         })
         .collect();
 
     parse_quote! {
-        #vis fn tools(&self) -> Vec<pmcp::types::Tool> {
+        #vis fn tools(&self) -> Vec<pmcp::types::ToolInfo> {
             vec![
                 #(#tool_definitions),*
             ]
@@ -213,7 +203,7 @@ fn generate_handle_tool_method(methods: &[ToolMethod], vis: &Visibility) -> Impl
                     let result = self.#method_name(args.clone())#await_token;
                     match result {
                         Ok(value) => Ok(serde_json::to_value(value)?),
-                        Err(e) => Err(pmcp::Error::ToolError(e.to_string())),
+                        Err(e) => Err(pmcp::Error::internal(format!("Tool error: {}", e))),
                     }
                 }
             }
@@ -225,27 +215,16 @@ fn generate_handle_tool_method(methods: &[ToolMethod], vis: &Visibility) -> Impl
             &self,
             name: &str,
             args: serde_json::Value,
-            extra: pmcp::RequestHandlerExtra,
+            _extra: pmcp::RequestHandlerExtra,
         ) -> pmcp::Result<serde_json::Value> {
             match name {
                 #(#match_arms)*
-                _ => Err(pmcp::Error::MethodNotFound(format!("Unknown tool: {}", name))),
+                _ => Err(pmcp::Error::method_not_found(format!("Unknown tool: {}", name))),
             }
         }
     }
 }
 
-/// Generate router initialization method
-fn generate_router_init(router_field: &Ident, vis: &Visibility) -> ImplItemFn {
-    parse_quote! {
-        #vis fn init_tool_router(&mut self) {
-            // Initialize the tool router
-            // This is a placeholder - actual implementation would depend on the router type
-            self.#router_field = Default::default();
-        }
-    }
-}
-
 /// Parse visibility string into syn::Visibility
 fn parse_visibility(vis_str: &Option<String>) -> syn::Result<Visibility> {
     match vis_str {
@@ -261,11 +240,6 @@ fn parse_visibility(vis_str: &Option<String>) -> syn::Result<Visibility> {
     }
 }
 
-/// Trait to mark types that have a tool router
-trait ToolRouterInfo {
-    const ROUTER_FIELD: &'static str;
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

pmcp-macros/src/utils.rs

@@ -175,7 +175,7 @@ pub fn generate_error_conversion(error_type: &Type) -> TokenStream {
     if is_pmcp_error(error_type) {
         quote! { e }
     } else {
-        quote! { pmcp::Error::ToolError(e.to_string()) }
+        quote! { pmcp::Error::internal(format!("Tool error: {}", e)) }
     }
 }