refactor(Mountain/Vine): Standardize gRPC protocol field names and error handling

This commit refactors the Vine gRPC protocol definitions and implementation to establish consistent naming conventions and improve type safety across the IPC layer. Key changes include:

1. **Proto Field Standardization**:
   - Updated all field names in `Vine.proto` to PascalCase (e.g., `request_id` → `RequestIdentifier`, `params` → `Parameter`)
   - Renamed `RpcError` to `RPCError` for consistency
   - Added clearer comments for serialization expectations

2. **Rust Implementation Alignment**:
   - Updated `Mountain`'s Vine client/server code to match new proto field names
   - Renamed `VineError::RpcError` variant to `RPCError`
   - Improved error handling during JSON deserialization in gRPC handlers

3. **Build Process Enhancement**:
   - Added `compile_well_known_types(true)` in `build.rs` to support future protocol extensions

4. **Minor Refinements**:
   - Capitalized `IPCProvider` variable in shutdown sequence
   - Updated cancellation logic comments to reference new field names

These changes strengthen the foundation of the Vine IPC layer by:
- Ensuring field naming consistency between Mountain and Cocoon
- Preparing for advanced gRPC features through well-known type support
- Maintaining alignment with Land's core architecture where Vine serves as the critical communication channel between Mountain and Cocoon

BREAKING CHANGE: Requires corresponding updates in Cocoon to match new field names (`RequestIdentifier`, `Parameter`, `RPCError` etc.) in Vine.proto

Author: NikolaRHristov

Proto/Vine.proto

@@ -4,60 +4,75 @@ package vine_ipc;
 
 // Service running on the Mountain host, listening for requests from Cocoon.
 service MountainService {
-  // A generic request-response method for Cocoon to call a function on Mountain.
-  rpc ProcessCocoonRequest(GenericRequest) returns (GenericResponse);
-  // A generic fire-and-forget method for Cocoon to send a notification to Mountain.
-  rpc SendCocoonNotification(GenericNotification) returns (Empty);
-  // A method for Cocoon to request that Mountain cancel a long-running operation.
-  rpc CancelOperation(CancelOperationRequest) returns (Empty);
+	// A generic request-response method for Cocoon to call a function on Mountain.
+	rpc ProcessCocoonRequest(GenericRequest) returns (GenericResponse);
+
+	// A generic fire-and-forget method for Cocoon to send a notification to Mountain.
+	rpc SendCocoonNotification(GenericNotification) returns (Empty);
+
+	// A method for Cocoon to request that Mountain cancel a long-running operation.
+	rpc CancelOperation(CancelOperationRequest) returns (Empty);	
 }
 
 // Service running on the Cocoon sidecar, listening for requests from Mountain.
 service CocoonService {
-  // A generic request-response method for Mountain to call a function on Cocoon.
-  rpc ProcessMountainRequest(GenericRequest) returns (GenericResponse);
-  // A generic fire-and-forget method for Mountain to send a notification to Cocoon.
-  rpc SendMountainNotification(GenericNotification) returns (Empty);
-  // A method for Mountain to request that Cocoon cancel a long-running operation.
-  rpc CancelOperation(CancelOperationRequest) returns (Empty);
+	// A generic request-response method for Mountain to call a function on Cocoon.
+	rpc ProcessMountainRequest(GenericRequest) returns (GenericResponse);
+
+	// A generic fire-and-forget method for Mountain to send a notification to Cocoon.
+	rpc SendMountainNotification(GenericNotification) returns (Empty);
+
+	// A method for Mountain to request that Cocoon cancel a long-running operation.
+	rpc CancelOperation(CancelOperationRequest) returns (Empty);	
 }
 
 // Represents an empty message, typically used for RPCs that don't need to return data.
 message Empty {}
 
 // A generic request message containing a method name and serialized parameters.
 message GenericRequest {
-  uint64 request_id = 1;
-  string method = 2;
-  bytes params = 3; // Parameters are expected to be a JSON-serialized byte array.
+	uint64 RequestIdentifier = 1;
+
+	string Method = 2;
+
+	// Parameters are expected to be a JSON-serialized byte array.
+	bytes Parameter = 3;	
 }
 
 // A generic response message containing the result or an error.
 message GenericResponse {
-  uint64 request_id = 1;
-  bytes result = 2; // The successful result, JSON-serialized.
-  optional RpcError error = 3;
+	uint64 RequestIdentifier = 1;
+
+	// The successful result, JSON-serialized.
+	bytes Result = 2;
+
+	optional RPCError error = 3;	
 }
 
 // A generic notification message, which is fire-and-forget and does not have an ID.
 message GenericNotification {
-  string method = 1;
-  bytes params = 2; // Parameters are expected to be a JSON-serialized byte array.
+	string Method = 1;
+
+	// Parameters are expected to be a JSON-serialized byte array.
+	bytes Parameter = 2;	
 }
 
 // A structured error payload, compliant with JSON-RPC error objects.
