rails_mcp_engine 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53d474e90f159408325d95bf24d519e93a5f82b2b00258dc756300dd6ae04365
-  data.tar.gz: f38095e894a2ae6b3aba6744aadfaf529d8aa9029f7f1b0f0c4992516e2beb93
+  metadata.gz: f6c501b19758aada1c867684284621f255130d3d031aa39d4df44da9f3a79f93
+  data.tar.gz: e07a3da73bf2414648584e8a1eaa05b45e903d64151ec458dfd554c9ae15c0bd
 SHA512:
-  metadata.gz: 67040a2d30ec66489b8dd99f7d995f7f93e36f353e935384d8205b51d8d4103438f3ea83f8ead1397ef8afd0f54b823f76f513f3d5fe4613a0316de380d8b5a4
-  data.tar.gz: 75e1d06bb502e402beb4f8aa85c5ede2ab741017526cd7ed413130ab6c12edeb20a77ce3fdb7cccaf859103de82d24389d029a041271b90bf79fa8938835217b
+  metadata.gz: 6a4df6b3b995f865c86ed8d648d1629207ad9a603033f4b74ecbfff58c9913550b90588ae71952fbec505b3b4699e1c6247c4b310e7f777a60c3167c32aadb5b
+  data.tar.gz: 76372d4ad6346c20b65306dc277e7daba2921089fe808e721258b5b6ecb3bb72ba8d1caf16e57f7be728ad0e77a5131ad0b6cbe22d1adbf86dd2ec64a66ec345

data/README.md

@@ -99,6 +99,23 @@ Tools::MetaToolService.new.register_tool(
 
 These hooks are executed around the tool's entrypoint method for both RubyLLM and FastMCP wrappers.
 
+## Using Tools in Host Application
+
+You can easily fetch the generated RubyLLM tool classes for use in your host application (e.g., when calling an LLM API):
+
+```ruby
+# Fetch specific tool classes by name
+tool_classes = Tools::MetaToolService.ruby_llm_tools(['book_meeting', 'calculator'])
+
+# Use them with RubyLLM
+response = RubyLLM.chat(
+  messages: messages,
+  tools: tool_classes,
+  model: 'gpt-4o'
+)
+```
+
+
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rails test` to run the tests.

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,28 +44,19 @@ 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)
+    sig { params(tool_names: T::Array[String]).returns(T::Array[T.class_of(Object)]) }
+    def self.ruby_llm_tools(tool_names)
+      ToolMeta.registry.filter_map do |service_class|
+        schema = ToolSchema::Builder.build(service_class)
+        next unless tool_names.include?(schema[:name])
 
-      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}" }
+        tool_class_name = ToolSchema::RubyLlmFactory.tool_class_name(service_class)
+        Tools.const_get(tool_class_name) if Tools.const_defined?(tool_class_name)
+      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.1.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.1.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