rails_mcp_engine 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46864199e9aea2b6d1e7b9b9c065109f3f70a012c35cc68a632a8fe39fd1ff06
-  data.tar.gz: a3cbbe5460b4c2d36e84a1d25fa3481e82ab678d1cd12dfef083819db352feb4
+  metadata.gz: f6c501b19758aada1c867684284621f255130d3d031aa39d4df44da9f3a79f93
+  data.tar.gz: e07a3da73bf2414648584e8a1eaa05b45e903d64151ec458dfd554c9ae15c0bd
 SHA512:
-  metadata.gz: a7f7134090f0de5dfb89878baf43ae74e6d5c0d9b9020744cdf4673f49e3daed9e0128e6d80c33d3e6fda0cd12af6b4e43e99307d6e44b817a88cf28e1952487
-  data.tar.gz: c7eb6c1be9166b14e06341b5ab10a097345fceb88790fceb432c20e09d0c3d707066f9d756e0e30aaa411e1f7d48d0d75f0e7b572ddc1d2cad897ec7987056c5
+  metadata.gz: 6a4df6b3b995f865c86ed8d648d1629207ad9a603033f4b74ecbfff58c9913550b90588ae71952fbec505b3b4699e1c6247c4b310e7f777a60c3167c32aadb5b
+  data.tar.gz: 76372d4ad6346c20b65306dc277e7daba2921089fe808e721258b5b6ecb3bb72ba8d1caf16e57f7be728ad0e77a5131ad0b6cbe22d1adbf86dd2ec64a66ec345

data/app/controllers/rails_mcp_engine/playground_controller.rb

@@ -50,7 +50,7 @@ module RailsMcpEngine
       result = if schema.nil?
                  { error: "Tool not found: #{tool_name}" }
                else
-                 delete_tool_from_registry(schema[:service_class])
+                 delete_tool_from_registry(tool_name)
                end
 
       flash[:register_result] = result
@@ -139,8 +139,9 @@ module RailsMcpEngine
       # The engine.rb defines ApplicationTool.
 
       # Re-using the logic from ManualController but adapting for Engine.
