ask-mcp 0.4.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8719aff67887e47eec36f7e8b8b7c822261cbf6e1120380580747691c4d2ef2b
-  data.tar.gz: a5c2006a33be93158838aa8fc0f0ae69c8f3a1ec2aa07fd1478cf88c50f2aa62
+  metadata.gz: 207c163681c8ee59bc9c869627cb6c053ca5e3824bb2e7eafd4669152c0a86cf
+  data.tar.gz: '029f07e479189995bb8b9aa7b4e09eb7e70308851789a4a9e05ab09a80e56568'
 SHA512:
-  metadata.gz: d5a909234ffdc34be3ee993118ae8145b971f120516e7eef66be8c1bf95b5a9b18e767a366e0abca51f5fd1d573186e60496404afeebcc2d66cc3d371a907a74
-  data.tar.gz: 8c058d280dd5da3aac82fcebe7aacddb3a7c5e8861375e987835294d99cfd6f4f79e12589f47b53773397267fbf7992a44f9548321b65cc6d6a108175fe800af
+  metadata.gz: 823681d47e782fa73574987dfdb65f7a0ef53ff68d8dfb46d3537995d1bfa04a231bac6ec53b6b4fa03f7c34276ee6181d339644b821a391dffbcc9642a42303
+  data.tar.gz: 4118870bcb52e14efccb0d1fec411c01af5d68e5b62111a5c6818d952004f63a8198c35f7264997f7922a41a7418fb6851a31bd3a20e182ead6fbd685011ef8f

data/CHANGELOG.md

@@ -1,3 +1,72 @@
+## [0.5.0] - 2026-09-17
+
+### Added
+
+- **`Ask::MCP::Server::HTTP`, a Rack application serving MCP over the
+  stateless Streamable HTTP transport (2026-07-28)** — mount it wherever Rack
+  runs: `mount Ask::MCP::Server.rack_app(name: "anychat", tools: [...]) => "/mcp"`.
+  Every POST carries one JSON-RPC message and is answered with a single
+  `application/json` object; there are no sessions, no GET stream and no SSE
+  resumability, which is what the revision requires. The transport enforces
+  what the spec makes a server's job: `Origin` validation (403 for an origin
+  the host has not allowed), the required `MCP-Protocol-Version`, `Mcp-Method`
+  and `Mcp-Name` request headers validated against the body (400 with
+  `HeaderMismatch` -32020), the base64 sentinel form for header values that are
+  not plain ASCII, `UnsupportedProtocolVersionError` (-32022) listing the
+  versions it does support, 404 with -32601 for a method it does not implement,
+  202 for a notification, and 401 with `WWW-Authenticate` when `authenticate`
+  rejects a caller. `tools` may be a callable of the request context, which is
+  what lets a host expose a different tool set per caller.
+
+- **`Ask::MCP::Server::Core`, transport-agnostic message handling** — the
+  dispatch that used to live inside `Server::Stdio`, extracted so more than one
+  transport can share it. A Core turns one parsed message into the messages the
+  server wants to send and collects them in `#outbox`; `Stdio` overrides
+  `#deliver` to write to stdout as they are produced. Protocol state is
+  per-instance, so a stateless transport builds a Core per request.
+
+- **`serverInfo` in every stateless result's `_meta`** — servers SHOULD
+  identify themselves on each result so a client can attribute an answer
+  without a separate discovery round trip.
+
+### Changed
+
+- **`Ask::MCP::Server::Stdio` is now a thin subclass of `Core`** — the read
+  loop, the stdout writer and the `notify_*` methods remain. Wire behaviour is
+  unchanged; the init gate is now stated once instead of on each gated method.
+
+- **The client negotiates stateless servers correctly** — `server/discover` is
+  now sent as a *modern* request, carrying `MCP-Protocol-Version` and `_meta`,
+  because a compliant 2026-07-28 server refuses anything else. A version the
+  server does not implement comes back as `UnsupportedProtocolVersionError`;
+  the client retries once with the best version the server advertises instead
+  of falling back to the `initialize` handshake the revision removed.
+
+- **A JSON-RPC error on a non-200 response is delivered as a response, not
+  raised as a transport failure** — the spec has servers carry errors on 400
+  (header mismatch, unsupported version) and 404 (unknown method), so
+  `Transport::StreamableHTTP` surfaces those to the message handlers where the
+  pending request can pick them up. `ConnectionError` is reserved for responses
+  that are not JSON-RPC at all.
+
+### Fixed
+
+- **A server rejection now echoes the request id** — request-level errors
+  (header mismatch, unsupported version) carry the id of the request that
+  caused them, so a client can correlate a failure with what it sent. Errors
+  raised before the body is understood, and the 403 for an untrusted `Origin`,
+  carry no id, which the spec allows.
+
+- **A base64 `Mcp-Name` decodes as UTF-8** — base64 carries bytes and knows
+  nothing of encodings, so a decoded name was compared as ASCII-8BIT and never
+  matched the UTF-8 value in the body. The spec defines the payload as the
+  UTF-8 representation, so the decoded string is tagged as such.
+
+- **A stateless request naming an unspoken revision is refused** — version
+  mismatches are answered with `UnsupportedProtocolVersionError` (-32022) and
+  the list of versions the server does speak, replacing the generic
+  "not initialized" the legacy gate would have produced.
+
 ## [0.4.5] - 2026-08-12
 
 ### Added

data/lib/ask/mcp/client.rb

@@ -161,8 +161,23 @@ module Ask
         @transport.protocol_version = @protocol_version if @transport.respond_to?(:protocol_version=)
       end
 
+      # Probe the server as a *modern* request. A compliant 2026-07-28 server
+      # requires MCP-Protocol-Version and `_meta` on every request and refuses
+      # anything else, so the probe has to name a version before negotiation
+      # has happened. A version the server does not implement comes back as an
+      # UnsupportedProtocolVersionError naming the ones it does; retry once
+      # with the best of those. Answers false for a server that is not modern,
+      # which is the caller's cue to fall back to `initialize`.
       def discover_server
-        response = send_request_raw("server/discover", {}, timeout: 5)
+        response = probe_discover(Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS.last)
+
+        if unsupported_version?(response)
+          chosen = advertised_protocol_version(response)
+          return false unless chosen
+
+          response = probe_discover(chosen)
+        end
+
         return false unless response.success?
 
         result = response.result
