zeromcp 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41b858d5fbd0613813087cb8ddb4af7f37ca0e14650dbd754937c8dd7450f5c6
-  data.tar.gz: 9a33ac859956b5dd640654a81e83c22be566216c415812e0d5f70444113ebe3f
+  metadata.gz: da354f1e655ec8a11fdab32fe614424855447046b47087bcfe06708f9a7fedcd
+  data.tar.gz: c6ec0cf498da41c890302f96fbfa337b23c081ec81185595e9c5a1926832f5a4
 SHA512:
-  metadata.gz: e0643b96c9e9c5e44bc67bf19bff9a564d947109a95ad1d1abf3d0d1d3a7fabc12e6333fca931096a84400b917a56c019aada8d7df18141adc03e2f44504e9c4
-  data.tar.gz: c980ba8e71e11bddfbfaa006ceda4a359c9fa5c05008781fa2876998bfe8f13bf0d7c34b4e23673fac6a5a2fc953043e45cebaa7ce2e2f5bbfc3313846454161
+  metadata.gz: a623e6e4be5051688e21f6b4d5d3633305b8ce8666778634348d0edc3e1012afe0633fdce2b3f9a22fce625d19a98fdfb2fb1592fd06743e1db1b8cfa6332096
+  data.tar.gz: 79182a97581d16e9f5c75607641326db7cb01abc28a6683aee36ae27f2f028324298674bd903a800678b21d0b726174b4e63ff48fd346987bc5f15cc7f599989

data/lib/zeromcp/config.rb

@@ -1,20 +1,32 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'base64'
 
 module ZeroMcp
   class Config
-    attr_reader :tools_dir, :separator, :logging, :bypass_permissions, :execute_timeout
+    attr_reader :tools_dir, :resources_dir, :prompts_dir,
+                :separator, :logging, :bypass_permissions, :execute_timeout,
+                :page_size, :icon
 
     def initialize(opts = {})
       tools = opts[:tools_dir] || opts['tools'] || './tools'
       @tools_dir = tools.is_a?(Array) ? tools : [tools]
+
+      resources = opts[:resources_dir] || opts['resources']
+      @resources_dir = resources ? (resources.is_a?(Array) ? resources : [resources]) : []
+
+      prompts = opts[:prompts_dir] || opts['prompts']
+      @prompts_dir = prompts ? (prompts.is_a?(Array) ? prompts : [prompts]) : []
+
       @separator = opts[:separator] || opts['separator'] || '_'
       @logging = opts[:logging] || opts['logging'] || false
       @bypass_permissions = opts[:bypass_permissions] || opts['bypass_permissions'] || false
       @execute_timeout = opts[:execute_timeout] || opts['execute_timeout'] || 30 # seconds
       @credentials = opts[:credentials] || opts['credentials'] || {}
       @namespacing = opts[:namespacing] || opts['namespacing'] || {}
+      @page_size = opts[:page_size] || opts['page_size'] || 0
+      @icon = opts[:icon] || opts['icon']
     end
 
     attr_reader :credentials, :namespacing
@@ -29,5 +41,36 @@ module ZeroMcp
     rescue JSON::ParserError
       new
     end
+
+    # Resolve an icon config value to a data URI. Supports:
+    # - data: URIs (returned as-is)
+    # - Local file paths (read and base64 encode)
+    # Returns nil on failure or if icon is not set.
+    def self.resolve_icon(icon)
+      return nil if icon.nil? || icon.empty?
+      return icon if icon.start_with?('data:')
+
+      # File path
+      path = File.expand_path(icon)
+      return nil unless File.exist?(path)
+
+      ext = File.extname(path).downcase
+      mime = ICON_MIME[ext] || 'image/png'
+      data = File.binread(path)
+      "data:#{mime};base64,#{Base64.strict_encode64(data)}"
+    rescue => e
+      $stderr.puts "[zeromcp] Warning: failed to read icon file #{icon}: #{e.message}"
+      nil
+    end
+
+    ICON_MIME = {
+      '.png'  => 'image/png',
+      '.jpg'  => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.gif'  => 'image/gif',
+      '.svg'  => 'image/svg+xml',
+      '.ico'  => 'image/x-icon',
+      '.webp' => 'image/webp'
+    }.freeze
   end
 end

data/lib/zeromcp/scanner.rb

@@ -118,4 +118,243 @@ module ZeroMcp
       @definition
     end
   end
