ask-mcp 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 207c163681c8ee59bc9c869627cb6c053ca5e3824bb2e7eafd4669152c0a86cf
-  data.tar.gz: '029f07e479189995bb8b9aa7b4e09eb7e70308851789a4a9e05ab09a80e56568'
+  metadata.gz: b2b34899f61be9226b77f6e212d5756555c86e52e17ba301fcf3eaa24f1d3a62
+  data.tar.gz: 51656c01a274744d51bb328d11f0f9dc84ac6f20fbe7fa5bb0b90125e670a2d3
 SHA512:
-  metadata.gz: 823681d47e782fa73574987dfdb65f7a0ef53ff68d8dfb46d3537995d1bfa04a231bac6ec53b6b4fa03f7c34276ee6181d339644b821a391dffbcc9642a42303
-  data.tar.gz: 4118870bcb52e14efccb0d1fec411c01af5d68e5b62111a5c6818d952004f63a8198c35f7264997f7922a41a7418fb6851a31bd3a20e182ead6fbd685011ef8f
+  metadata.gz: baec4cee8a4bdd42174107b545e0c7a144dd7a646f64e37f3ed09d3f57826a417a1a801ec5f06fc8aed7119a9357c41f524549e62b5c0446e756ebbd5df0171c
+  data.tar.gz: dfaddecd4733e04fa5fbac5ee68ae95031cf4e3111a9db7237170ac7601f261ddb25f7f82eab41f478a2aa010aa9c31c92ca385b2b41d4e615cf628363e43578

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.6.0
+
+- `Auth::Connect`: the browser OAuth flow for MCP servers, as a reusable
+  class. Discovers the authorization server behind a protected resource
+  (RFC 9728) and its endpoints (RFC 8414 / OIDC), registers the client on
+  the spot when the server allows it, builds the authorization URL with
+  PKCE, and redeems the redirected code — or a refresh token — for tokens.
+  HTTP rides a small injected seam, so hosts can bring their own client.
+
+- **`Ask::MCP::RuntimeExecutor`** — bridges MCP clients into the
+  `Ask::Runtime::ToolExecutor` interface. Wraps an `Ask::MCP::Client`,
+  implements `#execute(tool_call, context:)`, normalizes MCP content/result
+  shapes (array, hash, string, nil) into `ToolResult.success` or `failure`,
+  honors context cancellation before calling the client, and emits
+  `ToolStarted` / `ToolCompleted` / `ToolFailed` / `ToolCancelled` lifecycle
+  events via `context.event_sink` with terminal snapshots.
+
+- **`Ask::MCP::ToolDiscovery`** module — helper for discovering MCP tools
+  from a client and wrapping them as `Adapters::AskTool` or
+  `Ask::Tools::Tool` instances.
+
 ## [0.5.0] - 2026-09-17
 
 ### Added

data/README.md

@@ -161,6 +161,8 @@ annotations are excluded from `tools/list` on HTTP transports.
 | `server.notify_*_list_changed` | Emit change notifications to clients |
 | `Ask::MCP::Adapters::AskTool.wrap(tools_hash)` | Adapter from MCP tools to `Ask::Tool` instances for ask-agent |
 | `Ask::MCP::Adapters::ToolServer` | Adapter from duck-typed tools to MCP server tools |
+| `Ask::MCP::RuntimeExecutor.new(client)` | Bridge MCP client into `Ask::Runtime::ToolExecutor` |
+| `Ask::MCP::ToolDiscovery` | Discover MCP tools and wrap them as `AskTool` adapters |
 | `Ask::MCP::Auth::Token.new(token)` | Token-based auth (`apply(headers)`) |
 | `Ask::MCP::Auth::OAuth.new(client_id:, ...)` | OAuth for MCP; `discover!` (OIDC), `authenticate!`, `validate_iss!`, `apply(headers)` |
 | `Ask::MCP::Auth::ClientIdMetadataDocument` | Build/validate Client ID Metadata Documents (2026-07-28 client registration) |
