Fixed an issue with agent tools and added the option to create customers (#18)

Author: pelle

.gitignore

@@ -41,7 +41,7 @@ Cargo.lock
 .DS_Store
 Thumbs.db
 .windsurfrules
-CLAUDE.md
+CLAUDE.local.md
 
 **/.claude/settings.local.json
 backup/

tap-mcp/src/tools/agent_tools.rs

@@ -58,15 +58,73 @@ impl ToolHandler for CreateAgentTool {
 
         debug!("Creating new agent with auto-generated DID");
 
-        // Create an ephemeral agent for simplicity
+        // Create an ephemeral agent
         use std::sync::Arc;
-        use tap_agent::TapAgent;
+        use tap_agent::storage::KeyStorage;
+        use tap_agent::{
+            did::{DIDGenerationOptions, DIDKeyGenerator, KeyType},
+            TapAgent,
+        };
 
-        let (agent, generated_did) = TapAgent::from_ephemeral_key()
-            .await
-            .map_err(|e| Error::tool_execution(format!("Failed to create agent: {}", e)))?;
+        // Generate a new key
+        let generator = DIDKeyGenerator::new();
+        let generated_key = generator
+            .generate_did(DIDGenerationOptions {
+                key_type: KeyType::Ed25519,
+            })
+            .map_err(|e| Error::tool_execution(format!("Failed to generate DID: {}", e)))?;
+
+        debug!("Generated new DID for agent: {}", generated_key.did);
+
+        // Create the agent from the generated key
+        let (agent, generated_did) = TapAgent::from_private_key(
+            &generated_key.private_key,
+            generated_key.key_type,
+            false, // debug mode
+        )
+        .await
+        .map_err(|e| Error::tool_execution(format!("Failed to create agent: {}", e)))?;
+
+        // Save the key to storage with the label
+        let mut key_storage = match KeyStorage::load_default() {
+            Ok(storage) => storage,
+            Err(e) => {
+                debug!("Could not load existing key storage ({}), creating new", e);
+                KeyStorage::new()
+            }
+        };
+
+        // Create a StoredKey with the label
+        let stored_key = if let Some(ref label) = params.label {
+            tap_agent::storage::KeyStorage::from_generated_key_with_label(&generated_key, label)
+        } else {
+            tap_agent::storage::KeyStorage::from_generated_key(&generated_key)
+        };
+
+        // Add the key to storage
+        key_storage.add_key(stored_key);
 
-        debug!("Generated new DID for agent: {}", generated_did);
+        debug!("Current keys in storage: {}", key_storage.keys.len());
+        for (did, key) in &key_storage.keys {
+            debug!("  - {}: {}", did, key.label);
+        }
+
+        // Save the storage
+        match key_storage.save_default() {
+            Ok(_) => {
+                info!(
+                    "Successfully saved agent key to storage with label: {:?}",
+                    params.label
+                );
+            }
+            Err(e) => {
+                error!("Failed to save key storage: {}", e);
+                return Err(Error::tool_execution(format!(
+                    "Failed to save key storage: {}",
+                    e
+                )));
+            }
+        }
 
         // Register the agent with the TapNode
         match self

tap-mcp/src/tools/customer_tools.rs

@@ -6,11 +6,12 @@ use crate::error::{Error, Result};
 use crate::mcp::protocol::{CallToolResult, Tool};
 use crate::tap_integration::TapIntegration;
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
+use serde_json::{json, Value};
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 use tap_msg::message::TapMessage;
 use tap_node::customer::CustomerManager;
+use tap_node::storage::models::{Customer, SchemaType};
 use tracing::{debug, error};
 
 /// Tool for listing customers (parties that an agent acts for)
@@ -740,6 +741,229 @@ impl ToolHandler for UpdateCustomerProfileTool {
     }
 }
 
+/// Tool for creating a new customer
+pub struct CreateCustomerTool {
+    tap_integration: Arc<TapIntegration>,
+}
+
+/// Parameters for creating a customer
+#[derive(Debug, Deserialize)]
+struct CreateCustomerParams {
+    agent_did: String,
+    customer_id: String,
+    profile_data: Value,
+}
+
+impl CreateCustomerTool {
+    pub fn new(tap_integration: Arc<TapIntegration>) -> Self {
+        Self { tap_integration }
+    }
+
+    fn tap_integration(&self) -> &TapIntegration {
+        &self.tap_integration
+    }
+}
+
+#[async_trait::async_trait]
+impl ToolHandler for CreateCustomerTool {
+    async fn handle(&self, arguments: Option<Value>) -> Result<CallToolResult> {
+        let params: CreateCustomerParams = match arguments {
+            Some(args) => serde_json::from_value(args)
+                .map_err(|e| Error::invalid_parameter(format!("Invalid parameters: {}", e)))?,
+            None => {
+                return Ok(error_text_response(
+                    "Missing required parameters".to_string(),
+                ))
+            }
+        };
+
+        debug!(
+            "Creating customer {} via agent {}",
+            params.customer_id, params.agent_did
+        );
+
+        // Get storage for the agent
+        let storage = match self
+            .tap_integration()
+            .storage_for_agent(&params.agent_did)
+            .await
+        {
+            Ok(storage) => storage,
+            Err(e) => {
+                error!(
+                    "Failed to get storage for agent {}: {}",
+                    params.agent_did, e
+                );
+                return Ok(error_text_response(format!(
+                    "Failed to get storage for agent {}: {}",
+                    params.agent_did, e
+                )));
+            }
+        };
+
+        // Create customer manager
+        let customer_manager = CustomerManager::new(storage.clone());
+
+        // Check if customer already exists
+        let existing = match storage.get_customer(&params.customer_id).await {
+            Ok(existing) => existing,
+            Err(e) => {
+                error!("Failed to check existing customer: {}", e);
+                return Ok(error_text_response(format!(
+                    "Failed to check existing customer: {}",
+                    e
+                )));
+            }
+        };
+
+        if existing.is_none() {
+            // Create new customer
+            let display_name = params
+                .profile_data
+                .get("givenName")
+                .and_then(|v| v.as_str())
+                .map(|given| {
+                    if let Some(family) = params
+                        .profile_data
+                        .get("familyName")
+                        .and_then(|v| v.as_str())
+                    {
+                        format!("{} {}", given, family)
+                    } else {
+                        given.to_string()
+                    }
+                });
+
+            // Create customer profile from schema.org data
+            let mut profile = json!({
+                "@context": "https://schema.org",
+                "@type": "Person",
+                "identifier": params.customer_id.clone(),
+            });
+
+            // Merge provided profile data
+            if let Value::Object(profile_obj) = &mut profile {
+                if let Value::Object(data_obj) = &params.profile_data {
+                    for (key, value) in data_obj {
+                        profile_obj.insert(key.clone(), value.clone());
+                    }
+                }
+            }
+
+            // Determine schema type based on provided data
+            let schema_type = if params.profile_data.get("@type").and_then(|v| v.as_str())
+                == Some("Organization")
+            {
+                SchemaType::Organization
+            } else {
+                SchemaType::Person
+            };
+
+            // Create Customer struct
+            let customer = Customer {
+                id: params.customer_id.clone(),
+                agent_did: params.agent_did.clone(),
+                schema_type,
+                given_name: params
+                    .profile_data
+                    .get("givenName")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                family_name: params
+                    .profile_data
+                    .get("familyName")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                display_name,
+                legal_name: params
+                    .profile_data
+                    .get("legalName")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                lei_code: params
+                    .profile_data
+                    .get("leiCode")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                mcc_code: params
+                    .profile_data
+                    .get("mccCode")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                address_country: params
+                    .profile_data
+                    .get("addressCountry")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                address_locality: params
+                    .profile_data
+                    .get("addressLocality")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                postal_code: params
+                    .profile_data
+                    .get("postalCode")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                street_address: params
+                    .profile_data
+                    .get("streetAddress")
+                    .and_then(|v| v.as_str())
+                    .map(String::from),
+                profile,
+                ivms101_data: None,
+                verified_at: None,
+                created_at: chrono::Utc::now().to_rfc3339(),
+                updated_at: chrono::Utc::now().to_rfc3339(),
+            };
+
+            // Create the customer
+            match storage.upsert_customer(&customer).await {
+                Ok(_) => {
+                    debug!("Created new customer {}", params.customer_id);
+                    Ok(success_text_response(format!(
+                        "Successfully created customer {}",
+                        params.customer_id
+                    )))
+                }
+                Err(e) => {
+                    error!("Failed to create customer: {}", e);
+                    Ok(error_text_response(format!(
+                        "Failed to create customer: {}",
+                        e
+                    )))
+                }
+            }
+        } else {
+            // Update existing customer
+            match customer_manager
+                .update_customer_profile(&params.customer_id, params.profile_data)
+                .await
+            {
+                Ok(_) => Ok(success_text_response(format!(
+                    "Successfully updated existing customer {}",
+                    params.customer_id
+                ))),
+                Err(e) => {
+                    error!("Failed to update customer: {}", e);
+                    Ok(error_text_response(format!(
+                        "Failed to update customer: {}",
+                        e
+                    )))
+                }
+            }
+        }
+    }
+
+    fn get_definition(&self) -> Tool {
+        Tool {
+            name: "tap_create_customer".to_string(),
+            description: "Creates a new customer profile for an agent. The customer_id should be a DID or unique identifier. The profile_data should be a JSON object with schema.org fields (e.g., givenName, familyName, addressCountry). If a customer with the same ID already exists, their profile will be updated.".to_string(),
+            input_schema: schema::create_customer_schema(),
+        }
+    }
+}
+
 /// Tool for updating customer from IVMS101 data
 pub struct UpdateCustomerFromIvms101Tool {
     tap_integration: Arc<TapIntegration>,

tap-mcp/src/tools/mod.rs

@@ -140,6 +140,10 @@ impl ToolRegistry {
             "tap_generate_ivms101".to_string(),
             Box::new(GenerateIvms101Tool::new(tap_integration.clone())),
         );
+        tools.insert(
+            "tap_create_customer".to_string(),
+            Box::new(CreateCustomerTool::new(tap_integration.clone())),
+        );
         tools.insert(
             "tap_update_customer_profile".to_string(),
             Box::new(UpdateCustomerProfileTool::new(tap_integration.clone())),

tap-mcp/src/tools/schema.rs

@@ -445,6 +445,29 @@ pub fn update_customer_profile_schema() -> Value {
     })
 }
 
+/// Schema for create_customer tool
+pub fn create_customer_schema() -> Value {
+    json!({
+        "type": "object",
+        "properties": {
+            "agent_did": {
+                "type": "string",
+                "description": "The DID of the agent that will manage this customer"
+            },
+            "customer_id": {
+                "type": "string",
+                "description": "The ID of the customer to create (should be a DID or unique identifier)"
+            },
+            "profile_data": {
+                "type": "object",
+                "description": "Schema.org profile data for the customer (e.g., givenName, familyName, email, telephone, addressCountry, addressLocality, postalCode)"
+            }
+        },
+        "required": ["agent_did", "customer_id", "profile_data"],
+        "additionalProperties": false
+    })
+}
+
 /// Schema for update_customer_from_ivms101 tool
 pub fn update_customer_from_ivms101_schema() -> Value {
     json!({

tap-mcp/tests/integration_tests.rs

@@ -174,7 +174,7 @@ async fn test_list_tools() -> Result<()> {
 
     if let Some(result) = response.result {
         let tools = result["tools"].as_array().unwrap();
-        assert_eq!(tools.len(), 30); // All 30 tools should be available (including complete, revert, communication, delivery, customer, received message tools, database tools, agent management tools, and policy tools)
+        assert_eq!(tools.len(), 31); // All 31 tools should be available (including complete, revert, communication, delivery, customer, received message tools, database tools, agent management tools, and policy tools)
 
         let tool_names: Vec<&str> = tools.iter().map(|t| t["name"].as_str().unwrap()).collect();
 
@@ -193,6 +193,7 @@ async fn test_list_tools() -> Result<()> {
         assert!(tool_names.contains(&"tap_list_deliveries_by_thread"));
         assert!(tool_names.contains(&"tap_list_customers"));
         assert!(tool_names.contains(&"tap_list_connections"));
+        assert!(tool_names.contains(&"tap_create_customer"));
         assert!(tool_names.contains(&"tap_list_received"));
         assert!(tool_names.contains(&"tap_get_pending_received"));
         assert!(tool_names.contains(&"tap_view_raw_received"));