rasti-ai 1.0.1 → 1.2.0

data/spec/mcp/client_spec.rb

@@ -0,0 +1,256 @@
+require 'minitest_helper'
+
+describe Rasti::AI::MCP::Client do
+
+  let(:mcp_url) { 'https://mcp.server.ai/mcp' }
+
+  let(:client) { Rasti::AI::MCP::Client.new(url: mcp_url) }
+
+  let(:client_with_allowed_tools) { Rasti::AI::MCP::Client.new(url: mcp_url, allowed_tools: ['sum_tool']) }
+
+  def stub_mcp_request(method, params:{}, result:{}, error:nil)
+    request_body = {
+      jsonrpc: '2.0',
+      method: method,
+      params: params
+    }
+
+    response_body = {
+      jsonrpc: '2.0'
+    }
+
+    if error
+      response_body[:error] = error
+    else
+      response_body[:result] = result
+    end
+
+    stub_request(:post, mcp_url)
+      .with(
+        body: JSON.dump(request_body),
+        headers: {'Content-Type' => 'application/json'}
+      )
+      .to_return(
+        body: JSON.dump(response_body),
+        headers: {'Content-Type' => 'application/json'}
+      )
+  end
+
+  describe 'List tools' do
+
+    it 'Returns all tools when no allowed_tools' do
+      tools = [
+        {
+          'name' => 'hello_world_tool',
+          'description' => 'Hello World'
+        },
+        {
+          'name' => 'sum_tool',
+          'description' => 'Sum two numbers'
+        }
+      ]
+
+      stub_mcp_request 'tools/list', result: {'tools' => tools}
+
+      result = client.list_tools
+
+      assert_equal tools, result
+    end
+
+    it 'Returns empty list when no tools available' do
+      stub_mcp_request 'tools/list', result: {'tools' => []}
+
+      result = client.list_tools
+
+      assert_equal [], result
+    end
+
+    it 'Filters tools by allowed_tools' do
+      tools = [
+        {
+          'name' => 'hello_world_tool',
+          'description' => 'Hello World'
+        },
+        {
+          'name' => 'sum_tool',
+          'description' => 'Sum two numbers'
+        },
+        {
+          'name' => 'multiply_tool',
+          'description' => 'Multiply'
+        }
+      ]
+
+      stub_mcp_request 'tools/list', result: {'tools' => tools}
+
+      result = client_with_allowed_tools.list_tools
+
+      expected = [
+        {
+          'name' => 'sum_tool',
+          'description' => 'Sum two numbers'
+        }
+      ]
+
+      assert_equal expected, result
+    end
+
+    it 'Returns empty when no tools match allowed_tools' do
+      tools = [
+        {
+          'name' => 'hello_world_tool',
+          'description' => 'Hello World'
+        },
+        {
+          'name' => 'multiply_tool',
+          'description' => 'Multiply'
+        }
+      ]
+
+      stub_mcp_request 'tools/list', result: {'tools' => tools}
+
+      result = client_with_allowed_tools.list_tools
+
+      assert_equal [], result
+    end
+
+  end
+
+  describe 'Call tool' do
+
+    it 'Executes tool with arguments' do
+      params = {
+        name: 'sum_tool',
+        arguments: {
+          number_a: 1,
+          number_b: 2
+        }
+      }
+
+      result_content = {
+        'content' => [
+          {
+            'type' => 'text',
+            'text' => '{"result":3.0}'
+          }
+        ]
+      }
+
+      stub_mcp_request 'tools/call', params: params, result: result_content
+
+      result = client.call_tool 'sum_tool', number_a: 1, number_b: 2
+
+      assert_equal '{"type":"text","text":"{\"result\":3.0}"}', result
+    end
+
+    it 'Executes tool without arguments' do
+      params = {
+        name: 'hello_world_tool',
+        arguments: {}
+      }
+
+      result_content = {
+        'content' => [
+          {
+            'type' => 'text',
+            'text' => '{"text":"Hello world"}'
+          }
+        ]
+      }
+
+      stub_mcp_request 'tools/call', params: params, result: result_content
+
+      result = client.call_tool 'hello_world_tool'
+
+      assert_equal '{"type":"text","text":"{\"text\":\"Hello world\"}"}', result
+    end
+
+    it 'Raises error when tool not in allowed_tools' do
+      error = assert_raises RuntimeError do
+        client_with_allowed_tools.call_tool 'hello_world_tool'
+      end
+
+      assert_equal 'Invalid tool: hello_world_tool', error.message
+    end
+
+    it 'Allows tool call when in allowed_tools' do
+      params = {
+        name: 'sum_tool',
+        arguments: {
+          number_a: 5,
+          number_b: 3
+        }
+      }
+
+      result_content = {
+        'content' => [
+          {
+            'type' => 'text',
+            'text' => '{"result":8.0}'
+          }
+        ]
+      }
+
+      stub_mcp_request 'tools/call', params: params, result: result_content
+
+      result = client_with_allowed_tools.call_tool 'sum_tool', number_a: 5, number_b: 3
+
+      assert_equal '{"type":"text","text":"{\"result\":8.0}"}', result
+    end
+
+  end
+
+  describe 'Error handling' do
+
+    it 'Raises error when MCP returns error' do
+      error_response = {
+        'code' => -32603,
+        'message' => 'Tool not found'
+      }
+
+      params = {
+        name: 'nonexistent',
+        arguments: {}
+      }
+
+      stub_mcp_request 'tools/call', params: params, error: error_response
+
+      error = assert_raises RuntimeError do
+        client.call_tool 'nonexistent'
+      end
+
+      assert_equal 'MCP Error: Tool not found', error.message
+    end
+
+    it 'Raises error when result is missing' do
+      stub_request(:post, mcp_url)
+        .to_return(
+          status: 200,
+          body: JSON.dump({ jsonrpc: '2.0' }),
+          headers: { 'Content-Type' => 'application/json' }
+        )
+
+      error = assert_raises RuntimeError do
+        client.list_tools
+      end
+
+      assert_equal 'MCP Error: invalid result', error.message
+    end
+
+    it 'Raises error when response is invalid JSON' do
+      stub_request(:post, mcp_url)
+        .to_return(
+          status: 200,
+          body: 'invalid json{',
+          headers: {'Content-Type' => 'application/json'}
+        )
+
+      error = assert_raises JSON::ParserError do
+        client.list_tools
+      end
+
+      assert_match /unexpected token/, error.message
+    end
+
+  end
+end

