kward 0.73.1 → 0.75.0

data/lib/kward/tools/mcp_tool.rb

@@ -0,0 +1,122 @@
+require "json"
+require_relative "base"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Tools
+    # Adapts an MCP server tool to Kward's model-callable tool interface.
+    class MCPTool < Base
+      attr_reader :server_name, :remote_name
+
+      def display_name
+        "#{server_name}.#{remote_name}"
+      end
+
+      def initialize(server_name:, client:, tool:)
+        @server_name = server_name.to_s
+        @client = client
+        @tool = tool
+        @remote_name = value(tool, "name").to_s
+        super(kward_name(@server_name, @remote_name), description, properties: {}, required: [])
+      end
+
+      def schema
+        {
+          type: "function",
+          function: {
+            name: name,
+            description: description,
+            parameters: input_schema
+          }
+        }
+      end
+
+      def call(args, _conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        result = @client.call_tool(@remote_name, args || {})
+        format_result(result)
+      rescue StandardError => e
+        "MCP tool #{server_name}.#{remote_name} failed: #{e.message}"
+      end
+
+      def self.kward_name(server_name, tool_name)
+        "#{sanitize_name(server_name)}__#{sanitize_name(tool_name)}"
+      end
+
+      def self.sanitize_name(value)
+        text = value.to_s.gsub(/[^A-Za-z0-9_-]/, "_")
+        text = "mcp" if text.empty?
+        text[0, 60]
+      end
+
+      private
+
+      def kward_name(server_name, tool_name)
+        self.class.kward_name(server_name, tool_name)
+      end
+
+      def description
+        value(@tool, "description").to_s.empty? ? "MCP tool #{@server_name}.#{@remote_name}" : value(@tool, "description").to_s
+      end
+
+      def input_schema
+        schema = value(@tool, "inputSchema")
+        return empty_object_schema unless schema.is_a?(Hash)
+
+        schema.empty? ? empty_object_schema : schema
+      end
+
+      def empty_object_schema
+        { type: "object", properties: {}, additionalProperties: false }
+      end
+
+      def format_result(result)
+        return "MCP tool #{server_name}.#{remote_name} returned no content." unless result.is_a?(Hash)
+
+        parts = []
+        parts << "MCP tool #{server_name}.#{remote_name} reported an error:" if truthy?(value(result, "isError"))
+        parts.concat(format_content(value(result, "content")))
+
+        structured = value(result, "structuredContent")
+        parts << JSON.pretty_generate(structured) unless structured.nil?
+
+        parts.empty? ? "MCP tool #{server_name}.#{remote_name} returned no content." : parts.join("\n\n")
+      end
+
+      def format_content(content)
+        Array(content).filter_map do |entry|
+          next entry.to_s unless entry.is_a?(Hash)
+
+          case value(entry, "type")
+          when "text"
+            value(entry, "text").to_s
+          when "image"
+            "[MCP image content: #{value(entry, "mimeType") || "unknown MIME type"}]"
+          when "audio"
+            "[MCP audio content: #{value(entry, "mimeType") || "unknown MIME type"}]"
+          when "resource_link"
+            "[MCP resource link: #{value(entry, "uri") || value(entry, "name") || "unnamed"}]"
+          when "resource"
+            "[MCP embedded resource: #{resource_label(value(entry, "resource"))}]"
+          else
+            JSON.generate(entry)
+          end
+        end
+      end
+
+      def resource_label(resource)
+        return "unnamed" unless resource.is_a?(Hash)
+
+        value(resource, "uri") || value(resource, "name") || "unnamed"
+      end
+
+      def truthy?(value)
+        value == true || value.to_s == "true"
+      end
+
+      def value(object, key)
+        object[key] || object[key.to_sym]
+      end
+    end
+  end
+end

data/lib/kward/tools/read_skill.rb

@@ -8,12 +8,16 @@ module Kward
     # Tool wrapper for reading configured skill instructions.
     class ReadSkill < Base
       # Builds the tool schema and stores the execution dependency.
-      def initialize
+      def initialize(skills: nil)
+        name_property = { type: "string", description: "Skill name." }
+        skill_names = Array(skills).map(&:name).compact.sort
+        name_property[:enum] = skill_names unless skill_names.empty?
+
         super(
           "read_skill",
           "Read configured skill instructions/files.",
           properties: {
-            name: { type: "string", description: "Skill name." },
+            name: name_property,
             path: { type: "string", description: "Path inside skill; default SKILL.md." }
           },
           required: ["name"]
@@ -21,11 +25,12 @@ module Kward
       end
 
       # Executes the tool and returns model-facing output text.
-      def call(args, _conversation, cancellation: nil)
+      def call(args, conversation, cancellation: nil)
         name = argument(args, :name, "")
         path = argument(args, :path)
+        workspace_root = conversation.respond_to?(:workspace_root) ? conversation.workspace_root : Dir.pwd
 
-        ConfigFiles.read_skill_file(name, path)
+        ConfigFiles.read_skill_file(name, path, workspace_root: workspace_root)
       end
     end
   end

data/lib/kward/tools/registry.rb

@@ -1,5 +1,6 @@
 require_relative "../config_files"
 require_relative "../conversation"
+require_relative "../hooks"
 require_relative "ask_user_question"
 require_relative "code_search"
 require_relative "context_budget_stats"
@@ -8,6 +9,7 @@ require_relative "edit_file"
 require_relative "fetch_content"
 require_relative "fetch_raw"
 require_relative "list_directory"
+require_relative "mcp_tool"
 require_relative "read_file"
 require_relative "read_skill"
 require_relative "run_shell_command"
@@ -19,6 +21,7 @@ require_relative "search/code"
 require_relative "search/web"
 require_relative "search/web_fetch"
 require_relative "tool_call"
+require_relative "../mcp/server_config"
 require_relative "../telemetry/logger"
 require_relative "../tool_output_compactor"
 require_relative "../workspace"
@@ -60,7 +63,7 @@ module Kward
     # @param web_search_enabled [Boolean, nil] override for web search exposure
     # @param skills [Array<ConfigFiles::Skill>, nil] override discovered skills
     # @param ask_user_question_enabled [Boolean, nil] override question exposure
-    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil, allowed_tool_names: nil, write_lock: nil, writer_id: nil, tool_output_compactor: ToolOutputCompactor.new, telemetry_logger: TelemetryLogger.new, context_budget_meter: nil)
+    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil, allowed_tool_names: nil, write_lock: nil, writer_id: nil, tool_output_compactor: ToolOutputCompactor.new, telemetry_logger: TelemetryLogger.new, context_budget_meter: nil, mcp_clients: nil, tool_approval: nil, hook_manager: nil, hook_context: nil)
       @workspace = workspace
       @prompt = prompt
       @web_search = web_search
