rcrewai 0.2.1 → 0.4.0

data/lib/rcrewai/knowledge/store.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RCrewAI
+  module Knowledge
+    # In-memory vector store with cosine-similarity search. The default backing
+    # store for Knowledge — no external service required. The interface
+    # (#add, #search) is intentionally small so a Chroma/Qdrant-backed store can
+    # be swapped in later.
+    class Store
+      Entry = Struct.new(:text, :vector)
+
+      def initialize
+        @entries = []
+      end
+
+      def add(text, vector)
+        @entries << Entry.new(text, vector)
+      end
+
+      # Returns the texts of the top-k entries most similar to +query_vector+.
+      def search(query_vector, k: 3)
+        return [] if @entries.empty?
+
+        @entries
+          .map { |e| [e.text, cosine_similarity(query_vector, e.vector)] }
+          .sort_by { |(_text, score)| -score }
+          .first(k)
+          .map(&:first)
+      end
+
+      def size
+        @entries.length
+      end
+
+      def empty?
+        @entries.empty?
+      end
+
+      private
+
+      def cosine_similarity(a, b)
+        dot = 0.0
+        norm_a = 0.0
+        norm_b = 0.0
+        a.each_index do |i|
+          ai = a[i].to_f
+          bi = (b[i] || 0).to_f
+          dot += ai * bi
+          norm_a += ai * ai
+          norm_b += bi * bi
+        end
+        return 0.0 if norm_a.zero? || norm_b.zero?
+
+        dot / (Math.sqrt(norm_a) * Math.sqrt(norm_b))
+      end
+    end
+  end
+end

data/lib/rcrewai/knowledge.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'knowledge/chunker'
+require_relative 'knowledge/store'
+require_relative 'knowledge/sources'
+require_relative 'knowledge/embedder'
+require_relative 'knowledge/base'
+
+module RCrewAI
+  # Retrieval-augmented knowledge for agents and crews. See Knowledge::Base.
+  module Knowledge
+  end
+end

