mcpable 0.1.0

data/lib/mcpable/transports/official_mcp.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require "mcp"
+
+module Mcpable
+  module Transports
+    class OfficialMcp < Ports::Transport
+      DEFAULT_SERVER_NAME = "mcpable"
+
+      attr_reader :server_name, :server_version
+
+      def initialize(registry: nil, runtime: nil, profile: :default, config: nil,
+                     server_name: DEFAULT_SERVER_NAME, server_version: Mcpable::VERSION)
+        super(
+          registry: registry || Mcpable.registry,
+          runtime: runtime || Mcpable.runtime,
+          profile: profile
+        )
+        @config = config
+        @server_name = server_name
+        @server_version = server_version
+      end
+
+      def list_tools
+        build_tools({}).map(&:to_h)
+      end
+
+      def handle(raw_request, context: {})
+        server = build_server(context)
+
+        case raw_request
+        when String then server.handle_json(raw_request)
+        when Hash then server.handle(symbolize_deep(raw_request))
+        else raise ArgumentError, "unsupported request: #{raw_request.class}"
+        end
+      end
+
+      def serve_stdio(context: {})
+        MCP::Server::Transports::StdioTransport.new(build_server(context)).open
+      end
+
+      def build_server(context = {})
+        MCP::Server.new(
+          name: server_name,
+          version: server_version,
+          tools: build_tools(context)
+        )
+      end
+
+      private
+
+      def current_config
+        @config || runtime_config || Mcpable.config
+      end
+
+      def runtime_config
+        runtime.config if runtime.respond_to?(:config)
+      end
+
+      def definitions
+        registry.for_profile(profile)
+      end
+
+      def build_tools(context)
+        definitions.map { |definition| build_tool(definition, context) }
+      end
+
+      def build_tool(definition, context)
+        runtime = self.runtime
+        name = definition.name
+
+        MCP::Tool.define(
+          name: name,
+          description: definition.description,
+          input_schema: normalize_schema(current_config.schema_strategy.input_schema(definition)),
+          annotations: annotations_for(definition)
+        ) do |**args|
+          args.delete(:server_context)
+          OfficialMcp.to_mcp_response(runtime.call_tool(name, args: args, context: context))
+        end
+      end
+
+      def annotations_for(definition)
+        {
+          read_only_hint: definition.read_only?,
+          destructive_hint: definition.destructive?,
+          open_world_hint: definition.open_world?
+        }
+      end
+
+      def normalize_schema(schema)
+        JSON.parse(JSON.generate(schema))
+      end
+
+      def symbolize_deep(value)
+        case value
+        when Hash then value.to_h { |k, v| [k.to_sym, symbolize_deep(v)] }
+        when Array then value.map { |v| symbolize_deep(v) }
+        else value
+        end
+      end
+
+      def self.to_mcp_response(result)
+        if result.ok?
+          MCP::Tool::Response.new([{ type: "text", text: JSON.generate(result.payload) }])
+        else
+          MCP::Tool::Response.new(
+            [{ type: "text", text: "#{result.status}: #{result.error}" }],
+            error: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mcpable/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Mcpable
+  VERSION = "0.1.0"
+end

data/lib/mcpable.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "mcpable/version"
+
+module Mcpable
+  class Error < StandardError; end
+
+  class DuplicateToolError < Error
+    def initialize(name) = super("tool already registered: #{name}")
+  end
+
+  class UnknownToolError < Error
+    def initialize(name) = super("unknown tool: #{name}")
+  end
+
+  class MissingScopeError < Error
+    def initialize(name) = super("policy #{name} has no Scope class")
+  end
+end
+
+require "mcpable/naming"
+require "mcpable/argument"
+require "mcpable/definition"
+require "mcpable/result"
+require "mcpable/tool_call"
+require "mcpable/ports/source"
+require "mcpable/ports/schema_strategy"
+require "mcpable/ports/middleware"
+require "mcpable/ports/transport"
+require "mcpable/pipeline"
+require "mcpable/registry"
+require "mcpable/runtime"
+require "mcpable/schema_strategies/explicit_schema"
+require "mcpable/sources/enumerable_source"
+require "mcpable/dsl"
+require "mcpable/dsl/tool_builder"
+require "mcpable/dsl/resource_builder"
+require "mcpable/tool"
+require "mcpable/resource"
+
+module Mcpable
+  class Configuration
+    DEFAULT_ERROR_MAPPER = ->(_error) { Result.fail("internal error") }
+    DEFAULT_CONTEXT_BUILDER = ->(_env) { {} }
+
+    attr_reader :pipeline
+    attr_accessor :schema_strategy, :error_mapper, :context_builder
+
+    def initialize
+      @pipeline = Pipeline.new(config: self)
+      @schema_strategy = SchemaStrategies::ExplicitSchema.new
+      @error_mapper = DEFAULT_ERROR_MAPPER
+      @context_builder = DEFAULT_CONTEXT_BUILDER
+    end
+  end
+
+  class << self
+    def registry = @registry ||= Registry.new
+
+    def config = @config ||= Configuration.new
+
+    def configure
+      yield config
+      config
+    end
+
+    def runtime = @runtime ||= Runtime.new
+
+    def reset!
+      @registry = Registry.new
+      @config = Configuration.new
+      @runtime = Runtime.new
+      self
+    end
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: mcpable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Afshin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: Mcpable turns plain Ruby classes and Rails models into Model Context
+  Protocol tools through a declarative DSL, a middleware pipeline and pluggable source,
+  schema and transport ports.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- app/controllers/mcpable/rails/tools_controller.rb
+- lib/mcpable.rb
+- lib/mcpable/active_record.rb
+- lib/mcpable/active_record/column_inference.rb
+- lib/mcpable/active_record/source.rb
+- lib/mcpable/argument.rb
+- lib/mcpable/definition.rb
+- lib/mcpable/dsl.rb
+- lib/mcpable/dsl/resource_builder.rb
+- lib/mcpable/dsl/tool_builder.rb
+- lib/mcpable/naming.rb
+- lib/mcpable/pipeline.rb
+- lib/mcpable/ports/middleware.rb
+- lib/mcpable/ports/schema_strategy.rb
+- lib/mcpable/ports/source.rb
+- lib/mcpable/ports/transport.rb
+- lib/mcpable/pundit.rb
+- lib/mcpable/pundit/authorize.rb
+- lib/mcpable/rails.rb
+- lib/mcpable/rails/engine.rb
+- lib/mcpable/rails/loader.rb
+- lib/mcpable/registry.rb
+- lib/mcpable/resource.rb
+- lib/mcpable/result.rb
+- lib/mcpable/runtime.rb
+- lib/mcpable/schema_strategies/explicit_schema.rb
+- lib/mcpable/sources/enumerable_source.rb
+- lib/mcpable/tool.rb
+- lib/mcpable/tool_call.rb
+- lib/mcpable/transports/official_mcp.rb
+- lib/mcpable/version.rb
+homepage: https://github.com/afshmini/mcpable
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/afshmini/mcpable
+  bug_tracker_uri: https://github.com/afshmini/mcpable/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: Expose Ruby objects and Rails models as MCP tools.
+test_files: []