rcrewai 0.7.0 → 0.8.0

data/lib/rcrewai/llm_clients/bedrock.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'faraday'
+require 'json'
+require_relative 'base'
+require_relative '../events'
+require_relative '../pricing'
+
+module RCrewAI
+  module LLMClients
+    # AWS Bedrock via the Converse API (v4). Converse gives every Bedrock model
+    # one request/response shape regardless of the underlying vendor, so this
+    # client speaks Converse rather than each model's native format.
+    #
+    # Authentication: the configured api_key is sent as a bearer token, which
+    # covers Bedrock API keys and any gateway fronting Bedrock. Full SigV4
+    # request signing is not implemented -- it needs the aws-sigv4 gem, and
+    # adding a hard AWS dependency for one provider is not worth it. Users
+    # needing SigV4 can sign via a before_request hook.
+    class Bedrock < Base
+      STOP_REASONS = {
+        'end_turn' => :stop,
+        'stop_sequence' => :stop,
+        'max_tokens' => :length,
+        'tool_use' => :tool_calls,
+        'content_filtered' => :content_filter
+      }.freeze
+
+      def initialize(config = RCrewAI.configuration, **hooks)
+        super
+        @region = config.aws_region
+      end
+
+      def provider_name
+        :bedrock
+      end
+
+      def chat(messages:, tools: nil, tool_choice: :auto, stream: nil, **options) # rubocop:disable Lint/UnusedMethodArgument
+        system_text = extract_system(messages)
+        payload = {
+          messages: format_messages(messages),
+          inferenceConfig: {
+            temperature: options[:temperature] || config.temperature,
+            maxTokens: options[:max_tokens] || config.max_tokens
+          }.compact
+        }
+        payload[:system] = [{ text: system_text }] if system_text
+        payload[:toolConfig] = { tools: format_tools(tools) } if tools && !tools.empty?
+
+        plain_chat(payload)
+      end
+
+      # Converse exposes tool use uniformly, but streaming uses a separate
+      # endpoint and event-stream framing that this client does not implement.
+      def supports_native_tools?(model: config.model) # rubocop:disable Lint/UnusedMethodArgument
+        true
+      end
+
+      private
+
+      def plain_chat(payload)
+        url = converse_url
+        payload = apply_before_request(payload)
+        started_at = Time.now
+        log_request(:post, url, payload)
+        response = http_client.post(url, payload, build_headers.merge(auth_header))
+        log_response(response)
+        body = handle_response(response)
+        apply_after_response(normalize(body), started_at)
+      end
+
+      def converse_url
+        "https://bedrock-runtime.#{@region}.amazonaws.com/model/#{CGI.escape(config.model)}/converse"
+      end
+
+      # Converse carries the system prompt at the top level, not in messages.
+      def extract_system(messages)
+        systems = messages.select { |m| m.is_a?(Hash) && m[:role].to_s == 'system' }
+        return nil if systems.empty?
+
+        systems.map { |m| m[:content] }.join("\n\n")
+      end
+
+      # Every message content is a list of typed blocks.
+      def format_messages(messages)
+        messages.reject { |m| m.is_a?(Hash) && m[:role].to_s == 'system' }.map do |m|
+          { role: m[:role].to_s, content: [{ text: m[:content].to_s }] }
+        end
+      end
+
+      def format_tools(tools)
+        tools.map do |t|
+          { toolSpec: { name: t[:name], description: t[:description],
+                        inputSchema: { json: t[:parameters] } } }
+        end
+      end
+
+      def normalize(body)
+        blocks = body.dig('output', 'message', 'content') || []
+        text = blocks.filter_map { |b| b['text'] }.join
+        tool_calls = blocks.filter_map do |b|
+          use = b['toolUse']
+          next unless use
+
+          { id: use['toolUseId'], name: use['name'], arguments: use['input'] || {} }
+        end
+
+        {
+          content: text.empty? ? nil : text,
+          tool_calls: tool_calls,
+          usage: {
+            prompt_tokens: body.dig('usage', 'inputTokens'),
+            completion_tokens: body.dig('usage', 'outputTokens'),
+            total_tokens: body.dig('usage', 'totalTokens')
+          },
+          finish_reason: STOP_REASONS.fetch(body['stopReason'], :stop),
+          model: config.model,
+          provider: provider_name
+        }
+      end
+
+      def auth_header
+        { 'Authorization' => "Bearer #{config.api_key}" }
+      end
+
+      def validate_config!
+        raise ConfigurationError, 'Bedrock API key is required' unless config.api_key
+        raise ConfigurationError, 'An AWS region is required for Bedrock' unless config.aws_region
+        raise ConfigurationError, 'Model is required' unless config.model
+      end
+    end
+  end
+end

