Wrapping packet information
One empty interface could be considered a code smell, but can sometimes be useful for reflection purposes. Having two is nonsensical. An interface defines a contract that the type has to adhere to. Where's the contract here? I fail to see how these two types belong to the same inheritance tree. "Type" members also set off alarm bells in my head. They're usually an indication that there are missing interfaces. You could then just inspect the actual type, if you really had to. 

I would go with something more like this. 

public interface IMessagePacket 
{
    string Message { get; }
}

public interface IStatusPacket
{
    bool Status { get; }
}

[Serializable]
public struct ServerChatIncomingMessagePacket : IMessagePacket
{
    public readonly string text;

    public string Message
    {
        get { return text; }
    }

    public ServerChatIncomingMessagePacket(string text)
    {
        this.text = text;
    }
}

[Serializable]
public struct ServerAccountAnswerLoginPacket : IStatusPacket
{
    public readonly bool success;

    public bool Status
    {
         get { return success; }
    }

    public ServerAccountAnswerLoginPacket(bool success)
    {
        this.success = success;
    }
}


This allows us to define behavior of the types. We could easily implement an OutGoingMessagePacket that implements IMessagePacket, or a LogOffPacket that implements IStatusPacket. 



On another note, in your original implementation, you never used the parameter you passed to ServerAccountAnswerLoginPacket's constructor, or it's related private readonly field.