diff --git a/services/wsprd/app/app.go b/services/wsprd/app/app.go
index ce64c62..3135d13 100644
--- a/services/wsprd/app/app.go
+++ b/services/wsprd/app/app.go
@@ -5,7 +5,6 @@
 import (
 	"bytes"
 	"encoding/hex"
-	"flag"
 	"fmt"
 	"io"
 	"reflect"
@@ -31,8 +30,13 @@
 	"v.io/x/ref/services/wsprd/rpc/server"
 )
 
-// pkgPath is the prefix os errors in this package.
-const pkgPath = "v.io/x/ref/services/wsprd/app"
+const (
+	// pkgPath is the prefix os errors in this package.
+	pkgPath = "v.io/x/ref/services/wsprd/app"
+
+	// defaultRetryTimeout is the default RPC timeout.
+	defaultRetryTimeout = 2 * time.Second
+)
 
 // Errors
 var (
@@ -43,18 +47,6 @@
 	invalidBlessingsHandle = verror.Register(pkgPath+".invalidBlessingsHandle", verror.NoRetry, "{1} {2} invalid blessings handle {_}")
 )
 
-// TODO(bjornick,nlacasse): Remove the retryTimeout flag once we able
-// to pass it in from javascript. For now all RPCs have the same
-// retryTimeout, set by command line flag.
-var retryTimeout *int
-
-func init() {
-	// TODO(bjornick,nlacasse): Remove the retryTimeout flag once we able
-	// to pass it in from javascript. For now all RPCs have the same
-	// retryTimeout, set by command line flag.
-	retryTimeout = flag.Int("retry-timeout", 2, "Duration in seconds to retry starting an RPC call. 0 means never retry.")
-}
-
 type outstandingRequest struct {
 	stream *outstandingStream
 	cancel context.CancelFunc
@@ -208,10 +200,39 @@
 	}
 }
 
+// callOpts turns a slice of type []RpcCallOption object into an array of rpc.CallOpt.
+func (c *Controller) callOpts(opts []RpcCallOption) ([]rpc.CallOpt, error) {
+	var callOpts []rpc.CallOpt
+
+	retryTimeoutSet := false
+
+	for _, opt := range opts {
+		switch v := opt.(type) {
+		case RpcCallOptionAllowedServersPolicy:
+			callOpts = append(callOpts, options.AllowedServersPolicy(v.Value))
+		case RpcCallOptionRetryTimeout:
+			retryTimeoutSet = true
+			callOpts = append(callOpts, options.RetryTimeout(v.Value))
+		default:
+			return nil, fmt.Errorf("Unknown RpcCallOption type %T", v)
+		}
+	}
+
+	// If no RetryTimeout was provided, use the default.
+	if !retryTimeoutSet {
+		callOpts = append(callOpts, options.RetryTimeout(defaultRetryTimeout))
+	}
+
+	return callOpts, nil
+}
+
 func (c *Controller) startCall(ctx *context.T, w lib.ClientWriter, msg *RpcRequest, inArgs []interface{}) (rpc.ClientCall, error) {
 	methodName := lib.UppercaseFirstCharacter(msg.Method)
-	retryTimeoutOpt := options.RetryTimeout(time.Duration(*retryTimeout) * time.Second)
-	clientCall, err := v23.GetClient(ctx).StartCall(ctx, msg.Name, methodName, inArgs, retryTimeoutOpt)
+	callOpts, err := c.callOpts(msg.CallOptions)
+	if err != nil {
+		return nil, err
+	}
+	clientCall, err := v23.GetClient(ctx).StartCall(ctx, msg.Name, methodName, inArgs, callOpts...)
 	if err != nil {
 		return nil, fmt.Errorf("error starting call (name: %v, method: %v, args: %v): %v", msg.Name, methodName, inArgs, err)
 	}
@@ -664,7 +685,7 @@
 
 // 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) {
-	retryTimeoutOpt := options.RetryTimeout(time.Duration(*retryTimeout) * time.Second)
+	retryTimeoutOpt := options.RetryTimeout(defaultRetryTimeout)
 	return c.signatureManager.Signature(ctx, name, retryTimeoutOpt)
 }
 
diff --git a/services/wsprd/app/app.vdl b/services/wsprd/app/app.vdl
index 46a1834..243f2cd 100644
--- a/services/wsprd/app/app.vdl
+++ b/services/wsprd/app/app.vdl
@@ -5,6 +5,7 @@
 import (
 	"time"
 
+	"v.io/v23/security"
 	"v.io/v23/vtrace"
 )
 
