riffer 0.6.0 → 0.7.0

data/lib/riffer/messages/tool.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
 class Riffer::Messages::Tool < Riffer::Messages::Base
-  attr_reader :tool_call_id, :name
+  attr_reader :tool_call_id, :name, :error, :error_type
 
-  def initialize(content, tool_call_id:, name:)
+  def initialize(content, tool_call_id:, name:, error: nil, error_type: nil)
     super(content)
     @tool_call_id = tool_call_id
     @name = name
+    @error = error
+    @error_type = error_type
+  end
+
+  def error?
+    !@error.nil?
   end
 
   def role
@@ -14,6 +20,11 @@ class Riffer::Messages::Tool < Riffer::Messages::Base
   end
 
   def to_h
-    {role: role, content: content, tool_call_id: tool_call_id, name: name}
+    hash = {role: role, content: content, tool_call_id: tool_call_id, name: name}
+    if error?
+      hash[:error] = error
+      hash[:error_type] = error_type
+    end
+    hash
   end
 end

data/lib/riffer/providers/amazon_bedrock.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
   # Initializes the Amazon Bedrock provider.
   #
@@ -27,37 +29,87 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
 
   private
 
-  def perform_generate_text(messages, model:, reasoning: nil)
+  def perform_generate_text(messages, model:, **options)
     partitioned_messages = partition_messages(messages)
+    tools = options[:tools]
 
     params = {
       model_id: model,
       system: partitioned_messages[:system],
-      messages: partitioned_messages[:conversation]
+      messages: partitioned_messages[:conversation],
+      **options.except(:tools)
     }
 
+    if tools && !tools.empty?
+      params[:tool_config] = {
+        tools: tools.map { |t| convert_tool_to_bedrock_format(t) }
+      }
+    end
+
     response = @client.converse(**params)
     extract_assistant_message(response)
   end
 
-  def perform_stream_text(messages, model:, reasoning: nil)
+  def perform_stream_text(messages, model:, **options)
     Enumerator.new do |yielder|
       partitioned_messages = partition_messages(messages)
+      tools = options[:tools]
 
       params = {
         model_id: model,
         system: partitioned_messages[:system],
-        messages: partitioned_messages[:conversation]
+        messages: partitioned_messages[:conversation],
+        **options.except(:tools)
       }
 
+      if tools && !tools.empty?
+        params[:tool_config] = {
+          tools: tools.map { |t| convert_tool_to_bedrock_format(t) }
+        }
+      end
+
       accumulated_text = ""
+      current_tool_use = nil
 
       @client.converse_stream(**params) do |stream|
+        stream.on_content_block_start_event do |event|
+          if event.start&.tool_use
+            tool_use = event.start.tool_use
+            current_tool_use = {
+              id: tool_use.tool_use_id,
+              name: tool_use.name,
+              arguments: ""
+            }
+          end
+        end
+
         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)
+          elsif event.delta&.tool_use
+            input_delta = event.delta.tool_use.input
+            if current_tool_use && input_delta
+              current_tool_use[:arguments] += input_delta
+              yielder << Riffer::StreamEvents::ToolCallDelta.new(
+                item_id: current_tool_use[:id],
+                name: current_tool_use[:name],
+                arguments_delta: input_delta
+              )
+            end
+          end
+        end
+
+        stream.on_content_block_stop_event do |_event|
+          if current_tool_use
+            yielder << Riffer::StreamEvents::ToolCallDone.new(
+              item_id: current_tool_use[:id],
+              call_id: current_tool_use[:id],
+              name: current_tool_use[:name],
+              arguments: current_tool_use[:arguments]
+            )
+            current_tool_use = nil
           end
         end
 
@@ -79,9 +131,17 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
       when Riffer::Messages::User
         conversation_messages << {role: "user", content: [{text: message.content}]}
       when Riffer::Messages::Assistant
-        conversation_messages << {role: "assistant", content: [{text: message.content}]}
+        conversation_messages << convert_assistant_to_bedrock_format(message)
       when Riffer::Messages::Tool