data/lib/rcrewai/legacy_react_runner.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative 'events'
+
+module RCrewAI
+  # Behavior-preserving extraction of the prompt-parsed `USE_TOOL[]` /
+  # `FINAL_ANSWER[]` loop that lived in Agent. Used as a fallback when an
+  # agent's tools have no DSL schemas declared OR the configured LLM does
+  # not support native function calling.
+  class LegacyReactRunner
+    DEFAULT_MAX_ITERATIONS = 10
+
+    def initialize(agent:, llm:, tools:, max_iterations: DEFAULT_MAX_ITERATIONS, event_sink: nil)
+      @agent = agent
+      @llm = llm
+      @tools = tools
+      @max_iterations = max_iterations
+      @sink = event_sink || ->(_) {}
+    end
+
+    def run(messages:)
+      msgs = messages.dup
+      history = []
+      iter = 0
+      total_usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+      last_reasoning = nil
+      last_action_result = nil
+
+      while iter < @max_iterations
+        iter += 1
+        emit(Events::IterationStart, iteration: iter, iteration_index: iter)
+
+        response = @llm.chat(messages: msgs)
+        accumulate_usage(total_usage, response[:usage])
+        reasoning = response[:content] || ''
+        last_reasoning = reasoning
+
+        action_result, iteration_history = parse_and_execute_actions(reasoning, iter)
+        history.concat(iteration_history)
+        last_action_result = action_result
+
+        msgs << { role: 'assistant', content: reasoning }
+        msgs << { role: 'user', content: action_result } if action_result && !action_result.empty?
+
+        finish_reason = response[:finish_reason]
+        emit(Events::IterationEnd, iteration: iter, finish_reason: finish_reason)
+
+        next unless task_complete?(reasoning, action_result) || finish_reason == :stop
+
+        final = extract_final_result(reasoning, action_result)
+        return finalize(content: final, history: history, iter: iter,
+                        finish_reason: finish_reason || :stop, usage: total_usage)
+      end
+
+      final = extract_final_result(last_reasoning || '', last_action_result) ||
+              'Task execution reached limits without clear completion'
+      finalize(content: final, history: history, iter: iter,
+               finish_reason: :max_iterations, usage: total_usage)
+    end
+
+    private
+
+    def parse_and_execute_actions(reasoning, iter)
+      results = []
+      iteration_history = []
+      reasoning.scan(/USE_TOOL\[(\w+)\]\(([^)]*)\)/).each do |tool_name, params_str|
+        params = parse_tool_params(params_str)
+        tool = find_tool(tool_name)
+
+        emit(Events::ToolCallStart, iteration: iter, tool: tool_name,
+                                    args: params, call_id: nil)
+
+        if tool.nil?
+          err = "tool not found: #{tool_name}"
+          emit(Events::ToolCallError, iteration: iter, tool: tool_name, call_id: nil, error: err)
+          results << "Tool #{tool_name} failed: #{err}"
+          next
+        end
+
+        started = monotonic_ms
+        begin
+          result = tool.execute(**params)
+          duration = monotonic_ms - started
+          @agent.memory.add_tool_usage(tool_name, params, result) if @agent.respond_to?(:memory) && @agent.memory
+          emit(Events::ToolCallResult, iteration: iter, tool: tool_name,
+                                       call_id: nil, result: result, duration_ms: duration)
+          iteration_history << { tool: tool_name, args: params, result: result, duration_ms: duration }
+          results << "Tool #{tool_name} result: #{result}"
+        rescue StandardError => e
+          emit(Events::ToolCallError, iteration: iter, tool: tool_name,
+                                      call_id: nil, error: e.message)
+          results << "Tool #{tool_name} failed: #{e.message}"
+        end
+      end
+
+      [results.join("\n"), iteration_history]
+    end
+
+    def parse_tool_params(params_str)
+      params = {}
+      return params if params_str.strip.empty?
+
+      params_str.split(',').map(&:strip).each do |pair|
+        key, value = pair.split('=', 2).map(&:strip)
+        next unless key && value
+
+        value = value.gsub(/^["']|["']$/, '')
+        params[key.to_sym] = value
+      end
+      params
+    end
+
+    def find_tool(name)
+      @tools.find do |t|
+        t.name == name || t.class.name.split('::').last.downcase == name.downcase
+      end
+    end
+
+    def task_complete?(reasoning, _action_result)
+      reasoning.include?('FINAL_ANSWER[') ||
+        reasoning.downcase.include?('task complete') ||
+        reasoning.downcase.include?('finished')
+    end
+
+    def extract_final_result(reasoning, action_result)
+      if (match = reasoning.match(/FINAL_ANSWER\[(.*?)\]$/m))
+        return match[1].strip
+      end
+
+      lines = reasoning.split("\n").map(&:strip).reject(&:empty?)
+      final_lines = lines.last(3).join(' ')
+      return final_lines if final_lines.length > 20
+
+      action_result
+    end
+
+    def emit(klass, iteration:, **attrs)
+      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.respond_to?(:name) ? @agent.name : nil,
+                   iteration: iteration,
+                   **attrs
+                 ))
+    end
+
+    def accumulate_usage(total, partial)
+      return unless partial.is_a?(Hash)
+
+      total[:prompt_tokens]     += partial[:prompt_tokens]     || 0
+      total[:completion_tokens] += partial[:completion_tokens] || 0
+      total[:total_tokens]      += partial[:total_tokens]      || 0
+    end
+
+    def finalize(content:, history:, iter:, finish_reason:, usage:)
+      {
+        content: content,
+        tool_calls_history: history,
+        usage: usage,
+        iterations: iter,
+        finish_reason: finish_reason
+      }
+    end
+
+    def monotonic_ms
+      (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) * 1000).to_i
+    end
+  end
+end

