acp-sdk 0.1.0 → 0.3.0

data/lib/acp/agent_process.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+# A child agent process and the ACP::ClientConnection wired to its stdio.
+# Spawn one with ACP::AgentProcess.spawn.
+class ACP::AgentProcess
+  # @rbs @connection: ACP::ClientConnection
+  # @rbs @reader: Thread
+  # @rbs @pid: Integer
+  # @rbs @stdin: IO
+  # @rbs @stdout: IO
+  # @rbs @waiter: Process::Waiter
+  # @rbs @err_r: IO?
+  # @rbs @err_reader: Thread?
+  # @rbs @stderr: String?
+
+  # @dynamic pid
+  attr_reader :pid #: Integer
+
+  # @dynamic connection
+  attr_reader :connection #: ACP::ClientConnection
+
+  # Child stderr captured when spawn was given stderr: :capture, else nil.
+  #
+  # @dynamic stderr
+  attr_reader :stderr #: String?
+
+  # Starts a command with args, env and cwd, wires its stdio to a new
+  # ACP::ClientConnection and starts it. With a block, yields the connection
+  # and this process, then terminates the child when the block exits; without
+  # one, returns the process and terminate is the caller's job.
+  #
+  # @rbs command: String
+  # @rbs *args: String
+  # @rbs env: Hash[String, String]?
+  # @rbs cwd: String?
+  # @rbs stderr: (:inherit | :capture)
+  # @rbs permission: ACP::ClientConnection::_PermissionHandler
+  # @rbs updates: ACP::ClientConnection::_UpdateHandler
+  # @rbs &block: ? (ACP::ClientConnection, ACP::AgentProcess) -> untyped
+  # @rbs return: (untyped | ACP::AgentProcess)
+  def self.spawn(
+    command,
+    *args,
+    permission:,
+    env: nil,
+    cwd: nil,
+    stderr: :inherit,
+    updates: ACP::ClientConnection::IGNORE,
+    &block
+  )
+    err_r, err_w = stderr == :capture ? IO.pipe : nil
+    opts = {} #: Hash[Symbol, untyped]
+    opts[:chdir] = cwd if cwd
+    opts[:err] = err_w if err_w
+    spawner = Open3.method(:popen2) #: _Spawner
+    stdin, stdout, waiter = spawner.call(*(env ? [env, command, *args] : [command, *args]), **opts)
+    err_w&.close
+    connection = ACP::ClientConnection.new(
+      transport: ACP::Transport::Stdio.new(input: stdout, output: stdin),
+      permission:,
+      updates:
+    )
+    process = new(connection:, reader: connection.start, stdin:, stdout:, waiter:, err_r:)
+    return process unless block
+
+    begin
+      yield connection, process
+    ensure
+      process.terminate
+    end
+  end
+
+  # Closes stdin, waits for the child to exit — sending TERM and then KILL if
+  # it will not — and joins the transport reader before closing the pipe it
+  # reads.
+  #
+  # @rbs return: void
+  def terminate
+    @stdin.close unless @stdin.closed?
+    @waiter.join(1) or signal('TERM')
+    @waiter.join(2) or signal('KILL')
+    @waiter.join(2)
+    @reader.join(1)
+    @stdout.close unless @stdout.closed?
+    @err_reader&.join(1)
+    @err_r&.close unless @err_r&.closed?
+  end
+
+  private
+
+  # @rbs connection: ACP::ClientConnection
+  # @rbs reader: Thread
+  # @rbs stdin: IO
+  # @rbs stdout: IO
+  # @rbs waiter: Process::Waiter
+  # @rbs err_r: IO?
+  # @rbs return: void
+  def initialize(connection:, reader:, stdin:, stdout:, waiter:, err_r:)
+    @connection = connection
+    @reader = reader
+    @pid = waiter.pid
+    @stdin = stdin
+    @stdout = stdout
+    @waiter = waiter
+    @err_r = err_r
+    @stderr = err_r ? +'' : nil
+    @err_reader = Thread.new { err_r.each_line { |line| @stderr&.concat(line) } } if err_r
+  end
+
+  # @rbs sig: String
+  # @rbs return: void
+  def signal(sig)
+    Process.kill(sig, @pid)
+  rescue Errno::ESRCH
+    nil
+  end
+end

data/lib/acp/client_connection.rb

@@ -33,33 +33,33 @@ class ACP::ClientConnection
   # sent by connect.
   #
   # @rbs request: ACP::Types::InitializeRequest
