riffer 0.27.2 → 0.29.0

data/sig/generated/riffer/skills/config.rbs

@@ -51,7 +51,7 @@ class Riffer::Skills::Config
   # Returns the configured override when set, or +nil+ when unset. The
   # global fallback to <tt>Riffer.config.skills.default_activate_tool</tt>
   # is applied by the agent at resolution time (see
-  # Riffer::Agent.resolved_tool_classes), not by this getter.
+  # Riffer::Agent#resolve_tools), not by this getter.
   #
   # The override must be a subclass of Riffer::Tool.
   #

data/sig/generated/riffer/skills/context.rbs

@@ -5,8 +5,8 @@
 # Coordinates skill discovery, activation, and prompt rendering.
 # Tracks activations with caching to avoid redundant backend reads.
 #
-# Built by the agent at the start of generate/stream and passed to
-# tools via +context[:skills]+.
+# Built by the agent during +Agent.new+ and exposed to tools via
+# <tt>context.skills</tt> on the agent's +Riffer::Agent::Context+.
 #
 # See Riffer::Skills::Backend, Riffer::Skills::Frontmatter.
 class Riffer::Skills::Context

data/sig/generated/riffer/stream_events/interrupt.rbs

@@ -7,9 +7,14 @@ class Riffer::StreamEvents::Interrupt < Riffer::StreamEvents::Base
   # The reason provided with the interrupt, if any.
   attr_reader reason: (String | Symbol)?
 
+  # Call ids of tool_use blocks that riffer filled with placeholder
+  # results when the interrupt fired. Populated only when
+  # +Riffer.config.experimental_history_healing+ is on.
+  attr_reader healed_tool_call_ids: Array[String]
+
   # --
-  # : (?reason: (String | Symbol)?) -> void
-  def initialize: (?reason: (String | Symbol)?) -> void
+  # : (?reason: (String | Symbol)?, ?healed_tool_call_ids: Array[String]) -> void
+  def initialize: (?reason: (String | Symbol)?, ?healed_tool_call_ids: Array[String]) -> void
 
   # Converts the event to a hash.
   #

data/sig/generated/riffer/stream_events/token_usage_done.rbs

@@ -9,11 +9,11 @@
 #   event.token_usage.total_tokens   # => 150
 class Riffer::StreamEvents::TokenUsageDone < Riffer::StreamEvents::Base
   # The token usage data for this response.
-  attr_reader token_usage: Riffer::TokenUsage
+  attr_reader token_usage: Riffer::Providers::TokenUsage
 
   # --
-  # : (token_usage: Riffer::TokenUsage, ?role: Symbol) -> void
-  def initialize: (token_usage: Riffer::TokenUsage, ?role: Symbol) -> void
+  # : (token_usage: Riffer::Providers::TokenUsage, ?role: Symbol) -> void
+  def initialize: (token_usage: Riffer::Providers::TokenUsage, ?role: Symbol) -> void
 
   # --
   # : () -> Hash[Symbol, untyped]

data/sig/generated/riffer/tool.rbs

@@ -20,15 +20,15 @@
 #     end
 #   end
 class Riffer::Tool
-  extend Riffer::Toolable
+  extend Riffer::Tools::Toolable
 
   # Executes the tool with the given arguments.
   #
   # Raises NotImplementedError if not implemented by subclass.
   #
   # --
-  # : (context: Hash[Symbol, untyped]?, **untyped) -> Riffer::Tools::Response
-  def call: (context: Hash[Symbol, untyped]?, **untyped) -> Riffer::Tools::Response
+  # : (context: Riffer::Agent::Context?, **untyped) -> Riffer::Tools::Response
+  def call: (context: Riffer::Agent::Context?, **untyped) -> Riffer::Tools::Response
 
   # Creates a text response. Shorthand for Riffer::Tools::Response.text.
   #
@@ -55,6 +55,6 @@ class Riffer::Tool
   # Raises Riffer::Error if the tool does not return a Response object.
   #
   # --
