riffer 0.40.0 → 0.42.0

data/docs/providers/AZURE_OPENAI.md

@@ -14,9 +14,8 @@ gem 'openai'
 
 Credentials are resolved in order:
 
-1. Keyword arguments (`api_key`, `base_url`)
-2. Global config (`Riffer.config.azure_openai.api_key` / `.endpoint`)
-3. Environment variables (`AZURE_OPENAI_API_KEY` / `AZURE_OPENAI_ENDPOINT`)
+1. Global config (`Riffer.config.azure_openai.api_key` / `.endpoint`)
+2. Environment variables (`AZURE_OPENAI_API_KEY` / `AZURE_OPENAI_ENDPOINT`)
 
 ### Global config
 
@@ -27,16 +26,20 @@ Riffer.configure do |config|
 end
 ```
 
-### Per-agent
+### Custom client
+
+Azure AD token auth, timeouts, and retries are configured on your own `OpenAI::Client`. A `Proc` is the right shape for expiring AD tokens — it is resolved on every LLM call:
 
 ```ruby
-class MyAgent < Riffer::Agent
-  model 'azure_openai/gpt-5-mini'
-  provider_options api_key: ENV['AZURE_OPENAI_API_KEY'],
-                   base_url: ENV['AZURE_OPENAI_ENDPOINT']
+Riffer.configure do |config|
+  config.azure_openai.client = -> {
+    OpenAI::Client.new(api_key: AzureAd.current_token, base_url: ENV['AZURE_OPENAI_ENDPOINT'])
+  }
 end
 ```
 
+See [Configuration → Provider Clients](../CONFIGURATION.md#provider-clients).
+
 ### Environment variables only
 
 If `AZURE_OPENAI_API_KEY` and `AZURE_OPENAI_ENDPOINT` are set, no explicit configuration is needed:
@@ -151,10 +154,7 @@ end
 ## Direct Provider Usage
 
 ```ruby