data/lib/rcrewai/llm_clients/google.rb

@@ -20,8 +20,8 @@ module RCrewAI
         'RECITATION' => :stop
       }.freeze
 
-      def initialize(config = RCrewAI.configuration)
-        super
+      def initialize(config = RCrewAI.configuration, **hooks)
+        super(config, **hooks)
         @base_url = BASE_URL
       end
 
@@ -62,17 +62,25 @@ module RCrewAI
         %w[gemini-pro gemini-1.5-pro gemini-1.5-flash gemini-pro-vision]
       end
 
+      def provider_name
+        :google
+      end
+
       private
 
       def plain_chat(url, payload)
+        payload = apply_before_request(payload)
+        started_at = Time.now
         log_request(:post, url, payload)
         response = http_client.post(url, payload, build_headers)
         log_response(response)
         body = handle_response(response)
-        normalize_non_streaming(body)
+        apply_after_response(normalize_non_streaming(body), started_at)
       end
 
       def stream_chat(url, payload, sink)
+        payload = apply_before_request(payload)
+        started_at = Time.now
         log_request(:post, url, payload)
 
         assembled_text = +''
@@ -123,7 +131,7 @@ module RCrewAI
 
         finish_reason = :tool_calls if tool_calls.any?
 
-        {
+        result = {
           content: assembled_text.empty? ? nil : assembled_text,
           tool_calls: tool_calls,
           usage: usage || {},
@@ -131,6 +139,7 @@ module RCrewAI
           model: config.model,
           provider: :google
         }
+        apply_after_response(result, started_at)
       end
 
       def streaming_post(url, payload, &on_chunk)

data/lib/rcrewai/llm_clients/ollama.rb

@@ -21,8 +21,8 @@ module RCrewAI
         firefunction-v2
       ].freeze
 
-      def initialize(config = RCrewAI.configuration)
-        super
+      def initialize(config = RCrewAI.configuration, **hooks)
+        super(config, **hooks)
         @base_url = config.base_url || ollama_url || DEFAULT_URL
       end
 
@@ -78,17 +78,25 @@ module RCrewAI
         handle_response(response)
       end
 
+      def provider_name
+        :ollama
+      end
+
       private
 
       def plain_chat(url, payload)
+        payload = apply_before_request(payload)
+        started_at = Time.now
         log_request(:post, url, payload)
         response = http_client.post(url, payload, build_headers)
         log_response(response)
         body = handle_response(response)
-        normalize_non_streaming(body)
+        apply_after_response(normalize_non_streaming(body), started_at)
       end
 
       def stream_chat(url, payload, sink)
+        payload = apply_before_request(payload)
+        started_at = Time.now
         log_request(:post, url, payload)
 
         assembled_text = +''
@@ -145,8 +153,14 @@ module RCrewAI
                     ))
         end
 
+        result = stream_result(assembled_text, tool_calls, finish_reason,
+                               prompt_tokens, completion_tokens)
+        apply_after_response(result, started_at)
+      end
+
+      def stream_result(text, tool_calls, finish_reason, prompt_tokens, completion_tokens)
         {
-          content: assembled_text.empty? ? nil : assembled_text,
+          content: text.empty? ? nil : text,
           tool_calls: tool_calls,
           usage: {
             prompt_tokens: prompt_tokens,

data/lib/rcrewai/llm_clients/openai.rb

@@ -13,8 +13,8 @@ module RCrewAI
     class OpenAI < Base
       BASE_URL = 'https://api.openai.com/v1'
 
-      def initialize(config = RCrewAI.configuration)
-        super
+      def initialize(config = RCrewAI.configuration, **hooks)
+        super(config, **hooks)
         @base_url = BASE_URL
       end
 
@@ -49,6 +49,10 @@ module RCrewAI
         true
       end
 
+      def provider_name
+        :openai
+      end
+
       def models
         url = "#{@base_url}/models"
         response = http_client.get(url, {}, build_headers.merge(auth_header))
@@ -64,15 +68,19 @@ module RCrewAI
 
       def plain_chat(payload)
         url = chat_url
+        payload = apply_before_request(payload)
+        started_at = Time.now
         log_request(:post, url, payload)
         response = http_client.post(url, payload, build_headers.merge(auth_header))
         log_response(response)
         body = handle_response(response)
-        normalize_non_streaming(body)
+        apply_after_response(normalize_non_streaming(body), started_at)
       end
 
       def stream_chat(payload, sink) # rubocop:disable Metrics/AbcSize
         url = chat_url
+        payload = apply_before_request(payload)
+        started_at = Time.now
         log_request(:post, url, payload)
 
         assembled_text = +''
@@ -137,18 +145,14 @@ module RCrewAI
                     ))
         end
 