@@ -179,15 +194,43 @@ module Ask
         false
       end
 
+      def probe_discover(version)
+        @transport.protocol_version = version if @transport.respond_to?(:protocol_version=)
+        request = Native::Messages::Request.new(
+          method: "server/discover", params: meta_params(version), id: next_id
+        )
+        wait_for_response(request, timeout: 5)
+      end
+
+      def unsupported_version?(response)
+        return false if response.success?
+
+        error_of(response)[:code] == Native::Messages::ErrorCodes::UNSUPPORTED_PROTOCOL_VERSION
+      end
+
+      def advertised_protocol_version(response)
+        data = error_of(response)[:data]
+        supported = Array(data[:supported] || data["supported"])
+        Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS.reverse.find { |version| supported.include?(version) }
+      end
+
+      def error_of(response)
+        error = response.error
+        { code: error[:code] || error["code"], data: error[:data] || error["data"] || {} }
+      end
+
       def reset_caches
         @tools_cache = nil
         @resources_cache = nil
         @prompts_cache = nil
       end
 
-      def meta_params
+      # The `_meta` envelope every stateless request carries. `version` is
+      # overridable so the discover probe can name a version before any
+      # negotiation has happened.
+      def meta_params(version = @protocol_version)
         meta = {
-          Native::Messages::Meta::PROTOCOL_VERSION_KEY => @protocol_version,
+          Native::Messages::Meta::PROTOCOL_VERSION_KEY => version,
           Native::Messages::Meta::CLIENT_CAPABILITIES_KEY => @options[:client_capabilities] || {},
           Native::Messages::Meta::CLIENT_INFO_KEY => { name: "ask-mcp", version: Ask::MCP::VERSION }
         }

