mcp_on_ruby 0.3.0 → 1.0.0

data/lib/ruby_mcp/providers/anthropic.rb

@@ -1,269 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Providers
-    class Anthropic < Base
-      MODELS = [
-        {
-          id: 'claude-3-opus-20240229',
-          capabilities: %w[text-generation streaming tool-calls]
-        },
-        {
-          id: 'claude-3-sonnet-20240229',
-          capabilities: %w[text-generation streaming tool-calls]
-        },
-        {
-          id: 'claude-3-haiku-20240307',
-          capabilities: %w[text-generation streaming tool-calls]
-        },
-        {
-          id: 'claude-2.1',
-          capabilities: %w[text-generation streaming]
-        },
-        {
-          id: 'claude-2.0',
-          capabilities: %w[text-generation streaming]
-        },
-        {
-          id: 'claude-instant-1.2',
-          capabilities: %w[text-generation streaming]
-        }
-      ].freeze
-
-      def list_engines
-        # Anthropic doesn't have an endpoint to list models, so we use a static list
-        MODELS.map do |model_info|
-          RubyMCP::Models::Engine.new(
-            id: "anthropic/#{model_info[:id]}",
-            provider: 'anthropic',
-            model: model_info[:id],
-            capabilities: model_info[:capabilities]
-          )
-        end
-      end
-
-      def generate(context, options = {})
-        messages = format_messages(context)
-
-        payload = {
-          model: options[:model],
-          messages: messages,
-          max_tokens: options[:max_tokens] || 4096,
-          temperature: options[:temperature],
-          top_p: options[:top_p],
-          stop_sequences: options[:stop]
-        }.compact
-
-        if options[:tools]
-          payload[:tools] = options[:tools]
-          payload[:tool_choice] = options[:tool_choice] || 'auto'
-        end
-
-        headers = {
-          'Anthropic-Version' => '2023-06-01',
-          'Content-Type' => 'application/json'
-        }
-
-        response = create_client.post('messages') do |req|
-          req.headers.merge!(headers)
-          req.body = payload.to_json
-        end
-
-        unless response.success?
-          raise RubyMCP::Errors::ProviderError,
-                "Anthropic generation failed: #{response.body['error']&.dig('message') || response.status}"
-        end
-
-        content = response.body['content']&.first&.dig('text')
-        tool_calls = nil
-
-        # Handle tool calls
-        if response.body['tool_calls']
-          tool_calls = response.body['tool_calls'].map do |tc|
-            {
-              id: tc['id'],
-              type: 'function',
-              function: {
-                name: tc['name'],
-                arguments: tc['input']
-              }
-            }
-          end
-        end
-
-        result = {
-          provider: 'anthropic',
-          model: options[:model],
-          created_at: Time.now.utc.iso8601
-        }
-
-        if tool_calls
-          result[:tool_calls] = tool_calls
-        else
-          result[:content] = content
-        end
-
-        result
-      end
-
-      def generate_stream(context, options = {})
-        messages = format_messages(context)
-
-        payload = {
-          model: options[:model],
-          messages: messages,
-          max_tokens: options[:max_tokens] || 4096,
-          temperature: options[:temperature],
-          top_p: options[:top_p],
-          stop_sequences: options[:stop],
-          stream: true
-        }.compact
-
-        if options[:tools]
-          payload[:tools] = options[:tools]
-          payload[:tool_choice] = options[:tool_choice] || 'auto'
-        end
-
-        headers = {
-          'Anthropic-Version' => '2023-06-01',
-          'Content-Type' => 'application/json'
-        }
-
-        conn = create_client
-
-        # Update the client to handle streaming
-        conn.options.timeout = 120 # Longer timeout for streaming
-
-        generation_id = SecureRandom.uuid
-        content_buffer = ''
-        current_tool_calls = []
-
-        # Initial event
-        yield({
-          id: generation_id,
-          event: 'generation.start',
-          created_at: Time.now.utc.iso8601
-        })
-
-        begin
-          conn.post('messages') do |req|
-            req.headers.merge!(headers)
-            req.body = payload.to_json
-            req.options.on_data = proc do |chunk, _size, _total|
-              next if chunk.strip.empty?
-
-              # Process each SSE event
-              chunk.split('data: ').each do |data|
-                next if data.strip.empty?
-
-                begin
-                  json = JSON.parse(data.strip)
-
-                  case json['type']
-                  when 'content_block_delta'
-                    delta = json['delta']['text']
-                    content_buffer += delta
-
-                    # Send content update
-                    yield({
-                      id: generation_id,
-                      event: 'generation.content',
-                      created_at: Time.now.utc.iso8601,
-                      content: delta
-                    })
-                  when 'tool_call'
-                    tool_call = {
-                      'id' => json['id'],
-                      'type' => 'function',
-                      'function' => {
-                        'name' => json['name'],
-                        'arguments' => json['input']
-                      }
-                    }
-
-                    current_tool_calls << tool_call
-
-                    # Send tool call update
-                    yield({
-                      id: generation_id,
-                      event: 'generation.tool_call',
-                      created_at: Time.now.utc.iso8601,
-                      tool_calls: current_tool_calls
-                    })
-                  when 'message_stop'
-                    # Handled by the final event after the streaming is done
-                  end
-                rescue JSON::ParserError => e
-                  # Skip invalid JSON
-                  RubyMCP.logger.warn "Invalid JSON in Anthropic stream: #{e.message}"
-                end
-              end
-            end
-          end
-        rescue Faraday::Error => e
-          raise RubyMCP::Errors::ProviderError, "Anthropic streaming failed: #{e.message}"
-        end
-
-        # Final event
-        if current_tool_calls.any?
-          # Final tool calls event
-          yield({
-            id: generation_id,
-            event: 'generation.complete',
-            created_at: Time.now.utc.iso8601,
-            tool_calls: current_tool_calls
-          })
-        else
-          # Final content event
-          yield({
-            id: generation_id,
-            event: 'generation.complete',
-            created_at: Time.now.utc.iso8601,
-            content: content_buffer
-          })
-        end
-      end
-
-      def abort_generation(_generation_id)
-        # Anthropic doesn't support aborting generations yet
-        raise RubyMCP::Errors::ProviderError, "Anthropic doesn't support aborting generations"
-      end
-
-      protected
-
-      def default_api_base
-        'https://api.anthropic.com/v1'
-      end
-
-      private
-
-      def format_messages(context)
-        context.messages.map do |msg|
-          # Convert to Anthropic's message format
-          if msg.content_type == 'array'
-            # Handle structured content
-            content_parts = []
-
-            msg.content.each do |part|
-              if part.is_a?(String)
-                content_parts << { 'type' => 'text', 'text' => part }
-              elsif part.is_a?(Hash)
-                if part[:type] == 'text'
-                  content_parts << { 'type' => 'text', 'text' => part[:text] }
-                elsif part[:type] == 'content_pointer'
-                  # We don't have file IDs for Anthropic here
-                  content_parts << { 'type' => 'text', 'text' => "[Content reference: #{part[:content_id]}]" }
-                end
-              end
-            end
-
-            { 'role' => msg.role, 'content' => content_parts }
-          else
-            # Simple text content
-            { 'role' => msg.role, 'content' => msg.content }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_mcp/providers/base.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Providers
-    class Base
-      attr_reader :config
-
-      def initialize(config = {})
-        @config = config
-      end
-
-      def list_engines
-        raise NotImplementedError, "#{self.class.name} must implement #list_engines"
-      end
-
-      def generate(context, options = {})
-        raise NotImplementedError, "#{self.class.name} must implement #generate"
-      end
-
-      def generate_stream(context, options = {}, &block)
-        raise NotImplementedError, "#{self.class.name} must implement #generate_stream"
-      end
-
-      def abort_generation(generation_id)
-        raise NotImplementedError, "#{self.class.name} must implement #abort_generation"
-      end
-
-      protected
-
-      def api_key
-        @config[:api_key] || ENV["#{provider_name.upcase}_API_KEY"]
-      end
-
-      def api_base
-        @config[:api_base] || default_api_base
-      end
-
-      def provider_name
-        self.class.name.split('::').last.downcase
-      end
-
-      def default_api_base
-        raise NotImplementedError, "#{self.class.name} must implement #default_api_base"
-      end
-
-      def create_client
-        Faraday.new(url: api_base) do |conn|
-          conn.request :json
-          conn.response :json
-          conn.adapter :net_http
-          conn.headers['Authorization'] = "Bearer #{api_key}"
-          conn.headers['Content-Type'] = 'application/json'
-        end
-      end
-    end
-  end
-end