@@ -188,6 +190,32 @@ wrapped.each { |name, adapter| agent.register_tool(adapter.to_ask_tool) }
 
 Expose `Ask::Tool` subclasses as an MCP server with `Ask::MCP::Server.start_stdio(name:, tools:, capabilities: { tools: {} })`; the `ToolServer` adapter handles them.
 
+### With ask-runtime
+
+Bridge an MCP client into `Ask::Runtime` tool-call pipelines:
+
+```ruby
+require "ask/mcp"
+require "ask/runtime"
+
+client = Ask::MCP.from_stdio("npx", ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"])
+client.start
+
+executor = Ask::MCP::RuntimeExecutor.new(client)
+
+# Build a tool call and context
+call = Ask::Runtime::ToolCall.new(tool_name: "read_file", input: { path: "/tmp/test.txt" })
+ctx = Ask::Runtime::ExecutionContext.new(session_id: "s1", turn: 1)
+
+result = executor.execute(call, context: ctx)
+result.success?  # => true
+result.output    # => file contents
+
+# Discover and wrap tools for integration
+include Ask::MCP::ToolDiscovery
+tools = mcp_tools(client)   # => Hash{String => Adapters::AskTool}
+```
+
 ## Full documentation
 
 The full ask-rb documentation lives at https://ask-rb.github.io/ask-docs.

