Remove Complete message type per updated TAIP specifications

- Remove Complete message implementation from tap-msg
- Remove CompleteTool from tap-mcp tools
- Update test files to remove Complete references
- Update MCP integration test to expect 30 tools instead of 31
- Update README.md to list Cancel and Revert instead of Complete

This aligns the codebase with the updated TAIP specifications where
the Complete message has been removed in favor of using the standard
TAIP-4 authorization flow (Payment -> Authorize -> Settle).

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: pelle

README.md

@@ -116,7 +116,7 @@ See individual tool READMEs for detailed usage instructions.
 
 ## Key Features
 
-- **Complete TAP Implementation**: Support for all TAP message types (Transfer, Authorize, Reject, Settle, Complete, etc.)
+- **Complete TAP Implementation**: Support for all TAP message types (Transfer, Authorize, Reject, Settle, Cancel, Revert, etc.)
 - **DIDComm v2 Integration**: Secure, encrypted messaging with authenticated signatures
 - **Chain Agnostic Identifiers**: Implementation of CAIP-2 (ChainID), CAIP-10 (AccountID), and CAIP-19 (AssetID)
 - **Multiple DID Methods**: Support for did:key, did:web, did:pkh, and more

prds/taips

@@ -34,7 +34,7 @@ use std::fs;
 use std::path::Path;
 use tap_msg::didcomm::PlainMessage;
 use tap_msg::message::{
-    AuthorizationRequired, Cancel, Complete, ConfirmRelationship, Connect, DIDCommPresentation,
+    AuthorizationRequired, Cancel, ConfirmRelationship, Connect, DIDCommPresentation,
     Payment, RemoveAgent, ReplaceAgent, Revert, UpdateParty, UpdatePolicies,
 };
 use tap_msg::{
@@ -95,7 +95,6 @@ fn validate_tap_message(message: &PlainMessage) -> Result<(), String> {
         "https://tap.rsvp/schema/1.0#Authorize",
         "https://tap.rsvp/schema/1.0#Reject",
         "https://tap.rsvp/schema/1.0#Settle",
-        "https://tap.rsvp/schema/1.0#Complete",
         "https://tap.rsvp/schema/1.0#Cancel",
         "https://tap.rsvp/schema/1.0#Revert",
         "https://tap.rsvp/schema/1.0#AddAgents",
@@ -241,11 +240,6 @@ fn validate_tap_message(message: &PlainMessage) -> Result<(), String> {
                     .map_err(|e| format!("Failed to parse AuthorizationRequired: {}", e))?;
             auth_required.validate().map_err(|e| e.to_string())
         }
-        "https://tap.rsvp/schema/1.0#Complete" => {
-            let complete: Complete = serde_json::from_value(body_with_thread_id.clone())
-                .map_err(|e| format!("Failed to parse Complete: {}", e))?;
-            complete.validate().map_err(|e| e.to_string())
-        }
         "https://didcomm.org/out-of-band/2.0/invitation" => {
             // Out-of-band messages must have a goal_code starting with "tap."
             if let Some(body_obj) = body_with_thread_id.as_object() {

tap-agent/tests/test_vectors_validation.rs

@@ -84,10 +84,6 @@ impl ToolRegistry {
             "tap_settle".to_string(),
             Box::new(SettleTool::new(tap_integration.clone())),
         );
-        tools.insert(
-            "tap_complete".to_string(),
-            Box::new(CompleteTool::new(tap_integration.clone())),
-        );
 
         // Transaction management tools
         tools.insert(

tap-mcp/src/tools/mod.rs

@@ -227,32 +227,6 @@ pub fn settle_schema() -> Value {
     })
 }
 
-/// Schema for complete tool
-pub fn complete_schema() -> Value {
-    json!({
-        "type": "object",
-        "properties": {
-            "agent_did": {
-                "type": "string",
-                "description": "The DID of the agent that will sign and send this message"
-            },
-            "transaction_id": {
-                "type": "string",
-                "description": "Transaction ID to complete"
-            },
-            "settlement_address": {
-                "type": "string",
-                "description": "CAIP-10 settlement address"
-            },
-            "amount": {
-                "type": "string",
-                "description": "Optional amount completed"
-            }
-        },
-        "required": ["agent_did", "transaction_id", "settlement_address"],
-        "additionalProperties": false
-    })
-}
 
 /// Schema for list_transactions tool
 pub fn list_transactions_schema() -> Value {

tap-mcp/src/tools/schema.rs

@@ -12,7 +12,7 @@ use std::sync::Arc;
 use tap_caip::AssetId;
 use tap_msg::message::tap_message_trait::TapMessageBody;
 use tap_msg::message::{
-    Agent, Authorize, Cancel, Complete, Party, Reject, Revert, Settle, Transfer,
+    Agent, Authorize, Cancel, Party, Reject, Revert, Settle, Transfer,
 };
 use tap_node::storage::models::SchemaType;
 use tracing::{debug, error};
@@ -1250,145 +1250,3 @@ impl ToolHandler for ListTransactionsTool {
     }
 }
 
-/// Tool for completing transactions
-pub struct CompleteTool {
-    tap_integration: Arc<TapIntegration>,
-}
-
-/// Parameters for completing a transaction
-#[derive(Debug, Deserialize)]
-struct CompleteParams {
-    agent_did: String, // The DID of the agent that will sign and send this message
-    transaction_id: String,
-    settlement_address: String,
-    #[serde(default)]
-    amount: Option<String>,
-}
-
-/// Response for completing a transaction
-#[derive(Debug, Serialize)]
-struct CompleteResponse {
-    transaction_id: String,
-    message_id: String,
-    status: String,
-    settlement_address: String,
-    amount: Option<String>,
-    completed_at: String,
-}
-
-impl CompleteTool {
-    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 CompleteTool {
-    async fn handle(&self, arguments: Option<Value>) -> Result<CallToolResult> {
-        let params: CompleteParams = 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!(
-            "Completing transaction: {} with settlement_address: {}",
-            params.transaction_id, params.settlement_address
-        );
-
-        // Create complete message
-        let complete = Complete {
-            transaction_id: params.transaction_id.clone(),
-            settlement_address: params.settlement_address.clone(),
-            amount: params.amount.clone(),
-        };
-
-        // Validate the complete message
-        if let Err(e) = complete.validate() {
-            return Ok(error_text_response(format!(
-                "Complete validation failed: {}",
-                e
-            )));
-        }
-
-        // Create DIDComm message using the specified agent DID
-        let didcomm_message = match complete.to_didcomm(&params.agent_did) {
-            Ok(msg) => msg,
-            Err(e) => {
-                return Ok(error_text_response(format!(
-                    "Failed to create DIDComm message: {}",
-                    e
-                )));
-            }
-        };
-
-        // Determine recipient from the message
-        let recipient_did = if !didcomm_message.to.is_empty() {
-            didcomm_message.to[0].clone()
-        } else {
-            return Ok(error_text_response(
-                "No recipient found for complete message".to_string(),
-            ));
-        };
-
-        debug!(
-            "Sending complete from {} to {} for transaction: {}",
-            params.agent_did, recipient_did, params.transaction_id
-        );
-
-        // Send the message through the TAP node (this will handle storage, logging, and delivery tracking)
-        match self
-            .tap_integration()
-            .node()
-            .send_message(params.agent_did.clone(), didcomm_message.clone())
-            .await
-        {
-            Ok(packed_message) => {
-                debug!(
-                    "Complete message sent successfully to {}, packed message length: {}",
-                    recipient_did,
-                    packed_message.len()
-                );
-
-                let response = CompleteResponse {
-                    transaction_id: params.transaction_id,
-                    message_id: didcomm_message.id,
-                    status: "sent".to_string(),
-                    settlement_address: params.settlement_address,
-                    amount: params.amount,
-                    completed_at: chrono::Utc::now().to_rfc3339(),
-                };
-
-                let response_json = serde_json::to_string_pretty(&response).map_err(|e| {
-                    Error::tool_execution(format!("Failed to serialize response: {}", e))
-                })?;
-
-                Ok(success_text_response(response_json))
-            }
-            Err(e) => {
-                error!("Failed to send complete message: {}", e);
-                Ok(error_text_response(format!(
-                    "Failed to send complete message: {}",
-                    e
-                )))
-            }
-        }
-    }
-
-    fn get_definition(&self) -> Tool {
-        Tool {
-            name: "tap_complete".to_string(),
-            description: "Request from merchant to complete a TAP payment (TAIP-14) transaction using the Complete message so funds are settled and the transaction is finalized."
-                .to_string(),
-            input_schema: schema::complete_schema(),
-        }
-    }
-}

tap-mcp/src/tools/transaction_tools.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(), 31); // All 31 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(), 30); // All 30 tools should be available (including 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();
 

tap-mcp/tests/integration_tests.rs

@@ -9,7 +9,6 @@ pub mod agent_management;
 pub mod authorize;
 pub mod basic_message;
 pub mod cancel;
-pub mod complete;
 pub mod connection;
 pub mod context;
 pub mod did_presentation;
@@ -46,9 +45,6 @@ pub use basic_message::BasicMessage;
 // Re-export cancel type
 pub use cancel::Cancel;
 
-// Re-export complete type
-pub use complete::Complete;
-
 // Re-export connection types
 pub use connection::{
     AuthorizationRequired, Connect, ConnectionConstraints, OutOfBand, TransactionLimits,