ask-mcp 0.4.1 → 0.4.2

data/lib/ask/mcp/adapters/tool_server.rb

@@ -23,11 +23,18 @@ module Ask
         def definitions
           @tools.map do |tool|
             schema = tool.params_schema || { type: "object", properties: {}, required: [] }
-            {
+            defn = {
               name: tool.name,
               description: tool.description || "",
               inputSchema: schema
             }
+            # 2025-11-25: optional display metadata (SEP-973 icons, title).
+            # Only included when the tool object provides them.
+            defn[:title] = tool.title if tool.respond_to?(:title) && tool.title
+            if tool.respond_to?(:icons) && tool.icons&.any?
+              defn[:icons] = tool.icons
+            end
+            defn
           end
         end
 

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Ask
+  module MCP
+    module Auth
+      # OAuth Client ID Metadata Documents (2026-07-28, SEP-991) — the
+      # recommended client registration mechanism, replacing the deprecated
+      # Dynamic Client Registration Protocol (RFC 7591).
+      #
+      # A client_id is an HTTPS URL pointing to a JSON document describing the
+      # client; the authorization server fetches and validates it on demand.
+      # Because the document is self-hosted, URL-based client IDs are portable
+      # across authorization servers — no re-registration needed when the
+      # server changes.
+      module ClientIdMetadataDocument
+        # Fields every metadata document MUST include.
+        REQUIRED_FIELDS = %w[client_id client_name redirect_uris].freeze
+        # OIDC application types (native = desktop/mobile/CLI/localhost web).
+        APPLICATION_TYPES = %w[native web].freeze
+
+        module_function
+
+        # Build a metadata document hash. `client_id` must be an https URL
+        # with a path component; `redirect_uris` must be a non-empty array.
+        # Extra keyword args are included verbatim (string keys).
+        def build(client_id:, client_name:, redirect_uris:, application_type: "native", **extra)
+          {
+            "client_id" => client_id,
+            "client_name" => client_name,
+            "redirect_uris" => redirect_uris,
+            "application_type" => application_type
+          }.merge(extra.transform_keys(&:to_s))
+        end
+
+        # Whether the client_id has the required URL form: https scheme with
+        # a path component (e.g. https://example.com/client.json).
+        def valid_client_id_url?(client_id)
+          uri = URI.parse(client_id.to_s)
+          uri.scheme == "https" && !uri.path.to_s.empty? && uri.path != "/"
+        rescue URI::InvalidURIError
+          false
+        end
+
+        # Validate a fetched document. Returns nil when valid, or a reason
+        # string. When `document_url` is given, the document's client_id MUST
+        # match it exactly.
+        def invalid_reason(document, document_url: nil)
+          return "metadata document must be a JSON object" unless document.is_a?(Hash)
+
+          missing = REQUIRED_FIELDS.reject { |f| document[f] || document[f.to_sym] }
+          return "missing required fields: #{missing.join(', ')}" unless missing.empty?
+
+          client_id = (document["client_id"] || document[:client_id]).to_s
+          if document_url && client_id != document_url
+            return "client_id #{client_id.inspect} does not match document URL #{document_url.inspect}"
+          end
+          return "client_id must be an https URL with a path" unless valid_client_id_url?(client_id)
+
+          redirect_uris = document["redirect_uris"] || document[:redirect_uris]
+          return "redirect_uris must be a non-empty array" unless redirect_uris.is_a?(Array) && !redirect_uris.empty?
+
+          app_type = document["application_type"] || document[:application_type]
+          if app_type && !APPLICATION_TYPES.include?(app_type.to_s)
+            return "invalid application_type #{app_type.inspect}"
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -4,16 +4,18 @@ module Ask
   module MCP
     module Auth
       class OAuth
-        attr_reader :client_id, :client_secret, :token_url, :auth_url
+        attr_reader :client_id, :client_secret, :token_url, :auth_url, :issuer
 
-        def initialize(client_id:, client_secret: nil, token_url:, auth_url: nil,
-                       redirect_uri: nil, scopes: [])
+        def initialize(client_id:, client_secret: nil, token_url: nil, auth_url: nil,
+                       redirect_uri: nil, scopes: [], issuer: nil, discovery_url: nil)
           @client_id = client_id
           @client_secret = client_secret
           @token_url = token_url
           @auth_url = auth_url
           @redirect_uri = redirect_uri
           @scopes = scopes
+          @issuer = issuer
+          @discovery_url = discovery_url
           @access_token = nil
           @refresh_token = nil
           @expires_at = nil
@@ -28,10 +30,12 @@ module Ask
         end
 
         def authenticate!
-          if @client_secret
+          if @client_secret && @token_url
             authenticate_client_credentials
           elsif @auth_url
             authenticate_authorization_code
+          elsif @issuer || @discovery_url
+            raise AuthError, "Call #discover! before #authenticate! to resolve endpoints"
           else
             raise AuthError, "No authentication method available"
           end
@@ -44,8 +48,52 @@ module Ask
           self
         end
 
+        # Validate an `iss` parameter from an authorization response
+        # (RFC 9207, 2026-07-28): when an issuer is recorded (via
+        # discovery or configuration), a present `iss` MUST match it.
+        # Call before redeeming an authorization code.
+        def validate_iss!(iss)
+          return self if @issuer.nil?
+          raise AuthError, "iss mismatch: expected #{@issuer}, got #{iss.inspect}" unless iss.to_s == @issuer.to_s
+          self
+        end
+
+        # Discover authorization server endpoints via OpenID Connect Discovery
+        # 1.0 (2025-11-25, SEP-797). Fetches the document at discovery_url (or
+        # the well-known URL derived from issuer per RFC 8414) and populates
+        # token_url, auth_url, and issuer. Returns self.
+        def discover!(discovery_url: nil)
+          require "httpx"
+
+          url = discovery_url || @discovery_url || well_known_discovery_url
+          data = fetch_json(HTTPX, url)
+
+          @issuer = data[:issuer] if data[:issuer]
+          @token_url = data[:token_endpoint] if data[:token_endpoint]
+          @auth_url = data[:authorization_endpoint] if data[:authorization_endpoint]
+
+          raise AuthError, "Discovery document has no token_endpoint" unless @token_url
+          self
+        end
+
         private
 
+        def well_known_discovery_url
+          return @discovery_url if @discovery_url
+          raise AuthError, "OIDC discovery requires an issuer or discovery_url" unless @issuer
+          "#{@issuer.sub(%r{/+\z}, "")}/.well-known/openid-configuration"
+        end
+
+        def fetch_json(http, url)
+          response = http.get(url)
+          unless response.status == 200
+            raise AuthError, "Discovery request failed: #{response.status} #{response.body.to_s[0..200]}"
+          end
+          JSON.parse(response.body.to_s, symbolize_names: true)
+        rescue JSON::ParserError => e
+          raise AuthError, "Invalid discovery document: #{e.message}"
+        end
+
         def expired?
           @expires_at && Time.now >= @expires_at
         end

data/lib/ask/mcp/client.rb

@@ -3,7 +3,9 @@
 module Ask
   module MCP
     class Client
-      PROTOCOL_VERSION = "0.1.0"
+      # Deprecated: use Ask::MCP::PROTOCOL_VERSION (the canonical constant).
+      # Kept as an alias so existing consumers don't break.
+      PROTOCOL_VERSION = Ask::MCP::PROTOCOL_VERSION
 
       attr_reader :transport, :capabilities, :server_info
 
@@ -18,14 +20,18 @@ module Ask
         @pending_requests = {}
         @pending_mutex = Mutex.new
         @pending_condition = ConditionVariable.new
+        @request_handlers = {}
         @next_id = 0
         @initialized = false
+        # Negotiated protocol version; nil until start() resolves it.
+        @protocol_version = nil
+        @stateless = false
       end
 
       def start
         @transport.on_message { |message| handle_message(message) }
         @transport.start
-        initialize_session
+        negotiate_protocol
         self
       end
 
@@ -39,6 +45,7 @@ module Ask
 
         response = send_request("tools/list")
         tools = (response[:tools] || []).map { |t| Tool.from_h(t) }
+        tools = reject_invalid_mcp_header_tools(tools)
         @tools_cache = index_by_name(tools)
       end
 
@@ -65,17 +72,18 @@ module Ask
             Validator.new(tool.input_schema).validate!(arguments)
           end
         end
-        response = send_request("tools/call", name: name, arguments: arguments)
+        headers = mcp_param_headers(name, arguments)
+        response = send_request("tools/call", { name: name, arguments: arguments }, headers: headers)
         response[:content] || response
       end
 
       def read_resource(uri)
-        response = send_request("resources/read", uri: uri)
+        response = send_request("resources/read", { uri: uri })
         response[:contents] || response
       end
 
       def get_prompt(name, arguments = {})
-        response = send_request("prompts/get", name: name, arguments: arguments)
+        response = send_request("prompts/get", { name: name, arguments: arguments })
         response[:messages] || response
       end
 
@@ -83,8 +91,149 @@ module Ask
         @initialized
       end
 
+      # Register a handler for a server-initiated request (a JSON-RPC Request
+      # the server sends to the client, such as elicitation/create or
+      # sampling/createMessage). The handler receives the request params and
+      # must return the result hash to send back. The handler runs on the
+      # transport reader thread, so long-blocking handlers block message
+      # processing — return promptly.
+      def on_request(method, &handler)
+        @request_handlers[method] = handler
+      end
+
+      # Handle a server request for user input (client/elicitation, 2025-06-18+).
+      # The handler receives the elicitation params (including the Elicitation
+      # schema with titled/untitled, single/multi-select enums and default
+      # values in 2025-11-25) and returns an ElicitationResponse hash, e.g.
+      #   { message: "42" }
+      # or structured content. Declare client support via
+      #   Ask::MCP::Client.new(transport, client_capabilities: { elicitation: {} })
+      def on_elicitation(&handler)
+        on_request("elicitation/create", &handler)
+      end
+
+      # Handle a sampling request (client/sampling). The handler receives the
+      # CreateMessageRequest params — including `tools` and `toolChoice` when
+      # the server offers tool calling (2025-11-25, SEP-1577) — and returns a
+      # CreateMessageResult hash, e.g.
+      #   { role: "assistant", content: { type: "text", text: "..." } }
+      # Declare client support via
+      #   Ask::MCP::Client.new(transport, client_capabilities: { sampling: {} })
+      def on_sampling(&handler)
+        on_request("sampling/createMessage", &handler)
+      end
+
+      # Open a long-lived notification stream (2026-07-28 subscriptions/listen).
+      # `notifications` is a filter Hash, e.g.
+      #   { toolsListChanged: true, resourceSubscriptions: ["file:///x"] }
+      # Notifications flow into the client's message handling (which resets
+      # caches on list_changed). Only supported on transports that implement
+      # #listen (StreamableHTTP).
+      def listen(notifications)
+        @transport.listen(notifications)
+      end
+
       private
 
+      # Resolve the protocol version to speak with the server (2026-07-28
+      # stateless negotiation). Tries `server/discover` first: a server that
+      # answers with a supported version list we intersect goes stateless
+      # (no initialize handshake); anything else falls back to the legacy
+      # `initialize` handshake.
+      def negotiate_protocol
+        if discover_server
+          if @stateless
+            # 2026-07-28 stateless peer: no initialize handshake.
+            @initialized = true
+            reset_caches
+            debug "Stateless mode (protocol #{@protocol_version})"
+          else
+            # Server is a legacy revision (≤ 2025-11-25): it still requires
+            # the initialize handshake. discover already filled in server_info
+            # and capabilities; initialize refines them.
+            initialize_session
+          end
+        else
+          initialize_session
+        end
+        # Streamable HTTP mirrors the negotiated version into the
+        # MCP-Protocol-Version header on every POST.
+        @transport.protocol_version = @protocol_version if @transport.respond_to?(:protocol_version=)
+      end
+
+      def discover_server
+        response = send_request_raw("server/discover", {}, timeout: 5)
+        return false unless response.success?
+
+        result = response.result
+        supported = result[:protocolVersions] || result["protocolVersions"] || []
+        chosen = Ask::MCP::SUPPORTED_PROTOCOL_VERSIONS.reverse.find { |v| supported.include?(v) }
+        return false unless chosen
+
+        @protocol_version = chosen
+        @stateless = chosen == Ask::MCP::LATEST_PROTOCOL_VERSION
+        @server_info = result[:serverInfo] || result["serverInfo"] || {}
+        @capabilities = result[:capabilities] || result["capabilities"] || {}
+        true
+      rescue StandardError
+        false
+      end
+
+      def reset_caches
+        @tools_cache = nil
+        @resources_cache = nil
+        @prompts_cache = nil
+      end
+
+      def meta_params
+        meta = {
+          Native::Messages::Meta::PROTOCOL_VERSION_KEY => @protocol_version,
+          Native::Messages::Meta::CLIENT_CAPABILITIES_KEY => @options[:client_capabilities] || {},
+          Native::Messages::Meta::CLIENT_INFO_KEY => { name: "ask-mcp", version: Ask::MCP::VERSION }
+        }
+        # Optional extra `_meta` fields — e.g. OpenTelemetry trace context
+        # (traceparent/tracestate/baggage) via
+        #   Client.new(transport, meta: TraceContext.from_headers(rack_env))
+        meta.merge!(@options[:meta]) if @options[:meta]
+        { _meta: meta }
+      end
+
+      # Mirror x-mcp-header-annotated tool parameters into Mcp-Param-{Name}
+      # HTTP headers (2026-07-28, SEP-2243). Only applies on transports that
+      # support it (StreamableHTTP). Values are encoded per the spec; integer
+      # values outside the JavaScript safe range cannot be represented safely
+      # and their headers are omitted.
+      def mcp_param_headers(tool_name, arguments)
+        return {} unless @transport.is_a?(Transport::StreamableHTTP)
+        tool = @tools_cache && @tools_cache[tool_name]
+        return {} unless tool && tool.input_schema
+
+        props = tool.input_schema[:properties] || tool.input_schema["properties"] || {}
+        props.each_with_object({}) do |(prop_name, prop_schema), headers|
+          header_name = prop_schema[:'x-mcp-header'] || prop_schema["x-mcp-header"]
+          next unless header_name
+          value = arguments[prop_name] || arguments[prop_name.to_s]
+          next if value.nil?
+          next if value.is_a?(Integer) && !XMcpHeader.safe_integer?(value)
+          headers["Mcp-Param-#{header_name}"] = @transport.encode_header_value(value)
+        end
+      end
+
+      # Streamable HTTP clients MUST reject tool definitions with invalid
+      # x-mcp-header annotations, excluding the tool from tools/list
+      # (2026-07-28, SEP-2243). Other transports ignore the annotations.
+      def reject_invalid_mcp_header_tools(tools)
+        return tools unless @transport.is_a?(Transport::StreamableHTTP)
+
+        tools.reject do |tool|
+          reason = XMcpHeader.invalid_reason(tool.input_schema)
+          next false unless reason
+
+          warn "[ask-mcp][client] rejecting tool #{tool.name} from tools/list: #{reason}"
+          true
+        end
+      end
+
       def next_id
         @pending_mutex.synchronize do
           @next_id += 1
@@ -93,7 +242,7 @@ module Ask
 
       def initialize_session
         response = send_request_raw("initialize", {
-          protocolVersion: PROTOCOL_VERSION,
+          protocolVersion: @protocol_version || Ask::MCP::PROTOCOL_VERSION,
           capabilities: @options[:client_capabilities] || {},
           clientInfo: {
             name: "ask-mcp",
@@ -108,24 +257,28 @@ module Ask
         result = response.result
         @server_info = result[:serverInfo] || {}
         @capabilities = result[:capabilities] || {}
+        @protocol_version = result[:protocolVersion] || Ask::MCP::PROTOCOL_VERSION
 
         send_notification("notifications/initialized")
         @initialized = true
 
-        @tools_cache = nil
-        @resources_cache = nil
-        @prompts_cache = nil
+        reset_caches
       end
 
-      def send_request(method, params = {})
-        response = send_request_raw(method, params)
+      def debug(msg)
+        warn "[ask-mcp][client] #{msg}" if @options[:debug]
+      end
+
+      def send_request(method, params = {}, headers: {})
+        response = send_request_raw(method, params, headers: headers)
         raise ProtocolError, "Request failed: #{response.error[:message]}" unless response.success?
         response.result
       end
 
-      def send_request_raw(method, params = {})
+      def send_request_raw(method, params = {}, timeout: nil, headers: {})
+        params = params.merge(meta_params) if @stateless
         request = Native::Messages::Request.new(method:, params:, id: next_id)
-        wait_for_response(request)
+        wait_for_response(request, timeout: timeout, headers: headers)
       end
 
       def send_notification(method, params = {})
@@ -133,15 +286,38 @@ module Ask
         @transport.send(notification)
       end
 
-      def wait_for_response(request)
+      # Multi Round-Trip Requests (2026-07-28, SEP-2322): how many times the
+      # client may retry a request after an InputRequiredResult before giving up.
+      MAX_MRTR_ROUND_TRIPS = 5
+
+      def wait_for_response(request, timeout: nil, headers: {})
+        timeout ||= @options[:timeout] || 60
+        round_trips = 0
+
+        loop do
+          response = send_and_wait(request, timeout, headers: headers)
+          return response unless input_required?(response)
+
+          round_trips += 1
+          if round_trips > MAX_MRTR_ROUND_TRIPS
+            raise ProtocolError, "MRTR exceeded #{MAX_MRTR_ROUND_TRIPS} round trips"
+          end
+
+          result = response.result
+          input_responses = resolve_input_requests(result[:inputRequests] || result["inputRequests"] || {})
+          request = build_retry_request(request, result, input_responses)
+        end
+      end
+
+      # Send a single request and wait for its response.
+      def send_and_wait(request, timeout, headers: {})
         # Register the pending request BEFORE sending to avoid race
         @pending_mutex.synchronize do
           @pending_requests[request.id] = true
         end
 
-        @transport.send(request)
+        @transport.send(request, headers)
 
-        timeout = @options[:timeout] || 60
         deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
 
         @pending_mutex.synchronize do
@@ -163,6 +339,39 @@ module Ask
         end
       end
 
+      # An InputRequiredResult only occurs in the stateless (2026-07-28) mode.
+      def input_required?(response)
+        @stateless && response.success? && response.result.is_a?(Hash) &&
+          response.result[:resultType] == "input_required"
+      end
+
+      # Resolve each server inputRequest (elicitation/create, sampling/
+      # createMessage, roots/list) through the registered on_request handlers.
+      # Returns the InputResponses map keyed by the server's identifiers.
+      def resolve_input_requests(input_requests)
+        return {} if input_requests.nil? || input_requests.empty?
+
+        input_requests.each_with_object({}) do |(key, req), responses|
+          method = req[:method] || req["method"]
+          handler = @request_handlers[method]
+          unless handler
+            raise ProtocolError, "MRTR: no handler registered for #{method} (inputRequest #{key})"
+          end
+          responses[key] = handler.call(req[:params] || req["params"] || {})
+        end
+      end
+
+      # Build the MRTR retry: same method, a NEW id, the original params plus
+      # inputResponses and — if the server sent one — the opaque requestState
+      # echoed verbatim (clients MUST NOT inspect or modify it).
+      def build_retry_request(request, result, input_responses)
+        retry_params = (request.params || {}).dup
+        retry_params[:inputResponses] = input_responses
+        state = result[:requestState] || result["requestState"]
+        retry_params[:requestState] = state if state
+        Native::Messages::Request.new(method: request.method, params: retry_params, id: next_id)
+      end
+
       def handle_message(message)
         case message
         when Native::Messages::Response
@@ -186,13 +395,18 @@ module Ask
       end
 
       def handle_request(request)
-        response = Native::Messages::Response.new(
-          id: request.id,
-          error: {
-            code: Native::Messages::ErrorCodes::METHOD_NOT_FOUND,
-            message: "Method not implemented: #{request.method}"
-          }
-        )
+        handler = @request_handlers[request.method]
+        response = if handler
+                     Native::Messages::Response.new(id: request.id, result: handler.call(request.params || {}))
+                   else
+                     Native::Messages::Response.new(
+                       id: request.id,
+                       error: {
+                         code: Native::Messages::ErrorCodes::METHOD_NOT_FOUND,
+                         message: "Method not implemented: #{request.method}"
+                       }
+                     )
+                   end
         @transport.send(response)
       end
 

data/lib/ask/mcp/native/messages.rb

@@ -133,7 +133,7 @@ module Ask
           INVALID_PARAMS   = -32602
           INTERNAL_ERROR   = -32603
 
-          # MCP-specific error codes
+          # MCP-specific error codes (legacy, 2025-06-18 and earlier)
           TOOL_NOT_FOUND      = -32000
           RESOURCE_NOT_FOUND  = -32001
           PROMPT_NOT_FOUND    = -32002
@@ -141,6 +141,13 @@ module Ask
           CONNECTION_ERROR    = -32004
           TIMEOUT_ERROR       = -32005
 
+          # 2026-07-28: the -32020..-32099 range is reserved for the MCP
+          # specification (error code allocation policy); older codes were
+          # renumbered.
+          HEADER_MISMATCH                 = -32020
+          MISSING_REQUIRED_CLIENT_CAPABILITY = -32021
+          UNSUPPORTED_PROTOCOL_VERSION    = -32022
+
           ERROR_MESSAGES = {
             PARSE_ERROR      => "Parse error",
             INVALID_REQUEST  => "Invalid request",
@@ -152,9 +159,23 @@ module Ask
             PROMPT_NOT_FOUND => "Prompt not found",
             AUTH_ERROR       => "Authentication error",
             CONNECTION_ERROR => "Connection error",
-            TIMEOUT_ERROR    => "Timeout error"
+            TIMEOUT_ERROR    => "Timeout error",
+            HEADER_MISMATCH  => "Header mismatch",
+            MISSING_REQUIRED_CLIENT_CAPABILITY => "Missing required client capability",
+            UNSUPPORTED_PROTOCOL_VERSION => "Unsupported protocol version"
           }.freeze
         end
+
+        # Reserved `_meta` keys for the stateless protocol (2026-07-28).
+        # Keys are namespaced strings; note the JSON parser symbolizes all
+        # keys, so lookups must try both the string and symbol forms.
+        module Meta
+          PROTOCOL_VERSION_KEY    = "io.modelcontextprotocol/protocolVersion"
+          CLIENT_CAPABILITIES_KEY = "io.modelcontextprotocol/clientCapabilities"
+          CLIENT_INFO_KEY         = "io.modelcontextprotocol/clientInfo"
+          SERVER_INFO_KEY         = "io.modelcontextprotocol/serverInfo"
+          LOG_LEVEL_KEY           = "io.modelcontextprotocol/logLevel"
+        end
       end
     end
   end

data/lib/ask/mcp/prompt.rb

@@ -3,18 +3,22 @@
 module Ask
   module MCP
     class Prompt
-      attr_reader :name, :description, :arguments
+      attr_reader :name, :description, :arguments, :title, :icons
 
-      def initialize(name:, description: nil, arguments: [])
+      def initialize(name:, description: nil, arguments: [], title: nil, icons: [])
         @name = name
         @description = description
         @arguments = arguments
+        @title = title
+        @icons = icons
       end
 
       def to_h
         h = { name: @name }
+        h[:title] = @title if @title
         h[:description] = @description if @description
         h[:arguments] = @arguments if @arguments.any?
+        h[:icons] = @icons if @icons.any?
         h
       end
 
@@ -22,7 +26,9 @@ module Ask
         new(
           name: hash[:name] || hash["name"],
           description: hash[:description] || hash["description"],
-          arguments: hash[:arguments] || hash["arguments"] || []
+          arguments: hash[:arguments] || hash["arguments"] || [],
+          title: hash[:title] || hash["title"],
+          icons: hash[:icons] || hash["icons"] || []
         )
       end
     end

data/lib/ask/mcp/resource.rb

@@ -3,19 +3,23 @@
 module Ask
   module MCP
     class Resource
-      attr_reader :uri, :name, :description, :mime_type
+      attr_reader :uri, :name, :description, :mime_type, :title, :icons
 
-      def initialize(uri:, name:, description: nil, mime_type: nil)
+      def initialize(uri:, name:, description: nil, mime_type: nil, title: nil, icons: [])
         @uri = uri
         @name = name
         @description = description
         @mime_type = mime_type
+        @title = title
+        @icons = icons
       end
 
       def to_h
         h = { uri: @uri, name: @name }
+        h[:title] = @title if @title
         h[:description] = @description if @description
         h[:mimeType] = @mime_type if @mime_type
+        h[:icons] = @icons if @icons.any?
         h
       end
 
@@ -24,7 +28,9 @@ module Ask
           uri: hash[:uri] || hash["uri"],
           name: hash[:name] || hash["name"],
           description: hash[:description] || hash["description"],
-          mime_type: hash[:mimeType] || hash["mime_type"] || hash[:mime_type]
+          mime_type: hash[:mimeType] || hash["mime_type"] || hash[:mime_type],
+          title: hash[:title] || hash["title"],
+          icons: hash[:icons] || hash["icons"] || []
         )
       end
     end