@@ -16,6 +17,24 @@
 	IsStreaming  bool
 	Deadline     time.WireDeadline
 	TraceRequest vtrace.Request
+	CallOptions  []RpcCallOption
+}
+
+// TODO(nlacasse): It would be nice if RpcCallOption were a struct with
+// optional types, like:
+//
+//   type RpcCallOptions struct {
+//     AllowedServersPolicy ?[]security.BlessingPattern
+//     RetryTimeout         ?time.Duration
+//   }
+//
+// Unfortunately, optional types are currently only supported for structs, not
+// slices or primitive types.  Once optional types are better supported, switch
+// this to a struct with optional types.
+
+type RpcCallOption union {
+	AllowedServersPolicy []security.BlessingPattern
+	RetryTimeout         time.Duration
 }
 
 type RpcResponse struct {
diff --git a/services/wsprd/app/app.vdl.go b/services/wsprd/app/app.vdl.go
index 53d02a3..bd2650d 100644
--- a/services/wsprd/app/app.vdl.go
+++ b/services/wsprd/app/app.vdl.go
@@ -10,7 +10,9 @@
 	"v.io/v23/vdl"
 
 	// VDL user imports
-	"v.io/v23/vdlroot/time"
+	"time"
+	"v.io/v23/security"
+	time_2 "v.io/v23/vdlroot/time"
 	"v.io/v23/vtrace"
 )
 
@@ -20,8 +22,9 @@
 	NumInArgs    int32
 	NumOutArgs   int32
 	IsStreaming  bool
-	Deadline     time.Deadline
+	Deadline     time_2.Deadline
 	TraceRequest vtrace.Request
+	CallOptions  []RpcCallOption
 }
 
 func (RpcRequest) __VDLReflect(struct {
@@ -29,6 +32,43 @@
 }) {
 }
 
+type (
+	// RpcCallOption represents any single field of the RpcCallOption union type.
+	RpcCallOption interface {
+		// Index returns the field index.
+		Index() int
+		// Interface returns the field value as an interface.
+		Interface() interface{}
+		// Name returns the field name.
+		Name() string
+		// __VDLReflect describes the RpcCallOption union type.
+		__VDLReflect(__RpcCallOptionReflect)
+	}
+	// RpcCallOptionAllowedServersPolicy represents field AllowedServersPolicy of the RpcCallOption union type.
+	RpcCallOptionAllowedServersPolicy struct{ Value []security.BlessingPattern }
+	// RpcCallOptionRetryTimeout represents field RetryTimeout of the RpcCallOption union type.
+	RpcCallOptionRetryTimeout struct{ Value time.Duration }
+	// __RpcCallOptionReflect describes the RpcCallOption union type.
+	__RpcCallOptionReflect struct {
+		Name  string "v.io/x/ref/services/wsprd/app.RpcCallOption"
+		Type  RpcCallOption
+		Union struct {
+			AllowedServersPolicy RpcCallOptionAllowedServersPolicy
+			RetryTimeout         RpcCallOptionRetryTimeout
+		}
+	}
+)
+
+func (x RpcCallOptionAllowedServersPolicy) Index() int                          { return 0 }
+func (x RpcCallOptionAllowedServersPolicy) Interface() interface{}              { return x.Value }
+func (x RpcCallOptionAllowedServersPolicy) Name() string                        { return "AllowedServersPolicy" }
+func (x RpcCallOptionAllowedServersPolicy) __VDLReflect(__RpcCallOptionReflect) {}
+
+func (x RpcCallOptionRetryTimeout) Index() int                          { return 1 }
+func (x RpcCallOptionRetryTimeout) Interface() interface{}              { return x.Value }
+func (x RpcCallOptionRetryTimeout) Name() string                        { return "RetryTimeout" }
+func (x RpcCallOptionRetryTimeout) __VDLReflect(__RpcCallOptionReflect) {}
+
 type RpcResponse struct {
 	OutArgs       []*vdl.Value
 	TraceResponse vtrace.Response
@@ -41,5 +81,6 @@
 
 func init() {
 	vdl.Register((*RpcRequest)(nil))
+	vdl.Register((*RpcCallOption)(nil))
 	vdl.Register((*RpcResponse)(nil))
 }