data/lib/ruby_mcp/providers/openai.rb

@@ -1,265 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Providers
-    class Openai < Base
-      def list_engines
-        response = create_client.get('models')
-
-        unless response.success?
-          raise RubyMCP::Errors::ProviderError,
-                "Failed to list OpenAI models: #{response.body['error']&.dig('message') || response.status}"
-        end
-
-        models = response.body['data']
-
-        models.map do |model_data|
-          next unless model_data['id'].start_with?('gpt')
-
-          capabilities = ['text-generation']
-          capabilities << 'streaming' if model_data['id'].start_with?('gpt-3.5', 'gpt-4')
-          capabilities << 'tool-calls' if model_data['id'].start_with?('gpt-3.5', 'gpt-4')
-
-          RubyMCP::Models::Engine.new(
-            id: "openai/#{model_data['id']}",
-            provider: 'openai',
-            model: model_data['id'],
-            capabilities: capabilities
-          )
-        end.compact
-      end
-
-      def generate(context, options = {})
-        messages = format_messages(context)
-
-        payload = {
-          model: options[:model],
-          messages: messages,
-          max_tokens: options[:max_tokens],
-          temperature: options[:temperature],
-          top_p: options[:top_p],
-          frequency_penalty: options[:frequency_penalty],
-          presence_penalty: options[:presence_penalty],
-          stop: options[:stop]
-        }.compact
-
-        if options[:tools]
-          payload[:tools] = options[:tools]
-          payload[:tool_choice] = options[:tool_choice] || 'auto'
-        end
-
-        response = create_client.post('chat/completions', payload)
-
-        unless response.success?
-          raise RubyMCP::Errors::ProviderError,
-                "OpenAI generation failed: #{response.body['error']&.dig('message') || response.status}"
-        end
-
-        choice = response.body['choices']&.first
-        content = choice&.dig('message', 'content')
-
-        # Handle tool calls
-        tool_calls = nil
-        if choice&.dig('message', 'tool_calls')
-          tool_calls = choice['message']['tool_calls'].map do |tc|
-            {
-              id: tc['id'],
-              type: 'function',
-              function: {
-                name: tc['function']['name'],
-                arguments: tc['function']['arguments']
-              }
-            }
-          end
-        end
-
-        result = {
-          provider: 'openai',
-          model: options[:model],
-          created_at: Time.now.utc.iso8601
-        }
-
-        if tool_calls
-          result[:tool_calls] = tool_calls
-        else
-          result[:content] = content
-        end
-
-        result
-      end
-
-      def generate_stream(context, options = {})
-        messages = format_messages(context)
-
-        payload = {
-          model: options[:model],
-          messages: messages,
-          max_tokens: options[:max_tokens],
-          temperature: options[:temperature],
-          top_p: options[:top_p],
-          frequency_penalty: options[:frequency_penalty],
-          presence_penalty: options[:presence_penalty],
-          stop: options[:stop],
-          stream: true
-        }.compact
-
-        if options[:tools]
-          payload[:tools] = options[:tools]
-          payload[:tool_choice] = options[:tool_choice] || 'auto'
-        end
-
-        conn = create_client
-
-        # Update the client to handle streaming
-        conn.options.timeout = 120 # Longer timeout for streaming
-
-        generation_id = SecureRandom.uuid
-        content_buffer = ''
-        current_tool_calls = []
-
-        # Initial event
-        yield({
-          id: generation_id,
-          event: 'generation.start',
-          created_at: Time.now.utc.iso8601
-        })
-
-        begin
-          conn.post('chat/completions') do |req|
-            req.body = payload.to_json
-            req.options.on_data = proc do |chunk, _size, _total|
-              next if chunk.strip.empty?
-
-              # Process each SSE event
-              chunk.split('data: ').each do |data|
-                next if data.strip.empty?
-
-                # Skip "[DONE]" marker
-                next if data.strip == '[DONE]'
-
-                begin
-                  json = JSON.parse(data.strip)
-                  delta = json.dig('choices', 0, 'delta')
-
-                  if delta&.key?('content') && delta['content']
-                    content_buffer += delta['content']
-
-                    # Send content update
-                    yield({
-                      id: generation_id,
-                      event: 'generation.content',
-                      created_at: Time.now.utc.iso8601,
-                      content: delta['content']
-                    })
-                  end
-
-                  # Handle tool call updates
-                  if delta&.key?('tool_calls')
-                    delta['tool_calls'].each do |tc|
-                      tc_id = tc['index']
-
-                      # Initialize tool call if it's new
-                      current_tool_calls[tc_id] ||= {
-                        'id' => SecureRandom.uuid,
-                        'type' => 'function',
-                        'function' => {
-                          'name' => '',
-                          'arguments' => ''
-                        }
-                      }
-
-                      # Update function name
-                      if tc.dig('function', 'name')
-                        current_tool_calls[tc_id]['function']['name'] += tc['function']['name']
-                      end
-
-                      # Update arguments
-                      if tc.dig('function', 'arguments')
-                        current_tool_calls[tc_id]['function']['arguments'] += tc['function']['arguments']
-                      end
-
-                      # Send tool call update
-                      yield({
-                        id: generation_id,
-                        event: 'generation.tool_call',
-                        created_at: Time.now.utc.iso8601,
-                        tool_calls: current_tool_calls
-                      })
-                    end
-                  end
-                rescue JSON::ParserError => e
-                  # Skip invalid JSON
-                  RubyMCP.logger.warn "Invalid JSON in OpenAI stream: #{e.message}"
-                end
-              end
-            end
-          end
-        rescue Faraday::Error => e
-          raise RubyMCP::Errors::ProviderError, "OpenAI streaming failed: #{e.message}"
-        end
-
-        # Final event
-        if current_tool_calls.any?
-          # Final tool calls event
-          yield({
-            id: generation_id,
-            event: 'generation.complete',
-            created_at: Time.now.utc.iso8601,
-            tool_calls: current_tool_calls
-          })
-        else
-          # Final content event
-          yield({
-            id: generation_id,
-            event: 'generation.complete',
-            created_at: Time.now.utc.iso8601,
-            content: content_buffer
-          })
-        end
-      end
-
-      def abort_generation(_generation_id)
-        # OpenAI doesn't support aborting generations yet
-        raise RubyMCP::Errors::ProviderError, "OpenAI doesn't support aborting generations"
-      end
-
-      protected
-
-      def default_api_base
-        'https://api.openai.com/v1'
-      end
-
-      private
-
-      def format_messages(context)
-        context.messages.map do |msg|
-          # Convert to OpenAI's message format
-          message = { 'role' => msg.role, 'content' => msg.content }
-
-          # Handle structured content
-          if msg.content_type == 'array'
-            content_parts = []
-
-            msg.content.each do |part|
-              if part.is_a?(String)
-                content_parts << { 'type' => 'text', 'text' => part }
-              elsif part.is_a?(Hash)
-                if part[:type] == 'text'
-                  content_parts << { 'type' => 'text', 'text' => part[:text] }
-                elsif part[:type] == 'content_pointer'
-                  # We don't have file IDs for OpenAI here
-                  # In a real implementation, we would upload the file to OpenAI
-                  content_parts << { 'type' => 'text', 'text' => "[Content reference: #{part[:content_id]}]" }
-                end
-              end
-            end
-
-            message['content'] = content_parts
-          end
-
-          message
-        end
-      end
-    end
-  end
-end

