diff --git a/go.mod b/go.mod
index 09fe1092f..4b8dc13b2 100644
--- a/go.mod
+++ b/go.mod
@@ -154,4 +154,6 @@ require (
 	golang.org/x/crypto v0.14.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 )
-
+replace (
+	github.com/OpenIMSDK/protocol v0.0.37 => github.com/AndrewZuo01/protocol v0.0.0-20231221102834-60b65871d305
+)
diff --git a/internal/api/msg.go b/internal/api/msg.go
index 664ee505a..e8fc7116a 100644
--- a/internal/api/msg.go
+++ b/internal/api/msg.go
@@ -173,6 +173,7 @@ func (m *MessageApi) getSendMsgReq(c *gin.Context, req apistruct.SendMsg) (sendM
 			return nil, errs.ErrNoPermission.
 				Wrap("only app manager can as sender send OANotificationElem")
 		}
+
 	default:
 		return nil, errs.ErrArgs.WithDetail("not support err contentType")
 	}
@@ -186,38 +187,63 @@ func (m *MessageApi) getSendMsgReq(c *gin.Context, req apistruct.SendMsg) (sendM
 	return m.newUserSendMsgReq(c, &req), nil
 }
 
+// SendMessage handles the sending of a message. It's an HTTP handler function to be used with Gin framework.
 func (m *MessageApi) SendMessage(c *gin.Context) {
+	// Initialize a request struct for sending a message.
 	req := apistruct.SendMsgReq{}
+
+	// Bind the JSON request body to the request struct.
 	if err := c.BindJSON(&req); err != nil {
+		// Respond with an error if request body binding fails.
 		apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap())
 		return
 	}
+
+	// Check if the user has the app manager role.
 	if !authverify.IsAppManagerUid(c) {
+		// Respond with a permission error if the user is not an app manager.
 		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
 		return
 	}
+
+	// Prepare the message request with additional required data.
 	sendMsgReq, err := m.getSendMsgReq(c, req.SendMsg)
 	if err != nil {
+		// Log and respond with an error if preparation fails.
 		log.ZError(c, "decodeData failed", err)
 		apiresp.GinError(c, err)
 		return
 	}
+
+	// Set the receiver ID in the message data.
 	sendMsgReq.MsgData.RecvID = req.RecvID
+
+	// Declare a variable to store the message sending status.
 	var status int
+
+	// Attempt to send the message using the client.
 	respPb, err := m.Client.SendMsg(c, sendMsgReq)
 	if err != nil {
+		// Set the status to failed and respond with an error if sending fails.
 		status = constant.MsgSendFailed
 		log.ZError(c, "send message err", err)
 		apiresp.GinError(c, err)
 		return
 	}
+
+	// Set the status to successful if the message is sent.
 	status = constant.MsgSendSuccessed
+
+	// Attempt to update the message sending status in the system.
 	_, err = m.Client.SetSendMsgStatus(c, &msg.SetSendMsgStatusReq{
 		Status: int32(status),
 	})
 	if err != nil {
+		// Log the error if updating the status fails.
 		log.ZError(c, "SetSendMsgStatus failed", err)
 	}
+
+	// Respond with a success message and the response payload.
 	apiresp.GinSuccess(c, respPb)
 }
 
diff --git a/internal/msggateway/client.go b/internal/msggateway/client.go
index 69b49d81a..43047fd73 100644
--- a/internal/msggateway/client.go
+++ b/internal/msggateway/client.go
@@ -87,6 +87,7 @@ func newClient(ctx *UserConnContext, conn LongConn, isCompress bool) *Client {
 	}
 }
 
+// ResetClient updates the client's state with new connection and context information.
 func (c *Client) ResetClient(
 	ctx *UserConnContext,
 	conn LongConn,
@@ -108,11 +109,13 @@ func (c *Client) ResetClient(
 	c.token = token
 }
 
+// pingHandler handles ping messages and sends pong responses.
 func (c *Client) pingHandler(_ string) error {
 	_ = c.conn.SetReadDeadline(pongWait)
 	return c.writePongMsg()
 }
 
+// readMessage continuously reads messages from the connection.
 func (c *Client) readMessage() {
 	defer func() {
 		if r := recover(); r != nil {
@@ -164,6 +167,7 @@ func (c *Client) readMessage() {
 	}
 }
 
+// handleMessage processes a single message received by the client.
 func (c *Client) handleMessage(message []byte) error {
 	if c.IsCompress {
 		var err error