data/lib/ask/mcp/server/core.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+require "json"
+require "timeout"
+
+module Ask
+  module MCP
+    class Server
+      # Transport-agnostic MCP request processing.
+      #
+      # A Core owns one server's tools, resources and prompts and turns a
+      # single parsed JSON-RPC message into the messages the server wants to
+      # send back. Transports differ only in how those messages reach the
+      # client: Stdio writes each one to $stdout as it is produced, the HTTP
+      # transport collects them in #outbox and renders a response.
+      #
+      # Negotiated protocol state (`@protocol_version`) lives on the instance,
+      # so a stateless transport builds a Core per request rather than sharing
+      # one across callers.
+      class Core
+        MAX_RESULT_CACHE = 100
+
+        attr_reader :name, :tools, :capabilities, :resources, :prompts,
+                    :resource_templates, :outbox
+
+        # The protocol version a request declares in params `_meta`, or nil for
+        # a legacy request that expects an `initialize` handshake. Handles both
+        # symbol and string key forms (the JSON parser symbolizes all keys).
+        def self.declared_protocol_version(params)
+          meta = params[:meta] || params[:_meta] || {}
+          key = Native::Messages::Meta::PROTOCOL_VERSION_KEY
+          meta[key] || meta[key.to_sym] || meta[key.to_s]
+        end
+
+        def initialize(name:, version: nil, tools: [], capabilities: { tools: {} },
+                       resources: {}, prompts: {}, resource_templates: {},
+                       debug: false, tool_timeout: nil, cache_ttl_ms: 60_000,
+                       cache_scope: "private")
+          @name = name
+          @server_version = version || Ask::MCP::VERSION
+          @tools = tools || []
+          @capabilities = capabilities
+          @resources = resources
+          @prompts = prompts
+          @resource_templates = resource_templates
+          @debug = debug
+          @tool_timeout = tool_timeout
+          @cache_ttl_ms = cache_ttl_ms
+          @cache_scope = cache_scope
+
+          @adapter = Adapters::ToolServer.new(@tools)
+          @outbox = []
+          @initialized = false
+          @result_cache = {}
+          # Negotiated protocol version. nil until the client tells us which
+          # revision it speaks (legacy `initialize` or stateless `_meta`).
+          @protocol_version = nil
+        end
+
+        # Methods held behind the legacy gate. A stateless (2026-07-28) request
+        # opens them by declaring its version; a legacy client opens them with
+        # `initialize`.
+        GATED_METHODS = %w[
+          tools/list tools/call
+          resources/list resources/read resources/templates/list
+          prompts/list prompts/get
+        ].freeze
+
+        # Process one JSON-RPC message (symbolized keys). Every message the
+        # server produces is handed to #deliver, in order.
+        def handle_message(msg)
+          method = msg[:method]
+          id = msg[:id]
+          params = msg[:params] || {}
+          has_id = msg.key?(:id)
+
+          # A stateless (2026-07-28) request carries its protocol version in
+          # `_meta` instead of an `initialize` handshake; a version this server
+          # does not speak is answered here and the message stops.
+          version = meta_protocol_version(params)
+          if version && !supported_version?(version)
+            return send_error(id, Native::Messages::ErrorCodes::UNSUPPORTED_PROTOCOL_VERSION,
+                              "Unsupported protocol version: #{version}")
+          end
+
+          adopt_version(version)
+          return send_error(id, -32_000, "Server not initialized") if gated?(method) && !@initialized
+
+          case method
+          when "initialize"
+            handle_initialize(id, params)
+          when "server/discover"
+            handle_discover(id)
+          when "notifications/initialized"
+            @initialized = true
+            debug_log "Client initialized"
+          when "tools/list"
+            handle_tools_list(id)
+          when "tools/call"
+            handle_tool_call(id, params)
+          when "resources/list"
+            handle_resources_list(id)
+          when "resources/read"
+            handle_resource_read(id, params)
+          when "resources/templates/list"
+            handle_resources_templates_list(id)
+          when "prompts/list"
+            handle_prompts_list(id)
+          when "prompts/get"
+            handle_prompt_get(id, params)
+          when "ping"
+            # ping was removed in 2026-07-28; legacy clients still use it.
+            if stateless_mode?
+              send_error(id, Native::Messages::ErrorCodes::METHOD_NOT_FOUND, "Method not found: ping") if has_id
+            elsif has_id
+              send_result(id, {})
+            end
+          else
+            debug_log "Unknown method: #{method}"
+            send_error(id, Native::Messages::ErrorCodes::METHOD_NOT_FOUND, "Method not found: #{method}") if has_id
+          end
+        end
+
+        private
+
+        # Hand an outbound message to the transport. The default collects into
+        # #outbox; Stdio overrides this to write to $stdout as messages appear.
+        def deliver(message)
+          @outbox << message
+        end
+
+        # Adopt the protocol version a stateless (2026-07-28) request declares
+        # in `_meta`; that declaration is what unlocks the handlers without the
+        # legacy gate. A legacy request declares nothing, so the gate stands.
+        def adopt_version(version)
+          return if version.nil?
+
+          @protocol_version = version
+          @initialized = true
+          debug_log "Stateless request (protocol #{version})"
+        end
+
+        # server/discover (2026-07-28): advertise supported protocol versions,
+        # capabilities, and identity. Clients call it before anything else to
+        # select a version (or as a backward-compat probe on stdio).
+        def handle_discover(id)
+          send_result(id, {
+                        protocolVersions: Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS,
+                        capabilities: @capabilities,
+                        serverInfo: { name: @name, version: @server_version }
+                      })
+          debug_log "server/discover answered"
+        end
+
+        def handle_initialize(id, params)
+          @initialized = true
+          @protocol_version = params[:protocolVersion] || Ask::MCP::PROTOCOL_VERSION
+          client_version = params[:protocolVersion] || Ask::MCP::PROTOCOL_VERSION
+          debug_log "Handling initialize (id=#{id.inspect}, version=#{client_version})"
+          send_result(id, {
+                        protocolVersion: client_version,
+                        capabilities: @capabilities,
+                        serverInfo: {
+                          name: @name,
+                          version: @server_version
+                        }
+                      })
+          debug_log "Initialize complete"
+        end
+
+        def handle_tools_list(id)
+          defs = @adapter.definitions
+          debug_log "tools/list returning #{defs.length} tool definitions"
+          send_result(id, cacheable({ tools: defs }))
+        end
+
+        def handle_resources_list(id)
+          defs = @resources.values.map { |r| resource_to_h(r) }
+          debug_log "resources/list returning #{defs.length} resources"
+          send_result(id, cacheable({ resources: defs }))
+        end
+
+        def handle_resources_templates_list(id)
+          defs = @resource_templates.values.map { |t| template_to_h(t) }
+          debug_log "resources/templates/list returning #{defs.length} templates"
+          send_result(id, cacheable({ resourceTemplates: defs }))
+        end
+
+        def handle_resource_read(id, params)
+          uri = params[:uri].to_s
+          resource = @resources[uri]
+          if resource.nil?
+            code = stateless_mode? ? Native::Messages::ErrorCodes::INVALID_PARAMS : Native::Messages::ErrorCodes::RESOURCE_NOT_FOUND
+            return send_error(id, code, "Resource not found: #{uri}")
+          end
+
+          contents = if resource.respond_to?(:content)
+                       resource.content
+                     elsif resource.respond_to?(:read)
+                       resource.read
+                     else
+                       [{ uri: uri, text: "" }]
+                     end
+          send_result(id, cacheable({ contents: contents }))
+        end
+
+        def handle_prompts_list(id)
+          defs = @prompts.values.map { |p| prompt_to_h(p) }
+          debug_log "prompts/list returning #{defs.length} prompts"
+          send_result(id, cacheable({ prompts: defs }))
+        end
+
+        def handle_prompt_get(id, params)
+          name = params[:name].to_s
+          prompt = @prompts[name]
+          if prompt.nil?
+            return send_error(id, Native::Messages::ErrorCodes::PROMPT_NOT_FOUND, "Prompt not found: #{name}")
+          end
+
+          messages = prompt.respond_to?(:messages) ? prompt.messages : []
+          send_result(id, { messages: messages })
+        end
+
+        def handle_tool_call(id, params)
+          cache_key = id.to_s
+
+          # Return cached result for retried requests (same ID, already processed)
+          if @result_cache.key?(cache_key)
+            debug_log "Returning cached result for id=#{id}"
+            return send_result(id, @result_cache[cache_key])
+          end
+
+          tool_name = params[:name].to_s
+          arguments = params[:arguments] || {}
+
+          debug_log "Handling tools/call: #{tool_name} (id=#{id.inspect})"
+
+          result = if @tool_timeout
+                     Timeout.timeout(@tool_timeout) { @adapter.call(tool_name, arguments) }
+                   else
+                     @adapter.call(tool_name, arguments)
+                   end
+
+          @result_cache[cache_key] = result
+          trim_cache
+
+          send_result(id, result)
+        rescue Timeout::Error
+          debug_log "Tool call timed out: #{tool_name}"
+          send_result(id, {
+                        content: [{ type: "text", text: "Tool call timed out: #{tool_name}" }],
+                        isError: true
+                      })
+        end
+
+        # Serialize a resource object for resources/list. Prefers to_h (the
+        # Resource value object emits title/icons/description/mimeType);
+        # otherwise builds the shape from duck-typed accessors.
+        def resource_to_h(resource)
+          return resource.to_h if resource.respond_to?(:to_h)
+
+          h = { uri: resource.uri, name: resource.name }
+          h[:title] = resource.title if resource.respond_to?(:title) && resource.title
+          h[:description] = resource.description if resource.respond_to?(:description) && resource.description
+          h[:mimeType] = resource.mime_type if resource.respond_to?(:mime_type) && resource.mime_type
+          h[:icons] = resource.icons if resource.respond_to?(:icons) && resource.icons&.any?
+          h
+        end
+
+        def template_to_h(template)
+          return template.to_h if template.respond_to?(:to_h)
+
+          h = { uriTemplate: template.uri_template, name: template.name }
+          h[:title] = template.title if template.respond_to?(:title) && template.title
+          h[:mimeType] = template.mime_type if template.respond_to?(:mime_type) && template.mime_type
+          h[:icons] = template.icons if template.respond_to?(:icons) && template.icons&.any?
+          h
+        end
+
+        def prompt_to_h(prompt)
+          return prompt.to_h if prompt.respond_to?(:to_h)
+
+          h = { name: prompt.name }
+          h[:title] = prompt.title if prompt.respond_to?(:title) && prompt.title
+          h[:description] = prompt.description if prompt.respond_to?(:description) && prompt.description
+          h[:arguments] = prompt.arguments if prompt.respond_to?(:arguments) && prompt.arguments&.any?
+          h[:icons] = prompt.icons if prompt.respond_to?(:icons) && prompt.icons&.any?
+          h
+        end
+
+        def send_result(id, result)
+          result = result.merge(stateless_result_fields) if stateless_mode?
+          deliver({ jsonrpc: "2.0", id: id, result: result })
+        end
+
+        # 2026-07-28: every result carries `resultType`, and servers SHOULD
+        # identify themselves in `_meta` so a client can attribute an answer
+        # without a separate discovery round trip. Legacy peers tolerate both
+        # fields, but we only emit them for stateless peers so the legacy wire
+        # output is unchanged.
+        def stateless_result_fields
+          {
+            resultType: "complete",
+            _meta: { Native::Messages::Meta::SERVER_INFO_KEY => server_info }
+          }
+        end
+
+        def server_info
+          { name: @name, version: @server_version }
+        end
+
+        # Build a server→client notification (no id).
+        def send_notification(method, params = {})
+          msg = { jsonrpc: "2.0", method: method }
+          msg[:params] = params unless params.empty?
+          deliver(msg)
+        end
+
+        # 2026-07-28 CacheableResult: freshness hints (ttlMs) and scope
+        # (public/private) on list/read results so clients and shared
+        # intermediaries may cache them. Only emitted for stateless peers.
+        def cacheable(result)
+          return result unless stateless_mode?
+
+          result.merge(ttlMs: @cache_ttl_ms, cacheScope: @cache_scope)
+        end
+
+        # True once a 2026-07-28 stateless peer has been detected.
+        def stateless_mode?
+          @protocol_version == Ask::MCP::LATEST_PROTOCOL_VERSION
+        end
+
+        def supported_version?(version)
+          Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS.include?(version)
+        end
+
+        def gated?(method)
+          GATED_METHODS.include?(method)
+        end
+
+        # Read the protocol version a stateless client advertises in params
+        # `_meta`. Returns nil for legacy requests. Handles both symbol and
+        # string key forms (the JSON parser symbolizes all keys).
+        def meta_protocol_version(params)
+          meta = params[:meta] || params[:_meta] || {}
+          meta_value(meta, Native::Messages::Meta::PROTOCOL_VERSION_KEY)
+        end
+
+        def meta_value(meta, key)
+          meta[key] || meta[key.to_sym] || meta[key.to_s]
+        end
+
+        def send_error(id, code, message)
+          deliver({ jsonrpc: "2.0", id: id, error: { code: code, message: message } })
+        end
+
+        def debug_log(msg)
+          return unless @debug
+
+          ts = Time.now.strftime("%H:%M:%S.%L")
+          warn "[#{ts}] [#{@name}] #{msg}"
+        end
+
+        def trim_cache
+          return if @result_cache.size <= MAX_RESULT_CACHE
+
+          @result_cache.shift(@result_cache.size - MAX_RESULT_CACHE)
+        end
+      end
+    end
+  end
+end