-        raise NotImplementedError, "Tool messages are not supported by Amazon Bedrock provider yet"
+        conversation_messages << {
+          role: "user",
+          content: [{
+            tool_result: {
+              tool_use_id: message.tool_call_id,
+              content: [{text: message.content}]
+            }
+          }]
+        }
       end
     end
 
@@ -91,6 +151,28 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     }
   end
 
+  def convert_assistant_to_bedrock_format(message)
+    content = []
+    content << {text: message.content} if message.content && !message.content.empty?
+
+    message.tool_calls.each do |tc|
+      content << {
+        tool_use: {
+          tool_use_id: tc[:id] || tc[:call_id],
+          name: tc[:name],
+          input: parse_tool_arguments(tc[:arguments])
+        }
+      }
+    end
+
+    {role: "assistant", content: content}
+  end
+
+  def parse_tool_arguments(arguments)
+    return {} if arguments.nil? || arguments.empty?
+    arguments.is_a?(String) ? JSON.parse(arguments) : arguments
+  end
+
   def extract_assistant_message(response)
     output = response.output
     raise Riffer::Error, "No output returned from Bedrock API" if output.nil? || output.message.nil?
@@ -98,9 +180,38 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     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?
+    text_content = ""
+    tool_calls = []
+
+    content_blocks.each do |block|
+      if block.respond_to?(:text) && block.text
+        text_content = block.text
+      elsif block.respond_to?(:tool_use) && block.tool_use
+        tool_calls << {
+          id: block.tool_use.tool_use_id,
+          call_id: block.tool_use.tool_use_id,
+          name: block.tool_use.name,
+          arguments: block.tool_use.input.to_json
+        }
+      end
+    end
+
+    if text_content.empty? && tool_calls.empty?
+      raise Riffer::Error, "No content returned from Bedrock API"
+    end
+
+    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls)
+  end
 
-    Riffer::Messages::Assistant.new(text_block.text)
+  def convert_tool_to_bedrock_format(tool)
+    {
+      tool_spec: {
+        name: tool.name,
+        description: tool.description,
+        input_schema: {
+          json: tool.parameters_schema
+        }
+      }
+    }
   end
 end

data/lib/riffer/providers/base.rb

@@ -10,13 +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
+  # @param options [Hash] additional options passed to the model invocation
   # @return [Riffer::Messages::Assistant] the generated assistant message
-  def generate_text(prompt: nil, system: nil, messages: nil, model: nil, reasoning: nil)
+  def generate_text(prompt: nil, system: nil, messages: nil, model: nil, **options)
     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, reasoning: reasoning)
+    perform_generate_text(normalized_messages, model: model, **options)
   end
 
   # Streams text from the provider.
@@ -25,22 +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
+  # @param options [Hash] additional options passed to the model invocation
   # @return [Enumerator] an enumerator yielding stream events or chunks (provider-specific)
-  def stream_text(prompt: nil, system: nil, messages: nil, model: nil, reasoning: nil)
+  def stream_text(prompt: nil, system: nil, messages: nil, model: nil, **options)
     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, reasoning: reasoning)
+    perform_stream_text(normalized_messages, model: model, **options)
   end
 
   private
 
-  def perform_generate_text(messages, model: nil, reasoning: nil)
+  def perform_generate_text(messages, model: nil, **options)
     raise NotImplementedError, "Subclasses must implement #perform_generate_text"
   end
 
-  def perform_stream_text(messages, model: nil, reasoning: nil)
+  def perform_stream_text(messages, model: nil, **options)
     raise NotImplementedError, "Subclasses must implement #perform_stream_text"
   end
 

data/lib/riffer/providers/open_ai.rb

@@ -1,87 +1,124 @@
 # frozen_string_literal: true
 
-require "openai"
-
 class Riffer::Providers::OpenAI < Riffer::Providers::Base
   # Initializes the OpenAI provider.
   # @param options [Hash] optional client options. Use `:api_key` to override `Riffer.config.openai.api_key`.