-  # : (context: Hash[Symbol, untyped]?, **untyped) -> Riffer::Tools::Response
-  def call_with_validation: (context: Hash[Symbol, untyped]?, **untyped) -> Riffer::Tools::Response
+  # : (context: Riffer::Agent::Context?, **untyped) -> Riffer::Tools::Response
+  def call_with_validation: (context: Riffer::Agent::Context?, **untyped) -> Riffer::Tools::Response
 end

data/sig/generated/riffer/{tool_runtime → tools/runtime}/fibers.rbs

@@ -1,11 +1,11 @@
-# Generated from lib/riffer/tool_runtime/fibers.rb with RBS::Inline
+# Generated from lib/riffer/tools/runtime/fibers.rb with RBS::Inline
 
 # Executes tool calls concurrently using fibers via the +async+ gem.
 #
 #   class MyAgent < Riffer::Agent
-#     tool_runtime Riffer::ToolRuntime::Fibers
+#     tool_runtime Riffer::Tools::Runtime::Fibers
 #   end
-class Riffer::ToolRuntime::Fibers < Riffer::ToolRuntime
+class Riffer::Tools::Runtime::Fibers < Riffer::Tools::Runtime
   # [max_concurrency] maximum number of tool calls to execute simultaneously.
   #   When +nil+, all tool calls run as fibers without limit.
   #

data/sig/generated/riffer/{tool_runtime → tools/runtime}/inline.rbs

@@ -1,9 +1,9 @@
-# Generated from lib/riffer/tool_runtime/inline.rb with RBS::Inline
+# Generated from lib/riffer/tools/runtime/inline.rb with RBS::Inline
 
 # Executes tool calls sequentially in the current thread.
 #
 # This is the default tool runtime used when no runtime is configured.
-class Riffer::ToolRuntime::Inline < Riffer::ToolRuntime
+class Riffer::Tools::Runtime::Inline < Riffer::Tools::Runtime
   # --
   # : () -> void
   def initialize: () -> void

data/sig/generated/riffer/{tool_runtime → tools/runtime}/threaded.rbs

@@ -1,11 +1,11 @@
-# Generated from lib/riffer/tool_runtime/threaded.rb with RBS::Inline
+# Generated from lib/riffer/tools/runtime/threaded.rb with RBS::Inline
 
 # Executes tool calls concurrently using threads.
 #
 #   class MyAgent < Riffer::Agent
-#     tool_runtime Riffer::ToolRuntime::Threaded
+#     tool_runtime Riffer::Tools::Runtime::Threaded
 #   end
-class Riffer::ToolRuntime::Threaded < Riffer::ToolRuntime
+class Riffer::Tools::Runtime::Threaded < Riffer::Tools::Runtime
   DEFAULT_MAX_CONCURRENCY: Integer
 
   # [max_concurrency] maximum number of tool calls to execute simultaneously.

data/sig/generated/riffer/{tool_runtime.rbs → tools/runtime.rbs}

@@ -1,6 +1,6 @@
-# Generated from lib/riffer/tool_runtime.rb with RBS::Inline
+# Generated from lib/riffer/tools/runtime.rb with RBS::Inline
 
-# Riffer::ToolRuntime handles tool call execution for an agent.
+# Riffer::Tools::Runtime handles tool call execution for an agent.
 #
 # Composes with a Riffer::Runner for concurrency control and provides
 # +execute+ as the sole public entry point.
@@ -8,12 +8,12 @@
 # Subclass and override +dispatch_tool_call+ to customize how individual
 # tool calls are dispatched (e.g., HTTP, gRPC).
 #
-#   runtime = Riffer::ToolRuntime::Inline.new
+#   runtime = Riffer::Tools::Runtime::Inline.new
 #   results = runtime.execute(tool_calls, tools: tools, context: context)
-class Riffer::ToolRuntime
+class Riffer::Tools::Runtime
   # [runner] the concurrency runner to use for batch execution.
   #
