riffer 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b78c9eff3bd51ccab98e50b8adbee7c5aabd8b5da8fea825559c7a7b7783340
-  data.tar.gz: 605b9ab5ab96bf8f7b6af9083a955293931a0603875c6a17011a1249d4533948
+  metadata.gz: 414f5f9afaa98b3d19f1e649ea15aaa632fa60073d11ac940d6fdbb893b4356e
+  data.tar.gz: dd693e59f9acabd91f9bb4f7621aced10ca871d4f76d030ad6ab2ab743b9f2b9
 SHA512:
-  metadata.gz: e80cf949f74dbb12d9e161525c4403cfa8f560333e322580f28f187a946c0c061acd47e92a68d328767819daeba4397639891d7f6585d3c095109824d6702638
-  data.tar.gz: 1f81bb4bd577b13d0e0c45c37d594012c340f13bf8e1bf59a34f88481cb6cecddd54078a51d1dae262982e73d8bcbbbe6fae030e61a3d7cc7a3c7ae3014ed39d
+  metadata.gz: b4ee5e296e43d8727a2e9a214d8fe713bae89f0ba90c7e46ec6b7c1c3fae4cd2c8b0dc8efcbf771955a1c36b4a1ed5a4b591d034f9bf88b17ee99464590ed551
+  data.tar.gz: 1eb8e7c0ee9e381a78d5ddcbeb707f6bed15935bf8d45367da26a9f723372de7503dc14c7379d2e180c581b4aad6257571888eb46bc73e2dce190ef1bd8b823c

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.5.1"
+  ".": "0.6.0"
 }

