wip

Author: afstanton

.rubocop.yml

@@ -6,6 +6,9 @@ AllCops:
   TargetRubyVersion: 3.2
   NewCops: enable
 
+Lint/UnusedBlockArgument:
+  AllowUnusedKeywordArguments: true
+
 Lint/UnusedMethodArgument:
   AllowUnusedKeywordArguments: true
 

lib/tool_forge/tool_definition.rb

@@ -34,5 +34,59 @@ def param(name, type: :string, description: nil, required: true, default: nil)
     def execute(&block)
       @execute_block = block
     end
+
+    def to_ruby_llm_tool
+      raise LoadError, 'RubyLLM is not loaded. Please require "ruby_llm" first.' unless defined?(RubyLLM::Tool)
+      raise LoadError, 'RubyLLM is not loaded. Please require "ruby_llm" first.' if RubyLLM::Tool.nil?
+
+      definition = self
+
+      Class.new(RubyLLM::Tool) do
+        description definition.description
+
+        definition.params.each do |param_def|
+          param param_def[:name], type: param_def[:type], desc: param_def[:description]
+        end
+
+        define_method(:execute) do |**args|
+          definition.execute_block.call(**args)
+        end
+      end
+    end
+
+    def to_mcp_tool
+      raise LoadError, 'MCP SDK is not loaded. Please require "mcp" first.' unless defined?(MCP::Tool)
+      raise LoadError, 'MCP SDK is not loaded. Please require "mcp" first.' if MCP::Tool.nil?
+
+      definition = self
+
+      Class.new(MCP::Tool) do
+        description definition.description
+
+        # Build properties hash for input schema
+        properties = {}
+        required_params = []
+
+        definition.params.each do |param_def|
+          prop = {
+            type: param_def[:type].to_s
+          }
+          prop[:description] = param_def[:description] if param_def[:description]
+
+          properties[param_def[:name].to_s] = prop
+          required_params << param_def[:name].to_s if param_def[:required]
+        end
+
+        input_schema(
+          properties: properties,
+          required: required_params
+        )
+
+        define_singleton_method(:call) do |server_context:, **args|
+          result = definition.execute_block.call(**args)
+          MCP::Tool::Response.new([{ type: 'text', text: result.to_s }])
+        end
+      end
+    end
   end
 end

spec/tool_forge/tool_definition_to_mcp_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+# rubocop:disable RSpec/SpecFilePathFormat
+RSpec.describe ToolForge::ToolDefinition, '#to_mcp_tool' do
+  # rubocop:enable RSpec/SpecFilePathFormat
+  it 'raises an error if MCP::Tool is not loaded' do
+    tool = described_class.new(:my_tool) do
+      description 'A test tool'
+    end
+
+    # Stub to simulate MCP not being loaded
+    stub_const('MCP::Tool', nil)
+
+    expect { tool.to_mcp_tool }.to raise_error(LoadError, /MCP SDK is not loaded/)
+  end
+
+  it 'returns a class that inherits from MCP::Tool' do
+    tool = described_class.new(:my_tool) do
+      description 'A test tool'
+    end
+
+    tool_class = tool.to_mcp_tool
+    expect(tool_class).to be_a(Class)
+    expect(tool_class.ancestors).to include(MCP::Tool)
+  end
+
+  it 'sets the tool description' do
+    tool = described_class.new(:greeting_tool) do
+      description 'Greets a user'
+    end
+
+    tool_class = tool.to_mcp_tool
+
+    # MCP::Tool stores description at class level
+    expect(tool_class.description).to eq('Greets a user')
+  end
+
+  it 'defines input schema with parameters' do
+    tool = described_class.new(:my_tool) do
+      description 'A test tool'
+      param :name, type: :string, description: 'User name', required: true
+      param :age, type: :integer, description: 'User age', required: false
+    end
+
+    tool_class = tool.to_mcp_tool
+    schema = tool_class.input_schema.to_h
+
+    expect(schema[:properties]).to have_key('name')
+    expect(schema[:properties]['name'][:type]).to eq('string')
+    expect(schema[:properties]['name'][:description]).to eq('User name')
+
+    expect(schema[:properties]).to have_key('age')
+    expect(schema[:properties]['age'][:type]).to eq('integer')
+    expect(schema[:properties]['age'][:description]).to eq('User age')
+
+    expect(schema[:required]).to eq([:name])
+  end
+
+  it 'creates a call method that executes the block' do
+    tool = described_class.new(:greeting_tool) do
+      description 'Greets a user'
+      param :name, type: :string
+      execute { |name:| "Hello, #{name}!" }
+    end
+
+    tool_class = tool.to_mcp_tool
+
+    result = tool_class.call(server_context: nil, name: 'Alice')
+    expect(result).to be_a(MCP::Tool::Response)
+    expect(result.content.first[:text]).to eq('Hello, Alice!')
+  end
+
+  it 'handles tools with default values' do
+    tool = described_class.new(:greeting_tool) do
+      description 'Greets a user'
+      param :name, type: :string
+      param :greeting, type: :string, default: 'Hello'
+
+      execute do |name:, greeting: 'Hello'|
+        "#{greeting}, #{name}!"
+      end
+    end
+
+    tool_class = tool.to_mcp_tool
+
+    result1 = tool_class.call(server_context: nil, name: 'Bob')
+    expect(result1.content.first[:text]).to eq('Hello, Bob!')
+
+    result2 = tool_class.call(server_context: nil, name: 'Bob', greeting: 'Hi')
+    expect(result2.content.first[:text]).to eq('Hi, Bob!')
+  end
+
+  it 'handles tools with multiple parameter types' do
+    tool = described_class.new(:complex_tool) do
+      description 'A complex tool'
+      param :name, type: :string
+      param :count, type: :integer
+      param :active, type: :boolean
+
+      execute do |name:, count:, active:|
+        { name: name, count: count, active: active }.to_s
+      end
+    end
+
+    tool_class = tool.to_mcp_tool
+    schema = tool_class.input_schema.to_h
+
+    expect(schema[:properties]['name'][:type]).to eq('string')
+    expect(schema[:properties]['count'][:type]).to eq('integer')
+    expect(schema[:properties]['active'][:type]).to eq('boolean')
+
+    result = tool_class.call(server_context: nil, name: 'test', count: 5, active: true)
+    expect(result).to be_a(MCP::Tool::Response)
+  end
+
+  it 'converts type symbols to JSON schema types' do
+    tool = described_class.new(:type_test) do
+      description 'Tests type conversion'
+      param :str, type: :string
+      param :int, type: :integer
+      param :bool, type: :boolean
+      param :arr, type: :array
+      param :obj, type: :object
+    end
+
+    tool_class = tool.to_mcp_tool
+    schema = tool_class.input_schema.to_h
+
+    expect(schema[:properties]['str'][:type]).to eq('string')
+    expect(schema[:properties]['int'][:type]).to eq('integer')
+    expect(schema[:properties]['bool'][:type]).to eq('boolean')
+    expect(schema[:properties]['arr'][:type]).to eq('array')
+    expect(schema[:properties]['obj'][:type]).to eq('object')
+  end
+end

