riffer-rig 0.12.0 → 0.14.0

data/lib/riffer/rig/acp/mapper.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::ACP::Mapper
+  extend self
+
+  TOOL_KINDS = {
+    'read' => ::ACP::Types::ToolKind::READ,
+    'write' => ::ACP::Types::ToolKind::EDIT,
+    'edit' => ::ACP::Types::ToolKind::EDIT,
+    'bash' => ::ACP::Types::ToolKind::EXECUTE
+  }.freeze #: Hash[String, String]
+
+  CONFIRMED = 'yes' #: String
+  CONFIRM_OPTIONS = [
+    ::ACP::Types::PermissionOption.new(
+      option_id: CONFIRMED, name: 'Yes', kind: ::ACP::Types::PermissionOptionKind::ALLOW_ONCE
+    ),
+    ::ACP::Types::PermissionOption.new(option_id: 'no', name: 'No', kind: ::ACP::Types::PermissionOptionKind::REJECT_ONCE)
+  ].freeze #: Array[::ACP::Types::PermissionOption]
+  ANSWER_FIELD = 'answer' #: String
+
+  # Text and resource links are ACP's must-support prompt blocks; the client
+  # cannot send the others unless the agent advertised them.
+  # @rbs blocks: Array[::ACP::Types::ContentBlock::t]
+  # @rbs return: String
+  def prompt_text(blocks)
+    blocks.filter_map { |block| prompt_text_of(block) }.join("\n\n")
+  end
+
+  # @rbs content: String
+  # @rbs return: ::ACP::Types::SessionUpdate::AgentMessageChunk
+  def message_chunk(content)
+    ::ACP::Types::SessionUpdate::AgentMessageChunk.new(content: text_block(content))
+  end
+
+  # @rbs text: String
+  # @rbs return: ::ACP::Types::SessionUpdate::AgentMessageChunk
+  def notice(text)
+    # ACP has no update for a notice, and without blank lines around it a
+    # notice runs into the reply and into the next notice.
+    message_chunk("\n\n#{text}\n\n")
+  end
+
+  # @rbs return: ::ACP::Types::SessionUpdate::AgentMessageChunk
+  def job_exit
+    # ACP has no update for a job exit notice, and without a break the replies
+    # either side of one read as a single message.
+    message_chunk("\n\n")
+  end
+
+  # @rbs completion: Riffer::Rig::Runtime::JobCompletion
+  # @rbs return: ::ACP::Types::SessionUpdate::AgentMessageChunk
+  def job_completion(completion)
+    notice("Background job #{completion.job_id} #{ending(completion)}: #{completion.command}")
+  end
+
+  # @rbs message: Hash[Symbol, untyped]
+  # @rbs return: ::ACP::Types::SessionUpdate::t?
+  def replay_of(message)
+    return job_exit if message[Riffer::Rig::Runtime::JobNotification::MARKER]
+
+    case message[:role]
+    when 'user' then ::ACP::Types::SessionUpdate::UserMessageChunk.new(content: text_block(message[:content].to_s))
+    when 'assistant' then message_chunk(message[:content].to_s) unless message[:content].to_s.strip.empty?
+    when 'tool' then replayed_tool_call(message)
+    end
+  end
+
+  # @rbs event: Riffer::StreamEvents::ToolCallDone
+  # @rbs return: ::ACP::Types::SessionUpdate::ToolCall
+  def tool_call(event)
+    ::ACP::Types::SessionUpdate::ToolCall.new(
+      tool_call_id: event.call_id,
+      title: "#{event.name}(#{event.arguments})",
+      name: event.name,
+      kind: TOOL_KINDS.fetch(event.name, ::ACP::Types::ToolKind::OTHER),
+      status: ::ACP::Types::ToolCallStatus::IN_PROGRESS
+    )
+  end
+
+  # @rbs event: Riffer::Rig::Events::AfterToolCall
+  # @rbs return: ::ACP::Types::SessionUpdate::ToolCallUpdate
+  def tool_call_done(event)
+    result = event.result
+    ::ACP::Types::SessionUpdate::ToolCallUpdate.new(
+      tool_call_id: event.call_id,
+      status: result.error? ? ::ACP::Types::ToolCallStatus::FAILED : ::ACP::Types::ToolCallStatus::COMPLETED,
+      content: tool_content(result.content)
+    )
+  end
+
+  # riffer's failure reasons (:error, :other, :guardrail_blocked) have no ACP
+  # counterpart; refusal is the closest signal that the turn did not complete.
+  # @rbs stop_reason: Symbol
+  # @rbs return: String
+  def stop_reason_of(stop_reason)
+    case stop_reason
+    when :completed then ::ACP::Types::StopReason::END_TURN
+    when Riffer::Rig::Runtime::INTERRUPT_CANCELLED then ::ACP::Types::StopReason::CANCELLED
+    when :max_steps then ::ACP::Types::StopReason::MAX_TURN_REQUESTS
+    else
+      stopped = Riffer::Rig::Runtime::STOPPED_WITHOUT_COMPLETING.include?(stop_reason)
+      stopped ? ::ACP::Types::StopReason::MAX_TOKENS : ::ACP::Types::StopReason::REFUSAL
+    end
+  end
+
+  # @rbs options: Array[String]
+  # @rbs return: Array[::ACP::Types::PermissionOption]
+  def choices(options)
+    options.map do |option|
+      ::ACP::Types::PermissionOption.new(
+        option_id: option, name: option, kind: ::ACP::Types::PermissionOptionKind::ALLOW_ONCE
+      )
+    end
+  end
+
+  # @rbs tool_call_id: String
+  # @rbs question: String
+  # @rbs return: ::ACP::Types::SessionUpdate::ToolCall
+  def permission_call(tool_call_id, question)
+    ::ACP::Types::SessionUpdate::ToolCall.new(
+      tool_call_id: tool_call_id,
+      title: question,
+      kind: ::ACP::Types::ToolKind::OTHER,
+      status: ::ACP::Types::ToolCallStatus::PENDING
+    )
+  end
+
+  # @rbs session_id: String
+  # @rbs tool_call_id: String
+  # @rbs question: String
+  # @rbs options: Array[::ACP::Types::PermissionOption]
+  # @rbs return: ::ACP::Types::RequestPermissionRequest
+  def permission_request(session_id, tool_call_id, question, options)
+    ::ACP::Types::RequestPermissionRequest.new(
+      session_id: session_id,
+      tool_call: ::ACP::Types::ToolCallUpdate.new(
+        tool_call_id: tool_call_id,
+        title: question,
+        kind: ::ACP::Types::ToolKind::OTHER,
+        status: ::ACP::Types::ToolCallStatus::PENDING
+      ),
+      options: options
+    )
+  end
+
+  # @rbs response: ::ACP::Types::RequestPermissionResponse | ::ACP::RequestError
+  # @rbs return: String?
+  def selected_option(response)
+    return nil unless response.is_a?(::ACP::Types::RequestPermissionResponse)
+
+    outcome = response.outcome
+    outcome.option_id if outcome.is_a?(::ACP::Types::RequestPermissionOutcome::Selected)
+  end
+
+  # @rbs tool_call_id: String
+  # @rbs selected: String?
+  # @rbs return: ::ACP::Types::SessionUpdate::ToolCallUpdate
+  def permission_done(tool_call_id, selected)
+    ::ACP::Types::SessionUpdate::ToolCallUpdate.new(
+      tool_call_id: tool_call_id,
+      status: selected ? ::ACP::Types::ToolCallStatus::COMPLETED : ::ACP::Types::ToolCallStatus::FAILED
+    )
+  end
+
+  # @rbs session_id: String
+  # @rbs question: String
+  # @rbs return: ::ACP::Types::CreateElicitationRequest
+  def elicitation_request(session_id, question)
+    ::ACP::Types::CreateElicitationRequest.new(
+      message: question,
+      mode: ::ACP::Types::CreateElicitationRequest::Mode::Form.new(
+        requested_schema: ::ACP::Types::ElicitationSchema.new(
+          type: ::ACP::Types::ElicitationSchemaType::OBJECT,
+          properties: {
+            ANSWER_FIELD => ::ACP::Types::ElicitationPropertySchema::StringPropertySchema.new(title: question)
+          },
+          required: [ANSWER_FIELD]
+        ),
+        scope: ::ACP::Types::ElicitationSessionScope.new(session_id: session_id)
+      )
+    )
+  end
+
+  # @rbs response: ::ACP::Types::CreateElicitationResponse | ::ACP::RequestError
+  # @rbs return: String?
+  def elicited_answer(response)
+    return nil unless response.is_a?(::ACP::Types::CreateElicitationResponse)
+
+    action = response.action
+    return nil unless action.is_a?(::ACP::Types::CreateElicitationResponse::Action::Accept)
+
+    answer = action.content&.fetch(ANSWER_FIELD, nil)
+    answer if answer.is_a?(String)
+  end
+
+  private
+
+  # @rbs block: ::ACP::Types::ContentBlock::t
+  # @rbs return: String?
+  def prompt_text_of(block)
+    case block
+    when ::ACP::Types::ContentBlock::Text then block.text
+    when ::ACP::Types::ContentBlock::ResourceLink then "#{block.title || block.name} #{block.uri}"
+    end
+  end
+
+  # @rbs text: String
+  # @rbs return: ::ACP::Types::ContentBlock::Text
+  def text_block(text)
+    ::ACP::Types::ContentBlock::Text.new(text: text)
+  end
+
+  # @rbs completion: Riffer::Rig::Runtime::JobCompletion
+  # @rbs return: String
+  def ending(completion)
+    exit_status = completion.exit_status
+    exit_status ? "exited with status #{exit_status}" : "was killed by SIG#{completion.signal}"
+  end
+
+  # The stored result is all a replayed call has: the arguments live in the
+  # assistant message's tool_calls, so the title is the name alone.
+  # @rbs message: Hash[Symbol, untyped]
+  # @rbs return: ::ACP::Types::SessionUpdate::ToolCall
+  def replayed_tool_call(message)
+    name = message[:name].to_s
+    ::ACP::Types::SessionUpdate::ToolCall.new(
+      tool_call_id: message[:tool_call_id].to_s,
+      title: name,
+      name: name,
+      kind: TOOL_KINDS.fetch(name, ::ACP::Types::ToolKind::OTHER),
+      status: ::ACP::Types::ToolCallStatus::COMPLETED,
+      content: tool_content(message[:content].to_s)
+    )
+  end
+
+  # @rbs text: String
+  # @rbs return: Array[::ACP::Types::ToolCallContent::t]
+  def tool_content(text)
+    [::ACP::Types::ToolCallContent::Content.new(content: text_block(text))]
+  end
+end

