rcrewai 0.2.0 → 0.3.0

data/lib/rcrewai/llm_clients/openai.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
@@ -12,113 +18,184 @@ module RCrewAI
         @base_url = BASE_URL
       end
 
-      def chat(messages:, **options)
+      def chat(messages:, tools: nil, tool_choice: :auto, stream: nil, **options)
         payload = {
           model: config.model,
-          messages: format_messages(messages),
+          messages: messages,
           temperature: options[:temperature] || config.temperature,
           max_tokens: options[:max_tokens] || config.max_tokens
-        }
+        }.compact
 
-        # Add additional OpenAI-specific options
         payload[:top_p] = options[:top_p] if options[:top_p]
         payload[:frequency_penalty] = options[:frequency_penalty] if options[:frequency_penalty]
         payload[:presence_penalty] = options[:presence_penalty] if options[:presence_penalty]
         payload[:stop] = options[:stop] if options[:stop]
 
-        url = "#{@base_url}/chat/completions"
-        log_request(:post, url, payload)
-
-        response = http_client.post(url, payload, build_headers.merge(authorization_header))
-        log_response(response)
-
-        result = handle_response(response)
-        format_response(result)
-      end
+        if tools && !tools.empty?
+          payload[:tools] = ProviderSchema.for_many(:openai, tools)
+          payload[:tool_choice] = tool_choice if tool_choice != :auto
+        end
 
-      def complete(prompt:, **options)
-        # For older models that use completions endpoint
-        if config.model.include?('davinci') || config.model.include?('curie') || 
-           config.model.include?('babbage') || config.model.include?('ada')
-          completion_request(prompt, **options)
+        if stream
+          payload[:stream] = true
+          payload[:stream_options] = { include_usage: true }
+          stream_chat(payload, stream)
         else
-          # Use chat endpoint for newer models
-          super
+          plain_chat(payload)
         end
       end
 
+      def supports_native_tools?(model: config.model) # rubocop:disable Lint/UnusedMethodArgument
+        true
+      end
+
       def models
         url = "#{@base_url}/models"
-        response = http_client.get(url, {}, build_headers.merge(authorization_header))
+        response = http_client.get(url, {}, build_headers.merge(auth_header))
         result = handle_response(response)
         result['data'].map { |model| model['id'] }
       end
 
       private
 
-      def authorization_header
-        { 'Authorization' => "Bearer #{config.api_key}" }
+      def chat_url
+        "#{@base_url}/chat/completions"
       end
 
-      def completion_request(prompt, **options)
-        payload = {
-          model: config.model,
-          prompt: prompt,
-          temperature: options[:temperature] || config.temperature,
-          max_tokens: options[:max_tokens] || config.max_tokens
-        }
+      def plain_chat(payload)
+        url = chat_url
+        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
 
-        url = "#{@base_url}/completions"
+      def stream_chat(payload, sink) # rubocop:disable Metrics/AbcSize
+        url = chat_url
         log_request(:post, url, payload)
 
-        response = http_client.post(url, payload, build_headers.merge(authorization_header))
-        log_response(response)
+        assembled_text = +''
+        tool_calls_by_index = {}
+        final_usage = nil
+        finish_reason = nil
+
+        parser = SSEParser.new do |sse|
+          data_str = sse[:data]
+          next if data_str == '[DONE]'
+
+          data = JSON.parse(data_str)
+          choice = data.dig('choices', 0) || {}
+          delta = choice['delta'] || {}
+
+          if delta['content']
+            assembled_text << delta['content']
+            sink.call(Events::TextDelta.new(
+                        type: :text_delta, timestamp: Time.now, agent: nil, iteration: nil,
+                        text: delta['content']
+                      ))
+          end
 