-  # Subclasses must provide a runner; instantiating ToolRuntime directly
+  # Subclasses must provide a runner; instantiating Riffer::Tools::Runtime directly
   # raises +NotImplementedError+.
   #
   # --
@@ -25,20 +25,24 @@ class Riffer::ToolRuntime
   # [tool_calls] the tool calls to execute.
   # [tools] the resolved tool classes.
   # [context] the context hash.
+  # [assistant_message] the assistant message that produced these tool
+  #   calls, when known. Forwarded to +around_tool_call+ and
+  #   +dispatch_tool_call+ so subclasses can access it (e.g. for
+  #   instrumentation that needs the accompanying assistant text).
   #
   # --
-  # : (Array[Riffer::Messages::Assistant::ToolCall], tools: Array[singleton(Riffer::Tool)], context: Hash[Symbol, untyped]?) -> Array[[Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response]]
-  def execute: (Array[Riffer::Messages::Assistant::ToolCall], tools: Array[singleton(Riffer::Tool)], context: Hash[Symbol, untyped]?) -> Array[[ Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response ]]
+  # : (Array[Riffer::Messages::Assistant::ToolCall], tools: Array[singleton(Riffer::Tool)], context: Riffer::Agent::Context?, ?assistant_message: Riffer::Messages::Assistant?) -> Array[[Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response]]
+  def execute: (Array[Riffer::Messages::Assistant::ToolCall], tools: Array[singleton(Riffer::Tool)], context: Riffer::Agent::Context?, ?assistant_message: Riffer::Messages::Assistant?) -> Array[[ Riffer::Messages::Assistant::ToolCall, Riffer::Tools::Response ]]
 
   # Hook that wraps each tool call execution. Override in subclasses
   # to customize. Must +yield+ to continue execution.
   #
   # The default implementation simply yields.
   #
-  #   class InstrumentedRuntime < Riffer::ToolRuntime::Inline
+  #   class InstrumentedRuntime < Riffer::Tools::Runtime::Inline
   #     private
   #
-  #     def around_tool_call(tool_call, context:)
+  #     def around_tool_call(tool_call, context:, assistant_message: nil)
   #       start = Time.now
   #       result = yield
   #       Rails.logger.info("Tool #{tool_call.name} took #{Time.now - start}s")
@@ -47,8 +51,8 @@ class Riffer::ToolRuntime
   #   end
   #
   # --
-  # : (Riffer::Messages::Assistant::ToolCall, context: Hash[Symbol, untyped]?) { () -> Riffer::Tools::Response } -> Riffer::Tools::Response
-  def around_tool_call: (Riffer::Messages::Assistant::ToolCall, context: Hash[Symbol, untyped]?) { () -> Riffer::Tools::Response } -> Riffer::Tools::Response
+  # : (Riffer::Messages::Assistant::ToolCall, context: Riffer::Agent::Context?, ?assistant_message: Riffer::Messages::Assistant?) { () -> Riffer::Tools::Response } -> Riffer::Tools::Response
+  def around_tool_call: (Riffer::Messages::Assistant::ToolCall, context: Riffer::Agent::Context?, ?assistant_message: Riffer::Messages::Assistant?) { () -> Riffer::Tools::Response } -> Riffer::Tools::Response
 
   private
 
@@ -58,10 +62,12 @@ class Riffer::ToolRuntime
   # [tool_call] the tool call to execute.
   # [tools] the resolved tool classes.
   # [context] the context hash.
+  # [assistant_message] the assistant message that produced this tool
+  #   call, when known.
   #
   # --