data/lib/rcrewai/llm_client.rb

@@ -28,6 +28,29 @@ module RCrewAI
       end
     end
 
+    # Resolves a per-agent / per-pass LLM spec into a client.
+    #   nil            -> global provider
+    #   Symbol/String  -> that provider, global model
+    #   Hash           -> { provider:, model:, api_key:, temperature: } overrides
+    #   client object  -> returned as-is (anything responding to #chat)
+    def self.resolve(spec, config = RCrewAI.configuration)
+      case spec
+      when nil
+        for_provider(nil, config)
+      when Symbol, String
+        overridden = config.with_overrides(provider: spec)
+        for_provider(overridden.llm_provider, overridden)
+      when Hash
+        overridden = config.with_overrides(**spec)
+        for_provider(overridden.llm_provider, overridden)
+      else
+        return spec if spec.respond_to?(:chat)
+
+        raise ConfigurationError,
+              "Invalid llm: expected a provider symbol, an options hash, or a client responding to #chat, got #{spec.class}"
+      end
+    end
+
     def self.chat(messages:, **options)
       client = for_provider
       client.chat(messages: messages, **options)
@@ -38,4 +61,4 @@ module RCrewAI
       client.complete(prompt: prompt, **options)
     end
   end
-end
+end

data/lib/rcrewai/llm_clients/anthropic.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
+require 'faraday'
+require 'json'
 require_relative 'base'
+require_relative '../events'
+require_relative '../sse_parser'
+require_relative '../provider_schema'
+require_relative '../pricing'
 
 module RCrewAI
   module LLMClients
@@ -8,101 +14,215 @@ module RCrewAI
       BASE_URL = 'https://api.anthropic.com/v1'
       API_VERSION = '2023-06-01'
 
+      STOP_REASON_MAP = {
+        'tool_use' => :tool_calls,
+        'end_turn' => :stop,
+        'stop_sequence' => :stop,
+        'max_tokens' => :length
+      }.freeze
+
       def initialize(config = RCrewAI.configuration)
         super
         @base_url = BASE_URL
       end
 
-      def chat(messages:, **options)
-        # Convert messages to Anthropic format
+      def chat(messages:, tools: nil, tool_choice: :auto, stream: nil, **options)
         system_message = extract_system_message(messages)
-        formatted_messages = format_messages(messages.reject { |m| m.is_a?(Hash) && m[:role] == 'system' })
+        non_system = messages.reject { |m| m.is_a?(Hash) && m[:role] == 'system' }
 
         payload = {
           model: config.model,
-          messages: formatted_messages,
+          messages: format_messages(non_system),
           max_tokens: options[:max_tokens] || config.max_tokens || 1000,
           temperature: options[:temperature] || config.temperature
-        }
+        }.compact
+
+        if system_message
+          payload[:system] = if options[:cache_system]
+                               [{ type: 'text', text: system_message,
+                                  cache_control: { type: 'ephemeral' } }]
+                             else
+                               system_message
+                             end
+        end
 
-        payload[:system] = system_message if system_message
+        if tools && !tools.empty?
+          payload[:tools] = ProviderSchema.for_many(:anthropic, tools)
+          payload[:tool_choice] = { type: tool_choice.to_s } if tool_choice != :auto && tool_choice.is_a?(Symbol)
+        end
 
-        # Add Anthropic-specific options
         payload[:top_p] = options[:top_p] if options[:top_p]
         payload[:top_k] = options[:top_k] if options[:top_k]
         payload[:stop_sequences] = options[:stop_sequences] if options[:stop_sequences]
 
-        url = "#{@base_url}/messages"
-        log_request(:post, url, payload)
-
-        response = http_client.post(url, payload, build_headers.merge(authorization_header))
-        log_response(response)
+        if stream
+          payload[:stream] = true
+          stream_chat(payload, stream)
+        else
+          plain_chat(payload)
+        end
+      end
 