@@ -75,8 +78,18 @@ module Kward
       @tool_output_compactor = tool_output_compactor
       @telemetry_logger = telemetry_logger
       @context_budget_meter = context_budget_meter
+      @tool_approval = tool_approval
+      @hook_manager = hook_manager
+      @hook_context = hook_context
+      @mcp_clients = if mcp_clients
+                       mcp_clients
+                     elsif @allowed_tool_names
+                       []
+                     else
+                       MCP::ServerConfig.clients_from_config(ConfigFiles.read_config)
+                     end
       @tools = build_tools.freeze
-      @schemas = build_schema_tools.map(&:schema).freeze
+      @schemas = build_schema_tools.map { |tool| schema_with_metadata(tool) }.freeze
     end
 
     # Executes a model-requested tool call and appends the result to the
@@ -96,10 +109,18 @@ module Kward
       tool = @tools[name]
 
       original_content = if tool
-                           if mutation_tool?(name) && !write_lock_owned?
+                           before_tool = run_hook("tool_call_before", conversation, payload: tool_payload(name, args, tool_call))
+                           args = hook_arguments(before_tool, args)
+                           if before_tool.denied?
+                             hook_denied_content(before_tool, "tool call denied: #{name}")
+                           elsif before_tool.approval_required? && hook_approval_denied?(before_tool, tool_call, name, args, cancellation)
+                             hook_denied_content(before_tool, "tool call approval denied: #{name}")
+                           elsif mutation_tool?(name) && !write_lock_owned?
                              "Workspace write denied: another worker owns the write lock."
+                           elsif tool_approval_denied?(tool_call, name, args, cancellation)
+                             "Declined: tool execution denied by user: #{name}"
                            else