-  # @rbs return: ACP::Types::InitializeResponse | ACP::Transport::ResponseError
+  # @rbs return: ACP::Types::InitializeResponse | ACP::RequestError
   def connect(request)
     parse(ACP::Types::InitializeResponse, @transport.request('initialize', request.to_h))
   end
 
   # @rbs request: ACP::Types::NewSessionRequest
-  # @rbs return: ACP::Types::NewSessionResponse | ACP::Transport::ResponseError
+  # @rbs return: ACP::Types::NewSessionResponse | ACP::RequestError
   def session_new(request)
     parse(ACP::Types::NewSessionResponse, @transport.request('session/new', request.to_h))
   end
 
   # @rbs request: ACP::Types::PromptRequest
   # @rbs &block: (ACP::Types::SessionUpdate::t) -> void
-  # @rbs return: ACP::Types::PromptResponse | ACP::Transport::ResponseError
+  # @rbs return: ACP::Types::PromptResponse | ACP::RequestError
   def session_prompt(request, &)
     parse(ACP::Types::PromptResponse, stream(request.session_id, 'session/prompt', request.to_h, &))
   end
 
   # @rbs request: ACP::Types::LoadSessionRequest
   # @rbs &block: (ACP::Types::SessionUpdate::t) -> void
-  # @rbs return: ACP::Types::LoadSessionResponse | ACP::Transport::ResponseError
+  # @rbs return: ACP::Types::LoadSessionResponse | ACP::RequestError
   def session_load(request, &)
     parse(ACP::Types::LoadSessionResponse, stream(request.session_id, 'session/load', request.to_h, &))
   end
 
   # @rbs request: ACP::Types::ListSessionsRequest
-  # @rbs return: ACP::Types::ListSessionsResponse | ACP::Transport::ResponseError
+  # @rbs return: ACP::Types::ListSessionsResponse | ACP::RequestError
   def session_list(request)
     parse(ACP::Types::ListSessionsResponse, @transport.request('session/list', request.to_h))
   end
@@ -73,10 +73,12 @@ class ACP::ClientConnection
   private
 
   # @rbs type: ACP::AgentConnection::_Parser
-  # @rbs result: ACP::Transport::Result
+  # @rbs result: (Hash[String, untyped] | ACP::RequestError)
   # @rbs return: untyped
   def parse(type, result)
-    result.error || type.from_h(result.value)
+    return result if result.is_a?(ACP::RequestError)
+
+    type.from_h(result)
   end
 
   # The request waits on its own thread so the caller's thread can yield each
@@ -87,7 +89,7 @@ class ACP::ClientConnection
   # @rbs method: String
   # @rbs params: Hash[String, untyped]
   # @rbs &block: (ACP::Types::SessionUpdate::t) -> void
-  # @rbs return: ACP::Transport::Result
+  # @rbs return: (Hash[String, untyped] | ACP::RequestError)
   def stream(session_id, method, params)
     queue = Thread::Queue.new
     @lock.synchronize { @streams[session_id] = queue }
@@ -114,16 +116,12 @@ class ACP::ClientConnection
   end
 
   # @rbs params: untyped
-  # @rbs return: ACP::Transport::Result
+  # @rbs return: (ACP::Types::RequestPermissionResponse | ACP::RequestError)
   def request_permission(params)
     request = ACP::Types::RequestPermissionRequest.from_h(params)
   rescue KeyError, TypeError, NoMethodError
-    ACP::Transport::Result.error(ACP::AgentConnection::INVALID_PARAMS)
+    ACP::RequestError.invalid_params
   else
-    response = @permission.call(request)
-    case response
-    when ACP::Transport::ResponseError then ACP::Transport::Result.error(response)
-    else ACP::Transport::Result.ok(response.to_h)
-    end
+    @permission.call(request)
   end
 end

