rasti-ai 2.0.2 → 3.0.0

data/lib/rasti/ai/mcp/client.rb

@@ -4,13 +4,14 @@ module Rasti
       class Client
 
         def initialize(url:, allowed_tools:nil, logger:nil)
-          @url = url
+          @url          = url
           @allowed_tools = allowed_tools
-          @logger = logger || Rasti::AI.logger
+          @logger       = logger || Rasti::AI.logger
+          @session_id   = nil
         end
 
         def list_tools
-          result = request_mcp 'tools/list'
+          result = request_with_session 'tools/list'
           tools = result['tools']
           if allowed_tools
             tools.select { |tool| allowed_tools.include? tool['name'] }
@@ -21,15 +22,55 @@ module Rasti
 
         def call_tool(name, arguments={})
           raise "Invalid tool: #{name}" if allowed_tools && !allowed_tools.include?(name)
-          result = request_mcp 'tools/call', name: name, arguments: arguments
+          result = request_with_session 'tools/call', name: name, arguments: arguments
           JSON.dump result['content'][0]
         end
 
         private
 
-        attr_reader :url, :allowed_tools, :logger
+        attr_reader :url, :allowed_tools, :logger, :session_id
+
+        def request_with_session(method, params={})
+          request_mcp method, params
+        rescue RuntimeError => e
+          raise unless e.message =~ /session/i && session_id.nil?
+          initialize_session
+          request_mcp method, params
+        end
+
+        def initialize_session
+          _result, response = request_mcp_raw 'initialize',
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: {name: 'rasti-ai', version: Rasti::AI::VERSION}
+
+          @session_id = response['mcp-session-id']
+
+          send_notification 'notifications/initialized' if session_id
+        end
+
+        def send_notification(method)
+          uri = URI.parse url
+          http = Net::HTTP.new uri.host, uri.port
+          http.use_ssl = uri.scheme == 'https'
+
+          req = Net::HTTP::Post.new uri.path
+          req['Content-Type'] = 'application/json'
+          req['Accept'] = 'application/json, text/event-stream'
+          req['Mcp-Session-Id'] = session_id if session_id
+          req.body = JSON.dump(jsonrpc: JSON_RPC_VERSION, method: method)
+
+          http.request req
+        rescue => e
+          logger.warn(self.class) { "Notification failed: #{e.message}" }
+        end
 
         def request_mcp(method, params={})
+          result, _response = request_mcp_raw method, params
+          result
+        end
+
+        def request_mcp_raw(method, params={})
           uri = URI.parse url
 
           http = Net::HTTP.new uri.host, uri.port
@@ -38,9 +79,12 @@ module Rasti
           request = Net::HTTP::Post.new uri.path
 
           request['Content-Type'] = 'application/json'
+          request['Accept'] = 'application/json, text/event-stream'
+          request['Mcp-Session-Id'] = session_id if session_id
 
           body = {
-            jsonrpc: '2.0',
+            jsonrpc: JSON_RPC_VERSION,
+            id: 1,
             method: method,
             params: params
           }
@@ -48,18 +92,25 @@ module Rasti
 
           logger.info(self.class) { "POST #{url} -> #{method}" }
           logger.debug(self.class) { JSON.pretty_generate(params) }
-          
+
           response = http.request request
 
           logger.info(self.class) { "Response #{response.code}" }
           logger.debug(self.class) { response.body }
 
-          json = JSON.parse response.body
+          body_str = response.body
+
+          # Handle SSE format (text/event-stream)
+          if response['Content-Type']&.include?('text/event-stream')
+            body_str = body_str.scan(/^data:\s*(.+)$/).flatten.first || body_str
+          end
+
+          json = JSON.parse body_str
 
           raise "MCP Error: #{json['error']['message']}" if json['error']
           raise "MCP Error: invalid result" unless json['result']
 
-          json['result']
+          [json['result'], response]
         end
 
       end

data/lib/rasti/ai/mcp/{errors.rb → constants.rb}

@@ -2,6 +2,9 @@ module Rasti
   module AI
     module MCP
 
+      JSON_RPC_VERSION                   = '2.0'.freeze
+      PROTOCOL_VERSION                   = '2024-11-05'.freeze
+
       # JSON-RPC oficiales
       JSON_RPC_PARSE_ERROR               = -32700
       JSON_RPC_INVALID_REQUEST           = -32600
@@ -26,4 +29,4 @@ module Rasti
 
     end
   end
-end
+end

data/lib/rasti/ai/mcp/server.rb

@@ -3,44 +3,22 @@ module Rasti
     module MCP
       class Server
 
