diff --git a/.gerrit_commit_message b/.gerrit_commit_message
new file mode 100644
index 0000000..ad8838d
--- /dev/null
+++ b/.gerrit_commit_message
@@ -0,0 +1,7 @@
+wspr: Use a type flow to pass type messages between wspr and js.
+
+This change doesn't make any new code paths re-use the type info across
+requests.  That will happen in subsequent changes.
+
+MultiPart: 2/2
+Change-Id: I5e540c2f66b421bca6e8e27317748c0160404058
\ No newline at end of file
diff --git a/services/wspr/internal/app/app.go b/services/wspr/internal/app/app.go
index 0aa6f44..140203f 100644
--- a/services/wspr/internal/app/app.go
+++ b/services/wspr/internal/app/app.go
@@ -7,6 +7,8 @@
 package app
 
 import (
+	"bytes"
+	"encoding/hex"
 	"fmt"
 	"io"
 	"reflect"
@@ -101,13 +103,10 @@
 	// an outgoing rpc call.
 	reservedServices map[string]rpc.Invoker
 
-	encoderLock   sync.Mutex
-	clientEncoder *vom.Encoder
-	clientWriter  *lib.ProxyWriter
+	typeEncoder *vom.TypeEncoder
 
-	decoderLock   sync.Mutex
-	clientDecoder *vom.Decoder
-	clientReader  *lib.ProxyReader
+	typeDecoder *vom.TypeDecoder
+	typeReader  *lib.TypeReader
 }
 
 var _ ControllerServerMethods = (*Controller)(nil)
@@ -174,7 +173,7 @@
 			if blessings, ok := item.(security.Blessings); ok {
 				item = principal.ConvertBlessingsToHandle(blessings, c.blessingsHandles.GetOrAddHandle(blessings))
 			}
-			vomItem, err := lib.HexVomEncode(item)
+			vomItem, err := lib.HexVomEncode(item, c.typeEncoder)
 			if err != nil {
 				w.Error(verror.New(marshallingError, ctx, item, err))
 				continue
@@ -219,13 +218,13 @@
 		OutArgs:       results,
 		TraceResponse: vtrace.GetResponse(ctx),
 	}
-	c.encoderLock.Lock()
-	defer c.encoderLock.Unlock()
-	if err := c.clientEncoder.Encode(response); err != nil {
+	var buf bytes.Buffer
+	encoder := vom.NewEncoderWithTypeEncoder(&buf, c.typeEncoder)
+	if err := encoder.Encode(response); err != nil {
 		w.Error(err)
 		return
 	}
-	encoded := c.clientWriter.ConsumeBuffer()
+	encoded := hex.EncodeToString(buf.Bytes())
 	if err := w.Send(lib.ResponseFinal, encoded); err != nil {
 		w.Error(verror.Convert(marshallingError, ctx, err))
 	}
@@ -293,7 +292,7 @@
 	id := c.lastGeneratedId
 	c.lastGeneratedId += 2
 	c.flowMap[id] = s
-	os := newStream(c.blessingsHandles)
+	os := newStream(c.blessingsHandles, c.typeDecoder)
 	os.init(stream)
 	c.outstandingRequests[id] = &outstandingRequest{
 		stream: os,
@@ -363,6 +362,7 @@
 		server.Stop()
 	}
 
+	c.typeReader.Close()
 	c.cancel()
 }
 
@@ -371,10 +371,10 @@
 	c.outstandingRequests = make(map[int32]*outstandingRequest)
 	c.flowMap = make(map[int32]interface{})
 	c.servers = make(map[uint32]*server.Server)
-	c.clientReader = lib.NewProxyReader()
-	c.clientDecoder = vom.NewDecoder(c.clientReader)
-	c.clientWriter = lib.NewProxyWriter()
-	c.clientEncoder = vom.NewEncoder(c.clientWriter)
+	c.typeReader = lib.NewTypeReader()
+	c.typeDecoder = vom.NewTypeDecoder(c.typeReader)
+	c.typeEncoder = vom.NewTypeEncoder(lib.NewTypeWriter(c.writerCreator(0)))
+	c.lastGeneratedId += 2
 }
 
 // SendOnStream writes data on id's stream.  The actual network write will be