data/lib/acp/request_error.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# The schema's JSON-RPC Error object, named after the official SDKs'
+# RequestError: built by handlers and local refusals, and decoded from a
+# peer's error replies by the transport.
+class ACP::RequestError
+  PARSE_ERROR = -32_700 #: Integer
+  INVALID_REQUEST = -32_600 #: Integer
+  METHOD_NOT_FOUND = -32_601 #: Integer
+  INVALID_PARAMS = -32_602 #: Integer
+  INTERNAL_ERROR = -32_603 #: Integer
+  REQUEST_CANCELLED = -32_800 #: Integer
+  AUTH_REQUIRED = -32_000 #: Integer
+  RESOURCE_NOT_FOUND = -32_002 #: Integer
+
+  # @rbs code: Integer
+  # @rbs message: String
+  # @rbs data: untyped
+  # @rbs return: void
+  def initialize(code:, message:, data: nil)
+    @code = code
+    @message = message
+    @data = data
+    freeze
+  end
+
+  # @dynamic code
+  attr_reader :code #: Integer
+
+  # @dynamic message
+  attr_reader :message #: String
+
+  # @dynamic data
+  attr_reader :data #: untyped
+
+  # @rbs return: Hash[String, untyped]
+  def to_h
+    { 'code' => code, 'message' => message, 'data' => data }.compact
+  end
+
+  # @rbs return: ACP::RequestError
+  def self.parse_error
+    new(code: PARSE_ERROR, message: 'Parse error')
+  end
+
+  # @rbs return: ACP::RequestError
+  def self.invalid_request
+    new(code: INVALID_REQUEST, message: 'Invalid request')
+  end
+
+  # @rbs return: ACP::RequestError
+  def self.method_not_found
+    new(code: METHOD_NOT_FOUND, message: 'Method not found')
+  end
+
+  # @rbs return: ACP::RequestError
+  def self.invalid_params
+    new(code: INVALID_PARAMS, message: 'Invalid params')
+  end
+
+  # @rbs return: ACP::RequestError
+  def self.internal_error
+    new(code: INTERNAL_ERROR, message: 'Internal error')
+  end
+
+  # @rbs return: ACP::RequestError
+  def self.request_cancelled
+    new(code: REQUEST_CANCELLED, message: 'Request cancelled')
+  end
+
+  # @rbs return: ACP::RequestError
+  def self.auth_required
+    new(code: AUTH_REQUIRED, message: 'Authentication required')
+  end
+
+  # @rbs uri: String?
+  # @rbs return: ACP::RequestError
+  def self.resource_not_found(uri = nil)
+    new(code: RESOURCE_NOT_FOUND, message: 'Resource not found', data: uri && { uri: uri })
+  end
+end

data/lib/acp/transport/reply.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-# A request handler's result plus a callback the transport runs once that
-# result is on the wire, for messages the peer must only see after the reply.
+# A request handler's outcome plus a callback the transport runs once that
+# outcome is on the wire, for messages the peer must only see after the reply.
 class ACP::Transport::Reply
   # @dynamic result
-  attr_reader :result #: ACP::Transport::Result
+  attr_reader :result #: ACP::Transport::Stdio::_ToH
 
   # @dynamic after
   attr_reader :after #: ^() -> void
 
-  # @rbs result: ACP::Transport::Result
+  # @rbs result: ACP::Transport::Stdio::_ToH
   # @rbs after: ^() -> void
   # @rbs return: void
   def initialize(result, after:)

data/lib/acp/transport/stdio.rb

@@ -16,11 +16,9 @@ class ACP::Transport::Stdio
   # @rbs @next_id: Integer
   # @rbs @closed: bool
 
-  INTERNAL_ERROR = -32_603 #: Integer
-  PARSE_ERROR = ACP::Transport::ResponseError.new(code: -32_700, message: 'Parse error') #: ACP::Transport::ResponseError
-  INVALID_REQUEST = ACP::Transport::ResponseError.new(code: -32_600, message: 'Invalid request') #: ACP::Transport::ResponseError
-  METHOD_NOT_FOUND = ACP::Transport::ResponseError.new(code: -32_601, message: 'Method not found') #: ACP::Transport::ResponseError
-  CONNECTION_CLOSED = ACP::Transport::ResponseError.new(code: INTERNAL_ERROR, message: 'Connection closed') #: ACP::Transport::ResponseError
+  CONNECTION_CLOSED = ACP::RequestError.new(
+    code: ACP::RequestError::INTERNAL_ERROR, message: 'Connection closed'
+  ) #: ACP::RequestError
 
   # @rbs input: _Reader
   # @rbs output: _Writer
@@ -52,14 +50,14 @@ class ACP::Transport::Stdio
 
   # @rbs method: String
   # @rbs params: untyped
-  # @rbs return: ACP::Transport::Result
+  # @rbs return: (Hash[String, untyped] | ACP::RequestError)
   def request(method, params = nil)
     queue = Thread::Queue.new
     id = register(queue)