-        {
-          content: assembled_text.empty? ? nil : assembled_text,
-          tool_calls: tool_calls,
-          usage: final_usage || {},
-          finish_reason: finish_reason || :stop,
-          model: config.model,
-          provider: provider_name
-        }
-      end
-
-      def provider_name
-        :openai
+        apply_after_response({
+                               content: assembled_text.empty? ? nil : assembled_text,
+                               tool_calls: tool_calls,
+                               usage: final_usage || {},
+                               finish_reason: finish_reason || :stop,
+                               model: config.model,
+                               provider: provider_name
+                             }, started_at)
       end
 
       def streaming_post(url, payload, &on_chunk)

data/lib/rcrewai/llm_clients/openai_compatible.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'openai'
+
+module RCrewAI
+  module LLMClients
+    # Any endpoint speaking the OpenAI Chat Completions wire format: Together,
+    # Groq, Fireworks, vLLM, LiteLLM, OpenRouter, a self-hosted gateway. Only
+    # the base URL differs, so this is OpenAI with the endpoint made explicit
+    # and required.
+    class OpenAICompatible < OpenAI
+      def initialize(config = RCrewAI.configuration, **hooks)
+        super
+        @base_url = config.base_url.chomp('/')
+      end
+
+      def provider_name
+        :openai_compatible
+      end
+
+      private
+
+      def validate_config!
+        raise ConfigurationError, 'API key is required' unless config.api_key
+        raise ConfigurationError, 'A base url is required for an OpenAI-compatible provider' unless config.base_url
+        raise ConfigurationError, 'Model is required' unless config.model
+      end
+
+      def auth_header
+        { 'Authorization' => "Bearer #{config.api_key}" }
+      end
+    end
+  end
+end