+
+  # --- Resource scanning ---
+
+  MIME_MAP = {
+    '.json' => 'application/json',
+    '.txt'  => 'text/plain',
+    '.md'   => 'text/markdown',
+    '.html' => 'text/html',
+    '.xml'  => 'application/xml',
+    '.yaml' => 'text/yaml',
+    '.yml'  => 'text/yaml',
+    '.csv'  => 'text/csv',
+    '.css'  => 'text/css',
+    '.js'   => 'application/javascript',
+    '.ts'   => 'text/typescript',
+    '.sql'  => 'text/plain',
+    '.sh'   => 'text/plain',
+    '.py'   => 'text/plain',
+    '.go'   => 'text/plain',
+    '.rs'   => 'text/plain',
+    '.toml' => 'text/plain',
+    '.ini'  => 'text/plain',
+    '.env'  => 'text/plain'
+  }.freeze
+
+  class ResourceScanner
+    attr_reader :resources, :templates
+
+    def initialize(config)
+      @config = config
+      @resources = {}
+      @templates = {}
+    end
+
+    def scan
+      @resources.clear
+      @templates.clear
+
+      @config.resources_dir.each do |d|
+        dir = File.expand_path(d)
+        unless Dir.exist?(dir)
+          $stderr.puts "[zeromcp] Cannot read resources directory: #{dir}"
+          next
+        end
+        scan_dir(dir, dir)
+      end
+    end
+
+    private
+
+    def scan_dir(dir, root_dir)
+      Dir.entries(dir).sort.each do |entry|
+        next if entry.start_with?('.')
+
+        full_path = File.join(dir, entry)
+
+        if File.directory?(full_path)
+          scan_dir(full_path, root_dir)
+        elsif File.file?(full_path)
+          rel = Pathname.new(full_path).relative_path_from(Pathname.new(root_dir)).to_s
+          ext = File.extname(entry)
+          name = rel.sub(/\.[^.]+$/, '').gsub(%r{[\\/]}, @config.separator)
+
+          if ext == '.rb'
+            load_dynamic(full_path, name)
+          else
+            load_static(full_path, rel, name, ext)
+          end
+        end
+      end
+    end
+
+    def load_dynamic(file_path, name)
+      loader = ResourceLoader.new
+      loader.instance_eval(File.read(file_path), file_path)
+      defn = loader._definition
+      return unless defn && defn[:read]
+
+      if defn[:uri_template]
+        @templates[name] = {
+          uri_template: defn[:uri_template],
+          name: name,
+          description: defn[:description],
+          mime_type: defn[:mime_type] || 'application/json',
+          read: defn[:read]
+        }
+      else
+        uri = defn[:uri] || "resource:///#{name}"
+        @resources[name] = {
+          uri: uri,
+          name: name,
+          description: defn[:description],
+          mime_type: defn[:mime_type] || 'application/json',
+          read: defn[:read]
+        }
+      end
+
+      $stderr.puts "[zeromcp] Resource loaded: #{name}"
+    rescue => e
+      $stderr.puts "[zeromcp] Error loading resource #{file_path}: #{e.message}"
+    end
+
+    def load_static(file_path, rel_path, name, ext)
+      uri = "resource:///#{rel_path.gsub('\\', '/')}"
+      mime_type = MIME_MAP[ext] || 'application/octet-stream'
+
+      @resources[name] = {
+        uri: uri,
+        name: name,
+        description: "Static resource: #{rel_path}",
+        mime_type: mime_type,
+        read: -> { File.read(file_path, encoding: 'UTF-8') }
+      }
+    end
+  end
+
+  # DSL for dynamic resource .rb files
+  class ResourceLoader
+    def initialize
+      @definition = {}
+    end
+
+    def resource(description: nil, mime_type: nil, uri: nil, uri_template: nil)
+      @definition[:description] = description
+      @definition[:mime_type] = mime_type
+      @definition[:uri] = uri
+      @definition[:uri_template] = uri_template
+    end
+
+    def read(&block)
+      @definition[:read] = block
+    end
+
+    def _definition
+      return nil unless @definition[:read]
+      @definition
+    end
+  end
+
+  # --- Prompt scanning ---
+
+  class PromptScanner
+    attr_reader :prompts
+
+    def initialize(config)
+      @config = config
+      @prompts = {}
+    end
+
+    def scan
+      @prompts.clear
+
+      @config.prompts_dir.each do |d|
+        dir = File.expand_path(d)
+        unless Dir.exist?(dir)
+          $stderr.puts "[zeromcp] Cannot read prompts directory: #{dir}"
+          next
+        end
+        scan_dir(dir, dir)
+      end
+    end
+
+    private
+
+    def scan_dir(dir, root_dir)
+      Dir.entries(dir).sort.each do |entry|
+        next if entry.start_with?('.')
+
+        full_path = File.join(dir, entry)
+
+        if File.directory?(full_path)
+          scan_dir(full_path, root_dir)
+        elsif entry.end_with?('.rb')
+          rel = Pathname.new(full_path).relative_path_from(Pathname.new(root_dir)).to_s
+          name = rel.sub(/\.rb$/, '').gsub(%r{[\\/]}, @config.separator)
+          load_prompt(full_path, name)
+        end
+      end
+    end
+
+    def load_prompt(file_path, name)
+      loader = PromptLoader.new
+      loader.instance_eval(File.read(file_path), file_path)
+      defn = loader._definition
+      return unless defn && defn[:render]
+
+      # Convert arguments hash to MCP prompt arguments array
+      prompt_args = nil
+      if defn[:arguments] && !defn[:arguments].empty?
+        prompt_args = defn[:arguments].map do |key, val|
+          key = key.to_s
+          if val.is_a?(String)
+            { 'name' => key, 'required' => true }
+          elsif val.is_a?(Hash)
+            entry = { 'name' => key }
+            desc = val[:description] || val['description']
+            entry['description'] = desc if desc
+            optional = val[:optional] || val['optional']
+            entry['required'] = !optional
+            entry
+          else
+            { 'name' => key, 'required' => true }
+          end
+        end
+      end
+
+      @prompts[name] = {
+        name: name,
+        description: defn[:description],
+        arguments: prompt_args,
+        render: defn[:render]
+      }
+
+      $stderr.puts "[zeromcp] Prompt loaded: #{name}"
+    rescue => e
+      $stderr.puts "[zeromcp] Error loading prompt #{file_path}: #{e.message}"
+    end
+  end
+
+  # DSL for prompt .rb files
+  class PromptLoader
+    def initialize
+      @definition = {}
+    end
+
+    def prompt(description: nil, arguments: {})
+      @definition[:description] = description
+      @definition[:arguments] = arguments
+    end
+
+    def render(&block)
+      @definition[:render] = block
+    end
+
+    def _definition
+      return nil unless @definition[:render]
+      @definition
+    end
+  end
 end