-    return ACP::Transport::Result.error(CONNECTION_CLOSED) unless id
+    return CONNECTION_CLOSED unless id
 
     write({ 'jsonrpc' => '2.0', 'id' => id, 'method' => method, 'params' => params }.compact)
-    queue.pop || ACP::Transport::Result.error(CONNECTION_CLOSED)
+    queue.pop || CONNECTION_CLOSED
   end
 
   # @rbs method: String
@@ -78,7 +76,7 @@ class ACP::Transport::Stdio
   def receive(line, requests, notifications)
     message = parse(line)
     case message
-    when ACP::Transport::ResponseError then reply(nil, ACP::Transport::Result.error(message))
+    when ACP::RequestError then reply(nil, message)
     else route(message, requests, notifications)
     end
   end
@@ -98,25 +96,24 @@ class ACP::Transport::Stdio
       handler = notifications[method]
       quietly { handler.call(message['params']) } if handler
     elsif message.key?('result')
-      settle(message['id'], ACP::Transport::Result.ok(message['result']))
+      settle(message['id'], message['result'])
     elsif error.is_a?(Hash) && error['code'].is_a?(Integer) && error['message'].is_a?(String)
       code, text, data = error.values_at('code', 'message', 'data')
-      response_error = ACP::Transport::ResponseError.new(code:, message: text, data:)
-      settle(message['id'], ACP::Transport::Result.error(response_error))
+      settle(message['id'], ACP::RequestError.new(code:, message: text, data:))
     else
-      reply(nil, ACP::Transport::Result.error(INVALID_REQUEST))
+      reply(nil, ACP::RequestError.invalid_request)
     end
   end
 
   # @rbs line: String
-  # @rbs return: Hash[String, untyped] | ACP::Transport::ResponseError
+  # @rbs return: Hash[String, untyped] | ACP::RequestError
   def parse(line)
-    return PARSE_ERROR unless line.valid_encoding?
+    return ACP::RequestError.parse_error unless line.valid_encoding?
 
     message = JSON.parse(line)
-    message.is_a?(Hash) ? message : INVALID_REQUEST
+    message.is_a?(Hash) ? message : ACP::RequestError.invalid_request
   rescue JSON::ParserError
-    PARSE_ERROR
+    ACP::RequestError.parse_error
   end
 
   # @rbs handler: _Handler?
@@ -125,7 +122,7 @@ class ACP::Transport::Stdio
   # @rbs return: void
   def serve(handler, id, params)
     Thread.new do
-      outcome = handler ? invoke(handler, params) : ACP::Transport::Result.error(METHOD_NOT_FOUND)
+      outcome = handler ? invoke(handler, params) : ACP::RequestError.method_not_found
       case outcome
       when ACP::Transport::Reply
         reply(id, outcome.result)
@@ -152,19 +149,25 @@ class ACP::Transport::Stdio
   #
   # @rbs handler: _Handler
   # @rbs params: untyped
-  # @rbs return: ACP::Transport::Result | ACP::Transport::Reply
+  # @rbs return: (_ToH | ACP::RequestError | ACP::Transport::Reply)
   def invoke(handler, params)
     handler.call(params)
   rescue StandardError => e
-    ACP::Transport::Result.error(ACP::Transport::ResponseError.new(code: INTERNAL_ERROR, message: e.message))
+    ACP::RequestError.new(code: ACP::RequestError::INTERNAL_ERROR, message: e.message)
   end
 
+  # The success arm is whatever the handler returned, which the transport only
+  # knows serializes with to_h; RequestError picks the error arm of the reply.
+  #
   # @rbs id: untyped
-  # @rbs result: ACP::Transport::Result
+  # @rbs outcome: (_ToH | ACP::RequestError)
   # @rbs return: void
-  def reply(id, result)
-    error = result.error
-    write({ 'jsonrpc' => '2.0', 'id' => id }.merge(error ? { 'error' => error.to_h } : { 'result' => result.value }))
+  def reply(id, outcome)
+    payload = case outcome
+              when ACP::RequestError then { 'error' => outcome.to_h }
+              else { 'result' => outcome.to_h }
+              end
+    write({ 'jsonrpc' => '2.0', 'id' => id }.merge(payload))
   end
 
   # @rbs queue: Thread::Queue
@@ -180,7 +183,7 @@ class ACP::Transport::Stdio
   end
 
   # @rbs id: untyped