data/spec/mcp/server_spec.rb

@@ -0,0 +1,372 @@
+require 'minitest_helper'
+
+describe Rasti::AI::MCP::Server do
+
+  class HelloWorldTool < Rasti::AI::Tool
+    def self.description
+      'Hello World'
+    end
+
+    def execute(form)
+      {text: 'Hello world'}
+    end
+  end
+
+  class SumTool < Rasti::AI::Tool
+    class Form < Rasti::Form
+      attribute :number_a, Rasti::Types::Float
+      attribute :number_b, Rasti::Types::Float
+    end
+
+    def execute(form)
+      {result: form.number_a + form.number_b}
+    end
+  end
+
+  class ErrorTool < Rasti::AI::Tool
+    def execute(form)
+      raise "Unexpected tool error"
+    end
+  end
+
+  include Rack::Test::Methods
+
+  let(:app) do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['App response']] }
+    Rasti::AI::MCP::Server.new app
+  end
+
+  before do
+    Rasti::AI::MCP::Server.clear_tools
+    Rasti::AI::MCP::Server.restore_default_configuration
+  end
+
+  def post_mcp_request(method, params={})
+    request_data = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: method
+    }
+    request_data[:params] = params unless params.empty?
+
+    post Rasti::AI::MCP::Server.relative_path, JSON.dump(request_data), CONTENT_TYPE: 'application/json'
+  end
+
+  def assert_jsonrpc_success(expected_result)
+    expected_response = {
+      jsonrpc: '2.0',
+      id: 1,
+      result: expected_result
+    }
+    
+    assert_equal 200, last_response.status
+    assert_equal 'application/json', last_response.content_type
+    assert_equal_json JSON.dump(expected_response), last_response.body
+  end
+
+  def assert_jsonrpc_error(expected_error)
+    expected_response = {
+      jsonrpc: '2.0',
+      id: 1,
+      error: expected_error
+    }
+    
+    assert_equal 200, last_response.status
+    assert_equal 'application/json', last_response.content_type
+    assert_equal_json JSON.dump(expected_response), last_response.body
+  end
+
+  describe 'Tool registration' do
+
+    it 'Register tool' do
+      Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+      Rasti::AI::MCP::Server.register_tool SumTool.new
+      
+      serializations = Rasti::AI::MCP::Server.tools_serializations
+
+      expeted_serializations = [
+        Rasti::AI::ToolSerializer.serialize(HelloWorldTool),
+        Rasti::AI::ToolSerializer.serialize(SumTool)
+      ]
+
+      assert_equal expeted_serializations, serializations
+    end
+
+    it 'Register duplicate tool raises error' do
+      Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+      
+      error = assert_raises RuntimeError do
+        Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+      end
+      
+      assert_equal 'Tool hello_world_tool already exist', error.message
+    end
+
+    it 'Tools serializations empty when no tools' do
+      assert_empty Rasti::AI::MCP::Server.tools_serializations
+    end
+
+    it 'Call tool executes registered tool' do
+      Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+      
+      result = Rasti::AI::MCP::Server.call_tool 'hello_world_tool'
+      
+      assert_equal '{"text":"Hello world"}', result
+    end
+
+    it 'Call tool not found raises error' do
+      error = assert_raises RuntimeError do
+        Rasti::AI::MCP::Server.call_tool 'non_existent', {}
+      end
+      
+      assert_equal 'Tool non_existent not found', error.message
+    end
+
+  end
+
+  describe 'Initialize request' do
+
+    it 'Returns protocol version and capabilities' do
+      post_mcp_request 'initialize'
+
+      expected_result = {
+        protocolVersion: '2024-11-05',
+        capabilities: {
+          tools: {
+            list: true,
+            call: true
+          }
+        },
+        serverInfo: {
+          name: 'MCP Server',
+          version: '1.0.0'
+        }
+      }
+
+      assert_jsonrpc_success expected_result
+    end
+
+    it 'Custom server configuration' do
+      Rasti::AI::MCP::Server.configure do |config|
+        config.server_name = 'Custom MCP Server'
+        config.server_version = '2.0.0'
+      end
+      
+      post_mcp_request 'initialize'
+
+      expected_result = {
+        protocolVersion: '2024-11-05',
+        capabilities: {
+          tools: {
+            list: true,
+            call: true
+          }
+        },
+        serverInfo: {
+          name: 'Custom MCP Server',
+          version: '2.0.0'
+        }
+      }
+
+      assert_jsonrpc_success expected_result
+    end
+
+  end
+
+  describe 'Tools list request' do
+
+    it 'Returns empty list when no tools' do
+      post_mcp_request 'tools/list'
+
+      expected_result = {
+        tools: []
+      }
+
+      assert_jsonrpc_success expected_result
+    end
+
+    it 'Returns registered tools' do
+      Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+      Rasti::AI::MCP::Server.register_tool SumTool.new
+
+      post_mcp_request 'tools/list'
+
+      expected_result = {
+        tools: [
+          Rasti::AI::ToolSerializer.serialize(HelloWorldTool),
+          Rasti::AI::ToolSerializer.serialize(SumTool)
+        ]
+      }
+
+      assert_jsonrpc_success expected_result
+    end
+
+  end
+
+  describe 'Tools call request' do
+
+    before do
+      Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+      Rasti::AI::MCP::Server.register_tool SumTool.new
+    end
+
+    it 'Executes tool with arguments' do
+      params = {
+        name: 'sum_tool',
+        arguments: {
+          number_a: 1,
+          number_b: 2
+        }
+      }
+
+      post_mcp_request 'tools/call', params
+
+      expected_result = {
+        content: [
+          {
+            type: 'text',
+            text: '{"result":3.0}'
+          }
+        ]
+      }
+
+      assert_jsonrpc_success expected_result
+    end
+
+    it 'Executes tool without arguments' do
+      params = {
+        name: 'hello_world_tool'
+      }
+
+      post_mcp_request 'tools/call', params
+
+      expected_result = {
+        content: [
+          {
+            type: 'text',
+            text: '{"text":"Hello world"}'
+          }
+        ]
+      }
+
+      assert_jsonrpc_success expected_result
+    end
+
+    it 'Tool call with nonexistent tool returns error' do
+      params = {
+        name: 'nonexistent'
+      }
+
+      post_mcp_request 'tools/call', params
+
+      expected_error = {
+        code: -32603,
+        message: 'Tool nonexistent not found'
+      }
+
+      assert_jsonrpc_error expected_error
+    end
+
+    it 'Tool execution error returns error response' do
+      Rasti::AI::MCP::Server.register_tool ErrorTool.new
+
+      params = {
+        name: 'error_tool'
+      }
+
+      post_mcp_request 'tools/call', params
+
+      expected_error = {
+        code: -32603,
+        message: 'Unexpected tool error'
+      }
+
+      assert_jsonrpc_error expected_error
+    end
+
+  end
+
+  describe 'Error handling' do
+
+    it 'Method not found' do
+      post_mcp_request 'invalid/method'
+
+      expected_error = {
+        code: -32601,
+        message: 'Method not found'
+      }
+
+      assert_jsonrpc_error expected_error      
+    end
+
+    it 'Invalid JSON returns 400' do
+      post '/mcp', 'invalid json{'
+      
+      assert_equal 400, last_response.status
+      assert_equal 'application/json', last_response.content_type
+
+      json_response = JSON.parse last_response.body
+      assert_equal -32700, json_response['error']['code']
+      assert_match /unexpected token/, json_response['error']['message']
+    end
+
+    it 'Unhandled exception returns 500' do
+      app.stub :handle_initialize, ->(_) { raise 'Unexpected server error' } do
+        post_mcp_request 'initialize'
+
+        expected_response = {
+          jsonrpc: '2.0',
+          id: nil,
+          error: {
+            code: -32603,
+            message: 'Unexpected server error'
+          }
+        }
+        
+        assert_equal 500, last_response.status
+        assert_equal 'application/json', last_response.content_type
+        assert_equal_json JSON.dump(expected_response), last_response.body
+      end
+    end
+
+  end
+
+  describe 'Middleware behavior' do
+
+    it 'Non MCP requests passed to app' do
+      get '/other/path'
+      
+      assert_equal 200, last_response.status
+      assert_equal 'App response', last_response.body
+    end
+
+    it 'GET requests to MCP path passed to app' do
+      get '/mcp'
+      
+      assert_equal 200, last_response.status
+      assert_equal 'App response', last_response.body
+    end
+
+    it 'POST to different path passed to app' do
+      post '/other/path'
+
+      assert_equal 200, last_response.status
+      assert_equal 'App response', last_response.body
+    end
+
+    it 'Custom relative path' do
+      Rasti::AI::MCP::Server.configure do |config|
+        config.relative_path = '/path/too/custom_mcp'
+      end
+
+      post '/mcp'
+      assert_equal 200, last_response.status
+      assert_equal 'App response', last_response.body 
+      
+      post_mcp_request 'tools/list'
+      assert_jsonrpc_success tools: []
+    end
+
+  end
+
+end

