diff --git a/components/rpc/invoker/mosn/mosninvoker.go b/components/rpc/invoker/mosn/mosninvoker.go
index c85dc4e330..211b708c3e 100644
--- a/components/rpc/invoker/mosn/mosninvoker.go
+++ b/components/rpc/invoker/mosn/mosninvoker.go
@@ -121,6 +121,7 @@ func (m *mosnInvoker) Invoke(ctx context.Context, req *rpc.RPCRequest) (resp *rp
 	resp, err = m.cb.AfterInvoke(resp)
 	if err != nil {
 		log.DefaultLogger.Errorf("[runtime][rpc]after filter error %s", err.Error())
+		return nil, err
 	}
-	return resp, err
+	return resp, nil
 }
diff --git a/components/rpc/invoker/mosn/transport_protocol/bolt.go b/components/rpc/invoker/mosn/transport_protocol/bolt.go
index 13a27ad5a9..caf7ffd789 100644
--- a/components/rpc/invoker/mosn/transport_protocol/bolt.go
+++ b/components/rpc/invoker/mosn/transport_protocol/bolt.go
@@ -63,20 +63,24 @@ func (b *boltCommon) Init(conf map[string]interface{}) error {
 // FromFrame is boltProtocol transform
 func (b *boltCommon) FromFrame(resp api.XRespFrame) (*rpc.RPCResponse, error) {
 	respCode := uint16(resp.GetStatusCode())
-	if respCode == bolt.ResponseStatusSuccess {
-		return b.fromFrame.FromFrame(resp)
+	rpcResp, err := b.fromFrame.FromFrame(resp)
+	rpcResp.Success = false
+	if err != nil {
+		return nil, common.Errorf(common.InternalCode, "bolt error code %d, transform RPCResponse fail with err: %+v", respCode, err)
 	}
-
 	switch respCode {
+	case bolt.ResponseStatusSuccess:
+		rpcResp.Success = true
 	case bolt.ResponseStatusServerDeserialException:
-		return nil, common.Errorf(common.InternalCode, "bolt error code %d, ServerDeserializeException", respCode)
+		rpcResp.Error = common.Errorf(common.InternalCode, "bolt error code %d, ServerDeserializeException", respCode)
 	case bolt.ResponseStatusServerSerialException:
-		return nil, common.Errorf(common.InternalCode, "bolt error code %d, ServerSerializeException", respCode)
+		rpcResp.Error = common.Errorf(common.InternalCode, "bolt error code %d, ServerSerializeException", respCode)
 	case bolt.ResponseStatusCodecException:
-		return nil, common.Errorf(common.InternalCode, "bolt error code %d, CodecException", respCode)
+		rpcResp.Error = common.Errorf(common.InternalCode, "bolt error code %d, CodecException", respCode)
 	default:
-		return nil, common.Errorf(common.UnavailebleCode, "bolt error code %d", respCode)
+		rpcResp.Error = common.Errorf(common.UnavailebleCode, "bolt error code %d", respCode)
 	}
+	return rpcResp, nil
 }
 
 // newBoltProtocol is create boltProtocol
diff --git a/components/rpc/invoker/mosn/transport_protocol/bolt_test.go b/components/rpc/invoker/mosn/transport_protocol/bolt_test.go
index 0d08edf555..ba0b50603d 100644
--- a/components/rpc/invoker/mosn/transport_protocol/bolt_test.go
+++ b/components/rpc/invoker/mosn/transport_protocol/bolt_test.go
@@ -66,9 +66,58 @@ func Test_boltCommon_FromFrame(t *testing.T) {
 		err := b.Init(conf)
 		assert.Nil(t, err)
 
-		_, err = b.FromFrame(resp)
-		assert.NotNil(t, err)
-		assert.True(t, strings.Contains(err.Error(), "bolt error code 1"))
+		f, err := b.FromFrame(resp)
+		assert.Nil(t, err)
+		assert.Equal(t, false, f.Success)
+		assert.True(t, strings.Contains(f.Error.Error(), "bolt error code 1"))
+	})
+
+	t.Run("fail", func(t *testing.T) {
+		resp := &bolt.Response{}
+		resp.ResponseStatus = bolt.ResponseStatusServerDeserialException
+		b := &boltCommon{}
+		conf := map[string]interface{}{
+			"class": "bolt",
+		}
+		err := b.Init(conf)
+		assert.Nil(t, err)
+
+		f, err := b.FromFrame(resp)
+		assert.Nil(t, err)
+		assert.Equal(t, false, f.Success)
+		assert.True(t, strings.Contains(f.Error.Error(), "bolt error code 18"))
+	})
+
+	t.Run("fail", func(t *testing.T) {
+		resp := &bolt.Response{}
+		resp.ResponseStatus = bolt.ResponseStatusServerSerialException
+		b := &boltCommon{}
+		conf := map[string]interface{}{
+			"class": "bolt",
+		}
+		err := b.Init(conf)
+		assert.Nil(t, err)
+
+		f, err := b.FromFrame(resp)
+		assert.Nil(t, err)
+		assert.Equal(t, false, f.Success)
+		assert.True(t, strings.Contains(f.Error.Error(), "bolt error code 17"))
+	})
+
+	t.Run("fail", func(t *testing.T) {
+		resp := &bolt.Response{}
+		resp.ResponseStatus = bolt.ResponseStatusCodecException
+		b := &boltCommon{}
+		conf := map[string]interface{}{
+			"class": "bolt",
+		}
+		err := b.Init(conf)
+		assert.Nil(t, err)
+
+		f, err := b.FromFrame(resp)
+		assert.Nil(t, err)
+		assert.Equal(t, false, f.Success)
+		assert.True(t, strings.Contains(f.Error.Error(), "bolt error code 9"))
 	})
 }
 
diff --git a/components/rpc/types.go b/components/rpc/types.go
index 95b95276ea..7aa9781c7c 100644
--- a/components/rpc/types.go
+++ b/components/rpc/types.go
@@ -78,6 +78,8 @@ type RPCResponse struct {
 	Header      RPCHeader
 	ContentType string
 	Data        []byte
+	Success     bool
+	Error       error
 }
 
 type RpcConfig struct {
diff --git a/pkg/grpc/dapr/dapr_api.go b/pkg/grpc/dapr/dapr_api.go
index 0ea0d1a0b5..df7ddbe122 100644
--- a/pkg/grpc/dapr/dapr_api.go
+++ b/pkg/grpc/dapr/dapr_api.go
@@ -117,6 +117,10 @@ func (d *daprGrpcAPI) InvokeService(ctx context.Context, in *dapr_v1pb.InvokeSer
 	if err != nil {
 		return nil, runtime_common.ToGrpcError(err)
 	}
+	// 5. convert result
+	if !resp.Success && resp.Error != nil {
+		return nil, runtime_common.ToGrpcError(resp.Error)
+	}
 
 	if resp.Header != nil {
 		header := metadata.Pairs()