-  # : (Riffer::Messages::Assistant::ToolCall, tools: Array[singleton(Riffer::Tool)], context: Hash[Symbol, untyped]?) -> Riffer::Tools::Response
-  def dispatch_tool_call: (Riffer::Messages::Assistant::ToolCall, tools: Array[singleton(Riffer::Tool)], context: Hash[Symbol, untyped]?) -> Riffer::Tools::Response
+  # : (Riffer::Messages::Assistant::ToolCall, tools: Array[singleton(Riffer::Tool)], context: Riffer::Agent::Context?, ?assistant_message: Riffer::Messages::Assistant?) -> Riffer::Tools::Response
+  def dispatch_tool_call: (Riffer::Messages::Assistant::ToolCall, tools: Array[singleton(Riffer::Tool)], context: Riffer::Agent::Context?, ?assistant_message: Riffer::Messages::Assistant?) -> Riffer::Tools::Response
 
   # --
   # : (String?) -> Hash[Symbol, untyped]

data/sig/generated/riffer/{toolable.rbs → tools/toolable.rbs}

@@ -1,6 +1,6 @@
-# Generated from lib/riffer/toolable.rb with RBS::Inline
+# Generated from lib/riffer/tools/toolable.rb with RBS::Inline
 
-# Riffer::Toolable provides the shared class-level DSL for anything that can
+# Riffer::Tools::Toolable provides the shared class-level DSL for anything that can
 # present as a tool to an LLM — tools today, and subagents/workflows in the
 # future.
 #
@@ -12,7 +12,7 @@
 # are NOT part of Toolable — those belong on Riffer::Tool.
 #
 #   class MyTool
-#     extend Riffer::Toolable
+#     extend Riffer::Tools::Toolable
 #
 #     description "Does something useful"
 #
@@ -20,7 +20,7 @@
 #       required :input, String
 #     end
 #   end
-module Riffer::Toolable
+module Riffer::Tools::Toolable
   DEFAULT_TIMEOUT: Integer
 
   # Tracks all classes that extend Toolable.
@@ -62,8 +62,8 @@ module Riffer::Toolable
   # Defines parameters using the Params DSL.
   #
   # --
-  # : () ?{ () -> void } -> Riffer::Params?
-  def params: () ?{ () -> void } -> Riffer::Params?
+  # : () ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?
+  def params: () ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?
 
   # Returns the JSON Schema for the tool's parameters.
   #

data/sig/stubs/agent_ivars.rbs

@@ -0,0 +1,7 @@
+# Class-level instance variable declarations for Riffer::Agent.
+#
+# The `#:` inline syntax used in lib/ can't declare class-level ivars, so we
+# stub them here instead.
+class Riffer::Agent
+  self.@config: Riffer::Agent::Config?
+end

data/sig/stubs/async.rbs

@@ -0,0 +1,24 @@
+# Minimal signatures for the optional `async` gem, which ships no RBS.
+#
+# Only the surface used by Riffer::Runner::Fibers is declared; the gem is
+# loaded lazily via depends_on, so this stub keeps Steep aware of the
+# constants without adding a hard `library` dependency.
+module Async
+  class Barrier
+    def initialize: () -> void
+
+    def async: () { () -> void } -> untyped
+
+    def wait: () -> void
+  end
+
+  class Semaphore
+    def initialize: (Integer, ?parent: untyped) -> void
+
+    def async: () { () -> void } -> untyped
+  end
+end
+
+module Kernel
+  def Async: () { () -> void } -> untyped
+end

data/sig/stubs/aws-sdk-core/seahorse_request_context.rbs

@@ -0,0 +1,7 @@
+module Seahorse
+  module Client
+    class RequestContext
+      def initialize: (operation_name: Symbol) -> void
+    end
+  end
+end

data/sig/stubs/aws-sdk-core/static_token_provider.rbs

@@ -0,0 +1,5 @@
+module Aws
+  class StaticTokenProvider
+    def initialize: (String token, ?Time? expiration) -> void
+  end
+end

data/sig/stubs/extend_self.rbs

@@ -0,0 +1,11 @@
+# rbs-inline does not emit `extend self` for modules that use it, so their
+# instance methods aren't visible as singleton methods. Reopening each module
+# here to `extend` itself restores that, matching the runtime behaviour.
+
+module Riffer::Helpers::CallOrValue
+  extend ::Riffer::Helpers::CallOrValue
+end
+
+module Riffer::Agent::Run
+  extend ::Riffer::Agent::Run
+end

