Support MCP resources, multimodal, unstructured-* with integration tests

golem-worker-service/src/mcp/agent_mcp_capability.rs

@@ -12,22 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::mcp::agent_mcp_resource::AgentMcpResource;
+use crate::mcp::agent_mcp_resource::{AgentMcpResource, AgentMcpResourceKind};
 use crate::mcp::agent_mcp_tool::AgentMcpTool;
 use crate::mcp::schema::{McpToolSchema, get_mcp_schema, get_mcp_tool_schema};
 use golem_common::base_model::account::AccountId;
 use golem_common::base_model::agent::{AgentMethod, AgentTypeName, DataSchema};
 use golem_common::base_model::component::ComponentId;
 use golem_common::base_model::environment::EnvironmentId;
 use golem_common::model::agent::AgentConstructor;
-use rmcp::model::Tool;
+use rmcp::model::{Annotated, RawResource, RawResourceTemplate, Tool};
 use std::borrow::Cow;
 use std::sync::Arc;
 
 #[derive(Clone)]
 pub enum McpAgentCapability {
     Tool(Box<AgentMcpTool>),
-    #[allow(unused)]
     Resource(AgentMcpResource),
 }
 
@@ -87,8 +86,55 @@ impl McpAgentCapability {
                         agent_type_name.0
                     );
 
+                    let constructor_param_names =
+                        AgentMcpResource::constructor_param_names(constructor);
+                    let name = AgentMcpResource::resource_name(agent_type_name, method);
+
+                    let kind = if constructor_param_names.is_empty() {
+                        let uri = AgentMcpResource::static_uri(agent_type_name, method);
+                        AgentMcpResourceKind::Static(Annotated::new(
+                            RawResource {
+                                uri,
+                                name,
+                                title: None,
+                                description: Some(method.description.clone()),
+                                mime_type: Some("application/json".to_string()),
+                                size: None,
+                                icons: None,
+                                meta: None,
+                            },
+                            None,
+                        ))
+                    } else {
+                        let uri_template = AgentMcpResource::template_uri(
+                            agent_type_name,
+                            method,
+                            &constructor_param_names,
+                        );
+                        AgentMcpResourceKind::Template {
+                            template: Annotated::new(
+                                RawResourceTemplate {
+                                    uri_template,
+                                    name,
+                                    title: None,
+                                    description: Some(method.description.clone()),
+                                    mime_type: Some("application/json".to_string()),
+                                    icons: None,
+                                },
+                                None,
+                            ),
+                            constructor_param_names,
+                        }
+                    };
+
                     Self::Resource(AgentMcpResource {
-                        resource: method.clone(),
+                        kind,
+                        environment_id: *environment_id,
+                        account_id: *account_id,
+                        constructor: constructor.clone(),
+                        raw_method: method.clone(),
+                        component_id,
+                        agent_type_name: agent_type_name.clone(),
                     })
                 }
             }

golem-worker-service/src/mcp/agent_mcp_resource.rs

@@ -12,10 +12,93 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use golem_common::base_model::agent::AgentMethod;
+use golem_common::base_model::account::AccountId;
+use golem_common::base_model::agent::{
+    AgentMethod, AgentTypeName, DataSchema, NamedElementSchemas,
+};
+use golem_common::base_model::component::ComponentId;
+use golem_common::base_model::environment::EnvironmentId;
+use golem_common::model::agent::AgentConstructor;
+use rmcp::model::{Resource, ResourceTemplate};
+
+pub type ResourceUri = String;
 
 #[derive(Clone)]
 pub struct AgentMcpResource {
-    #[allow(dead_code)]
-    pub resource: AgentMethod,
+    pub kind: AgentMcpResourceKind,
+    pub environment_id: EnvironmentId,
+    pub account_id: AccountId,
+    pub constructor: AgentConstructor,
+    pub raw_method: AgentMethod,
+    pub component_id: ComponentId,
+    pub agent_type_name: AgentTypeName,
+}
+
+#[derive(Clone)]
+pub enum AgentMcpResourceKind {
+    Static(Resource),
+    Template {
+        template: ResourceTemplate,
+        constructor_param_names: Vec<String>,
+    },
+}
+
+impl AgentMcpResource {
+    pub fn resource_name(agent_type_name: &AgentTypeName, method: &AgentMethod) -> String {
+        format!("{}-{}", agent_type_name.0, method.name)
+    }
+
+    pub fn static_uri(agent_type_name: &AgentTypeName, method: &AgentMethod) -> String {
+        format!("golem://{}/{}", agent_type_name.0, method.name)
+    }
+
+    pub fn template_uri(
+        agent_type_name: &AgentTypeName,
+        method: &AgentMethod,
+        param_names: &[String],
+    ) -> String {
+        let base = format!("golem://{}/{}", agent_type_name.0, method.name);
+        let placeholders: Vec<String> = param_names.iter().map(|n| format!("{{{}}}", n)).collect();
+        format!("{}/{}", base, placeholders.join("/"))
+    }
+
+    pub fn extract_params_from_uri(
+        template_uri: &str,
+        concrete_uri: &str,
+    ) -> Result<Vec<(String, String)>, String> {
+        let template_parts: Vec<&str> = template_uri.split('/').collect();
+        let concrete_parts: Vec<&str> = concrete_uri.split('/').collect();
+
+        if template_parts.len() != concrete_parts.len() {
+            return Err(format!(
+                "URI segment count mismatch: template has {}, concrete has {}",
+                template_parts.len(),
+                concrete_parts.len()
+            ));
+        }
+
+        let mut params = Vec::new();
+        for (tmpl, conc) in template_parts.iter().zip(concrete_parts.iter()) {
+            if tmpl.starts_with('{') && tmpl.ends_with('}') {
+                let name = tmpl[1..tmpl.len() - 1].to_string();
+                params.push((name, conc.to_string()));
+            } else if tmpl != conc {
+                return Err(format!(
+                    "URI segment mismatch: expected '{}', got '{}'",
+                    tmpl, conc
+                ));
+            }
+        }
+
+        Ok(params)
+    }
+
+    pub fn constructor_param_names(constructor: &AgentConstructor) -> Vec<String> {
+        match &constructor.input_schema {
+            DataSchema::Tuple(NamedElementSchemas { elements }) => {
+                elements.iter().map(|e| e.name.clone()).collect()
+            }
+            DataSchema::Multimodal(_) => vec![],
+        }
+    }
 }