-        ToolSpecification = Rasti::Model[:tool, :serialization]
-
-        PROTOCOL_VERSION = '2024-11-05'.freeze
-        JSON_RPC_VERSION = '2.0'.freeze
-
         extend ClassConfig
 
-        attr_config :server_name, 'MCP Server'
+        attr_config :server_name,    'MCP Server'
         attr_config :server_version, '1.0.0'
-        attr_config :relative_path, '/mcp'
-        
-        class << self
-
-          def register_tool(tool)
-            serialization = ToolSerializer.serialize tool.class
-            raise "Tool #{serialization[:name]} already exist" if tools.key? serialization[:name]
-            tools[serialization[:name]] = ToolSpecification.new tool: tool, serialization: serialization
-          end
-
-          def clear_tools
-            tools.clear
-          end
+        attr_config :relative_path,  '/mcp'
+        attr_config :tools_loader
+        attr_config :authenticator
 
-          def tools_serializations
-            tools.values.map(&:serialization)
-          end
-
-          def call_tool(name, arguments={})
-            raise "Tool #{name} not found" unless tools.key? name
-            tools[name].tool.call arguments
+        class << self
+          def load_tools(&block)
+            self.tools_loader = block
           end
 
-          private
-
-          def tools
-            @tools ||= {}
+          def authenticate(&block)
+            self.authenticator = block
           end
-
         end
 
         def initialize(app)
@@ -49,7 +27,7 @@ module Rasti
 
         def call(env)
           request = Rack::Request.new env
-          
+
           if request.post? && request.path == self.class.relative_path
             handle_mcp_request request
           else
@@ -62,31 +40,48 @@ module Rasti
         attr_reader :app
 
         def handle_mcp_request(request)
+          if !authorized? request
+            response = error_response nil, JSON_RPC_SERVER_UNAUTHORIZED, 'Unauthorized'
+            return [401, {'Content-Type' => 'application/json'}, [JSON.dump(response)]]
+          end
+
           body = request.body.read
           data = JSON.parse body
-          
+
+          tools_registry = build_tools_registry request
+
           response = case data['method']
           when 'initialize'
             handle_initialize data
           when 'tools/list'
-            handle_tools_list data
+            handle_tools_list data, tools_registry
           when 'tools/call'
-            handle_tool_call data
+            handle_tool_call data, tools_registry
           else
             error_response data['id'], JSON_RPC_METHOD_NOT_FOUND, 'Method not found'
           end
-          
+
           [200, {'Content-Type' => 'application/json'}, [JSON.dump(response)]]
 
         rescue JSON::ParserError => e
           response = error_response nil, JSON_RPC_PARSE_ERROR, e.message
           [400, {'Content-Type' => 'application/json'}, [JSON.dump(response)]]
-          
+
         rescue => e
           response = error_response nil, JSON_RPC_INTERNAL_ERROR, e.message
           [500, {'Content-Type' => 'application/json'}, [JSON.dump(response)]]
         end
-        
+
+        def authorized?(request)
+          !self.class.authenticator || self.class.authenticator.call(request)
+        end
+
+        def build_tools_registry(request)
+          tools_registry = ToolsRegistry.new
+          self.class.tools_loader.call tools_registry, request if self.class.tools_loader
+          tools_registry
+        end
+
         def handle_initialize(data)
           {
             jsonrpc: JSON_RPC_VERSION,
@@ -106,23 +101,23 @@ module Rasti
             }
           }
         end
-        
-        def handle_tools_list(data)
+
+        def handle_tools_list(data, tools_registry)
           {
             jsonrpc: JSON_RPC_VERSION,
             id: data['id'],
             result: {
-              tools: self.class.tools_serializations
+              tools: tools_registry.serializations
             }
           }
         end
-        
-        def handle_tool_call(data)
+
+        def handle_tool_call(data, tools_registry)
           tool_name = data['params']['name']
           arguments = data['params']['arguments'] || {}
 