-                             tool.call(args, conversation, cancellation: cancellation)
+                             execute_tool_with_hooks(tool, name, args, tool_call, conversation, cancellation)
                            end
                          else
                            "Unknown tool: #{name}"
@@ -112,7 +133,7 @@ module Kward
       end
 
       artifact_id = nil
-      model_content = @tool_output_compactor.compact(name, content) do
+      model_content = compact_tool_output(name, content, original_content, conversation) do
         artifact_id ||= conversation.store_tool_output_artifact(tool_name: name, content: original_content)
       end
       record_context_budget(conversation, name, before: original_content, after: model_content)
@@ -127,8 +148,73 @@ module Kward
       model_content
     end
 
+    def metadata_for(name)
+      tool = @tools[name.to_s]
+      return unknown_tool_metadata(name) unless tool
+
+      tool_metadata(tool)
+    end
+
     private
 
+    def schema_with_metadata(tool)
+      tool.schema.merge(metadata: tool_metadata(tool))
+    end
+
+    def tool_metadata(tool)
+      if tool.is_a?(Tools::MCPTool)
+        {
+          source: "mcp",
+          displayName: tool.display_name,
+          serverName: tool.server_name,
+          remoteName: tool.remote_name
+        }
+      else
+        {
+          source: source_for_tool(tool),
+          displayName: tool.name
+        }
+      end
+    end
+
+    def source_for_tool(tool)
+      case tool
+      when Tools::WebSearch, Tools::FetchContent, Tools::FetchRaw
+        "web"
+      when Tools::ReadSkill
+        "skill"
+      when Tools::AskUserQuestion
+        "ui"
+      else
+        "builtin"
+      end
+    end
+
+    def unknown_tool_metadata(name)
+      {
+        source: "unknown",
+        displayName: name.to_s
+      }
+    end
+
+    def compact_tool_output(name, content, original_content, conversation, &store_artifact)
+      before = run_hook("tool_output_compact_before", conversation, payload: {
+        tool_name: name,
+        bytes: content.bytesize,
+        duplicate: content != original_content
+      })
+      return content if before.denied? || before.approval_required?
+
+      compacted = @tool_output_compactor.compact(name, content, &store_artifact)
+      run_hook("tool_output_compact_after", conversation, payload: {
+        tool_name: name,
+        bytes_before: content.bytesize,
+        bytes_after: compacted.bytesize,
+        compacted: compacted != content
+      }) if compacted != content
+      compacted
+    end
+
     def record_context_budget(conversation, name, before:, after:)
       meter = conversation.respond_to?(:context_budget_meter) ? conversation.context_budget_meter : @context_budget_meter
       return unless meter
@@ -161,10 +247,184 @@ module Kward
       )
     end
 