data/lib/ask/mcp/server/http.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+
+module Ask
+  module MCP
+    class Server
+      # MCP server over the stateless Streamable HTTP transport (2026-07-28).
+      #
+      # A Rack application. Every JSON-RPC message is one HTTP POST to the
+      # endpoint and the server answers with a single application/json object.
+      # The 2026-07-28 revision removed protocol-level sessions, the GET
+      # stream endpoint and SSE resumability, so nothing here is stateful —
+      # each request is dispatched by a fresh Core.
+      #
+      #   mount Ask::MCP::Server.rack_app(name: "anychat", tools: [...]) => "/mcp"
+      #
+      # Multi-tenant servers resolve tools per request. `authenticate`
+      # receives the Rack env on every POST and returns whatever the host uses
+      # to identify the caller; a nil return rejects the request with 401.
+      # `tools` then receives that value:
+      #
+      #   HTTP.new(
+      #     name: "anychat",
+      #     authenticate: ->(env) { User.find_by_token(bearer_token(env)) },
+      #     tools: ->(user) { user ? Tools.for(user) : [] }
+      #   )
+      #
+      # Two spec obligations are deliberately left to the host or to a later
+      # revision, and are called out here so nobody assumes otherwise:
+      #
+      # * Requests that carry `Mcp-Param-{Name}` headers are checked for legal
+      #   field values, but not matched against the call arguments. Matching
+      #   needs the calling tool's `x-mcp-header` annotations; no tool in this
+      #   ecosystem declares them yet, so the condition cannot arise.
+      # * Notifications raised while handling a request are dropped rather than
+      #   streamed ahead of the response. This transport answers with
+      #   application/json rather than text/event-stream, and the 2026-07-28
+      #   channel for server-initiated changes is the opt-in
+      #   subscriptions/listen stream, which is not implemented.
+      class HTTP
+        ERROR_CODES = Native::Messages::ErrorCodes
+
+        NAME_BEARING_METHODS = %w[tools/call resources/read prompts/get].freeze
+        JSON_CONTENT_TYPE = "application/json"
+        MAX_BODY_BYTES = 1_048_576
+        # Values that are not plain visible ASCII travel base64-encoded inside
+        # this sentinel form (2026-07-28, SEP-2243). The markers are
+        # case-sensitive.
+        BASE64_SENTINEL = "=?base64?"
+        BASE64_SENTINEL_END = "?="
+        PARAM_HEADER_PREFIX = "HTTP_MCP_PARAM_"
+
+        # @param allowed_origins [Array<String>, :any, nil] origins permitted to
+        #   call this endpoint. nil — the default — trusts no browser origin,
+        #   which still admits server-to-server clients because they send no
+        #   Origin header at all.
+        def initialize(name:, version: nil, tools: [], capabilities: { tools: {} },
+                       resources: {}, prompts: {}, resource_templates: {},
+                       debug: false, tool_timeout: nil, cache_ttl_ms: 60_000,
+                       cache_scope: "private", authenticate: nil, context: nil,
+                       allowed_origins: nil)
+          @name = name
+          @tools = tools
+          @authenticate = authenticate
+          @context = context
+          @debug = debug
+          @allowed_origins = allowed_origins
+          @core_options = {
+            name: name,
+            version: version,
+            capabilities: capabilities,
+            resources: resources,
+            prompts: prompts,
+            resource_templates: resource_templates,
+            debug: debug,
+            tool_timeout: tool_timeout,
+            cache_ttl_ms: cache_ttl_ms,
+            cache_scope: cache_scope
+          }
+        end
+
+        # Rack interface.
+        def call(env)
+          return forbidden unless origin_allowed?(env)
+          return method_not_allowed(env) unless post?(env)
+
+          if @authenticate
+            context = @authenticate.call(env)
+            return unauthorized unless context
+
+            return dispatch(env, context)
+          end
+
+          dispatch(env, context_for(env))
+        end
+
+        private
+
+        def dispatch(env, context)
+          raw = read_body(env)
+          return error_response(400, ERROR_CODES::PARSE_ERROR, "Empty request body") if raw.strip.empty?
+
+          message = JSON.parse(raw, symbolize_names: true)
+          unless message.is_a?(Hash)
+            return error_response(400, ERROR_CODES::INVALID_REQUEST,
+                                  "Expected a single JSON-RPC object (batching is not part of this revision)")
+          end
+
+          # A revision this server cannot speak is a transport-level failure
+          # with its own error and status, so it is settled before validation.
+          declared_version = env["HTTP_MCP_PROTOCOL_VERSION"].to_s
+          if !declared_version.empty? && !Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS.include?(declared_version)
+            return unsupported_version_response(declared_version, message[:id])
+          end
+
+          # The header requirements are specified for requests; a notification
+          # is not one, and this revision defines no client-to-server
+          # notifications over this transport, so notifications are accepted
+          # without them.
+          if message.key?(:id)
+            violation = transport_violation(env, message)
+            return error_response(400, ERROR_CODES::HEADER_MISMATCH, violation, id: message[:id]) if violation
+          end
+
+          core = build_core(context)
+          core.handle_message(message)
+          render(core.outbox)
+        rescue JSON::ParserError => e
+          error_response(400, ERROR_CODES::PARSE_ERROR, "Parse error: #{e.message}")
+        end
+
+        # Servers MUST validate the Origin header and refuse an Origin they do
+        # not trust (2026-07-28): without this, a remote page can reach a
+        # local MCP endpoint through DNS rebinding.
+        def origin_allowed?(env)
+          origin = env["HTTP_ORIGIN"].to_s
+          return true if origin.empty?
+          return false if @allowed_origins.nil?
+
+          @allowed_origins == :any || Array(@allowed_origins).include?(origin)
+        end
+
+        def transport_violation(env, message)
+          protocol_violation(env, message) ||
+            method_violation(env, message) ||
+            name_violation(env, message) ||
+            param_value_violation(env)
+        end
+
+        # MCP-Protocol-Version is required on every POST and must agree with
+        # the version the body declares in `_meta`: the body is authoritative,
+        # the header exists so intermediaries can route without parsing it.
+        # A request with no `_meta` version is a client expecting the removed
+        # `initialize` handshake, which this stateless endpoint cannot honour.
+        def protocol_violation(env, message)
+          declared = env["HTTP_MCP_PROTOCOL_VERSION"].to_s
+          return "Missing required MCP-Protocol-Version header" if declared.empty?
+
+          body_version = Core.declared_protocol_version(message[:params] || {})
+          if body_version.nil?
+            return "MCP-Protocol-Version #{declared.inspect} has no matching " \
+                   "#{Native::Messages::Meta::PROTOCOL_VERSION_KEY} in params._meta"
+          end
+          return nil if declared == body_version
+
+          "MCP-Protocol-Version #{declared.inspect} does not match body value #{body_version.inspect}"
+        end
+
+        # Mcp-Method is required for all requests (2026-07-28, SEP-2243).
+        def method_violation(env, message)
+          method = message[:method].to_s
+          declared = env["HTTP_MCP_METHOD"].to_s
+          return "Missing required Mcp-Method header" if declared.empty?
+          return nil if declared == method
+
+          "Mcp-Method header #{declared.inspect} does not match method #{method.inspect}"
+        end
+
+        # Mcp-Name is required for the methods whose body carries a name.
+        def name_violation(env, message)
+          method = message[:method].to_s
+          return nil unless NAME_BEARING_METHODS.include?(method)
+
+          params = message[:params] || {}
+          expected = (params[:name] || params[:uri]).to_s
+          # A call missing its name is reported by the tool layer, with the
+          # error shape that layer already owns.
+          return nil if expected.empty?
+
+          declared = decode_header_value(env["HTTP_MCP_NAME"])
+          return "Missing required Mcp-Name header for #{method}" if declared.nil? || declared.empty?
+          return nil if declared == expected
+
+          "Mcp-Name header #{declared.inspect} does not match name #{expected.inspect}"
+        end
+
+        # Mirrored tool-parameter headers must carry legal field values, in
+        # base64 sentinel form when they cannot (2026-07-28, SEP-2243).
+        def param_value_violation(env)
+          env.each do |key, value|
+            next unless key.start_with?(PARAM_HEADER_PREFIX)
+            next if header_value_legal?(value)
+
+            return "#{header_name_for(key)} contains characters that require base64 encoding"
+          end
+          nil
+        end
+
+        def header_value_legal?(value)
+          return base64_encoded?(value) if value.start_with?(BASE64_SENTINEL)
+
+          value.each_char.all? do |char|
+            char.ord == 0x09 || char.ord.between?(0x20, 0x7e)
+          end
+        end
+
+        def base64_encoded?(value)
+          return false unless value.end_with?(BASE64_SENTINEL_END)
+
+          Base64.strict_decode64(sentinel_payload(value))
+          true
+        rescue ArgumentError
+          false
+        end
+
+        # Header values that are not plain visible ASCII travel base64-encoded
+        # in the =?base64?...?= sentinel form; servers MUST decode before
+        # comparing them with the body. Base64 carries bytes and knows nothing
+        # of encodings, and the spec defines the payload as the UTF-8
+        # representation, so the decoded string is tagged as such — otherwise
+        # it compares unequal to the same text from the body.
+        def decode_header_value(value)
+          return nil if value.nil?
+          return value unless value.start_with?(BASE64_SENTINEL)
+
+          Base64.strict_decode64(sentinel_payload(value)).force_encoding(Encoding::UTF_8)
+        rescue ArgumentError
+          value
+        end
+
+        def sentinel_payload(value)
+          value[BASE64_SENTINEL.length..-(BASE64_SENTINEL_END.length + 1)]
+        end
+
+        # Rack folds header names into HTTP_MCP_PARAM_REGION; fold it back for
+        # a message a human can act on.
+        def header_name_for(key)
+          key.delete_prefix("HTTP_").split("_").map(&:capitalize).join("-")
+        end
+
+        def build_core(context)
+          Core.new(**@core_options, tools: resolve_tools(context))
+        end
+
+        def resolve_tools(context)
+          return @tools unless @tools.respond_to?(:call)
+
+          @tools.call(context) || []
+        end
+
+        def context_for(env)
+          @context ? @context.call(env) : env
+        end
+
+        def render(outbox)
+          response = outbox.reverse.find { |message| message.key?(:id) }
+          dropped = outbox.count { |message| !message.key?(:id) }
+          debug_log "Dropped #{dropped} notification(s): no channel for them on this transport" if dropped.positive?
+
+          # A message with no id is a notification: accepted, nothing to say.
+          return [202, json_headers, []] if response.nil?
+
+          [status_for(response), json_headers, [JSON.generate(response)]]
+        end
+
+        # An RPC the server does not implement is a transport-level 404 with a
+        # JSON-RPC -32601 body (2026-07-28); every other outcome is 200, with
+        # failures inside the JSON-RPC envelope where they belong.
+        def status_for(response)
+          response.dig(:error, :code) == ERROR_CODES::METHOD_NOT_FOUND ? 404 : 200
+        end
+
+        def read_body(env)
+          input = env["rack.input"]
+          return "" unless input
+
+          input.read(MAX_BODY_BYTES).to_s
+        end
+
+        def post?(env)
+          env["REQUEST_METHOD"] == "POST"
+        end
+
+        def json_headers
+          { "Content-Type" => JSON_CONTENT_TYPE }
+        end
+
+        def method_not_allowed(env)
+          rpc_error(405, ERROR_CODES::METHOD_NOT_FOUND,
+                    "Method not allowed: #{env['REQUEST_METHOD']} (this endpoint accepts POST)")
+            .tap { |triple| triple[1] = triple[1].merge("Allow" => "POST") }
+        end
+
+        def unsupported_version_response(version, id)
+          rpc_error(400, ERROR_CODES::UNSUPPORTED_PROTOCOL_VERSION,
+                    "Unsupported protocol version: #{version}",
+                    id: id, data: { supported: Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS })
+        end
+
+        def forbidden
+          rpc_error(403, ERROR_CODES::INVALID_REQUEST, "Origin not allowed")
+        end
+
+        def unauthorized
+          rpc_error(401, ERROR_CODES::AUTH_ERROR, "Unauthorized")
+            .tap { |triple| triple[1] = triple[1].merge("WWW-Authenticate" => "Bearer") }
+        end
+
+        def error_response(status, code, message, id: nil)
+          rpc_error(status, code, message, id: id)
+        end
+
+        # A rejection that the server could tie to a request echoes that
+        # request's id, so a JSON-RPC client can correlate the failure with
+        # what it sent. Failures raised before the body is understood — and the
+        # 403 for an untrusted Origin — carry no id, which the spec allows.
+        def rpc_error(status, code, message, id: nil, data: nil)
+          error = { code: code, message: message }
+          error[:data] = data if data
+          body = { jsonrpc: "2.0", id: id, error: error }
+          [status, json_headers, [JSON.generate(body)]]
+        end
+
+        def debug_log(message)
+          return unless @debug
+
+          warn "[ask-mcp] [#{@name}] #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/ask/mcp/server/stdio.rb

