ask-mcp 0.4.5 → 0.5.0

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