anchor.diff:      State1 = State0#thrift_processor{protocol = Proto1},
       case MessageBegin of
           #protocol_message_begin{name = Function,
  -                                type = ?tMessageType_CALL} ->
  -            {State2, ok} = handle_function(State1, list_to_atom(Function)),
  +                                type = ?tMessageType_CALL,
  +                                seqid = Seqid} ->
  +            {State2, ok} = handle_function(State1, list_to_atom(Function), Seqid),
               loop(State2);
           #protocol_message_begin{name = Function,
  -                                type = ?tMessageType_ONEWAY} ->
  -            {State2, ok} = handle_function(State1, list_to_atom(Function)),
  +                                type = ?tMessageType_ONEWAY, 
  +                                seqid = Seqid} ->
  +            {State2, ok} = handle_function(State1, list_to_atom(Function), Seqid),
               loop(State2);
           {error, timeout} ->
               thrift_protocol:close_transport(Proto1),
  
positive.code:                                                 % Make sure we got at least one defined
      case lists:all(fun(X) -> X =:= undefined end, ExceptionList) of
          true ->
              handle_unknown_exception(State, Function, Exception);
          false ->
              send_reply(State, Function, ?tMessageType_REPLY, {ReplySpec, ExceptionTuple})
      end.
  
  %%
  %% Called when an exception has been explicitly thrown by the service, but it was
  %% not one of the exceptions that was defined for the function.
  %%
  handle_unknown_exception(State, Function, Exception) ->
      handle_error(State, Function, {exception_not_declared_as_thrown,
                                     Exception}).
  
  handle_error(State, Function, Error) ->
      Stack = erlang:get_stacktrace(),
      error_logger:error_msg("~p had an error: ~p~n", [Function, {Error, Stack}]),
  
  
negative.code: 
          {throw, Exception} when is_tuple(Exception), size(Exception) > 0 ->
              %error_logger:warning_msg("~p threw exception: ~p~n", [Function, Exception]),
              handle_exception(State, Function, Exception, Seqid);
              % we still want to accept more requests from this client
  
          {error, Error} ->
              handle_error(State, Function, Error, Seqid)
      end.
  
  handle_success(State = #thrift_processor{service = Service},
                 Function,
                 Result,
                 Seqid) ->
      ReplyType  = Service:function_info(Function, reply_type),
      StructName = atom_to_list(Function) ++ "_result",
  
      case Result of
          {reply, ReplyData} ->
              Reply = {{struct, [{0, ReplyType}]}, {StructName, ReplyData}},
              send_reply(State, Function, ?tMessageType_REPLY, Reply, Seqid);
  
          ok when ReplyType == {struct, []} ->
              send_reply(State, Function, ?tMessageType_REPLY, {ReplyType, {StructName}}, Seqid);
  
          ok when ReplyType == oneway_void ->
              %% no reply for oneway void
  