data/lib/ask/mcp/auth/connect.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "digest"
+require "uri"
+
+module Ask
+  module MCP
+    module Auth
+      # The browser dance that gives one person a credential for an MCP
+      # server: discover the authorization server behind the protected
+      # resource, register this client when the server allows it, hand the
+      # host a URL to send the browser to, and redeem the redirected code
+      # for tokens.
+      #
+      # Built for hosts that drive a real browser — a web action redirects
+      # to #authorization_url and its callback redeems the code — so the
+      # class keeps no browser state of its own. The caller carries the
+      # state and the PKCE verifier between the two steps, and persists
+      # #registered_client when dynamic registration produced one.
+      class Connect
+        class Error < StandardError; end
+
+        attr_reader :endpoint, :registered_client
+
+        def initialize(endpoint:, client_id: nil, client_secret: nil, http: Http)
+          @endpoint = endpoint
+          @client_id = client_id
+          @client_secret = client_secret
+          @http = http
+          @metadata = nil
+          @registered_client = nil
+        end
+
+        # The URL to send the browser to, with the PKCE verifier the caller
+        # must keep until the callback. The scope comes from the server's
+        # own advertised scopes unless the caller names one.
+        def authorization_url(redirect_uri:, state:, scope: nil, code_verifier: nil)
+          metadata = discover!
+          client = ensure_client!(redirect_uri)
+          verifier = code_verifier || self.class.generate_verifier
+
+          params = {
+            response_type: "code",
+            client_id: client[:client_id],
+            redirect_uri: redirect_uri,
+            state: state,
+            code_challenge: pkce_challenge(verifier),
+            code_challenge_method: "S256"
+          }
+          params[:scope] = scope || metadata[:scopes_supported]&.join(" ") || "mcp"
+
+          {url: "#{metadata[:authorization_endpoint]}?#{URI.encode_www_form(params)}", code_verifier: verifier}
+        end
+
+        # Redeem the redirected code. The same verifier the authorization
+        # step handed back comes along; the answer is the caller's token to
+        # store against whoever consented.
+        def exchange(code:, verifier:, redirect_uri:)
+          metadata = discover!
+          client = ensure_client!(redirect_uri)
+
+          params = {
+            grant_type: "authorization_code",
+            code: code,
+            redirect_uri: redirect_uri,
+            client_id: client[:client_id],
+            code_verifier: verifier
+          }
+          params[:client_secret] = client[:client_secret] if client[:client_secret]
+
+          token_response(@http.post_json(metadata[:token_endpoint], params))
+        end
+
+        # A fresh access token from the refresh token the server handed out.
+        def refresh(refresh_token:)
+          metadata = discover!
+          client = ensure_client!
+
+          params = {
+            grant_type: "refresh_token",
+            refresh_token: refresh_token,
+            client_id: client[:client_id]
+          }
+          params[:client_secret] = client[:client_secret] if client[:client_secret]
+
+          token_response(@http.post_json(metadata[:token_endpoint], params))
+        end
+
+        # Walk the chain MCP defines: the resource server names its
+        # authorization servers, and one of them names its endpoints. A
+        # server that publishes nothing is its own authorization server.
+        def discover!
+          return @metadata if @metadata
+
+          issuer = authorization_server_for(endpoint)
+          document = authorization_server_metadata(issuer)
+          unless document && document[:authorization_endpoint] && document[:token_endpoint]
+            raise Error, "no authorization server metadata at #{issuer}"
+          end
+
+          @metadata = {
+            issuer: issuer,
+            authorization_endpoint: document[:authorization_endpoint],
+            token_endpoint: document[:token_endpoint],
+            registration_endpoint: document[:registration_endpoint],
+            scopes_supported: document[:scopes_supported]
+          }
+        end
+
+        # The client this server knows us by: pre-registered credentials
+        # when the host has them, otherwise a registration the server
+        # created on the spot. The registered client is exposed for the
+        # host to persist — a registration that is remembered is one that
+        # is never asked for twice.
+        def ensure_client!(redirect_uri = nil)
+          return {client_id: @client_id, client_secret: @client_secret}.compact if @client_id
+
+          registration = @metadata && @metadata[:registration_endpoint]
+          raise Error, "no client credentials and #{endpoint} does not allow registration" unless registration
+          raise Error, "dynamic registration needs a redirect_uri" unless redirect_uri
+
+          @registered_client ||= begin
+            document = @http.post_json(registration, registration_params(redirect_uri))
+            {client_id: document[:client_id], client_secret: document[:client_secret]}.compact
+          end
+        end
+
+        def self.generate_verifier
+          Base64.urlsafe_encode64(SecureRandom.random_bytes(64)).delete("=")
+        end
+
+        def self.pkce_challenge(verifier)
+          Base64.urlsafe_encode64(Digest::SHA256.digest(verifier)).delete("=")
+        end
+
+        private
+
+        attr_reader :http
+
+        def registration_params(redirect_uri)
+          {
+            client_name: "Anychat",
+            redirect_uris: [redirect_uri],
+            grant_types: %w[authorization_code refresh_token],
+            response_types: %w[code],
+            token_endpoint_auth_method: "none",
+            application_type: "web"
+          }
+        end
+
+        def pkce_challenge(verifier)
+          self.class.pkce_challenge(verifier)
+        end
+
+        # RFC 9728: the resource server publishes its metadata under its own
+        # well-known path. The RFC allows the root form and a path-suffixed
+        # form; a server that publishes neither is treated as its own
+        # authorization server, which is how single-server setups behave.
+        def authorization_server_for(url)
+          uri = URI.parse(url.to_s)
+          candidates = [
+            well_known_uri(uri, "oauth-protected-resource"),
+            well_known_uri(uri, "oauth-protected-resource", suffix_path: uri.path)
+          ].compact
+
+          document = candidates.filter_map { |candidate| http.get_json(candidate) rescue nil }.first
+          servers = document && (document[:authorization_servers] || document["authorization_servers"])
+          Array(servers).first || "#{uri.scheme}://#{uri.host}#{uri.port == uri.default_port ? "" : ":#{uri.port}"}"
+        rescue URI::InvalidURIError
+          raise Error, "not a usable endpoint: #{endpoint.inspect}"
+        end
+
+        # RFC 8414 and OIDC discovery, same bargain: try the standard
+        # placements and take the first that answers.
+        def authorization_server_metadata(issuer)
+          issuer_uri = URI.parse(issuer.to_s)
+          [
+            well_known_uri(issuer_uri, "oauth-authorization-server"),
+            well_known_uri(issuer_uri, "oauth-authorization-server", suffix_path: issuer_uri.path),
+            well_known_uri(issuer_uri, "openid-configuration")
+          ].compact.filter_map { |candidate| http.get_json(candidate) rescue nil }.first
+        end
+
+        def well_known_uri(uri, name, suffix_path: nil)
+          path = suffix_path.to_s.sub(%r{/\z}, "")
+          base = "#{uri.scheme}://#{uri.host}#{uri.port == uri.default_port ? "" : ":#{uri.port}"}"
+          if path.empty?
+            "#{base}/.well-known/#{name}"
+          else
+            "#{base}/.well-known/#{name}#{path}"
+          end
+        end
+
+        def token_response(response)
+          unless response[:access_token]
+            raise Error, "token request did not return an access_token"
+          end
+
+          {
+            access_token: response[:access_token],
+            refresh_token: response[:refresh_token],
+            expires_at: response[:expires_in] ? Time.now + response[:expires_in].to_i : nil,
+            scope: response[:scope]
+          }
+        end
+
+        # A thin HTTP seam, so a host can bring its own client and tests can
+        # stay off the network. Form-encoded bodies, because that is what
+        # authorization servers speak at these endpoints.
+        module Http
+          module_function
+
+          def get_json(url)
+            require "httpx"
+
+            response = HTTPX.get(url)
+            return nil unless response.status == 200
+
+            JSON.parse(response.body.to_s, symbolize_names: true)
+          rescue JSON::ParserError
+            nil
+          end
+
+          def post_json(url, params)
+            require "httpx"
+
+            response = HTTPX.post(url, form: params)
+            unless response.status == 200 || response.status == 201
+              raise Error, "request to #{url} failed: #{response.status} #{response.body.to_s[0, 200]}"
+            end
+
+            JSON.parse(response.body.to_s, symbolize_names: true)
+          rescue JSON::ParserError
+            raise Error, "invalid JSON from #{url}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ask/mcp/runtime_executor.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "ask/runtime"
+
+module Ask
+  module MCP
+    # Bridges an MCP Client into the Ask::Runtime::ToolExecutor interface.
+    #
+    # Wraps an Ask::MCP::Client and implements the execute() contract so that
+    # MCP tools can participate in Ask::Runtime tool-call pipelines.
+    #
+    #   executor = Ask::MCP::RuntimeExecutor.new(client)
+    #   result = executor.execute(tool_call, context: ctx)
+    #
+    # Responsibilities:
+    # - Delegates to client.call_tool(tool_call.tool_name, tool_call.input)
+    # - Normalizes MCP content/result shapes into ToolResult.success or failure
+    # - Honors context cancellation before calling the client
+    # - Emits ToolStarted / ToolCompleted / ToolFailed / ToolCancelled events
+    #   via context.event_sink with terminal snapshots
+    #
+    # Error handling:
+    # - MCP isError responses → ToolResult.failure
+    # - Client exceptions (ProtocolError, ConnectionError) → ToolResult.failure
+    # - Malformed/empty results → ToolResult.success with nil output
+    #
+    class RuntimeExecutor
+      include Ask::Runtime::ToolExecutor
+
+      # @param client [Ask::MCP::Client] an initialized MCP client
+      def initialize(client)
+        @client = client
+      end
+
+      # @return [Ask::MCP::Client] the underlying MCP client
+      attr_reader :client
+
+      # Create a RuntimeExecutor from a client.
+      #
+      # @param client [Ask::MCP::Client] an initialized MCP client
+      # @return [RuntimeExecutor]
+      def self.from_client(client)
+        new(client)
+      end
+
+      # Execute a tool call via the MCP client.
+      #
+      # @param tool_call [Ask::Runtime::ToolCall] the tool-call request
+      # @param context [Ask::Runtime::ExecutionContext, nil] execution context
+      # @return [Ask::Runtime::ToolResult] normalized result
+      def execute(tool_call, context: nil)
+        context ||= Ask::Runtime::ExecutionContext.new
+
+        started_call = transition(tool_call, :running, started_at: Time.now)
+        emit_event(Ask::Runtime::Events::ToolStarted,
+                    tool_call: started_call, execution_context: context)
+
+        return cancel(tool_call, context, "Cancelled before execution") if context.cancelled?
+
+        result = call_tool(tool_call)
+        return cancel(tool_call, context, "Cancelled during execution") if context.cancelled?
+
+        finished_at = Time.now
+        duration = finished_at - started_call.started_at
+
+        terminal_call = started_call.with(
+          state: result.success? ? :completed : :failed,
+          tool_result: result,
+          finished_at: finished_at
+        )
+
+        event_class = result.success? ? Ask::Runtime::Events::ToolCompleted : Ask::Runtime::Events::ToolFailed
+        emit_event(event_class,
+                    tool_call: terminal_call, tool_result: result,
+                    execution_context: context, duration: duration)
+
+        result_with_duration(result, duration)
+      end
+
+      private
+
+      def call_tool(tool_call)
+        response = @client.call_tool(tool_call.tool_name, tool_call.input)
+        normalize_result(response)
+      rescue Ask::MCP::Error, Ask::MCP::ConnectionError => e
+        Ask::Runtime::ToolResult.failure(e.message)
+      rescue => e
+        Ask::Runtime::ToolResult.failure("#{e.class}: #{e.message}")
+      end
+
+      # Normalize MCP tools/call response shapes into a ToolResult.
+      #
+      # MCP responses are one of:
+      #   Array  — [{ type: "text", text: "..." }, ...]
+      #   Hash   — { content: [...], isError: bool, ... }
+      #   String — plain text (some servers)
+      #   nil    — empty response
+      def normalize_result(response)
+        error = error?(response)
+        output = extract_output(response)
+
+        if error
+          msg = extract_error_message(response) ||
+                (output.is_a?(String) ? output : nil) ||
+                "MCP tool error"
+          Ask::Runtime::ToolResult.failure(msg)
+        else
+          Ask::Runtime::ToolResult.success(data: output)
+        end
+      end
+
+      def extract_output(response)
+        case response
+        when Array
+          extract_from_content_array(response)
+        when Hash
+          if response[:content] || response["content"]
+            extract_from_content_array(response[:content] || response["content"])
+          else
+            response
+          end
+        when String
+          response
+        when nil
+          nil
+        else
+          response.to_s
+        end
+      end
+
+      def extract_from_content_array(array)
+        return nil if array.nil? || array.empty?
+
+        if array.length == 1
+          item = array.first
+          if item.is_a?(Hash) && (item[:text] || item["text"])
+            return item[:text] || item["text"]
+          end
+          return array
+        end
+
+        texts = array.filter_map do |item|
+          item.is_a?(Hash) ? (item[:text] || item["text"]) : item&.to_s
+        end
+        texts.length == array.length ? texts.join("\n") : array
+      end
+
+      def error?(response)
+        return false unless response.is_a?(Hash)
+
+        response[:isError] || response["isError"]
+      end
+
+      def extract_error_message(response)
+        return unless response.is_a?(Hash)
+
+        content = response[:content] || response["content"]
+        return unless content.is_a?(Array) && content.any?
+
+        first = content.first
+        first[:text] || first["text"] if first.is_a?(Hash)
+      end
+
+      def cancel(tool_call, context, reason)
+        result = Ask::Runtime::ToolResult.cancelled(reason)
+        terminal_call = tool_call.with(
+          state: :cancelled,
+          tool_result: result,
+          finished_at: Time.now
+        )
+        duration = terminal_call.finished_at - terminal_call.created_at
+
+        emit_event(Ask::Runtime::Events::ToolCancelled,
+                    tool_call: terminal_call, tool_result: result,
+                    execution_context: context, duration: duration)
+
+        result
+      end
+
+      def transition(tool_call, state, **attrs)
+        tool_call.with(state: state, **attrs)
+      end
+
+      def result_with_duration(result, duration)
+        return result if result.duration == duration
+
+        Ask::Runtime::ToolResult.new(
+          result: result.result,
+          outcome: result.outcome,
+          duration: duration
+        )
+      end
+
+      def emit_event(event_class, **args)
+        timestamp = Time.now
+        event = event_class.new(**args, timestamp: timestamp)
+        sink = args[:execution_context].event_sink
+        event_type = event_class.name.split("::").last
+                     .gsub(/([a-z])([A-Z])/, '\1_\2')
+                     .downcase
+                     .to_sym
+        sink.emit(event_type, event: event)
+      rescue => e
+        warn "[ask-mcp][runtime_executor] event emission failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/ask/mcp/tool_discovery.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    # Helpers for discovering MCP tools and exposing them as Ask::Tool wrappers.
+    #
+    #   include Ask::MCP::ToolDiscovery
+    #   tools = mcp_tools(client)  # => Hash{String => Adapters::AskTool}
+    #
+    module ToolDiscovery
+      # Discover tools from an MCP client and wrap them as AskTool adapters.
+      #
+      # @param client [Ask::MCP::Client] an initialized MCP client
+      # @return [Hash{String => Adapters::AskTool}] tools keyed by name
+      def mcp_tools(client)
+        tools = client.tools
+        Adapters::AskTool.wrap(tools)
+      end
+
+      # Discover tools and convert them to Ask::Tools::Tool instances.
+      #
+      # @param client [Ask::MCP::Client] an initialized MCP client
+      # @return [Hash{String => Ask::Tools::Tool}] tools keyed by name
+      def mcp_ask_tools(client)
+        mcp_tools(client).transform_values(&:to_ask_tool)
+      end
+    end
+  end
+end