data/lib/rcrewai/llm_clients/openai_responses.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'openai'
+
+module RCrewAI
+  module LLMClients
+    # OpenAI's Responses API. Same host and auth as Chat Completions, but a
+    # different request and response shape:
+    #
+    #   - messages go under :input, and the system prompt under :instructions
+    #   - :max_tokens becomes :max_output_tokens
+    #   - the reply is an :output array of typed items (message, function_call,
+    #     reasoning, ...) rather than a single choice
+    #   - usage is input_tokens / output_tokens
+    #
+    # Only the non-streaming path is implemented; Responses streams a distinct
+    # set of semantic events that the SSE assembly here does not model.
+    class OpenAIResponses < OpenAI
+      def provider_name
+        :openai_responses
+      end
+
+      def chat(messages:, tools: nil, tool_choice: :auto, stream: nil, **options) # rubocop:disable Lint/UnusedMethodArgument
+        payload = {
+          model: config.model,
+          input: format_input(messages),
+          temperature: options[:temperature] || config.temperature,
+          max_output_tokens: options[:max_tokens] || config.max_tokens
+        }.compact
+
+        instructions = extract_instructions(messages)
+        payload[:instructions] = instructions if instructions
+
+        if tools && !tools.empty?
+          payload[:tools] = format_tools(tools)
+          payload[:tool_choice] = tool_choice if tool_choice != :auto
+        end
+
+        plain_chat(payload)
+      end
+
+      private
+
+      def chat_url
+        "#{@base_url}/responses"
+      end
+
+      # Responses carries the system prompt out-of-band as :instructions.
+      def extract_instructions(messages)
+        systems = messages.select { |m| m.is_a?(Hash) && m[:role].to_s == 'system' }
+        return nil if systems.empty?
+
+        systems.map { |m| m[:content] }.join("\n\n")
+      end
+
+      def format_input(messages)
+        messages.reject { |m| m.is_a?(Hash) && m[:role].to_s == 'system' }
+                .map { |m| { role: m[:role].to_s, content: m[:content] } }
+      end
+
+      # Responses flattens the function definition instead of nesting it under
+      # a :function key the way Chat Completions does.
+      def format_tools(tools)
+        tools.map do |t|
+          { type: 'function', name: t[:name], description: t[:description],
+            parameters: t[:parameters] }
+        end
+      end
+
+      def normalize_non_streaming(body)
+        output = Array(body['output'])
+        text = extract_text(output)
+        tool_calls = extract_tool_calls(output)
+
+        {
+          content: text.empty? ? nil : text,
+          tool_calls: tool_calls,
+          usage: {
+            prompt_tokens: body.dig('usage', 'input_tokens'),
+            completion_tokens: body.dig('usage', 'output_tokens'),
+            total_tokens: body.dig('usage', 'total_tokens')
+          },
+          finish_reason: finish_reason_for(body, tool_calls),
+          model: body['model'] || config.model,
+          provider: provider_name
+        }
+      end
+
+      def extract_text(output)
+        output.select { |item| item['type'] == 'message' }
+              .flat_map { |item| Array(item['content']) }
+              .select { |part| part['type'] == 'output_text' }
+              .map { |part| part['text'] }
+              .join
+      end
+
+      def extract_tool_calls(output)
+        output.select { |item| item['type'] == 'function_call' }.map do |item|
+          {
+            id: item['call_id'] || item['id'],
+            name: item['name'],
+            arguments: parse_arguments(item['arguments'])
+          }
+        end
+      end
+
+      def parse_arguments(raw)
+        return {} if raw.nil? || raw.empty?
+
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def finish_reason_for(body, tool_calls)
+        return :tool_calls if tool_calls.any?
+
+        if body['status'] == 'incomplete'
+          reason = body.dig('incomplete_details', 'reason')
+          return reason == 'max_output_tokens' ? :length : :incomplete
+        end
+
+        :stop
+      end
+    end
+  end
+end

data/lib/rcrewai/llm_clients/snowflake_cortex.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'openai'
+
+module RCrewAI
+  module LLMClients
+    # Snowflake Cortex inference. The request/response bodies follow the
+    # OpenAI Chat Completions shape, so only the endpoint and the auth headers
+    # differ -- Cortex wants the token type declared alongside the bearer
+    # token.
+    class SnowflakeCortex < OpenAI
+      def initialize(config = RCrewAI.configuration, **hooks)
+        super
+        @account = config.snowflake_account
+        @base_url = "https://#{@account}.snowflakecomputing.com"
+      end
+
+      def provider_name
+        :snowflake
+      end
+
+      private
+
+      def chat_url
+        "#{@base_url}/api/v2/cortex/inference:complete"
+      end
+
+      def auth_header
+        {
+          'Authorization' => "Bearer #{config.api_key}",
+          'X-Snowflake-Authorization-Token-Type' => 'KEYPAIR_JWT'
+        }
+      end
+
+      def validate_config!
+        raise ConfigurationError, 'Snowflake token is required' unless config.api_key
+        raise ConfigurationError, 'A Snowflake account identifier is required' unless config.snowflake_account
+        raise ConfigurationError, 'Model is required' unless config.model
+      end
+    end
+  end
+end

data/lib/rcrewai/process.rb

@@ -17,6 +17,18 @@ module RCrewAI
 
       protected
 
+      # True when this task's result was replayed from a checkpoint and so must
+      # not be executed again.
+      def restored?(task)
+        crew.respond_to?(:restored_task_names) &&
+          crew.restored_task_names.include?(task.name)
+      end
+
+      # Records a settled task in the crew's checkpoint, if one is active.
+      def checkpoint(task, status)
+        crew.checkpoint_task(task, status) if crew.respond_to?(:checkpoint_task)
+      end
+
       def log_execution_start
         @logger.info "Starting #{self.class.name.split('::').last.downcase} process execution"
         @logger.info "Crew: #{crew.name} with #{crew.agents.length} agents, #{crew.tasks.length} tasks"