+    def execute_tool_with_hooks(tool, name, args, tool_call, conversation, cancellation)
+      args = run_shell_before_hooks(name, args, tool_call, conversation, cancellation)
+      run_file_change_before_hooks(name, args, tool_call, conversation, cancellation)
+      run_mcp_before_hooks(name, args, tool_call, conversation, cancellation)
+      content = tool.call(args, conversation, cancellation: cancellation)
+      run_mcp_after_hooks(name, args, content, conversation)
+      run_shell_after_hooks(name, args, content, conversation)
+      run_file_change_after_hooks(name, args, content, conversation)
+      run_hook("tool_call_after", conversation, payload: tool_payload(name, args, tool_call).merge(content: content.to_s))
+      content
+    rescue HookDenied => e
+      e.message
+    rescue StandardError => e
+      run_mcp_error_hooks(name, args, e, conversation)
+      run_hook("tool_call_error", conversation, payload: tool_payload(name, args, tool_call).merge(error: e.message))
+      raise
+    end
+
+    def run_mcp_before_hooks(name, args, tool_call, conversation, cancellation)
+      return unless mcp_tool?(name)
+
+      result = run_hook("mcp_tool_before", conversation, payload: mcp_payload(name, args))
+      if result.denied?
+        raise HookDenied, hook_denied_content(result, "MCP tool denied")
+      end
+      if result.approval_required? && hook_approval_denied?(result, tool_call, name, args, cancellation)
+        raise HookDenied, hook_denied_content(result, "MCP tool approval denied")
+      end
+    end
+
+    def run_mcp_after_hooks(name, args, content, conversation)
+      return unless mcp_tool?(name)
+
+      run_hook("mcp_tool_after", conversation, payload: mcp_payload(name, args).merge(content: content.to_s))
+    end
+
+    def run_mcp_error_hooks(name, args, error, conversation)
+      return unless mcp_tool?(name)
+
+      run_hook("mcp_tool_error", conversation, payload: mcp_payload(name, args).merge(error: error.message))
+    end
+
+    def run_shell_before_hooks(name, args, tool_call, conversation, cancellation)
+      return args unless name.to_s == "run_shell_command"
+
+      result = run_hook("shell_command_before", conversation, payload: shell_payload(args))
+      if result.denied?
+        raise HookDenied, hook_denied_content(result, "shell command denied")
+      end
+      if result.approval_required? && hook_approval_denied?(result, tool_call, name, args, cancellation)
+        raise HookDenied, hook_denied_content(result, "shell command approval denied")
+      end
+      shell_arguments(result.payload, args)
+    end
+
+    def run_shell_after_hooks(name, args, content, conversation)
+      return unless name.to_s == "run_shell_command"
+
+      run_hook("shell_command_after", conversation, payload: shell_payload(args).merge(content: content.to_s))
+    end
+
+    def run_file_change_before_hooks(name, args, tool_call, conversation, cancellation)
+      return unless ToolCall.file_change_tool?(name)
+
+      result = run_hook("file_change_before", conversation, payload: file_change_payload(name, args))
+      if result.denied?
+        raise HookDenied, hook_denied_content(result, "file change denied")
+      end
+      if result.approval_required? && hook_approval_denied?(result, tool_call, name, args, cancellation)
+        raise HookDenied, hook_denied_content(result, "file change approval denied")
+      end
+    end
+
+    def run_file_change_after_hooks(name, args, content, conversation)
+      return unless ToolCall.file_change_tool?(name)
+      return unless content.to_s.start_with?("Wrote ", "Edited ")
+
+      run_hook("file_change_after", conversation, payload: file_change_payload(name, args).merge(content: content.to_s))
+    end
+
+    HookDenied = Class.new(StandardError)
+
+    def run_hook(name, conversation, payload: {})
+      return Hooks::Manager::Result.new(event: nil, decision: Hooks::Decision.allow, decisions: [], warnings: [], messages: [], payload: payload) unless @hook_manager
+
+      @hook_manager.run(Hooks::Event.new(
+        name: name,
+        workspace: { root: @workspace.respond_to?(:root) ? @workspace.root.to_s : nil },
+        payload: payload
+      ), context: @hook_context || default_hook_context(conversation))
+    end
+
+    def default_hook_context(conversation)
+      return nil unless defined?(PluginRegistry::Context)
+
+      PluginRegistry::Context.new(conversation: conversation, workspace_root: @workspace.respond_to?(:root) ? @workspace.root.to_s : Dir.pwd)
+    end
+
+    def tool_payload(name, args, tool_call)
+      metadata = metadata_for(name)
+      {
+        tool_name: name,
+        arguments: args,
+        tool_call_id: tool_call["id"] || tool_call[:id],
+        source: metadata[:source] || metadata["source"],
+        server_name: metadata[:serverName] || metadata["serverName"],
+        remote_name: metadata[:remoteName] || metadata["remoteName"]
+      }.compact
+    end
+
+    def hook_arguments(result, fallback)
+      payload_arguments = result.payload[:arguments] || result.payload["arguments"]
+      payload_arguments.is_a?(Hash) ? payload_arguments : fallback
+    end
+
+    def mcp_payload(name, args)
+      tool_payload(name, args, {}).slice(:tool_name, :arguments, :source, :server_name, :remote_name)
+    end
+
+    def shell_payload(args)
+      {
+        tool_name: "run_shell_command",
+        command: args[:command] || args["command"],
+        timeout_seconds: args[:timeout_seconds] || args["timeout_seconds"] || Workspace::DEFAULT_COMMAND_TIMEOUT_SECONDS,
+        cwd: @workspace.respond_to?(:root) ? @workspace.root.to_s : nil
+      }.compact
+    end
+
+    def file_change_payload(name, args)
+      operation = name.to_s.start_with?("edit") ? "edit" : "write"
+      path = args[:path] || args["path"]
+      payload = {
+        tool_name: name,
+        operation: operation,
+        path: path,
+        files: [{ path: path, operation: operation }]
+      }
+      if operation == "edit"
+        payload[:edits] = args[:edits] || args["edits"]
+      else
+        payload[:content] = args[:content] || args["content"]
+      end
+      payload.compact
+    end
+
+    def shell_arguments(payload, fallback)
+      fallback.merge(
+        command: payload[:command] || payload["command"] || fallback[:command] || fallback["command"],
+        timeout_seconds: payload[:timeout_seconds] || payload["timeout_seconds"] || fallback[:timeout_seconds] || fallback["timeout_seconds"]
+      )
+    end
+
+    def hook_denied_content(result, fallback)
+      "Declined: #{result.decision.message || fallback}"
+    end
+
+    def hook_approval_denied?(result, tool_call, name, args, cancellation)
+      return true unless @tool_approval
+
+      approval_args = args.merge("hook_message" => result.decision.message)
+      @tool_approval.call(tool_call: tool_call, name: name, args: approval_args, cancellation: cancellation) == false
+    end
+
+    def mcp_tool?(name)
+      metadata = metadata_for(name)
+      (metadata[:source] || metadata["source"]).to_s == "mcp"
+    end
+
     def mutation_tool?(name)
       ToolCall.write_lock_required?(name)
     end
 
