active_mcp 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33e83423b0e7e4bdf722b5473ec742e92efe3af946270f3fc1edf2ee9806c8d2
-  data.tar.gz: a9fe38a30a53fbdc4810b2c5d08884730f71cd4ace372188c69916f6db61742a
+  metadata.gz: 664064f2b6638585937706546194313e1b9beddcec7952bde94b34b39e39f851
+  data.tar.gz: d97d6e74d9a1235fa99f7362e0c38102069705b7c6ccb8f45d292ed6f45f08f3
 SHA512:
-  metadata.gz: b20d1f9baf3a7b48cab071135ca15fc182fb3d1cdc3570bcd0b0fb337906dd9e5fa0dc1f646823b281a9600911e3ef9ef7d5cf67eaab80a19a2cad27304f04bb
-  data.tar.gz: 5036f8e8b6056255e81b693cb5fc436d78bf04b8f0546c186110eb4774e6b7b7fe36d4e755c30e84884cadb75a4455af469fbe27d869b502a5ee5d0c79c9d167
+  metadata.gz: bd746883f2345681dafaf3ba99d1925c11eb8bf0a2ee2dc25fd17d4f1c3906b371f961a64298edc998cc58b6c1424a55efdfbbd0195c5e6e7a21dd160376821d
+  data.tar.gz: dd3ccaa91bd1f807d6f2ea7fc9dc03dc363b30b4bcad3335448f34d978c70f98d63b0ac4641455e9600639d2b88c94ca6c47cd945c8a82edecc5577b4ecbe65c

data/README.md