data/spec/minitest_helper.rb

@@ -1,7 +1,9 @@
 require 'coverage_helper'
 require 'minitest/autorun'
 require 'minitest/colorin'
+require 'minitest/extended_assertions'
 require 'webmock/minitest'
+require 'rack/test'
 require 'pry-nav'
 require 'rasti-ai'
 require 'securerandom'

data/spec/open_ai/assistant_spec.rb

@@ -8,14 +8,17 @@ describe Rasti::AI::OpenAI::Assistant do
 
   let(:answer) { 'Lionel Messi scored 672 goals in 778 official matches for FC Barcelona.' }
 
-  def stub_open_ai_chat_completions(model:nil, question:, answer:)
+  def stub_open_ai_chat_completions(question:, answer:, model:nil, json_schema:nil)
     model ||= Rasti::AI.openai_default_model
 
+    body = read_json_resource('open_ai/basic_request.json', model: model, prompt: question)
+    body['response_format'] = {type: 'json_schema', json_schema: json_schema} if json_schema
+
     stub_request(:post, api_url)
-      .with(body: read_resource('open_ai/basic_request.json', model: model, prompt: question))
+      .with(body: JSON.dump(body))
       .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
   end
-
+ 
 
   it 'Default' do
     stub_open_ai_chat_completions question: question, answer: answer