+    def tool_approval_denied?(tool_call, name, args, cancellation)
+      return false unless @tool_approval
+
+      @tool_approval.call(tool_call: tool_call, name: name, args: args, cancellation: cancellation) == false
+    end
+
     def write_lock_owned?
       return true unless @write_lock
 
@@ -182,6 +442,7 @@ module Kward
         "list_directory", "read_file", "write_file", "edit_file", "run_shell_command", "code_search", "summarize_file_structure", "context_for_task", "context_budget_stats", "retrieve_tool_output"
       )
       tools.concat(@tools.values_at("web_search", "fetch_content", "fetch_raw")) if web_search_available?
+      tools.concat(@tools.values.select { |tool| tool.is_a?(Tools::MCPTool) })
       tools << @tools["read_skill"] if skills_available?
       tools << @tools["ask_user_question"] if ask_user_question_available?
       tools.compact
@@ -192,9 +453,9 @@ module Kward
         Tools::WebSearch.new(web_search: @web_search),
         Tools::FetchContent.new(web_fetch: @web_fetch),
         Tools::FetchRaw.new(web_fetch: @web_fetch),
-        Tools::ReadSkill.new,
+        Tools::ReadSkill.new(skills: discovered_skills),
         Tools::AskUserQuestion.new(prompt: @prompt)
-      ]
+      ] + mcp_tool_values
     end
 
     def core_tools
@@ -219,9 +480,36 @@ module Kward
       true
     end
 
+    def discovered_skills(workspace_root: nil)
+      return @skills unless @skills.nil?
+
+      @discovered_skills ||= {}
+      root = workspace_root || (@workspace.respond_to?(:root) ? @workspace.root : Dir.pwd)
+      @discovered_skills[root] ||= ConfigFiles.skills(workspace_root: root)
+    end
+
     def skills_available?
-      skills = @skills.nil? ? ConfigFiles.skills : @skills
-      skills.any?
+      discovered_skills.any?
+    end
+
+    def mcp_tool_values
+      @mcp_tool_values ||= build_mcp_tools
+    end
+
+    def build_mcp_tools
+      Array(@mcp_clients).flat_map do |client|
+        client.list_tools.map do |tool|
+          Tools::MCPTool.new(server_name: client.name, client: client, tool: tool)
+        end
+      rescue StandardError => e
+        @telemetry_logger.log(
+          "mcp",
+          "server_unavailable",
+          "server" => client.respond_to?(:name) ? client.name : "unknown",
+          "error" => e.message
+        )
+        []
+      end
     end
 
     def ask_user_question_available?

data/lib/kward/tools/search/code.rb

@@ -5,7 +5,9 @@ require "net/http"
 require "open3"
 require "pathname"
 require "uri"
+require_relative "../../path_guard"
 require_relative "../../config_files"
+require_relative "web"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -24,7 +26,7 @@ module Kward
     ACTIONS = %w[package_search github_search repo_clone repo_search repo_read list_cache refresh_cache clear_cache].freeze
 
     # Creates an object for code search and repository cache operations.