data/lib/zeromcp/server.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'base64'
 require 'timeout'
 require_relative 'schema'
 require_relative 'config'
@@ -13,14 +14,31 @@ module ZeroMcp
     def initialize(config = nil)
       @config = config || Config.load
       @scanner = Scanner.new(@config)
+      @resource_scanner = ResourceScanner.new(@config)
+      @prompt_scanner = PromptScanner.new(@config)
       @tools = {}
+      @resources = {}
+      @templates = {}
+      @prompts = {}
+      @subscriptions = {}
+      @log_level = 'info'
+      @icon = nil
     end
 
-    # Load tools from the configured directories. Call this before using
-    # handle_request directly (serve calls this automatically).
+    # Load tools (and resources/prompts) from the configured directories.
+    # Call this before using handle_request directly (serve calls this
+    # automatically).
     def load_tools
       @tools = @scanner.scan
-      $stderr.puts "[zeromcp] #{@tools.size} tool(s) loaded"
+      @resource_scanner.scan
+      @resources = @resource_scanner.resources
+      @templates = @resource_scanner.templates
+      @prompt_scanner.scan
+      @prompts = @prompt_scanner.prompts
+      @icon = Config.resolve_icon(@config.icon)
+
+      resource_count = @resources.size + @templates.size
+      $stderr.puts "[zeromcp] #{@tools.size} tool(s), #{resource_count} resource(s), #{@prompts.size} prompt(s)"
     end
 
     def serve
@@ -28,8 +46,17 @@ module ZeroMcp
       $stderr.sync = true
       $stdin.set_encoding('UTF-8')
       $stdout.set_encoding('UTF-8')
+
       @tools = @scanner.scan
