rcrewai 0.2.1 → 0.4.0

data/lib/rcrewai/agent.rb

@@ -4,13 +4,17 @@ require 'logger'
 require_relative 'llm_client'
 require_relative 'memory'
 require_relative 'tools/base'
+require_relative 'tool_runner'
+require_relative 'legacy_react_runner'
 require_relative 'human_input'
 
 module RCrewAI
   class Agent
     include HumanInteractionExtensions
-    attr_reader :name, :role, :goal, :backstory, :tools, :memory, :llm_client
+    attr_reader :name, :role, :goal, :backstory, :tools, :memory, :llm_client, :knowledge
     attr_accessor :verbose, :allow_delegation, :max_iterations, :max_execution_time, :manager
+    # Set by the crew so agents see shared knowledge in addition to their own.
+    attr_writer :crew_knowledge
 
     def initialize(name:, role:, goal:, backstory: nil, tools: [], **options)
       @name = name
@@ -20,7 +24,7 @@ module RCrewAI
       @tools = tools
       @verbose = options.fetch(:verbose, false)
       @allow_delegation = options.fetch(:allow_delegation, false)
-      @manager = options.fetch(:manager, false)  # New manager flag
+      @manager = options.fetch(:manager, false) # New manager flag
       @max_iterations = options.fetch(:max_iterations, 10)
       @max_execution_time = options.fetch(:max_execution_time, 300) # 5 minutes
       @human_input_enabled = options.fetch(:human_input, false)
@@ -29,39 +33,50 @@ module RCrewAI
       @logger = Logger.new($stdout)
       @logger.level = verbose ? Logger::DEBUG : Logger::INFO
       @memory = Memory.new
-      @llm_client = LLMClient.for_provider
-      @subordinates = []  # For manager agents
+      @llm_client = build_llm_client(options[:llm])
+      @knowledge = build_knowledge(options[:knowledge], options[:knowledge_sources])
+      @subordinates = [] # For manager agents
     end
 
-    def execute_task(task)
+    def execute_task(task, stream: nil, **opts)
       @logger.info "Agent #{name} starting task: #{task.name}"
       start_time = Time.now
 
       begin
-        # Build context for the agent
-        context = build_context(task)
-        
-        # Execute task with reasoning loop
-        result = reasoning_loop(task, context)
-        
+        initial_messages = build_initial_messages(task)
+        sink = stream || ->(_) {}
+
+        runner_class = pick_runner_class
+        @logger.info "[rcrewai] agent=#{name} runner=#{runner_class.name.split('::').last}"
+
+        runner = runner_class.new(
+          agent: self, llm: @llm_client, tools: @tools,
+          max_iterations: opts.fetch(:max_iterations, max_iterations),
+          event_sink: sink
+        )
+
+        runner_result = runner.run(messages: initial_messages)
         execution_time = Time.now - start_time
         @logger.info "Task completed in #{execution_time.round(2)}s"
-        
-        # Store in memory
-        memory.add_execution(task, result, execution_time)
-        
-        task.result = result
-        result
 
-      rescue => e
+        result_string = runner_result[:content].to_s
+        memory.add_execution(task, result_string, execution_time)
+        task.result = result_string
+
+        build_task_result(task, runner_result)
+      rescue StandardError => e
         @logger.error "Task execution failed: #{e.message}"
         task.result = "Task failed: #{e.message}"
         raise AgentError, "Agent #{name} failed to execute task: #{e.message}"
       end
     end
 
+    def require_approval_for_tools?
+      @require_approval_for_tools && @human_input_enabled
+    end
+
     def available_tools_description
-      return "No tools available." if tools.empty?
+      return 'No tools available.' if tools.empty?
 
       tools.map do |tool|
         "- #{tool.name}: #{tool.description}"
@@ -82,23 +97,21 @@ module RCrewAI
       end
 
       @logger.debug "Using tool: #{tool_name} with params: #{params}"
-      
+
       begin
         result = tool.execute(**params)
-        
+
         # Store tool usage in memory
         memory.add_tool_usage(tool_name, params, result)
-        
+
         result