-        result = handle_response(response)
-        format_completion_response(result)
-      end
+          Array(delta['tool_calls']).each do |tc|
+            idx = tc['index']
+            tool_calls_by_index[idx] ||= { id: nil, name: nil, arguments: +'' }
+            tool_calls_by_index[idx][:id]   ||= tc['id']
+            tool_calls_by_index[idx][:name] ||= tc.dig('function', 'name')
+            tool_calls_by_index[idx][:arguments] << (tc.dig('function', 'arguments') || '')
+          end
+
+          finish_reason ||= choice['finish_reason']&.to_sym
 
-      def format_messages(messages)
-        messages.map do |msg|
-          if msg.is_a?(Hash)
-            msg
-          else
-            { role: 'user', content: msg.to_s }
+          if data['usage']
+            final_usage = {
+              prompt_tokens: data['usage']['prompt_tokens'],
+              completion_tokens: data['usage']['completion_tokens'],
+              total_tokens: data['usage']['total_tokens']
+            }
           end
         end
-      end
 
-      def format_response(response)
-        choice = response.dig('choices', 0)
-        return nil unless choice
+        streaming_post(url, payload) { |chunk| parser.feed(chunk) }
+
+        tool_calls = tool_calls_by_index.values.map do |tc|
+          {
+            id: tc[:id],
+            name: tc[:name],
+            arguments: tc[:arguments].empty? ? {} : JSON.parse(tc[:arguments])
+          }
+        end
+
+        if final_usage
+          sink.call(Events::Usage.new(
+                      type: :usage, timestamp: Time.now, agent: nil, iteration: nil,
+                      prompt_tokens: final_usage[:prompt_tokens],
+                      completion_tokens: final_usage[:completion_tokens],
+                      total_tokens: final_usage[:total_tokens],
+                      cost_usd: Pricing.cost_for(config.model,
+                                                 prompt_tokens: final_usage[:prompt_tokens],
+                                                 completion_tokens: final_usage[:completion_tokens])
+                    ))
+        end
 
         {
-          content: choice.dig('message', 'content'),
-          role: choice.dig('message', 'role'),
-          finish_reason: choice['finish_reason'],
-          usage: response['usage'],
-          model: response['model'],
-          provider: :openai
+          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 format_completion_response(response)
-        choice = response.dig('choices', 0)
-        return nil unless choice
+      def provider_name
+        :openai
+      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)
+        choice = body.dig('choices', 0) || {}
+        msg = choice['message'] || {}
+        tool_calls = Array(msg['tool_calls']).map do |tc|
+          {
+            id: tc['id'],
+            name: tc.dig('function', 'name'),
+            arguments: JSON.parse(tc.dig('function', 'arguments') || '{}')
+          }
+        end
         {
-          content: choice['text'],
-          finish_reason: choice['finish_reason'],
-          usage: response['usage'],
-          model: response['model'],
-          provider: :openai
+          content: msg['content'],
+          tool_calls: tool_calls,
+          usage: {
+            prompt_tokens: body.dig('usage', 'prompt_tokens'),
+            completion_tokens: body.dig('usage', 'completion_tokens'),
+            total_tokens: body.dig('usage', 'total_tokens')
+          },
+          finish_reason: (choice['finish_reason'] || 'stop').to_sym,
+          model: body['model'] || config.model,
+          provider: provider_name
         }
       end
 
+      def auth_header
+        { 'Authorization' => "Bearer #{config.openai_api_key || config.api_key}" }
+      end
+
       def validate_config!
-        raise ConfigurationError, "OpenAI API key is required" unless config.openai_api_key || config.api_key
-        raise ConfigurationError, "Model is required" unless config.model
+        raise ConfigurationError, 'OpenAI API key is required' unless config.openai_api_key || config.api_key
+        raise ConfigurationError, 'Model is required' unless config.model
       end
     end
   end
-end
+end

