acp_sdk_async 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a87705f9f7fc44a42ab713bc4122e1298c84cd5fa736bab7f605d83ee91fe493
+  data.tar.gz: 05f8fe85747082078abd8963111084d6e8d5fcac56c64afb5e7d4cc9dadf22dc
+SHA512:
+  metadata.gz: '0170289fc4f146993df1a91092643774248cfd86d806cb12ef932788462c4333da1beb24c00dda4c672b0ae3b8d3a14be6c732738ecf459f02e01f170b7218eb'
+  data.tar.gz: 361eb5a9641e852eb48d71bce99a8ca811ba50a364b497f62e13d9490c4456b34133a9e6d4bb4336c6c34e4e9a2335affdbb932e41e249b70faabda88911768f

data/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

data/README.md

@@ -0,0 +1,147 @@
+# acp_sdk_async
+
+Ruby SDK for the [Agent Client Protocol](https://agentclientprotocol.com) (ACP): typed schema models generated from the official `schema.json`, a JSON-RPC 2.0 connection over NDJSON, client- and agent-side wrappers, and helpers for spawning agents over stdio.
+
+Requires Ruby 3.2+ and runs on [`async`](https://github.com/socketry/async), the same cooperative scheduler used by Falcon. The public API is blocking (`client.prompt(...)`) like a normal Ruby method; inside a reactor those calls yield to other tasks instead of occupying a thread.
+
+## Installation
+
+```ruby
+gem "acp_sdk_async"
+```
+
+From git:
+
+```ruby
+gem "acp_sdk_async", git: "git@github.com:nutsoriginal/acp_sdk.git", branch: "main"
+```
+
+```bash
+bundle install
+```
+
+## Client: talk to an agent over stdio
+
+ACP calls must run inside an Async reactor. `Sync { ... }` starts one, or reuses the current task if you are already inside Falcon/`Async`.
+
+```ruby
+require "acp_sdk_async"
+
+S = ACP::Schema
+
+class MyClient
+  def session_update(notification)
+    update = notification.update
+    print update.content.text if update.is_a?(S::AgentMessageChunk)
+  end
+
+  def request_permission(request)
+    option = request.options.find { |candidate| candidate.kind.start_with?("allow") }
+    return S::RequestPermissionResponse.new(outcome: S::DeniedOutcome.new) if option.nil?
+
+    S::RequestPermissionResponse.new(outcome: S::AllowedOutcome.new(option_id: option.option_id))
+  end
+end
+
+Sync do
+  process = ACP::Stdio.spawn_agent("my-agent", "--acp", cwd: Dir.pwd, stderr: :log)
+  client = process.connect(MyClient.new)
+
+  client.initialize_agent(client_info: S::Implementation.new(name: "my-client", version: "1.0"))
+  session = client.new_session(cwd: Dir.pwd)
+  response = client.prompt(
+    session_id: session.session_id,
+    prompt: [S::TextContentBlock.new(text: "Hello!")]
+  )
+  puts response.stop_reason
+
+  client.close
+  process.close
+end
+```
+
+`ACP::Client::Connection` exposes every agent method (`initialize_agent`, `authenticate`, `new_session`, `load_session`, `list_sessions`, `fork_session`, `resume_session`, `set_session_mode`, `set_session_config_option`, `prompt`, `cancel`, `logout`, `ext_method`, `ext_notification`, ...). Request arguments are keyword arguments matching the schema fields in snake_case; responses come back as typed models.
+
+The client handler receives typed models too: `session_update(S::SessionNotification)`, `request_permission(S::RequestPermissionRequest)`, `read_text_file`, `write_text_file`, `create_terminal`, `terminal_output`, `release_terminal`, `wait_for_terminal_exit`, `kill_terminal`, `create_elicitation`, `complete_elicitation`, `ext_method(name, params)`, `ext_notification(name, params)`. Methods the handler does not implement return `method not found` to the peer.
+
+Incoming requests run as child tasks so a handler can call back into the peer without deadlocking. Notifications are delivered in order on a single task. After `prompt` returns, queued `session/update` handlers have already finished.
+
+## Agent: serve the protocol over stdin/stdout
+
+```ruby
+require "acp_sdk_async"
+
+S = ACP::Schema
+
+class EchoAgent
+  def on_connect(connection)
+    @connection = connection
+  end
+
+  def initialize_acp(request)
+    S::InitializeResponse.new(
+      protocol_version: request.protocol_version,
+      agent_info: S::Implementation.new(name: "echo-agent", version: "0.1")
+    )
+  end
+
+  def new_session(_request)
+    S::NewSessionResponse.new(session_id: SecureRandom.uuid)
+  end
+
+  def prompt(request)
+    text = request.prompt.map { |block| block.respond_to?(:text) ? block.text : "" }.join
+    @connection.session_update(
+      session_id: request.session_id,
+      update: S::AgentMessageChunk.new(content: S::TextContentBlock.new(text: text.reverse))
+    )
+    S::PromptResponse.new(stop_reason: "end_turn")
+  end
+
+  def cancel(_notification); end
+end
+
+ACP::Agent.run_agent(EchoAgent.new)
+```
+
+`run_agent` starts the reactor with `Sync` and listens until stdin closes. The ACP `initialize` method maps to `initialize_acp` on the agent handler so it does not collide with Ruby's constructor. Every other method keeps its snake_case name (`new_session`, `load_session`, `prompt`, `cancel`, `set_session_mode`, ...).
+
+## Schema models
+
+`ACP::Schema` contains a class for every definition in the ACP schema. Models accept snake_case keyword arguments, serialize to camelCase JSON with `to_h`/`to_json`, and parse with `from_hash`. Unions (`ContentBlock`, `SessionUpdate`, `ToolCallContent`, ...) resolve to the right variant automatically; enums and required fields are validated on construction and on parse.
+
+```ruby
+block = ACP::Schema::ContentBlock.from_hash({ "type" => "text", "text" => "hi" })
+block.class        # => ACP::Schema::TextContentBlock
+block.to_h         # => { "type" => "text", "text" => "hi" }
+```
+
+`ACP::PROTOCOL_VERSION`, `ACP::AGENT_METHODS`, `ACP::CLIENT_METHODS` and `ACP::PROTOCOL_METHODS` mirror the official `meta.json`.
+
+## Lower level
+
+`ACP::Connection` is the transport-agnostic JSON-RPC layer (requests with optional timeouts, ordered notification delivery, observers for tracing traffic). `ACP::NdjsonTransport` wraps a pair of IO objects; `ACP::MemoryTransport.pair` gives two in-memory ends for tests.
+
+Logging goes through `ACP.logger` (a `Logger`, `WARN` level by default); assign your own to integrate with the host application.
+
+## Updating the schema
+
+`schema/schema.json`, `schema/meta.json` and `schema/VERSION` are vendored from the [ACP repository](https://github.com/agentclientprotocol/agent-client-protocol). After replacing them run:
+
+```bash
+bundle exec rake gen_schema
+bundle exec rake test
+```
+
+`lib/acp/schema.rb` and `lib/acp/meta.rb` are generated files; do not edit them by hand.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+## License
+
+This project is dedicated to the public domain under the [Unlicense](https://unlicense.org). You may use, copy, modify, and distribute the code without restriction.

data/lib/acp/agent.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require_relative "connection"
+require_relative "meta"
+require_relative "router"
+require_relative "schema"
+require_relative "transport"
+require_relative "wait"
+
+module ACP
+  module Agent
+    class Connection
+      attr_reader :conn, :agent
+
+      def initialize(agent, transport, **connection_options)
+        @agent = agent
+        router = self.class.build_router(agent)
+        @conn = ACP::Connection.new(router.method(:call), transport, **connection_options)
+        agent.on_connect(self) if agent.respond_to?(:on_connect)
+      end
+
+      def self.build_router(agent)
+        router = Router.new
+
+        router.route_request(AGENT_METHODS["initialize"], Schema::InitializeRequest, agent, :initialize_acp)
+        router.route_request(AGENT_METHODS["authenticate"], Schema::AuthenticateRequest, agent, :authenticate,
+                             normalize: true)
+        router.route_request(AGENT_METHODS["session_new"], Schema::NewSessionRequest, agent, :new_session)
+        router.route_request(AGENT_METHODS["session_load"], Schema::LoadSessionRequest, agent, :load_session,
+                             normalize: true)
+        router.route_request(AGENT_METHODS["session_list"], Schema::ListSessionsRequest, agent, :list_sessions)
+        router.route_request(AGENT_METHODS["session_fork"], Schema::ForkSessionRequest, agent, :fork_session)
+        router.route_request(AGENT_METHODS["session_resume"], Schema::ResumeSessionRequest, agent, :resume_session)
+        router.route_request(AGENT_METHODS["session_close"], Schema::CloseSessionRequest, agent, :close_session,
+                             normalize: true)
+        router.route_request(AGENT_METHODS["session_delete"], Schema::DeleteSessionRequest, agent, :delete_session,
+                             normalize: true)
+        router.route_request(AGENT_METHODS["session_set_mode"], Schema::SetSessionModeRequest, agent,
+                             :set_session_mode, normalize: true)
+        router.route_request(AGENT_METHODS["session_set_config_option"], Schema::SetSessionConfigOptionRequest, agent,
+                             :set_session_config_option, :set_config_option, normalize: true)
+        router.route_request(AGENT_METHODS["session_prompt"], Schema::PromptRequest, agent, :prompt)
+        router.route_request(AGENT_METHODS["logout"], Schema::LogoutRequest, agent, :logout, normalize: true)
+        router.route_request(AGENT_METHODS["providers_list"], Schema::ListProvidersRequest, agent, :list_providers)
+        router.route_request(AGENT_METHODS["providers_set"], Schema::SetProviderRequest, agent, :set_provider,
+                             normalize: true)
+        router.route_request(AGENT_METHODS["providers_disable"], Schema::DisableProviderRequest, agent,
+                             :disable_provider, normalize: true)
+        router.route_request(AGENT_METHODS["mcp_message"], Schema::MessageMcpRequest, agent, :mcp_message)
+
+        router.route_notification(AGENT_METHODS["session_cancel"], Schema::CancelNotification, agent,
+                                  :cancel, :cancel_session)
+
+        router.on_extension_request do |name, params|
+          raise RequestError.method_not_found("_#{name}") unless agent.respond_to?(:ext_method)
+
+          agent.ext_method(name, params)
+        end
+
+        router.on_extension_notification do |name, params|
+          agent.ext_notification(name, params) if agent.respond_to?(:ext_notification)
+        end
+
+        router
+      end
+
+      def listen
+        @conn.listen
+      end
+
+      def start
+        @conn.start
+      end
+
+      def join(timeout = nil)
+        @conn.join(timeout)
+      end
+
+      def add_observer(callable = nil, &block)
+        @conn.add_observer(callable, &block)
+      end
+
+      def close
+        @conn.close
+      end
+
+      def closed?
+        @conn.closed?
+      end
+
+      def session_update(session_id:, update:, **meta)
+        notify(CLIENT_METHODS["session_update"], Schema::SessionNotification, session_id: session_id, update: update, **meta)
+      end
+
+      def request_permission(session_id:, tool_call:, options:, **meta)
+        request(
+          CLIENT_METHODS["session_request_permission"], Schema::RequestPermissionRequest,
+          Schema::RequestPermissionResponse,
+          session_id: session_id, tool_call: tool_call, options: options, **meta
+        )
+      end
+
+      def read_text_file(session_id:, path:, line: nil, limit: nil, **meta)
+        request(
+          CLIENT_METHODS["fs_read_text_file"], Schema::ReadTextFileRequest, Schema::ReadTextFileResponse,
+          session_id: session_id, path: path, line: line, limit: limit, **meta
+        )
+      end
+
+      def write_text_file(session_id:, path:, content:, **meta)
+        request(
+          CLIENT_METHODS["fs_write_text_file"], Schema::WriteTextFileRequest, Schema::WriteTextFileResponse,
+          session_id: session_id, path: path, content: content, **meta
+        )
+      end
+
+      def create_terminal(session_id:, command:, args: nil, cwd: nil, env: nil, output_byte_limit: nil, **meta)
+        request(
+          CLIENT_METHODS["terminal_create"], Schema::CreateTerminalRequest, Schema::CreateTerminalResponse,
+          session_id: session_id, command: command, args: args, cwd: cwd, env: env,
+          output_byte_limit: output_byte_limit, **meta
+        )
+      end
+
+      def terminal_output(session_id:, terminal_id:, **meta)
+        request(
+          CLIENT_METHODS["terminal_output"], Schema::TerminalOutputRequest, Schema::TerminalOutputResponse,
+          session_id: session_id, terminal_id: terminal_id, **meta
+        )
+      end
+
+      def release_terminal(session_id:, terminal_id:, **meta)
+        request(
+          CLIENT_METHODS["terminal_release"], Schema::ReleaseTerminalRequest, Schema::ReleaseTerminalResponse,
+          session_id: session_id, terminal_id: terminal_id, **meta
+        )
+      end
+
+      def wait_for_terminal_exit(session_id:, terminal_id:, **meta)
+        request(
+          CLIENT_METHODS["terminal_wait_for_exit"], Schema::WaitForTerminalExitRequest,
+          Schema::WaitForTerminalExitResponse,
+          session_id: session_id, terminal_id: terminal_id, **meta
+        )
+      end
+
+      def kill_terminal(session_id:, terminal_id:, **meta)
+        request(
+          CLIENT_METHODS["terminal_kill"], Schema::KillTerminalRequest, Schema::KillTerminalResponse,
+          session_id: session_id, terminal_id: terminal_id, **meta
+        )
+      end
+
+      def create_elicitation(request)
+        payload = Schema::CreateElicitationRequest.coerce(request)
+        result = @conn.send_request(CLIENT_METHODS["elicitation_create"], payload)
+        Schema::CreateElicitationResponse.coerce(result || {})
+      end
+
+      def complete_elicitation(elicitation_id:, **meta)
+        notify(CLIENT_METHODS["elicitation_complete"], Schema::CompleteElicitationNotification,
+               elicitation_id: elicitation_id, **meta)
+      end
+
+      def ext_method(name, params = {})
+        @conn.send_request("_#{name}", params)
+      end
+
+      def ext_notification(name, params = {})
+        @conn.send_notification("_#{name}", params)
+      end
+
+      private
+
+      def request(method, request_class, response_class, **kwargs)
+        payload = build(request_class, kwargs)
+        result = @conn.send_request(method, payload)
+        response_class.coerce(result || {})
+      end
+
+      def notify(method, request_class, **kwargs)
+        @conn.send_notification(method, build(request_class, kwargs))
+      end
+
+      def build(request_class, kwargs)
+        meta = kwargs.delete(:field_meta) || kwargs.delete(:meta)
+        model = request_class.new(**kwargs.compact)
+        model.field_meta = meta if meta
+        model
+      end
+    end
+
+    def self.run_agent(agent, input: $stdin, output: $stdout, **connection_options)
+      input, output = Stdio.stdio_streams(input, output)
+      transport = NdjsonTransport.new(input, output)
+      connection = Connection.new(agent, transport, **connection_options)
+      Sync { connection.listen }
+      connection
+    end
+  end
+end

data/lib/acp/client.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require_relative "connection"
+require_relative "meta"
+require_relative "router"
+require_relative "schema"
+
+module ACP
+  module Client
+    class Connection
+      DEFAULT_DRAIN_TIMEOUT = 1.0
+
+      attr_reader :conn, :handler
+
+      def initialize(handler, transport, drain_timeout: DEFAULT_DRAIN_TIMEOUT, **connection_options)
+        @handler = handler
+        @drain_timeout = drain_timeout
+        router = self.class.build_router(handler)
+        @conn = ACP::Connection.new(router.method(:call), transport, **connection_options)
+        handler.on_connect(self) if handler.respond_to?(:on_connect)
+      end
+
+      def self.build_router(client)
+        router = Router.new
+
+        router.route_request(CLIENT_METHODS["fs_write_text_file"], Schema::WriteTextFileRequest, client,
+                             :write_text_file, normalize: true)
+        router.route_request(CLIENT_METHODS["fs_read_text_file"], Schema::ReadTextFileRequest, client,
+                             :read_text_file)
+        router.route_request(CLIENT_METHODS["session_request_permission"], Schema::RequestPermissionRequest, client,
+                             :request_permission)
+        router.route_request(CLIENT_METHODS["terminal_create"], Schema::CreateTerminalRequest, client,
+                             :create_terminal, optional: true)
+        router.route_request(CLIENT_METHODS["terminal_output"], Schema::TerminalOutputRequest, client,
+                             :terminal_output, optional: true)
+        router.route_request(CLIENT_METHODS["terminal_release"], Schema::ReleaseTerminalRequest, client,
+                             :release_terminal, optional: true, default_result: {}, normalize: true)
+        router.route_request(CLIENT_METHODS["terminal_wait_for_exit"], Schema::WaitForTerminalExitRequest, client,
+                             :wait_for_terminal_exit, optional: true)
+        router.route_request(CLIENT_METHODS["terminal_kill"], Schema::KillTerminalRequest, client,
+                             :kill_terminal, optional: true, default_result: {}, normalize: true)
+        router.route_request(CLIENT_METHODS["elicitation_create"], Schema::CreateElicitationRequest, client,
+                             :create_elicitation, normalize: true)
+        router.route_request(CLIENT_METHODS["mcp_connect"], Schema::ConnectMcpRequest, client, :mcp_connect)
+        router.route_request(CLIENT_METHODS["mcp_message"], Schema::MessageMcpRequest, client, :mcp_message)
+        router.route_request(CLIENT_METHODS["mcp_disconnect"], Schema::DisconnectMcpRequest, client,
+                             :mcp_disconnect, normalize: true)
+
+        router.route_notification(CLIENT_METHODS["session_update"], Schema::SessionNotification, client,
+                                  :session_update)
+        router.route_notification(CLIENT_METHODS["elicitation_complete"], Schema::CompleteElicitationNotification,
+                                  client, :complete_elicitation)
+
+        router.on_extension_request do |name, params|
+          raise RequestError.method_not_found("_#{name}") unless client.respond_to?(:ext_method)
+
+          client.ext_method(name, params)
+        end
+
+        router.on_extension_notification do |name, params|
+          client.ext_notification(name, params) if client.respond_to?(:ext_notification)
+        end
+
+        router
+      end
+
+      def listen
+        @conn.listen
+      end
+
+      def start
+        @conn.start
+      end
+
+      def join(timeout = nil)
+        @conn.join(timeout)
+      end
+
+      def add_observer(callable = nil, &block)
+        @conn.add_observer(callable, &block)
+      end
+
+      def close
+        @conn.close
+      end
+
+      def closed?
+        @conn.closed?
+      end
+
+      def initialize_agent(protocol_version: PROTOCOL_VERSION, client_capabilities: nil, client_info: nil, **meta)
+        request(
+          AGENT_METHODS["initialize"], Schema::InitializeRequest, Schema::InitializeResponse,
+          protocol_version: protocol_version, client_capabilities: client_capabilities, client_info: client_info, **meta
+        )
+      end
+
+      def authenticate(method_id:, **meta)
+        request(AGENT_METHODS["authenticate"], Schema::AuthenticateRequest, Schema::AuthenticateResponse,
+                method_id: method_id, **meta)
+      end
+
+      def new_session(cwd:, mcp_servers: [], additional_directories: nil, **meta)
+        request(
+          AGENT_METHODS["session_new"], Schema::NewSessionRequest, Schema::NewSessionResponse,
+          cwd: cwd, mcp_servers: mcp_servers || [], additional_directories: additional_directories, **meta
+        )
+      end
+
+      def load_session(cwd:, session_id:, mcp_servers: [], additional_directories: nil, **meta)
+        request(
+          AGENT_METHODS["session_load"], Schema::LoadSessionRequest, Schema::LoadSessionResponse,
+          cwd: cwd, session_id: session_id, mcp_servers: mcp_servers || [],
+          additional_directories: additional_directories, **meta
+        )
+      end
+
+      def list_sessions(cwd: nil, cursor: nil, **meta)
+        request(AGENT_METHODS["session_list"], Schema::ListSessionsRequest, Schema::ListSessionsResponse,
+                cwd: cwd, cursor: cursor, **meta)
+      end
+
+      def fork_session(session_id:, cwd:, mcp_servers: nil, additional_directories: nil, **meta)
+        request(
+          AGENT_METHODS["session_fork"], Schema::ForkSessionRequest, Schema::ForkSessionResponse,
+          session_id: session_id, cwd: cwd, mcp_servers: mcp_servers,
+          additional_directories: additional_directories, **meta
+        )
+      end
+
+      def resume_session(session_id:, cwd:, mcp_servers: nil, additional_directories: nil, **meta)
+        request(
+          AGENT_METHODS["session_resume"], Schema::ResumeSessionRequest, Schema::ResumeSessionResponse,
+          session_id: session_id, cwd: cwd, mcp_servers: mcp_servers,
+          additional_directories: additional_directories, **meta
+        )
+      end
+
+      def close_session(session_id:, **meta)
+        request(AGENT_METHODS["session_close"], Schema::CloseSessionRequest, Schema::CloseSessionResponse,
+                session_id: session_id, **meta)
+      end
+
+      def delete_session(session_id:, **meta)
+        request(AGENT_METHODS["session_delete"], Schema::DeleteSessionRequest, Schema::DeleteSessionResponse,
+                session_id: session_id, **meta)
+      end
+
+      def set_session_mode(session_id:, mode_id:, **meta)
+        request(AGENT_METHODS["session_set_mode"], Schema::SetSessionModeRequest, Schema::SetSessionModeResponse,
+                session_id: session_id, mode_id: mode_id, **meta)
+      end
+
+      def set_session_config_option(session_id:, config_id:, value:, **meta)
+        request_class = if value == true || value == false
+                          Schema::SetSessionConfigOptionBooleanRequest
+                        else
+                          Schema::SetSessionConfigOptionSelectRequest
+                        end
+        request(
+          AGENT_METHODS["session_set_config_option"], request_class, Schema::SetSessionConfigOptionResponse,
+          session_id: session_id, config_id: config_id, value: value, **meta
+        )
+      end
+
+      def prompt(session_id:, prompt:, **meta)
+        request(AGENT_METHODS["session_prompt"], Schema::PromptRequest, Schema::PromptResponse,
+                session_id: session_id, prompt: prompt, **meta)
+      ensure
+        drain_notifications
+      end
+
+      def cancel(session_id:, **meta)
+        notify(AGENT_METHODS["session_cancel"], Schema::CancelNotification, session_id: session_id, **meta)
+      end
+
+      def logout(**meta)
+        request(AGENT_METHODS["logout"], Schema::LogoutRequest, Schema::LogoutResponse, **meta)
+      end
+
+      def ext_method(name, params = {})
+        @conn.send_request("_#{name}", params)
+      end
+
+      def ext_notification(name, params = {})
+        @conn.send_notification("_#{name}", params)
+      end
+
+      def drain_notifications(timeout: @drain_timeout)
+        @conn.drain_notifications(timeout: timeout)
+      end
+
+      private
+
+      def request(method, request_class, response_class, **kwargs)
+        payload = build(request_class, kwargs)
+        result = @conn.send_request(method, payload)
+        response_class.coerce(result || {})
+      end
+
+      def notify(method, request_class, **kwargs)
+        @conn.send_notification(method, build(request_class, kwargs))
+      end
+
+      def build(request_class, kwargs)
+        meta = kwargs.delete(:field_meta) || kwargs.delete(:meta)
+        model = request_class.new(**kwargs.compact)
+        model.field_meta = meta if meta
+        model
+      end
+    end
+  end
+end