@@ -39,7 +42,8 @@ describe Rasti::AI::OpenAI::Assistant do
               role: Rasti::AI::OpenAI::Roles::USER,
               content: question
             }
-          ]
+          ],
+          response_format: nil
         }
       ]
 
@@ -107,6 +111,19 @@ describe Rasti::AI::OpenAI::Assistant do
       assert_equal answer, response
     end
 
+    it 'JSON Schema' do
+      json_schema = {answer: 'Response answer'}
+      json_answer = "{\\\"answer\\\": \\\"#{answer}\\\"}"
+
+      stub_open_ai_chat_completions question: question, answer: json_answer, json_schema: json_schema
+
+      assistant = Rasti::AI::OpenAI::Assistant.new json_schema: json_schema
+
+      response = assistant.call question
+
+      assert_equal answer, JSON.parse(response)['answer']
+    end
+
   end
 
   describe 'Tools' do
@@ -146,11 +163,18 @@ describe Rasti::AI::OpenAI::Assistant do
     end
 
     def stub_client_request(role:, content:, response:, tools:[])
+      serialized_tools = tools.map do |tool|
+        {
+          type: 'function',
+          function: Rasti::AI::ToolSerializer.serialize(tool.class)
+        }
+      end
+      
       client.expect :chat_completions, response do |params|
         last_message = params[:messages].last
         last_message[:role] == role &&
           last_message[:content] == content &&
-          params[:tools] == tools.map { |t| Rasti::AI::OpenAI::ToolSerializer.serialize t.class }
+          params[:tools] == serialized_tools
       end
     end