-        result = handle_response(response)
-        format_response(result)
+      def supports_native_tools?(model: config.model) # rubocop:disable Lint/UnusedMethodArgument
+        true
       end
 
       def models
-        # Anthropic doesn't have a models endpoint, return known models
-        [
-          'claude-3-opus-20240229',
-          'claude-3-sonnet-20240229',
-          'claude-3-haiku-20240307',
-          'claude-2.1',
-          'claude-2.0',
-          'claude-instant-1.2'
+        %w[
+          claude-opus-4-7 claude-sonnet-4-6 claude-haiku-4-5
+          claude-3-5-sonnet-20241022 claude-3-haiku-20240307
         ]
       end
 
       private
 
-      def authorization_header
+      def plain_chat(payload)
+        url = "#{@base_url}/messages"
+        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)
+      end
+
+      def stream_chat(payload, sink) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        url = "#{@base_url}/messages"
+        log_request(:post, url, payload)
+
+        assembled_text = +''
+        # tool_use blocks keyed by content-block index
+        blocks = {}
+        finish_reason = nil
+        prompt_tokens = nil
+        completion_tokens = nil
+
+        parser = SSEParser.new do |sse|
+          data = JSON.parse(sse[:data])
+          case data['type']
+          when 'message_start'
+            prompt_tokens = data.dig('message', 'usage', 'input_tokens')
+          when 'content_block_start'
+            cb = data['content_block'] || {}
+            blocks[data['index']] = { id: cb['id'], name: cb['name'], arguments: +'' } if cb['type'] == 'tool_use'
+          when 'content_block_delta'
+            delta = data['delta'] || {}
+            case delta['type']
+            when 'text_delta'
+              text = delta['text'].to_s
+              assembled_text << text
+              sink.call(Events::TextDelta.new(type: :text_delta, timestamp: Time.now,
+                                              agent: nil, iteration: nil, text: text))
+            when 'input_json_delta'
+              block = blocks[data['index']]
+              block[:arguments] << delta['partial_json'].to_s if block
+            end
+          when 'message_delta'
+            finish_reason ||= STOP_REASON_MAP[data.dig('delta', 'stop_reason')] ||
+                              data.dig('delta', 'stop_reason')&.to_sym
+            completion_tokens = data.dig('usage', 'output_tokens') || completion_tokens
+          end
+        end
+
+        streaming_post(url, payload) { |chunk| parser.feed(chunk) }
+
+        tool_calls = blocks.values.map do |b|
+          {
+            id: b[:id],
+            name: b[:name],
+            arguments: b[:arguments].empty? ? {} : JSON.parse(b[:arguments])
+          }
+        end
+
+        usage = {
+          prompt_tokens: prompt_tokens,
+          completion_tokens: completion_tokens,
+          total_tokens: (prompt_tokens || 0) + (completion_tokens || 0)
+        }
+
+        if prompt_tokens || completion_tokens
+          sink.call(Events::Usage.new(
+                      type: :usage, timestamp: Time.now, agent: nil, iteration: nil,
+                      prompt_tokens: prompt_tokens, completion_tokens: completion_tokens,
+                      total_tokens: usage[:total_tokens],
+                      cost_usd: Pricing.cost_for(config.model,
+                                                 prompt_tokens: prompt_tokens || 0,
+                                                 completion_tokens: completion_tokens || 0)
+                    ))
+        end
+
         {
-          'x-api-key' => config.api_key,
+          content: assembled_text.empty? ? nil : assembled_text,
+          tool_calls: tool_calls,
+          usage: usage,
+          finish_reason: finish_reason || :stop,
+          model: config.model,
+          provider: :anthropic
+        }
+      end
+
+      def streaming_post(url, payload, &on_chunk)
+        conn = Faraday.new do |f|
+          f.request :json
+          f.options.timeout = config.timeout
+          f.adapter Faraday.default_adapter
+        end
+        conn.post(url) do |req|
+          req.headers = build_headers.merge(auth_header)
+          req.body = payload.to_json
+          req.options.on_data = proc { |chunk, _| on_chunk.call(chunk) }
+        end
+      end
+
+      def normalize_non_streaming(body)
+        content_blocks = Array(body['content'])
+        text = content_blocks.select { |b| b['type'] == 'text' }.map { |b| b['text'] }.join
+        tool_calls = content_blocks.select { |b| b['type'] == 'tool_use' }.map do |b|
+          { id: b['id'], name: b['name'], arguments: b['input'] || {} }
+        end
+        prompt_tokens = body.dig('usage', 'input_tokens')
+        completion_tokens = body.dig('usage', 'output_tokens')
+
+        {
+          content: text.empty? ? nil : text,
+          tool_calls: tool_calls,
+          usage: {
+            prompt_tokens: prompt_tokens,
+            completion_tokens: completion_tokens,
+            total_tokens: (prompt_tokens || 0) + (completion_tokens || 0)
+          },
+          finish_reason: STOP_REASON_MAP[body['stop_reason']] || body['stop_reason']&.to_sym || :stop,
+          model: body['model'] || config.model,
+          provider: :anthropic
+        }
+      end
+
+      def auth_header
+        {
+          'x-api-key' => config.anthropic_api_key || config.api_key,
           'anthropic-version' => API_VERSION
         }
       end
 
       def extract_system_message(messages)
         return nil unless messages.is_a?(Array)