data/sig/stubs/lib_ivars.rbs

@@ -0,0 +1,101 @@
+# Instance/module variable declarations for non-provider lib/ classes.
+#
+# rbs-inline's `#:` syntax types an assignment expression (a Steep assertion)
+# but doesn't declare the instance variable itself, so we stub the ivar types
+# here instead (mirrors sig/stubs/agent_ivars.rbs and provider_ivars.rbs).
+
+class Riffer::Mcp::Registration
+  @cancelled: bool
+  @tools: Array[singleton(Riffer::Tool)]
+  @mutex: Thread::Mutex
+end
+
+module Riffer::Mcp::Registry
+  self.@mutex: Thread::Mutex
+  self.@store: Hash[String, Riffer::Mcp::Registration]
+end
+
+class Riffer::Mcp::Client
+  @client: untyped
+end
+
+# Toolable is extended onto tool classes; its instance methods run as class
+# methods on the extender, which is also extended with ClassNameConverter
+# (see Toolable.extended). The include models that method availability for Steep.
+module Riffer::Tools::Toolable
+  include Riffer::Helpers::ClassNameConverter
+
+  self.@extenders: Array[Module]?
+  @description: String?
+  @identifier: String?
+  @timeout: (Integer | Float)?
+  @params_builder: Riffer::Params?
+  @kind: Symbol?
+end
+
+class Riffer::Evals::Judge
+  @provider_options: Hash[Symbol, untyped]
+  @provider_instance: Riffer::Providers::Base?
+  @provider_name: String?
+  @model_name: String?
+end
+
+class Riffer::Evals::Evaluator
+  self.@instructions: String?
+  self.@higher_is_better: bool?
+  self.@judge_model: String?
+  @judge: Riffer::Evals::Judge?
+end
+
+class Riffer::Skills::Context
+  @backend: Riffer::Skills::Backend
+  @activated: Hash[String, String]
+end
+
+class Riffer::Skills::Config
+  @backend: (Riffer::Skills::Backend | Proc)?
+  @adapter: singleton(Riffer::Skills::Adapter)?
+  @activate: (Array[String] | Proc)?
+  @activate_tool: singleton(Riffer::Tool)?
+end
+
+class Riffer::Skills::FilesystemBackend
+  @paths: Array[String]
+  @skills_cache: Hash[String, String]?
+end
+
+module Riffer
+  self.@config: Riffer::Config?
+end
+
+class Riffer::Agent::Session
+  @callbacks: Array[^(Riffer::Messages::Base) -> void]
+end
+
+class Riffer::Agent::Context
+  @data: Hash[Symbol, untyped]
+end
+
+class Riffer::Agent::Response
+  @interrupted: bool
+end
+
+class Riffer::Tools::Response
+  @success: bool
+end
+
+class Riffer::Tools::Runtime
+  @runner: Riffer::Runner
+end
+
+class Riffer::Runner::Threaded
+  @max_concurrency: Integer
+end
+
+class Riffer::Runner::Fibers
+  @max_concurrency: Integer?
+end
+
+class Riffer::Messages::FilePart
+  @url_string: String?
+end

data/sig/stubs/mcp_sdk.rbs

@@ -0,0 +1,22 @@
+# Minimal signatures for the optional `mcp` gem (v0.8+), which ships no RBS.
+#
+# Only the surface used by Riffer::Mcp::Client is declared; the gem is loaded
+# lazily via depends_on, so this stub keeps Steep aware of the constants
+# without adding a hard `library` dependency (mirrors provider_sdk_methods.rbs).
+module MCP
+  class Client
+    class HTTP
+      def initialize: (url: untyped, headers: untyped) -> void
+    end
+
+    class Tool
+      def initialize: (name: untyped, ?description: untyped, ?input_schema: untyped) -> void
+    end
+
+    def initialize: (transport: untyped) -> void
+
+    def tools: () -> untyped
+
+    def call_tool: (tool: untyped, arguments: untyped) -> untyped
+  end
+end