-  # @raise [Riffer::ArgumentError] if an API key is not provided either via `:api_key` or `Riffer.config.openai.api_key`.
   def initialize(**options)
     depends_on "openai"
 
     api_key = options.fetch(:api_key, Riffer.config.openai.api_key)
-    raise Riffer::ArgumentError, "OpenAI API key is required. Set it via Riffer.configure or pass :api_key option" if api_key.nil? || api_key.empty?
-
     @client = ::OpenAI::Client.new(api_key: api_key, **options.except(:api_key))
   end
 
   private
 
-  def perform_generate_text(messages, model:, reasoning: nil)
-    params = build_request_params(messages, model, reasoning)
+  def perform_generate_text(messages, model:, **options)
+    params = build_request_params(messages, model, options)
     response = @client.responses.create(params)
 
-    output = response.output.find { |o| o.type == :message }
-
-    if output.nil?
-      raise Riffer::Error, "No output returned from OpenAI API"
-    end
-
-    content = output.content.find { |c| c.type == :output_text }
-
-    if content.nil?
-      raise Riffer::Error, "No content returned from OpenAI API"
-    end
-
-    if content.type == :refusal
-      raise Riffer::Error, "Request was refused: #{content.refusal}"
-    end
-
-    if content.type != :output_text
-      raise Riffer::Error, "Unexpected content type: #{content.type}"
-    end
-
-    Riffer::Messages::Assistant.new(content.text)
+    extract_assistant_message(response.output)
   end
 
-  def perform_stream_text(messages, model:, reasoning: nil)
+  def perform_stream_text(messages, model:, **options)
     Enumerator.new do |yielder|
-      params = build_request_params(messages, model, reasoning)
+      params = build_request_params(messages, model, options)
       stream = @client.responses.stream(params)
 
       process_stream_events(stream, yielder)
     end
   end
 
-  def build_request_params(messages, model, reasoning)
-    {
-      input: convert_message_to_openai_format(messages),
+  def build_request_params(messages, model, options)
+    reasoning = options[:reasoning]
+    tools = options[:tools]
+
+    params = {
+      input: convert_messages_to_openai_format(messages),
       model: model,
       reasoning: reasoning && {
         effort: reasoning,
         summary: "auto"
-      }
+      },
+      **options.except(:reasoning, :tools)
     }
+
+    if tools && !tools.empty?
+      params[:tools] = tools.map { |t| convert_tool_to_openai_format(t) }
+    end
+
+    params.compact
   end
 
-  def convert_message_to_openai_format(messages)
-    messages.map do |message|
+  def convert_messages_to_openai_format(messages)
+    messages.flat_map do |message|
       case message
       when Riffer::Messages::System
         {role: "developer", content: message.content}
       when Riffer::Messages::User
         {role: "user", content: message.content}
       when Riffer::Messages::Assistant
-        {role: "assistant", content: message.content}
+        convert_assistant_to_openai_format(message)
       when Riffer::Messages::Tool
-        raise NotImplementedError, "Tool messages are not supported by OpenAI provider yet"
+        {
+          type: "function_call_output",
+          call_id: message.tool_call_id,
+          output: message.content
+        }
       end
     end
   end
 
+  def convert_assistant_to_openai_format(message)
+    if message.tool_calls.empty?
+      {role: "assistant", content: message.content}
+    else
+      items = []
+      items << {type: "message", role: "assistant", content: message.content} if message.content && !message.content.empty?
+      message.tool_calls.each do |tc|
+        items << {
+          type: "function_call",
+          id: tc[:id],
+          call_id: tc[:call_id] || tc[:id],
+          name: tc[:name],
+          arguments: tc[:arguments].is_a?(String) ? tc[:arguments] : tc[:arguments].to_json
+        }
+      end
+      items
+    end
+  end
+
+  def extract_assistant_message(output_items)
+    text_content = ""
+    tool_calls = []
+
+    output_items.each do |item|
+      case item.type
+      when :message
+        text_block = item.content&.find { |c| c.type == :output_text }
+        text_content = text_block&.text || "" if text_block
+      when :function_call
+        tool_calls << {
+          id: item.id,
+          call_id: item.call_id,
+          name: item.name,
+          arguments: item.arguments
+        }
+      end
+    end
+
+    if text_content.empty? && tool_calls.empty?
+      raise Riffer::Error, "No output returned from OpenAI API"
+    end
+
+    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls)
+  end
+
   def process_stream_events(stream, yielder)
