diff --git a/apier/v1/smgenericv1.go b/apier/v1/smgenericv1.go
index dd15b1750..ae1298ce9 100644
--- a/apier/v1/smgenericv1.go
+++ b/apier/v1/smgenericv1.go
@@ -20,7 +20,6 @@ package v1
 import (
 	"reflect"
 	"strings"
-	"time"
 
 	"github.com/cgrates/cgrates/sessionmanager"
 	"github.com/cgrates/cgrates/utils"
@@ -38,74 +37,37 @@ type SMGenericV1 struct {
 
 // Returns MaxUsage (for calls in seconds), -1 for no limit
 func (self *SMGenericV1) MaxUsage(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	maxUsageDur, err := self.sm.MaxUsage(ev)
-	if err != nil {
-		return utils.NewErrServerError(err)
-	}
-	if maxUsageDur == time.Duration(-1) {
-		*maxUsage = -1.0
-	} else {
-		*maxUsage = maxUsageDur.Seconds()
-	}
-	return nil
+	return self.sm.BiRPCV1MaxUsage(nil, ev, maxUsage)
 }
 
 // Returns list of suppliers which can be used for the request
 func (self *SMGenericV1) LCRSuppliers(ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
-	if supls, err := self.sm.LCRSuppliers(ev); err != nil {
-		return utils.NewErrServerError(err)
-	} else {
-		*suppliers = supls
-	}
-	return nil
+	return self.sm.BiRPCV1LCRSuppliers(nil, ev, suppliers)
 }
 
 // Called on session start, returns the maximum number of seconds the session can last
 func (self *SMGenericV1) InitiateSession(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	if minMaxUsage, err := self.sm.InitiateSession(ev, nil); err != nil {
-		return utils.NewErrServerError(err)
-	} else {
-		*maxUsage = minMaxUsage.Seconds()
-	}
-	return nil
+	return self.sm.BiRPCV1InitiateSession(nil, ev, maxUsage)
 }
 
 // Interim updates, returns remaining duration from the rater
 func (self *SMGenericV1) UpdateSession(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	if minMaxUsage, err := self.sm.UpdateSession(ev, nil); err != nil {
-		return utils.NewErrServerError(err)
-	} else {
-		*maxUsage = minMaxUsage.Seconds()
-	}
-	return nil
+	return self.sm.BiRPCV1UpdateSession(nil, ev, maxUsage)
 }
 
 // Called on session end, should stop debit loop
 func (self *SMGenericV1) TerminateSession(ev sessionmanager.SMGenericEvent, reply *string) error {
-	if err := self.sm.TerminateSession(ev, nil); err != nil {
-		return utils.NewErrServerError(err)
-	}
-	*reply = utils.OK
-	return nil
+	return self.sm.BiRPCV1TerminateSession(nil, ev, reply)
 }
 
 // Called on individual Events (eg SMS)
 func (self *SMGenericV1) ChargeEvent(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	if minMaxUsage, err := self.sm.ChargeEvent(ev); err != nil {
-		return utils.NewErrServerError(err)
-	} else {
-		*maxUsage = minMaxUsage.Seconds()
-	}
-	return nil
+	return self.sm.BiRPCV1ChargeEvent(nil, ev, maxUsage)
 }
 
 // Called on session end, should send the CDR to CDRS
 func (self *SMGenericV1) ProcessCDR(ev sessionmanager.SMGenericEvent, reply *string) error {
-	if err := self.sm.ProcessCDR(ev); err != nil {
-		return utils.NewErrServerError(err)
-	}
-	*reply = utils.OK
-	return nil
+	return self.sm.BiRPCV1ProcessCDR(nil, ev, reply)
 }
 
 func (self *SMGenericV1) ActiveSessions(attrs utils.AttrSMGGetActiveSessions, reply *[]*sessionmanager.ActiveSession) error {
@@ -113,12 +75,7 @@ func (self *SMGenericV1) ActiveSessions(attrs utils.AttrSMGGetActiveSessions, re
 }
 
 func (self *SMGenericV1) ActiveSessionsCount(attrs utils.AttrSMGGetActiveSessions, reply *int) error {
-	if _, count, err := self.sm.ActiveSessions(attrs.AsMapStringString(), true); err != nil {
-		return err
-	} else {
-		*reply = count
-	}
-	return nil
+	return self.sm.BiRPCV1ActiveSessionsCount(attrs, reply)
 }
 
 func (self *SMGenericV1) SetPassiveSessions(args sessionmanager.ArgsSetPassiveSessions, reply *string) error {
diff --git a/glide.lock b/glide.lock
index d270875b0..db06470c9 100644
--- a/glide.lock
+++ b/glide.lock
@@ -16,7 +16,7 @@ imports:
 - name: github.com/cgrates/osipsdagram
   version: 3d6beed663452471dec3ca194137a30d379d9e8f
 - name: github.com/cgrates/rpcclient
-  version: 8bb59b56f8c7bee0d5603914a044a1d64ab8781e
+  version: 399063410babe8d0334dc44daf45e92efdeb1e76
 - name: github.com/ChrisTrenkamp/goxpath
   version: 4aad8d0161aae7d17df4755d2c1e86cd1fcaaab6
   subpackages:
diff --git a/sessionmanager/smgeneric.go b/sessionmanager/smgeneric.go
index 5e37954d5..112886804 100644
--- a/sessionmanager/smgeneric.go
+++ b/sessionmanager/smgeneric.go
@@ -685,7 +685,7 @@ func (smg *SMGeneric) UpdateSession(gev SMGenericEvent, clnt rpcclient.RpcClient
 	if len(aSessions) == 0 {
 		if aSessions = smg.passiveToActive(cgrID); len(aSessions) == 0 {
 			utils.Logger.Err(fmt.Sprintf("<SMGeneric> SessionUpdate with no active sessions for event: <%s>", cgrID))
-			err = utils.ErrServerError
+			err = rpcclient.ErrSessionNotFound
 			return
 		}
 	}
@@ -765,7 +765,7 @@ func (smg *SMGeneric) TerminateSession(gev SMGenericEvent, clnt rpcclient.RpcCli
 		}
 	}
 	if !hasActiveSession {
-		err = utils.ErrNoActiveSession
+		err = rpcclient.ErrSessionNotFound
 		return
 	}
 	return
@@ -1035,22 +1035,27 @@ func (smg *SMGeneric) BiRPCV1InitiateSession(clnt rpcclient.RpcClientConnection,
 }
 
 // Interim updates, returns remaining duration from the RALs
-func (smg *SMGeneric) BiRPCV1UpdateSession(clnt rpcclient.RpcClientConnection, ev SMGenericEvent, maxUsage *float64) error {
+func (smg *SMGeneric) BiRPCV1UpdateSession(clnt rpcclient.RpcClientConnection, ev SMGenericEvent, maxUsage *float64) (err error) {
 	if minMaxUsage, err := smg.UpdateSession(ev, clnt); err != nil {
-		return utils.NewErrServerError(err)
+		if err != rpcclient.ErrSessionNotFound {
+			err = utils.NewErrServerError(err)
+		}
 	} else {
 		*maxUsage = minMaxUsage.Seconds()
 	}
-	return nil
+	return
 }
 
 // Called on session end, should stop debit loop
-func (smg *SMGeneric) BiRPCV1TerminateSession(clnt rpcclient.RpcClientConnection, ev SMGenericEvent, reply *string) error {
-	if err := smg.TerminateSession(ev, clnt); err != nil {
-		return utils.NewErrServerError(err)
+func (smg *SMGeneric) BiRPCV1TerminateSession(clnt rpcclient.RpcClientConnection, ev SMGenericEvent, reply *string) (err error) {
+	if err = smg.TerminateSession(ev, clnt); err != nil {
+		if err != rpcclient.ErrSessionNotFound {
+			err = utils.NewErrServerError(err)
+		}
+	} else {
+		*reply = utils.OK
 	}
-	*reply = utils.OK
-	return nil
+	return
 }
 
 // Called on individual Events (eg SMS)