-      ::Tools::MetaToolService.new.register_tool(
+      ::Tools::MetaToolWriteService.new.register_tool(
         class_name,
+        source: source,
         before_call: ->(args) { Rails.logger.info("  [MCP] Request #{class_name}: #{args.inspect}") },
         after_call: ->(result) { Rails.logger.info("  [MCP] Response #{class_name}: #{result.inspect}") }
       )
@@ -168,14 +169,8 @@ module RailsMcpEngine
       { error: e.message }
     end
 
-    def delete_tool_from_registry(service_class)
-      ToolMeta.registry.delete(service_class)
-
-      # Also remove the RubyLLM tool class constant
-      tool_constant = ToolSchema::RubyLlmFactory.tool_class_name(service_class)
-      ::Tools.send(:remove_const, tool_constant) if ::Tools.const_defined?(tool_constant, false)
-
-      { success: 'Tool deleted successfully' }
+    def delete_tool_from_registry(tool_name)
+      ::Tools::MetaToolWriteService.new.delete_tool(tool_name)
     rescue StandardError => e
       { error: e.message }
     end

data/app/services/tools/meta_tool_service.rb

@@ -44,26 +44,7 @@ module Tools
       end
     end
 
-    sig { params(class_name: T.nilable(String), before_call: T.nilable(Proc), after_call: T.nilable(Proc)).returns(T::Hash[Symbol, T.untyped]) }
-    def register_tool(class_name, before_call: nil, after_call: nil)
-      return { error: 'class_name is required for register' } if class_name.nil? || class_name.empty?
 
-      service_class = constantize(class_name)
-      return { error: "Could not find #{class_name}" } if service_class.nil?
-      return { error: "#{class_name} must extend ToolMeta" } unless service_class.respond_to?(:tool_metadata)
-
-      ToolMeta.registry << service_class unless ToolMeta.registry.include?(service_class)
-
-      schema = ToolSchema::Builder.build(service_class)
-      ToolSchema::RubyLlmFactory.build(service_class, schema, before_call: before_call, after_call: after_call)
-      ToolSchema::FastMcpFactory.build(service_class, schema, before_call: before_call, after_call: after_call)
-
-      { status: 'registered', tool: summary_payload(schema) }
-    rescue ToolMeta::MissingSignatureError => e
-      { error: e.message }
-    rescue NameError => e
-      { error: "Could not find #{class_name}: #{e.message}" }
-    end
 
     sig { params(tool_names: T::Array[String]).returns(T::Array[T.class_of(Object)]) }
     def self.ruby_llm_tools(tool_names)
@@ -76,7 +57,6 @@ module Tools
       end
     end
 
-    private
 
     sig { params(query: T.nilable(String)).returns(T::Hash[Symbol, T.untyped]) }
     def search_tools(query)

data/app/services/tools/meta_tool_write_service.rb

@@ -0,0 +1,72 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'tool_meta'
+require 'tool_schema/builder'
+require 'tool_schema/ruby_llm_factory'
+require 'tool_schema/fast_mcp_factory'
+
+module Tools
+  class MetaToolWriteService
+    extend T::Sig
+
+    sig { params(class_name: T.nilable(String), source: T.nilable(String), before_call: T.nilable(Proc), after_call: T.nilable(Proc)).returns(T::Hash[Symbol, T.untyped]) }
+    def register_tool(class_name, source: nil, before_call: nil, after_call: nil)
+      return { error: 'class_name is required for register' } if class_name.nil? || class_name.empty?
+
+      # If source is provided, evaluate it first
+      if source
+        begin
+          Object.class_eval(source)
+        rescue StandardError => e
+          return { error: "Failed to evaluate source: #{e.message}" }
+        end
+      end
+
+      begin
+        service_class = meta_service.constantize(class_name)
+      rescue NameError
+        return { error: "Could not find #{class_name}" }
+      end
+      
+      return { error: "#{class_name} must extend ToolMeta" } unless service_class.respond_to?(:tool_metadata)
+
+      ToolMeta.registry << service_class unless ToolMeta.registry.include?(service_class)
+
+      schema = ToolSchema::Builder.build(service_class)
+      ToolSchema::RubyLlmFactory.build(service_class, schema, before_call: before_call, after_call: after_call)
+      ToolSchema::FastMcpFactory.build(service_class, schema, before_call: before_call, after_call: after_call)
+
+      { status: 'registered', tool: meta_service.summary_payload(schema) }
+    rescue ToolMeta::MissingSignatureError => e
+      { error: e.message }
+    rescue NameError => e
+      { error: "Could not find #{class_name}: #{e.message}" }
+    end
+
+    sig { params(tool_name: String).returns(T::Hash[Symbol, T.untyped]) }
+    def delete_tool(tool_name)
+      schema = meta_service.find_schema(tool_name)
+      return { error: "Tool not found: #{tool_name}" } unless schema
+
+      service_class = schema[:service_class]
+      ToolMeta.registry.delete(service_class)
+
+      tool_constant = ToolSchema::RubyLlmFactory.tool_class_name(service_class)
+      Tools.send(:remove_const, tool_constant) if Tools.const_defined?(tool_constant, false)
+      fast_mcp_constant = ToolSchema::FastMcpFactory.tool_class_name(service_class)
+      Mcp.send(:remove_const, fast_mcp_constant) if Mcp.const_defined?(fast_mcp_constant, false)
+
+      { success: 'Tool deleted successfully' }
+    rescue StandardError => e
+      { error: e.message }
+    end
+
+    private
+
+    def meta_service
+      @meta_service ||= Tools::MetaToolService.new
+    end
+  end
+end

data/lib/rails_mcp_engine/version.rb

@@ -1,3 +1,3 @@
 module RailsMcpEngine
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_mcp_engine
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Soonoh Jung
@@ -92,6 +92,7 @@ files:
 - app/lib/tool_schema/ruby_llm_factory.rb
 - app/lib/tool_schema/sorbet_type_mapper.rb
 - app/services/tools/meta_tool_service.rb
+- app/services/tools/meta_tool_write_service.rb
 - app/views/rails_mcp_engine/chat/show.html.erb
 - app/views/rails_mcp_engine/playground/show.html.erb
 - config/routes.rb