data/lib/riffer/rig/acp.rb

@@ -11,31 +11,29 @@ class Riffer::Rig::ACP
 
   SESSION_EXTENSION = 'acp' #: String
 
-  TOOL_KINDS = {
-    'read' => ::ACP::Types::ToolKind::READ,
-    'write' => ::ACP::Types::ToolKind::EDIT,
-    'edit' => ::ACP::Types::ToolKind::EDIT,
-    'bash' => ::ACP::Types::ToolKind::EXECUTE
-  }.freeze #: Hash[String, String]
-
   # @rbs @input: IO
   # @rbs @output: IO
   # @rbs @env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
   # @rbs @home: String
+  # @rbs @cwd: String
   # @rbs @build: ^(String, Riffer::Rig::Hosts::_Host, Hash[String, Riffer::Rig::Mcp::Declaration]) -> Riffer::Rig::Runtime
-  # @rbs @client: ::ACP::AgentConnection::_Client?
+  # @rbs @adopt: (^(String) -> Riffer::Rig::Runtime?)?
+  # @rbs @client: ::ACP::AgentConnection::Client?
   # @rbs @sessions: Hash[String, Riffer::Rig::Runtime]
   # @rbs @hosts: Hash[String, Riffer::Rig::ACP::Host]
+  # @rbs @owned: Array[Riffer::Rig::Runtime]
   # @rbs @lock: Thread::Mutex
 
   # @rbs input: IO
   # @rbs output: IO
   # @rbs env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
   # @rbs home: String