-    def initialize(cache_root: nil, http_client: NetHttpClient.new, git_runner: GitRunner.new, max_output_bytes: MAX_OUTPUT_BYTES)
+    def initialize(cache_root: nil, http_client: WebSearch::NetHttpClient.new(user_agent: "Kward code_search"), git_runner: GitRunner.new, max_output_bytes: MAX_OUTPUT_BYTES)
       @cache_root = File.expand_path(cache_root || ConfigFiles.code_search_cache_dir)
       @http_client = http_client
       @git_runner = git_runner
@@ -49,26 +51,6 @@ module Kward
       "Error: code_search failed: #{redact(e.message)}"
     end
 
-    # HTTP adapter used by code search registry/package lookups.
-    class NetHttpClient
-      def get_json(url, headers: {})
-        JSON.parse(get_text(url, headers: headers.merge("Accept" => "application/json")))
-      end
-
-      def get_text(url, headers: {})
-        uri = URI(url)
-        request = Net::HTTP::Get.new(uri)
-        request["User-Agent"] = "Kward code_search"
-        headers.each { |key, val| request[key] = val }
-        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: HTTP_TIMEOUT_SECONDS, read_timeout: HTTP_TIMEOUT_SECONDS) do |http|
-          http.request(request)
-        end
-        raise "HTTP #{response.code} from #{uri.host}" unless response.is_a?(Net::HTTPSuccess)
-
-        response.body
-      end
-    end
-
     # Git command adapter used by repository cache operations.
     class GitRunner
       def run(*args, chdir: nil)
@@ -376,7 +358,7 @@ module Kward
     end
 
     def inside_root?(root, path)
-      path == root || path.start_with?(root + File::SEPARATOR)
+      PathGuard.inside?(path, root)
     end
 
     def inside_cache?(path)

data/lib/kward/tools/search/web.rb

@@ -54,7 +54,10 @@ module Kward
       return "Error: queries must be an array with 1-#{MAX_QUERIES} strings" unless valid_queries?(queries)
 
       max_results = bounded_max_results(args_value(args, "max_results") || args_value(args, "num_results"))
-      provider = normalize_provider(args_value(args, "provider") || config_value("provider") || "auto")
+      provider_value = args_value(args, "provider")
+      provider_value = config_value("provider") if provider_value.nil?
+      provider_value = "auto" if provider_value.nil? || provider_value.to_s.empty?
+      provider = normalize_provider(provider_value)
       return "Error: provider must be one of: #{PROVIDERS.join(", ")}" unless provider
 
       options = {
@@ -549,8 +552,10 @@ module Kward
 
     def args_value(args, key)
       return nil unless args.is_a?(Hash)
+      return args[key] if args.key?(key)
+      return args[key.to_sym] if args.key?(key.to_sym)
 
-      args[key] || args[key.to_sym]
+      nil
     end
 
     def success?(response)
@@ -717,10 +722,26 @@ module Kward
     class NetHttpClient
       Response = Struct.new(:code, :body, :headers, keyword_init: true)
 
+      def initialize(user_agent: nil)
+        @user_agent = user_agent
+      end
+
       def get(url, headers: {})
         request(url, Net::HTTP::Get, headers: headers)
       end
 
+      def get_json(url, headers: {})
+        JSON.parse(get_text(url, headers: headers.merge("Accept" => "application/json")))
+      end
+
+      def get_text(url, headers: {})
+        uri = URI.parse(url)
+        response = get(uri.to_s, headers: headers)
+        raise "HTTP #{response.code} from #{uri.host}" unless success?(response.code)
+
+        response.body
+      end
+
       def post(url, form:, headers: {})
         request(url, Net::HTTP::Post, headers: headers) do |http_request|
           http_request.set_form_data(form)
@@ -739,12 +760,17 @@ module Kward
         uri = URI.parse(url)
         Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: HTTP_TIMEOUT_SECONDS, read_timeout: HTTP_TIMEOUT_SECONDS) do |http|
           http_request = request_class.new(uri)
+          http_request["User-Agent"] = @user_agent if @user_agent
           headers.each { |key, value| http_request[key] = value }
           yield http_request if block_given?
           response = http.request(http_request)
           Response.new(code: response.code, body: response.body, headers: response.each_header.to_h)
         end
       end
+
+      def success?(code)
+        code.to_i.between?(200, 299)
+      end
     end
   end
 end