-      rescue => e
+      rescue StandardError => e
         @logger.error "Tool execution failed: #{e.message}"
-        
+
         # Offer human intervention if tool fails and human input is enabled
-        if @human_input_enabled
-          handle_tool_failure(tool_name, params, e)
-        else
-          raise e
-        end
+        raise e unless @human_input_enabled
+
+        handle_tool_failure(tool_name, params, e)
       end
     end
 
@@ -109,32 +122,31 @@ module RCrewAI
 
     def add_subordinate(agent)
       return unless is_manager?
+
       @subordinates << agent unless @subordinates.include?(agent)
     end
 
-    def subordinates
-      @subordinates
-    end
+    attr_reader :subordinates
 
     def delegate_task(task, target_agent)
       return unless is_manager?
       return unless @subordinates.include?(target_agent) || allow_delegation
 
       @logger.info "Manager #{name} delegating task '#{task.name}' to #{target_agent.name}"
-      
+
       # Create delegation context
       delegation_prompt = build_delegation_prompt(task, target_agent)
-      
+
       # Use LLM to create proper delegation
       response = llm_client.chat(
         messages: [{ role: 'user', content: delegation_prompt }],
         temperature: 0.2,
         max_tokens: 1000
       )
-      
+
       delegation_instructions = response[:content]
       @logger.debug "Delegation instructions: #{delegation_instructions}"
-      
+
       # Execute delegated task
       target_agent.execute_delegated_task(task, delegation_instructions, self)
     end
@@ -142,21 +154,21 @@ module RCrewAI
     def execute_delegated_task(task, delegation_instructions, manager_agent)
       @logger.info "Receiving delegation from manager #{manager_agent.name}"
       @logger.debug "Delegation instructions: #{delegation_instructions}"
-      
+
       # Store delegation context in task
       original_description = task.description
       enhanced_description = "#{original_description}\n\nDelegation Instructions from #{manager_agent.name}:\n#{delegation_instructions}"
-      
+
       # Temporarily modify task
       task.instance_variable_set(:@description, enhanced_description)
       task.instance_variable_set(:@manager, manager_agent)
-      
+
       begin
         result = execute_task(task)
-        
+
         # Report back to manager
         report_to_manager(task, result, manager_agent)
-        
+
         result
       ensure
         # Restore original task description
@@ -185,6 +197,21 @@ module RCrewAI
 
     private
 
+    # Resolves the +llm:+ option into an LLM client. See LLMClient.resolve.
+    def build_llm_client(llm)
+      LLMClient.resolve(llm)
+    end
+
+    # Accepts a pre-built Knowledge::Base via +knowledge:+ or an array of
+    # sources via +knowledge_sources:+ (wrapped in a Base). Returns nil if
+    # neither is given.
+    def build_knowledge(knowledge, sources)
+      return knowledge if knowledge
+      return nil if sources.nil? || sources.empty?
+
+      Knowledge::Base.new(sources: sources)
+    end
+
     def build_context(task)
       context = {
         agent_role: role,
@@ -198,240 +225,109 @@ module RCrewAI
       }
 
       # Add delegation capabilities if allowed
-      if allow_delegation
-        context[:delegation_note] = "You can delegate subtasks to other agents if needed."
-      end
+      context[:delegation_note] = 'You can delegate subtasks to other agents if needed.' if allow_delegation
 
       context
     end
 