-        system_msg = messages.find { |m| m.is_a?(Hash) && m[:role] == 'system' }
-        system_msg&.dig(:content)
+
+        msg = messages.find { |m| m.is_a?(Hash) && m[:role] == 'system' }
+        msg&.dig(:content)
       end
 
       def format_messages(messages)
         messages.map do |msg|
           if msg.is_a?(Hash)
-            {
-              role: msg[:role] == 'assistant' ? 'assistant' : 'user',
-              content: msg[:content]
-            }
+            { role: msg[:role] == 'assistant' ? 'assistant' : 'user', content: msg[:content] }
           else
             { role: 'user', content: msg.to_s }
           end
         end
       end
 
-      def format_response(response)
-        content = response.dig('content', 0, 'text') if response['content']&.any?
-
-        {
-          content: content,
-          role: 'assistant',
-          finish_reason: response['stop_reason'],
-          usage: {
-            'prompt_tokens' => response.dig('usage', 'input_tokens'),
-            'completion_tokens' => response.dig('usage', 'output_tokens'),
-            'total_tokens' => (response.dig('usage', 'input_tokens') || 0) + 
-                             (response.dig('usage', 'output_tokens') || 0)
-          },
-          model: response['model'],
-          provider: :anthropic
-        }
-      end
-
       def validate_config!
-        raise ConfigurationError, "Anthropic API key is required" unless config.anthropic_api_key || config.api_key
-        raise ConfigurationError, "Model is required" unless config.model
+        raise ConfigurationError, 'Anthropic API key is required' unless config.anthropic_api_key || config.api_key
+        raise ConfigurationError, 'Model is required' unless config.model
       end
 
       def handle_response(response)
@@ -110,12 +230,12 @@ module RCrewAI
         when 200..299
           response.body
         when 400
-          error_details = response.body.dig('error', 'message') || response.body
+          error_details = response.body.is_a?(Hash) ? response.body.dig('error', 'message') : response.body
           raise APIError, "Bad request: #{error_details}"
         when 401
-          raise AuthenticationError, "Invalid API key"
+          raise AuthenticationError, 'Invalid API key'
         when 429
-          raise RateLimitError, "Rate limit exceeded"
+          raise RateLimitError, 'Rate limit exceeded'
         when 500..599
           raise APIError, "Server error: #{response.status}"
         else
@@ -124,4 +244,4 @@ module RCrewAI
       end
     end
   end
-end
+end