spec/tool_forge/tool_definition_to_ruby_llm_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'ruby_llm'
+
+# rubocop:disable RSpec/SpecFilePathFormat
+RSpec.describe ToolForge::ToolDefinition, '#to_ruby_llm_tool' do
+  # rubocop:enable RSpec/SpecFilePathFormat
+  it 'raises an error if RubyLLM::Tool is not loaded' do
+    tool = described_class.new(:my_tool) do
+      description 'A test tool'
+    end
+
+    # Stub to simulate RubyLLM not being loaded
+    stub_const('RubyLLM::Tool', nil)
+
+    expect { tool.to_ruby_llm_tool }.to raise_error(LoadError, /RubyLLM is not loaded/)
+  end
+
+  it 'returns a class that inherits from RubyLLM::Tool' do
+    tool = described_class.new(:my_tool) do
+      description 'A test tool'
+    end
+
+    tool_class = tool.to_ruby_llm_tool
+    expect(tool_class).to be_a(Class)
+    expect(tool_class.ancestors).to include(RubyLLM::Tool)
+  end
+
+  it 'sets the tool description' do
+    tool = described_class.new(:greeting_tool) do
+      description 'Greets a user'
+    end
+
+    tool_class = tool.to_ruby_llm_tool
+    instance = tool_class.new
+
+    expect(instance.class.description).to eq('Greets a user')
+  end
+
+  it 'creates an execute method that calls the block' do
+    tool = described_class.new(:greeting_tool) do
+      description 'Greets a user'
+      param :name, type: :string
+      execute { |name:| "Hello, #{name}!" }
+    end
+
+    tool_class = tool.to_ruby_llm_tool
+    instance = tool_class.new
+
+    result = instance.execute(name: 'Alice')
+    expect(result).to eq('Hello, Alice!')
+  end
+
+  it 'handles tools with default values' do
+    tool = described_class.new(:greeting_tool) do
+      description 'Greets a user'
+      param :name, type: :string
+      param :greeting, type: :string, default: 'Hello'
+
+      execute do |name:, greeting: 'Hello'|
+        "#{greeting}, #{name}!"
+      end
+    end
+
+    tool_class = tool.to_ruby_llm_tool
+    instance = tool_class.new
+
+    expect(instance.execute(name: 'Bob')).to eq('Hello, Bob!')
+    expect(instance.execute(name: 'Bob', greeting: 'Hi')).to eq('Hi, Bob!')
+  end
+
+  it 'handles tools with multiple parameter types' do
+    tool = described_class.new(:complex_tool) do
+      description 'A complex tool'
+      param :name, type: :string
+      param :count, type: :integer
+      param :active, type: :boolean
+      param :tags, type: :array
+      param :metadata, type: :object
+
+      execute do |name:, count:, active:, tags:, metadata:|
+        { name: name, count: count, active: active, tags: tags, metadata: metadata }
+      end
+    end
+
+    tool_class = tool.to_ruby_llm_tool
+    instance = tool_class.new
+
+    result = instance.execute(
+      name: 'test',
+      count: 5,
+      active: true,
+      tags: %w[a b],
+      metadata: { key: 'value' }
+    )
+
+    expect(result).to eq(
+      name: 'test',
+      count: 5,
+      active: true,
+      tags: %w[a b],
+      metadata: { key: 'value' }
+    )
+  end
+end