-      $stderr.puts "[zeromcp] #{@tools.size} tool(s) loaded"
+      @resource_scanner.scan
+      @resources = @resource_scanner.resources
+      @templates = @resource_scanner.templates
+      @prompt_scanner.scan
+      @prompts = @prompt_scanner.prompts
+      @icon = Config.resolve_icon(@config.icon)
+
+      resource_count = @resources.size + @templates.size
+      $stderr.puts "[zeromcp] #{@tools.size} tool(s), #{resource_count} resource(s), #{@prompts.size} prompt(s)"
       $stderr.puts "[zeromcp] stdio transport ready"
 
       $stdin.each_line do |line|
@@ -59,7 +86,7 @@ module ZeroMcp
     # Process a single JSON-RPC request hash and return a response hash.
     # Returns nil for notifications that require no response.
     #
-    # Note: tools must be loaded first via #serve or by calling scanner.scan
+    # Note: tools must be loaded first via #serve or by calling load_tools
     # manually if using this method directly for HTTP integration.
     #
     # Usage:
@@ -69,49 +96,47 @@ module ZeroMcp
       method = request['method']
       params = request['params'] || {}
 
-      # Notifications (no id) for known notification methods
-      if id.nil? && method == 'notifications/initialized'
+      # Notifications (no id)
+      if id.nil?
+        handle_notification(method, params)
         return nil
       end
 
       case method
       when 'initialize'
-        {
-          'jsonrpc' => '2.0',
-          'id' => id,
-          'result' => {
-            'protocolVersion' => '2024-11-05',
-            'capabilities' => {
-              'tools' => { 'listChanged' => true }
-            },
-            'serverInfo' => {
-              'name' => 'zeromcp',
-              'version' => '0.1.0'
-            }
-          }
-        }
+        handle_initialize(id, params)
+      when 'ping'
+        { 'jsonrpc' => '2.0', 'id' => id, 'result' => {} }
 
+      # Tools
       when 'tools/list'
-        {
-          'jsonrpc' => '2.0',
-          'id' => id,
-          'result' => {
-            'tools' => build_tool_list
-          }
-        }
-
+        handle_tools_list(id, params)
       when 'tools/call'
-        {
-          'jsonrpc' => '2.0',
-          'id' => id,
-          'result' => call_tool(params)
-        }
+        { 'jsonrpc' => '2.0', 'id' => id, 'result' => call_tool(params) }
 
-      when 'ping'
-        { 'jsonrpc' => '2.0', 'id' => id, 'result' => {} }
+      # Resources
+      when 'resources/list'
+        handle_resources_list(id, params)
+      when 'resources/read'
+        handle_resources_read(id, params)
+      when 'resources/subscribe'
+        handle_resources_subscribe(id, params)
+      when 'resources/templates/list'
+        handle_resources_templates_list(id, params)
+
+      # Prompts
+      when 'prompts/list'
+        handle_prompts_list(id, params)
+      when 'prompts/get'
+        handle_prompts_get(id, params)
+
+      # Passthrough
+      when 'logging/setLevel'
+        handle_logging_set_level(id, params)
+      when 'completion/complete'
+        handle_completion_complete(id, params)
 
       else