@@ -443,10 +443,11 @@
 // but currently none of the methods the controller exports require
 // any of this context information.
 type localCall struct {
-	ctx  *context.T
-	vrpc *RpcRequest
-	tags []*vdl.Value
-	w    lib.ClientWriter
+	ctx         *context.T
+	vrpc        *RpcRequest
+	tags        []*vdl.Value
+	w           lib.ClientWriter
+	typeEncoder *vom.TypeEncoder
 }
 
 var (
@@ -455,7 +456,7 @@
 )
 
 func (l *localCall) Send(item interface{}) error {
-	vomItem, err := lib.HexVomEncode(item)
+	vomItem, err := lib.HexVomEncode(item, l.typeEncoder)
 	if err != nil {
 		err = verror.New(marshallingError, l.ctx, item, err)
 		l.w.Error(err)
@@ -484,42 +485,40 @@
 func (l *localCall) RemoteEndpoint() naming.Endpoint                 { return nil }
 func (l *localCall) Security() security.Call                         { return l }
 
-func (c *Controller) handleInternalCall(ctx *context.T, invoker rpc.Invoker, msg *RpcRequest, w lib.ClientWriter, span vtrace.Span) {
+func (c *Controller) handleInternalCall(ctx *context.T, invoker rpc.Invoker, msg *RpcRequest, w lib.ClientWriter, span vtrace.Span, decoder *vom.Decoder) {
 	argptrs, tags, err := invoker.Prepare(msg.Method, int(msg.NumInArgs))
 	if err != nil {
 		w.Error(verror.Convert(verror.ErrInternal, ctx, err))
 		return
 	}
 	for _, argptr := range argptrs {
-		if err := c.clientDecoder.Decode(argptr); err != nil {
+		if err := decoder.Decode(argptr); err != nil {
 			w.Error(verror.Convert(verror.ErrInternal, ctx, err))
 			return
 		}
 	}
-	go func() {
-		results, err := invoker.Invoke(ctx, &localCall{ctx, msg, tags, w}, msg.Method, argptrs)
+	results, err := invoker.Invoke(ctx, &localCall{ctx, msg, tags, w, c.typeEncoder}, msg.Method, argptrs)
+	if err != nil {
+		w.Error(verror.Convert(verror.ErrInternal, ctx, err))
+		return
+	}
+	if msg.IsStreaming {
+		if err := w.Send(lib.ResponseStreamClose, nil); err != nil {
+			w.Error(verror.New(marshallingError, ctx, "ResponseStreamClose"))
+		}
+	}
+
+	// Convert results from []interface{} to []*vdl.Value.
+	vresults := make([]*vdl.Value, len(results))
+	for i, res := range results {
+		vv, err := vdl.ValueFromReflect(reflect.ValueOf(res))
 		if err != nil {
 			w.Error(verror.Convert(verror.ErrInternal, ctx, err))
 			return
 		}
-		if msg.IsStreaming {
-			if err := w.Send(lib.ResponseStreamClose, nil); err != nil {
-				w.Error(verror.New(marshallingError, ctx, "ResponseStreamClose"))
-			}
-		}
-
-		// Convert results from []interface{} to []*vdl.Value.
-		vresults := make([]*vdl.Value, len(results))
-		for i, res := range results {
-			vv, err := vdl.ValueFromReflect(reflect.ValueOf(res))
-			if err != nil {
-				w.Error(verror.Convert(verror.ErrInternal, ctx, err))
-				return
-			}
-			vresults[i] = vv
-		}
-		c.sendRPCResponse(ctx, w, span, vresults)
-	}()
+		vresults[i] = vv
+	}
+	c.sendRPCResponse(ctx, w, span, vresults)
 }
 
 // HandleCaveatValidationResponse handles the response to caveat validation
@@ -537,15 +536,18 @@
 
 // HandleVeyronRequest starts a vanadium rpc and returns before the rpc has been completed.
 func (c *Controller) HandleVeyronRequest(ctx *context.T, id int32, data string, w lib.ClientWriter) {
-	c.decoderLock.Lock()
-	defer c.decoderLock.Unlock()
-	err := c.clientReader.ReplaceBuffer(data)
+	binBytes, err := hex.DecodeString(data)
+	if err != nil {
+		w.Error(verror.Convert(verror.ErrInternal, ctx, fmt.Errorf("Error decoding hex string %q: %v", data, err)))
+		return
+	}
+	decoder := vom.NewDecoderWithTypeDecoder(bytes.NewReader(binBytes), c.typeDecoder)
 	if err != nil {
 		w.Error(verror.Convert(verror.ErrInternal, ctx, fmt.Errorf("Error decoding hex string %q: %v", data, err)))
 		return
 	}
 	var msg RpcRequest
-	if err := c.clientDecoder.Decode(&msg); err != nil {
+	if err := decoder.Decode(&msg); err != nil {
 		w.Error(verror.Convert(verror.ErrInternal, ctx, err))
 		return
 	}
@@ -568,14 +570,14 @@
 
 	// If this message is for an internal service, do a short-circuit dispatch here.
 	if invoker, ok := c.reservedServices[msg.Name]; ok {
-		c.handleInternalCall(ctx, invoker, &msg, w, span)
+		go c.handleInternalCall(ctx, invoker, &msg, w, span, decoder)
 		return
 	}
 
 	inArgs := make([]interface{}, msg.NumInArgs)
 	for i := range inArgs {
 		var v *vdl.Value
-		if err := c.clientDecoder.Decode(&v); err != nil {
+		if err := decoder.Decode(&v); err != nil {
 			w.Error(err)
 			return
 		}
@@ -591,7 +593,7 @@
 		// to put the outstanding stream in the map before we make the async call so that
 		// the future send know which queue to write to, even if the client call isn't
 		// actually ready yet.
-		request.stream = newStream(c.blessingsHandles)
+		request.stream = newStream(c.blessingsHandles, c.typeDecoder)
 	}
 	c.Lock()
 	c.outstandingRequests[id] = request
@@ -742,16 +744,6 @@
 	server.HandleServerResponse(id, data)
 }
 
-// parseVeyronRequest parses a json rpc request into a RpcRequest object.
-func (c *Controller) parseVeyronRequest(data string) (*RpcRequest, error) {
-	var msg RpcRequest
-	if err := lib.HexVomDecode(data, &msg); err != nil {
-		return nil, err
-	}
-	vlog.VI(2).Infof("RpcRequest: %s.%s(..., streaming=%v)", msg.Name, msg.Method, msg.IsStreaming)
-	return &msg, nil
-}
-
 // getSignature uses the signature manager to get and cache the signature of a remote server.
 func (c *Controller) getSignature(ctx *context.T, name string) ([]signature.Interface, error) {
 	return c.signatureManager.Signature(ctx, name)
@@ -935,6 +927,10 @@
 	granterStr.Send(data)
 }
 
+func (c *Controller) HandleTypeMessage(data string) {
+	c.typeReader.Add(data)
+}
+
 func (c *Controller) BlessingsDebugString(_ *context.T, _ rpc.ServerCall, handle principal.BlessingsHandle) (string, error) {
 	var inputBlessings security.Blessings
 	if inputBlessings = c.GetBlessings(handle); inputBlessings.IsZero() {
@@ -979,3 +975,7 @@
 		vlog.Errorf("unexpected error sending blessings cache message: %v", err)
 	}
 }
+
+func (c *Controller) TypeEncoder() *vom.TypeEncoder {
+	return c.typeEncoder
+}
diff --git a/services/wspr/internal/app/app_test.go b/services/wspr/internal/app/app_test.go
index 4550e58..b71c6ff 100644
--- a/services/wspr/internal/app/app_test.go
+++ b/services/wspr/internal/app/app_test.go
@@ -6,6 +6,7 @@
 
 import (
 	"bytes"
+	"encoding/base64"
 	"encoding/hex"
 	"fmt"
 	"reflect"
@@ -129,6 +130,11 @@
 	return startAnyServer(ctx, true, mt)
 }
 
+func createWriterCreator(w lib.ClientWriter) func(id int32) lib.ClientWriter {
+	return func(int32) lib.ClientWriter {
+		return w
+	}
+}
 func TestGetGoServerSignature(t *testing.T) {
 	ctx, shutdown := test.V23Init()
 	defer shutdown()
@@ -143,7 +149,8 @@
 
 	spec := v23.GetListenSpec(ctx)
 	spec.Proxy = "mockVeyronProxyEP"
-	controller, err := NewController(ctx, nil, &spec, nil, newBlessedPrincipal(ctx))
+	writer := &testwriter.Writer{}
+	controller, err := NewController(ctx, createWriterCreator(writer), &spec, nil, newBlessedPrincipal(ctx))
 
 	if err != nil {
 		t.Fatalf("Failed to create controller: %v", err)
@@ -164,12 +171,13 @@
 }
 
 type goServerTestCase struct {
-	method          string
-	inArgs          []interface{}
-	numOutArgs      int32
-	streamingInputs []interface{}
-	expectedStream  []lib.Response
-	expectedError   error
+	expectedTypeStream []lib.Response
+	method             string
+	inArgs             []interface{}
+	numOutArgs         int32
+	streamingInputs    []interface{}
+	expectedStream     []lib.Response
+	expectedError      error
 }
 
 func runGoServerTestCase(t *testing.T, testCase goServerTestCase) {
@@ -186,23 +194,23 @@
 
 	spec := v23.GetListenSpec(ctx)
 	spec.Proxy = "mockVeyronProxyEP"
-	controller, err := NewController(ctx, nil, &spec, nil, newBlessedPrincipal(ctx))
+	writer := testwriter.Writer{}
+	controller, err := NewController(ctx, createWriterCreator(&writer), &spec, nil, newBlessedPrincipal(ctx))
 
 	if err != nil {
 		t.Errorf("unable to create controller: %v", err)
 		t.Fail()
 		return
 	}
-	writer := testwriter.Writer{}
 	var stream *outstandingStream
 	if len(testCase.streamingInputs) > 0 {
-		stream = newStream(nil)
+		stream = newStream(nil, nil)
 		controller.outstandingRequests[0] = &outstandingRequest{
 			stream: stream,
 		}
 		go func() {
 			for _, value := range testCase.streamingInputs {
-				controller.SendOnStream(0, lib.HexVomEncodeOrDie(value), &writer)
+				controller.SendOnStream(0, lib.HexVomEncodeOrDie(value, nil), &writer)
 			}
 			controller.CloseStream(0)
 		}()
@@ -217,26 +225,48 @@
 	}
 	controller.sendVeyronRequest(ctx, 0, &request, testCase.inArgs, &writer, stream, vtrace.GetSpan(ctx))
 
-	if err := testwriter.CheckResponses(&writer, testCase.expectedStream, testCase.expectedError); err != nil {
+	if err := testwriter.CheckResponses(&writer, testCase.expectedStream, testCase.expectedTypeStream, testCase.expectedError); err != nil {
 		t.Error(err)
 	}
 }
 
-func makeRPCResponse(outArgs ...*vdl.Value) string {
-	return lib.HexVomEncodeOrDie(RpcResponse{
+type typeWriter struct {
+	resps []lib.Response
+}
+
+func (t *typeWriter) Write(p []byte) (int, error) {
+	t.resps = append(t.resps, lib.Response{
+		Type:    lib.ResponseTypeMessage,
+		Message: base64.StdEncoding.EncodeToString(p),
+	})
+	return len(p), nil
+}
+
+func makeRPCResponse(outArgs ...*vdl.Value) (string, []lib.Response) {
+	writer := typeWriter{}
+	typeEncoder := vom.NewTypeEncoder(&writer)
+	var buf bytes.Buffer
+	encoder := vom.NewEncoderWithTypeEncoder(&buf, typeEncoder)
+	var output = RpcResponse{
 		OutArgs:       outArgs,
 		TraceResponse: vtrace.Response{},
-	})
+	}
+	if err := encoder.Encode(output); err != nil {
+		panic(err)
+	}
+	return hex.EncodeToString(buf.Bytes()), writer.resps
 }
 
 func TestCallingGoServer(t *testing.T) {
+	resp, typeMessages := makeRPCResponse(vdl.Int32Value(5))
 	runGoServerTestCase(t, goServerTestCase{
-		method:     "Add",
-		inArgs:     []interface{}{2, 3},
-		numOutArgs: 1,
+		expectedTypeStream: typeMessages,
+		method:             "Add",
+		inArgs:             []interface{}{2, 3},
+		numOutArgs:         1,
 		expectedStream: []lib.Response{
 			lib.Response{
-				Message: makeRPCResponse(vdl.Int32Value(5)),
+				Message: resp,
 				Type:    lib.ResponseFinal,
 			},
 		},
@@ -253,25 +283,27 @@
 }
 
 func TestCallingGoWithStreaming(t *testing.T) {
+	resp, typeMessages := makeRPCResponse(vdl.Int32Value(10))
 	runGoServerTestCase(t, goServerTestCase{
-		method:          "StreamingAdd",
-		streamingInputs: []interface{}{1, 2, 3, 4},
-		numOutArgs:      1,
+		expectedTypeStream: typeMessages,
+		method:             "StreamingAdd",
+		streamingInputs:    []interface{}{1, 2, 3, 4},
+		numOutArgs:         1,
 		expectedStream: []lib.Response{
 			lib.Response{
-				Message: lib.HexVomEncodeOrDie(int32(1)),
+				Message: lib.HexVomEncodeOrDie(int32(1), nil),
 				Type:    lib.ResponseStream,
 			},
 			lib.Response{
-				Message: lib.HexVomEncodeOrDie(int32(3)),
+				Message: lib.HexVomEncodeOrDie(int32(3), nil),
 				Type:    lib.ResponseStream,
 			},
 			lib.Response{
-				Message: lib.HexVomEncodeOrDie(int32(6)),
+				Message: lib.HexVomEncodeOrDie(int32(6), nil),
 				Type:    lib.ResponseStream,
 			},
 			lib.Response{
-				Message: lib.HexVomEncodeOrDie(int32(10)),
+				Message: lib.HexVomEncodeOrDie(int32(10), nil),
 				Type:    lib.ResponseStream,
 			},
 			lib.Response{
@@ -279,7 +311,7 @@
 				Type:    lib.ResponseStreamClose,
 			},
 			lib.Response{
-				Message: makeRPCResponse(vdl.Int32Value(10)),
+				Message: resp,
 				Type:    lib.ResponseFinal,
 			},
 		},
@@ -291,11 +323,13 @@
 	writer           *testwriter.Writer
 	mounttableServer rpc.Server
 	proxyShutdown    func()
+	typeStream       *typeWriter
+	typeEncoder      *vom.TypeEncoder
 }
 
-func makeRequest(rpc RpcRequest, args ...interface{}) (string, error) {
+func makeRequest(typeEncoder *vom.TypeEncoder, rpc RpcRequest, args ...interface{}) (string, error) {
 	var buf bytes.Buffer
-	encoder := vom.NewEncoder(&buf)
+	encoder := vom.NewEncoderWithTypeEncoder(&buf, typeEncoder)
 	if err := encoder.Encode(rpc); err != nil {
 		return "", err
 	}
@@ -343,19 +377,31 @@
 	}
 
 	v23.GetNamespace(controller.Context()).SetRoots("/" + endpoint.String())
-
-	req, err := makeRequest(RpcRequest{
+	typeStream := &typeWriter{}
+	typeEncoder := vom.NewTypeEncoder(typeStream)
+	req, err := makeRequest(typeEncoder, RpcRequest{
 		Name:       "__controller",
 		Method:     "Serve",
 		NumInArgs:  3,
 		NumOutArgs: 1,
 		Deadline:   vdltime.Deadline{},
 	}, "adder", 0, []RpcServerOption{})
+
+	for _, r := range typeStream.resps {
+		b, err := base64.StdEncoding.DecodeString(r.Message.(string))
+		if err != nil {
+			panic(err)
+		}
+
+		controller.HandleTypeMessage(hex.EncodeToString(b))
+	}
+	typeStream.resps = []lib.Response{}
 	controller.HandleVeyronRequest(ctx, 0, req, writer)
 
 	testWriter, _ := writer.(*testwriter.Writer)
 	return &runningTest{
 		controller, testWriter, mounttableServer, proxyShutdown,
+		typeStream, typeEncoder,
 	}, nil
 }
 
@@ -389,7 +435,7 @@
 
 	vomClientStream := []string{}
 	for _, m := range testCase.clientStream {
-		vomClientStream = append(vomClientStream, lib.HexVomEncodeOrDie(m))
+		vomClientStream = append(vomClientStream, lib.HexVomEncodeOrDie(m, nil))
 	}
 	mock := &mockJSServer{
 		t:                    t,
@@ -402,7 +448,10 @@
 		finalResponse:        testCase.finalResponse,
 		finalError:           testCase.err,
 		controllerReady:      sync.RWMutex{},
+		flowCount:            2,
+		typeReader:           lib.NewTypeReader(),
 	}
+	mock.typeDecoder = vom.NewTypeDecoder(mock.typeReader)
 	rt, err := serveServer(ctx, mock, func(controller *Controller) {
 		mock.controller = controller
 	})
diff --git a/services/wspr/internal/app/granter.go b/services/wspr/internal/app/granter.go
index bd9d4a9..659c906 100644
--- a/services/wspr/internal/app/granter.go
+++ b/services/wspr/internal/app/granter.go
@@ -29,7 +29,7 @@
 		GranterHandle: g.granterHandle,
 		Call:          server.ConvertSecurityCall(g.c, ctx, call, true),
 	}
-	encoded, err := lib.HexVomEncode(request)
+	encoded, err := lib.HexVomEncode(request, nil)
 	if err != nil {
 		return security.Blessings{}, err
 	}
@@ -64,7 +64,7 @@
 func (g *granterStream) Send(item interface{}) error {
 	dataString := item.(string)
 	var gr *GranterResponse
-	if err := lib.HexVomDecode(dataString, &gr); err != nil {
+	if err := lib.HexVomDecode(dataString, &gr, nil); err != nil {
 		return fmt.Errorf("error decoding granter response: %v", err)
 	}
 	g.c <- gr
diff --git a/services/wspr/internal/app/messaging.go b/services/wspr/internal/app/messaging.go
index 315fa04..fe09c00 100644
--- a/services/wspr/internal/app/messaging.go
+++ b/services/wspr/internal/app/messaging.go
@@ -81,6 +81,8 @@
 
 	// A response to a granter request.
 	GranterResponseMessage = 22
+
+	TypeMessage = 23
 )
 
 type Message struct {
@@ -123,28 +125,28 @@
 		go c.HandleCaveatValidationResponse(msg.Id, msg.Data)
 	case GranterResponseMessage:
 		go c.HandleGranterResponse(msg.Id, msg.Data)
-
+	case TypeMessage:
+		c.HandleTypeMessage(msg.Data)
 	default:
 		w.Error(verror.New(errUnknownMessageType, ctx, msg.Type))
 	}
 }
 
 // ConstructOutgoingMessage constructs a message to send to javascript in a consistent format.
-// TODO(bprosnitz) Don't double-encode
 func ConstructOutgoingMessage(messageId int32, messageType lib.ResponseType, data interface{}) (string, error) {
 	var buf bytes.Buffer
+	if _, err := buf.Write(lib.BinaryEncodeUint(uint64(messageId))); err != nil {
+		return "", err
+	}
+	if _, err := buf.Write(lib.BinaryEncodeUint(uint64(messageType))); err != nil {
+		return "", err
+	}
 	enc := vom.NewEncoder(&buf)
-	if err := enc.Encode(lib.Response{Type: messageType, Message: data}); err != nil {
+	if err := enc.Encode(data); err != nil {
 		return "", err
 	}
 
-	var buf2 bytes.Buffer
-	enc2 := vom.NewEncoder(&buf2)
-	if err := enc2.Encode(Message{Id: messageId, Data: fmt.Sprintf("%x", buf.Bytes())}); err != nil {
-		return "", err
-	}
-
-	return fmt.Sprintf("%x", buf2.Bytes()), nil
+	return fmt.Sprintf("%x", buf.Bytes()), nil
 }
 
 // FormatAsVerror formats an error as a verror.
diff --git a/services/wspr/internal/app/mock_jsServer_test.go b/services/wspr/internal/app/mock_jsServer_test.go
index 3c2fca4..27891d2 100644
--- a/services/wspr/internal/app/mock_jsServer_test.go
+++ b/services/wspr/internal/app/mock_jsServer_test.go
@@ -6,6 +6,7 @@
 
 import (
 	"bytes"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -44,6 +45,9 @@
 	// at the same time.
 	flowCount int32
 	rpcFlow   int32
+
+	typeReader  *lib.TypeReader
+	typeDecoder *vom.TypeDecoder
 }
 
 func (m *mockJSServer) Send(responseType lib.ResponseType, msg interface{}) error {
@@ -69,6 +73,9 @@
 	case lib.ResponseLog, lib.ResponseBlessingsCacheMessage:
 		m.flowCount += 2
 		return nil
+	case lib.ResponseTypeMessage:
+		m.handleTypeMessage(msg)
+		return nil
 	}
 	return fmt.Errorf("Unknown message type: %d", responseType)
 }
@@ -82,7 +89,7 @@
 
 	return lib.HexVomEncodeOrDie(server.LookupReply{
 		Err: err,
-	})
+	}, nil)
 }
 
 func (m *mockJSServer) Error(err error) {
@@ -105,6 +112,9 @@
 	return r.(map[string]interface{}), nil
 }
 
+func (m *mockJSServer) handleTypeMessage(v interface{}) {
+	m.typeReader.Add(hex.EncodeToString(v.([]byte)))
+}
 func (m *mockJSServer) handleDispatcherLookup(v interface{}) error {
 	defer func() {
 		m.flowCount += 2
@@ -126,7 +136,7 @@
 		Handle:        0,
 		Signature:     m.serviceSignature,
 		HasAuthorizer: m.hasAuthorizer,
-	})
+	}, nil)
 	m.controller.HandleLookupResponse(m.flowCount, lookupReply)
 	return nil
 }
@@ -147,7 +157,7 @@
 	}
 
 	var msg server.AuthRequest
-	if err := lib.HexVomDecode(v.(string), &msg); err != nil {
+	if err := lib.HexVomDecode(v.(string), &msg, nil); err != nil {
 		m.controller.HandleAuthResponse(m.flowCount, internalErr(fmt.Sprintf("error decoding %v:", err)))
 		return nil
 	}
@@ -191,7 +201,7 @@
 
 	authReply := lib.HexVomEncodeOrDie(server.AuthReply{
 		Err: m.authError,
-	})
+	}, nil)
 
 	m.controller.HandleAuthResponse(m.flowCount, authReply)
 	return nil
@@ -208,7 +218,7 @@
 	}
 
 	var msg server.ServerRpcRequest
-	if err := lib.HexVomDecode(v.(string), &msg); err != nil {
+	if err := lib.HexVomDecode(v.(string), &msg, nil); err != nil {
 		m.controller.HandleServerResponse(m.flowCount, internalErr(err))
 		return nil
 	}
@@ -284,7 +294,7 @@
 	defer m.sender.Done()
 	m.controllerReady.RLock()
 	for _, v := range m.serverStream {
-		m.controller.SendOnStream(m.rpcFlow, lib.HexVomEncodeOrDie(v), m)
+		m.controller.SendOnStream(m.rpcFlow, lib.HexVomEncodeOrDie(v, nil), m)
 	}
 	m.controllerReady.RUnlock()
 }
@@ -312,7 +322,7 @@
 	}
 
 	m.controllerReady.RLock()
-	m.controller.HandleServerResponse(m.rpcFlow, lib.HexVomEncodeOrDie(reply))
+	m.controller.HandleServerResponse(m.rpcFlow, lib.HexVomEncodeOrDie(reply, nil))
 	m.controllerReady.RUnlock()
 	return nil
 }
diff --git a/services/wspr/internal/app/stream.go b/services/wspr/internal/app/stream.go
index 74852c7..74ca481 100644
--- a/services/wspr/internal/app/stream.go
+++ b/services/wspr/internal/app/stream.go
@@ -8,6 +8,7 @@
 	"fmt"
 
 	"v.io/v23/rpc"
+	"v.io/v23/vom"
 	"v.io/x/ref/services/wspr/internal/lib"
 	"v.io/x/ref/services/wspr/internal/principal"
 )
@@ -41,11 +42,12 @@
 	// true if the stream has been closed.
 	closed bool
 
+	typeDecoder *vom.TypeDecoder
 	// Used to translate from JsBlesssings to Blessings
 	blessingsCache *principal.JSBlessingsHandles
 }
 
-func newStream(cache *principal.JSBlessingsHandles) *outstandingStream {
+func newStream(cache *principal.JSBlessingsHandles, typeDecoder *vom.TypeDecoder) *outstandingStream {
 	os := &outstandingStream{
 		initChan: make(chan *initConfig, 1),
 		// We allow queueing up to 100 messages before init is called.
@@ -53,6 +55,7 @@
 		messages:       make(chan *message, 100),
 		done:           make(chan bool),
 		blessingsCache: cache,
+		typeDecoder:    typeDecoder,
 	}
 	go os.loop()
 	return os
@@ -81,7 +84,7 @@
 	config := <-os.initChan
 	for msg := range os.messages {
 		var item interface{}
-		if err := lib.HexVomDecode(msg.data, &item); err != nil {
+		if err := lib.HexVomDecode(msg.data, &item, os.typeDecoder); err != nil {
 			msg.writer.Error(fmt.Errorf("failed to decode stream arg from %v: %v", msg.data, err))
 			break
 		}
diff --git a/services/wspr/internal/browspr/browspr_test.go b/services/wspr/internal/browspr/browspr_test.go
index 03c108f..956fe54 100644
--- a/services/wspr/internal/browspr/browspr_test.go
+++ b/services/wspr/internal/browspr/browspr_test.go
@@ -78,6 +78,26 @@
 	return s, endpoints[0], nil
 }
 
+func parseBrowsperResponse(data string, t *testing.T) (uint64, uint64, []byte) {
+	receivedBytes, err := hex.DecodeString(data)
+	if err != nil {
+		t.Fatalf("Failed to hex decode outgoing message: %v", err)
+	}
+
+	id, bytesRead, err := lib.BinaryDecodeUint(receivedBytes)
+	if err != nil {
+		t.Fatalf("Failed to read mesage id: %v", err)
+	}
+
+	receivedBytes = receivedBytes[bytesRead:]
+	messageType, bytesRead, err := lib.BinaryDecodeUint(receivedBytes)
+	if err != nil {
+		t.Fatalf("Failed to read message type: %v", err)
+	}
+	receivedBytes = receivedBytes[bytesRead:]
+	return id, messageType, receivedBytes
+}
+
 func TestBrowspr(t *testing.T) {
 	ctx, shutdown := test.V23Init()
 	defer shutdown()
@@ -154,12 +174,26 @@
 	receivedResponse := make(chan bool, 1)
 	var receivedInstanceId int32
 	var receivedType string
-	var receivedMsg string
+	var messageId uint64
+	var messageType uint64
+	var receivedBytes []byte
+	typeReader := lib.NewTypeReader()
 
 	var postMessageHandler = func(instanceId int32, ty, msg string) {
+		id, mType, bin := parseBrowsperResponse(msg, t)
+		if mType == lib.ResponseTypeMessage {
+			var decodedBytes []byte
+			if err := vom.Decode(bin, &decodedBytes); err != nil {
+				t.Fatalf("Failed to decode type bytes: %v", err)
+			}
+			typeReader.Add(hex.EncodeToString(decodedBytes))
+			return
+		}
 		receivedInstanceId = instanceId
 		receivedType = ty
-		receivedMsg = msg
+		messageType = mType
+		messageId = id
+		receivedBytes = bin
 		receivedResponse <- true
 	}
 
@@ -194,14 +228,17 @@
 		Deadline:    vdltime.Deadline{},
 	}
 
+	var typeBuf bytes.Buffer
+	typeEncoder := vom.NewTypeEncoder(&typeBuf)
 	var buf bytes.Buffer
-	encoder := vom.NewEncoder(&buf)
+	encoder := vom.NewEncoderWithTypeEncoder(&buf, typeEncoder)
 	if err := encoder.Encode(rpc); err != nil {
 		t.Fatalf("Failed to vom encode rpc message: %v", err)
 	}
 	if err := encoder.Encode("InputValue"); err != nil {
 		t.Fatalf("Failed to vom encode rpc message: %v", err)
 	}
+
 	vomRPC := hex.EncodeToString(buf.Bytes())
 
 	msg := app.Message{
@@ -210,6 +247,11 @@
 		Type: app.VeyronRequestMessage,
 	}
 
+	typeMessage := app.Message{
+		Id:   0,
+		Data: hex.EncodeToString(typeBuf.Bytes()),
+		Type: app.TypeMessage,
+	}
 	createInstanceMessage := CreateInstanceMessage{
 		InstanceId:     msgInstanceId,
 		Origin:         msgOrigin,
@@ -218,6 +260,11 @@
 	}
 	_, err = browspr.HandleCreateInstanceRpc(vdl.ValueOf(createInstanceMessage))
 
+	err = browspr.HandleMessage(msgInstanceId, msgOrigin, typeMessage)
+	if err != nil {
+		t.Fatalf("Error while handling type message: %v", err)
+	}
+
 	err = browspr.HandleMessage(msgInstanceId, msgOrigin, msg)
 	if err != nil {
 		t.Fatalf("Error while handling message: %v", err)
@@ -232,32 +279,28 @@
 		t.Errorf("Received unexpected response type. Expected: %q, but got %q", "browsprMsg", receivedType)
 	}
 
-	var outMsg app.Message
-	if err := lib.HexVomDecode(receivedMsg, &outMsg); err != nil {
-		t.Fatalf("Failed to unmarshall outgoing message: %v", err)
-	}
-	if outMsg.Id != int32(1) {
-		t.Errorf("Id was %v, expected %v", outMsg.Id, int32(1))
-	}
-	if outMsg.Type != app.VeyronRequestMessage {
-		t.Errorf("Message type was %v, expected %v", outMsg.Type, app.MessageType(0))
+	if messageId != 1 {
+		t.Errorf("Id was %v, expected %v", messageId, int32(1))
 	}
 
-	var responseMsg lib.Response
-	if err := lib.HexVomDecode(outMsg.Data, &responseMsg); err != nil {
+	if lib.ResponseType(messageType) != lib.ResponseFinal {
+		t.Errorf("Message type was %v, expected %v", messageType, lib.ResponseFinal)
+	}
+
+	var data string
+	if err := vom.NewDecoder(bytes.NewBuffer(receivedBytes)).Decode(&data); err != nil {
 		t.Fatalf("Failed to unmarshall outgoing response: %v", err)
 	}
-	if responseMsg.Type != lib.ResponseFinal {
-		t.Errorf("Data was %q, expected %q", outMsg.Data, `["[InputValue]"]`)
-	}
-	var outArg string
-	var ok bool
-	if outArg, ok = responseMsg.Message.(string); !ok {
-		t.Errorf("Got unexpected response message body of type %T, expected type string", responseMsg.Message)
-	}
+
 	var result app.RpcResponse
-	if err := lib.HexVomDecode(outArg, &result); err != nil {
-		t.Errorf("Failed to vom decode args from %v: %v", outArg, err)
+	dataBytes, err := hex.DecodeString(data)
+	if err != nil {
+		t.Errorf("Failed to hex decode from %v: %v", data, err)
+	}
+
+	decoder := vom.NewDecoderWithTypeDecoder(bytes.NewBuffer(dataBytes), vom.NewTypeDecoder(typeReader))
+	if err := decoder.Decode(&result); err != nil {
+		t.Errorf("Failed to vom decode args from %v: %v", data, err)
 	}
 	if got, want := result.OutArgs[0], vdl.StringValue("[InputValue]"); !vdl.EqualValue(got, want) {
 		t.Errorf("Result got %v, want %v", got, want)
diff --git a/services/wspr/internal/lib/binary_util.go b/services/wspr/internal/lib/binary_util.go
new file mode 100644
index 0000000..9ddc65c
--- /dev/null
+++ b/services/wspr/internal/lib/binary_util.go
@@ -0,0 +1,75 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package lib
+
+import (
+	"v.io/v23/verror"
+)
+
+const pkgPath = "v.io/x/ref/services/wspr/internal/lib"
+
+const uint64Size = 8
+
+var (
+	errInvalid      = verror.Register(pkgPath+".errInvalid", verror.NoRetry, "{1:}{2:} wspr: invalid encoding{:_}")
+	errEOF          = verror.Register(pkgPath+".errEOF", verror.NoRetry, "{1:}{2:} wspr: eof{:_}")
+	errUintOverflow = verror.Register(pkgPath+".errUintOverflow", verror.NoRetry, "{1:}{2:} wspr: scalar larger than 8 bytes{:_}")
+)
+
+// Unsigned integers are the basis for all other primitive values.  This is a
+// two-state encoding.  If the number is less than 128 (0 through 0x7f), its
+// value is written directly.  Otherwise the value is written in big-endian byte
+// order preceded by the negated byte length.
+func BinaryEncodeUint(v uint64) []byte {
+	switch {
+	case v <= 0x7f:
+		return []byte{byte(v)}
+	case v <= 0xff:
+		return []byte{0xff, byte(v)}
+	case v <= 0xffff:
+		return []byte{0xfe, byte(v >> 8), byte(v)}
+	case v <= 0xffffff:
+		return []byte{0xfd, byte(v >> 16), byte(v >> 8), byte(v)}
+	case v <= 0xffffffff:
+		return []byte{0xfc, byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)}
+	case v <= 0xffffffffff:
+		return []byte{0xfb, byte(v >> 32), byte(v >> 24),
+			byte(v >> 16), byte(v >> 8), byte(v)}
+	case v <= 0xffffffffffff:
+		return []byte{0xfa, byte(v >> 40), byte(v >> 32), byte(v >> 24),
+			byte(v >> 16), byte(v >> 8), byte(v)}
+	case v <= 0xffffffffffffff:
+		return []byte{0xf9, byte(v >> 48), byte(v >> 40), byte(v >> 32),
+			byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)}
+	default:
+		return []byte{0xf9, byte(v >> 56), byte(v >> 48), byte(v >> 40),
+			byte(v >> 32), byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)}
+	}
+}
+
+func BinaryDecodeUint(input []byte) (v uint64, byteLen int, err error) {
+	if len(input) == 0 {
+		return 0, 0, verror.New(errEOF, nil)
+	}
+	firstByte := input[0]
+	if firstByte <= 0x7f {
+		return uint64(firstByte), 1, nil
+	}
+
+	if firstByte <= 0xdf {
+		return 0, 0, verror.New(errInvalid, nil)
+	}
+	byteLen = int(-int8(firstByte))
+	if byteLen < 1 || byteLen > uint64Size {
+		return 0, 0, verror.New(errUintOverflow, nil)
+	}
+	if len(input) < byteLen {
+		return 0, 0, verror.New(errEOF, nil)
+	}
+	for i := 1; i < byteLen; i++ {
+		v = v<<8 | uint64(input[i])
+	}
+	return
+}
diff --git a/services/wspr/internal/lib/hex_vom.go b/services/wspr/internal/lib/hex_vom.go
index ded745dd..2dcbb82 100644
--- a/services/wspr/internal/lib/hex_vom.go
+++ b/services/wspr/internal/lib/hex_vom.go
@@ -8,68 +8,112 @@
 	"bytes"
 	"encoding/hex"
 	"fmt"
+	"io"
+	"sync"
 
 	"v.io/v23/vom"
 )
 
-func HexVomEncode(v interface{}) (string, error) {
+func HexVomEncode(v interface{}, te *vom.TypeEncoder) (string, error) {
 	var buf bytes.Buffer
-	encoder := vom.NewEncoder(&buf)
+	var encoder *vom.Encoder
+	if te != nil {
+		encoder = vom.NewEncoderWithTypeEncoder(&buf, te)
+	} else {
+
+		encoder = vom.NewEncoder(&buf)
+	}
 	if err := encoder.Encode(v); err != nil {
 		return "", err
 	}
 	return hex.EncodeToString(buf.Bytes()), nil
 }
 
-func HexVomEncodeOrDie(v interface{}) string {
-	s, err := HexVomEncode(v)
+func HexVomEncodeOrDie(v interface{}, te *vom.TypeEncoder) string {
+	s, err := HexVomEncode(v, te)
 	if err != nil {
 		panic(err)
 	}
 	return s
 }
 
-func HexVomDecode(data string, v interface{}) error {
+func HexVomDecode(data string, v interface{}, td *vom.TypeDecoder) error {
 	binbytes, err := hex.DecodeString(data)
 	if err != nil {
 		return fmt.Errorf("Error decoding hex string %q: %v", data, err)
 	}
-	decoder := vom.NewDecoder(bytes.NewReader(binbytes))
+	var decoder *vom.Decoder
+	if td != nil {
+		decoder = vom.NewDecoderWithTypeDecoder(bytes.NewReader(binbytes), td)
+	} else {
+		decoder = vom.NewDecoder(bytes.NewReader(binbytes))
+	}
 	return decoder.Decode(v)
 }
 
-// ProxyReader implements io.Reader but allows changing the underlying buffer.
+// TypeReader implements io.Reader but allows changing the underlying buffer.
 // This is useful for merging discrete messages that are part of the same flow.
-type ProxyReader struct {
-	bytes.Buffer
+type TypeReader struct {
+	buf      bytes.Buffer
+	mu       sync.Mutex
+	isClosed bool
+	cond     *sync.Cond
 }
 
-func NewProxyReader() *ProxyReader {
-	return &ProxyReader{}
+func NewTypeReader() *TypeReader {
+	reader := &TypeReader{}
+	reader.cond = sync.NewCond(&reader.mu)
+	return reader
 }
 
-func (p *ProxyReader) ReplaceBuffer(data string) error {
-	binbytes, err := hex.DecodeString(data)
+func (r *TypeReader) Add(data string) error {
+	binBytes, err := hex.DecodeString(data)
 	if err != nil {
 		return err
 	}
-	p.Reset()
-	p.Write(binbytes)
-	return nil
+	r.mu.Lock()
+	_, err = r.buf.Write(binBytes)
+	r.mu.Unlock()
+	r.cond.Signal()
+	return err
 }
 
-// ProxyWriter implements io.Writer but allows changing the underlying buffer.
+func (r *TypeReader) Read(p []byte) (int, error) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	for {
+		if r.buf.Len() > 0 {
+			return r.buf.Read(p)
+		}
+		if r.isClosed {
+			return 0, io.EOF
+		}
+		r.cond.Wait()
+	}
+
+}
+
+func (r *TypeReader) Close() {
+	r.mu.Lock()
+	r.isClosed = true
+	r.mu.Unlock()
+	r.cond.Broadcast()
+}
+
+// TypeWriter implements io.Writer but allows changing the underlying buffer.
 // This is useful for merging discrete messages that are part of the same flow.
-type ProxyWriter struct {
-	bytes.Buffer
+type TypeWriter struct {
+	writer ClientWriter
 }
 
-func NewProxyWriter() *ProxyWriter {
-	return &ProxyWriter{}
+func NewTypeWriter(w ClientWriter) *TypeWriter {
+	return &TypeWriter{writer: w}
 }
 
-func (p *ProxyWriter) ConsumeBuffer() string {
-	s := hex.EncodeToString(p.Buffer.Bytes())
-	p.Reset()
-	return s
+func (w *TypeWriter) Write(p []byte) (int, error) {
+	err := w.writer.Send(ResponseTypeMessage, p)
+	if err != nil {
+		return 0, err
+	}
+	return len(p), nil
 }
diff --git a/services/wspr/internal/lib/hex_vom_test.go b/services/wspr/internal/lib/hex_vom_test.go
new file mode 100644
index 0000000..728f976
--- /dev/null
+++ b/services/wspr/internal/lib/hex_vom_test.go
@@ -0,0 +1,63 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package lib
+
+import (
+	"encoding/hex"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestReadBeforeData(t *testing.T) {
+	reader := NewTypeReader()
+	input := []byte{0, 2, 3, 4, 5}
+	data := make([]byte, 5)
+	go func() {
+		<-time.After(100 * time.Millisecond)
+		reader.Add(hex.EncodeToString(input))
+	}()
+	n, err := reader.Read(data)
+	if n != len(data) {
+		t.Errorf("Read the wrong number of bytes, wanted:%d, got:%d", len(data), n)
+	}
+
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(input, data) {
+		t.Errorf("wrong data, want:%x, got:%x", input, data)
+	}
+}
+
+func TestReadWithPartialData(t *testing.T) {
+	reader := NewTypeReader()
+	input := []byte{0, 2, 3, 4, 5}
+	data := make([]byte, 5)
+	reader.Add(hex.EncodeToString(input[:2]))
+	go func() {
+		<-time.After(300 * time.Millisecond)
+		reader.Add(hex.EncodeToString(input[2:]))
+	}()
+	totalRead := 0
+	for {
+		n, err := reader.Read(data[totalRead:])
+		totalRead += n
+		if err != nil {
+			t.Errorf("Unexpected error: %v", err)
+			break
+		}
+		if totalRead == 5 {
+			break
+		}
+	}
+	if totalRead != len(data) {
+		t.Errorf("Read the wrong number of bytes, wanted:%d, got:%d", len(data), totalRead)
+	}
+
+	if !reflect.DeepEqual(input, data) {
+		t.Errorf("wrong data, want:%x, got:%x", input, data)
+	}
+}
diff --git a/services/wspr/internal/lib/testwriter/writer.go b/services/wspr/internal/lib/testwriter/writer.go
index 01c78d4..2c9da53 100644
--- a/services/wspr/internal/lib/testwriter/writer.go
+++ b/services/wspr/internal/lib/testwriter/writer.go
@@ -22,8 +22,9 @@
 
 type Writer struct {
 	sync.Mutex
-	Stream []lib.Response // TODO Why not use channel?
-	err    error
+	TypeStream []lib.Response
+	Stream     []lib.Response // TODO Why not use channel?
+	err        error
 	// If this channel is set then a message will be sent
 	// to this channel after recieving a call to FinishMessage()
 	notifier chan bool
@@ -45,7 +46,11 @@
 
 	w.Lock()
 	defer w.Unlock()
-	w.Stream = append(w.Stream, r)
+	if responseType == lib.ResponseTypeMessage {
+		w.TypeStream = append(w.TypeStream, r)
+	} else {
+		w.Stream = append(w.Stream, r)
+	}
 	if w.notifier != nil {
 		w.notifier <- true
 	}
@@ -101,10 +106,13 @@
 	return nil
 }
 
-func CheckResponses(w *Writer, wantStream []lib.Response, wantErr error) error {
+func CheckResponses(w *Writer, wantStream []lib.Response, wantTypes []lib.Response, wantErr error) error {
 	if got, want := w.Stream, wantStream; !reflect.DeepEqual(got, want) {
 		return fmt.Errorf("streams don't match: got %#v, want %#v", got, want)
 	}
+	if got, want := w.TypeStream, wantTypes; !reflect.DeepEqual(got, want) {
+		return fmt.Errorf("streams don't match: got %#v, want %#v", got, want)
+	}
 	if got, want := w.err, wantErr; verror.ErrorID(got) != verror.ErrorID(want) {
 		return fmt.Errorf("unexpected error, got: %#v, expected: %#v", got, want)
 	}
diff --git a/services/wspr/internal/lib/writer.go b/services/wspr/internal/lib/writer.go
index da3f117..1c90372 100644
--- a/services/wspr/internal/lib/writer.go
+++ b/services/wspr/internal/lib/writer.go
@@ -19,6 +19,7 @@
 	ResponseLog                                = 9 // Sends a message to be logged.
 	ResponseGranterRequest                     = 10
 	ResponseBlessingsCacheMessage              = 11 // Update the blessings cache
+	ResponseTypeMessage                        = 12
 )
 
 type Response struct {
diff --git a/services/wspr/internal/rpc/server/dispatcher.go b/services/wspr/internal/rpc/server/dispatcher.go
index fa76d75..cb1c457 100644
--- a/services/wspr/internal/rpc/server/dispatcher.go
+++ b/services/wspr/internal/rpc/server/dispatcher.go
@@ -128,7 +128,7 @@
 	}
 
 	var lookupReply LookupReply
-	if err := lib.HexVomDecode(data, &lookupReply); err != nil {
+	if err := lib.HexVomDecode(data, &lookupReply, nil); err != nil {
 		err2 := verror.Convert(verror.ErrInternal, nil, err)
 		lookupReply = LookupReply{Err: err2}
 		vlog.Errorf("unmarshaling invoke request failed: %v, %s", err, data)
diff --git a/services/wspr/internal/rpc/server/dispatcher_test.go b/services/wspr/internal/rpc/server/dispatcher_test.go
index 43039ae..0e6615b 100644
--- a/services/wspr/internal/rpc/server/dispatcher_test.go
+++ b/services/wspr/internal/rpc/server/dispatcher_test.go
@@ -94,7 +94,7 @@
 			HasAuthorizer: false,
 			Signature:     expectedSig,
 		}
-		d.handleLookupResponse(0, lib.HexVomEncodeOrDie(reply))
+		d.handleLookupResponse(0, lib.HexVomEncodeOrDie(reply, nil))
 	}()
 
 	invoker, auth, err := d.Lookup("a/b")
@@ -122,7 +122,7 @@
 			},
 		},
 	}
-	if err := testwriter.CheckResponses(&flowFactory.writer, expectedResponses, nil); err != nil {
+	if err := testwriter.CheckResponses(&flowFactory.writer, expectedResponses, nil, nil); err != nil {
 		t.Error(err)
 	}
 }
@@ -143,7 +143,7 @@
 			HasAuthorizer: true,
 			Signature:     expectedSig,
 		}
-		d.handleLookupResponse(0, lib.HexVomEncodeOrDie(reply))
+		d.handleLookupResponse(0, lib.HexVomEncodeOrDie(reply, nil))
 	}()
 
 	invoker, auth, err := d.Lookup("a/b")
@@ -171,7 +171,7 @@
 			},
 		},
 	}
-	if err := testwriter.CheckResponses(&flowFactory.writer, expectedResponses, nil); err != nil {
+	if err := testwriter.CheckResponses(&flowFactory.writer, expectedResponses, nil, nil); err != nil {
 		t.Error(err)
 	}
 }
@@ -187,7 +187,7 @@
 		reply := LookupReply{
 			Err: verror.New(verror.ErrNoExist, nil),
 		}
-		d.handleLookupResponse(0, lib.HexVomEncodeOrDie(reply))
+		d.handleLookupResponse(0, lib.HexVomEncodeOrDie(reply, nil))
 	}()
 
 	_, _, err := d.Lookup("a/b")
@@ -205,7 +205,7 @@
 			},
 		},
 	}
-	if err := testwriter.CheckResponses(&flowFactory.writer, expectedResponses, nil); err != nil {
+	if err := testwriter.CheckResponses(&flowFactory.writer, expectedResponses, nil, nil); err != nil {
 		t.Error(err)
 	}
 }
diff --git a/services/wspr/internal/rpc/server/server.go b/services/wspr/internal/rpc/server/server.go
index eb54436..e3cd66e 100644
--- a/services/wspr/internal/rpc/server/server.go
+++ b/services/wspr/internal/rpc/server/server.go
@@ -21,6 +21,7 @@
 	"v.io/v23/vdlroot/signature"
 	vdltime "v.io/v23/vdlroot/time"
 	"v.io/v23/verror"
+	"v.io/v23/vom"
 	"v.io/v23/vtrace"
 	"v.io/x/lib/vlog"
 	"v.io/x/ref/services/wspr/internal/lib"
@@ -51,6 +52,8 @@
 	SendLogMessage(level lib.LogLevel, msg string) error
 	BlessingsCache() *principal.BlessingsCache
 
+	TypeEncoder() *vom.TypeEncoder
+
 	Context() *context.T
 }
 
@@ -177,7 +180,7 @@
 			Args:     vdlValArgs,
 			Call:     rpcCall,
 		}
