rcrewai 0.2.1 → 0.3.0

data/lib/rcrewai/async_executor.rb

@@ -12,7 +12,7 @@ module RCrewAI
       @timeout = options.fetch(:timeout, 300) # 5 minutes default
       @logger = Logger.new($stdout)
       @logger.level = options.fetch(:verbose, false) ? Logger::DEBUG : Logger::INFO
-      
+
       # Create thread pool for task execution
       @thread_pool = Concurrent::ThreadPoolExecutor.new(
         min_threads: 1,
@@ -20,7 +20,7 @@ module RCrewAI
         max_queue: @max_concurrency * 2,
         fallback_policy: :caller_runs
       )
-      
+
       @futures = {}
       @task_dependencies = {}
       @completed_tasks = Concurrent::Set.new
@@ -29,30 +29,30 @@ module RCrewAI
 
     def execute_tasks_async(tasks, dependency_graph = {})
       @logger.info "Starting async execution of #{tasks.length} tasks with max #{@max_concurrency} concurrent threads"
-      
+
       @task_dependencies = dependency_graph
       execution_phases = organize_tasks_by_dependencies(tasks)
-      
+
       start_time = Time.now
       results = []
-      
+
       execution_phases.each_with_index do |phase_tasks, phase_index|
         @logger.info "Executing phase #{phase_index + 1}: #{phase_tasks.length} tasks"
-        
+
         phase_results = execute_phase_concurrently(phase_tasks, phase_index + 1)
         results.concat(phase_results)
-        
+
         # Check if we should continue
         failed_in_phase = phase_results.count { |r| r[:status] == :failed }
-        if failed_in_phase > 0 && should_abort_after_failures?(failed_in_phase, phase_tasks.length)
+        if failed_in_phase.positive? && should_abort_after_failures?(failed_in_phase, phase_tasks.length)
           @logger.error "Aborting execution due to #{failed_in_phase} failures in phase #{phase_index + 1}"
           break
         end
       end
-      
+
       total_time = Time.now - start_time
       @logger.info "Async execution completed in #{total_time.round(2)}s"
-      
+
       format_async_results(results, total_time)
     end
 
@@ -60,38 +60,36 @@ module RCrewAI
       future = Concurrent::Future.execute(executor: @thread_pool) do
         execute_task_with_monitoring(task)
       end
-      
+
       @futures[task] = future
       future
     end
 
     def wait_for_completion(futures, timeout = nil)
       timeout ||= @timeout
-      
+
       results = []
       futures.each do |task, future|
-        begin
-          result = future.value(timeout)
-          results << { task: task, result: result, status: :completed }
-        rescue Concurrent::TimeoutError
-          @logger.error "Task #{task.name} timed out after #{timeout}s"
-          results << { task: task, result: "Task timed out", status: :timeout }
-        rescue => e
-          @logger.error "Task #{task.name} failed: #{e.message}"
-          results << { task: task, result: e.message, status: :failed }
-        end
+        result = future.value(timeout)
+        results << { task: task, result: result, status: :completed }
+      rescue Concurrent::TimeoutError
+        @logger.error "Task #{task.name} timed out after #{timeout}s"
+        results << { task: task, result: 'Task timed out', status: :timeout }
+      rescue StandardError => e
+        @logger.error "Task #{task.name} failed: #{e.message}"
+        results << { task: task, result: e.message, status: :failed }
       end
-      
+
       results
     end
 
     def shutdown
-      @logger.info "Shutting down async executor..."
+      @logger.info 'Shutting down async executor...'
       @thread_pool.shutdown
-      unless @thread_pool.wait_for_termination(30)
-        @logger.warn "Thread pool did not shut down gracefully, forcing shutdown"
-        @thread_pool.kill
-      end
+      return if @thread_pool.wait_for_termination(30)
+
+      @logger.warn 'Thread pool did not shut down gracefully, forcing shutdown'
+      @thread_pool.kill
     end
 
     def stats
@@ -136,7 +134,7 @@ module RCrewAI
 
     def execute_phase_concurrently(phase_tasks, phase_number)
       @logger.debug "Phase #{phase_number}: Launching #{phase_tasks.length} concurrent tasks"