+  # @rbs cwd: String
   # @rbs build: (^(String, Riffer::Rig::Hosts::_Host, Hash[String, Riffer::Rig::Mcp::Declaration]) -> Riffer::Rig::Runtime)?
+  # @rbs adopt: (^(String) -> Riffer::Rig::Runtime?)?
   # @rbs return: Riffer::Rig::ACP
-  def self.for(input:, output:, env:, home:, build: nil)
-    new(input: input, output: output, env: env, home: home, build: build)
+  def self.for(input:, output:, env:, home:, cwd:, build: nil, adopt: nil)
+    new(input: input, output: output, env: env, home: home, cwd: cwd, build: build, adopt: adopt)
   end
 
   # Builds the Runtime a session runs on: the client's MCP servers flow
@@ -49,42 +47,50 @@ class Riffer::Rig::ACP
   # @rbs home: String
   # @rbs return: Riffer::Rig::Runtime
   def self.build_runtime(cwd, host, servers, env:, home:)
-    extension = session_extension(servers)
     Riffer::Rig::Loader.runtime(
-      cwd: cwd, host: host, env: env, home: home, extra_extensions: extension ? [extension] : []
+      cwd: cwd, host: host, env: env, home: home, extra_extensions: session_extensions(servers)
     )
   end
 
   # @rbs servers: Hash[String, Riffer::Rig::Mcp::Declaration]