data/sig/stubs/provider_ivars.rbs

@@ -0,0 +1,36 @@
+# Instance variable declarations for the provider adapters.
+#
+# rbs-inline's `#:` syntax types an assignment expression (a Steep assertion)
+# but doesn't declare the instance variable itself, so we stub the ivar types
+# here instead.
+class Riffer::Providers::Base
+  @current_tools: Array[singleton(Riffer::Tool)]
+end
+
+class Riffer::Providers::Anthropic
+  @client: ::Anthropic::Client
+end
+
+class Riffer::Providers::OpenAI
+  @client: ::OpenAI::Client
+end
+
+class Riffer::Providers::OpenRouter
+  @client: ::OpenAI::Client
+end
+
+class Riffer::Providers::AmazonBedrock
+  @client: ::Aws::BedrockRuntime::Client
+end
+
+class Riffer::Providers::Gemini
+  @api_key: String?
+  @open_timeout: Integer
+  @read_timeout: Integer
+end
+
+class Riffer::Providers::Mock
+  @responses: Array[Hash[Symbol, untyped]]
+  @current_index: Integer
+  @stubbed_responses: Array[Hash[Symbol, untyped]]
+end

data/sig/stubs/provider_sdk_methods.rbs

@@ -0,0 +1,50 @@
+# Accurate signatures for SDK resource methods whose shipped RBS doesn't match
+# the real API.
+#
+# The OpenAI and Anthropic gems implement these as positional `def x(params)`
+# methods (a single options hash), but their generated RBS advertises
+# keyword-only signatures — and the Anthropic gem omits `Messages#stream`
+# altogether. The providers call them with a positional hash (`x(params)`) or a
+# keyword splat (`x(**params)`); both reach the same positional parameter at
+# runtime, so we accept either here (`| ...` extends the gem's existing
+# overloads). Streaming methods are typed to return `untyped`: the event
+# objects are a ~60-member union dispatched dynamically on `#type`, which the
+# providers (and their `untyped` event handlers) already treat as dynamic.
+module OpenAI
+  module Resources
+    class Responses
+      def create: (Hash[Symbol, untyped] params) -> OpenAI::Models::Responses::Response
+                | (**untyped) -> OpenAI::Models::Responses::Response
+                | ...
+      def stream: (Hash[Symbol, untyped] params) -> untyped
+                | (**untyped) -> untyped
+                | ...
+    end
+
+    class Chat
+      class Completions
+        def create: (Hash[Symbol, untyped] params) -> OpenAI::Models::Chat::ChatCompletion
+                  | (**untyped) -> OpenAI::Models::Chat::ChatCompletion
+                  | ...
+        def stream_raw: (Hash[Symbol, untyped] params) -> untyped
+                      | (**untyped) -> untyped
+                      | ...
+      end
+    end
+  end
+end
+
+module Anthropic
+  module Resources
+    class Messages
+      def create: (Hash[Symbol, untyped] params) -> Anthropic::Models::Message
+                | (**untyped) -> Anthropic::Models::Message
+                | ...
+
+      # Omitted from the gem's RBS; present at runtime (returns a MessageStream
+      # helper iterated with `#each` / `#accumulated_message` / `#close`).
+      def stream: (Hash[Symbol, untyped] params) -> untyped
+                | (**untyped) -> untyped
+    end
+  end
+end

data/sig/stubs/zeitwerk.rbs

@@ -0,0 +1,12 @@
+# Minimal signatures for the `zeitwerk` gem (autoloader), which ships no RBS.
+#
+# Only the surface used in lib/riffer.rb to set up the loader is declared.
+module Zeitwerk
+  class Loader
+    def self.for_gem: (*untyped) -> Zeitwerk::Loader
+
+    def inflector: () -> untyped
+
+    def setup: () -> void
+  end
+end