+    tool_info = {}
+
     stream.each do |raw_event|
-      event = convert_event(raw_event)
+      track_tool_info(raw_event, tool_info)
+      event = convert_event(raw_event, tool_info)
 
       next unless event
 
@@ -89,7 +126,17 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
     end
   end
 
-  def convert_event(event)
+  def track_tool_info(event, tool_info)
+    return unless event.type == :"response.output_item.added"
+    return unless event.item&.type == :function_call
+
+    tool_info[event.item.id] = {
+      name: event.item.name,
+      call_id: event.item.call_id
+    }
+  end
+
+  def convert_event(event, tool_info = {})
     case event.type
     when :"response.output_text.delta"
       Riffer::StreamEvents::TextDelta.new(event.delta)
@@ -99,6 +146,31 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
       Riffer::StreamEvents::ReasoningDelta.new(event.delta)
     when :"response.reasoning_summary_text.done"
       Riffer::StreamEvents::ReasoningDone.new(event.text)
+    when :"response.function_call_arguments.delta"
+      tracked = tool_info[event.item_id] || {}
+      Riffer::StreamEvents::ToolCallDelta.new(
+        item_id: event.item_id,
+        name: tracked[:name],
+        arguments_delta: event.delta
+      )
+    when :"response.function_call_arguments.done"
+      tracked = tool_info[event.item_id] || {}
+      Riffer::StreamEvents::ToolCallDone.new(
+        item_id: event.item_id,
+        call_id: tracked[:call_id] || event.item_id,
+        name: tracked[:name],
+        arguments: event.arguments
+      )
     end
   end
+
+  def convert_tool_to_openai_format(tool)
+    {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters_schema,
+      strict: true
+    }
+  end
 end

data/lib/riffer/providers/test.rb

@@ -7,21 +7,51 @@ class Riffer::Providers::Test < Riffer::Providers::Base
     @responses = options[:responses] || []
     @current_index = 0
     @calls = []
-    @stubbed_response = nil
-    @stubbed_reasoning = nil
+    @stubbed_responses = []
   end
 
-  def stub_response(content, tool_calls: [], reasoning: nil)
-    @stubbed_response = {role: "assistant", content: content, tool_calls: tool_calls}
-    @stubbed_reasoning = reasoning
+  # Stubs the next response from the provider
+  # Can be called multiple times to queue responses
+  # @param content [String] the response content
+  # @param tool_calls [Array<Hash>] optional tool calls to include
+  # @example
+  #   provider.stub_response("Hello")
+  #   provider.stub_response("", tool_calls: [{name: "my_tool", arguments: '{"key":"value"}'}])
+  #   provider.stub_response("Final response")  # Queued for after tool execution
+  def stub_response(content, tool_calls: [])
+    formatted_tool_calls = tool_calls.map.with_index do |tc, idx|
+      {
+        id: tc[:id] || "test_id_#{idx}",
+        call_id: tc[:call_id] || tc[:id] || "test_call_#{idx}",
+        name: tc[:name],
+        arguments: tc[:arguments].is_a?(String) ? tc[:arguments] : tc[:arguments].to_json
+      }
+    end
+    @stubbed_responses << {role: "assistant", content: content, tool_calls: formatted_tool_calls}
+  end
+
+  # Clears all stubbed responses
+  def clear_stubs
+    @stubbed_responses = []
   end
 
   private
 
-  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
+  def next_response
+    if @stubbed_responses.any?
+      @stubbed_responses.shift
+    elsif @responses[@current_index]
+      response = @responses[@current_index]
+      @current_index += 1
+      response
+    else
+      {role: "assistant", content: "Test response"}
+    end
+  end
+
+  def perform_generate_text(messages, model: nil, **options)
+    @calls << {messages: messages.map(&:to_h), model: model, **options}
+    response = next_response
 
     if response.is_a?(Hash)
       Riffer::Messages::Assistant.new(response[:content], tool_calls: response[:tool_calls] || [])
