diff --git a/server/package-lock.json b/server/package-lock.json
index 284406cac..690bdfb68 100644
--- a/server/package-lock.json
+++ b/server/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@scrypted/server",
-  "version": "0.115.22",
+  "version": "0.115.23",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrypted/server",
-      "version": "0.115.22",
+      "version": "0.115.23",
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {
diff --git a/server/python/rpc.py b/server/python/rpc.py
index f725bc00b..80424d45d 100644
--- a/server/python/rpc.py
+++ b/server/python/rpc.py
@@ -22,6 +22,7 @@ async def maybe_await(value):
 
 
 class RPCResultError(Exception):
+    # i think this stuff shouldn't be here...
     name: str
     stack: str
     message: str
@@ -187,14 +188,7 @@ class RpcPeer:
         s = self.serializeError(e)
         result['result'] = s
         result['throw'] = True
-
-        # TODO 3/2/2023 deprecate these properties
-        tb = traceback.format_exc()
-        message = str(e)
-        result['stack'] = tb or '[no stack]',
-        result['message'] = message or '[no message]',
-        # END TODO
-
+        return result
 
     def deserializeError(e: Dict) -> RPCResultError:
         error = RPCResultError(None, e.get('message'))
@@ -390,6 +384,9 @@ class RpcPeer:
 
         return value
 
+    def sendResult(self, result: Dict, serializationContext: Dict):
+        self.send(result, lambda e: self.send(self.createErrorResult(result, e, None), None), serializationContext)
+
     async def handleMessage(self, message: Dict, deserializationContext: Dict):
         try:
             messageType = message['type']
@@ -409,7 +406,7 @@ class RpcPeer:
                     self.createErrorResult(
                         result, type(e).__name, str(e), tb)
 
-                self.send(result, None, serializationContext)
+                self.sendResult(result, serializationContext)
 
             elif messageType == 'apply':
                 result = {
@@ -450,7 +447,7 @@ class RpcPeer:
                     self.createErrorResult(result, e)
 
                 if not message.get('oneway', False):
-                    self.send(result, None, serializationContext)
+                    self.sendResult(result, serializationContext)
 
             elif messageType == 'result':
                 id = message['id']
@@ -459,13 +456,6 @@ class RpcPeer:
                     raise RPCResultError(
                         None, 'unknown result %s' % id)
                 del self.pendingResults[id]
-                if (hasattr(message, 'message') or hasattr(message, 'stack')) and not hasattr(message, 'throw'):
-                    e = RPCResultError(
-                        None, message.get('message', None))
-                    e.stack = message.get('stack', None)
-                    e.name = message.get('name', None)
-                    future.set_exception(e)
-                    return
                 deserialized = self.deserialize(message.get('result', None), deserializationContext)
                 if message.get('throw'):
                     future.set_exception(deserialized)
diff --git a/server/src/rpc.ts b/server/src/rpc.ts
index da30e15ab..193bf0742 100644
--- a/server/src/rpc.ts
+++ b/server/src/rpc.ts
@@ -48,17 +48,6 @@ export interface RpcApply extends RpcMessage {
 export interface RpcResult extends RpcMessage {
     type: 'result';
     id: string;
-    // TODO 3/2/2023
-    // deprecate these properties from rpc protocol. treat error results like any other result
-    // and auto serialize them.
-    /**
-     * @deprecated
-     */
-    stack?: string;
-    /**
-     * @deprecated
-     */
-    message?: string;
     throw?: boolean;
     result?: any;
 }
@@ -493,16 +482,10 @@ export class RpcPeer {
         });
     }
 
-    /**
-     * @deprecated
-     * @param result
-     * @param e
-     */
     createErrorResult(result: RpcResult, e: ErrorType) {
         result.result = this.serializeError(e);
         result.throw = true;
-        result.message = (e as Error).message || 'no message';
-        result.stack = e.stack || 'no stack';
+        return result;
     }
 
     deserialize(value: any, deserializationContext: any): any {
@@ -688,6 +671,13 @@ export class RpcPeer {
         }
     }
 
+    sendResult(result: RpcResult, serializationContext: any) {
+        this.send(result, e => {
+            // attempt to handle transport serialization failure.
+            this.send(this.createErrorResult(result, e), undefined, serializationContext);
+        }, serializationContext);
+    }
+
     private async handleMessageInternal(message: RpcMessage, deserializationContext?: any) {
         if (Object.isFrozen(this.pendingResults))
             return;
@@ -710,7 +700,7 @@ export class RpcPeer {
                         this.createErrorResult(result, e as Error);
                     }
 
-                    this.send(result, undefined, serializationContext);
+                    this.sendResult(result, serializationContext);
                     break;
                 }
                 case 'apply': {
@@ -773,7 +763,7 @@ export class RpcPeer {
                     }
 
                     if (!rpcApply.oneway)
-                        this.send(result, undefined, serializationContext);
+                        this.sendResult(result, serializationContext);
                     break;
                 }
                 case 'result': {
@@ -783,14 +773,6 @@ export class RpcPeer {
                     delete this.pendingResults[rpcResult.id];
                     if (!deferred)
                         throw new Error(`unknown result ${rpcResult.id}`);
-                    if ((rpcResult.message || rpcResult.stack) && !rpcResult.throw) {
-                        const e = new RPCResultError(this, rpcResult.message || 'no message', undefined, {
-                            name: rpcResult.result,
-                            stack: rpcResult.stack,
-                        });
-                        deferred.reject(e);
-                        return;
-                    }
                     const deserialized = this.deserialize(rpcResult.result, deserializationContext);
                     if (rpcResult.throw)
                         deferred.reject(deserialized);