@@ -1,42 +1,21 @@
 # frozen_string_literal: true
 
-require "json"
-require "timeout"
-
 module Ask
   module MCP
     class Server
-      # MCP server over stdio transport.
-      class Stdio
-        MAX_RESULT_CACHE = 100
+      # MCP server over the stdio transport.
+      #
+      # Reads newline-delimited JSON-RPC on stdin and writes replies to
+      # stdout as they are produced. All message handling lives in Core;
+      # this class adds the read loop and the stdout writer.
+      class Stdio < Core
         # Deprecated: use Ask::MCP::PROTOCOL_VERSION (the canonical constant).
         PROTOCOL_VERSION = Ask::MCP::PROTOCOL_VERSION
 
-        attr_reader :name, :tools, :capabilities, :resources, :prompts
-
-        def initialize(name:, tools: [], capabilities: {}, resources: {}, prompts: {},
-                       resource_templates: {}, debug: false, tool_timeout: nil,
-                       cache_ttl_ms: 60_000, cache_scope: "private", version: nil)
-          @name = name
-          @server_version = version || Ask::MCP::VERSION
-          @capabilities = capabilities
-          @resources = resources
-          @prompts = prompts
-          @resource_templates = resource_templates
-          @debug = debug
-          @tool_timeout = tool_timeout
-          @cache_ttl_ms = cache_ttl_ms
-          @cache_scope = cache_scope
-
-          @adapter = Adapters::ToolServer.new(tools || [])
-          @initialized = false
+        def initialize(**options)
+          super
           @running = false
           @shutdown_requested = false