@@ -34,13 +46,21 @@ module RCrewAI
         results = []
 
         crew.tasks.each do |task|
+          if restored?(task)
+            @logger.info "Skipping task (restored from checkpoint): #{task.name}"
+            results << { task: task, result: task.result, status: :completed }
+            next
+          end
+
           @logger.info "Executing task: #{task.name}"
           begin
             result = task.execute
             results << { task: task, result: result, status: :completed }
+            checkpoint(task, :completed)
           rescue StandardError => e
             @logger.error "Task #{task.name} failed: #{e.message}"
             results << { task: task, result: e.message, status: :failed }
+            checkpoint(task, :failed)
           end
         end
 
@@ -241,6 +261,15 @@ module RCrewAI
         tasks.each do |task|
           assigned_agent = hierarchy[:task_assignments][task]
 
+          if restored?(task)
+            @logger.info "Skipping task (restored from checkpoint): #{task.name}"
+            phase_results << {
+              task: task, result: task.result, status: :completed,
+              assigned_agent: assigned_agent, phase: phase_number
+            }
+            next
+          end
+
           @logger.info "Manager delegating '#{task.name}' to #{assigned_agent.name}"
 
           begin
@@ -258,8 +287,10 @@ module RCrewAI
               phase: phase_number
             }
 
+            checkpoint(task, :completed)
             @logger.info "Task '#{task.name}' completed successfully"
           rescue StandardError => e
+            checkpoint(task, :failed)
             @logger.error "Delegated task '#{task.name}' failed: #{e.message}"
 
             phase_results << {
@@ -351,7 +382,7 @@ module RCrewAI
         end
 
         # Execute the task
-        agent.execute_task(enhanced_task)
+        agent.execute_task(enhanced_task, stream: crew.stream_sink)
       end
 
       def should_abort_execution?(failed_tasks, phase_number, _plan)
@@ -390,11 +421,17 @@ module RCrewAI
       private
 
       def execute_with_consensus(task)
+        if restored?(task)
+          @logger.info "Skipping task (restored from checkpoint): #{task.name}"
+          return { task: task, result: task.result, status: :completed }
+        end
+
         @logger.info "Consensus for task: #{task.name}"
         participants = select_participants(task)
         candidates = gather_proposals(task, participants)
 
         if candidates.empty?
+          checkpoint(task, :failed)
           return { task: task, result: 'All agents failed to produce a proposal', status: :failed }
         end
 
@@ -402,9 +439,11 @@ module RCrewAI
         winner = pick_winner(task, scored)
         task.result = winner[:content] if task.respond_to?(:result=)
 
+        checkpoint(task, :completed)
         { task: task, result: winner[:content], status: :completed }
       rescue StandardError => e
         @logger.error "Consensus failed for #{task.name}: #{e.message}"
+        checkpoint(task, :failed)
         { task: task, result: e.message, status: :failed }
       end
 
@@ -421,7 +460,7 @@ module RCrewAI
 
       def gather_proposals(task, participants)
         participants.filter_map do |agent|
-          content = extract_content(agent.execute_task(task))
+          content = extract_content(agent.execute_task(task, stream: crew.stream_sink))
           { agent: agent, content: content }
         rescue StandardError => e
           @logger.warn "Agent #{agent.name} failed to propose: #{e.message}"

data/lib/rcrewai/task.rb

@@ -10,7 +10,7 @@ module RCrewAI
     include HumanInteractionExtensions
     attr_reader :name, :description, :agent, :context, :expected_output, :tools, :async,
                 :raw_result, :structured_output, :attachments
-    attr_accessor :result, :status, :start_time, :end_time, :execution_time
+    attr_accessor :result, :status, :start_time, :end_time, :execution_time, :stream_sink
 
     def initialize(name:, description:, agent: nil, **options)
       @name = name
@@ -44,6 +44,7 @@ module RCrewAI
       @start_time = nil
       @end_time = nil
       @execution_time = nil
+      @stream_sink = nil
       @retry_count = 0
       @max_retries = options.fetch(:max_retries, 2)
     end
@@ -218,7 +219,7 @@ module RCrewAI
 
       loop do
         attempts += 1
-        raw = extract_content(agent.execute_task(self))
+        raw = extract_content(agent.execute_task(self, stream: @stream_sink))
         @raw_result = raw
 
         begin