-  # @rbs return: Riffer::Rig::Extension?
-  def self.session_extension(servers)
-    return nil if servers.empty?
+  # @rbs return: Array[Riffer::Rig::Extension]
+  def self.session_extensions(servers)
+    return [] if servers.empty?
 
-    Riffer::Rig::Extension.new(SESSION_EXTENSION) do |rig|
+    extension = Riffer::Rig::Extension.new(SESSION_EXTENSION) do |rig|
       servers.each { |name, server| rig.mcp(name, command: server.command, args: server.args, env: server.env) }
     end
+    [extension]
   end
 
   # @rbs input: IO
   # @rbs output: IO
   # @rbs env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
   # @rbs home: String
+  # @rbs cwd: String
   # @rbs build: (^(String, Riffer::Rig::Hosts::_Host, Hash[String, Riffer::Rig::Mcp::Declaration]) -> Riffer::Rig::Runtime)?
+  # @rbs adopt: (^(String) -> Riffer::Rig::Runtime?)?
   # @rbs return: void
-  def initialize(input:, output:, env:, home:, build: nil)
+  def initialize(input:, output:, env:, home:, cwd:, build: nil, adopt: nil)
     @input = input
     @output = output
     @env = env
     @home = home
-    @build = build || ->(cwd, host, servers) { self.class.build_runtime(cwd, host, servers, env: @env, home: @home) }
+    @cwd = cwd
+    @build = build || lambda do |cwd, host, servers|
+      own(self.class.build_runtime(cwd, host, servers, env: @env, home: @home))
+    end
+    @adopt = adopt
     @client = nil
     @sessions = {}
     @hosts = {}
+    @owned = []
     @lock = Mutex.new
   end
 
   # Serves the connection until the client closes stdin; then the reader
   # thread ends and run returns.