-          @result_cache = {}
-          # Negotiated protocol version. nil until the client tells us which
-          # revision it speaks (legacy `initialize` or stateless `_meta`).
-          @protocol_version = nil
-          @stateless = false
         end
 
         def start
@@ -54,6 +33,7 @@ module Ask
           while @running && !@shutdown_requested && (line = $stdin.gets)
             line = line.strip
             next if line.empty?
+
             process_line(line)
           end
 
@@ -95,6 +75,12 @@ module Ask
 
         private
 
+        # Static stdio peers have no request/response framing, so each message
+        # is written the moment the Core produces it.
+        def deliver(message)
+          $stdout.puts(JSON.generate(message))
+        end
+
         def graceful_shutdown
           @shutdown_requested = true
           # Close stdin to unblock $stdin.gets so the signal handler
@@ -106,269 +92,7 @@ module Ask
           msg = JSON.parse(line, symbolize_names: true)
           handle_message(msg)
         rescue JSON::ParserError => e
-          send_error(nil, -32700, "Parse error: #{e.message}")
-        end
-
-        def handle_message(msg)
-          method = msg[:method]
-          id = msg[:id]
-          params = msg[:params] || {}
-          has_id = msg.key?(:id)
-
-          # Stateless (2026-07-28) requests carry the protocol version in
-          # `_meta` instead of an `initialize` handshake. Detecting it here
-          # unlocks all handlers without the legacy @initialized gate.
-          if (meta_version = meta_protocol_version(params))
-            @protocol_version = meta_version
-            @stateless = true
-            @initialized = true
-            debug_log "Stateless request (protocol #{meta_version})"
-          end
-
-          case method
-          when "initialize"
-            handle_initialize(id, params)
-          when "server/discover"
-            handle_discover(id)
-          when "notifications/initialized"
-            @initialized = true
-            debug_log "Client initialized"
-          when "tools/list"
-            return send_error(id, -32000, "Server not initialized") unless @initialized
-            handle_tools_list(id)
-          when "tools/call"
-            return send_error(id, -32000, "Server not initialized") unless @initialized
-            handle_tool_call(id, params)
-          when "resources/list"
-            return send_error(id, -32000, "Server not initialized") unless @initialized
-            handle_resources_list(id)
-          when "resources/read"
-            return send_error(id, -32000, "Server not initialized") unless @initialized
-            handle_resource_read(id, params)
-          when "resources/templates/list"
-            return send_error(id, -32000, "Server not initialized") unless @initialized
-            handle_resources_templates_list(id)
-          when "prompts/list"
-            return send_error(id, -32000, "Server not initialized") unless @initialized
-            handle_prompts_list(id)
-          when "prompts/get"
-            return send_error(id, -32000, "Server not initialized") unless @initialized
-            handle_prompt_get(id, params)
-          when "ping"
-            # ping was removed in 2026-07-28; legacy clients still use it.
-            if stateless_mode?
-              send_error(id, -32601, "Method not found: ping") if has_id
-            else
-              send_result(id, {}) if has_id
-            end
-          else
-            debug_log "Unknown method: #{method}"
-            send_error(id, -32601, "Method not found: #{method}") if has_id
-          end
-        end
-
-        # server/discover (2026-07-28): advertise supported protocol versions,
-        # capabilities, and identity. Clients call it before anything else to
-        # select a version (or as a backward-compat probe on stdio).
-        def handle_discover(id)
-          send_result(id, {
-            protocolVersions: Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS,
-            capabilities: @capabilities,
-            serverInfo: { name: @name, version: @server_version }
-          })
-          debug_log "server/discover answered"
-        end
-
-        def handle_initialize(id, params)
-          @initialized = true
-          @protocol_version = params[:protocolVersion] || Ask::MCP::PROTOCOL_VERSION
-          client_version = params[:protocolVersion] || Ask::MCP::PROTOCOL_VERSION
-          debug_log "Handling initialize (id=#{id.inspect}, version=#{client_version})"
-          send_result(id, {
-            protocolVersion: client_version,
-            capabilities: @capabilities,
-            serverInfo: {
-              name: @name,
-              version: @server_version
-            }
-          })
-          debug_log "Initialize complete"
-        end
-
-        def handle_tools_list(id)
-          defs = @adapter.definitions
-          debug_log "tools/list returning #{defs.length} tool definitions"
-          send_result(id, cacheable({ tools: defs }))
-        end
-
-        def handle_resources_list(id)
-          defs = @resources.values.map { |r| resource_to_h(r) }
-          debug_log "resources/list returning #{defs.length} resources"
-          send_result(id, cacheable({ resources: defs }))
-        end
-
-        def handle_resources_templates_list(id)
-          defs = @resource_templates.values.map { |t| template_to_h(t) }
-          debug_log "resources/templates/list returning #{defs.length} templates"
-          send_result(id, cacheable({ resourceTemplates: defs }))
-        end
-
-        def handle_resource_read(id, params)
-          uri = params[:uri].to_s
-          resource = @resources[uri]
-          if resource.nil?
-            code = stateless_mode? ? -32_602 : Native::Messages::ErrorCodes::RESOURCE_NOT_FOUND
-            return send_error(id, code, "Resource not found: #{uri}")
-          end
-
-          contents = if resource.respond_to?(:content)
-                       resource.content
-                     elsif resource.respond_to?(:read)
-                       resource.read
-                     else
-                       [{ uri: uri, text: "" }]
-                     end
-          send_result(id, cacheable({ contents: contents }))
-        end
-
-        def handle_prompts_list(id)
-          defs = @prompts.values.map { |p| prompt_to_h(p) }
-          debug_log "prompts/list returning #{defs.length} prompts"
-          send_result(id, cacheable({ prompts: defs }))
-        end
-
-        def handle_prompt_get(id, params)
-          name = params[:name].to_s
-          prompt = @prompts[name]
-          if prompt.nil?
-            return send_error(id, Native::Messages::ErrorCodes::PROMPT_NOT_FOUND, "Prompt not found: #{name}")
-          end
-
-          messages = prompt.respond_to?(:messages) ? prompt.messages : []
-          send_result(id, { messages: messages })
-        end
-
-        def handle_tool_call(id, params)
-          cache_key = id.to_s
-
-          # Return cached result for retried requests (same ID, already processed)
-          if @result_cache.key?(cache_key)
-            debug_log "Returning cached result for id=#{id}"
-            return send_result(id, @result_cache[cache_key])
-          end
-
-          tool_name = params[:name].to_s
-          arguments = params[:arguments] || {}
-
-          debug_log "Handling tools/call: #{tool_name} (id=#{id.inspect})"
-
-          result = if @tool_timeout
-                     Timeout.timeout(@tool_timeout) { @adapter.call(tool_name, arguments) }
-                   else
-                     @adapter.call(tool_name, arguments)
-                   end
-
-          @result_cache[cache_key] = result
-          trim_cache
-
-          send_result(id, result)
-        rescue Timeout::Error
-          debug_log "Tool call timed out: #{tool_name}"
-          send_result(id, {
-            content: [{ type: "text", text: "Tool call timed out: #{tool_name}" }],
-            isError: true
-          })
-        end
-
-        # Serialize a resource object for resources/list. Prefers to_h (the
-        # Resource value object emits title/icons/description/mimeType);
-        # otherwise builds the shape from duck-typed accessors.
-        def resource_to_h(resource)
-          return resource.to_h if resource.respond_to?(:to_h)
-
-          h = { uri: resource.uri, name: resource.name }
-          h[:title] = resource.title if resource.respond_to?(:title) && resource.title
-          h[:description] = resource.description if resource.respond_to?(:description) && resource.description
-          h[:mimeType] = resource.mime_type if resource.respond_to?(:mime_type) && resource.mime_type
-          h[:icons] = resource.icons if resource.respond_to?(:icons) && resource.icons&.any?
-          h
-        end
-
-        def template_to_h(template)
-          return template.to_h if template.respond_to?(:to_h)
-
-          h = { uriTemplate: template.uri_template, name: template.name }
-          h[:title] = template.title if template.respond_to?(:title) && template.title
-          h[:mimeType] = template.mime_type if template.respond_to?(:mime_type) && template.mime_type
-          h[:icons] = template.icons if template.respond_to?(:icons) && template.icons&.any?
-          h
-        end
-
-        def prompt_to_h(prompt)
-          return prompt.to_h if prompt.respond_to?(:to_h)
-
-          h = { name: prompt.name }
-          h[:title] = prompt.title if prompt.respond_to?(:title) && prompt.title
-          h[:description] = prompt.description if prompt.respond_to?(:description) && prompt.description
-          h[:arguments] = prompt.arguments if prompt.respond_to?(:arguments) && prompt.arguments&.any?
-          h[:icons] = prompt.icons if prompt.respond_to?(:icons) && prompt.icons&.any?
-          h
-        end
-
-        def send_result(id, result)
-          # 2026-07-28: all results carry `resultType`. Legacy peers tolerate
-          # the field, but we only add it for stateless peers to keep the
-          # legacy wire output unchanged.
-          result = result.merge(resultType: "complete") if stateless_mode?
-          $stdout.puts({ jsonrpc: "2.0", id: id, result: result }.to_json)
-        end
-
-        # Write a server→client notification (no id). stdout is sync'd in
-        # #start, so this is safe to call from any thread.
-        def send_notification(method, params = {})
-          msg = { jsonrpc: "2.0", method: method }
-          msg[:params] = params unless params.empty?
-          $stdout.puts(msg.to_json)
-        end
-
-        # 2026-07-28 CacheableResult: freshness hints (ttlMs) and scope
-        # (public/private) on list/read results so clients and shared
-        # intermediaries may cache them. Only emitted for stateless peers.
-        def cacheable(result)
-          return result unless stateless_mode?
-          result.merge(ttlMs: @cache_ttl_ms, cacheScope: @cache_scope)
-        end
-
-        # True once a 2026-07-28 stateless peer has been detected.
-        def stateless_mode?
-          @protocol_version == Ask::MCP::LATEST_PROTOCOL_VERSION
-        end
-
-        # Read the protocol version a stateless client advertises in params
-        # `_meta`. Returns nil for legacy requests. Handles both symbol and
-        # string key forms (the JSON parser symbolizes all keys).
-        def meta_protocol_version(params)
-          meta = params[:meta] || params[:_meta] || {}
-          meta_value(meta, Native::Messages::Meta::PROTOCOL_VERSION_KEY)
-        end
-
-        def meta_value(meta, key)
-          meta[key] || meta[key.to_sym] || meta[key.to_s]
-        end
-
-        def send_error(id, code, message)
-          $stdout.puts({ jsonrpc: "2.0", id: id, error: { code: code, message: message } }.to_json)
-        end
-
-        def debug_log(msg)
-          return unless @debug
-          ts = Time.now.strftime("%H:%M:%S.%L")
-          $stderr.puts "[#{ts}] [ask-mcp] #{msg}"
-        end
-
-        def trim_cache
-          return if @result_cache.size <= MAX_RESULT_CACHE
-          @result_cache.shift(@result_cache.size - MAX_RESULT_CACHE)
+          send_error(nil, Native::Messages::ErrorCodes::PARSE_ERROR, "Parse error: #{e.message}")
         end
       end
     end

