zeromcp 0.1.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbe9bf54912165bb33c8934830b2e743a9ac0b7248db1bff952c055ae98da075
-  data.tar.gz: 8507519d2addb779518363c2630032b3e89e72ea1ab4413c976c5d424928e0ec
+  metadata.gz: b2e5b203cdc7f03afff0cf6ce507e9480455b3f16e469222d5934af9351ffa9a
+  data.tar.gz: 8e968d22d810a2f25962eb5de0f242438f3ea4359c40cee4616398280695c6f8
 SHA512:
-  metadata.gz: e59df47759f27cd5f832b55ebd9139e7874732186ef188ef7eae2d2150284f0d055ec6c1beae462e09ad54b396b8fd82ff52a54c5680375fc9e9fd7384b520bd
-  data.tar.gz: 7958981ea82048324f9a5a81bb3ba9d483a9f5b0d9ae59877e150767af59712ac3aa2d99fa5c2a91a586957441661f99a2154e1c88f07458a85a731db583631f
+  metadata.gz: b5af7807f278f6430cd65fad75104d90536fbe5c840a2dfce3b7c125415940d65f4166e420f06b085c1ff6fe60c90a525773956e4e341c3b20098258227296a5
+  data.tar.gz: 3c0c7c8350efedaf3bf7ec4342e85f817b6da45e6668d6aace1553ef98edc478143db42acc4652b119a179c7b4580ddef29c54226457d03b3ed88d4582e6bd09

data/lib/zeromcp/config.rb

@@ -1,23 +1,36 @@
 # 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'] || {}
+      @cache_credentials = opts.key?(:cache_credentials) ? opts[:cache_credentials] : (opts.key?('cache_credentials') ? opts['cache_credentials'] : true)
       @namespacing = opts[:namespacing] || opts['namespacing'] || {}
+      @page_size = opts[:page_size] || opts['page_size'] || 0
+      @icon = opts[:icon] || opts['icon']
     end
 
-    attr_reader :credentials, :namespacing
+    attr_reader :credentials, :cache_credentials, :namespacing
 
     def self.load(path = nil)
       path ||= File.join(Dir.pwd, 'zeromcp.config.json')
@@ -29,5 +42,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,32 @@ 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
+      @credential_cache = {}
     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 +47,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 +87,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 +97,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 +148,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' => 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'] || {}) : {}
@@ -173,15 +442,22 @@ module ZeroMcp
 
     def _resolve_credentials(tool_name)
       return nil if @config.credentials.empty?
-      # Match credential namespace from tool name prefix
       @config.credentials.each do |ns, source|
         if tool_name.start_with?("#{ns}_") || tool_name.start_with?("#{ns}#{@config.separator}")
-          return _resolve_credential_source(source)
+          return _resolve_credentials_for_ns(ns.to_s, source)
         end
       end
       nil
     end
 
+    def _resolve_credentials_for_ns(ns, source)
+      return _resolve_credential_source(source) unless @config.cache_credentials
+      return @credential_cache[ns] if @credential_cache.key?(ns)
+      creds = _resolve_credential_source(source)
+      @credential_cache[ns] = creds
+      creds
+    end
+
     def _resolve_credential_source(source)
       source = source.transform_keys(&:to_s) if source.is_a?(Hash)
       if source['env']

data/zeromcp.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'zeromcp'
-  s.version     = '0.1.1'
+  s.version     = '0.2.2'
   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.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Antidrift
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-07 00:00:00.000000000 Z
+date: 2026-04-25 00:00:00.000000000 Z
 dependencies: []
 description: Drop tool files in a directory, get a working MCP server. Zero boilerplate.
 email: hello@probeo.io