+  # @rbs &block: ? (::ACP::AgentConnection) -> void
   # @rbs return: Integer
   def run
     connection = ::ACP::AgentConnection.new(
@@ -99,7 +105,16 @@ class Riffer::Rig::ACP
       self
     end
     connection.start.join
+    yield connection if block_given?
     0
+  ensure
+    # Background jobs run in process groups of their own, so only closing
+    # their Runtime stops them outliving this process. A turn still running is
+    # not waited for, so it is cancelled first to stop it starting another.
+    @lock.synchronize { @owned.dup }.each do |runtime|
+      runtime.cancel
+      runtime.close
+    end
   end
 
   # @rbs request: ::ACP::Types::NewSessionRequest
@@ -107,7 +122,7 @@ class Riffer::Rig::ACP
   def new_session(request)
     host = Riffer::Rig::ACP::Host.new(client: client)
     servers = declarations(request.mcp_servers, host)
-    runtime = @build.call(request.cwd, host, servers)
+    runtime = announcing_job_exits(@build.call(request.cwd, host, servers), host)
     @lock.synchronize do
       @sessions[runtime.id] = runtime
       @hosts[runtime.id] = host
@@ -123,41 +138,58 @@ class Riffer::Rig::ACP
     runtime = session(request.session_id)
     return ::ACP::RequestError.resource_not_found unless runtime
 
-    # @type var stop_reason: Symbol?
-    stop_reason = nil
-    runtime.prompt(prompt_text(request.prompt)) do |event|
+    commands = available_commands(runtime).to_set(&:to_h)
+    # A command that runs no turn sends no turn_end.
+    stop_reason = :completed
+    dispatch(runtime, Riffer::Rig::ACP::Mapper.prompt_text(request.prompt)) do |event|
       case event
       when Riffer::StreamEvents::TextDelta
-        client.update(request.session_id, message_chunk(event.content))
+        client.update(request.session_id, Riffer::Rig::ACP::Mapper.message_chunk(event.content))
+      when Riffer::Rig::Events::CommandOutput
+        client.update(request.session_id, Riffer::Rig::ACP::Mapper.message_chunk(event.text))
       when Riffer::StreamEvents::ToolCallDone
-        client.update(request.session_id, tool_call(event))
+        client.update(request.session_id, Riffer::Rig::ACP::Mapper.tool_call(event))
+      when Riffer::Rig::Events::AfterToolCall
+        client.update(request.session_id, Riffer::Rig::ACP::Mapper.tool_call_done(event))
+      when Riffer::Rig::Events::JobExit
+        client.update(request.session_id, Riffer::Rig::ACP::Mapper.job_exit)
       when Riffer::Rig::Events::TurnEnd
         stop_reason = event.stop_reason
       end
     end
-    ::ACP::Types::PromptResponse.new(stop_reason: stop_reason_of(stop_reason))
-  rescue Riffer::Rig::Runtime::BusyError, Riffer::Rig::Runtime::ClosedError => e
-    ::ACP::RequestError.new(code: ::ACP::RequestError::INTERNAL_ERROR, message: e.message)
+    # A reload in the dispatch, by /reload or the automatic check, can change
+    # the commands; its rebuild also reorders them, which is no change.
+    reloaded = available_commands(runtime)
+    client.available_commands(request.session_id, reloaded) unless reloaded.to_set(&:to_h) == commands
+    ::ACP::Types::PromptResponse.new(stop_reason: Riffer::Rig::ACP::Mapper.stop_reason_of(stop_reason))
+  rescue Riffer::Rig::Runtime::BusyError
+    ::ACP::RequestError.new(
+      code: ::ACP::RequestError::INVALID_REQUEST,
+      message: 'a prompt is already running on this session; wait for it to finish or cancel it'
+    )
+  rescue StandardError => e
+    ::ACP::RequestError.new(
+      code: ::ACP::RequestError::INTERNAL_ERROR, message: Riffer::Rig::Runtime::ErrorMessage.of(e)
+    )
   end
 
-  # The host takes the session id before the build, so a build-time notify
-  # still reaches the client as an update for this session.
   # @rbs request: ::ACP::Types::LoadSessionRequest
   # @rbs return: (::ACP::Types::LoadSessionResponse | ::ACP::RequestError)
   def load_session(request)
     host = Riffer::Rig::ACP::Host.new(client: client)
-    host.session_id = request.session_id
     loader = Riffer::Rig::Loader.new(cwd: request.cwd, host: host, env: @env, home: @home)
-    runtime = loader.resume(request.session_id)
+    runtime = adopted(request.session_id) || resumed(loader, request, host)
     return ::ACP::RequestError.resource_not_found unless runtime
 
-    @lock.synchronize do
-      @sessions[request.session_id] = runtime
-      @hosts[request.session_id] = host
-    end
+    # A client need not answer a question while its own session/load is
+    # pending, and acp-sdk never times a request out, so the host takes the
+    # session id only once the build can no longer ask one.
+    host.session_id = request.session_id
+    @lock.synchronize { @sessions[request.session_id] = runtime }
     loader.messages(request.session_id)
-          .filter_map { |message| replay_of(message) }
+          .filter_map { |message| Riffer::Rig::ACP::Mapper.replay_of(message) }
           .each { |update| client.update(request.session_id, update) }
+    client.available_commands(request.session_id, available_commands(runtime))
     ::ACP::Types::LoadSessionResponse.new
   rescue StandardError => e
     ::ACP::RequestError.new(code: ::ACP::RequestError::INTERNAL_ERROR, message: e.message)
@@ -167,7 +199,7 @@ class Riffer::Rig::ACP
   # @rbs return: (::ACP::Types::ListSessionsResponse | ::ACP::RequestError)
   def list_sessions(request)
     loader = Riffer::Rig::Loader.new(
-      cwd: request.cwd || Dir.pwd,
+      cwd: request.cwd || @cwd,
       host: Riffer::Rig::Hosts::Null.new,
       env: @env,
       home: @home
@@ -186,7 +218,8 @@ class Riffer::Rig::ACP
     ::ACP::RequestError.new(code: ::ACP::RequestError::INTERNAL_ERROR, message: e.message)
   end
 
-  # Runs on the transport's reader thread, so it only sets the cancel flag.
+  # Runs on the transport's reader thread, so it asks the turn to stop and
+  # never waits for it.
   # @rbs notification: ::ACP::Types::CancelNotification
   # @rbs return: void
   def cancel(notification)
@@ -211,7 +244,7 @@ class Riffer::Rig::ACP
 
   private
 
-  # @rbs return: ::ACP::AgentConnection::_Client
+  # @rbs return: ::ACP::AgentConnection::Client
   def client
     @client or raise 'ACP agent used before ::ACP::AgentConnection.start built it'
   end
@@ -222,6 +255,59 @@ class Riffer::Rig::ACP
     @lock.synchronize { @sessions[id] }
   end
 
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs text: String
+  # @rbs &: (::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event) -> void
+  # @rbs return: void
+  def dispatch(runtime, text, &)
+    command = Riffer::Rig::Command::INVOCATION.match(text)
+    command ? runtime.run_command(command[1].to_s, command[2].to_s, &) : runtime.prompt(text, &)
+  end
+
+  # @rbs id: String
+  # @rbs return: Riffer::Rig::Runtime?
+  def adopted(id)
+    runtime = @adopt&.call(id)
+    # The Loader that built the Runtime holds this same host, so it is
+    # re-pointed in place rather than replaced.
+    case (host = runtime&.host&.host)
+    when Riffer::Rig::ACP::Host then host.client = client
+    end
+    runtime
+  end
+
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs request: ::ACP::Types::LoadSessionRequest
+  # @rbs host: Riffer::Rig::ACP::Host
+  # @rbs return: Riffer::Rig::Runtime?
+  def resumed(loader, request, host)
+    runtime = loader.resume(
+      request.session_id,
+      extra_extensions: self.class.session_extensions(declarations(request.mcp_servers, host))
+    )
+    runtime && own(announcing_job_exits(runtime, host))
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs return: Riffer::Rig::Runtime
+  def own(runtime)
+    @lock.synchronize { @owned << runtime }
+    runtime
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs host: Riffer::Rig::ACP::Host
+  # @rbs return: Riffer::Rig::Runtime
+  def announcing_job_exits(runtime, host)
+    # A prompt in flight marks the exit on its own stream when it tells the
+    # model. One starting meanwhile collects the exit from the inbox whose
+    # lock this subscriber holds, so it cannot stream ahead of this update.
+    runtime.on_job_exit do |completion|
+      host.update(Riffer::Rig::ACP::Mapper.job_completion(completion)) unless runtime.busy?
+    end
+    runtime
+  end
+
   # @rbs servers: Array[::ACP::Types::McpServer::t]
   # @rbs host: Riffer::Rig::ACP::Host
   # @rbs return: Hash[String, Riffer::Rig::Mcp::Declaration]
@@ -260,89 +346,6 @@ class Riffer::Rig::ACP
     server.env.to_h { |variable| [variable.name, variable.value] }
   end
 
-  # Text and resource links are ACP's must-support prompt blocks; the client
-  # cannot send the others unless the agent advertised them.
-  # @rbs blocks: Array[::ACP::Types::ContentBlock::t]
-  # @rbs return: String
-  def prompt_text(blocks)
-    blocks.filter_map { |block| prompt_text_of(block) }.join("\n\n")
-  end
-
-  # @rbs block: ::ACP::Types::ContentBlock::t
-  # @rbs return: String?
-  def prompt_text_of(block)
-    case block
-    when ::ACP::Types::ContentBlock::Text then block.text
-    when ::ACP::Types::ContentBlock::ResourceLink then "#{block.title || block.name} #{block.uri}"
-    end
-  end
-
-  # @rbs content: String
-  # @rbs return: ::ACP::Types::SessionUpdate::AgentMessageChunk
-  def message_chunk(content)
-    ::ACP::Types::SessionUpdate::AgentMessageChunk.new(content: text_block(content))
-  end
-
-  # @rbs text: String
-  # @rbs return: ::ACP::Types::ContentBlock::Text
-  def text_block(text)
-    ::ACP::Types::ContentBlock::Text.new(text: text)
-  end
-
-  # @rbs message: Hash[Symbol, untyped]
-  # @rbs return: ::ACP::Types::SessionUpdate::t?
-  def replay_of(message)
-    case message[:role]
-    when 'user' then ::ACP::Types::SessionUpdate::UserMessageChunk.new(content: text_block(message[:content].to_s))
-    when 'assistant' then message_chunk(message[:content].to_s)
-    when 'tool' then replayed_tool_call(message)
-    end
-  end
-
-  # The stored result is all a replayed call has: the arguments live in the
-  # assistant message's tool_calls, so the title is the name alone.
-  # @rbs message: Hash[Symbol, untyped]
-  # @rbs return: ::ACP::Types::SessionUpdate::ToolCall
-  def replayed_tool_call(message)
-    name = message[:name].to_s
-    ::ACP::Types::SessionUpdate::ToolCall.new(
-      tool_call_id: message[:tool_call_id].to_s,
-      title: name,
-      name: name,
-      kind: TOOL_KINDS.fetch(name, ::ACP::Types::ToolKind::OTHER),
-      status: ::ACP::Types::ToolCallStatus::COMPLETED,
-      content: [::ACP::Types::ToolCallContent::Content.new(content: text_block(message[:content].to_s))]
-    )
-  end
-
-  # riffer's stream has no completion boundary for a tool call, so a call goes
-  # out once, in progress, when its arguments are complete.
-  # @rbs event: Riffer::StreamEvents::ToolCallDone
-  # @rbs return: ::ACP::Types::SessionUpdate::ToolCall
-  def tool_call(event)
-    ::ACP::Types::SessionUpdate::ToolCall.new(
-      tool_call_id: event.call_id,
-      title: "#{event.name}(#{event.arguments})",
-      name: event.name,
-      kind: TOOL_KINDS.fetch(event.name, ::ACP::Types::ToolKind::OTHER),
-      status: ::ACP::Types::ToolCallStatus::IN_PROGRESS
-    )
-  end
-
-  # riffer's failure reasons (:error, :other, :guardrail_blocked) have no ACP
-  # counterpart; refusal is the closest signal that the turn did not complete.
-  # @rbs stop_reason: Symbol?
-  # @rbs return: String
-  def stop_reason_of(stop_reason)
-    case stop_reason
-    when :completed then ::ACP::Types::StopReason::END_TURN
-    when Riffer::Rig::Runtime::INTERRUPT_CANCELLED then ::ACP::Types::StopReason::CANCELLED
-    when :max_steps then ::ACP::Types::StopReason::MAX_TURN_REQUESTS
-    when :context_window, :length, :content_filter, :malformed_output then ::ACP::Types::StopReason::MAX_TOKENS
-    else ::ACP::Types::StopReason::REFUSAL
-    end
-  end
-
   # @rbs runtime: Riffer::Rig::Runtime
   # @rbs return: Array[::ACP::Types::AvailableCommand]
   def available_commands(runtime)

data/lib/riffer/rig/bundled/bash.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
 module Riffer::Rig::Bundled
-  Bash = Riffer::Rig::Extension.new('bash') { |rig| rig.tool Riffer::Rig::Tools::Bash } #: Riffer::Rig::Extension
+  Bash = Riffer::Rig::Extension.new('bash') do |rig|
+    rig.tool Riffer::Rig::Tools::Bash
+    rig.tool Riffer::Rig::Tools::Bash::Output
+    rig.tool Riffer::Rig::Tools::Bash::Kill
+  end #: Riffer::Rig::Extension
 end