-		vomMessage, err := lib.HexVomEncode(message)
+		vomMessage, err := lib.HexVomEncode(message, nil)
 		if err != nil {
 			return errHandler(err)
 		}
@@ -203,7 +206,7 @@
 			ch <- &lib.ServerRpcReply{nil, &err, vtrace.Response{}}
 		}()
 
-		go proxyStream(call, flow.Writer, s.helper)
+		go proxyStream(call, flow.Writer, s.helper, s.helper.TypeEncoder())
 
 		return replyChan
 	}
@@ -286,7 +289,7 @@
 			Args:     []*vdl.Value{vdl.ValueOf(pattern)},
 			Call:     rpcCall,
 		}
-		vomMessage, err := lib.HexVomEncode(message)
+		vomMessage, err := lib.HexVomEncode(message, nil)
 		if err != nil {
 			return errHandler(err)
 		}
@@ -316,7 +319,7 @@
 	}
 }
 
-func proxyStream(stream rpc.Stream, w lib.ClientWriter, blessingsCache HandleStore) {
+func proxyStream(stream rpc.Stream, w lib.ClientWriter, blessingsCache HandleStore, typeEncoder *vom.TypeEncoder) {
 	var item interface{}
 	var err error
 	for err = stream.Recv(&item); err == nil; err = stream.Recv(&item) {
@@ -324,7 +327,7 @@
 			item = principal.ConvertBlessingsToHandle(blessings, blessingsCache.GetOrAddBlessingsHandle(blessings))
 
 		}
-		vomItem, err := lib.HexVomEncode(item)
+		vomItem, err := lib.HexVomEncode(item, typeEncoder)
 		if err != nil {
 			w.Error(verror.Convert(verror.ErrInternal, nil, err))
 			return
@@ -565,7 +568,7 @@
 	}
 	vlog.VI(0).Infof("Sending out auth request for %v, %v", flow.ID, message)
 
-	vomMessage, err := lib.HexVomEncode(message)
+	vomMessage, err := lib.HexVomEncode(message, nil)
 	if err != nil {
 		replyChan <- verror.Convert(verror.ErrInternal, nil, err)
 	} else if err := flow.Writer.Send(lib.ResponseAuthRequest, vomMessage); err != nil {
@@ -655,7 +658,7 @@
 
 	// Decode the result and send it through the channel
 	var reply lib.ServerRpcReply
-	if err := lib.HexVomDecode(data, &reply); err != nil {
+	if err := lib.HexVomDecode(data, &reply, nil); err != nil {
 		reply.Err = err
 	}
 
@@ -697,7 +700,7 @@
 	}
 	// Decode the result and send it through the channel
 	var reply AuthReply
-	if err := lib.HexVomDecode(data, &reply); err != nil {
+	if err := lib.HexVomDecode(data, &reply, nil); err != nil {
 		err = verror.Convert(verror.ErrInternal, nil, err)
 		reply = AuthReply{Err: err}
 	}
@@ -727,7 +730,7 @@
 	}
 
 	var reply CaveatValidationResponse
-	if err := lib.HexVomDecode(data, &reply); err != nil {
+	if err := lib.HexVomDecode(data, &reply, nil); err != nil {
 		vlog.Errorf("failed to decode validation response %q: error %v", data, err)
 		ch <- []error{}
 		return