-    def reasoning_loop(task, context)
-      iteration = 0
-      start_time = Time.now
-
-      loop do
-        iteration += 1
-        current_time = Time.now
-
-        # Check limits
-        if iteration > max_iterations
-          @logger.warn "Max iterations (#{max_iterations}) reached"
-          break
-        end
-
-        if current_time - start_time > max_execution_time
-          @logger.warn "Max execution time (#{max_execution_time}s) reached"
-          break
-        end
-
-        # Human review of reasoning at key points
-        if @human_input_enabled && (iteration == 1 || iteration % 3 == 0)
-          review_result = request_reasoning_review(task, context, iteration)
-          if review_result && review_result[:feedback]
-            context[:human_guidance] = review_result[:feedback]
-            @logger.info "Incorporating human guidance into reasoning"
-          end
-        end
-
-        # Generate reasoning prompt
-        prompt = build_reasoning_prompt(context, iteration)
-        
-        # Get LLM response
-        @logger.debug "Iteration #{iteration}: Sending prompt to LLM"
-        response = llm_client.chat(
-          messages: [{ role: 'user', content: prompt }],
-          temperature: 0.1,
-          max_tokens: 2000
-        )
-
-        reasoning = response[:content]
-        @logger.debug "LLM Response: #{reasoning[0..200]}..." if verbose
-
-        # Parse and execute actions
-        action_result = parse_and_execute_actions(reasoning, task)
-        
-        # Check if task is complete
-        if task_complete?(reasoning, action_result)
-          final_result = extract_final_result(reasoning, action_result)
-          
-          # Human approval of final result if required
-          if @require_approval_for_final_answer && @human_input_enabled
-            final_result = request_final_answer_approval(final_result)
-          end
-          
-          @logger.info "Task completed successfully in #{iteration} iterations"
-          return final_result
-        end
-
-        # Update context with new information
-        context[:previous_reasoning] = reasoning
-        context[:previous_result] = action_result
-        context[:iteration] = iteration
-      end
-
-      # If we exit the loop without completion, return best effort result
-      final_result = extract_final_result(context[:previous_reasoning], context[:previous_result]) || 
-        "Task execution reached limits without clear completion"
-      
-      # Human approval even for incomplete results if required
-      if @require_approval_for_final_answer && @human_input_enabled
-        final_result = request_final_answer_approval(final_result)
+    def build_initial_messages(task)
+      ctx = build_context(task)
+      system = +"You are #{ctx[:agent_role]}. Goal: #{ctx[:agent_goal]}."
+      system << " #{ctx[:agent_backstory]}" if ctx[:agent_backstory]
+      if @tools.any?
+        system << "\nAvailable Tools:\n#{ctx[:available_tools]}"
+        system << "\nYou may call tools by name when needed."
       end
-      
-      final_result
-    end
+      system << "\n#{ctx[:delegation_note]}" if ctx[:delegation_note]
 
-    def build_reasoning_prompt(context, iteration)
-      prompt = <<~PROMPT
-        You are #{context[:agent_role]}.
-        
-        Your goal: #{context[:agent_goal]}
-        
-        Background: #{context[:agent_backstory]}
-        
-        Current Task: #{context[:task_description]}
-        Expected Output: #{context[:task_expected_output]}
-        
-        Available Tools:
-        #{context[:available_tools]}
-        
-        #{context[:delegation_note] if context[:delegation_note]}
-        
-        #{build_context_section(context)}
-        
-        This is iteration #{iteration}. Think step by step about how to approach this task.
-        
-        You can:
-        1. Use tools by writing: USE_TOOL[tool_name](param1=value1, param2=value2)
-        2. Provide your final answer when ready: FINAL_ANSWER[your complete response]
-        3. Continue reasoning if you need more information
-        
-        What is your next step?
-      PROMPT
+      user = +"Task: #{task.description}"
+      user << "\nExpected Output: #{task.expected_output}" if task.expected_output
+      user << "\nAdditional Context:\n#{ctx[:context_data]}" if ctx[:context_data] && !ctx[:context_data].to_s.empty?
 
-      prompt
-    end
+      knowledge = retrieve_knowledge(task)
+      user << "\n\nRelevant Knowledge:\n#{knowledge}" unless knowledge.empty?
 
-    def build_context_section(context)
-      sections = []
-      
-      if context[:context_data] && !context[:context_data].empty?
-        sections << "Additional Context:\n#{context[:context_data]}"
-      end
-      
-      if context[:previous_executions] && !context[:previous_executions].empty?
-        sections << "Previous Similar Tasks:\n#{context[:previous_executions]}"
-      end
-      
-      if context[:human_guidance]
-        sections << "Human Guidance:\n#{context[:human_guidance]}"
-      end
-      
-      if context[:previous_reasoning]
-        sections << "Previous Reasoning:\n#{context[:previous_reasoning]}"
-      end
-      
-      if context[:previous_result]
-        sections << "Previous Action Result:\n#{context[:previous_result]}"
-      end
-      
-      sections.join("\n\n")
+      [
+        { role: 'system', content: system },
+        { role: 'user', content: user }
+      ]
     end
 