-          result = self.class.call_tool tool_name, arguments
-          
+          result = tools_registry.call tool_name, arguments
+
           {
             jsonrpc: JSON_RPC_VERSION,
             id: data['id'],
@@ -138,7 +133,7 @@ module Rasti
         rescue => e
           error_response data['id'], JSON_RPC_INTERNAL_ERROR, e.message
         end
-        
+
         def error_response(id, code, message)
           {
             jsonrpc: JSON_RPC_VERSION,
@@ -153,4 +148,4 @@ module Rasti
       end
     end
   end
-end
+end

data/lib/rasti/ai/mcp/tools_registry.rb

@@ -0,0 +1,64 @@
+module Rasti
+  module AI
+    module MCP
+      class ToolsRegistry
+
+        Entry = Rasti::Model[:serialization, :executor]
+
+        def initialize
+          @entries = {}
+        end
+
+        def register(tool: nil, name: nil, description: nil, form: nil, input_schema: nil, &block)
+          resolved_name        = resolve_name tool, name
+          resolved_description = resolve_description tool, description
+          resolved_schema      = resolve_schema tool, form, input_schema
+          resolved_executor    = resolve_executor(tool, resolved_name, &block)
+
+          serialization = {name: resolved_name}
+          serialization[:description] = resolved_description if resolved_description
+          serialization[:inputSchema] = resolved_schema      if resolved_schema
+
+          entries[resolved_name] = Entry.new serialization: serialization, executor: resolved_executor
+        end
+
+        def serializations
+          entries.values.map(&:serialization)
+        end
+
+        def call(name, args={})
+          raise "Tool #{name} not found" unless entries.key? name
+          entries[name].executor.call args
+        end
+
+        private
+
+        attr_reader :entries
+
+        def resolve_name(tool, name)
+          return name if name
+          return ToolSerializer.serialize_name tool.class if tool
+          raise ArgumentError, 'name is required'
+        end
+
+        def resolve_description(tool, description)
+          return description if description
+          tool.class.description if tool && tool.class.respond_to?(:description)
+        end
+
+        def resolve_schema(tool, form, input_schema)
+          return input_schema if input_schema
+          return ToolSerializer.serialize_form form if form
+          ToolSerializer.serialize_form tool.class.form if tool && tool.class.respond_to?(:form)
+        end
+
+        def resolve_executor(tool, name, &block)
+          return block if block
+          return tool.method :call if tool
+          raise ArgumentError, "executor required: provide a tool or a block for '#{name}'"
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/open_ai/assistant.rb

@@ -33,10 +33,15 @@ module Rasti
             messages
           end
 
-          client.chat_completions messages: msgs,
-                                  model: model,
-                                  tools: serialized_tools,
-                                  response_format: response_format
+          client.chat_completions messages:         msgs,
+                                  model:            model,
+                                  tools:            serialized_tools,
+                                  response_format:  response_format,
+                                  reasoning_effort: thinking_config
+        end
+
+        def thinking_config
+          thinking
         end
 
         def parse_tool_calls(response)

data/lib/rasti/ai/open_ai/client.rb

@@ -3,7 +3,7 @@ module Rasti
     module OpenAI
       class Client < Rasti::AI::Client
 
-        def chat_completions(messages:, model:nil, tools:[], response_format:nil)
+        def chat_completions(messages:, model:nil, tools:[], response_format:nil, reasoning_effort:nil)
           body = {
             model: model || Rasti::AI.openai_default_model,
             messages: messages,
@@ -11,7 +11,8 @@ module Rasti
             tool_choice: tools.empty? ? 'none' : 'auto'
           }
 
-          body[:response_format] = response_format unless response_format.nil?
+          body[:response_format]   = response_format   unless response_format.nil?
+          body[:reasoning_effort]  = reasoning_effort  if reasoning_effort
 
           post '/chat/completions', body
         end

data/lib/rasti/ai/tool_serializer.rb

@@ -9,50 +9,47 @@ module Rasti
           }
 
           serialization[:description] = normalize_description(tool_class.description) if tool_class.respond_to? :description
-
           serialization[:inputSchema] = serialize_form(tool_class.form) if tool_class.respond_to? :form
 
           serialization
-          
+
         rescue => ex
           raise Errors::ToolSerializationError.new(tool_class), cause: ex
         end
 
-        private
-
         def serialize_name(tool_class)
           Inflecto.underscore Inflecto.demodulize(tool_class.name)
         end
 
         def serialize_form(form_class)
-          serialized_attributes = form_class.attributes.each_with_object({}) do |attribute, hash|
-            hash[attribute.name] = serialize_attribute attribute
-          end
+          json_schema_from_model_schema form_class.to_schema
+        end
 
-          serialization = {
-            type: 'object',
-            properties: serialized_attributes
-          }
+        private
 
-          required_attributes = form_class.attributes.select { |a| a.option(:required) }
+        def json_schema_from_model_schema(schema)
+          properties = schema[:attributes].each_with_object({}) do |attribute, hash|
+            hash[attribute[:name]] = json_schema_for_attribute(attribute)
+          end
 
-          serialization[:required] = required_attributes.map(&:name) unless required_attributes.empty?
+          result = {type: 'object', properties: properties}
 
-          serialization
+          required = schema[:attributes].select { |a| (a[:options] || {})[:required] }.map { |a| a[:name] }
+          result[:required] = required unless required.empty?
+
+          result
         end
 
-        def serialize_attribute(attribute)
+        def json_schema_for_attribute(attribute)
           serialization = {}
-          
-          if attribute.option(:description)
-            serialization[:description] = normalize_description attribute.option(:description)
-          end
-          
-          type_serialization = serialize_type attribute.type
-          serialization.merge! type_serialization
 
-          if attribute.type.is_a? Types::Enum
-            values = "#{type_serialization[:enum].join(', ')}"
+          description = (attribute[:options] || {})[:description]
+          serialization[:description] = normalize_description(description) if description
+
+          serialization.merge! json_schema_for_type(attribute)
+
+          if attribute[:type] == :enum
+            values = attribute[:values].join(', ')
             if serialization[:description]
               serialization[:description] += " (#{values})"
             else
@@ -63,50 +60,26 @@ module Rasti
           serialization
         end
 
-        def serialize_type(type)
-          if type == Types::String
-            {type: 'string'}
-
-          elsif type == Types::Integer
-            {type: 'integer'}
-
-          elsif type == Types::Float
-            {type: 'number'}
-
-          elsif type == Types::Boolean
-            {type: 'boolean'}
-
-          elsif type.is_a? Types::Time
-            {
-              type: 'string',
-              format: 'date'
-            }
-
-          elsif type.is_a? Types::Enum
-            {
-              type: 'string',
-              enum: type.values
-            }
-
-          elsif type.is_a? Types::Array
-            {
-              type: 'array',
-              items: serialize_type(type.type)
-            }
-
-          elsif type.is_a? Types::Model
-            serialize_form(type.model)
-
-          else
-            raise "Type not serializable #{type}"
+        def json_schema_for_type(type_hash)
+          case type_hash[:type]
+          when :string, :symbol then {type: 'string'}
+          when :integer         then {type: 'integer'}
+          when :float           then {type: 'number'}
+          when :boolean         then {type: 'boolean'}
+          when :time            then {type: 'string', format: 'date'}
+          when :enum            then {type: 'string', enum: type_hash[:values]}
+          when :array           then {type: 'array', items: json_schema_for_type(type_hash[:items])}
+          when :model           then json_schema_from_model_schema(type_hash[:schema])
+          when :hash            then {type: 'object'}
+          else                       {}
           end
         end
 
         def normalize_description(description)
           description.split("\n").map(&:strip).join(' ').strip
         end
-        
+
       end
     end
   end
-end
+end

data/lib/rasti/ai/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module AI
-    VERSION = '2.0.2'
+    VERSION = '3.0.0'
   end
 end

data/lib/rasti/ai.rb

@@ -14,6 +14,13 @@ module Rasti
     extend MultiRequire
     extend ClassConfig
 
+    require_relative 'ai/errors'
+    require_relative 'ai/usage'
+    require_relative 'ai/assistant_state'
+    require_relative 'ai/tool'
+    require_relative 'ai/tool_serializer'
+    require_relative 'ai/client'
+    require_relative 'ai/assistant'
     require_relative_pattern 'ai/**/*'
 
     attr_config :logger, Logger.new(STDOUT)
@@ -28,6 +35,9 @@ module Rasti
     attr_config :gemini_api_key, ENV['GEMINI_API_KEY']
     attr_config :gemini_default_model, ENV['GEMINI_DEFAULT_MODEL']
 
+    attr_config :anthropic_api_key, ENV['ANTHROPIC_API_KEY']
+    attr_config :anthropic_default_model, ENV['ANTHROPIC_DEFAULT_MODEL']
+
     attr_config :usage_tracker, nil
 
   end

data/rasti-ai.gemspec

@@ -13,6 +13,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/gabynaiman/rasti-ai'
   spec.license       = 'MIT'
 
+  spec.required_ruby_version = '>= 2.3'
+
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
@@ -25,12 +27,13 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'class_config', '~> 0.0'
 
   spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rack', '>= 1.3', '< 3'
   spec.add_development_dependency 'rack-test', '~> 2.0'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
   spec.add_development_dependency 'minitest-extended_assertions', '~> 1.0'
   spec.add_development_dependency 'simplecov', '~> 0.12'
-  spec.add_development_dependency 'pry-nav', '~> 0.2'
+  spec.add_development_dependency 'pry-nav', '>= 0.2'
   spec.add_development_dependency 'webmock', '~> 3.0'
 end