diff --git a/README.md b/README.md
index 520007af0af9e59d04dcc18cd2d6c802c1f7872a..6b323b411ea731bdb0d8b8f444333562df69b993 100644
--- a/README.md
+++ b/README.md
@@ -55,9 +55,9 @@ You can set up all the asynchronous features using
 attributes. No elaborate configuration is needed.
 
 ```php
-#[RespondsToWebSocketRPC(RPCMethod::Echo)]
-#[Singleton(collection: SingletonCollection::WebSocketRPCResponder)]
-final readonly class EchoResponder extends WebSocketRPCResponder
+#[RespondsToWebSocketJsonRPC(JsonRPCMethod::Echo)]
+#[Singleton(collection: SingletonCollection::WebSocketJsonRPCResponder)]
+final readonly class EchoResponder extends WebSocketJsonJsonRPCResponder
 {
     public function getConstraint(): Constraint
     {
@@ -69,7 +69,7 @@ final readonly class EchoResponder extends WebSocketRPCResponder
         WebSocketConnection $webSocketConnection,
         RPCRequest $rpcRequest,
     ): void {
-        $webSocketConnection->push(new RPCResponse(
+        $webSocketConnection->push(new JsonRPCResponse(
             $rpcRequest,
             $rpcRequest->payload,
         ));
diff --git a/docs/pages/docs/features/websockets/protocols.md b/docs/pages/docs/features/websockets/protocols.md
index 79763e448bee1f966d76ccd69776ea80536ba715..523422d102ce1bd29f796ec436ff3120d0bd2a5e 100644
--- a/docs/pages/docs/features/websockets/protocols.md
+++ b/docs/pages/docs/features/websockets/protocols.md
@@ -11,14 +11,14 @@ description: >
 
 # Protocols
 
-## RPC
+## Json RPC
 
 ```graphviz render
 digraph { 
     Message 
         -> WebSocketServerController 
-        -> RPCProtocolController
-        -> WebSocketRPCResponder
+        -> JsonRPCProtocolController
+        -> WebSocketJsonRPCResponder
     ;
 }
 ```
@@ -34,7 +34,7 @@ const serverUrl = new URL('wss://localhost:9501');
 
 serverUrl.searchParams.append('csrf', /* obtain CSRF token */);
 
-const webSocket = new WebSocket(serverUrl, ['dm-rpc']);
+const webSocket = new WebSocket(serverUrl, ['jsonrpc']);
 ```
 
 For example, if you are using {{docs/features/templating/twig/index}}, you can
@@ -53,31 +53,31 @@ serverUrl.searchParams.append(
 );
 ```
 
-### Writing RPC Responders
+### Writing Json RPC Responders
 
 ```php
 <?php
 
-namespace App\WebSocketRPCResponder;
+namespace App\WebSocketJsonRPCResponder;
 
-use App\RPCMethod;
-use Distantmagic\Resonance\Attribute\RespondsToWebSocketRPC;
+use App\JsonRPCMethod;
+use Distantmagic\Resonance\Attribute\RespondsToWebSocketJsonRPC;
 use Distantmagic\Resonance\Attribute\Singleton;
 use Distantmagic\Resonance\Attribute\WantsFeature;
-use Distantmagic\Resonance\Feature;
 use Distantmagic\Resonance\Constraint;
 use Distantmagic\Resonance\Constraint\StringConstraint;
-use Distantmagic\Resonance\RPCRequest;
-use Distantmagic\Resonance\RPCResponse;
+use Distantmagic\Resonance\Feature;
+use Distantmagic\Resonance\JsonRPCRequest;
+use Distantmagic\Resonance\JsonRPCResponse;
 use Distantmagic\Resonance\SingletonCollection;
 use Distantmagic\Resonance\WebSocketAuthResolution;
 use Distantmagic\Resonance\WebSocketConnection;
-use Distantmagic\Resonance\WebSocketRPCResponder;
+use Distantmagic\Resonance\WebSocketJsonRPCResponder;
 
-#[RespondsToWebSocketRPC(RPCMethod::Echo)]
-#[Singleton(collection: SingletonCollection::WebSocketRPCResponder)]
+#[RespondsToWebSocketJsonRPC(JsonRPCMethod::Echo)]
+#[Singleton(collection: SingletonCollection::WebSocketJsonRPCResponder)]
 #[WantsFeature(Feature::WebSocket)]