data/lib/ruby_mcp/schemas.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry-schema'
-
-module RubyMCP
-  module Schemas
-    # Define schemas using dry-schema
-
-    ContextSchema = Dry::Schema.JSON do
-      optional(:id).maybe(:string).filled(format?: /^ctx_[a-zA-Z0-9]+$/)
-
-      optional(:messages).array(:hash) do
-        required(:role).filled(:string, included_in?: %w[user assistant system tool])
-        required(:content).filled
-        optional(:id).maybe(:string)
-        optional(:metadata).maybe(:hash)
-      end
-
-      optional(:metadata).maybe(:hash)
-    end
-
-    MessageSchema = Dry::Schema.JSON do
-      required(:context_id).filled(:string, format?: /^ctx_[a-zA-Z0-9]+$/)
-      required(:role).filled(:string, included_in?: %w[user assistant system tool])
-      required(:content).filled
-      optional(:id).maybe(:string)
-      optional(:metadata).maybe(:hash)
-    end
-
-    GenerateSchema = Dry::Schema.JSON do
-      required(:context_id).filled(:string, format?: /^ctx_[a-zA-Z0-9]+$/)
-      required(:engine_id).filled(:string, format?: %r{^[a-z0-9-]+/[a-z0-9-]+$})
-
-      optional(:max_tokens).maybe(:integer, gt?: 0)
-      optional(:temperature).maybe(:float, gteq?: 0, lteq?: 2)
-      optional(:top_p).maybe(:float, gteq?: 0, lteq?: 1)
-      optional(:frequency_penalty).maybe(:float, gteq?: -2, lteq?: 2)
-      optional(:presence_penalty).maybe(:float, gteq?: -2, lteq?: 2)
-      optional(:stop).maybe(:string)
-      optional(:update_context).maybe(:bool)
-
-      # Tool calling support could be added here
-    end
-
-    ContentSchema = Dry::Schema.JSON do
-      required(:context_id).filled(:string, format?: /^ctx_[a-zA-Z0-9]+$/)
-      optional(:id).maybe(:string)
-      optional(:type).maybe(:string)
-
-      optional(:file_data).maybe(:string)
-      optional(:filename).maybe(:string)
-      optional(:content_type).maybe(:string)
-      optional(:data).maybe(:hash)
-    end
-  end
-end