@@ -30,26 +60,32 @@ class Riffer::Providers::Test < Riffer::Providers::Base
     end
   end
 
-  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
+  def perform_stream_text(messages, model: nil, **options)
+    @calls << {messages: messages.map(&:to_h), model: model, **options}
+    response = next_response
     Enumerator.new do |yielder|
-      if @stubbed_reasoning
-        reasoning_parts = @stubbed_reasoning.split(". ").map { |part| part + (part.end_with?(".") ? "" : ".") }
+      full_content = response[:content] || ""
+      tool_calls = response[:tool_calls] || []
 
-        reasoning_parts.each do |part|
-          yielder << Riffer::StreamEvents::ReasoningDelta.new(part + " ")
+      unless full_content.empty?
+        content_parts = full_content.split(". ").map { |part| part + (part.end_with?(".") ? "" : ".") }
+        content_parts.each do |part|
+          yielder << Riffer::StreamEvents::TextDelta.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?(".") ? "" : ".") }
-
-      content_parts.each do |part|
-        yielder << Riffer::StreamEvents::TextDelta.new(part + " ")
+      tool_calls.each do |tc|
+        yielder << Riffer::StreamEvents::ToolCallDelta.new(
+          item_id: tc[:id],
+          name: tc[:name],
+          arguments_delta: tc[:arguments]
+        )
+        yielder << Riffer::StreamEvents::ToolCallDone.new(
+          item_id: tc[:id],
+          call_id: tc[:call_id],
+          name: tc[:name],
+          arguments: tc[:arguments]
+        )
       end
 
       yielder << Riffer::StreamEvents::TextDone.new(full_content)

data/lib/riffer/stream_events/tool_call_delta.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Riffer::StreamEvents::ToolCallDelta represents an incremental tool call chunk during streaming.
+#
+# Emitted when the LLM is building a tool call, containing partial argument data.
+#
+# @api public
+class Riffer::StreamEvents::ToolCallDelta < Riffer::StreamEvents::Base
+  attr_reader :item_id, :name, :arguments_delta
+
+  # Creates a new tool call delta event
+  # @param item_id [String] the tool call item identifier
+  # @param name [String, nil] the tool name (may only be present in first delta)
+  # @param arguments_delta [String] the incremental arguments JSON fragment
+  # @param role [String] the message role (defaults to "assistant")
+  def initialize(item_id:, arguments_delta:, name: nil, role: "assistant")
+    super(role: role)
+    @item_id = item_id
+    @name = name
+    @arguments_delta = arguments_delta
+  end
+
+  # Converts the event to a hash
+  # @return [Hash] the event data
+  def to_h
+    {role: @role, item_id: @item_id, name: @name, arguments_delta: @arguments_delta}.compact
+  end
+end

data/lib/riffer/stream_events/tool_call_done.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Riffer::StreamEvents::ToolCallDone represents a completed tool call during streaming.
+#
+# Emitted when the LLM has finished building a tool call with complete arguments.
+#
+# @api public
+class Riffer::StreamEvents::ToolCallDone < Riffer::StreamEvents::Base
+  attr_reader :item_id, :call_id, :name, :arguments
+
+  # Creates a new tool call done event
+  # @param item_id [String] the tool call item identifier
+  # @param call_id [String] the call identifier for response matching
+  # @param name [String] the tool name
+  # @param arguments [String] the complete arguments JSON string
+  # @param role [String] the message role (defaults to "assistant")
+  def initialize(item_id:, call_id:, name:, arguments:, role: "assistant")
+    super(role: role)
+    @item_id = item_id
+    @call_id = call_id
+    @name = name
+    @arguments = arguments
+  end
+
+  # Converts the event to a hash
+  # @return [Hash] the event data
+  def to_h
+    {role: @role, item_id: @item_id, call_id: @call_id, name: @name, arguments: @arguments}
+  end
+end