rcrewai 0.7.1 → 0.8.0

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 << {
@@ -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
 

data/lib/rcrewai/tool_runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'securerandom'
 require_relative 'events'
 require_relative 'provider_schema'
 
@@ -16,7 +17,13 @@ module RCrewAI
       @sink = event_sink || ->(_) {}
     end
 
-    def run(messages:) # rubocop:disable Metrics/AbcSize
+    def run(messages:)
+      Events.with_parent(@run_span_id ||= SecureRandom.uuid) { run_loop(messages: messages) }
+    end
+
+    private
+
+    def run_loop(messages:) # rubocop:disable Metrics/AbcSize
       msgs = messages.dup
       history = []
       iter = 0
@@ -78,8 +85,6 @@ module RCrewAI
                finish_reason: :max_iterations, usage: total_usage)
     end
 
-    private
-
     # Trims the message list to the model's context window when the agent
     # supports it; a no-op otherwise.
     def fit_context(messages)
@@ -94,13 +99,13 @@ module RCrewAI
       type_sym = klass.name.split('::').last
                       .gsub(/([A-Z])/) { "_#{Regexp.last_match(1).downcase}" }
                       .sub(/^_/, '').to_sym
-      @sink.call(klass.new(
-                   type: type_sym,
-                   timestamp: Time.now,
-                   agent: agent_name,
-                   iteration: iteration,
-                   **attrs
-                 ))
+      Events.emit(@sink, klass.new(
+                           type: type_sym,
+                           timestamp: Time.now,
+                           agent: agent_name,
+                           iteration: iteration,
+                           **attrs
+                         ))
     end
 
     def agent_name
@@ -110,6 +115,7 @@ module RCrewAI
     def retag(event, iter)
       event.agent = agent_name if event.respond_to?(:agent=) && event.agent.nil?
       event.iteration = iter if event.respond_to?(:iteration=) && event.iteration.nil?
+      event.parent_id ||= Events.current_parent
       event
     end
 

data/lib/rcrewai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RCrewAI
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
 end

data/lib/rcrewai.rb

@@ -19,6 +19,7 @@ end
 require_relative 'rcrewai/version'
 require_relative 'rcrewai/configuration'
 require_relative 'rcrewai/events'
+require_relative 'rcrewai/checkpoint'
 require_relative 'rcrewai/sse_parser'
 require_relative 'rcrewai/pricing'
 require_relative 'rcrewai/llm_client'
@@ -56,3 +57,5 @@ require_relative 'rcrewai/task'
 require_relative 'rcrewai/crew'
 require_relative 'rcrewai/flow'
 require_relative 'rcrewai/mcp'
+require_relative 'rcrewai/checkpoint/cli'
+require_relative 'rcrewai/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcrewai
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - gkosmo
@@ -389,6 +389,8 @@ files:
 - lib/rcrewai/agent.rb
 - lib/rcrewai/agent_augmentations.rb
 - lib/rcrewai/async_executor.rb
+- lib/rcrewai/checkpoint.rb
+- lib/rcrewai/checkpoint/cli.rb
 - lib/rcrewai/cli.rb
 - lib/rcrewai/configuration.rb
 - lib/rcrewai/context_window.rb
@@ -409,9 +411,13 @@ files:
 - lib/rcrewai/llm_clients/anthropic.rb
 - lib/rcrewai/llm_clients/azure.rb
 - lib/rcrewai/llm_clients/base.rb
+- lib/rcrewai/llm_clients/bedrock.rb
 - lib/rcrewai/llm_clients/google.rb
 - lib/rcrewai/llm_clients/ollama.rb
 - lib/rcrewai/llm_clients/openai.rb
+- lib/rcrewai/llm_clients/openai_compatible.rb
+- lib/rcrewai/llm_clients/openai_responses.rb
+- lib/rcrewai/llm_clients/snowflake_cortex.rb
 - lib/rcrewai/mcp.rb
 - lib/rcrewai/mcp/client.rb
 - lib/rcrewai/mcp/tool_adapter.rb