@@ -17,8 +17,6 @@ A Ruby on Rails engine for the [Model Context Protocol (MCP)](https://modelconte
   - [✨ Features](#-features)
   - [📦 Installation](#-installation)
   - [🚀 Setup](#-setup)
-    - [Using the Install Generator (Recommended)](#using-the-install-generator-recommended)
-    - [Manual Setup](#manual-setup)
   - [🔌 MCP Connection Methods](#-mcp-connection-methods)
     - [1. Direct HTTP Connection](#1-direct-http-connection)
     - [2. Standalone MCP Server](#2-standalone-mcp-server)
@@ -38,8 +36,6 @@ A Ruby on Rails engine for the [Model Context Protocol (MCP)](https://modelconte
     - [Resource Types](#resource-types)
   - [📦 MCP Resource Templates](#-mcp-resource-templates)
     - [Creating Resource Templates](#creating-resource-templates)
-  - [⚙️ Advanced Configuration](#️-advanced-configuration)
-    - [Custom Controller](#custom-controller)
   - [💡 Best Practices](#-best-practices)
     - [1. Create Specific Tool Classes](#1-create-specific-tool-classes)
     - [2. Validate and Sanitize Inputs](#2-validate-and-sanitize-inputs)
@@ -78,7 +74,7 @@ $ gem install active_mcp
 
 ## 🚀 Setup
 
-### Using the Install Generator (Recommended)
+1. Initialize
 
 The easiest way to set up Active MCP in your Rails application is to use the install generator:
 
@@ -86,46 +82,61 @@ The easiest way to set up Active MCP in your Rails application is to use the ins
 $ rails generate active_mcp:install
 ```
 
-This generator will:
+This generator will create a configuration initializer at `config/initializers/active_mcp.rb`
 
-1. Create a configuration initializer at `config/initializers/active_mcp.rb`
-2. Mount the ActiveMcp engine in your routes
-3. Create an MCP server script at `script/mcp_server.rb`
-4. Show instructions for next steps
+2. Create a tool by inheriting from `ActiveMcp::Tool::Base`:
 
-After running the generator, follow the displayed instructions to create and configure your MCP tools.
+```bash
+$ rails generate active_mcp:tool create_note
+```
 
-### Manual Setup
+```ruby
+class CreateNoteTool < ActiveMcp::Tool::Base
+  def name
+    "Create Note"
+  end
 
-If you prefer to set up manually:
+  def description
+    "Create Note"
+  end
 
-1. Mount the ActiveMcp engine in your `config/routes.rb`:
+  argument :title, :string, required: true
+  argument :content, :string, required: true
 
-```ruby
-Rails.application.routes.draw do
-  mount ActiveMcp::Engine, at: "/mcp"
+  def call(title:, content:, context:)
+    note = Note.create(title: title, content: content)
 
-  # Your other routes
+    "Created note with ID: #{note.id}"
+  end
 end
 ```
 
-2. Create a tool by inheriting from `ActiveMcp::Tool`:
+3. Create schema for your application:
 
 ```ruby
-class CreateNoteTool < ActiveMcp::Tool
-  description "Create Note"
-
-  argument :title, :string, required: true
-  argument :content, :string, required: true
+class MySchema < ActiveMcp::Schema::Base
+  tool CreateNoteTool.new
+end
+```
 
-  def call(title:, content:)
-    note = Note.create(title: title, content: content)
+4. Create controller ans set up routing:
 
-    "Created note with ID: #{note.id}"
+```ruby
+class MyMcpController < ActiveMcp::Controller::Base
+  def schema
+    MySchema.new(context:)
   end
 end
 ```
 
+```ruby
+Rails.application.routes.draw do
+  post "/mcp", to: "my_mcp#index"
+
+  # Your other routes
+end
+```
+
 ## 🔌 MCP Connection Methods
 
 Active MCP supports two connection methods:
@@ -184,7 +195,7 @@ Create new MCP tools quickly:
 $ rails generate active_mcp:tool search_users
 ```
 
-This creates a new tool file at `app/tools/search_users_tool.rb` with ready-to-customize starter code.
+This creates a new tool file at `app/mcp/tools/search_users_tool.rb` with ready-to-customize starter code.
 
 ### Resource Generator
 
@@ -194,21 +205,27 @@ Generate new MCP resources to share data with AI:
 $ rails generate active_mcp:resource profile_image
 ```
 
-This creates a new resource file at `app/resources/profile_image_resource.rb` that you can customize to provide various types of content to AI assistants.
+This creates a new resource file at `app/mcp/resources/profile_image_resource.rb` that you can customize to provide various types of content to AI assistants.
 
 ## 🧰 Creating MCP Tools
 
-MCP tools are Ruby classes that inherit from `ActiveMcp::Tool` and define an interface for AI to interact with your application:
+MCP tools are Ruby classes that inherit from `ActiveMcp::Tool::Base` and define an interface for AI to interact with your application:
 
 ```ruby
-class SearchUsersTool < ActiveMcp::Tool
-  description 'Search users by criteria'
+class SearchUsersTool < ActiveMcp::Tool::Base
+  def name
+    "Search Users"
+  end
+
+  def description
+    'Search users by criteria'
+  end
 
   argument :email, :string, required: false, description: 'Email to search for'
   argument :name, :string, required: false, description: 'Name to search for'
   argument :limit, :integer, required: false, description: 'Maximum number of records to return'
 
-  def call(email: nil, name: nil, limit: 10)
+  def call(email: nil, name: nil, limit: 10, context: {})
     criteria = {}
     criteria[:email] = email if email.present?
     criteria[:name] = name if name.present?
@@ -250,21 +267,27 @@ Supported types:
 Control access to tools by overriding the `visible?` class method:
 
 ```ruby
-class AdminOnlyTool < ActiveMcp::Tool
-  description "Admin-only tool"
+class AdminOnlyTool < ActiveMcp::Tool::Base
+  def name
+    "Admin-only tool"
+  end
+
+  def description
+    "Admin-only tool"
+  end
 
   argument :command, :string, required: true, description: "Admin command"
 
   # Only allow admins to access this tool
-  def self.visible?(auth_info)
-    return false unless auth_info
-    return false unless auth_info[:type] == :bearer
+  def visible?(context:)
+    return false unless context
+    return false unless context[:auth_info][:type] == :bearer
 
     # Check if the token belongs to an admin
-    auth_info[:token] == "admin-token" || User.find_by_token(auth_info[:token])&.admin?
+    context[:auth_info] == "admin-token" || User.find_by_token(context[:auth_info])&.admin?
   end
 
-  def call(command:, auth_info: nil)
+  def call(command:, context: {})
     # Tool implementation
   end
 end
@@ -289,14 +312,14 @@ server.start
 #### 2. Token Verification in Tools
 
 ```ruby
-def call(resource_id:, auth_info: nil, **args)
+def call(resource_id:, context: {})
   # Check if authentication is provided
-  unless auth_info.present?
+  unless context[:auth_info].present?
     raise "Authentication required"
   end
 
   # Verify the token
-  user = User.authenticate_with_token(auth_info[:token])
+  user = User.authenticate_with_token(context[:auth_info][:token])
 
   unless user
     raise "Invalid authentication token"
@@ -316,8 +339,8 @@ MCP Resources allow you to share data and files with AI assistants. Resources ha
 Resources are Ruby classes `**Resource`:
 
 ```ruby
-class UserResource
-  def initialize(id:, auth_info: nil)
+class UserResource < ActiveMcp::Resource::Base
+  def initialize(id:)
     @user = User.find(id)
     @auth_info = auth_info
   end
@@ -338,6 +361,10 @@ class UserResource
     @user.profile
   end
 
+  def visible?(context:)
+    # Your logic...
+  end
+
   def text
     # Return JSON data
     {
@@ -351,13 +378,9 @@ end
 ```
 
 ```ruby
-class McpController < ActiveMcp::BaseController
-  private
-
-  def resource_list
-    User.all.map do |user|
-      UserResource.new(id: user.id)
-    end
+class MySchema < ActiveMcp::Schema::Base
+  User.all.each do |user|
+    resource UserResource.new(id: user.id)
   end
 end
 ```
@@ -378,19 +401,21 @@ end
 2. **Binary Content** - Use the `blob` method to return binary files:
 
 ```ruby
-class ImageResource
+class ImageResource < ActiveMcp::Resource::Base
+  class << self
+    def mime_type
+      "image/png"
+    end
+  end
+
   def name
-    "image"
+    "Profile Image"
   end
 
   def uri
     "data://localhost/image"
   end
 
-  def mime_type
-    "image/png"
-  end
-
   def description
     "Profile image"
   end
@@ -405,12 +430,12 @@ end
 Resources can be protected using the same authorization mechanism as tools:
 
 ```ruby
-def visible?
-  return false unless auth_info
-  return false unless auth_info[:type] == :bearer
+def visible?(context: {})
+  return false unless context
+  return false unless context[:auth_info][:type] == :bearer
 
   # Check if the token belongs to an admin
-  User.find_by_token(auth_info[:token])&.admin?
+  User.find_by_token(context[:auth_info][:token])&.admin?
 end
 ```
 
@@ -423,54 +448,60 @@ MCP Resource Teamplates allow you to define template of resources.
 Resources are Ruby classes `**ResourceTemplates`:
 
 ```ruby
-class UserResourceTemplate
-  def name
-    "Users"
-  end
+class UserResource < ActiveMcp::Resource::Base
+  class << self
+    def name
+      "Users"
+    end
 
-  def uri_template
-    "data://localhost/users/{id}"
-  end
+    def uri_template
+      "data://localhost/users/{id}"
+    end
 
-  def mime_type
-    "application/json"
-  end
+    def mime_type
+      "application/json"
+    end
 
-  def description
-    "This is a test."
+    def description
+      "This is a test."
+    end
+
+    def visible?(context:)
+      # Your logic...
+    end
   end
-end
-```
 
-```ruby
-class McpController < ActiveMcp::BaseController
-  private
+  argument :id, ->(value) do
+    User.all.pluck(:id).filter { _1.match(value) }
+  end
 
-  def resource_templates_list
-    [
-      UserResourceTemplate.new
-    ]
+  def initialize(id:)
+    @user = User.find(id)
   end
-end
-```
 
-## ⚙️ Advanced Configuration
+  def name
+    @user.name
+  end
 
-### Custom Controller
+  def description
+    @user.profile
+  end
 
-Create a custom controller for advanced needs:
+  def uri
+    "data://localhost/users/#{@user.name}"
+  end
 
-```ruby
-class CustomMcpController < ActiveMcp::BaseController
-  # Custom MCP handling logic
+  def text
+    { name: @user.name }
+  end
 end
 ```
 
-Update routes:
-
 ```ruby
-Rails.application.routes.draw do
-  post "/mcp", to: "custom_mcp#index"
+class MySchema < ActiveMcp::Schema::Base
+  User.all.each do |user|
+    resource UserResource.new(id: user.id)
+  end
 end
 ```
 
@@ -482,12 +513,12 @@ Create dedicated tool classes for each model or operation instead of generic too
 
 ```ruby
 # ✅ GOOD: Specific tool for a single purpose
-class SearchUsersTool < ActiveMcp::Tool
+class SearchUsersTool < ActiveMcp::Tool::Base
   # ...specific implementation
 end
 
 # ❌ BAD: Generic tool that dynamically loads models
-class GenericSearchTool < ActiveMcp::Tool
+class GenericSearchTool < ActiveMcp::Tool::Base
   # Avoid this pattern - security and maintainability issues
 end
 ```
@@ -497,7 +528,7 @@ end
 Always validate and sanitize inputs in your tool implementations:
 
 ```ruby
-def call(user_id:, **args)
+def call(user_id:, **args, context: {})
   # Validate input
   unless user_id.is_a?(Integer) || user_id.to_s.match?(/^\d+$/)
     raise "Invalid user ID format"
@@ -514,7 +545,7 @@ end
 Return structured responses that are easy for AI to parse:
 
 ```ruby
-def call(query:, **args)
+def call(query:, context: {})
   results = User.search(query)
 
   {

data/app/controllers/active_mcp/base_controller.rb

@@ -1,9 +1,33 @@
 # frozen_string_literal: true
 
+require_relative "../concerns/active_mcp/authenticatable"
+require_relative "../concerns/active_mcp/request_handlable"
+require_relative "../concerns/active_mcp/resource_readable"
+require_relative "../concerns/active_mcp/tool_executable"
+
 module ActiveMcp
   class BaseController < ActionController::Base
-    include RequestHandlable
-    include ResourceReadable
-    include ToolExecutable
+    include ::ActiveMcp::RequestHandlable
+    include ::ActiveMcp::ResourceReadable
+    include ::ActiveMcp::ToolExecutable
+    include ::ActiveMcp::Authenticatable
+
+    protect_from_forgery with: :null_session
+    skip_before_action :verify_authenticity_token
+    before_action :authenticate, only: [:index]
+
+    def index
+      if json_rpc_request?
+        handle_mcp_client_request
+      else
+        handle_mcp_server_request
+      end
+    end
+
+    private
+
+    def schema
+      nil
+    end
   end
 end

data/app/controllers/concerns/active_mcp/authenticatable.rb

@@ -0,0 +1,29 @@
+module ActiveMcp
+  module Authenticatable
+    extend ActiveSupport::Concern
+
+    private
+
+    def authenticate
+      auth_header = request.headers["Authorization"]
+      if auth_header.present?
+        @context ||= {}
+        @context[:auth_info] = {
+          header: auth_header,
+          type: if auth_header.start_with?("Bearer ")
+                  :bearer
+                elsif auth_header.start_with?("Basic ")
+                  :basic
+                else
+                  :unknown
+                end,
+          token: auth_header.split(" ").last
+        }
+      end
+    end
+
+    def context
+      @context
+    end
+  end
+end

data/app/controllers/concerns/active_mcp/request_handlable.rb

@@ -4,20 +4,6 @@ module ActiveMcp
   module RequestHandlable
     extend ActiveSupport::Concern
 
-    included do
-      protect_from_forgery with: :null_session
-      skip_before_action :verify_authenticity_token
-      before_action :authenticate, only: [:index]
-    end
-
-    def index
-      if json_rpc_request?
-        handle_mcp_client_request
-      else
-        handle_mcp_server_request
-      end
-    end
-
     private
 
     def json_rpc_request?
@@ -26,7 +12,6 @@ module ActiveMcp
 
     def handle_mcp_client_request
       @id = params[:id]
-      @auth_info = auth_info
       
       case params[:method]
       when Method::INITIALIZE
@@ -36,25 +21,30 @@ module ActiveMcp
       when Method::CANCELLED
         render 'active_mcp/cancelled', formats: :json
       when Method::RESOURCES_LIST
-        @resources = resources_list
+        @resources = schema.resources
         @format = :jsonrpc
         render 'active_mcp/resources_list', formats: :json
       when Method::RESOURCES_TEMPLATES_LIST
-        @resource_templates = resource_templates_list
+        @resource_templates = schema.resource_templates
         @format = :jsonrpc
         render 'active_mcp/resource_templates_list', formats: :json
       when Method::RESOURCES_READ
-        @resource = read_resource(params:, auth_info:)
+        @resource = read_resource(params:, context:)
         @format = :jsonrpc
         render 'active_mcp/resources_read', formats: :json
       when Method::TOOLS_LIST
-        @tools = ActiveMcp::Tool.authorized_tools(auth_info)
+        @tools = schema.tools
         @format = :jsonrpc
         render 'active_mcp/tools_list', formats: :json
       when Method::TOOLS_CALL
-        @tool_result = execute_tool(params: params, auth_info: auth_info)
+        @tool_result = execute_tool(params:, context:)
         @format = :jsonrpc
         render 'active_mcp/tools_call', formats: :json
+      when Method::COMPLETION_COMPLETE
+        type = params.dig(:params, :ref, :type)
+        @completion = ActiveMcp::Completion.new.complete(params: params[:params], context:, refs: type === "ref/resource" ? schema.resource_templates : [])
+        @format = :jsonrpc
+        render "active_mcp/completion_complete", formats: :json
       else
         @format = :jsonrpc
         render 'active_mcp/no_method', formats: :json
@@ -62,54 +52,40 @@ module ActiveMcp
     end
 
     def handle_mcp_server_request
-      @auth_info = auth_info
-      
       case params[:method]
       when Method::RESOURCES_LIST
-        @resources = resources_list
+        @resources = schema.resources
         @format = :json
         render 'active_mcp/resources_list', formats: :json
       when Method::RESOURCES_READ
-        @resource = read_resource(params:, auth_info:)
+        @resource = read_resource(params:, context:)
         @format = :json
         render 'active_mcp/resources_read', formats: :json
       when Method::RESOURCES_TEMPLATES_LIST
-        @resource_templates = resource_templates_list
+        @resource_templates = schema.resource_templates
         @format = :json
         render 'active_mcp/resource_templates_list', formats: :json
       when Method::TOOLS_LIST
-        @tools = ActiveMcp::Tool.authorized_tools(auth_info)
+        @tools = schema.tools
         @format = :json
         render 'active_mcp/tools_list', formats: :json
       when Method::TOOLS_CALL
-        @tool_result = execute_tool(params: params, auth_info: auth_info)
+        @tool_result = execute_tool(params:, context:)
         @format = :json
         render 'active_mcp/tools_call', formats: :json
+      when Method::COMPLETION_COMPLETE
+        type = params.dig(:params, :ref, :type)
+        @completion = ActiveMcp::Completion.new.complete(params: params[:params], context:, refs: type == "ref/resource" ? schema.resource_templates : [])
+        @format = :json
+        render "active_mcp/completion_complete", formats: :json
       else
         @format = :json
         render 'active_mcp/no_method', formats: :json
       end
     end
 
-    def authenticate
-      auth_header = request.headers["Authorization"]
-      if auth_header.present?
-        @auth_info = {
-          header: auth_header,
-          type: if auth_header.start_with?("Bearer ")
-                  :bearer
-                elsif auth_header.start_with?("Basic ")
-                  :basic
-                else
-                  :unknown
-                end,
-          token: auth_header.split(" ").last
-        }
-      end
-    end
-
-    def auth_info
-      @auth_info
+    def context
+      @context ||= {}
     end
   end
 end

data/app/controllers/concerns/active_mcp/resource_readable.rb

@@ -4,15 +4,7 @@ module ActiveMcp
 
     private
 
-    def resource_templates_list
-      []
-    end
-
-    def resources_list
-      []
-    end
-
-    def read_resource(params:, auth_info:)
+    def read_resource(params:, context:)
       if params[:jsonrpc].present?
         uri = params[:params][:uri]
       else
@@ -26,7 +18,7 @@ module ActiveMcp
         }
       end
 
-      resource = resources_list.find do |r|
+      resource = schema.resources.find do |r|
         r.uri == uri
       end
 
@@ -37,7 +29,7 @@ module ActiveMcp
         }
       end
 
-      if resource.respond_to?(:visible?) && !resource.visible?
+      if resource.respond_to?(:visible?) && !resource.visible?(context:)
         return {
           isError: true,
           contents: []
@@ -50,7 +42,7 @@ module ActiveMcp
             contents: [
               {
                 uri:,
-                mimeType: resource.mime_type,
+                mimeType: resource.class.mime_type,
                 text: formatted(content)
               }
             ]
@@ -60,7 +52,7 @@ module ActiveMcp
             contents: [
               {
                 uri:,
-                mimeType: resource.mime_type,
+                mimeType: resource.class.mime_type,
                 blob: Base64.strict_encode64(content)
               }
             ]

data/app/controllers/concerns/active_mcp/tool_executable.rb

@@ -4,7 +4,7 @@ module ActiveMcp
 
     private
 
-    def execute_tool(params:, auth_info:)
+    def execute_tool(params:, context: {})
       if params[:jsonrpc].present?
         tool_name = params[:params][:name]
         tool_params = params[:params][:arguments]
@@ -25,11 +25,11 @@ module ActiveMcp
         }
       end
 
-      tool_class = Tool.registered_tools.find do |tc|
-        tc.tool_name == tool_name
+      tool = schema.tools.find do |tc|
+        tc.name == tool_name
       end
       
-      unless tool_class
+      unless tool
         return {
           isError: true,
           content: [
@@ -41,7 +41,7 @@ module ActiveMcp
         }
       end
       
-      unless tool_class.visible?(auth_info)
+      unless tool.visible?(context:)
         return {
           isError: true,
           content: [
@@ -69,7 +69,6 @@ module ActiveMcp
         end
       end
 
-      tool = tool_class.new
       validation_result = tool.validate_arguments(arguments)
 
       if validation_result.is_a?(Hash) && validation_result[:error]
@@ -86,13 +85,11 @@ module ActiveMcp
       
       # Execute the tool
       begin
-        arguments[:auth_info] = auth_info if auth_info.present?
-        
         return {
           content: [
             {
               type: "text",
-              text: formatted(tool.call(**arguments.symbolize_keys))
+              text: formatted(tool.call(**arguments, context:))
             }
           ]
         }

data/app/views/active_mcp/completion_complete.json.jbuilder

@@ -0,0 +1,16 @@
+json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
+json.id @id if @format == :jsonrpc && @id.present?
+
+if @format == :jsonrpc
+  json.result do
+    json.completion do
+      json.values @completion[:values]
+      json.total @completion[:total]
+    end
+  end
+else
+  json.result do
+    json.values @completion[:values]
+    json.total @completion[:total]
+  end
+end

data/app/views/active_mcp/resources_list.json.jbuilder

@@ -7,7 +7,7 @@ if @format == :jsonrpc
       json.array!(@resources) do |resource|
         json.name resource.name
         json.uri resource.uri
-        json.mimeType resource.mime_type
+        json.mimeType resource.class.mime_type
         json.description resource.description
       end
     end
@@ -17,7 +17,7 @@ else
     json.array!(@resources) do |resource|
       json.name resource.name
       json.uri resource.uri
-      json.mimeType resource.mime_type
+      json.mimeType resource.class.mime_type
       json.description resource.description
     end
   end

data/app/views/active_mcp/tools_list.json.jbuilder

@@ -3,8 +3,20 @@ json.id @id if @format == :jsonrpc && @id.present?
 
 if @format == :jsonrpc
   json.result do
-    json.tools @tools
+    json.tools do
+      json.array!(@tools) do |tool|
+        json.name tool.name
+        json.description tool.description
+        json.inputSchema tool.class.schema
+      end
+    end
   end
 else
-  json.result @tools
+  json.result do
+    json.array!(@tools) do |tool|
+      json.name tool.name
+      json.description tool.description
+      json.inputSchema tool.class.schema
+    end
+  end
 end

data/lib/active_mcp/completion.rb

@@ -0,0 +1,18 @@
+module ActiveMcp
+  class Completion
+    def complete(params: {}, context: {}, refs: [])
+      ref_name = params.dig(:ref, :name)
+      uri_template = params.dig(:ref, :uri)
+      arg_name = params.dig(:argument, :name)
+      value = params.dig(:argument, :value)
+
+      if uri_template
+        resource_class = refs.find { _1.uri_template == uri_template }
+        values = resource_class.arguments[arg_name.to_sym].call(value)
+        { values:, total: values.length }
+      elsif ref_name
+        { values: [], total: 0 }
+      end
+    end
+  end
+end

data/lib/active_mcp/controller/base.rb

@@ -0,0 +1,7 @@
+require_relative "../../../app/controllers/active_mcp/base_controller"
+
+module ActiveMcp
+  module Controller
+    Base = ActiveMcp::BaseController
+  end
+end

data/lib/active_mcp/engine.rb

@@ -2,20 +2,17 @@ module ActiveMcp
   class Engine < ::Rails::Engine
     isolate_namespace ActiveMcp
 
-    initializer "active_mcp.eager_load_tools" do |app|
-      tools_path = Rails.root.join("app", "tools")
-      if Dir.exist?(tools_path)
-        Dir[tools_path.join("*.rb")].sort.each do |file|
-          require_dependency file
-        end
-      end
-    end
-
-    initializer "active_mcp.eager_load_resources" do |app|
-      tools_path = Rails.root.join("app", "resources")
-      if Dir.exist?(tools_path)
-        Dir[tools_path.join("*.rb")].sort.each do |file|
-          require_dependency file
+    initializer "active_mcp.eager_load" do |app|
+      [
+        Rails.root.join("app", "mcp", "tools"),
+        Rails.root.join("app", "mcp", "resources"),
+        Rails.root.join("app", "mcp", "resource_templates"),
+        Rails.root.join("app", "mcp", "schemas")
+      ].each do |tools_path|
+        if Dir.exist?(tools_path)
+          Dir[tools_path.join("*.rb")].sort.each do |file|
+            require_dependency file
+          end
         end
       end
     end

data/lib/active_mcp/resource/base.rb

@@ -0,0 +1,29 @@
+require "json-schema"
+
+module ActiveMcp
+  module Resource
+    class Base
+      class << self
+        attr_reader :schema, :arguments
+
+        def argument(name, complete)
+          @arguments = {}
+          @arguments[name] = complete
+        end
+      end
+
+      def initialize
+      end
+
+      def name
+      end
+
+      def description
+      end
+
+      def visible?(context: {})
+        true
+      end
+    end
+  end
+end

data/lib/active_mcp/schema/base.rb

@@ -0,0 +1,46 @@
+module ActiveMcp
+  module Schema
+    class Base
+      class << self
+        attr_reader :resources, :resource_templates, :tools
+
+        def resource(klass)
+          @resources ||= []
+          @resources << klass
+
+          if klass.class.respond_to?(:uri_template)
+            @resource_templates ||= []
+            @resource_templates << klass.class unless klass.class.in?(@resource_templates)
+          end
+        end
+
+        def tool(klass)
+          @tools ||= []
+          @tools << klass
+        end
+      end
+
+      def initialize(context: {})
+        @context = context
+      end
+
+      def resources
+        self.class.resources.filter do |resource|
+          !resource.respond_to?(:visible?) || resource.visible?(context: @context)
+        end
+      end
+
+      def resource_templates
+        self.class.resource_templates.filter do |template|
+          !template.respond_to?(:visible?) || template.visible?(context: @context)
+        end
+      end
+
+      def tools
+        self.class.tools.filter do |tool|
+          !tool.respond_to?(:visible?) || tool.visible?(context: @context)
+        end
+      end
+    end
+  end
+end

data/lib/active_mcp/server/method.rb

@@ -11,5 +11,6 @@ module ActiveMcp
     RESOURCES_LIST = "resources/list"
     RESOURCES_READ = "resources/read"
     RESOURCES_TEMPLATES_LIST = "resources/templates/list"
+    COMPLETION_COMPLETE = "completion/complete"
   end
 end

data/lib/active_mcp/server/protocol_handler.rb

@@ -58,6 +58,8 @@ module ActiveMcp
           handle_call_tool(request)
         when Method::RESOURCES_READ
           handle_read_resource(request)
+        when Method::COMPLETION_COMPLETE
+          handle_complete(request)
         else
           error_response(request[:id], ErrorCode::METHOD_NOT_FOUND, "Unknown method: #{request[:method]}")
         end
@@ -194,6 +196,21 @@ module ActiveMcp
         end
       end
 
+      def handle_complete(request)
+        begin
+          result = @server.fetch(
+            params: {
+              method: Method::COMPLETION_COMPLETE,
+              params: request[:params],
+            }
+          )
+          success_response(request[:id], { completion: result[:result] })
+        rescue => e
+          Server.("Error reading resource #{uri}", e)
+          error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while reading the resource")
+        end
+      end
+
       def success_response(id, result)
         {
           jsonrpc: JSON_RPC_VERSION,

data/lib/active_mcp/tool/base.rb

@@ -0,0 +1,52 @@
+require "json-schema"
+
+module ActiveMcp
+  module Tool
+    class Base
+      class << self
+        attr_reader :schema
+
+        def argument(name, type, required: false, description: nil)
+          @schema ||= default_schema
+
+          @schema["properties"][name.to_s] = {"type" => type.to_s}
+          @schema["properties"][name.to_s]["description"] = description if description
+          @schema["required"] << name.to_s if required
+        end
+
+        def default_schema
+          {
+            "type" => "object",
+            "properties" => {},
+            "required" => []
+          }
+        end
+      end
+
+      def initialize
+      end
+
+      def name
+      end
+
+      def description
+      end
+
+      def visible?(context: {})
+        true
+      end
+
+      def call(context: {}, **args)
+        raise NotImplementedError, "#{self.class.name}#call must be implemented"
+      end
+
+      def validate_arguments(args)
+        return true unless self.class.schema
+
+        JSON::Validator.validate!(self.class.schema, args)
+      rescue JSON::Schema::ValidationError => e
+        {error: e.message}
+      end
+    end
+  end
+end

data/lib/active_mcp/version.rb

@@ -1,3 +1,3 @@
 module ActiveMcp
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end

data/lib/active_mcp.rb

@@ -3,11 +3,15 @@
 require "jbuilder"
 require_relative "active_mcp/version"
 require_relative "active_mcp/configuration"
-require_relative "active_mcp/tool"
+require_relative "active_mcp/schema/base"
+require_relative "active_mcp/tool/base"
+require_relative "active_mcp/resource/base"
 require_relative "active_mcp/server"
+require_relative "active_mcp/completion"
 
 if defined? ::Rails
   require_relative "active_mcp/engine"
+  require_relative "active_mcp/controller/base"
 end
 
 module ActiveMcp

data/lib/generators/active_mcp/install/install_generator.rb

@@ -2,16 +2,12 @@ module ActiveMcp
   module Generators
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path('templates', __dir__)
-      
-      desc "Creates an Active MCP initializer and mounts the engine in your routes"
-      
+
+      desc "Creates an Active MCP initializer"
+
       def create_initializer_file
         template "initializer.rb", "config/initializers/active_mcp.rb"
       end
-      
-      def update_routes
-        route "mount ActiveMcp::Engine, at: '/mcp'"
-      end
     end
   end
 end

data/lib/generators/active_mcp/resource/resource_generator.rb

@@ -4,7 +4,7 @@ module ActiveMcp
       source_root File.expand_path("templates", __dir__)
 
       def create_resource_file
-        template "resource.rb.erb", File.join("app/resources", "#{file_name}_resource.rb")
+        template "resource.rb.erb", File.join("app/mcp/resources", "#{file_name}_resource.rb")
       end
 
       private

data/lib/generators/active_mcp/resource/templates/resource.rb.erb

@@ -1,12 +1,4 @@
 class <%= class_name %>
-  def initialize(auth_info:)
-    @auth_info = auth_info
-
-    # Authentication information can be accessed via @auth_info parameter
-    # @auth_info = { type: :bearer, token: "xxx", header: "Bearer xxx" }
-    # or { type: :basic, token: "base64encoded", header: "Basic base64encoded" }
-  end
-
   def name
     "<%= file_name %>"
   end
@@ -25,16 +17,16 @@ class <%= class_name %>
 
   # Uncomment and modify this method to implement authorization control
   # This controls who can see and use this tool
-  # def visible?
+  # def visible?(context: {})
   #   # Example: require authentication
-  #   # return false unless @auth_info
+  #   # return false unless context
   #   
   #   # Example: require a specific authentication type
-  #   # return false unless @auth_info[:type] == :bearer
+  #   # return false unless context[:auth_info][:type] == :bearer
   #   
   #   # Example: check for admin permissions
   #   # admin_tokens = ["admin-token"]
-  #   # return admin_tokens.include?(@auth_info[:token])
+  #   # return admin_tokens.include?(context[:auth_info][:token])
   #   
   #   # Default: allow all access
   #   true

data/lib/generators/active_mcp/tool/templates/tool.rb.erb

@@ -1,5 +1,11 @@
-class <%= class_name %> < ActiveMcp::Tool
-  description "<%= file_name.humanize %>"
+class <%= class_name %> < ActiveMcp::Tool::Base
+  def name
+    "<%= file_name.humanize %>"
+  end
+
+  def description
+    "<%= file_name.humanize %>"
+  end
   
   argument :param1, :string, required: true, description: "First parameter description"
   argument :param2, :string, required: false, description: "Second parameter description"
@@ -7,25 +13,25 @@ class <%= class_name %> < ActiveMcp::Tool
   
   # Uncomment and modify this method to implement authorization control
   # This controls who can see and use this tool
-  # def self.visible?(auth_info)
+  # def visible?(context: {})
   #   # Example: require authentication
-  #   # return false unless auth_info
+  #   # return false unless context
   #   
   #   # Example: require a specific authentication type
-  #   # return false unless auth_info[:type] == :bearer
+  #   # return false unless context[:auth_info][:type] == :bearer
   #   
   #   # Example: check for admin permissions
   #   # admin_tokens = ["admin-token"]
-  #   # return admin_tokens.include?(auth_info[:token])
+  #   # return admin_tokens.include?(context[:auth_info][:token])
   #   
   #   # Default: allow all access
   #   true
   # end
   
-  def call(param1:, param2: nil, auth_info: nil, **args)
+  def call(param1:, param2: nil, context: {})
     # Authentication information can be accessed via _auth_info parameter
-    # auth_info = { type: :bearer, token: "xxx", header: "Bearer xxx" }
-    # or { type: :basic, token: "base64encoded", header: "Basic base64encoded" }
+    # context = { auth_info: { type: :bearer, token: "xxx", header: "Bearer xxx" } }
+    # or { auth_info: { type: :basic, token: "base64encoded", header: "Basic base64encoded" } }
 
     # Implement tool logic here
 

data/lib/generators/active_mcp/tool/tool_generator.rb

@@ -4,7 +4,7 @@ module ActiveMcp
       source_root File.expand_path("templates", __dir__)
 
       def create_tool_file
-        template "tool.rb.erb", File.join("app/tools", "#{file_name}_tool.rb")
+        template "tool.rb.erb", File.join("app/mcp/tools", "#{file_name}_tool.rb")
       end
 
       private

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_mcp
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Moeki Kawakami
 bindir: exe
 cert_chain: []
-date: 2025-04-07 00:00:00.000000000 Z
+date: 2025-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -68,10 +68,12 @@ files:
 - README.md
 - Rakefile
 - app/controllers/active_mcp/base_controller.rb
+- app/controllers/concerns/active_mcp/authenticatable.rb
 - app/controllers/concerns/active_mcp/request_handlable.rb
 - app/controllers/concerns/active_mcp/resource_readable.rb
 - app/controllers/concerns/active_mcp/tool_executable.rb
 - app/views/active_mcp/cancelled.json.jbuilder
+- app/views/active_mcp/completion_complete.json.jbuilder
 - app/views/active_mcp/initialize.json.jbuilder
 - app/views/active_mcp/initialized.json.jbuilder
 - app/views/active_mcp/no_method.json.jbuilder
@@ -82,15 +84,19 @@ files:
 - app/views/active_mcp/tools_list.json.jbuilder
 - config/routes.rb
 - lib/active_mcp.rb
+- lib/active_mcp/completion.rb
 - lib/active_mcp/configuration.rb
+- lib/active_mcp/controller/base.rb
 - lib/active_mcp/engine.rb
+- lib/active_mcp/resource/base.rb
+- lib/active_mcp/schema/base.rb
 - lib/active_mcp/server.rb
 - lib/active_mcp/server/error_codes.rb
 - lib/active_mcp/server/fetcher.rb
 - lib/active_mcp/server/method.rb
 - lib/active_mcp/server/protocol_handler.rb
 - lib/active_mcp/server/stdio_connection.rb
-- lib/active_mcp/tool.rb
+- lib/active_mcp/tool/base.rb
 - lib/active_mcp/version.rb
 - lib/generators/active_mcp/install/install_generator.rb
 - lib/generators/active_mcp/install/templates/initializer.rb

data/lib/active_mcp/tool.rb

@@ -1,82 +0,0 @@
-require "json-schema"
-
-module ActiveMcp
-  class Tool
-    class << self
-      attr_reader :desc, :schema
-
-      def tool_name
-        name ? name.underscore.sub(/_tool$/, "") : ""
-      end
-
-      def description(value)
-        @desc = value
-      end
-
-      def property(name, type, required: false, description: nil)
-        @schema ||= default_schema
-
-        @schema["properties"][name.to_s] = {"type" => type.to_s}
-        @schema["properties"][name.to_s]["description"] = description if description
-        @schema["required"] << name.to_s if required
-      end
-
-      def argument(...)
-        property(...)
-      end
-
-      def registered_tools
-        @registered_tools ||= []
-      end
-
-      attr_writer :registered_tools
-
-      def inherited(subclass)
-        registered_tools << subclass
-      end
-
-      def visible?(auth_info)
-        if respond_to?(:authorized?)
-          authorized?(auth_info)
-        else
-          true
-        end
-      end
-
-      def authorized_tools(auth_info = nil)
-        registered_tools.select do |tool_class|
-          tool_class.visible?(auth_info)
-        end.map do |tool_class|
-          {
-            name: tool_class.tool_name,
-            description: tool_class.desc,
-            inputSchema: tool_class.schema || default_schema
-          }
-        end
-      end
-
-      def default_schema
-        {
-          "type" => "object",
-          "properties" => {},
-          "required" => []
-        }
-      end
-    end
-
-    def initialize
-    end
-
-    def call(**args)
-      raise NotImplementedError, "#{self.class.name}#call must be implemented"
-    end
-
-    def validate_arguments(args)
-      return true unless self.class.schema
-
-      JSON::Validator.validate!(self.class.schema, args)
-    rescue JSON::Schema::ValidationError => e
-      {error: e.message}
-    end
-  end
-end