rcrewai 0.2.1 → 0.4.0

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

data/lib/rcrewai/output_schema.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RCrewAI
+  # Validates and coerces a task's raw string output against a JSON-Schema
+  # subset (object / type / required / property types). Used by Task for the
+  # `output_schema:` option. Kept intentionally small: it covers the shapes an
+  # LLM is realistically asked to emit, not the whole JSON Schema spec.
+  module OutputSchema
+    module_function
+
+    # Returns the validated/coerced object.
+    # Raises OutputSchemaError if the string can't be parsed or doesn't conform.
+    def coerce(raw, schema)
+      data = parse(raw)
+      validate!(data, schema)
+      data
+    end
+
+    # Extracts a JSON document from a string that may contain surrounding prose,
+    # then parses it. Prefers a fenced ```json block, then the first balanced
+    # object/array, then the whole string.
+    def parse(raw)
+      candidate = extract_json(raw.to_s)
+      JSON.parse(candidate)
+    rescue JSON::ParserError => e
+      raise OutputSchemaError, "output is not valid JSON: #{e.message}"
+    end
+
+    def extract_json(text)
+      if (fenced = text[/```(?:json)?\s*(\{.*?\}|\[.*?\])\s*```/m, 1])
+        return fenced
+      end
+
+      first = text.index(/[{\[]/)
+      last  = text.rindex(/[}\]]/)
+      return text if first.nil? || last.nil? || last < first
+
+      text[first..last]
+    end
+
+    def validate!(data, schema)
+      type = (schema[:type] || schema['type'])&.to_s
+      case type
+      when 'object' then validate_object!(data, schema)
+      when 'array'  then raise_unless(data.is_a?(Array), 'expected an array')
+      when 'string' then raise_unless(data.is_a?(String), 'expected a string')
+      when 'integer' then raise_unless(data.is_a?(Integer), 'expected an integer')
+      when 'number' then raise_unless(data.is_a?(Numeric), 'expected a number')
+      when 'boolean' then raise_unless([true, false].include?(data), 'expected a boolean')
+      end
+      data
+    end
+
+    def validate_object!(data, schema)
+      raise_unless(data.is_a?(Hash), 'expected a JSON object')
+
+      required = schema[:required] || schema['required'] || []
+      required.each do |key|
+        raise_unless(data.key?(key.to_s), "missing required property '#{key}'")
+      end
+
+      props = schema[:properties] || schema['properties'] || {}
+      props.each do |name, subschema|
+        value = data[name.to_s]
+        next if value.nil?
+
+        validate!(value, subschema)
+      end
+    end
+
+    def raise_unless(condition, message)
+      raise OutputSchemaError, message unless condition
+    end
+  end
+
+  class OutputSchemaError < Error; end
+end

data/lib/rcrewai/planning.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'output_schema'
+
+module RCrewAI
+  # Runs a single planning pass over a crew's tasks before execution. Asks an
+  # LLM to draft a short, concrete plan for each task and folds that plan into
+  # the task's description, so the executing agent starts with a game plan.
+  #
+  # Mirrors CrewAI's `planning=True`. Best-effort: if the planner errors or
+  # returns unparseable output, execution proceeds with the original tasks.
+  class Planning
+    def initialize(crew, llm: nil, logger: nil)
+      @crew = crew
+      @llm = llm || LLMClient.for_provider
+      @logger = logger
+    end
+
+    def plan!
+      return if @crew.tasks.empty?
+
+      plans = request_plans
+      return if plans.nil? || plans.empty?
+
+      @crew.tasks.each do |task|
+        step = plans[task.name] || plans[task.name.to_s]
+        task.enrich_description("Plan: #{step}") if step
+      end
+    rescue StandardError => e
+      @logger&.warn("Planning pass failed, continuing without a plan: #{e.message}")
+      nil
+    end
+
+    private
+
+    def request_plans
+      response = @llm.chat(messages: [
+                             { role: 'system', content: system_prompt },
+                             { role: 'user', content: user_prompt }
+                           ])
+      content = response.is_a?(Hash) ? response[:content].to_s : response.to_s
+      parse_plans(content)
+    end
+
+    def parse_plans(content)
+      OutputSchema.parse(content)
+    rescue OutputSchemaError
+      nil
+    end
+
+    def system_prompt
+      'You are a planning assistant. Given a list of tasks, produce a short, ' \
+        'concrete plan for each. Respond ONLY with a JSON object mapping each ' \
+        'task name to a one-sentence plan string.'
+    end
+
+    def user_prompt
+      lines = @crew.tasks.map do |t|
+        "- #{t.name}: #{t.description} (expected: #{t.expected_output || 'n/a'})"
+      end
+      "Tasks:\n#{lines.join("\n")}\n\nReturn JSON: { \"<task name>\": \"<plan>\", ... }"
+    end
+  end
+end

data/lib/rcrewai/pricing.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RCrewAI
+  module Pricing
+    # Prices in USD per 1M tokens. List prices as of 2026-05; users can override.
+    DEFAULT_PRICES = {
+      # OpenAI
+      'gpt-4o' => { input: 2.50, output: 10.00 },
+      'gpt-4o-mini' => { input: 0.15, output: 0.60 },
+      'gpt-4-turbo' => { input: 10.00, output: 30.00 },
+      'gpt-4' => { input: 30.00, output: 60.00 },
+      'gpt-3.5-turbo' => { input: 0.50, output: 1.50 },
+      # Anthropic
+      'claude-opus-4-7' => { input: 15.00, output: 75.00 },
+      'claude-sonnet-4-6' => { input: 3.00, output: 15.00 },
+      'claude-haiku-4-5' => { input: 0.80, output: 4.00 },
+      'claude-3-5-sonnet-20241022' => { input: 3.00, output: 15.00 },
+      'claude-3-haiku-20240307' => { input: 0.25, output: 1.25 },
+      # Google
+      'gemini-1.5-pro' => { input: 1.25, output: 5.00 },
+      'gemini-1.5-flash' => { input: 0.075, output: 0.30 }
+    }.freeze
+
+    module_function
+
+    def cost_for(model, prompt_tokens:, completion_tokens:)
+      table = RCrewAI.configuration.pricing || {}
+      entry = table[model] || DEFAULT_PRICES[model]
+      return nil unless entry
+
+      ((prompt_tokens * entry[:input]) + (completion_tokens * entry[:output])) / 1_000_000.0
+    end
+  end
+end