-      
+
       # Launch all tasks in this phase concurrently
       phase_futures = {}
       phase_tasks.each do |task|
@@ -146,7 +144,7 @@ module RCrewAI
 
       # Wait for all tasks in this phase to complete
       phase_results = wait_for_completion(phase_futures)
-      
+
       # Update tracking sets
       phase_results.each do |result|
         case result[:status]
@@ -156,31 +154,33 @@ module RCrewAI
           @failed_tasks.add(result[:task])
         end
       end
-      
-      @logger.info "Phase #{phase_number} completed: #{phase_results.count { |r| r[:status] == :completed }}/#{phase_tasks.length} successful"
-      
+
+      @logger.info "Phase #{phase_number} completed: #{phase_results.count do |r|
+        r[:status] == :completed
+      end}/#{phase_tasks.length} successful"
+
       phase_results.map { |r| r.merge(phase: phase_number) }
     end
 
     def execute_task_with_monitoring(task)
       thread_id = Thread.current.object_id
       @logger.debug "Task #{task.name} starting on thread #{thread_id}"
-      
+
       start_time = Time.now
-      
+
       begin
         # Add async context to task
         task.instance_variable_set(:@async_execution, true)
         task.instance_variable_set(:@thread_id, thread_id)
-        
+
         # Execute the task
         result = task.execute
-        
+
         execution_time = Time.now - start_time
         @logger.debug "Task #{task.name} completed in #{execution_time.round(2)}s on thread #{thread_id}"
-        
+
         result
-      rescue => e
+      rescue StandardError => e
         execution_time = Time.now - start_time
         @logger.error "Task #{task.name} failed after #{execution_time.round(2)}s on thread #{thread_id}: #{e.message}"
         raise e
@@ -189,7 +189,7 @@ module RCrewAI
 
     def should_abort_after_failures?(failed_count, total_count)
       failure_rate = failed_count.to_f / total_count
-      
+
       # Abort if more than 50% of tasks in a phase fail
       failure_rate > 0.5
     end
@@ -198,7 +198,7 @@ module RCrewAI
       completed = results.count { |r| r[:status] == :completed }
       failed = results.count { |r| r[:status] == :failed }
       timed_out = results.count { |r| r[:status] == :timeout }