-provider = Riffer::Providers::AzureOpenAI.new(
-  api_key: ENV['AZURE_OPENAI_API_KEY'],
-  base_url: ENV['AZURE_OPENAI_ENDPOINT']
-)
+provider = Riffer::Providers::AzureOpenAI.new
 
 response = provider.generate_text(
   prompt: "Hello!",

data/docs/providers/CUSTOM_PROVIDERS.md

@@ -8,14 +8,14 @@ Extend `Riffer::Providers::Base` and implement the five required hook methods:
 
 ```ruby
 class Riffer::Providers::MyProvider < Riffer::Providers::Base
-  def initialize(**options)
-    # Initialize your client
-    @api_key = options[:api_key] || ENV['MY_PROVIDER_API_KEY']
-    @client = MyProviderClient.new(api_key: @api_key)
-  end
-
   private
 
+  # Client hook — see "Client resolution" below.
+
+  def build_client
+    MyProviderClient.new(api_key: ENV['MY_PROVIDER_API_KEY'])
+  end
+
   # Hook methods (matching base.rb order)
 
   def build_request_params(messages, model, options)
@@ -35,11 +35,11 @@ class Riffer::Providers::MyProvider < Riffer::Providers::Base
   end
 
   def execute_generate(params)
-    @client.generate(**params)
+    client.generate(**params)
   end
 
   def execute_stream(params, yielder)
-    @client.stream(**params) do |chunk|
+    client.stream(**params) do |chunk|
       case chunk.type
       when :text
         yielder << Riffer::StreamEvents::TextDelta.new(chunk.content)
@@ -121,16 +121,30 @@ class Riffer::Providers::MyProvider < Riffer::Providers::Base
 end
 ```
 
+## Client resolution
+
+Riffer constructs providers with `provider_class.new`, so `initialize` takes no arguments; read credentials from configuration inside `build_client`. `Riffer::Providers::Base` provides a private `client` method for your `execute_generate`/`execute_stream` to call. It resolves, in order:
+
+1. **A configured client** — whatever `global_client` returns: a client instance, or a no-argument `Proc` resolved on **every** call. Override that hook to read the client off your own configuration; it defaults to `nil`.
+2. **A memoized client** from `build_client` — implement this hook to build your SDK client from configured credentials.
+
+This gives your provider the same "works out of the box, bring your own client in production" behavior as the built-ins. See [Configuration → Provider Clients](../CONFIGURATION.md#provider-clients).
+
 ## Using depends_on
 
 For lazy loading of external gems:
 
 ```ruby
 class Riffer::Providers::MyProvider < Riffer::Providers::Base
-  def initialize(**options)
+  def initialize
+    super
     depends_on "my_provider_gem"  # Only loaded when provider is used
+  end
+
+  private
 
-    @client = ::MyProviderGem::Client.new(**options)
+  def build_client
+    ::MyProviderGem::Client.new(api_key: ENV["MY_PROVIDER_API_KEY"])
   end
 end
 ```
@@ -291,17 +305,19 @@ end
 # lib/riffer/providers/my_provider.rb
 
 class Riffer::Providers::MyProvider < Riffer::Providers::Base
-  def initialize(**options)
+  def initialize
+    super
     depends_on "my_provider_gem"
-
-    api_key = options[:api_key] || ENV["MY_PROVIDER_API_KEY"]
-    @client = ::MyProviderGem::Client.new(api_key: api_key)
   end
 
   private
 
   # Hook methods
 
+  def build_client
+    ::MyProviderGem::Client.new(api_key: ENV["MY_PROVIDER_API_KEY"])
+  end
+
   def build_request_params(messages, model, options)
     system_message = extract_system(messages)
     conversation = messages.reject { |m| m.is_a?(Riffer::Messages::System) }
@@ -323,13 +339,13 @@ class Riffer::Providers::MyProvider < Riffer::Providers::Base
   end
 
   def execute_generate(params)
-    @client.create(**params)
+    client.create(**params)
   end
 
   def execute_stream(params, yielder)
     accumulated_text = ""
 
-    @client.stream(**params) do |event|
+    client.stream(**params) do |event|
       case event.type
       when :text_delta
         accumulated_text += event.text

data/docs/providers/GEMINI.md

@@ -12,15 +12,38 @@ Riffer.configure do |config|
 end
 ```
 
-Or per-agent:
+## HTTP Client
+
+Gemini has no vendor SDK, so riffer ships its own transport: `Riffer::Providers::Gemini::Client`. The provider builds one from the configured `api_key` by default; construct your own to tune the HTTP knobs and assign it to `config.gemini.client`:
 
 ```ruby
-class MyAgent < Riffer::Agent
-  model 'gemini/gemini-2.5-flash-lite'
-  provider_options api_key: ENV['GEMINI_API_KEY']
+Riffer.configure do |config|
+  config.gemini.client = Riffer::Providers::Gemini::Client.new(
+    api_key: ENV['GEMINI_API_KEY'],
+    read_timeout: 120
+  )
 end
 ```
 
+| Option          | Default                                     | Description                            |
+| --------------- | ------------------------------------------- | -------------------------------------- |
+| `api_key`       | `nil`                                       | Sent as the `x-goog-api-key` header    |
+| `base_url`      | `https://generativelanguage.googleapis.com` | API origin (proxies, regional mirrors) |
+| `open_timeout`  | `10`                                        | Connection-open timeout in seconds     |
+| `read_timeout`  | `60`                                        | Read timeout in seconds                |
+| `write_timeout` | `nil`                                       | Write timeout in seconds               |
+| `proxy_address` | `nil`                                       | HTTP proxy host                        |
+| `proxy_port`    | `nil`                                       | HTTP proxy port                        |
+
+The setting accepts a client instance or a no-argument `Proc`, resolved on every LLM call — see [Configuration → Provider Clients](../CONFIGURATION.md#provider-clients).
+
+The class is a default implementation, not a required base: any object implementing the two-method contract works, e.g. a Faraday-based or instrumented transport.
+
+| Method                                  | Contract                                                                                                                      |
+| --------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `post(path, body)`                      | POST `body` as JSON to `path`; return the parsed response `Hash` (symbol keys); raise `Riffer::Error` on a non-success status |
+| `post_stream(path, body) { \|chunk\| }` | POST `body` as JSON to `path`; yield raw response body chunks; raise `Riffer::Error` on a non-success status                  |
+
 ## Supported Models
 
 Use Gemini model IDs in the `gemini/model` format:
@@ -62,7 +85,7 @@ model_options topP: 0.9
 ### Basic Generation
 
 ```ruby
-provider = Riffer::Providers::Gemini.new(api_key: ENV['GEMINI_API_KEY'])
+provider = Riffer::Providers::Gemini.new
 
 response = provider.generate_text(
   prompt: "Hello!",

data/docs/providers/OPENAI.md

@@ -20,12 +20,28 @@ Riffer.configure do |config|
 end
 ```
 
-Or per-agent:
+Both `api_key` and `base_url` resolve in order: `Riffer.config.openai.*` → the OpenAI SDK's own `OPENAI_API_KEY` / `OPENAI_BASE_URL` lookup. Leaving one unset in riffer means the SDK resolves it, so an `OPENAI_BASE_URL` gateway is honored without any riffer configuration.
+
+For anything beyond the API key — timeouts, retries, proxies — supply your own `OpenAI::Client`:
 
 ```ruby
-class MyAgent < Riffer::Agent
-  model 'openai/gpt-5-mini'
-  provider_options api_key: ENV['CUSTOM_API_KEY']
+Riffer.configure do |config|
+  config.openai.client = OpenAI::Client.new(
+    api_key: ENV['OPENAI_API_KEY'],
+    timeout: 30,
+    max_retries: 4
+  )
+end
+```
+
+The setting accepts a client instance or a no-argument `Proc`, resolved on every LLM call — see [Configuration → Provider Clients](../CONFIGURATION.md#provider-clients).
+
+For OpenAI-compatible servers (LiteLLM, vLLM, corporate gateways), configure a `base_url`:
+
+```ruby
+Riffer.configure do |config|
+  config.openai.api_key = ENV['GATEWAY_KEY']
+  config.openai.base_url = 'http://localhost:4000/v1'
 end
 ```
 
@@ -185,7 +201,7 @@ The provider converts Riffer messages to OpenAI format:
 ## Direct Provider Usage
 
 ```ruby
-provider = Riffer::Providers::OpenAI.new(api_key: ENV['OPENAI_API_KEY'])
+provider = Riffer::Providers::OpenAI.new
 
 response = provider.generate_text(
   prompt: "Hello!",

data/docs/providers/OPENROUTER.md

@@ -24,16 +24,21 @@ Riffer.configure do |config|
 end
 ```
 
-Or per-agent:
+The `api_key` resolves in order: `Riffer.config.openrouter.api_key` → `ENV['OPENROUTER_API_KEY']`.
+
+For anything beyond the API key — timeouts, retries, proxies — supply your own `OpenAI::Client` pinned to the OpenRouter endpoint:
 
 ```ruby
-class MyAgent < Riffer::Agent
-  model 'openrouter/anthropic/claude-sonnet-4.6'
-  provider_options api_key: ENV['MY_OR_KEY']
+Riffer.configure do |config|
+  config.openrouter.client = OpenAI::Client.new(
+    api_key: ENV['OPENROUTER_API_KEY'],
+    base_url: 'https://openrouter.ai/api/v1',
+    timeout: 60
+  )
 end
 ```
 
-The `api_key` resolves in order: keyword arg → `Riffer.config.openrouter.api_key` → `ENV['OPENROUTER_API_KEY']`.
+The setting accepts a client instance or a no-argument `Proc`, resolved on every LLM call — see [Configuration → Provider Clients](../CONFIGURATION.md#provider-clients).
 
 ## Supported Models
 
@@ -229,7 +234,7 @@ User messages with files become multi-part content (`image_url` for images, `fil
 ## Direct Provider Usage
 
 ```ruby
-provider = Riffer::Providers::OpenRouter.new(api_key: ENV['OPENROUTER_API_KEY'])
+provider = Riffer::Providers::OpenRouter.new
 
 response = provider.generate_text(
   prompt: 'Hello!',

data/docs/providers/PROVIDERS.md

@@ -30,6 +30,21 @@ class MyAgent < Riffer::Agent
 end
 ```
 
+## Credentials and Clients
+
+Every credential comes from configuration: `Riffer::Providers::OpenAI.new` takes no arguments.
+
+| Provider       | Configured credentials                                            |
+| -------------- | ----------------------------------------------------------------- |
+| OpenAI         | `config.openai.api_key`, `config.openai.base_url`                 |
+| Azure OpenAI   | `config.azure_openai.api_key`, `config.azure_openai.endpoint`     |
+| Anthropic      | `config.anthropic.api_key`                                        |
+| Amazon Bedrock | `config.amazon_bedrock.api_token`, `config.amazon_bedrock.region` |
+| Gemini         | `config.gemini.api_key`                                           |
+| OpenRouter     | `config.openrouter.api_key`                                       |
+
+Out of the box, each provider builds an SDK client from these credentials. Everything else — timeouts, retries, proxies, custom auth — is configured by assigning your own client (an instance, or a `Proc` resolved on every LLM call) to `Riffer.config.<provider>.client`. See [Configuration → Provider Clients](../CONFIGURATION.md#provider-clients).
+
 ## Provider Interface
 
 All providers inherit from `Riffer::Providers::Base` and implement:
@@ -39,7 +54,7 @@ All providers inherit from `Riffer::Providers::Base` and implement:
 Generates a response synchronously:
 
 ```ruby
-provider = Riffer::Providers::OpenAI.new(api_key: "...")
+provider = Riffer::Providers::OpenAI.new
 
 response = provider.generate_text(
   prompt: "Hello!",

data/lib/riffer/agent/config.rb

@@ -16,9 +16,6 @@ class Riffer::Agent::Config
   # The configured instructions.
   attr_reader :instructions #: (String | Proc)?
 
-  # Options passed to the provider client.
-  attr_accessor :provider_options #: Hash[Symbol, untyped]
-
   # Options passed to generate_text/stream_text.
   attr_accessor :model_options #: Hash[Symbol, untyped]
 
@@ -50,7 +47,6 @@ class Riffer::Agent::Config
   #    ?identifier: String?,
   #    ?model: (String | Proc)?,
   #    ?instructions: (String | Proc)?,
-  #    ?provider_options: Hash[Symbol, untyped],
   #    ?model_options: Hash[Symbol, untyped],
   #    ?structured_output: Riffer::Params?,
   #    ?max_steps: Numeric?,
@@ -64,7 +60,6 @@ class Riffer::Agent::Config
     identifier: nil,
     model: nil,
     instructions: nil,
-    provider_options: {},
     model_options: {},
     structured_output: nil,
     max_steps: DEFAULT_MAX_STEPS,
@@ -74,7 +69,6 @@ class Riffer::Agent::Config
     skills_config: nil,
     guardrails: { before: [], after: [] }
   )
-    @provider_options = provider_options
     @model_options = model_options
     @max_steps = max_steps
     @tools_config = tools_config

data/lib/riffer/agent/run.rb

@@ -465,10 +465,8 @@ module Riffer::Agent::Run
     tripwire = response.tripwire
     return unless tripwire
 
-    class_name = tripwire.guardrail.name
-    if class_name
-      span.set_attribute("riffer.tripwire.guardrail", Riffer::Helpers::ClassNameConverter.convert(class_name))
-    end
+    identifier = Riffer::Helpers::Identifier.for(tripwire.guardrail)
+    span.set_attribute("riffer.tripwire.guardrail", identifier) unless identifier.empty?
     span.set_attribute("riffer.tripwire.reason", tripwire.reason)
     span.set_attribute("riffer.tripwire.phase", tripwire.phase.to_s)
   end

data/lib/riffer/agent/serializer.rb

@@ -37,7 +37,6 @@ module Riffer::Agent::Serializer
       model: "#{agent.provider_name}/#{agent.model_name}",
       instructions: agent.instruction_message&.content,
       model_options: config.model_options,
-      provider_options: config.provider_options,
       max_steps: encode_max_steps(config.max_steps),
       structured_output: config.structured_output&.to_json_schema(strict: false),
       tools: agent.tools.map { |tool_class| tool_descriptor(tool_class) },
@@ -96,7 +95,6 @@ module Riffer::Agent::Serializer
       identifier: hash[:identifier],
       model: hash[:model],
       instructions: hash[:instructions],
-      provider_options: hash[:provider_options] || {},
       model_options: hash[:model_options] || {},
       structured_output: decode_structured_output(hash[:structured_output]),
       max_steps: decode_max_steps(hash),

data/lib/riffer/agent.rb

@@ -15,6 +15,8 @@ require "json"
 #   agent.generate('Hello!')
 #
 class Riffer::Agent
+  extend Riffer::Registrable
+
   # @rbs self.@config: Riffer::Agent::Config?
 
   INTERRUPT_MAX_STEPS = :max_steps #: Symbol
@@ -31,7 +33,7 @@ class Riffer::Agent
   #--
   #: (?String?) -> String
   def self.identifier(value = nil)
-    value.nil? ? (config.identifier || Riffer::Helpers::ClassNameConverter.convert(name)) : (config.identifier = value)
+    value.nil? ? (config.identifier || Riffer::Helpers::Identifier.for(self)) : (config.identifier = value)
   end
 
   # Gets or sets the model string (e.g., "openai/gpt-4o").
@@ -57,14 +59,6 @@ class Riffer::Agent
     value.nil? ? config.instructions : (config.instructions = value)
   end
 
-  # Gets or sets provider options passed to the provider client.
-  #
-  #--
-  #: (?Hash[Symbol, untyped]?) -> Hash[Symbol, untyped]
-  def self.provider_options(options = nil)
-    options.nil? ? config.provider_options : (config.provider_options = options)
-  end
-
   # Gets or sets model options passed to generate_text/stream_text.
   #
   #--
@@ -152,22 +146,6 @@ class Riffer::Agent
     config.skills_config
   end
 
-  # Finds an agent class by identifier.
-  #
-  #--
-  #: (String) -> singleton(Riffer::Agent)?
-  def self.find(identifier)
-    all.find { |agent_class| agent_class.identifier == identifier.to_s }
-  end
-
-  # Returns all agent subclasses.
-  #
-  #--
-  #: () -> Array[singleton(Riffer::Agent)]
-  def self.all
-    subclasses #: Array[singleton(Riffer::Agent)]
-  end
-
   # Generates a response using a new agent instance.
   #--
   #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?context: Hash[Symbol, untyped]?, ?tags: Hash[(String | Symbol), untyped]) -> Riffer::Agent::Response
@@ -408,7 +386,7 @@ class Riffer::Agent
     provider_class = Riffer::Providers::Repository.find(@provider_name)
     raise Riffer::ArgumentError, "Provider not found: #{@provider_name}" unless provider_class
 
-    provider_class.new(**@config.provider_options)
+    provider_class.new
   end
 
   #--

data/lib/riffer/config.rb

@@ -3,12 +3,12 @@
 
 # Configuration for the Riffer framework.
 class Riffer::Config
-  AmazonBedrock = Struct.new(:api_token, :region)
-  Anthropic = Struct.new(:api_key)
-  AzureOpenAI = Struct.new(:api_key, :endpoint)
-  Gemini = Struct.new(:api_key, :open_timeout, :read_timeout)
-  OpenAI = Struct.new(:api_key)
-  OpenRouter = Struct.new(:api_key)
+  AmazonBedrock = Struct.new(:api_token, :region, :client)
+  Anthropic = Struct.new(:api_key, :client)
+  AzureOpenAI = Struct.new(:api_key, :endpoint, :client)
+  Gemini = Struct.new(:api_key, :client)
+  OpenAI = Struct.new(:api_key, :base_url, :client)
+  OpenRouter = Struct.new(:api_key, :client)
   Evals = Struct.new(:judge_model)
   Mcp = Struct.new(:credentials, :discovery_runner)
 

data/lib/riffer/evals/judge.rb

@@ -6,7 +6,6 @@ require "json"
 # Executes LLM-as-judge evaluations, using tool calling internally to get
 # structured output from the judge model.
 class Riffer::Evals::Judge
-  # @rbs @provider_options: Hash[Symbol, untyped]
   # @rbs @provider_instance: Riffer::Providers::Base?
   # @rbs @provider_name: String?
   # @rbs @model_name: String?
@@ -33,15 +32,14 @@ class Riffer::Evals::Judge
 
   # Raises Riffer::ArgumentError unless +model+ is "provider/model" format.
   #--
-  #: (model: String, ?provider_options: Hash[Symbol, untyped]) -> void
-  def initialize(model:, provider_options: {})
+  #: (model: String) -> void
+  def initialize(model:)
     provider_name, model_name = model.split("/", 2)
     unless [provider_name, model_name].all? { |part| part.is_a?(String) && !part.strip.empty? }
       raise Riffer::ArgumentError, "Invalid model string: #{model}"
     end
 
     @model = model
-    @provider_options = provider_options
   end
 
   # Evaluates an input/output pair using the configured LLM.
@@ -92,7 +90,7 @@ class Riffer::Evals::Judge
       provider_class = Riffer::Providers::Repository.find(provider_name)
       raise Riffer::ArgumentError, "Provider not found: #{provider_name}" unless provider_class
 
-      provider_class.new(**@provider_options)
+      provider_class.new
     end
   end
 

data/lib/riffer/guardrail.rb

@@ -36,7 +36,7 @@ class Riffer::Guardrail
   #--
   #: () -> String
   def name
-    Riffer::Helpers::ClassNameConverter.convert(self.class.name)
+    Riffer::Helpers::Identifier.for(self.class)
   end
 
   protected

data/lib/riffer/helpers/identifier.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# Helper module for deriving snake_case identifiers from class names.
+module Riffer::Helpers::Identifier
+  extend self
+
+  # Derives a snake_case identifier from a class name string.
+  #
+  #--
+  #: (String?) -> String
+  def derive(class_name)
+    class_name.
+      to_s.
+      gsub("::", "/").
+      gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+      gsub(/([a-z\d])([A-Z])/, '\1_\2').
+      downcase
+  end
+
+  # Derives and memoizes the identifier for a class or module. Anonymous
+  # classes return "" without caching, so a class named later still derives its
+  # real identifier — a guard that must travel with the cache, so callers never
+  # memoize their own.
+  #
+  #--
+  #: (Module) -> String
+  def for(klass)
+    cached = klass.instance_variable_get(:@derived_identifier) #: String?
+    return cached if cached
+
+    # Tool classes shadow Module#name with the identifier DSL, so the real
+    # class-path name must come from Module's own implementation.
+    real_name = Module.instance_method(:name).bind_call(klass) #: String?
+    return "" if real_name.nil?
+
+    derived = derive(real_name)
+    klass.instance_variable_set(:@derived_identifier, derived)
+    derived
+  end
+end

data/lib/riffer/providers/amazon_bedrock.rb

@@ -37,28 +37,40 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
   end
 
   #--
-  #: (?api_token: String?, ?region: String?, **untyped) -> void
-  def initialize(api_token: nil, region: nil, **)
-    super()
+  #: () -> void
+  def initialize
+    super
     depends_on "aws-sdk-bedrockruntime"
-
-    api_token ||= Riffer.config.amazon_bedrock.api_token
-    region ||= Riffer.config.amazon_bedrock.region
-
-    @client = if api_token && !api_token.empty?
-                Aws::BedrockRuntime::Client.new(
-                  region: region,
-                  token_provider: Aws::StaticTokenProvider.new(api_token),
-                  auth_scheme_preference: ["httpBearerAuth"],
-                  **,
-                )
-              else
-                Aws::BedrockRuntime::Client.new(region: region, **)
-              end
   end
 
   private
 
+  #--
+  #: () -> untyped
+  def global_client
+    Riffer.config.amazon_bedrock.client
+  end
+
+  # Compacted so an unset region stays absent: the AWS SDK resolves +AWS_REGION+
+  # and the shared config only for a missing argument, and raises
+  # +Aws::Errors::MissingRegionError+ on an explicit nil.
+  #--
+  #: () -> untyped
+  def build_client
+    api_token = Riffer.config.amazon_bedrock.api_token
+    region = Riffer.config.amazon_bedrock.region
+
+    if api_token && !api_token.empty?
+      Aws::BedrockRuntime::Client.new(**{
+        region: region,
+        token_provider: Aws::StaticTokenProvider.new(api_token),
+        auth_scheme_preference: ["httpBearerAuth"],
+      }.compact)
+    else
+      Aws::BedrockRuntime::Client.new(**{ region: region }.compact)
+    end
+  end
+
   #--
   #: (Array[Riffer::Messages::Base], String?, Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
   def build_request_params(messages, model, options)
@@ -137,7 +149,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
   #--
   #: (Hash[Symbol, untyped]) -> untyped
   def execute_generate(params)
-    @client.converse(**params)
+    client.converse(**params)
   end
 
   #--
@@ -227,7 +239,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
       tool_call: nil,
     } #: Hash[Symbol, untyped]
 
-    @client.converse_stream(**params) do |stream|
+    client.converse_stream(**params) do |stream|
       stream.on_event do |event|
         case event
         when Aws::BedrockRuntime::Types::ContentBlockStartEvent