data/lib/ask/mcp/server.rb

@@ -54,9 +54,27 @@ module Ask
                   resources: resources, prompts: prompts,
                   resource_templates: resource_templates, debug: debug).start
       end
+
+      # Build a Rack application serving MCP over the stateless Streamable
+      # HTTP transport (2026-07-28). Mount it wherever Rack runs:
+      #
+      #   mount Ask::MCP::Server.rack_app(name: "anychat", tools: [...]) => "/mcp"
+      #
+      # Accepts the same tool/resource/prompt options as .start_stdio, plus:
+      #
+      # @param authenticate [#call, nil] receives the Rack env per request and
+      #   returns the caller's identity; a nil return answers 401
+      # @param context [#call, nil] derives the value passed to a callable
+      #   `tools` when no `authenticate` is given (defaults to the Rack env)
+      # @return [Server::HTTP] a Rack application
+      def self.rack_app(**options)
+        HTTP.new(**options)
+      end
     end
   end
 end
 
 # Load Server subclasses after the Server class is defined
+require_relative "server/core"
 require_relative "server/stdio"
+require_relative "server/http"

data/lib/ask/mcp/transport/streamable_http.rb

@@ -138,26 +138,38 @@ module Ask
 
         def handle_response(response)
           status = response.status
-          if status == 202
-            # Notification accepted, no body.
-            return response
-          end
-          unless status == 200
-            raise ConnectionError, "HTTP #{status}: #{response.body.to_s[0..200]}"
-          end
+          # Notification accepted, no body.
+          return response if status == 202
 
           content_type = response.headers["content-type"].to_s