-message RpcError {
-  int32 code = 1;
-  string message = 2;
-  bytes data = 3; // Optional, additional error data, JSON-serialized.
+message RPCError {
+	int32 Code = 1;
+
+	string Message = 2;
+
+	// Optional, additional error data, JSON-serialized.
+	bytes Data = 3;	
 }
 
 // A message to cancel a specific, ongoing operation.
 message CancelOperationRequest {
-  uint64 request_id_to_cancel = 1;
+	uint64 RequestIdentifierToCancel = 1;	
 }
 
 // A generic data payload, currently unused but available for future extensions.
 message RPCDataPayload {
-  bytes data = 1;
+	bytes Data = 1;
 }

Source/RunTime/ApplicationRunTime.rs

@@ -53,8 +53,8 @@ impl ApplicationRunTime {
 		info!("[ApplicationRunTime] Initiating graceful shutdown of services...");
 
 		// 1. Shutdown Cocoon
-		let IpcProvider:Arc<dyn IPCProvider> = self.Environment.Require();
-		if let Err(e) = IpcProvider
+		let IPCProvider:Arc<dyn IPCProvider> = self.Environment.Require();
+		if let Err(e) = IPCProvider
 			.SendNotificationToSidecar("cocoon-main".to_string(), "$shutdown".to_string(), serde_json::Value::Null)
 			.await
 		{

Source/Vine/Client.rs

@@ -47,7 +47,7 @@ pub async fn SendNotification(SidecarIdentifier:String, Method:String, Parameter
 	};
 
 	if let Some(ref mut client) = client {
-		let request = GenericNotification { method:Method, params:to_vec(&Parameters)? };
+		let request = GenericNotification { method:Method, parameter:to_vec(&Parameters)? };
 		client.send_mountain_notification(request).await?;
 		Ok(())
 	} else {
@@ -74,9 +74,13 @@ pub async fn SendRequest(
 	if let Some(ref mut client) = client {
 		let mut hasher = DefaultHasher::new();
 		uuid::Uuid::new_v4().hash(&mut hasher);
-		let request_id = hasher.finish();
+		let RequestIdentifier = hasher.finish();
 
-		let request = GenericRequest { request_id, method:Method.clone(), params:to_vec(&Parameters)? };
+		let request = GenericRequest {
+			request_identifier:RequestIdentifier,
+			method:Method.clone(),
+			parameter:to_vec(&Parameters)?,
+		};
 
 		let future = client.process_mountain_request(request);
 
@@ -88,7 +92,7 @@ pub async fn SendRequest(
 						"[VineClient] Received RPC error from sidecar '{}': {}",
 						SidecarIdentifier, rpc_error.message
 					);
-					Err(VineError::RpcError(rpc_error.message))
+					Err(VineError::RPCError(rpc_error.message))
 				} else {
 					let deserialized_value = from_slice(&response_data.result)?;
 					Ok(deserialized_value)

Source/Vine/Error.rs

@@ -18,7 +18,7 @@ pub enum VineError {
 
 	/// An RPC call to a sidecar failed with a specific gRPC status.
 	#[error("gRPC call failed: {0}")]
-	RpcError(String),
+	RPCError(String),
 
 	/// An error occurred while serializing or deserializing a JSON payload.
 	#[error("JSON serialization error for gRPC payload: {0}")]
@@ -50,5 +50,5 @@ impl<T> From<PoisonError<MutexGuard<'_, T>>> for VineError {
 }
 
 impl From<tonic::Status> for VineError {
-	fn from(status:tonic::Status) -> Self { VineError::RpcError(status.to_string()) }
+	fn from(status:tonic::Status) -> Self { VineError::RPCError(status.to_string()) }
 }

Source/Vine/Generated/vine_ipc.rs

@@ -6,18 +6,18 @@ pub struct Empty {}
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GenericRequest {
     #[prost(uint64, tag = "1")]
-    pub request_id: u64,
+    pub request_identifier: u64,
     #[prost(string, tag = "2")]
     pub method: ::prost::alloc::string::String,
     /// Parameters are expected to be a JSON-serialized byte array.
     #[prost(bytes = "vec", tag = "3")]
-    pub params: ::prost::alloc::vec::Vec<u8>,
+    pub parameter: ::prost::alloc::vec::Vec<u8>,
 }
 /// A generic response message containing the result or an error.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GenericResponse {
     #[prost(uint64, tag = "1")]
-    pub request_id: u64,
+    pub request_identifier: u64,
     /// The successful result, JSON-serialized.
     #[prost(bytes = "vec", tag = "2")]
     pub result: ::prost::alloc::vec::Vec<u8>,
@@ -31,7 +31,7 @@ pub struct GenericNotification {
     pub method: ::prost::alloc::string::String,
     /// Parameters are expected to be a JSON-serialized byte array.
     #[prost(bytes = "vec", tag = "2")]
-    pub params: ::prost::alloc::vec::Vec<u8>,
+    pub parameter: ::prost::alloc::vec::Vec<u8>,
 }
 /// A structured error payload, compliant with JSON-RPC error objects.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -48,7 +48,7 @@ pub struct RpcError {
 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
 pub struct CancelOperationRequest {
     #[prost(uint64, tag = "1")]
-    pub request_id_to_cancel: u64,
+    pub request_identifier_to_cancel: u64,
 }
 /// A generic data payload, currently unused but available for future extensions.
 #[derive(Clone, PartialEq, ::prost::Message)]

Source/Vine/Server/MountainVinegRPCService.rs

@@ -20,7 +20,7 @@ use crate::{
 		GenericNotification,
 		GenericRequest,
 		GenericResponse,
-		RpcError,
+		RpcError as RPCError,
 		mountain_service_server::MountainService,
 	},
 };
@@ -48,22 +48,22 @@ impl MountainService for MountainVinegRPCService {
 	) -> Result<Response<GenericResponse>, Status> {
 		let RequestData = request.into_inner();
 		let MethodName = RequestData.method;
-		let RequestIdentifier = RequestData.request_id;
+		let RequestIdentifier = RequestData.request_identifier;
 
 		info!(
 			"[VineServer] Received gRPC Request [ID: {}]: Method='{}'",
 			RequestIdentifier, MethodName
 		);
 
-		let ParametersValue:Value = match serde_json::from_slice(&RequestData.params) {
+		let ParametersValue:Value = match serde_json::from_slice(&RequestData.parameter) {
 			Ok(v) => v,
 			Err(e) => {
 				let msg = format!("Failed to deserialize parameters for method '{}': {}", MethodName, e);
 				error!("{}", msg);
 				return Ok(Response::new(GenericResponse {
-					request_id:RequestIdentifier,
+					request_identifier:RequestIdentifier,
 					result:vec![],
-					error:Some(RpcError { message:msg, code:-32700, data:vec![] }),
+					error:Some(RPCError { message:msg, code:-32700, data:vec![] }),
 				}));
 			},
 		};
@@ -85,16 +85,16 @@ impl MountainService for MountainVinegRPCService {
 					b"null".to_vec()
 				});
 				Ok(Response::new(GenericResponse {
-					request_id:RequestIdentifier,
+					request_identifier:RequestIdentifier,
 					result:ResultBytes,
 					error:None,
 				}))
 			},
 			Err(ErrorString) => {
 				Ok(Response::new(GenericResponse {
-					request_id:RequestIdentifier,
+					request_identifier:RequestIdentifier,
 					result:vec![],
-					error:Some(RpcError {
+					error:Some(RPCError {
 						message:ErrorString,
 						code:-32000, // JSON-RPC Generic Server Error
 						data:vec![],
@@ -114,16 +114,16 @@ impl MountainService for MountainVinegRPCService {
 		// dedicated handler for processing status updates, etc. For now, we
 		// just log and acknowledge.
 		// For example:
-		// let params: Value = serde_json::from_slice(...)?;
-		// NotificationHandler::Handle(MethodName, params).await;
+		// let Parameter: Value = serde_json::from_slice(...)?;
+		// NotificationHandler::Handle(MethodName, Parameter).await;
 
 		Ok(Response::new(Empty {}))
 	}
 
 	/// Handles a request from Cocoon to cancel a long-running operation.
 	async fn cancel_operation(&self, _request:Request<CancelOperationRequest>) -> Result<Response<Empty>, Status> {
 		info!("[VineServer] Received CancelOperation request, but cancellation is not yet implemented.");
-		// A full implementation would map the request_id_to_cancel to a
+		// A full implementation would map the RequestIdentifier_to_cancel to a
 		// CancellationToken and trigger it.
 		Ok(Response::new(Empty {}))
 	}

build.rs

@@ -55,6 +55,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 		.build_server(true)
 		.build_client(true)
 		.out_dir("Source/Vine/Generated")
+		.compile_well_known_types(true)
 		.compile_protos(&["Proto/Vine.proto"], &["Proto"])?;
 
 	tauri_build::build();