data/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0](https://github.com/janeapp/riffer/compare/riffer/v0.5.1...riffer/v0.6.0) (2026-01-14)
+
+
+### Features
+
+* aws bedrock provider ([#73](https://github.com/janeapp/riffer/issues/73)) ([428ae90](https://github.com/janeapp/riffer/commit/428ae902db90c2d3765186ea06d76ee379b3eae7))
+* reasoning support ([#75](https://github.com/janeapp/riffer/issues/75)) ([fcee502](https://github.com/janeapp/riffer/commit/fcee502054882f41d15ea312222a5538c8f04220))
+
 ## [0.5.1](https://github.com/janeapp/riffer/compare/riffer/v0.5.0...riffer/v0.5.1) (2026-01-10)
 
 

data/CLAUDE.md

@@ -0,0 +1,73 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Riffer is a Ruby gem framework for building AI-powered applications and agents. It uses Zeitwerk for autoloading.
+
+## Commands
+
+```bash
+# Install dependencies
+bin/setup
+
+# Run tests
+bundle exec rake test
+
+# Run a single test file
+bundle exec ruby -Ilib:test test/riffer/agent_test.rb
+
+# Run a specific test by name
+bundle exec ruby -Ilib:test test/riffer/agent_test.rb --name "test_something"
+
+# Check code style
+bundle exec rake standard
+
+# Auto-fix style issues
+bundle exec rake standard:fix
+
+# Run both tests and linting (default task)
+bundle exec rake
+
+# Interactive console
+bin/console
+
+# Generate documentation
+bundle exec rake docs
+```
+
+## Architecture
+
+### Core Components
+
+- **Agent** (`lib/riffer/agent.rb`): Base class for AI agents. Subclass and use DSL methods `model` and `instructions` to configure. Orchestrates message flow, LLM calls, and tool execution via a generate/stream loop.
+
+- **Providers** (`lib/riffer/providers/`): Adapters for LLM APIs. Each provider extends `Riffer::Providers::Base` and implements `perform_generate_text` and `perform_stream_text`. Registered in `Repository` with identifier (e.g., `openai`).
+
+- **Messages** (`lib/riffer/messages/`): Typed message objects (`System`, `User`, `Assistant`, `Tool`). All extend `Base`. The `Converter` module handles hash-to-object conversion.
+
+- **StreamEvents** (`lib/riffer/stream_events/`): Structured events for streaming (`TextDelta`, `TextDone`).
+
+### Key Patterns
+
+- Model strings use `provider/model` format (e.g., `openai/gpt-4`)
+- Configuration via `Riffer.configure { |c| c.openai.api_key = "..." }`
+- Providers use `depends_on` helper for runtime dependency checking
+- Tests use VCR cassettes in `test/fixtures/vcr_cassettes/`
+
+### Adding a New Provider
+
+1. Create `lib/riffer/providers/your_provider.rb` extending `Riffer::Providers::Base`
+2. Implement `perform_generate_text(messages, model:)` returning `Riffer::Messages::Assistant`
+3. Implement `perform_stream_text(messages, model:)` returning an `Enumerator` yielding stream events
+4. Register in `Riffer::Providers::Repository::REPO`
+5. Add provider config to `Riffer::Config` if needed
+
+## Code Style
+
+- Ruby 3.2+ required
+- All files must have `# frozen_string_literal: true`
+- StandardRB for formatting (double quotes, 2-space indent)
+- Minitest with spec DSL for tests
+- YARD-style documentation for public APIs

data/README.md

@@ -58,7 +58,6 @@ Riffer.configure do |config|
 end
 
 class EchoAgent < Riffer::Agent
-  identifier 'echo'
   model 'openai/gpt-5-mini' # provider/model
   instructions 'You are an assistant that repeats what the user says.'
 end

data/lib/riffer/agent.rb

@@ -11,13 +11,14 @@ class Riffer::Agent
   include Riffer::Messages::Converter
 
   class << self
+    include Riffer::Helpers::ClassNameConverter
     include Riffer::Helpers::Validations
 
     # Gets or sets the agent identifier
     # @param value [String, nil] the identifier to set, or nil to get
     # @return [String] the agent identifier
     def identifier(value = nil)
-      return @identifier if value.nil?
+      return @identifier || class_name_to_path(name) if value.nil?
       @identifier = value.to_s
     end
 
@@ -39,6 +40,12 @@ class Riffer::Agent
       @instructions = instructions_text
     end
 
+    def reasoning(level = nil)
+      return @reasoning if level.nil?
+      validate_is_string!(level, "reasoning")
+      @reasoning = level
+    end
+
     # Finds an agent class by identifier
     # @param identifier [String] the identifier to search for
     # @return [Class, nil] the agent class, or nil if not found
@@ -64,6 +71,7 @@ class Riffer::Agent
     @messages = []
     @model_string = self.class.model
     @instructions_text = self.class.instructions
+    @reasoning = self.class.reasoning
 
     provider_name, model_name = @model_string.split("/", 2)
 
@@ -132,11 +140,11 @@ class Riffer::Agent
   end
 
   def call_llm
-    provider_instance.generate_text(messages: @messages, model: @model_name)
+    provider_instance.generate_text(messages: @messages, model: @model_name, reasoning: @reasoning)
   end
 
   def call_llm_stream
-    provider_instance.stream_text(messages: @messages, model: @model_name)
+    provider_instance.stream_text(messages: @messages, model: @model_name, reasoning: @reasoning)
   end
 
   def provider_instance

data/lib/riffer/config.rb

@@ -6,14 +6,23 @@
 #
 # @example Setting the OpenAI API key
 #   Riffer.config.openai.api_key = "sk-..."
+#
+# @example Setting Amazon Bedrock configuration
+#   Riffer.config.amazon_bedrock.region = "us-east-1"
+#   Riffer.config.amazon_bedrock.api_token = "..."
 class Riffer::Config
   # OpenAI configuration
   # @return [Struct]
   attr_reader :openai
 
+  # Amazon Bedrock configuration
+  # @return [Struct]
+  attr_reader :amazon_bedrock
+
   # Initializes the configuration
   # @return [void]
   def initialize
     @openai = Struct.new(:api_key).new
+    @amazon_bedrock = Struct.new(:api_token, :region).new
   end
 end

data/lib/riffer/helpers/class_name_converter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Riffer::Helpers::ClassNameConverter
+  # Converts a class name to snake_case path format
+  # @param class_name [String] the class name (e.g., "Riffer::Agent")
+  # @return [String] the snake_case path (e.g., "riffer/agent")
+  def class_name_to_path(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
+end

data/lib/riffer/providers/amazon_bedrock.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
+  # Initializes the Amazon Bedrock provider.
+  #
+  # @param options [Hash] options passed to Aws::BedrockRuntime::Client
+  # @option options [String] :api_token Bearer token for API authentication (requires :region)
+  # @option options [String] :region AWS region
+  # @see https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/BedrockRuntime/Client.html
+  def initialize(api_token: nil, region: nil, **options)
+    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"],
+        **options
+      )
+    else
+      Aws::BedrockRuntime::Client.new(region: region, **options)
+    end
+  end
+
+  private
+
+  def perform_generate_text(messages, model:, reasoning: nil)
+    partitioned_messages = partition_messages(messages)
+
+    params = {
+      model_id: model,
+      system: partitioned_messages[:system],
+      messages: partitioned_messages[:conversation]
+    }
+
+    response = @client.converse(**params)
+    extract_assistant_message(response)
+  end
+
+  def perform_stream_text(messages, model:, reasoning: nil)
+    Enumerator.new do |yielder|
+      partitioned_messages = partition_messages(messages)
+
+      params = {
+        model_id: model,
+        system: partitioned_messages[:system],
+        messages: partitioned_messages[:conversation]
+      }
+
+      accumulated_text = ""
+
+      @client.converse_stream(**params) do |stream|
+        stream.on_content_block_delta_event do |event|
+          if event.delta&.text
+            delta_text = event.delta.text
+            accumulated_text += delta_text
+            yielder << Riffer::StreamEvents::TextDelta.new(delta_text)
+          end
+        end
+
+        stream.on_message_stop_event do |_event|
+          yielder << Riffer::StreamEvents::TextDone.new(accumulated_text)
+        end
+      end
+    end
+  end
+
+  def partition_messages(messages)
+    system_prompts = []
+    conversation_messages = []
+
+    messages.each do |message|
+      case message
+      when Riffer::Messages::System
+        system_prompts << {text: message.content}
+      when Riffer::Messages::User
+        conversation_messages << {role: "user", content: [{text: message.content}]}
+      when Riffer::Messages::Assistant
+        conversation_messages << {role: "assistant", content: [{text: message.content}]}
+      when Riffer::Messages::Tool
+        raise NotImplementedError, "Tool messages are not supported by Amazon Bedrock provider yet"
+      end
+    end
+
+    {
+      system: system_prompts,
+      conversation: conversation_messages
+    }
+  end
+
+  def extract_assistant_message(response)
+    output = response.output
+    raise Riffer::Error, "No output returned from Bedrock API" if output.nil? || output.message.nil?
+
+    content_blocks = output.message.content
+    raise Riffer::Error, "No content returned from Bedrock API" if content_blocks.nil? || content_blocks.empty?
+
+    text_block = content_blocks.find { |block| block.respond_to?(:text) && block.text }
+    raise Riffer::Error, "No text content returned from Bedrock API" if text_block.nil?
+
+    Riffer::Messages::Assistant.new(text_block.text)
+  end
+end

data/lib/riffer/providers/base.rb

@@ -10,12 +10,13 @@ class Riffer::Providers::Base
   # @param system [String, nil] an optional system message
   # @param messages [Array<Hash, Riffer::Messages::Base>, nil] optional messages array
   # @param model [String, nil] optional model string to override the configured model
+  # @param reasoning [String, nil] optional reasoning level or instructions
   # @return [Riffer::Messages::Assistant] the generated assistant message
-  def generate_text(prompt: nil, system: nil, messages: nil, model: nil)
+  def generate_text(prompt: nil, system: nil, messages: nil, model: nil, reasoning: nil)
     validate_input!(prompt: prompt, system: system, messages: messages)
     normalized_messages = normalize_messages(prompt: prompt, system: system, messages: messages)
     validate_normalized_messages!(normalized_messages)
-    perform_generate_text(normalized_messages, model: model)
+    perform_generate_text(normalized_messages, model: model, reasoning: reasoning)
   end
 
   # Streams text from the provider.
@@ -24,21 +25,22 @@ class Riffer::Providers::Base
   # @param system [String, nil] an optional system message
   # @param messages [Array<Hash, Riffer::Messages::Base>, nil] optional messages array
   # @param model [String, nil] optional model string to override the configured model
+  # @param reasoning [String, nil] optional reasoning level or instructions
   # @return [Enumerator] an enumerator yielding stream events or chunks (provider-specific)
-  def stream_text(prompt: nil, system: nil, messages: nil, model: nil)
+  def stream_text(prompt: nil, system: nil, messages: nil, model: nil, reasoning: nil)
     validate_input!(prompt: prompt, system: system, messages: messages)
     normalized_messages = normalize_messages(prompt: prompt, system: system, messages: messages)
     validate_normalized_messages!(normalized_messages)
-    perform_stream_text(normalized_messages, model: model)
+    perform_stream_text(normalized_messages, model: model, reasoning: reasoning)
   end
 
   private
 
-  def perform_generate_text(messages, model: nil)
+  def perform_generate_text(messages, model: nil, reasoning: nil)
     raise NotImplementedError, "Subclasses must implement #perform_generate_text"
   end
 
-  def perform_stream_text(messages, model: nil)
+  def perform_stream_text(messages, model: nil, reasoning: nil)
     raise NotImplementedError, "Subclasses must implement #perform_stream_text"
   end
 

data/lib/riffer/providers/open_ai.rb

@@ -17,8 +17,8 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
 
   private
 
-  def perform_generate_text(messages, model:)
-    params = build_request_params(messages, model)
+  def perform_generate_text(messages, model:, reasoning: nil)
+    params = build_request_params(messages, model, reasoning)
     response = @client.responses.create(params)
 
     output = response.output.find { |o| o.type == :message }
@@ -44,19 +44,23 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
     Riffer::Messages::Assistant.new(content.text)
   end
 
-  def perform_stream_text(messages, model:)
+  def perform_stream_text(messages, model:, reasoning: nil)
     Enumerator.new do |yielder|
-      params = build_request_params(messages, model)
+      params = build_request_params(messages, model, reasoning)
       stream = @client.responses.stream(params)
 
       process_stream_events(stream, yielder)
     end
   end
 
-  def build_request_params(messages, model)
+  def build_request_params(messages, model, reasoning)
     {
+      input: convert_message_to_openai_format(messages),
       model: model,
-      input: convert_message_to_openai_format(messages)
+      reasoning: reasoning && {
+        effort: reasoning,
+        summary: "auto"
+      }
     }
   end
 
@@ -91,6 +95,10 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
       Riffer::StreamEvents::TextDelta.new(event.delta)
     when :"response.output_text.done"
       Riffer::StreamEvents::TextDone.new(event.text)
+    when :"response.reasoning_summary_text.delta"
+      Riffer::StreamEvents::ReasoningDelta.new(event.delta)
+    when :"response.reasoning_summary_text.done"
+      Riffer::StreamEvents::ReasoningDone.new(event.text)
     end
   end
 end

data/lib/riffer/providers/repository.rb

@@ -1,6 +1,7 @@
 class Riffer::Providers::Repository
   REPO = {
     openai: -> { Riffer::Providers::OpenAI },
+    amazon_bedrock: -> { Riffer::Providers::AmazonBedrock },
     test: -> { Riffer::Providers::Test }
   }.freeze
 

data/lib/riffer/providers/test.rb

@@ -8,16 +8,18 @@ class Riffer::Providers::Test < Riffer::Providers::Base
     @current_index = 0
     @calls = []
     @stubbed_response = nil
+    @stubbed_reasoning = nil
   end
 
-  def stub_response(content, tool_calls: [])
+  def stub_response(content, tool_calls: [], reasoning: nil)
     @stubbed_response = {role: "assistant", content: content, tool_calls: tool_calls}
+    @stubbed_reasoning = reasoning
   end
 
   private
 
-  def perform_generate_text(messages, model: nil)
-    @calls << {messages: messages.map(&:to_h)}
+  def perform_generate_text(messages, model: nil, reasoning: nil)
+    @calls << {messages: messages.map(&:to_h), model: model, reasoning: reasoning}
     response = @stubbed_response || @responses[@current_index] || {role: "assistant", content: "Test response"}
     @current_index += 1
 
@@ -28,11 +30,21 @@ class Riffer::Providers::Test < Riffer::Providers::Base
     end
   end
 
-  def perform_stream_text(messages, model: nil)
-    @calls << {messages: messages.map(&:to_h)}
+  def perform_stream_text(messages, model: nil, reasoning: nil)
+    @calls << {messages: messages.map(&:to_h), model: model, reasoning: reasoning}
     response = @stubbed_response || @responses[@current_index] || {role: "assistant", content: "Test response"}
     @current_index += 1
     Enumerator.new do |yielder|
+      if @stubbed_reasoning
+        reasoning_parts = @stubbed_reasoning.split(". ").map { |part| part + (part.end_with?(".") ? "" : ".") }
+
+        reasoning_parts.each do |part|
+          yielder << Riffer::StreamEvents::ReasoningDelta.new(part + " ")
+        end
+
+        yielder << Riffer::StreamEvents::ReasoningDone.new(@stubbed_reasoning)
+      end
+
       full_content = response[:content]
       content_parts = full_content.split(". ").map { |part| part + (part.end_with?(".") ? "" : ".") }
 

data/lib/riffer/stream_events/reasoning_delta.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Riffer::StreamEvents::ReasoningDelta < Riffer::StreamEvents::Base
+  attr_reader :content
+
+  def initialize(content, role: "assistant")
+    super(role: role)
+    @content = content
+  end
+
+  def to_h
+    {role: @role, content: @content}
+  end
+end

data/lib/riffer/stream_events/reasoning_done.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Riffer::StreamEvents::ReasoningDone < Riffer::StreamEvents::Base
+  attr_reader :content
+
+  def initialize(content, role: "assistant")
+    super(role: role)
+    @content = content
+  end
+
+  def to_h
+    {role: @role, content: @content}
+  end
+end

data/lib/riffer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Riffer
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Jake Bottrall
@@ -29,6 +29,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.6.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-bedrockruntime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: openai
   requirement: !ruby/object:Gem::Requirement
@@ -130,6 +144,7 @@ files:
 - ".ruby-version"
 - ".standard.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
@@ -138,6 +153,7 @@ files:
 - lib/riffer/agent.rb
 - lib/riffer/config.rb
 - lib/riffer/core.rb
+- lib/riffer/helpers/class_name_converter.rb
 - lib/riffer/helpers/dependencies.rb
 - lib/riffer/helpers/validations.rb
 - lib/riffer/messages.rb
@@ -148,12 +164,15 @@ files:
 - lib/riffer/messages/tool.rb
 - lib/riffer/messages/user.rb
 - lib/riffer/providers.rb
+- lib/riffer/providers/amazon_bedrock.rb
 - lib/riffer/providers/base.rb
 - lib/riffer/providers/open_ai.rb
 - lib/riffer/providers/repository.rb
 - lib/riffer/providers/test.rb
 - lib/riffer/stream_events.rb
 - lib/riffer/stream_events/base.rb
+- lib/riffer/stream_events/reasoning_delta.rb
+- lib/riffer/stream_events/reasoning_done.rb
 - lib/riffer/stream_events/text_delta.rb
 - lib/riffer/stream_events/text_done.rb
 - lib/riffer/version.rb