-          if content_type.include?("text/event-stream")
+          if status == 200 && content_type.include?("text/event-stream")
             read_sse_stream(response)
-          else
-            body = response.body.to_s
-            if body && !body.empty?
-              message = Native::Messages::Parser.parse(body)
-              @message_handlers.each { |handler| handler.call(message) }
-            end
+            return response
+          end
+
+          body = response.body.to_s
+          # A server may carry a JSON-RPC error on a non-200 status — 400 for a
+          # header mismatch or an unsupported protocol version, 404 for a
+          # method it does not implement. That is a response, not a transport
+          # failure, so it goes to the message handlers where the pending
+          # request can pick it up.
+          message = parse_message(body)
+          if message
+            @message_handlers.each { |handler| handler.call(message) }
+            return response
           end
 
-          response
+          return response if status == 200
+
+          raise ConnectionError, "HTTP #{status}: #{body[0..200]}"
+        end
+
+        def parse_message(body)
+          return nil if body.empty?
+
+          Native::Messages::Parser.parse(body)
+        rescue JSON::ParserError
+          nil
         end
 
         # Read an SSE stream, delivering each `data:` payload as a parsed

data/lib/ask/mcp/version.rb

@@ -1,5 +1,5 @@
 module Ask
   module MCP
-    VERSION = "0.4.6"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-mcp
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -119,6 +119,8 @@ files:
 - lib/ask/mcp/prompt.rb
 - lib/ask/mcp/resource.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/trace_context.rb