-final readonly class EchoResponder extends WebSocketRPCResponder
+final readonly class EchoResponder extends WebSocketJsonRPCResponder
 {
     public function getConstraint(): Constraint
     {
@@ -87,9 +87,9 @@ final readonly class EchoResponder extends WebSocketRPCResponder
     public function onRequest(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCRequest $rpcRequest,
+        JsonRPCRequest $rpcRequest,
     ): void {
-        $webSocketConnection->push(new RPCResponse(
+        $webSocketConnection->push(new JsonRPCResponse(
             $rpcRequest,
             $rpcRequest->payload,
         ));
@@ -101,12 +101,12 @@ final readonly class EchoResponder extends WebSocketRPCResponder
 
 In case you want not only respond to RPC messages, but also be able to push
 notifications to the client at any moment, you can implement 
-`Distantmagic\Resonance\WebSocketRPCConnectionControllerInterface` and 
+`Distantmagic\Resonance\WebSocketJsonRPCConnectionControllerInterface` and 
 register in in the {{docs/features/dependency-injection/index}} container.
 
 For example:
 
-```php file:app/WebSocketRPCConnectionController.php
+```php file:app/WebSocketJsonRPCConnectionController.php
 <?php
 
 namespace App;
@@ -114,14 +114,14 @@ namespace App;
 use Distantmagic\Resonance\Attribute\Singleton;
 use Distantmagic\Resonance\Attribute\WantsFeature;
 use Distantmagic\Resonance\Feature;
-use Distantmagic\Resonance\RPCNotification;
+use Distantmagic\Resonance\JsonRPCNotification;
 use Distantmagic\Resonance\WebSocketAuthResolution;
 use Distantmagic\Resonance\WebSocketConnection;
-use Distantmagic\Resonance\WebSocketRPCConnectionControllerInterface;
+use Distantmagic\Resonance\WebSocketJsonRPCConnectionControllerInterface;
 
-#[Singleton(provides: WebSocketRPCConnectionControllerInterface::class)]
+#[Singleton(provides: WebSocketJsonRPCConnectionControllerInterface::class)]
 #[WantsFeature(Feature::WebSocket)]
-readonly class WebSocketRPCConnectionController implements WebSocketRPCConnectionControllerInterface
+readonly class WebSocketJsonRPCConnectionController implements WebSocketJsonRPCConnectionControllerInterface
 {
     public function onClose(
         WebSocketAuthResolution $webSocketAuthResolution,
@@ -139,8 +139,8 @@ readonly class WebSocketRPCConnectionController implements WebSocketRPCConnectio
             // connection is closed
         }
 
-        $webSocketConnection->push(new RPCNotification(
-            RPCMethod::YourMethod,
+        $webSocketConnection->push(new JsonRPCNotification(
+            JsonRPCMethod::YourMethod,
             [
                 // your payload
             ]
diff --git a/docs/pages/docs/features/websockets/server.md b/docs/pages/docs/features/websockets/server.md
index abbc69df063a2a0a332a045d55f99edcdf266c7b..fe8e331b6da622838918a66184453a57459f194c 100644
--- a/docs/pages/docs/features/websockets/server.md
+++ b/docs/pages/docs/features/websockets/server.md
@@ -24,18 +24,18 @@ However, they cannot share the same port if they are separated.
 ## Enabling the Server
 
 To enable WebSocket server you need to provide the 
-`RPCMethodValidatorInterface`. For example:
+`JsonRPCMethodValidatorInterface`. For example:
 
-```php file:app\RPCMethod.php
+```php file:app\JsonRPCMethod.php
 <?php
 
 namespace App;
 
 use Distantmagic\Resonance\EnumValuesTrait;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
 use Distantmagic\Resonance\NameableEnumTrait;
-use Distantmagic\Resonance\RPCMethodInterface;
 
-enum RPCMethod: string implements RPCMethodInterface
+enum JsonRPCMethod: string implements JsonRPCMethodInterface
 {
     use EnumValuesTrait;
     use NameableEnumTrait;
@@ -49,7 +49,7 @@ Do not forget about `#[WantsFeature(Feature::WebSocket)` attribute. If added to
 any singleton, it tells Resonance to enable the WebSocket server.
 :::
 
-```php file:app\RPCMethodValidator.php
+```php file:app\JsonRPCMethodValidator.php
 <?php
 
 namespace App;
@@ -57,21 +57,21 @@ namespace App;
 use Distantmagic\Resonance\Attribute\Singleton;
 use Distantmagic\Resonance\Attribute\WantsFeature;
 use Distantmagic\Resonance\Feature;
-use Distantmagic\Resonance\RPCMethodInterface;
-use Distantmagic\Resonance\RPCMethodValidatorInterface;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
+use Distantmagic\Resonance\JsonRPCMethodValidatorInterface;
 
-#[Singleton(provides: RPCMethodValidatorInterface::class)]
+#[Singleton(provides: JsonRPCMethodValidatorInterface::class)]
 #[WantsFeature(Feature::WebSocket)]
-readonly class RPCMethodValidator implements RPCMethodValidatorInterface
+readonly class JsonRPCMethodValidator implements JsonRPCMethodValidatorInterface
 {
     public function cases(): array
     {
-        return RPCMethod::cases();
+        return JsonRPCMethod::cases();
     }
 
-    public function castToRPCMethod(string $methodName): RPCMethodInterface
+    public function castToRPCMethod(string $methodName): JsonRPCMethodInterface
     {
-        return RPCMethod::from($methodName);
+        return JsonRPCMethod::from($methodName);
     }
 
     public function names(): array
diff --git a/docs/pages/index.md b/docs/pages/index.md
index ea8919bf3bf334d7fd3d521d943e021b36f9e647..663aca8feb4911919921ff8eee97c9cbc2c816e0 100644
--- a/docs/pages/index.md
+++ b/docs/pages/index.md
@@ -149,9 +149,9 @@ readonly class CatAdopt implements PromptSubjectResponderInterface
                         class="language-php"
                         data-controller="hljs"
                         data-hljs-language-value="php"
-                    >#[RespondsToWebSocketRPC(RPCMethod::Echo)]
-#[Singleton(collection: SingletonCollection::WebSocketRPCResponder)]
-final readonly class EchoResponder extends WebSocketRPCResponder
+                    >#[RespondsToWebSocketJsonRPC(JsonRPCMethod::Echo)]
+#[Singleton(collection: SingletonCollection::WebSocketJsonRPCResponder)]
+final readonly class EchoResponder extends WebSocketJsonRPCResponder
 {
     public function getConstraint(): Constraint
     {
diff --git a/docs/pages/tutorials/how-to-create-llm-websocket-chat-with-llama-cpp/index.md b/docs/pages/tutorials/how-to-create-llm-websocket-chat-with-llama-cpp/index.md
index 4eaf93dbdf051b80b193547871c10959102df609..a02b430c8e019498b0edb461f0e79a2ce9e93d1a 100644
--- a/docs/pages/tutorials/how-to-create-llm-websocket-chat-with-llama-cpp/index.md
+++ b/docs/pages/tutorials/how-to-create-llm-websocket-chat-with-llama-cpp/index.md
@@ -39,7 +39,7 @@ Once you have both Resonance and
 First, we must create a security gate and decide which users can use our 
 chat. Let's say all authenticated users can do that:
 
-```php file:app/SiteActionGate/StartWebSocketRPCConnectionGate.php
+```php file:app/SiteActionGate/StartWebSocketJsonRPCConnectionGate.php
 <?php
 
 namespace App\SiteActionGate;
@@ -52,9 +52,9 @@ use Distantmagic\Resonance\SingletonCollection;
 use Distantmagic\Resonance\SiteAction;
 use Distantmagic\Resonance\SiteActionGate;
 
-#[DecidesSiteAction(SiteAction::StartWebSocketRPCConnection)]
+#[DecidesSiteAction(SiteAction::StartWebSocketJsonRPCConnection)]
 #[Singleton(collection: SingletonCollection::SiteActionGate)]
-final readonly class StartWebSocketRPCConnectionGate extends SiteActionGate
+final readonly class StartWebSocketJsonRPCConnectionGate extends SiteActionGate
 {
     public function can(?AuthenticatedUser $authenticatedUser): bool
     {
@@ -101,7 +101,7 @@ use Distantmagic\Resonance\TwigTemplate;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 
-#[Can(SiteAction::StartWebSocketRPCConnection)]
+#[Can(SiteAction::StartWebSocketJsonRPCConnection)]
 #[RespondsToHttp(
     method: RequestMethod::GET,
     pattern: '/chat',
@@ -136,9 +136,9 @@ Method, the first field, is validated against `RPCMethodInterface`, through
 namespace App;
 
 use Distantmagic\Resonance\EnumValuesTrait;
-use Distantmagic\Resonance\RPCMethodInterface;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
 
-enum RPCMethod: string implements RPCMethodInterface
+enum JsonRPCMethod: string implements JsonRPCMethodInterface
 {
     use EnumValuesTrait;
 
@@ -160,26 +160,26 @@ namespace App;
 use Distantmagic\Resonance\Attribute\Singleton;
 use Distantmagic\Resonance\Attribute\WantsFeature;
 use Distantmagic\Resonance\Feature;
-use Distantmagic\Resonance\RPCMethodInterface;
-use Distantmagic\Resonance\RPCMethodValidatorInterface;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
+use Distantmagic\Resonance\JsonRPCMethodValidatorInterface;
 
-#[Singleton(provides: RPCMethodValidatorInterface::class)]
+#[Singleton(provides: JsonRPCMethodValidatorInterface::class)]
 #[WantsFeature(Feature::WebSocket)]
-readonly class RPCMethodValidator implements RPCMethodValidatorInterface
+readonly class JsonRPCMethodValidator implements JsonRPCMethodValidatorInterface
 {
     public function cases(): array
     {
-        return RPCMethod::cases();
+        return JsonRPCMethod::cases();
     }
 
-    public function castToRPCMethod(string $methodName): RPCMethodInterface
+    public function castToRPCMethod(string $methodName): JsonRPCMethodInterface
     {
-        return RPCMethod::from($methodName);
+        return JsonRPCMethod::from($methodName);
     }
 
     public function values(): array
     {
-        return RPCMethod::values();
+        return JsonRPCMethod::values();
     }
 }
 ```
@@ -196,33 +196,33 @@ It will then use `LlamaCppClient` to fetch tokens from
 [llama.cpp](https://github.com/ggerganov/llama.cpp) server and forward them
 to the WebSocket connection:
 
-```php file:app/WebSocketRPCResponder/LlmChatPromptResponder.php
+```php file:app/WebSocketJsonRPCResponder/LlmChatPromptResponder.php
 <?php
 
-namespace App\WebSocketRPCResponder;
+namespace App\WebSocketJsonRPCResponder;
 
-use App\RPCMethod;
-use Distantmagic\Resonance\Attribute\RespondsToWebSocketRPC;
+use App\JsonRPCMethod;
+use Distantmagic\Resonance\Attribute\RespondsToWebSocketJsonRPC;
 use Distantmagic\Resonance\Attribute\Singleton;
 use Distantmagic\Resonance\Attribute\WantsFeature;
-use Distantmagic\Resonance\Feature;
 use Distantmagic\Resonance\Constraint;
 use Distantmagic\Resonance\Constraint\ObjectConstraint;
 use Distantmagic\Resonance\Constraint\StringConstraint;
+use Distantmagic\Resonance\Feature;
+use Distantmagic\Resonance\JsonRPCNotification;
+use Distantmagic\Resonance\JsonRPCRequest;
+use Distantmagic\Resonance\JsonRPCResponse;
 use Distantmagic\Resonance\LlamaCppClient;
 use Distantmagic\Resonance\LlamaCppCompletionRequest;
-use Distantmagic\Resonance\RPCNotification;
-use Distantmagic\Resonance\RPCRequest;
-use Distantmagic\Resonance\RPCResponse;
 use Distantmagic\Resonance\SingletonCollection;
 use Distantmagic\Resonance\WebSocketAuthResolution;
 use Distantmagic\Resonance\WebSocketConnection;
-use Distantmagic\Resonance\WebSocketRPCResponder;
+use Distantmagic\Resonance\WebSocketJsonRPCResponder;
 
-#[RespondsToWebSocketRPC(RPCMethod::LlmChatPrompt)]
-#[Singleton(collection: SingletonCollection::WebSocketRPCResponder)]
+#[RespondsToWebSocketJsonRPC(JsonRPCMethod::LlmChatPrompt)]
+#[Singleton(collection: SingletonCollection::WebSocketJsonRPCResponder)]
 #[WantsFeature(Feature::WebSocket)]
-final readonly class LlmChatPromptResponder extends WebSocketRPCResponder
+final readonly class LlmChatPromptResponder extends WebSocketJsonRPCResponder
 {
     public function __construct(
         private LlamaCppClient $llamaCppClient,
@@ -240,7 +240,7 @@ final readonly class LlmChatPromptResponder extends WebSocketRPCResponder
     public function onNotification(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCNotification $rpcNotification,
+        JsonRPCNotification $rpcNotification,
     ): void {
         $request = new LlamaCppCompletionRequest($rpcNotification->payload->prompt);
 
@@ -248,8 +248,8 @@ final readonly class LlmChatPromptResponder extends WebSocketRPCResponder
 
         foreach ($completion as $token) {
             if ($webSocketConnection->status->isOpen()) {
-                $webSocketConnection->push(new RPCNotification(
-                    RPCMethod::LlmToken,
+                $webSocketConnection->push(new JsonRPCNotification(
+                    JsonRPCMethod::LlmToken,
                     $token->content,
                 ));
             } else {
@@ -265,7 +265,7 @@ final readonly class LlmChatPromptResponder extends WebSocketRPCResponder
 [Stimulus](https://stimulus.hotwired.dev/) controller starts WebSocket 
 connection and sends user prompts to the server. Not that WebSocket
 connection uses both {{docs/features/security/csrf-protection/index}} and 
-`dm-rpc` {{docs/features/websockets/protocols}}:
+`jsonrpc` {{docs/features/websockets/protocols}}:
 
 ```typescript file:resources/ts/controller_llmchat.ts
 import { Controller } from "@hotwired/stimulus";
@@ -290,7 +290,7 @@ export class controller_llmchat extends Controller<HTMLElement> {
 
     servertUrl.searchParams.append("csrf", this.csrfTokenValue);
 
-    const webSocket = new WebSocket(servertUrl, ["dm-rpc"]);
+    const webSocket = new WebSocket(servertUrl, ["jsonrpc"]);
 
     webSocket.addEventListener("close", () => {
       this.webSocket = null;
@@ -307,9 +307,7 @@ export class controller_llmchat extends Controller<HTMLElement> {
 
       const parsed: unknown = JSON.parse(evt.data);
 
-      if (Array.isArray(parsed) && "string" === typeof parsed[1]) {
-        this.chatLogTarget.append(parsed[1]);
-      }
+      this.chatLogTarget.append(parsed.result);
     });
   }
 
@@ -322,13 +320,13 @@ export class controller_llmchat extends Controller<HTMLElement> {
 
     this.chatLogTarget.innerHTML = '';
 
-    this.webSocket?.send(JSON.stringify([
-      "llm_chat_prompt",
-      {
-        prompt: this.userInputFieldTarget.value,
-      },
-      null
-    ]));
+    this.webSocket?.send(JSON.stringify({
+        jsonrpc: "2.0",
+        method: "llm_chat_prompt",
+        params: {
+            prompt: this.userInputFieldTarget.value,
+        }
+    }));
 
     this.userInputFieldTarget.value = '';
   }
diff --git a/src/Attribute/RespondsToWebSocketRPC.php b/src/Attribute/RespondsToWebSocketJsonRPC.php
similarity index 58%
rename from src/Attribute/RespondsToWebSocketRPC.php
rename to src/Attribute/RespondsToWebSocketJsonRPC.php
index 004d5eb0a9715674994f4f18ecac5a431e47c545..dcff4ce896535b8c9e779a694eb8669669bfa878 100644
--- a/src/Attribute/RespondsToWebSocketRPC.php
+++ b/src/Attribute/RespondsToWebSocketJsonRPC.php
@@ -6,12 +6,12 @@ namespace Distantmagic\Resonance\Attribute;
 
 use Attribute;
 use Distantmagic\Resonance\Attribute as BaseAttribute;
-use Distantmagic\Resonance\RPCMethodInterface;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
 
 #[Attribute(Attribute::TARGET_CLASS)]
-final readonly class RespondsToWebSocketRPC extends BaseAttribute
+final readonly class RespondsToWebSocketJsonRPC extends BaseAttribute
 {
     public function __construct(
-        public RPCMethodInterface $method,
+        public JsonRPCMethodInterface $method,
     ) {}
 }
diff --git a/src/InputValidatedData/RPCMessage.php b/src/InputValidatedData/JsonRPCMessage.php
similarity index 67%
rename from src/InputValidatedData/RPCMessage.php
rename to src/InputValidatedData/JsonRPCMessage.php
index ee4a09372abd80019a86ce1828878f90e3763318..6ede324aa4757b7c6f3549b6de61e5f9ec3078da 100644
--- a/src/InputValidatedData/RPCMessage.php
+++ b/src/InputValidatedData/JsonRPCMessage.php
@@ -5,18 +5,18 @@ declare(strict_types=1);
 namespace Distantmagic\Resonance\InputValidatedData;
 
 use Distantmagic\Resonance\InputValidatedData;
-use Distantmagic\Resonance\RPCMethodInterface;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
 
 /**
  * @template TPayload
  */
-readonly class RPCMessage extends InputValidatedData
+readonly class JsonRPCMessage extends InputValidatedData
 {
     /**
      * @param TPayload $payload
      */
     public function __construct(
-        public RPCMethodInterface $method,
+        public JsonRPCMethodInterface $method,
         public mixed $payload,
         public ?string $requestId,
     ) {}
diff --git a/src/InputValidator/RPCMessageValidator.php b/src/InputValidator/JsonRPCMessageValidator.php
similarity index 73%
rename from src/InputValidator/RPCMessageValidator.php
rename to src/InputValidator/JsonRPCMessageValidator.php
index 49a731c4bf9342d7cd0521e40d0f6cbdde8f9c77..953236cea34b24c71c709569c4ddadbd9e648b13 100644
--- a/src/InputValidator/RPCMessageValidator.php
+++ b/src/InputValidator/JsonRPCMessageValidator.php
@@ -12,13 +12,13 @@ use Distantmagic\Resonance\Constraint\EnumConstraint;
 use Distantmagic\Resonance\Constraint\StringConstraint;
 use Distantmagic\Resonance\Constraint\TupleConstraint;
 use Distantmagic\Resonance\Feature;
-use Distantmagic\Resonance\InputValidatedData\RPCMessage;
+use Distantmagic\Resonance\InputValidatedData\JsonRPCMessage;
 use Distantmagic\Resonance\InputValidator;
-use Distantmagic\Resonance\RPCMethodValidatorInterface;
+use Distantmagic\Resonance\JsonRPCMethodValidatorInterface;
 use Distantmagic\Resonance\SingletonCollection;
 
 /**
- * @extends InputValidator<RPCMessage, array{
+ * @extends InputValidator<JsonRPCMessage, array{
  *     0: string,
  *     1: mixed,
  *     2: null|string,
@@ -26,13 +26,13 @@ use Distantmagic\Resonance\SingletonCollection;
  */
 #[GrantsFeature(Feature::WebSocket)]
 #[Singleton(collection: SingletonCollection::InputValidator)]
-readonly class RPCMessageValidator extends InputValidator
+readonly class JsonRPCMessageValidator extends InputValidator
 {
-    public function __construct(private RPCMethodValidatorInterface $rpcMethodValidator) {}
+    public function __construct(private JsonRPCMethodValidatorInterface $rpcMethodValidator) {}
 
-    public function castValidatedData(mixed $data): RPCMessage
+    public function castValidatedData(mixed $data): JsonRPCMessage
     {
-        return new RPCMessage(
+        return new JsonRPCMessage(
             $this->rpcMethodValidator->castToRPCMethod($data[0]),
             $data[1],
             $data[2],
diff --git a/src/RPCMethodInterface.php b/src/JsonRPCMethodInterface.php
similarity index 77%
rename from src/RPCMethodInterface.php
rename to src/JsonRPCMethodInterface.php
index 2e1deb24bbd32c49a87c9cb71118275918e770fd..05baa42ddcdf731829f94bf3bffadab4e145d2db 100644
--- a/src/RPCMethodInterface.php
+++ b/src/JsonRPCMethodInterface.php
@@ -4,7 +4,7 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance;
 
-interface RPCMethodInterface
+interface JsonRPCMethodInterface
 {
     public function getValue(): string;
 }
diff --git a/src/RPCMethodValidatorInterface.php b/src/JsonRPCMethodValidatorInterface.php
similarity index 55%
rename from src/RPCMethodValidatorInterface.php
rename to src/JsonRPCMethodValidatorInterface.php
index 1e8a3ea289436cc905c4c6edec5e57062718c3b2..d310cfffe10eb3394c8a9578601b257aa508ce55 100644
--- a/src/RPCMethodValidatorInterface.php
+++ b/src/JsonRPCMethodValidatorInterface.php
@@ -4,14 +4,14 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance;
 
-interface RPCMethodValidatorInterface
+interface JsonRPCMethodValidatorInterface
 {
     /**
-     * @return array<RPCMethodInterface>
+     * @return array<JsonRPCMethodInterface>
      */
     public function cases(): array;
 
-    public function castToRPCMethod(string $methodName): RPCMethodInterface;
+    public function castToRPCMethod(string $methodName): JsonRPCMethodInterface;
 
     /**
      * @return array<string>
diff --git a/src/RPCNotification.php b/src/JsonRPCNotification.php
similarity index 81%
rename from src/RPCNotification.php
rename to src/JsonRPCNotification.php
index e99f1eb611dc233637d49428fbb8fe25f210f766..c99fe2f9f44a01e405de93bd12cdb4187077043a 100644
--- a/src/RPCNotification.php
+++ b/src/JsonRPCNotification.php
@@ -11,13 +11,13 @@ use Stringable;
  *
  * @template TPayload
  */
-readonly class RPCNotification implements Stringable
+readonly class JsonRPCNotification implements Stringable
 {
     /**
      * @param TPayload $payload
      */
     public function __construct(
-        public RPCMethodInterface $method,
+        public JsonRPCMethodInterface $method,
         public mixed $payload,
     ) {}
 
diff --git a/src/RPCRequest.php b/src/JsonRPCRequest.php
similarity index 80%
rename from src/RPCRequest.php
rename to src/JsonRPCRequest.php
index 57b9bb4b72d0df871ad173fe0608cfaeac165635..151f43e66d637f8c606431df1cff9a3704a3f0b1 100644
--- a/src/RPCRequest.php
+++ b/src/JsonRPCRequest.php
@@ -9,13 +9,13 @@ namespace Distantmagic\Resonance;
  *
  * @template TPayload
  */
-readonly class RPCRequest
+readonly class JsonRPCRequest
 {
     /**
      * @param TPayload $payload
      */
     public function __construct(
-        public RPCMethodInterface $method,
+        public JsonRPCMethodInterface $method,
         public mixed $payload,
         public string $requestId,
     ) {}
diff --git a/src/RPCResponse.php b/src/JsonRPCResponse.php
similarity index 79%
rename from src/RPCResponse.php
rename to src/JsonRPCResponse.php
index 15d1a8e9a03f86cd6f29bb8510198f0044fe154e..c5dfe3f6b5273333e5827c93ceec2967761b7413 100644
--- a/src/RPCResponse.php
+++ b/src/JsonRPCResponse.php
@@ -6,10 +6,10 @@ namespace Distantmagic\Resonance;
 
 use Stringable;
 
-readonly class RPCResponse implements Stringable
+readonly class JsonRPCResponse implements Stringable
 {
     public function __construct(
-        private RPCRequest $rpcRequest,
+        private JsonRPCRequest $rpcRequest,
         private mixed $content,
     ) {}
 
diff --git a/src/SingletonCollection.php b/src/SingletonCollection.php
index 64b3f6ba04744e81f28f75a1a7e3d6c44acda7eb..63356a3f953c2217e4b1d25bd7448de153476214 100644
--- a/src/SingletonCollection.php
+++ b/src/SingletonCollection.php
@@ -37,6 +37,6 @@ enum SingletonCollection implements SingletonCollectionInterface
     case TwigFilter;
     case TwigFunction;
     case TwigLoader;
+    case WebSocketJsonRPCResponder;
     case WebSocketProtocolController;
-    case WebSocketRPCResponder;
 }
diff --git a/src/SingletonProvider/WebSocketJsonRPCResponderAggregateProvider.php b/src/SingletonProvider/WebSocketJsonRPCResponderAggregateProvider.php
new file mode 100644
index 0000000000000000000000000000000000000000..aa794cdc94efd9e353785c5a14bf72ce900b8d19
--- /dev/null
+++ b/src/SingletonProvider/WebSocketJsonRPCResponderAggregateProvider.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Distantmagic\Resonance\SingletonProvider;
+
+use Distantmagic\Resonance\Attribute\RequiresSingletonCollection;
+use Distantmagic\Resonance\Attribute\RespondsToWebSocketJsonRPC;
+use Distantmagic\Resonance\Attribute\Singleton;
+use Distantmagic\Resonance\PHPProjectFiles;
+use Distantmagic\Resonance\SingletonAttribute;
+use Distantmagic\Resonance\SingletonCollection;
+use Distantmagic\Resonance\SingletonContainer;
+use Distantmagic\Resonance\SingletonProvider;
+use Distantmagic\Resonance\WebSocketJsonRPCResponderAggregate;
+use Distantmagic\Resonance\WebSocketJsonRPCResponderInterface;
+
+/**
+ * @template-extends SingletonProvider<WebSocketJsonRPCResponderAggregate>
+ */
+#[RequiresSingletonCollection(SingletonCollection::WebSocketJsonRPCResponder)]
+#[Singleton(provides: WebSocketJsonRPCResponderAggregate::class)]
+final readonly class WebSocketJsonRPCResponderAggregateProvider extends SingletonProvider
+{
+    public function provide(SingletonContainer $singletons, PHPProjectFiles $phpProjectFiles): WebSocketJsonRPCResponderAggregate
+    {
+        $webSocketJsonRPCResponderAggregate = new WebSocketJsonRPCResponderAggregate();
+
+        foreach ($this->collectWebSocketJsonRPCResponders($singletons) as $rpcResponderAttribute) {
+            $webSocketJsonRPCResponderAggregate->cachedConstraints->put(
+                $rpcResponderAttribute->singleton,
+                $rpcResponderAttribute->singleton->getConstraint(),
+            );
+            $webSocketJsonRPCResponderAggregate->rpcResponders->put(
+                $rpcResponderAttribute->attribute->method,
+                $rpcResponderAttribute->singleton,
+            );
+        }
+
+        return $webSocketJsonRPCResponderAggregate;
+    }
+
+    /**
+     * @return iterable<SingletonAttribute<WebSocketJsonRPCResponderInterface,RespondsToWebSocketJsonRPC>>
+     */
+    private function collectWebSocketJsonRPCResponders(SingletonContainer $singletons): iterable
+    {
+        return $this->collectAttributes(
+            $singletons,
+            WebSocketJsonRPCResponderInterface::class,
+            RespondsToWebSocketJsonRPC::class,
+        );
+    }
+}
diff --git a/src/SingletonProvider/WebSocketRPCResponderAggregateProvider.php b/src/SingletonProvider/WebSocketRPCResponderAggregateProvider.php
deleted file mode 100644
index 611752ce17f98b35fa1c5c560b69ab8be321f3ba..0000000000000000000000000000000000000000
--- a/src/SingletonProvider/WebSocketRPCResponderAggregateProvider.php
+++ /dev/null
@@ -1,54 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Distantmagic\Resonance\SingletonProvider;
-
-use Distantmagic\Resonance\Attribute\RequiresSingletonCollection;
-use Distantmagic\Resonance\Attribute\RespondsToWebSocketRPC;
-use Distantmagic\Resonance\Attribute\Singleton;
-use Distantmagic\Resonance\PHPProjectFiles;
-use Distantmagic\Resonance\SingletonAttribute;
-use Distantmagic\Resonance\SingletonCollection;
-use Distantmagic\Resonance\SingletonContainer;
-use Distantmagic\Resonance\SingletonProvider;
-use Distantmagic\Resonance\WebSocketRPCResponderAggregate;
-use Distantmagic\Resonance\WebSocketRPCResponderInterface;
-
-/**
- * @template-extends SingletonProvider<WebSocketRPCResponderAggregate>
- */
-#[RequiresSingletonCollection(SingletonCollection::WebSocketRPCResponder)]
-#[Singleton(provides: WebSocketRPCResponderAggregate::class)]
-final readonly class WebSocketRPCResponderAggregateProvider extends SingletonProvider
-{
-    public function provide(SingletonContainer $singletons, PHPProjectFiles $phpProjectFiles): WebSocketRPCResponderAggregate
-    {
-        $webSocketRPCResponderAggregate = new WebSocketRPCResponderAggregate();
-
-        foreach ($this->collectWebSocketRPCResponders($singletons) as $rpcResponderAttribute) {
-            $webSocketRPCResponderAggregate->cachedConstraints->put(
-                $rpcResponderAttribute->singleton,
-                $rpcResponderAttribute->singleton->getConstraint(),
-            );
-            $webSocketRPCResponderAggregate->rpcResponders->put(
-                $rpcResponderAttribute->attribute->method,
-                $rpcResponderAttribute->singleton,
-            );
-        }
-
-        return $webSocketRPCResponderAggregate;
-    }
-
-    /**
-     * @return iterable<SingletonAttribute<WebSocketRPCResponderInterface,RespondsToWebSocketRPC>>
-     */
-    private function collectWebSocketRPCResponders(SingletonContainer $singletons): iterable
-    {
-        return $this->collectAttributes(
-            $singletons,
-            WebSocketRPCResponderInterface::class,
-            RespondsToWebSocketRPC::class,
-        );
-    }
-}
diff --git a/src/SiteAction.php b/src/SiteAction.php
index 19cb28561b14e84a677a87e28a9c9b717bd114b1..b076b752f3c76bdb295526bd07076fec71d7ddd2 100644
--- a/src/SiteAction.php
+++ b/src/SiteAction.php
@@ -8,7 +8,7 @@ enum SiteAction implements SiteActionInterface
 {
     use NameableEnumTrait;
 
-    case StartWebSocketRPCConnection;
+    case StartWebSocketJsonRPCConnection;
     case UseGraphQL;
     case UseOAuth2;
 }
diff --git a/src/WebSocketRPCConnectionController.php b/src/WebSocketJsonRPCConnectionController.php
similarity index 63%
rename from src/WebSocketRPCConnectionController.php
rename to src/WebSocketJsonRPCConnectionController.php
index d4a55383bca53d975b5e9e84cbf8465d6ff13efd..98f36700c5be680ecebe04039639c4d2d9c29eec 100644
--- a/src/WebSocketRPCConnectionController.php
+++ b/src/WebSocketJsonRPCConnectionController.php
@@ -4,7 +4,7 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance;
 
-abstract readonly class WebSocketRPCConnectionController implements WebSocketRPCConnectionControllerInterface
+abstract readonly class WebSocketJsonRPCConnectionController implements WebSocketJsonRPCConnectionControllerInterface
 {
     public function onClose(WebSocketAuthResolution $webSocketAuthResolution, WebSocketConnection $webSocketConnection): void {}
 }
diff --git a/src/WebSocketRPCConnectionControllerInterface.php b/src/WebSocketJsonRPCConnectionControllerInterface.php
similarity index 86%
rename from src/WebSocketRPCConnectionControllerInterface.php
rename to src/WebSocketJsonRPCConnectionControllerInterface.php
index 3b2ac58922a355a181050b5d8a1219729e292f89..b5843e7971f31fe097d7582b33ac23f5d90f4720 100644
--- a/src/WebSocketRPCConnectionControllerInterface.php
+++ b/src/WebSocketJsonRPCConnectionControllerInterface.php
@@ -4,7 +4,7 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance;
 
-interface WebSocketRPCConnectionControllerInterface
+interface WebSocketJsonRPCConnectionControllerInterface
 {
     public function onClose(
         WebSocketAuthResolution $webSocketAuthResolution,
diff --git a/src/WebSocketRPCConnectionHandle.php b/src/WebSocketJsonRPCConnectionHandle.php
similarity index 79%
rename from src/WebSocketRPCConnectionHandle.php
rename to src/WebSocketJsonRPCConnectionHandle.php
index 8e37283fb36189878449b8ecd4d061f1b472fbba..edd3164d0c6156e79386885f269f9639c6efe33f 100644
--- a/src/WebSocketRPCConnectionHandle.php
+++ b/src/WebSocketJsonRPCConnectionHandle.php
@@ -4,18 +4,18 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance;
 
-use Distantmagic\Resonance\InputValidatedData\RPCMessage;
+use Distantmagic\Resonance\InputValidatedData\JsonRPCMessage;
 use Ds\Set;
 
-readonly class WebSocketRPCConnectionHandle
+readonly class WebSocketJsonRPCConnectionHandle
 {
     /**
-     * @var Set<WebSocketRPCResponderInterface>
+     * @var Set<WebSocketJsonRPCResponderInterface>
      */
     private Set $activeResponders;
 
     public function __construct(
-        public WebSocketRPCResponderAggregate $webSocketRPCResponderAggregate,
+        public WebSocketJsonRPCResponderAggregate $webSocketJsonRPCResponderAggregate,
         public WebSocketAuthResolution $webSocketAuthResolution,
         public WebSocketConnection $webSocketConnection,
     ) {
@@ -36,15 +36,15 @@ readonly class WebSocketRPCConnectionHandle
         }
     }
 
-    public function onRPCMessage(RPCMessage $rpcMessage): ConstraintResult
+    public function onRPCMessage(JsonRPCMessage $rpcMessage): ConstraintResult
     {
         $responder = $this
-            ->webSocketRPCResponderAggregate
+            ->webSocketJsonRPCResponderAggregate
             ->selectResponder($rpcMessage)
         ;
 
         $constraintResult = $this
-            ->webSocketRPCResponderAggregate
+            ->webSocketJsonRPCResponderAggregate
             ->cachedConstraints
             ->get($responder)
             ->validate($rpcMessage->payload)
@@ -65,7 +65,7 @@ readonly class WebSocketRPCConnectionHandle
             $responder->onRequest(
                 $this->webSocketAuthResolution,
                 $this->webSocketConnection,
-                new RPCRequest(
+                new JsonRPCRequest(
                     $rpcMessage->method,
                     $constraintResult->castedData,
                     $rpcMessage->requestId,
@@ -75,7 +75,7 @@ readonly class WebSocketRPCConnectionHandle
             $responder->onNotification(
                 $this->webSocketAuthResolution,
                 $this->webSocketConnection,
-                new RPCNotification(
+                new JsonRPCNotification(
                     $rpcMessage->method,
                     $constraintResult->castedData,
                 )
diff --git a/src/WebSocketRPCResponder.php b/src/WebSocketJsonRPCResponder.php
similarity index 80%
rename from src/WebSocketRPCResponder.php
rename to src/WebSocketJsonRPCResponder.php
index 57880c398221ce52aa73c306cc5cd534e4fb9dae..b855e13c1f9d7887c16943e572fdc712c2381563 100644
--- a/src/WebSocketRPCResponder.php
+++ b/src/WebSocketJsonRPCResponder.php
@@ -10,9 +10,9 @@ use Distantmagic\Resonance\WebSocketProtocolException\UnexpectedRequest;
 /**
  * @template TPayload
  *
- * @template-implements WebSocketRPCResponderInterface<TPayload>
+ * @template-implements WebSocketJsonRPCResponderInterface<TPayload>
  */
-abstract readonly class WebSocketRPCResponder implements WebSocketRPCResponderInterface
+abstract readonly class WebSocketJsonRPCResponder implements WebSocketJsonRPCResponderInterface
 {
     public function onBeforeMessage(
         WebSocketAuthResolution $webSocketAuthResolution,
@@ -27,7 +27,7 @@ abstract readonly class WebSocketRPCResponder implements WebSocketRPCResponderIn
     public function onNotification(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCNotification $rpcNotification,
+        JsonRPCNotification $rpcNotification,
     ): void {
         throw new UnexpectedNotification($rpcNotification->method);
     }
@@ -35,7 +35,7 @@ abstract readonly class WebSocketRPCResponder implements WebSocketRPCResponderIn
     public function onRequest(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCRequest $rpcRequest,
+        JsonRPCRequest $rpcRequest,
     ): void {
         throw new UnexpectedRequest($rpcRequest->method);
     }
diff --git a/src/WebSocketRPCResponder/LlamaCppSubjectActionPromptResponder.php b/src/WebSocketJsonRPCResponder/LlamaCppSubjectActionPromptResponder.php
similarity index 92%
rename from src/WebSocketRPCResponder/LlamaCppSubjectActionPromptResponder.php
rename to src/WebSocketJsonRPCResponder/LlamaCppSubjectActionPromptResponder.php
index ef0f5304b681e3eb276dedd4ec2958849279aa2e..1de9c94628ace626f06022b90651ad2b6f9c9f1f 100644
--- a/src/WebSocketRPCResponder/LlamaCppSubjectActionPromptResponder.php
+++ b/src/WebSocketJsonRPCResponder/LlamaCppSubjectActionPromptResponder.php
@@ -2,9 +2,10 @@
 
 declare(strict_types=1);
 
-namespace Distantmagic\Resonance\WebSocketRPCResponder;
+namespace Distantmagic\Resonance\WebSocketJsonRPCResponder;
 
 use Distantmagic\Resonance\BackusNaurFormGrammar\SubjectActionGrammar;
+use Distantmagic\Resonance\JsonRPCRequest;
 use Distantmagic\Resonance\LlamaCppClient;
 use Distantmagic\Resonance\LlamaCppCompletionIterator;
 use Distantmagic\Resonance\LlamaCppCompletionRequest;
@@ -17,10 +18,9 @@ use Distantmagic\Resonance\ObservableTaskStatusUpdate;
 use Distantmagic\Resonance\ObservableTaskTable;
 use Distantmagic\Resonance\ObservableTaskTimeoutIterator;
 use Distantmagic\Resonance\PromptSubjectResponderAggregate;
-use Distantmagic\Resonance\RPCRequest;
 use Distantmagic\Resonance\WebSocketAuthResolution;
 use Distantmagic\Resonance\WebSocketConnection;
-use Distantmagic\Resonance\WebSocketRPCResponder;
+use Distantmagic\Resonance\WebSocketJsonRPCResponder;
 use Generator;
 use Psr\Log\LoggerInterface;
 use WeakMap;
@@ -28,9 +28,9 @@ use WeakMap;
 /**
  * @template TPayload
  *
- * @template-extends WebSocketRPCResponder<TPayload>
+ * @template-extends WebSocketJsonRPCResponder<TPayload>
  */
-abstract readonly class LlamaCppSubjectActionPromptResponder extends WebSocketRPCResponder
+abstract readonly class LlamaCppSubjectActionPromptResponder extends WebSocketJsonRPCResponder
 {
     /**
      * @var WeakMap<WebSocketConnection,LlamaCppCompletionIterator>
@@ -45,7 +45,7 @@ abstract readonly class LlamaCppSubjectActionPromptResponder extends WebSocketRP
     abstract protected function onResponseChunk(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCRequest $rpcRequest,
+        JsonRPCRequest $rpcRequest,
         mixed $responseChunk,
         bool $isLastChunk,
     ): void;
@@ -78,7 +78,7 @@ abstract readonly class LlamaCppSubjectActionPromptResponder extends WebSocketRP
     public function onRequest(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCRequest $rpcRequest,
+        JsonRPCRequest $rpcRequest,
     ): void {
         $this->observableTaskTable->observe(new ObservableTask(
             new ObservableTaskTimeoutIterator(
@@ -105,14 +105,14 @@ abstract readonly class LlamaCppSubjectActionPromptResponder extends WebSocketRP
     }
 
     /**
-     * @param RPCRequest<TPayload> $rpcRequest
+     * @param JsonRPCRequest<TPayload> $rpcRequest
      *
      * @return Generator<ObservableTaskStatusUpdate>
      */
     private function onObservableRequest(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCRequest $rpcRequest,
+        JsonRPCRequest $rpcRequest,
     ): Generator {
         $request = new LlamaCppCompletionRequest(
             backusNaurFormGrammar: $this->subjectActionGrammar,
diff --git a/src/WebSocketRPCResponder/ObservableTasksTableUpdateResponder.php b/src/WebSocketJsonRPCResponder/ObservableTasksTableUpdateResponder.php
similarity index 77%
rename from src/WebSocketRPCResponder/ObservableTasksTableUpdateResponder.php
rename to src/WebSocketJsonRPCResponder/ObservableTasksTableUpdateResponder.php
index b38daff1258d4d01f79d0ba5f2d52c0dbf235d79..5d2002c138962449c15207ced3b3fb22b114bb5b 100644
--- a/src/WebSocketRPCResponder/ObservableTasksTableUpdateResponder.php
+++ b/src/WebSocketJsonRPCResponder/ObservableTasksTableUpdateResponder.php
@@ -2,24 +2,24 @@
 
 declare(strict_types=1);
 
-namespace Distantmagic\Resonance\WebSocketRPCResponder;
+namespace Distantmagic\Resonance\WebSocketJsonRPCResponder;
 
 use Distantmagic\Resonance\Constraint;
 use Distantmagic\Resonance\Constraint\ObjectConstraint;
+use Distantmagic\Resonance\JsonRPCRequest;
+use Distantmagic\Resonance\JsonRPCResponse;
 use Distantmagic\Resonance\ObservableTaskSlotStatusUpdate;
 use Distantmagic\Resonance\ObservableTaskTable;
-use Distantmagic\Resonance\RPCRequest;
-use Distantmagic\Resonance\RPCResponse;
 use Distantmagic\Resonance\WebSocketAuthResolution;
 use Distantmagic\Resonance\WebSocketConnection;
-use Distantmagic\Resonance\WebSocketRPCResponder;
+use Distantmagic\Resonance\WebSocketJsonRPCResponder;
 
 /**
  * @template TPayload
  *
- * @template-extends WebSocketRPCResponder<TPayload>
+ * @template-extends WebSocketJsonRPCResponder<TPayload>
  */
-readonly class ObservableTasksTableUpdateResponder extends WebSocketRPCResponder
+readonly class ObservableTasksTableUpdateResponder extends WebSocketJsonRPCResponder
 {
     public function __construct(
         private ObservableTaskTable $observableTaskTable,
@@ -33,7 +33,7 @@ readonly class ObservableTasksTableUpdateResponder extends WebSocketRPCResponder
     public function onRequest(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCRequest $rpcRequest,
+        JsonRPCRequest $rpcRequest,
     ): void {
         $this->observableTaskTable->observers->add(
             static function (ObservableTaskSlotStatusUpdate $observableTaskSlotStatusUpdate) use (
@@ -44,7 +44,7 @@ readonly class ObservableTasksTableUpdateResponder extends WebSocketRPCResponder
                     return false;
                 }
 
-                return $webSocketConnection->push(new RPCResponse(
+                return $webSocketConnection->push(new JsonRPCResponse(
                     rpcRequest: $rpcRequest,
                     content: $observableTaskSlotStatusUpdate,
                 ));
diff --git a/src/WebSocketRPCResponderAggregate.php b/src/WebSocketJsonRPCResponderAggregate.php
similarity index 62%
rename from src/WebSocketRPCResponderAggregate.php
rename to src/WebSocketJsonRPCResponderAggregate.php
index 4208bb19529f648c14ccbfbd73d9a63604627037..4c7245aafad95a6669f974406f17d4b88635fef0 100644
--- a/src/WebSocketRPCResponderAggregate.php
+++ b/src/WebSocketJsonRPCResponderAggregate.php
@@ -4,19 +4,19 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance;
 
-use Distantmagic\Resonance\InputValidatedData\RPCMessage;
+use Distantmagic\Resonance\InputValidatedData\JsonRPCMessage;
 use DomainException;
 use Ds\Map;
 
-readonly class WebSocketRPCResponderAggregate
+readonly class WebSocketJsonRPCResponderAggregate
 {
     /**
-     * @var Map<WebSocketRPCResponderInterface,Constraint>
+     * @var Map<WebSocketJsonRPCResponderInterface,Constraint>
      */
     public Map $cachedConstraints;
 
     /**
-     * @var Map<RPCMethodInterface,WebSocketRPCResponderInterface> $rpcResponders
+     * @var Map<JsonRPCMethodInterface,WebSocketJsonRPCResponderInterface> $rpcResponders
      */
     public Map $rpcResponders;
 
@@ -26,7 +26,7 @@ readonly class WebSocketRPCResponderAggregate
         $this->rpcResponders = new Map();
     }
 
-    public function selectResponder(RPCMessage $rpcMessage): WebSocketRPCResponderInterface
+    public function selectResponder(JsonRPCMessage $rpcMessage): WebSocketJsonRPCResponderInterface
     {
         if (!$this->rpcResponders->hasKey($rpcMessage->method)) {
             throw new DomainException('There is no responder registered for RPC method: '.$rpcMessage->method->getValue());
diff --git a/src/WebSocketRPCResponderInterface.php b/src/WebSocketJsonRPCResponderInterface.php
similarity index 73%
rename from src/WebSocketRPCResponderInterface.php
rename to src/WebSocketJsonRPCResponderInterface.php
index 904a745413d16cc8e8f42163a93d15a1d00ea497..48d2e46251a27f96575b5f7783ee5b97f8936ce6 100644
--- a/src/WebSocketRPCResponderInterface.php
+++ b/src/WebSocketJsonRPCResponderInterface.php
@@ -7,7 +7,7 @@ namespace Distantmagic\Resonance;
 /**
  * @template TPayload
  */
-interface WebSocketRPCResponderInterface extends ConstraintSourceInterface
+interface WebSocketJsonRPCResponderInterface extends ConstraintSourceInterface
 {
     public function onBeforeMessage(
         WebSocketAuthResolution $webSocketAuthResolution,
@@ -20,20 +20,20 @@ interface WebSocketRPCResponderInterface extends ConstraintSourceInterface
     ): void;
 
     /**
-     * @param RPCNotification<TPayload> $rpcNotification
+     * @param JsonRPCNotification<TPayload> $rpcNotification
      */
     public function onNotification(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCNotification $rpcNotification,
+        JsonRPCNotification $rpcNotification,
     ): void;
 
     /**
-     * @param RPCRequest<TPayload> $rpcRequest
+     * @param JsonRPCRequest<TPayload> $rpcRequest
      */
     public function onRequest(
         WebSocketAuthResolution $webSocketAuthResolution,
         WebSocketConnection $webSocketConnection,
-        RPCRequest $rpcRequest,
+        JsonRPCRequest $rpcRequest,
     ): void;
 }
diff --git a/src/WebSocketProtocol.php b/src/WebSocketProtocol.php
index f7528316079878e01113c4c4ff4785d3fc355717..ce666d8c76b2c0941d8bf1e3336150fb223f000c 100644
--- a/src/WebSocketProtocol.php
+++ b/src/WebSocketProtocol.php
@@ -6,5 +6,5 @@ namespace Distantmagic\Resonance;
 
 enum WebSocketProtocol: string
 {
-    case RPC = 'dm-rpc';
+    case JsonRPC = 'jsonrpc';
 }
diff --git a/src/WebSocketProtocolController/RPCProtocolController.php b/src/WebSocketProtocolController/JsonRPCProtocolController.php
similarity index 85%
rename from src/WebSocketProtocolController/RPCProtocolController.php
rename to src/WebSocketProtocolController/JsonRPCProtocolController.php
index d7450c940a3f04fbbadc1ebca23850e3793b73de..832415aa2125cfb14eb57790bd70d153f1a1c5f4 100644
--- a/src/WebSocketProtocolController/RPCProtocolController.php
+++ b/src/WebSocketProtocolController/JsonRPCProtocolController.php
@@ -12,7 +12,7 @@ use Distantmagic\Resonance\ConstraintResultErrorMessage;
 use Distantmagic\Resonance\CSRFManager;
 use Distantmagic\Resonance\Feature;
 use Distantmagic\Resonance\Gatekeeper;
-use Distantmagic\Resonance\InputValidator\RPCMessageValidator;
+use Distantmagic\Resonance\InputValidator\JsonRPCMessageValidator;
 use Distantmagic\Resonance\InputValidatorController;
 use Distantmagic\Resonance\JsonSerializer;
 use Distantmagic\Resonance\SingletonCollection;
@@ -20,12 +20,12 @@ use Distantmagic\Resonance\SiteAction;
 use Distantmagic\Resonance\WebSocketAuthResolution;
 use Distantmagic\Resonance\WebSocketConnection;
 use Distantmagic\Resonance\WebSocketConnectionStatus;
+use Distantmagic\Resonance\WebSocketJsonRPCConnectionControllerInterface;
+use Distantmagic\Resonance\WebSocketJsonRPCConnectionHandle;
+use Distantmagic\Resonance\WebSocketJsonRPCResponderAggregate;
 use Distantmagic\Resonance\WebSocketProtocol;
 use Distantmagic\Resonance\WebSocketProtocolController;
 use Distantmagic\Resonance\WebSocketProtocolException;
-use Distantmagic\Resonance\WebSocketRPCConnectionControllerInterface;
-use Distantmagic\Resonance\WebSocketRPCConnectionHandle;
-use Distantmagic\Resonance\WebSocketRPCResponderAggregate;
 use Ds\Map;
 use JsonException;
 use Psr\Http\Message\ServerRequestInterface;
@@ -35,13 +35,13 @@ use Swoole\WebSocket\Frame;
 use Swoole\WebSocket\Server;
 use Throwable;
 
-#[ControlsWebSocketProtocol(WebSocketProtocol::RPC)]
+#[ControlsWebSocketProtocol(WebSocketProtocol::JsonRPC)]
 #[GrantsFeature(Feature::WebSocket)]
 #[Singleton(collection: SingletonCollection::WebSocketProtocolController)]
-final readonly class RPCProtocolController extends WebSocketProtocolController
+final readonly class JsonRPCProtocolController extends WebSocketProtocolController
 {
     /**
-     * @var Map<int, WebSocketRPCConnectionHandle>
+     * @var Map<int, WebSocketJsonRPCConnectionHandle>
      */
     private Map $connectionHandles;
 
@@ -50,14 +50,14 @@ final readonly class RPCProtocolController extends WebSocketProtocolController
         private AuthenticatedUserStoreAggregate $authenticatedUserStoreAggregate,
         private Gatekeeper $gatekeeper,
         private InputValidatorController $inputValidatorController,
+        private JsonRPCMessageValidator $rpcMessageValidator,
         private JsonSerializer $jsonSerializer,
         private LoggerInterface $logger,
-        private RPCMessageValidator $rpcMessageValidator,
-        private WebSocketRPCResponderAggregate $webSocketRPCResponderAggregate,
-        private ?WebSocketRPCConnectionControllerInterface $webSocketRPCConnectionController = null,
+        private WebSocketJsonRPCResponderAggregate $webSocketJsonRPCResponderAggregate,
+        private ?WebSocketJsonRPCConnectionControllerInterface $webSocketJsonRPCConnectionController = null,
     ) {
         /**
-         * @var Map<int, WebSocketRPCConnectionHandle>
+         * @var Map<int, WebSocketJsonRPCConnectionHandle>
          */
         $this->connectionHandles = new Map();
     }
@@ -85,7 +85,7 @@ final readonly class RPCProtocolController extends WebSocketProtocolController
         $user = $this->authenticatedUserStoreAggregate->getAuthenticatedUser($request);
 
         return new WebSocketAuthResolution(
-            $this->gatekeeper->withUser($user)->can(SiteAction::StartWebSocketRPCConnection),
+            $this->gatekeeper->withUser($user)->can(SiteAction::StartWebSocketJsonRPCConnection),
             $user,
         );
     }
@@ -104,7 +104,7 @@ final readonly class RPCProtocolController extends WebSocketProtocolController
         $connectionHandle->webSocketConnection->status = WebSocketConnectionStatus::Closed;
         $connectionHandle->onClose();
 
-        $this->webSocketRPCConnectionController?->onClose(
+        $this->webSocketJsonRPCConnectionController?->onClose(
             $connectionHandle->webSocketAuthResolution,
             $connectionHandle->webSocketConnection,
         );
@@ -133,13 +133,13 @@ final readonly class RPCProtocolController extends WebSocketProtocolController
     public function onOpen(Server $server, int $fd, WebSocketAuthResolution $webSocketAuthResolution): void
     {
         $webSocketConnection = new WebSocketConnection($server, $fd);
-        $connectionHandle = new WebSocketRPCConnectionHandle(
-            $this->webSocketRPCResponderAggregate,
+        $connectionHandle = new WebSocketJsonRPCConnectionHandle(
+            $this->webSocketJsonRPCResponderAggregate,
             $webSocketAuthResolution,
             $webSocketConnection,
         );
 
-        $this->webSocketRPCConnectionController?->onOpen(
+        $this->webSocketJsonRPCConnectionController?->onOpen(
             $webSocketAuthResolution,
             $webSocketConnection,
         );
@@ -147,7 +147,7 @@ final readonly class RPCProtocolController extends WebSocketProtocolController
         $this->connectionHandles->put($fd, $connectionHandle);
     }
 
-    private function getFrameController(Frame $frame): WebSocketRPCConnectionHandle
+    private function getFrameController(Frame $frame): WebSocketJsonRPCConnectionHandle
     {
         if (!$this->connectionHandles->hasKey($frame->fd)) {
             throw new RuntimeException(sprintf(
diff --git a/src/WebSocketProtocolException/UnexpectedNotification.php b/src/WebSocketProtocolException/UnexpectedNotification.php
index e6f1f39ae7dc63cabfd38f82cd6041a9338da643..d0a0e2b3bd86d794d39245430d8af8a900ffaea3 100644
--- a/src/WebSocketProtocolException/UnexpectedNotification.php
+++ b/src/WebSocketProtocolException/UnexpectedNotification.php
@@ -4,12 +4,12 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance\WebSocketProtocolException;
 
-use Distantmagic\Resonance\RPCMethodInterface;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
 use Distantmagic\Resonance\WebSocketProtocolException;
 
 class UnexpectedNotification extends WebSocketProtocolException
 {
-    public function __construct(RPCMethodInterface $rpcMethod)
+    public function __construct(JsonRPCMethodInterface $rpcMethod)
     {
         parent::__construct('RPC method must expect a notification: '.$rpcMethod->getValue());
     }
diff --git a/src/WebSocketProtocolException/UnexpectedRequest.php b/src/WebSocketProtocolException/UnexpectedRequest.php
index 4e3d64f8be53d88b1d8969efb972db53ea6cc327..870ec1883fdacf64cd352d331d183fed34ef8790 100644
--- a/src/WebSocketProtocolException/UnexpectedRequest.php
+++ b/src/WebSocketProtocolException/UnexpectedRequest.php
@@ -4,12 +4,12 @@ declare(strict_types=1);
 
 namespace Distantmagic\Resonance\WebSocketProtocolException;
 
-use Distantmagic\Resonance\RPCMethodInterface;
+use Distantmagic\Resonance\JsonRPCMethodInterface;
 use Distantmagic\Resonance\WebSocketProtocolException;
 
 class UnexpectedRequest extends WebSocketProtocolException
 {
-    public function __construct(RPCMethodInterface $rpcMethod)
+    public function __construct(JsonRPCMethodInterface $rpcMethod)
     {
         parent::__construct('RPC method must not expect a response: '.$rpcMethod->getValue());
     }
diff --git a/src/WebSocketProtocolIteratorTest.php b/src/WebSocketProtocolIteratorTest.php
index 727baffb87cea2188fe492369bf5d6194cdd2a22..dec58bb48ab9770277dfbb37179382881a37247a 100644
--- a/src/WebSocketProtocolIteratorTest.php
+++ b/src/WebSocketProtocolIteratorTest.php
@@ -15,11 +15,11 @@ final class WebSocketProtocolIteratorTest extends TestCase
 {
     public function test_iterates_over_protocol_values(): void
     {
-        $iter = new WebSocketProtocolIterator(' foo,         dm-rpc,bar, baz');
+        $iter = new WebSocketProtocolIterator(' foo,         jsonrpc,bar, baz');
         $values = iterator_to_array($iter);
 
         self::assertCount(1, $values);
         self::assertContainsOnlyInstancesOf(WebSocketProtocol::class, $values);
-        self::assertEquals(WebSocketProtocol::RPC, $values[0]);
+        self::assertEquals(WebSocketProtocol::JsonRPC, $values[0]);
     }
 }