-      
+
       {
         execution_mode: :async,
         total_time: total_time,
@@ -227,7 +227,7 @@ module RCrewAI
     module ClassMethods
       def execute_async(tasks, **options)
         executor = AsyncExecutor.new(**options)
-        
+
         begin
           results = executor.execute_tasks_async(tasks)
           results
@@ -245,4 +245,4 @@ module RCrewAI
       @thread_id
     end
   end
-end
+end

data/lib/rcrewai/cli.rb

@@ -2,14 +2,14 @@
 
 module RCrewAI
   class CLI < Thor
-    desc "new CREW_NAME", "Create a new AI crew"
+    desc 'new CREW_NAME', 'Create a new AI crew'
     def new(crew_name)
       puts "Creating new crew: #{crew_name}"
       Crew.create(crew_name)
     end
 
-    desc "run", "Run the AI crew"
-    option :crew, type: :string, required: true, desc: "Name of the crew to run"
+    desc 'run', 'Run the AI crew'
+    option :crew, type: :string, required: true, desc: 'Name of the crew to run'
     def run
       crew_name = options[:crew]
       puts "Running crew: #{crew_name}"
@@ -17,23 +17,23 @@ module RCrewAI
       crew.execute
     end
 
-    desc "list", "List all available crews"
+    desc 'list', 'List all available crews'
     def list
-      puts "Available crews:"
+      puts 'Available crews:'
       Crew.list.each do |crew|
         puts "  - #{crew}"
       end
     end
 
-    desc "agent SUBCOMMAND ...ARGS", "Manage agents"
-    subcommand "agent", Agent::CLI
+    desc 'agent SUBCOMMAND ...ARGS', 'Manage agents'
+    subcommand 'agent', Agent::CLI
 
-    desc "task SUBCOMMAND ...ARGS", "Manage tasks"
-    subcommand "task", Task::CLI
+    desc 'task SUBCOMMAND ...ARGS', 'Manage tasks'
+    subcommand 'task', Task::CLI
 
-    desc "version", "Show version"
+    desc 'version', 'Show version'
     def version
       puts "rcrewai version #{RCrewAI::VERSION}"
     end
   end
-end
+end

data/lib/rcrewai/configuration.rb

@@ -2,10 +2,11 @@
 
 module RCrewAI
   class Configuration
-    attr_accessor :llm_provider, :api_key, :model, :temperature, :max_tokens, :timeout
-    attr_accessor :openai_api_key, :anthropic_api_key, :google_api_key, :azure_api_key
-    attr_accessor :openai_model, :anthropic_model, :google_model, :azure_model
-    attr_accessor :base_url, :api_version, :deployment_name
+    attr_accessor :llm_provider, :api_key, :model, :temperature, :max_tokens, :timeout,
+                  :openai_api_key, :anthropic_api_key, :google_api_key, :azure_api_key,
+                  :openai_model, :anthropic_model, :google_model, :azure_model,
+                  :base_url, :api_version, :deployment_name,
+                  :pricing, :ollama_native_tools, :log_level
 
     def initialize
       @llm_provider = :openai
@@ -13,13 +14,17 @@ module RCrewAI
       @temperature = 0.1
       @max_tokens = 4000
       @timeout = 120
-      
+
       # Default models for each provider
       @openai_model = 'gpt-4'
       @anthropic_model = 'claude-3-sonnet-20240229'
       @google_model = 'gemini-pro'
       @azure_model = 'gpt-4'
-      
+
+      @pricing = nil
+      @ollama_native_tools = nil
+      @log_level = :info
+
       # Load from environment variables
       load_from_env
     end
@@ -55,7 +60,7 @@ module RCrewAI
     end
 
     def validate!
-      raise ConfigurationError, "LLM provider must be set" if @llm_provider.nil?
+      raise ConfigurationError, 'LLM provider must be set' if @llm_provider.nil?
       raise ConfigurationError, "API key must be set for #{@llm_provider}" if api_key.nil? || api_key.empty?
       raise ConfigurationError, "Model must be set for #{@llm_provider}" if model.nil? || model.empty?
     end
@@ -75,7 +80,7 @@ module RCrewAI
       @anthropic_api_key = ENV['ANTHROPIC_API_KEY'] || ENV['CLAUDE_API_KEY']
       @google_api_key = ENV['GOOGLE_API_KEY'] || ENV['GEMINI_API_KEY']
       @azure_api_key = ENV['AZURE_OPENAI_API_KEY']
-      
+
       @api_key = ENV['LLM_API_KEY'] if @api_key.nil?
       @base_url = ENV['LLM_BASE_URL'] if @base_url.nil?
       @api_version = ENV['AZURE_API_VERSION'] if @api_version.nil?
@@ -97,4 +102,4 @@ module RCrewAI
   def self.reset_configuration!
     @configuration = Configuration.new
   end
-end
+end

data/lib/rcrewai/crew.rb

@@ -2,6 +2,7 @@
 
 require_relative 'process'
 require_relative 'async_executor'
+require_relative 'events'
 
 module RCrewAI
   class Crew
@@ -28,7 +29,12 @@ module RCrewAI
       @tasks << task
     end
 
-    def execute(async: false, **async_options)
+    def execute(async: false, stream: nil, **async_options, &block)
+      sinks = []
+      sinks << block if block_given?
+      Array(stream).each { |s| sinks << s } if stream
+      @stream_sink = sinks.empty? ? nil : RCrewAI::Events.fan_out(sinks)
+
       if async
         execute_async(**async_options)
       else
@@ -36,9 +42,11 @@ module RCrewAI
       end
     end
 
+    attr_reader :stream_sink
+
     def execute_async(**options)
       puts "Executing crew: #{name} (async #{process_type} process)"
-      
+
       case process_type
       when :sequential
         execute_sequential_async(**options)
@@ -53,13 +61,13 @@ module RCrewAI
 
     def execute_sync
       puts "Executing crew: #{name} (#{process_type} process)"
-      
+
       # Create appropriate process instance
       @process_instance = create_process_instance
-      
+
       # Execute using the process
       results = @process_instance.execute
-      
+
       # Return formatted results
       format_execution_results(results)
     end
@@ -67,7 +75,7 @@ module RCrewAI
     def process=(new_process)
       @process_type = new_process.to_sym
       validate_process_type!
-      @process_instance = nil  # Reset process instance
+      @process_instance = nil # Reset process instance
     end
 
     def self.create(name)
@@ -84,7 +92,7 @@ module RCrewAI
 
     def self.list
       # List all available crews
-      ["example_crew", "research_crew", "development_crew"]
+      %w[example_crew research_crew development_crew]
     end
 
     def save
@@ -95,10 +103,10 @@ module RCrewAI
     private
 
     def validate_process_type!
-      valid_processes = [:sequential, :hierarchical, :consensual]
-      unless valid_processes.include?(process_type)
-        raise ConfigurationError, "Invalid process type: #{process_type}. Valid types: #{valid_processes.join(', ')}"
-      end
+      valid_processes = %i[sequential hierarchical consensual]
+      return if valid_processes.include?(process_type)
+
+      raise ConfigurationError, "Invalid process type: #{process_type}. Valid types: #{valid_processes.join(', ')}"
     end
 
     def create_process_instance
@@ -116,11 +124,11 @@ module RCrewAI
 
     def execute_sequential_async(**options)
       executor = AsyncExecutor.new(**options)
-      
+
       begin
         dependency_graph = build_dependency_graph
         results = executor.execute_tasks_async(tasks, dependency_graph)
-        
+
         # Add crew metadata
         results.merge(
           crew: name,
@@ -134,38 +142,36 @@ module RCrewAI
     def execute_hierarchical_async(**options)
       # For hierarchical async, we need to coordinate through the manager
       manager_agent = find_manager_agent
-      unless manager_agent
-        raise Process::ProcessError, "Hierarchical async execution requires a manager agent"
-      end
+      raise Process::ProcessError, 'Hierarchical async execution requires a manager agent' unless manager_agent
 
       puts "Manager #{manager_agent.name} coordinating async execution"
-      
+
       executor = AsyncExecutor.new(**options)
-      
+
       begin
         # Build execution phases respecting dependencies
         dependency_graph = build_dependency_graph
         phases = organize_tasks_into_phases(tasks, dependency_graph)
-        
+
         results = []
         phases.each_with_index do |phase_tasks, phase_index|
           puts "Manager delegating phase #{phase_index + 1}: #{phase_tasks.length} tasks"
-          
+
           # Create delegation contexts for each task
           phase_tasks.each do |task|
             unless task.agent
               # Manager assigns best agent for the task
               task.instance_variable_set(:@agent, find_best_agent_for_task(task))
             end
-            
+
             # Add delegation context
             add_delegation_context(task, manager_agent)
           end
-          
+
           # Execute phase concurrently
           phase_results = executor.execute_tasks_async(phase_tasks, {})
           results.concat(phase_results[:results])
-          
+
           # Check if we should abort
           failed_count = phase_results[:results].count { |r| r[:status] == :failed }
           if failed_count > phase_tasks.length * 0.5
@@ -173,7 +179,7 @@ module RCrewAI
             break
           end
         end
-        
+
         {
           crew: name,
           process: :async_hierarchical,
@@ -182,7 +188,13 @@ module RCrewAI
           completed_tasks: results.count { |r| r[:status] == :completed },
           failed_tasks: results.count { |r| r[:status] == :failed },
           results: results,
-          success_rate: results.empty? ? 0 : (results.count { |r| r[:status] == :completed }.to_f / results.length * 100).round(1)
+          success_rate: if results.empty?
+                          0
+                        else
+                          (results.count do |r|
+                            r[:status] == :completed
+                          end.to_f / results.length * 100).round(1)
+                        end
         }
       ensure
         executor.shutdown
@@ -192,11 +204,11 @@ module RCrewAI
     def execute_consensual_async(**options)
       # Simplified consensual async - execute in parallel with result aggregation
       executor = AsyncExecutor.new(**options)
-      
+
       begin
         # All tasks can potentially run in parallel for consensual
         results = executor.execute_tasks_async(tasks, {})
-        
+
         results.merge(
           crew: name,
           process: :async_consensual
@@ -239,30 +251,29 @@ module RCrewAI
     end
 
     def find_manager_agent
-      agents.find { |agent| agent.is_manager? } ||
-      agents.find { |agent| agent.allow_delegation }
+      agents.find(&:is_manager?) ||
+        agents.find(&:allow_delegation)
     end
 
     def find_best_agent_for_task(task)
       # Simple heuristic: match keywords
       task_keywords = extract_keywords(task.description.downcase)
-      
+
       # Filter out manager agents first
       non_manager_agents = agents.reject(&:is_manager?)
       return nil if non_manager_agents.empty?
-      
-      best_agent = non_manager_agents.max_by do |agent|
+
+      non_manager_agents.max_by do |agent|
         agent_keywords = extract_keywords("#{agent.role} #{agent.goal}".downcase)
         common_keywords = (task_keywords & agent_keywords).length
         tool_bonus = agent.tools.any? ? 0.5 : 0
         common_keywords + tool_bonus
       end
-
-      best_agent
     end
 
     def extract_keywords(text)
-      stopwords = %w[the a an and or but in on at to for of with by is are was were be been being have has had do does did will would could should]
+      stopwords = %w[the a an and or but in on at to for of with by is are was were be been being have has had do does
+                     did will would could should]
       text.split(/\W+/).reject { |w| w.length < 3 || stopwords.include?(w) }
     end
 
@@ -270,10 +281,10 @@ module RCrewAI
       delegation_context = {
         manager: manager_agent.name,
         delegation_reason: "Assigned by #{manager_agent.role} for optimal task execution",
-        coordination_notes: "Part of async hierarchical execution",
+        coordination_notes: 'Part of async hierarchical execution',
         async_execution: true
       }
-      
+
       task.instance_variable_set(:@delegation_context, delegation_context)
     end
 
@@ -285,8 +296,14 @@ module RCrewAI
         completed_tasks: results.count { |r| r[:status] == :completed },
         failed_tasks: results.count { |r| r[:status] == :failed },
         results: results,
-        success_rate: results.empty? ? 0.0 : (results.count { |r| r[:status] == :completed }.to_f / results.length * 100).round(1)
+        success_rate: if results.empty?
+                        0.0
+                      else
+                        (results.count do |r|
+                          r[:status] == :completed
+                        end.to_f / results.length * 100).round(1)
+                      end
       }
     end
   end
-end
+end

data/lib/rcrewai/events.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RCrewAI
+  module Events
+    BASE_ATTRS = %i[type timestamp agent iteration].freeze
+
+    Event           = Struct.new(*BASE_ATTRS, keyword_init: true)
+    TextDelta       = Struct.new(*BASE_ATTRS, :text,                                  keyword_init: true)
+    TextDone        = Struct.new(*BASE_ATTRS, :text,                                  keyword_init: true)
+    ToolCallStart   = Struct.new(*BASE_ATTRS, :tool, :args, :call_id,                 keyword_init: true)
+    ToolCallResult  = Struct.new(*BASE_ATTRS, :tool, :call_id, :result, :duration_ms, keyword_init: true)
+    ToolCallError   = Struct.new(*BASE_ATTRS, :tool, :call_id, :error,                keyword_init: true)
+    Thinking        = Struct.new(*BASE_ATTRS, :text,                                  keyword_init: true)
+    Usage           = Struct.new(*BASE_ATTRS, :prompt_tokens, :completion_tokens, :total_tokens, :cost_usd, keyword_init: true)
+    IterationStart  = Struct.new(*BASE_ATTRS, :iteration_index,                       keyword_init: true)
+    IterationEnd    = Struct.new(*BASE_ATTRS, :finish_reason,                         keyword_init: true)
+    Error           = Struct.new(*BASE_ATTRS, :error,                                 keyword_init: true)
+
+    def self.fan_out(sinks)
+      sinks = Array(sinks).compact
+      lambda do |event|
+        sinks.each do |s|
+          s.call(event)
+        rescue StandardError => e
+          Kernel.warn "[rcrewai] event sink raised: #{e.class}: #{e.message}"
+        end
+      end
+    end
+  end
+end