-  # @rbs result: ACP::Transport::Result
+  # @rbs result: (Hash[String, untyped] | ACP::RequestError)
   # @rbs return: void
   def settle(id, result)
     @lock.synchronize { @pending.delete(id) }&.push(result)

data/lib/acp/types.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module ACP::Types
+end

data/lib/acp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ACP
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

data/sig/generated/acp/agent_connection/client.rbs

@@ -24,6 +24,55 @@ class ACP::AgentConnection::Client
   # closes.
   #
   # @rbs request: ACP::Types::RequestPermissionRequest
-  # @rbs return: ACP::Types::RequestPermissionResponse | ACP::Transport::ResponseError
-  def request_permission: (ACP::Types::RequestPermissionRequest request) -> (ACP::Types::RequestPermissionResponse | ACP::Transport::ResponseError)
+  # @rbs return: ACP::Types::RequestPermissionResponse | ACP::RequestError
+  def request_permission: (ACP::Types::RequestPermissionRequest request) -> (ACP::Types::RequestPermissionResponse | ACP::RequestError)
+
+  # @rbs request: ACP::Types::ReadTextFileRequest
+  # @rbs return: ACP::Types::ReadTextFileResponse | ACP::RequestError
+  def read_text_file: (ACP::Types::ReadTextFileRequest request) -> (ACP::Types::ReadTextFileResponse | ACP::RequestError)
+
+  # @rbs request: ACP::Types::WriteTextFileRequest
+  # @rbs return: ACP::Types::WriteTextFileResponse | ACP::RequestError
+  def write_text_file: (ACP::Types::WriteTextFileRequest request) -> (ACP::Types::WriteTextFileResponse | ACP::RequestError)
+
+  # @rbs request: ACP::Types::CreateTerminalRequest
+  # @rbs return: ACP::Types::CreateTerminalResponse | ACP::RequestError
+  def create_terminal: (ACP::Types::CreateTerminalRequest request) -> (ACP::Types::CreateTerminalResponse | ACP::RequestError)
+
+  # @rbs request: ACP::Types::TerminalOutputRequest
+  # @rbs return: ACP::Types::TerminalOutputResponse | ACP::RequestError
+  def terminal_output: (ACP::Types::TerminalOutputRequest request) -> (ACP::Types::TerminalOutputResponse | ACP::RequestError)
+
+  # @rbs request: ACP::Types::WaitForTerminalExitRequest
+  # @rbs return: ACP::Types::WaitForTerminalExitResponse | ACP::RequestError
+  def wait_for_terminal_exit: (ACP::Types::WaitForTerminalExitRequest request) -> (ACP::Types::WaitForTerminalExitResponse | ACP::RequestError)
+
+  # @rbs request: ACP::Types::KillTerminalRequest
+  # @rbs return: ACP::Types::KillTerminalResponse | ACP::RequestError
+  def kill_terminal: (ACP::Types::KillTerminalRequest request) -> (ACP::Types::KillTerminalResponse | ACP::RequestError)
+
+  # @rbs request: ACP::Types::ReleaseTerminalRequest
+  # @rbs return: ACP::Types::ReleaseTerminalResponse | ACP::RequestError
+  def release_terminal: (ACP::Types::ReleaseTerminalRequest request) -> (ACP::Types::ReleaseTerminalResponse | ACP::RequestError)
+
+  private
+
+  # @rbs rpc_method: String
+  # @rbs type: ACP::AgentConnection::_Parser
+  # @rbs request: ACP::AgentConnection::_Response
+  # @rbs return: untyped
+  def call: (String rpc_method, ACP::AgentConnection::_Parser type, ACP::AgentConnection::_Response request) -> untyped
+
+  # @rbs rpc_method: String
+  # @rbs type: ACP::AgentConnection::_Parser
+  # @rbs request: ACP::AgentConnection::_Response
+  # @rbs return: untyped
+  def terminal_call: (String rpc_method, ACP::AgentConnection::_Parser type, ACP::AgentConnection::_Response request) -> untyped
+
+  # Same method-not-found code a peer would send, but with a message that says
+  # the refusal was local, so logs can tell the two cases apart.
+  #
+  # @rbs capability: String
+  # @rbs return: ACP::RequestError
+  def unadvertised: (String capability) -> ACP::RequestError
 end