data/lib/rcrewai/mcp/client.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'transport/stdio'
+require_relative 'transport/http'
+require_relative 'tool_adapter'
+
+module RCrewAI
+  module MCP
+    class Error < RCrewAI::Error; end
+
+    # Minimal MCP (Model Context Protocol) JSON-RPC client. Connects to a
+    # server via stdio or streamable HTTP, performs the initialize/initialized
+    # handshake, lists tools, and exposes them as RCrewAI::Tools::Base instances.
+    class Client
+      PROTOCOL_VERSION = '2024-11-05'
+
+      attr_reader :server_name, :tools
+
+      def self.connect(**opts)
+        new(**opts).tap(&:open)
+      end
+
+      def self.with_connection(**opts)
+        c = connect(**opts)
+        begin
+          yield c
+        ensure
+          c&.close
+        end
+      end
+
+      def initialize(command: nil, args: [], env: {}, url: nil, headers: {})
+        @transport = if url
+                       Transport::Http.new(url: url, headers: headers)
+                     else
+                       Transport::Stdio.new(command: command, args: args, env: env)
+                     end
+        @request_id = 0
+        @tools = []
+        @server_name = nil
+      end
+
+      def open
+        @transport.open
+        handshake
+        load_tools
+      end
+
+      def close
+        @transport.close
+      end
+
+      def call_tool(name, args)
+        result = request('tools/call',
+                         name: strip_prefix(name),
+                         arguments: args)
+        text = result.dig('content', 0, 'text')
+        text || result['content']
+      end
+
+      private
+
+      def handshake
+        info = request('initialize',
+                       protocolVersion: PROTOCOL_VERSION,
+                       capabilities: { tools: {} },
+                       clientInfo: { name: 'rcrewai', version: RCrewAI::VERSION })
+        @server_name = info.dig('serverInfo', 'name') || 'mcp'
+        notify('notifications/initialized', {})
+      end
+
+      def load_tools
+        result = request('tools/list', {})
+        @tools = Array(result['tools']).map { |t| ToolAdapter.new(self, t, @server_name) }
+      end
+
+      def request(method, params)
+        @request_id += 1
+        msg = { jsonrpc: '2.0', id: @request_id, method: method, params: params }
+        @transport.send_line(msg.to_json)
+        line = @transport.recv_line
+        raise Error, 'connection closed before response' if line.nil?
+
+        reply = JSON.parse(line)
+        raise Error, reply['error']['message'] if reply['error']
+
+        reply['result']
+      end
+
+      def notify(method, params)
+        msg = { jsonrpc: '2.0', method: method, params: params }
+        @transport.send_line(msg.to_json)
+      end
+
+      def strip_prefix(prefixed_name)
+        prefixed_name.sub(/^#{Regexp.escape(@server_name)}__/, '')
+      end
+    end
+  end
+end

data/lib/rcrewai/mcp/tool_adapter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../tools/base'
+
+module RCrewAI
+  module MCP
+    # Wraps a tool advertised by an MCP server as an RCrewAI::Tools::Base.
+    # Names are prefixed with the server name to avoid collisions when an
+    # agent has tools from multiple MCP servers.
+    class ToolAdapter < RCrewAI::Tools::Base
+      def initialize(client, mcp_tool_descriptor, server_name)
+        super()
+        @client = client
+        @descriptor = mcp_tool_descriptor
+        @server_name = server_name
+        @adapter_name = "#{server_name}__#{mcp_tool_descriptor['name']}"
+        @adapter_description = mcp_tool_descriptor['description'].to_s
+      end
+
+      def name
+        @adapter_name
+      end
+
+      def description
+        @adapter_description
+      end
+
+      def json_schema
+        {
+          name: @adapter_name,
+          description: @adapter_description,
+          parameters: stringify_keys(@descriptor['inputSchema'] ||
+                                     { 'type' => 'object', 'additionalProperties' => true })
+        }
+      end
+
+      def execute(**args)
+        @client.call_tool(@adapter_name, args)
+      end
+
+      def execute_with_validation(args_hash)
+        execute(**args_hash.transform_keys(&:to_sym))
+      end
+
+      private
+
+      def stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(k, v), out| out[k.to_s] = stringify_keys(v) }
+        when Array
+          value.map { |v| stringify_keys(v) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/mcp/transport/http.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require_relative '../../sse_parser'
+
+module RCrewAI
+  module MCP
+    module Transport
+      # Streamable HTTP transport for MCP: server pushes JSON-RPC responses
+      # via a long-lived SSE stream (GET); client sends requests via POST.
+      class Http
+        def initialize(url:, headers: {})
+          @url = url
+          @headers = headers
+          @queue = Queue.new
+          @sse_thread = nil
+        end
+
+        def open
+          @http = Faraday.new(url: @url) { |f| f.adapter Faraday.default_adapter }
+          @sse_thread = Thread.new { start_sse_stream }
+        end
+
+        def send_line(json)
+          @http.post('') do |req|
+            req.headers.merge!(@headers).merge!('Content-Type' => 'application/json')
+            req.body = json
+          end
+        end
+
+        def recv_line
+          @queue.pop
+        end
+
+        def close
+          @sse_thread&.kill
+        end
+
+        private
+
+        def start_sse_stream
+          parser = SSEParser.new do |evt|
+            @queue << "#{evt[:data]}\n" if evt[:event] == 'message' || evt[:event].nil?
+          end
+          @http.get('') do |req|
+            req.headers.merge!(@headers).merge!('Accept' => 'text/event-stream')
+            req.options.on_data = proc { |chunk, _| parser.feed(chunk) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/mcp/transport/stdio.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module RCrewAI
+  module MCP
+    module Transport
+      class Stdio
+        def initialize(command:, args: [], env: {})
+          @command = command
+          @args = args
+          @env = env
+          @stdin = nil
+          @stdout = nil
+          @stderr_thread = nil
+          @wait_thr = nil
+        end
+
+        def open
+          @stdin, @stdout, stderr, @wait_thr = Open3.popen3(@env, @command, *@args)
+          @stderr_thread = Thread.new do
+            stderr.each_line { |l| Kernel.warn "[mcp-stderr] #{l}" }
+          rescue IOError
+            # stream closed
+          end
+        end
+
+        def send_line(json)
+          @stdin.write("#{json}\n")
+          @stdin.flush
+        end
+
+        def recv_line
+          @stdout.gets
+        end
+
+        def close
+          return unless @wait_thr&.alive?
+
+          begin
+            ::Process.kill('TERM', @wait_thr.pid)
+          rescue Errno::ESRCH, Errno::EPERM
+            # already dead
+          end
+          @stdin&.close
+          @stdout&.close
+          @stderr_thread&.kill
+        rescue IOError
+          # streams already closed
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/mcp.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'mcp/client'
+
+module RCrewAI
+  module MCP
+  end
+end

data/lib/rcrewai/memory.rb

@@ -32,16 +32,16 @@ module RCrewAI
       @short_term = @short_term.first(@max_short_term)
 
       # Add to long-term memory if successful
-      if execution_data[:success]
-        task_type = execution_data[:task_type]
-        @long_term[task_type] ||= []
-        @long_term[task_type] << execution_data
-        
-        # Keep only best executions for each type
-        @long_term[task_type] = @long_term[task_type]
-          .sort_by { |e| [e[:success] ? 0 : 1, -e[:execution_time]] }
-          .first(10)
-      end
+      return unless execution_data[:success]
+
+      task_type = execution_data[:task_type]
+      @long_term[task_type] ||= []
+      @long_term[task_type] << execution_data
+
+      # Keep only best executions for each type
+      @long_term[task_type] = @long_term[task_type]
+                              .sort_by { |e| [e[:success] ? 0 : 1, -e[:execution_time]] }
+                              .first(10)
     end
 
     def add_tool_usage(tool_name, params, result)
@@ -54,7 +54,7 @@ module RCrewAI
       }
 
       @tool_usage.unshift(usage_data)
-      @tool_usage = @tool_usage.first(50)  # Keep last 50 tool usages
+      @tool_usage = @tool_usage.first(50) # Keep last 50 tool usages
     end
 
     def relevant_executions(task, limit = 3)
@@ -75,18 +75,16 @@ module RCrewAI
       end
 
       # Check long-term memory
-      if @long_term[task_type]
-        @long_term[task_type].each do |execution|
-          similarity = calculate_similarity(task, execution)
-          candidates << { execution: execution, similarity: similarity } if similarity > @similarity_threshold
-        end
+      @long_term[task_type]&.each do |execution|
+        similarity = calculate_similarity(task, execution)
+        candidates << { execution: execution, similarity: similarity } if similarity > @similarity_threshold
       end
 
       # Sort by similarity and success, return top results
       relevant = candidates
-        .sort_by { |c| [-c[:similarity], c[:execution][:success] ? 0 : 1] }
-        .first(limit)
-        .map { |c| format_execution_for_context(c[:execution]) }
+                 .sort_by { |c| [-c[:similarity], c[:execution][:success] ? 0 : 1] }
+                 .first(limit)
+                 .map { |c| format_execution_for_context(c[:execution]) }
 
       relevant.empty? ? nil : relevant.join("\n---\n")
     end
@@ -123,13 +121,23 @@ module RCrewAI
 
     def classify_task_type(task)
       description = task.description.downcase
-      
-      return :research if description.include?('research') || description.include?('find') || description.include?('search')
-      return :analysis if description.include?('analyze') || description.include?('examine') || description.include?('study')
-      return :writing if description.include?('write') || description.include?('create') || description.include?('compose')
-      return :coding if description.include?('code') || description.include?('program') || description.include?('develop')
-      return :planning if description.include?('plan') || description.include?('strategy') || description.include?('organize')
-      
+
+      if description.include?('research') || description.include?('find') || description.include?('search')
+        return :research
+      end
+      if description.include?('analyze') || description.include?('examine') || description.include?('study')
+        return :analysis
+      end
+      if description.include?('write') || description.include?('create') || description.include?('compose')
+        return :writing
+      end
+      if description.include?('code') || description.include?('program') || description.include?('develop')
+        return :coding
+      end
+      if description.include?('plan') || description.include?('strategy') || description.include?('organize')
+        return :planning
+      end
+
       :general
     end
 
@@ -142,17 +150,17 @@ module RCrewAI
       # Simple similarity based on common words and task type
       task_words = extract_keywords(task.description)
       execution_words = extract_keywords(execution[:task_description])
-      
+
       common_words = (task_words & execution_words).length
       total_words = (task_words | execution_words).length
-      
-      return 0.0 if total_words == 0
-      
+
+      return 0.0 if total_words.zero?
+
       word_similarity = common_words.to_f / total_words
-      
+
       # Boost similarity if task types match
-      type_bonus = (classify_task_type(task) == execution[:task_type]) ? 0.2 : 0.0
-      
+      type_bonus = classify_task_type(task) == execution[:task_type] ? 0.2 : 0.0
+
       [word_similarity + type_bonus, 1.0].min
     end
 
@@ -163,7 +171,7 @@ module RCrewAI
     end
 
     def format_execution_for_context(execution)
-      success_indicator = execution[:success] ? "✓" : "✗"
+      success_indicator = execution[:success] ? '✓' : '✗'
       <<~CONTEXT
         #{success_indicator} Task: #{execution[:task_name]}
         Description: #{execution[:task_description]}
@@ -174,7 +182,7 @@ module RCrewAI
     end
 
     def format_tool_usage_for_context(usage)
-      success_indicator = usage[:success] ? "✓" : "✗"
+      success_indicator = usage[:success] ? '✓' : '✗'
       params_str = usage[:params].map { |k, v| "#{k}=#{v}" }.join(', ')
       <<~CONTEXT
         #{success_indicator} Tool: #{usage[:tool_name]}
@@ -186,9 +194,9 @@ module RCrewAI
 
     def calculate_success_rate
       return 0.0 if @short_term.empty?
-      
+
       successful = @short_term.count { |e| e[:success] }
       (successful.to_f / @short_term.length * 100).round(1)
     end
   end
-end
+end