data/lib/ask/mcp/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Ask
   module MCP
-    VERSION = "0.5.0"
+    VERSION = "0.6.1"
   end
 end

data/lib/ask/mcp.rb

@@ -24,6 +24,8 @@ module Ask
     autoload :Validator, "ask/mcp/validator"
     autoload :XMcpHeader, "ask/mcp/x_mcp_header"
     autoload :TraceContext, "ask/mcp/trace_context"
+    autoload :RuntimeExecutor, "ask/mcp/runtime_executor"
+    autoload :ToolDiscovery, "ask/mcp/tool_discovery"
 
     module Native
       autoload :Messages, "ask/mcp/native/messages"
@@ -37,6 +39,7 @@ module Ask
 
     module Auth
       autoload :OAuth, "ask/mcp/auth/oauth"
+      autoload :Connect, "ask/mcp/auth/connect"
       autoload :Token, "ask/mcp/auth/token"
       autoload :ClientIdMetadataDocument, "ask/mcp/auth/client_id_metadata_document"
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-mcp
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Kaka Ruto
@@ -93,6 +93,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: ask-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: ask-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 description: Connect to MCP servers via stdio, SSE, and Streamable HTTP transports.
   Run as an MCP server exposing any Ruby object as a tool. Discover tools, resources,
   and prompts. OAuth 2.1 authentication.
@@ -112,17 +140,20 @@ files:
 - lib/ask/mcp/adapters/ask_tool.rb
 - lib/ask/mcp/adapters/tool_server.rb
 - lib/ask/mcp/auth/client_id_metadata_document.rb
+- lib/ask/mcp/auth/connect.rb
 - lib/ask/mcp/auth/oauth.rb
 - lib/ask/mcp/auth/token.rb
 - lib/ask/mcp/client.rb
 - lib/ask/mcp/native/messages.rb
 - lib/ask/mcp/prompt.rb
 - lib/ask/mcp/resource.rb
+- lib/ask/mcp/runtime_executor.rb
 - lib/ask/mcp/server.rb
 - lib/ask/mcp/server/core.rb
 - lib/ask/mcp/server/http.rb
 - lib/ask/mcp/server/stdio.rb
 - lib/ask/mcp/tool.rb
+- lib/ask/mcp/tool_discovery.rb
 - lib/ask/mcp/trace_context.rb
 - lib/ask/mcp/transport/sse.rb
 - lib/ask/mcp/transport/stdio.rb