data/sig/generated/acp/agent_connection/optional_method/authenticate.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/acp/agent_connection/optional_method/authenticate.rb with RBS::Inline
+
+module ACP::AgentConnection::OptionalMethod::Authenticate
+  # @rbs return: String
+  def rpc_method: () -> String
+
+  # @rbs return: Symbol
+  def agent_method: () -> Symbol
+
+  # @rbs initialize_response: ACP::Types::InitializeResponse
+  # @rbs return: bool
+  def advertised?: (ACP::Types::InitializeResponse initialize_response) -> bool
+end

data/sig/generated/acp/agent_connection/optional_method/close_session.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/acp/agent_connection/optional_method/close_session.rb with RBS::Inline
+
+module ACP::AgentConnection::OptionalMethod::CloseSession
+  # @rbs return: String
+  def rpc_method: () -> String
+
+  # @rbs return: Symbol
+  def agent_method: () -> Symbol
+
+  # @rbs initialize_response: ACP::Types::InitializeResponse
+  # @rbs return: bool
+  def advertised?: (ACP::Types::InitializeResponse initialize_response) -> bool
+end

data/sig/generated/acp/agent_connection/optional_method/delete_session.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/acp/agent_connection/optional_method/delete_session.rb with RBS::Inline
+
+module ACP::AgentConnection::OptionalMethod::DeleteSession
+  # @rbs return: String
+  def rpc_method: () -> String
+
+  # @rbs return: Symbol
+  def agent_method: () -> Symbol
+
+  # @rbs initialize_response: ACP::Types::InitializeResponse
+  # @rbs return: bool
+  def advertised?: (ACP::Types::InitializeResponse initialize_response) -> bool
+end

data/sig/generated/acp/agent_connection/optional_method/list_sessions.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/acp/agent_connection/optional_method/list_sessions.rb with RBS::Inline
+
+module ACP::AgentConnection::OptionalMethod::ListSessions
+  # @rbs return: String
+  def rpc_method: () -> String
+
+  # @rbs return: Symbol
+  def agent_method: () -> Symbol
+
+  # @rbs initialize_response: ACP::Types::InitializeResponse
+  # @rbs return: bool
+  def advertised?: (ACP::Types::InitializeResponse initialize_response) -> bool
+end

data/sig/generated/acp/agent_connection/optional_method/load_session.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/acp/agent_connection/optional_method/load_session.rb with RBS::Inline
+
+module ACP::AgentConnection::OptionalMethod::LoadSession
+  # @rbs return: String
+  def rpc_method: () -> String
+
+  # @rbs return: Symbol
+  def agent_method: () -> Symbol
+
+  # @rbs initialize_response: ACP::Types::InitializeResponse
+  # @rbs return: bool
+  def advertised?: (ACP::Types::InitializeResponse initialize_response) -> bool
+end

data/sig/generated/acp/agent_connection/optional_method/resume_session.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/acp/agent_connection/optional_method/resume_session.rb with RBS::Inline
+
+module ACP::AgentConnection::OptionalMethod::ResumeSession
+  # @rbs return: String
+  def rpc_method: () -> String
+
+  # @rbs return: Symbol
+  def agent_method: () -> Symbol
+
+  # @rbs initialize_response: ACP::Types::InitializeResponse
+  # @rbs return: bool
+  def advertised?: (ACP::Types::InitializeResponse initialize_response) -> bool
+end

data/sig/generated/acp/agent_connection/optional_method.rbs

@@ -1,21 +1,4 @@
 # Generated from lib/acp/agent_connection/optional_method.rb with RBS::Inline
 
-class ACP::AgentConnection::OptionalMethod
-  @capability: ^(ACP::Types::AgentCapabilities) -> boolish
-
-  # @dynamic rpc_method
-  attr_reader rpc_method: String
-
-  # @dynamic agent_method
-  attr_reader agent_method: Symbol
-
-  # @rbs rpc_method: String
-  # @rbs agent_method: Symbol
-  # @rbs &capability: (ACP::Types::AgentCapabilities) -> boolish
-  # @rbs return: void
-  def initialize: (rpc_method: String, agent_method: Symbol) { (ACP::Types::AgentCapabilities) -> boolish } -> void
-
-  # @rbs capabilities: ACP::Types::AgentCapabilities
-  # @rbs return: bool
-  def advertised?: (ACP::Types::AgentCapabilities capabilities) -> bool
+module ACP::AgentConnection::OptionalMethod
 end