-    def parse_and_execute_actions(reasoning, task)
-      results = []
-
-      # Look for tool usage patterns
-      tool_matches = reasoning.scan(/USE_TOOL\[(\w+)\]\(([^)]*)\)/)
-      tool_matches.each do |tool_name, params_str|
-        begin
-          params = parse_tool_params(params_str)
-          result = use_tool(tool_name, **params)
-          results << "Tool #{tool_name} result: #{result}"
-        rescue => e
-          results << "Tool #{tool_name} failed: #{e.message}"
-          @logger.error "Tool execution failed: #{e.message}"
-        end
-      end
-
-      results.join("\n")
+    # Retrieves knowledge chunks relevant to the task from the agent's own
+    # knowledge base and/or the crew-level base injected via #knowledge=.
+    def retrieve_knowledge(task)
+      bases = [@knowledge, @crew_knowledge].compact
+      return '' if bases.empty?
+
+      chunks = bases.flat_map { |kb| kb.search(task.description, k: 3) }
+      chunks.uniq.join("\n---\n")
+    rescue StandardError => e
+      @logger.warn("Knowledge retrieval failed: #{e.message}")
+      ''
     end
 
-    def parse_tool_params(params_str)
-      params = {}
-      return params if params_str.strip.empty?
-
-      param_pairs = params_str.split(',').map(&:strip)
-      param_pairs.each do |pair|
-        key, value = pair.split('=', 2).map(&:strip)
-        if key && value
-          # Remove quotes if present
-          value = value.gsub(/^["']|["']$/, '')
-          params[key.to_sym] = value
-        end
-      end
-
-      params
+    def build_task_result(task, runner_result)
+      {
+        task: task.name,
+        agent: name,
+        content: runner_result[:content],
+        tool_calls_history: runner_result[:tool_calls_history] || [],
+        usage: runner_result[:usage] || {},
+        iterations: runner_result[:iterations],
+        finish_reason: runner_result[:finish_reason]
+      }
     end
 
-    def task_complete?(reasoning, action_result)
-      reasoning.include?('FINAL_ANSWER[') || 
-      reasoning.downcase.include?('task complete') ||
-      reasoning.downcase.include?('finished')
+    def pick_runner_class
+      schemas_ok = @tools.empty? || @tools.all? { |t| t.respond_to?(:json_schema) && t.json_schema }
+      native = @llm_client.respond_to?(:supports_native_tools?) &&
+               safe_supports_native?(@llm_client)
+      schemas_ok && native ? ToolRunner : LegacyReactRunner
     end
 
-    def extract_final_result(reasoning, action_result)
-      # Look for FINAL_ANSWER pattern
-      if match = reasoning.match(/FINAL_ANSWER\[(.*?)\]$/m)
-        return match[1].strip
-      end
-
-      # Otherwise try to extract meaningful result from reasoning
-      lines = reasoning.split("\n").map(&:strip).reject(&:empty?)
-      final_lines = lines.last(3).join(" ")
-      
-      return final_lines if final_lines.length > 20
-      
-      # Fallback to action result
-      action_result
+    def safe_supports_native?(llm)
+      model = llm.respond_to?(:config) && llm.config.respond_to?(:model) ? llm.config.model : nil
+      llm.supports_native_tools?(model: model)
+    rescue StandardError
+      false
     end
 
     # Manager-specific private methods
     def build_delegation_prompt(task, target_agent)
       <<~PROMPT
         You are #{name}, a #{role}.
-        
+
         You need to delegate the following task to #{target_agent.name} (#{target_agent.role}):
-        
+
         Task: #{task.name}
         Description: #{task.description}
         Expected Output: #{task.expected_output || 'Not specified'}
-        
+
         Target Agent Profile:
         - Role: #{target_agent.role}
         - Goal: #{target_agent.goal}
         - Available Tools: #{target_agent.available_tools_description}
-        
+
         Create clear, specific delegation instructions that:
         1. Explain why this agent is the right choice for this task
         2. Provide any additional context or requirements
         3. Set clear expectations for deliverables
         4. Include any coordination notes with other team members
-        
+
         Keep instructions concise but comprehensive.
       PROMPT
     end
 
     def report_to_manager(task, result, manager_agent)
       @logger.info "Reporting task completion to manager #{manager_agent.name}"
-      
+
       # Store the delegation result in manager's memory
       manager_agent.memory.add_execution(
-        task, 
+        task,
         "Delegated to #{name}: #{result}",
         task.execution_time || 0
       )
-      
+
       # Could enhance with formal reporting mechanism
     end
 
@@ -440,34 +336,33 @@ module RCrewAI
       message = "Agent #{name} wants to use tool '#{tool_name}'"
       context = "Parameters: #{params.inspect}"
       consequences = "This will execute the #{tool_name} tool with the specified parameters."
-      
-      request_human_approval(message, 
-        context: context, 
-        consequences: consequences,
-        timeout: 60
-      )
+
+      request_human_approval(message,
+                             context: context,
+                             consequences: consequences,
+                             timeout: 60)
     end
 
     def handle_tool_failure(tool_name, params, error)
-      @logger.warn "Requesting human intervention for tool failure"
-      
+      @logger.warn 'Requesting human intervention for tool failure'
+
       choices = [
-        "Retry with same parameters",
-        "Retry with different parameters", 
-        "Skip this tool and continue",
-        "Abort task execution"
+        'Retry with same parameters',
+        'Retry with different parameters',
+        'Skip this tool and continue',
+        'Abort task execution'
       ]
-      
+
       choice_result = request_human_choice(
         "Tool '#{tool_name}' failed with error: #{error.message}. How should I proceed?",
         choices,
         timeout: 120
       )
-      
+
       case choice_result[:choice_index]
       when 0
         # Retry with same parameters
-        @logger.info "Human requested retry with same parameters"
+        @logger.info 'Human requested retry with same parameters'
         tool = tools.find { |t| t.name == tool_name }
         tool.execute(**params)
       when 1
@@ -475,11 +370,11 @@ module RCrewAI
         new_params_result = request_human_input(
           "Please provide new parameters for #{tool_name} (JSON format):",
           type: :json,
-          help_text: "Enter parameters as JSON, e.g. {\"param1\": \"value1\"}"
+          help_text: 'Enter parameters as JSON, e.g. {"param1": "value1"}'
         )
-        
+
         if new_params_result[:valid]
-          @logger.info "Human provided new parameters, retrying tool"
+          @logger.info 'Human provided new parameters, retrying tool'
           tool = tools.find { |t| t.name == tool_name }
           tool.execute(**new_params_result[:processed_input])
         else
@@ -487,43 +382,43 @@ module RCrewAI
         end
       when 2
         # Skip tool
-        @logger.info "Human requested to skip failed tool"
-        "Tool execution skipped by human intervention"
+        @logger.info 'Human requested to skip failed tool'
+        'Tool execution skipped by human intervention'
       else
         # Abort
-        @logger.error "Human requested task abortion due to tool failure"
+        @logger.error 'Human requested task abortion due to tool failure'
         raise AgentError, "Task aborted by human due to tool failure: #{error.message}"
       end
     end
 
     def request_final_answer_approval(proposed_answer)
       return proposed_answer unless @require_approval_for_final_answer && @human_input_enabled
-      
+
       review_result = request_human_review(
         proposed_answer,
-        review_criteria: ["Accuracy", "Completeness", "Clarity", "Relevance"],
+        review_criteria: %w[Accuracy Completeness Clarity Relevance],
         timeout: 180
       )
-      
+
       if review_result[:approved]
-        @logger.info "Final answer approved by human"
+        @logger.info 'Final answer approved by human'
         proposed_answer
       else
-        @logger.info "Human provided feedback on final answer"
-        
+        @logger.info 'Human provided feedback on final answer'
+
         if review_result[:suggested_changes].any?
           @logger.info "Suggested changes: #{review_result[:suggested_changes].join('; ')}"
-          
+
           # Ask human what to do with the feedback
           choice_result = request_human_choice(
-            "How should I handle your feedback?",
+            'How should I handle your feedback?',
             [
-              "Revise the answer based on feedback",
-              "Use the answer as-is despite feedback",
-              "Let me provide a completely new answer"
+              'Revise the answer based on feedback',
+              'Use the answer as-is despite feedback',
+              'Let me provide a completely new answer'
             ]
           )
-          
+
           case choice_result[:choice_index]
           when 0
             # Revise based on feedback
@@ -535,8 +430,8 @@ module RCrewAI
           when 2
             # Get new answer from human
             new_answer_result = request_human_input(
-              "Please provide the final answer:",
-              help_text: "Provide the complete answer for this task"
+              'Please provide the final answer:',
+              help_text: 'Provide the complete answer for this task'
             )
             new_answer_result[:input] || proposed_answer
           else
@@ -550,29 +445,29 @@ module RCrewAI
     end
 
     def revise_answer_with_feedback(feedback_context)
-      @logger.info "Revising answer based on human feedback"
-      
+      @logger.info 'Revising answer based on human feedback'
+
       revision_prompt = <<~PROMPT
         You are #{name}, a #{role}.
-        
+
         You need to revise your previous answer based on human feedback.
-        
+
         #{feedback_context}
-        
+
         Please provide a revised answer that addresses the feedback while maintaining accuracy and completeness.
-        
+
         Revised answer:
       PROMPT
-      
+
       response = llm_client.chat(
         messages: [{ role: 'user', content: revision_prompt }],
         temperature: 0.2,
         max_tokens: 1000
       )
-      
+
       revised_answer = response[:content]
       @logger.debug "Revised answer based on feedback: #{revised_answer[0..100]}..."
-      
+
       revised_answer
     end
 
@@ -582,36 +477,36 @@ module RCrewAI
       review_content = <<~CONTENT
         Task: #{task.name}
         Description: #{task.description}
-        
+
         Current Iteration: #{iteration}
-        
+
         Agent Analysis:
         - Role: #{role}
         - Current Progress: #{context[:previous_result] || 'Starting task'}
         - Previous Reasoning: #{context[:previous_reasoning] || 'No previous reasoning'}
-        
+
         The agent is about to continue reasoning for this task.
       CONTENT
 
       request_human_review(
         review_content,
-        review_criteria: ["Task approach", "Progress assessment", "Strategic guidance"],
+        review_criteria: ['Task approach', 'Progress assessment', 'Strategic guidance'],
         timeout: 30,
         optional: true
       )
-    rescue => e
+    rescue StandardError => e
       @logger.warn "Failed to get human reasoning review: #{e.message}"
       nil
     end
 
     class CLI < Thor
-      desc "new NAME", "Create a new agent"
+      desc 'new NAME', 'Create a new agent'
       option :role, type: :string, required: true
       option :goal, type: :string, required: true
       option :backstory, type: :string
       option :verbose, type: :boolean, default: false
       def new(name)
-        agent = Agent.new(
+        Agent.new(
           name: name,
           role: options[:role],
           goal: options[:goal],
@@ -621,16 +516,16 @@ module RCrewAI
         puts "Agent '#{name}' created with role: #{options[:role]}"
       end
 
-      desc "list", "List all agents"
+      desc 'list', 'List all agents'
       def list
-        puts "Available agents:"
-        puts "  - researcher (Role: Research Specialist)"
-        puts "  - writer (Role: Content Writer)"
-        puts "  - analyst (Role: Data Analyst)"
+        puts 'Available agents:'
+        puts '  - researcher (Role: Research Specialist)'
+        puts '  - writer (Role: Content Writer)'
+        puts '  - analyst (Role: Data Analyst)'
       end
     end
   end
 
   class AgentError < Error; end
   class ToolNotFoundError < AgentError; end
-end
+end