-        return nil if id.nil?
         {
           'jsonrpc' => '2.0',
           'id' => id,
@@ -122,16 +147,259 @@ module ZeroMcp
 
     private
 
-    def build_tool_list
-      @tools.map do |name, tool|
-        {
+    # --- Notifications ---
+
+    def handle_notification(method, params)
+      case method
+      when 'notifications/initialized'
+        # no-op
+      when 'notifications/roots/list_changed'
+        # store roots if provided
+        if params.is_a?(Hash) && params['roots'].is_a?(Array)
+          @roots = params['roots']
+        end
+      end
+    end
+
+    # --- Initialize ---
+
+    def handle_initialize(id, params)
+      capabilities = {
+        'tools' => { 'listChanged' => true }
+      }
+
+      if @resources.size > 0 || @templates.size > 0
+        capabilities['resources'] = { 'subscribe' => true, 'listChanged' => true }
+      end
+
+      if @prompts.size > 0
+        capabilities['prompts'] = { 'listChanged' => true }
+      end
+
+      capabilities['logging'] = {}
+
+      {
+        'jsonrpc' => '2.0',
+        'id' => id,
+        'result' => {
+          'protocolVersion' => '2024-11-05',
+          'capabilities' => capabilities,
+          'serverInfo' => {
+            'name' => 'zeromcp',
+            'version' => '0.2.0'
+          }
+        }
+      }
+    end
+
+    # --- Tools ---
+
+    def handle_tools_list(id, params)
+      list = @tools.map do |name, tool|
+        entry = {
           'name' => name,
           'description' => tool.description,
-          'inputSchema' => Schema.to_json_schema(tool.input)
+          'inputSchema' => tool.cached_schema
+        }
+        entry['icons'] = [{ 'uri' => @icon }] if @icon
+        entry
+      end
+
+      items, next_cursor = paginate(list, params['cursor'])
+      result = { 'tools' => items }
+      result['nextCursor'] = next_cursor if next_cursor
+      { 'jsonrpc' => '2.0', 'id' => id, 'result' => result }
+    end
+
+    # --- Resources ---
+
+    def handle_resources_list(id, params)
+      list = @resources.map do |_name, res|
+        entry = {
+          'uri' => res[:uri],
+          'name' => res[:name],
+          'description' => res[:description],
+          'mimeType' => res[:mime_type]
+        }
+        entry['icons'] = [{ 'uri' => @icon }] if @icon
+        entry
+      end
+
+      items, next_cursor = paginate(list, params['cursor'])
+      result = { 'resources' => items }
+      result['nextCursor'] = next_cursor if next_cursor
+      { 'jsonrpc' => '2.0', 'id' => id, 'result' => result }
+    end
+
+    def handle_resources_read(id, params)
+      uri = params.is_a?(Hash) ? params['uri'] : ''
+      uri ||= ''
+
+      # Check static/dynamic resources
+      @resources.each do |_name, res|
+        if res[:uri] == uri
+          begin
+            text = res[:read].call
+            return {
+              'jsonrpc' => '2.0',
+              'id' => id,
+              'result' => { 'contents' => [{ 'uri' => uri, 'mimeType' => res[:mime_type], 'text' => text }] }
+            }
+          rescue => e
+            return {
+              'jsonrpc' => '2.0',
+              'id' => id,
+              'error' => { 'code' => -32603, 'message' => "Error reading resource: #{e.message}" }
+            }
+          end
+        end
+      end
+
+      # Check templates
+      @templates.each do |_name, tmpl|
+        match = match_template(tmpl[:uri_template], uri)
+        if match
+          begin
+            text = tmpl[:read].call(match)
+            return {
+              'jsonrpc' => '2.0',
+              'id' => id,
+              'result' => { 'contents' => [{ 'uri' => uri, 'mimeType' => tmpl[:mime_type], 'text' => text }] }
+            }
+          rescue => e
+            return {
+              'jsonrpc' => '2.0',
+              'id' => id,
+              'error' => { 'code' => -32603, 'message' => "Error reading resource: #{e.message}" }
+            }
+          end
+        end
+      end
+
+      { 'jsonrpc' => '2.0', 'id' => id, 'error' => { 'code' => -32002, 'message' => "Resource not found: #{uri}" } }
+    end
+
+    def handle_resources_subscribe(id, params)
+      uri = params.is_a?(Hash) ? params['uri'] : nil
+      @subscriptions[uri] = true if uri
+      { 'jsonrpc' => '2.0', 'id' => id, 'result' => {} }
+    end
+
+    def handle_resources_templates_list(id, params)
+      list = @templates.map do |_name, tmpl|
+        entry = {
+          'uriTemplate' => tmpl[:uri_template],
+          'name' => tmpl[:name],
+          'description' => tmpl[:description],
+          'mimeType' => tmpl[:mime_type]
         }
+        entry['icons'] = [{ 'uri' => @icon }] if @icon
+        entry
       end
+
+      items, next_cursor = paginate(list, params['cursor'])
+      result = { 'resourceTemplates' => items }
+      result['nextCursor'] = next_cursor if next_cursor
+      { 'jsonrpc' => '2.0', 'id' => id, 'result' => result }
+    end
+
+    # --- Prompts ---
+
+    def handle_prompts_list(id, params)
+      list = @prompts.map do |_name, prompt|
+        entry = { 'name' => prompt[:name] }
+        entry['description'] = prompt[:description] if prompt[:description]
+        entry['arguments'] = prompt[:arguments] if prompt[:arguments]
+        entry['icons'] = [{ 'uri' => @icon }] if @icon
+        entry
+      end
+
+      items, next_cursor = paginate(list, params['cursor'])
+      result = { 'prompts' => items }
+      result['nextCursor'] = next_cursor if next_cursor
+      { 'jsonrpc' => '2.0', 'id' => id, 'result' => result }
     end
 
+    def handle_prompts_get(id, params)
+      name = params.is_a?(Hash) ? params['name'] : ''
+      args = params.is_a?(Hash) ? (params['arguments'] || {}) : {}
+
+      prompt = @prompts[name]
+      unless prompt
+        return {
+          'jsonrpc' => '2.0',
+          'id' => id,
+          'error' => { 'code' => -32002, 'message' => "Prompt not found: #{name}" }
+        }
+      end
+
+      begin
+        messages = prompt[:render].call(args)
+        { 'jsonrpc' => '2.0', 'id' => id, 'result' => { 'messages' => messages } }
+      rescue => e
+        { 'jsonrpc' => '2.0', 'id' => id, 'error' => { 'code' => -32603, 'message' => "Error rendering prompt: #{e.message}" } }
+      end
+    end
+
+    # --- Passthrough ---
+
+    def handle_logging_set_level(id, params)
+      level = params.is_a?(Hash) ? params['level'] : nil
+      @log_level = level if level
+      { 'jsonrpc' => '2.0', 'id' => id, 'result' => {} }
+    end
+
+    def handle_completion_complete(id, _params)
+      { 'jsonrpc' => '2.0', 'id' => id, 'result' => { 'completion' => { 'values' => [] } } }
+    end
+
+    # --- Pagination ---
+
+    def paginate(items, cursor)
+      page_size = @config.page_size
+      return [items, nil] if page_size <= 0
+
+      offset = cursor ? decode_cursor(cursor) : 0
+      slice = items[offset, page_size] || []
+      has_more = (offset + page_size) < items.size
+      next_cursor = has_more ? encode_cursor(offset + page_size) : nil
+      [slice, next_cursor]
+    end
+
+    def encode_cursor(offset)
+      Base64.strict_encode64(offset.to_s)
+    end
+
+    def decode_cursor(cursor)
+      decoded = Base64.decode64(cursor)
+      offset = decoded.to_i
+      offset < 0 ? 0 : offset
+    rescue
+      0
+    end
+
+    # --- Template matching ---
+
+    def match_template(template, uri)
+      # Convert {param} placeholders to named capture groups
+      param_names = []
+      regex_str = template.gsub(/\{(\w+)\}/) do
+        param_names << $1
+        '([^/]+)'
+      end
+
+      match = uri.match(/\A#{regex_str}\z/)
+      return nil unless match
+
+      result = {}
+      param_names.each_with_index do |name, i|
+        result[name] = match[i + 1]
+      end
+      result
+    end
+
+    # --- Tool execution ---
+
     def call_tool(params)
       name = params.is_a?(Hash) ? params['name'] : nil
       args = params.is_a?(Hash) ? (params['arguments'] || {}) : {}
@@ -145,8 +413,7 @@ module ZeroMcp
         }
       end
 
-      schema = Schema.to_json_schema(tool.input)
-      errors = Schema.validate(args, schema)
+      errors = Schema.validate(args, tool.cached_schema)
       if errors.any?
         return {
           'content' => [{ 'type' => 'text', 'text' => "Validation errors:\n#{errors.join("\n")}" }],

data/lib/zeromcp/tool.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'schema'
+
 module ZeroMcp
   class Tool
-    attr_reader :name, :description, :input, :permissions, :execute_block
+    attr_reader :name, :description, :input, :permissions, :execute_block, :cached_schema
 
     def initialize(name:, description: '', input: {}, permissions: {}, &block)
       @name = name
@@ -10,6 +12,7 @@ module ZeroMcp
       @input = input
       @permissions = permissions
       @execute_block = block
+      @cached_schema = Schema.to_json_schema(@input)
     end
 
     def call(args, ctx = {})

data/zeromcp.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'zeromcp'
-  s.version     = '0.1.0'
+  s.version     = '0.2.0'
   s.summary     = 'Zero-config MCP runtime'
   s.description = 'Drop tool files in a directory, get a working MCP server. Zero boilerplate.'
   s.authors     = ['Antidrift']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zeromcp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Antidrift
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-06 00:00:00.000000000 Z
+date: 2026-04-08 00:00:00.000000000 Z
 dependencies: []
 description: Drop tool files in a directory, get a working MCP server. Zero boilerplate.
 email: hello@probeo.io