kward 0.77.0 → 0.79.0

data/lib/kward/tab_driver.rb

@@ -0,0 +1,87 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Adapts a session-backed agent to the tab runtime interface. Plugin tab
+  # drivers implement the same small surface without becoming Kward sessions.
+  class SessionTabDriver
+    attr_reader :session, :agent
+
+    def initialize(session:, agent:)
+      @session = session
+      @agent = agent
+    end
+
+    def messages
+      agent.conversation.messages
+    end
+
+    def conversation
+      agent.conversation
+    end
+
+    def submit(input, display_input:, cancellation:, steering: nil, &block)
+      options = { cancellation: cancellation }
+      options[:display_input] = display_input unless display_input.nil?
+      options[:steering] = steering if steering
+      agent.ask(input, **options, &block)
+    end
+
+    def descriptor
+      { "kind" => "session", "session_path" => session.path }
+    end
+
+    def session?
+      true
+    end
+
+    def supports_steering?
+      true
+    end
+
+    def assistant_label
+      nil
+    end
+  end
+
+  # Represents a persisted plugin tab whose provider plugin is unavailable.
+  # Its descriptor is retained so reinstalling the plugin restores the tab.
+  class UnavailableTabDriver
+    attr_reader :descriptor
+
+    def initialize(descriptor:, message:)
+      @descriptor = descriptor
+      @message = message
+    end
+
+    def messages
+      [{ role: "assistant", content: @message }]
+    end
+
+    def submit(*)
+      raise @message
+    end
+
+    def session?
+      false
+    end
+
+    def supports_steering?
+      false
+    end
+
+    def assistant_label
+      "Plugin"
+    end
+  end
+
+  # Dependencies made available to a plugin tab factory. The host deliberately
+  # exposes provider transport and frontend-neutral facts, not CLI internals or
+  # workspace session state.
+  class PluginTabHost
+    attr_reader :client, :workspace_root
+
+    def initialize(client:, workspace_root:)
+      @client = client
+      @workspace_root = workspace_root
+    end
+  end
+end

data/lib/kward/tab_store.rb

@@ -5,32 +5,45 @@ require_relative "private_file"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Persists the terminal UI's open session tabs per workspace.
+  # Persists the terminal UI's open tabs per workspace.
   class TabStore
+    VERSION = 2
+
     def initialize(config_dir: ConfigFiles.config_dir, cwd: Dir.pwd)
       @config_dir = config_dir
       @cwd = File.expand_path(cwd)
     end
 
     def load
-      return { "session_paths" => [], "active_index" => 0 } unless File.file?(path)
+      return empty_state unless File.file?(path)
 
       data = JSON.parse(File.read(path))
-      paths = Array(data["session_paths"]).map(&:to_s).reject(&:empty?)
-      labels = Array(data["labels"]).map(&:to_s)
-      active_index = data["active_index"].to_i
-      { "session_paths" => paths, "labels" => labels, "active_index" => active_index }
+      return typed_state(data) if data["tabs"].is_a?(Array)
+
+      legacy_state(data)
     rescue JSON::ParserError
-      { "session_paths" => [], "active_index" => 0 }
+      empty_state
     end
 
-    def save(session_paths:, active_index:, labels: [])
-      paths = Array(session_paths).map(&:to_s).reject(&:empty?)
+    # `session_paths` remains supported for callers and layouts written before
+    # typed tab descriptors were introduced.
+    def save(session_paths: nil, tabs: nil, active_index:, labels: [])
+      tabs ||= Array(session_paths).filter_map.with_index do |session_path, index|
+        path = session_path.to_s
+        next if path.empty?
+
+        {
+          "kind" => "session",
+          "session_path" => path,
+          "label" => Array(labels)[index].to_s
+        }
+      end
+      tabs = normalize_tabs(tabs)
       PrivateFile.write_json(path, {
+        "version" => VERSION,
         "cwd" => @cwd,
-        "session_paths" => paths,
-        "labels" => Array(labels).map(&:to_s),
-        "active_index" => [[active_index.to_i, 0].max, [paths.length - 1, 0].max].min
+        "tabs" => tabs,
+        "active_index" => [[active_index.to_i, 0].max, [tabs.length - 1, 0].max].min
       })
     end
 
@@ -40,6 +53,55 @@ module Kward
 
     private
 
+    def empty_state
+      { "tabs" => [], "session_paths" => [], "labels" => [], "active_index" => 0 }
+    end
+
+    def typed_state(data)
+      tabs = normalize_tabs(data["tabs"])
+      state_for(tabs, data["active_index"])
+    end
+
+    def legacy_state(data)
+      paths = Array(data["session_paths"]).map(&:to_s).reject(&:empty?)
+      labels = Array(data["labels"]).map(&:to_s)
+      tabs = paths.each_with_index.map do |session_path, index|
+        { "kind" => "session", "session_path" => session_path, "label" => labels[index].to_s }
+      end
+      state_for(tabs, data["active_index"])
+    end
+
+    def state_for(tabs, active_index)
+      {
+        "tabs" => tabs,
+        "session_paths" => tabs.filter_map { |tab| tab["session_path"] if tab["kind"] == "session" },
+        "labels" => tabs.map { |tab| tab["label"].to_s },
+        "active_index" => [[active_index.to_i, 0].max, [tabs.length - 1, 0].max].min
+      }
+    end
+
+    def normalize_tabs(tabs)
+      session_paths = {}
+
+      Array(tabs).filter_map do |tab|
+        next unless tab.is_a?(Hash)
+
+        normalized = tab.transform_keys(&:to_s)
+        kind = normalized["kind"].to_s
+        next if kind.empty?
+        next if kind == "session" && normalized["session_path"].to_s.empty?
+
+        if kind == "session"
+          session_path = File.expand_path(normalized["session_path"].to_s, @cwd)
+          next if session_paths[session_path]
+
+          session_paths[session_path] = true
+        end
+
+        normalized
+      end
+    end
+
     def workspace_key
       Digest::SHA256.hexdigest(@cwd)[0, 24]
     end

data/lib/kward/tools/code_search.rb

@@ -37,7 +37,11 @@ module Kward
             },
             path: {
               type: "string",
-              description: "Repo-relative path."
+              description: "Repo-relative path; inferred from GitHub blob URLs when omitted."
+            },
+            ref: {
+              type: "string",
+              description: "Git branch, tag, or commit; inferred from GitHub blob URLs when omitted."
             },
             start_line: {
               type: "integer",
@@ -63,7 +67,9 @@ module Kward
       # Executes the tool and returns model-facing output text.
       def call(args, _conversation, cancellation: nil)
         cancellation&.raise_if_cancelled!
-        @code_search.call(args)
+        return @code_search.call(args) unless cancellation
+
+        @code_search.call(args, cancellation: cancellation)
       end
     end
   end

data/lib/kward/tools/fetch_content.rb

@@ -12,7 +12,7 @@ module Kward
         @web_fetch = web_fetch
         super(
           "fetch_content",
-          "Fetch a specific URL and extract readable bounded content.",
+          "Fetch a specific URL and extract readable bounded content, including links and simple tables.",
           properties: {
             url: {
               type: "string",
@@ -34,7 +34,9 @@ module Kward
 
       # Executes the tool and returns model-facing output text.
       def call(args, _conversation, cancellation: nil)
-        @web_fetch.fetch_content(args)
+        return @web_fetch.fetch_content(args) unless cancellation
+
+        @web_fetch.fetch_content(args, cancellation: cancellation)
       end
     end
   end

data/lib/kward/tools/fetch_raw.rb

@@ -33,7 +33,9 @@ module Kward
 
       # Executes the tool and returns model-facing output text.
       def call(args, _conversation, cancellation: nil)
-        @web_fetch.fetch_raw(args)
+        return @web_fetch.fetch_raw(args) unless cancellation
+
+        @web_fetch.fetch_raw(args, cancellation: cancellation)
       end
     end
   end

data/lib/kward/tools/registry.rb

@@ -22,6 +22,7 @@ require_relative "search/web"
 require_relative "search/web_fetch"
 require_relative "tool_call"
 require_relative "../mcp/server_config"
+require_relative "../permissions/policy"
 require_relative "../telemetry/logger"
 require_relative "../tool_output_compactor"
 require_relative "../workspace"
@@ -48,6 +49,19 @@ module Kward
   # explicit tool errors.
   # @api public
   class ToolRegistry
+    CORE_TOOL_NAMES = %w[
+      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
+    ].freeze
+
     # Tool schemas advertised to the model for the current frontend and config.
     #
     # @return [Array<Hash>] tool schemas currently advertised to the model
@@ -64,7 +78,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, 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)
+    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, tool_output_compactor: ToolOutputCompactor.new, telemetry_logger: TelemetryLogger.new, context_budget_meter: nil, mcp_clients: nil, tool_approval: nil, approval_for_allowed_tools: false, permission_policy: nil, hook_manager: nil, hook_context: nil)
       @workspace = workspace
       @prompt = prompt
       @web_search = web_search
@@ -78,6 +92,8 @@ module Kward
       @telemetry_logger = telemetry_logger
       @context_budget_meter = context_budget_meter
       @tool_approval = tool_approval
+      @approval_for_allowed_tools = approval_for_allowed_tools == true
+      @permission_policy = permission_policy || Permissions::Policy.from_config(ConfigFiles.read_config)
       @hook_manager = hook_manager
       @hook_context = hook_context
       @mcp_clients = if mcp_clients
@@ -114,10 +130,25 @@ module Kward
                              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 tool_approval_denied?(tool_call, name, args, cancellation)
-                             "Declined: tool execution denied by user: #{name}"
                            else
-                             execute_tool_with_hooks(tool, name, args, tool_call, conversation, cancellation)
+                             permission_decision = @permission_policy.decision_for(name, args, source: source_for_tool(tool))
+                             if permission_decision.denied?
+                               "Declined: #{permission_decision.reason}: #{name}"
+                             elsif permission_decision.approval_required?
+                               approval = permission_approval_result(tool_call, name, args, cancellation)
+                               if approval == :allow_for_session
+                                 @permission_policy.allow_for_session!(name)
+                                 execute_tool_with_hooks(tool, name, args, tool_call, conversation, cancellation)
+                               elsif approval == true
+                                 execute_tool_with_hooks(tool, name, args, tool_call, conversation, cancellation)
+                               else
+                                 approval_denied_content(approval, name)
+                               end
+                             elsif @approval_for_allowed_tools && tool_approval_denied?(tool_call, name, args, cancellation)
+                               "Declined: tool execution denied by user: #{name}"
+                             else
+                               execute_tool_with_hooks(tool, name, args, tool_call, conversation, cancellation)
+                             end
                            end
                          else
                            "Unknown tool: #{name}"
@@ -184,6 +215,8 @@ module Kward
 
     def source_for_tool(tool)
       case tool
+      when Tools::MCPTool
+        "mcp"
       when Tools::WebSearch, Tools::FetchContent, Tools::FetchRaw
         "web"
       when Tools::ReadSkill
@@ -420,6 +453,19 @@ module Kward
       (metadata[:source] || metadata["source"]).to_s == "mcp"
     end
 
+    def permission_approval_result(tool_call, name, args, cancellation)
+      return false unless @tool_approval
+
+      @tool_approval.call(tool_call: tool_call, name: name, args: args, cancellation: cancellation)
+    end
+
+    def approval_denied_content(approval, name)
+      message = approval[:denied_message] if approval.is_a?(Hash)
+      return "Declined: #{message}" unless message.to_s.empty?
+
+      "Declined: tool execution denied by user: #{name}"
+    end
+
     def tool_approval_denied?(tool_call, name, args, cancellation)
       return false unless @tool_approval
 
@@ -429,13 +475,15 @@ module Kward
     def build_tools
       tools = all_tools
       tools = tools.select { |tool| @allowed_tool_names.include?(tool.name) } if @allowed_tool_names
-      tools.to_h { |tool| [tool.name, tool] }
+      tools.each_with_object({}) do |tool, result|
+        raise ArgumentError, "Duplicate tool name: #{tool.name}" if result.key?(tool.name)
+
+        result[tool.name] = tool
+      end
     end
 
     def build_schema_tools
-      tools = @tools.values_at(
-        "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 = @tools.values_at(*CORE_TOOL_NAMES)
       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?

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

@@ -33,7 +33,10 @@ module Kward
       @max_output_bytes = max_output_bytes
     end
 
-    def call(args)
+    def call(args = nil, cancellation: nil, **keyword_args)
+      args ||= keyword_args
+      cancellation&.raise_if_cancelled!
+      @cancellation = cancellation
       action = value(args, "action").to_s
       return "Error: action must be one of: #{ACTIONS.join(", ")}" unless ACTIONS.include?(action)
 
@@ -47,6 +50,8 @@ module Kward
       when "refresh_cache" then refresh_cache(args)
       when "clear_cache" then clear_cache(args)
       end
+    rescue Cancellation::CancelledError
+      raise
     rescue StandardError => e
       "Error: code_search failed: #{redact(e.message)}"
     end
@@ -129,13 +134,16 @@ module Kward
       query = value(args, "query").to_s
       return "Error: query is required" if query.strip.empty?
 
-      path, = ensure_repo(repo, refresh: false)
+      path, revision = synchronized_repo(repo, value(args, "ref") || repo[:requested_ref])
       max_results = bounded_max_results(value(args, "max_results"))
       context = bounded_integer(value(args, "context_lines"), DEFAULT_CONTEXT_LINES, 0, 5)
       matches = search_files(path, query, max_results: max_results, context_lines: context)
-      return "Error: no matches found in #{repo[:full_name]}" if matches.empty?
+      if matches.empty?
+        suffix = revision == "unknown" ? "" : " at #{revision}"
+        return "Error: no matches found in #{repo[:full_name]}#{suffix}"
+      end
 
-      lines = ["# Code search", "- Repository: #{repo[:full_name]}", "- Query: #{query}", ""]
+      lines = ["# Code search", "- Repository: #{repo[:full_name]}", "- Revision: #{revision}", "- Query: #{query}", ""]
       matches.each do |match|
         lines << "## #{match[:path]}:#{match[:line]}"
         lines << "```"
@@ -148,10 +156,10 @@ module Kward
     def repo_read(args)
       repo = require_repo(args)
       return repo if repo.is_a?(String)
-      file = value(args, "path") || value(args, "file")
+      file = value(args, "path") || value(args, "file") || repo[:requested_path]
       return "Error: path is required" if file.to_s.empty?
 
-      root, = ensure_repo(repo, refresh: false)
+      root, revision = synchronized_repo(repo, value(args, "ref") || repo[:requested_ref])
       target = safe_existing_path(root, file.to_s)
       return "Error: path is not a file: #{file}" unless File.file?(target)
       return "Error: file is too large: #{file}" if File.size(target) > MAX_FILE_BYTES
@@ -161,7 +169,7 @@ module Kward
       lines = File.readlines(target, chomp: true)
       selected = lines.drop(start_line - 1).first(line_count)
       numbered = selected.each_with_index.map { |line, index| "#{start_line + index}: #{line}" }
-      truncate((["# Code read", "- Repository: #{repo[:full_name]}", "- Path: #{file}", ""] + numbered).join("\n"))
+      truncate((["# Code read", "- Repository: #{repo[:full_name]}", "- Revision: #{revision}", "- Path: #{file}", ""] + numbered).join("\n"))
     rescue ArgumentError => e
       "Error: #{e.message}"
     end
@@ -231,10 +239,7 @@ module Kward
       path = cache_path(repo)
       FileUtils.mkdir_p(@cache_root, mode: 0o700)
       if Dir.exist?(File.join(path, ".git"))
-        if refresh
-          @git_runner.run("fetch", "--depth", "1", "origin", chdir: path)
-          @git_runner.run("reset", "--hard", "FETCH_HEAD", chdir: path)
-        end
+        synchronize_checkout(path) if refresh
         return [path, false]
       end
 
@@ -243,11 +248,35 @@ module Kward
       [path, true]
     end
 
+    def synchronized_repo(repo, ref)
+      path = cache_path(repo)
+      lock_path = "#{path}.lock"
+      FileUtils.mkdir_p(@cache_root, mode: 0o700)
+      File.open(lock_path, File::RDWR | File::CREAT, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        path, created = ensure_repo(repo, refresh: false)
+        synchronize_checkout(path, ref: ref) unless created && ref.to_s.empty?
+        revision = @git_runner.run("rev-parse", "HEAD", chdir: path).strip
+        revision = "unknown" if revision.empty?
+        [path, revision]
+      end
+    end
+
+    def synchronize_checkout(path, ref: nil)
+      if ref.to_s.empty?
+        @git_runner.run("fetch", "--depth", "1", "origin", chdir: path)
+      else
+        @git_runner.run("fetch", "--depth", "1", "origin", ref.to_s, chdir: path)
+      end
+      @git_runner.run("reset", "--hard", "FETCH_HEAD", chdir: path)
+    end
+
     def search_files(root, query, max_results:, context_lines:)
       matches = []
       base = File.realpath(root)
       scanned = 0
       Dir.glob(File.join(root, "**", "*"), File::FNM_DOTMATCH).sort.each do |path|
+        @cancellation&.raise_if_cancelled!
         next if matches.length >= max_results || scanned >= MAX_SCANNED_FILES
         next if skip_search_path?(base, path)
 
@@ -327,7 +356,12 @@ module Kward
       return nil unless owner.match?(%r{\A[A-Za-z0-9_.-]+\z}) && name.match?(%r{\A[A-Za-z0-9_.-]+\z})
 
       full_name = "#{owner}/#{name}"
-      { full_name: full_name, html_url: "https://github.com/#{full_name}", clone_url: "https://github.com/#{full_name}.git" }
+      result = { full_name: full_name, html_url: "https://github.com/#{full_name}", clone_url: "https://github.com/#{full_name}.git" }
+      if parts[2] == "blob" && parts.length >= 5
+        result[:requested_ref] = parts[3]
+        result[:requested_path] = parts[4..].join("/")
+      end
+      result
     rescue URI::InvalidURIError
       nil
     end

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

@@ -4,6 +4,7 @@ require "net/http"
 require "nokogiri"
 require "uri"
 require_relative "../../config_files"
+require_relative "../../http"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -49,7 +50,9 @@ module Kward
       true
     end
 
-    def search(args)
+    def search(args = nil, cancellation: nil, **keyword_args)
+      args ||= keyword_args
+      cancellation&.raise_if_cancelled!
       queries = args_value(args, "queries")
       return "Error: queries must be an array with 1-#{MAX_QUERIES} strings" unless valid_queries?(queries)
 
@@ -60,36 +63,44 @@ module Kward
       provider = normalize_provider(provider_value)
       return "Error: provider must be one of: #{PROVIDERS.join(", ")}" unless provider
 
+      recency_value = args_value(args, "recency_filter") || args_value(args, "recencyFilter")
+      recency = normalize_recency(recency_value)
+      return "Error: recency_filter must be one of: day, week, month, year" if recency_value && !recency
+
       options = {
         max_results: max_results,
-        recency_filter: normalize_recency(args_value(args, "recency_filter") || args_value(args, "recencyFilter")),
+        recency_filter: recency,
         domain_filter: normalize_domain_filter(args_value(args, "domain_filter") || args_value(args, "domainFilter")),
         provider: provider
       }
 
-      sections = ["# Web search", "Use fetch_content with a result URL to verify human-readable pages, or fetch_raw for specs, JSON, YAML, XML, and other machine-readable resources."]
+      sections = ["# Web search"]
       failures = []
-      any_results = false
+      succeeded = 0
 
       queries.each do |query|
-        response, error = search_query(query, options)
-        any_results = true if successful_response?(response)
+        cancellation&.raise_if_cancelled!
+        response, error = search_query(query, options, cancellation: cancellation)
+        succeeded += 1 if successful_response?(response)
         failures << "#{query}: #{error}" if error && !successful_response?(response)
         sections << format_query_results(query, response, error)
       end
 
-      unless any_results
+      if succeeded.zero?
         return "Error: web_search found no results\n#{failures.map { |failure| "- #{failure}" }.join("\n")}".strip
       end
 
+      sections.insert(1, "- Queries: #{queries.length}\n- Succeeded: #{succeeded}\n- Failed: #{queries.length - succeeded}")
+      sections.insert(2, "Use fetch_content with a result URL to verify human-readable pages, or fetch_raw for specs, JSON, YAML, XML, and other machine-readable resources.")
       truncate_output(sections.join("\n\n"))
     end
 
     private
 
-    def search_query(query, options)
+    def search_query(query, options, cancellation: nil)
       errors = []
       provider_order(options[:provider]).each do |provider|
+        cancellation&.raise_if_cancelled!
         begin
           response = case provider
                      when "exa"
@@ -514,7 +525,7 @@ module Kward
         lines << answer
       end
 
-      results = response.results || []
+      results = unique_results(response.results || [])
       unless results.empty?
         lines << "Sources:" unless answer.empty?
         results.each_with_index do |result, index|
@@ -527,6 +538,25 @@ module Kward
       lines.join("\n")
     end
 
+    def unique_results(results)
+      seen = {}
+      results.each_with_object([]) do |result, unique|
+        url = clean_result_url(result.url)
+        uri = URI.parse(url)
+        next unless %w[http https].include?(uri.scheme) && uri.host
+
+        uri.fragment = nil
+        key = uri.to_s
+        next if seen[key]
+
+        seen[key] = true
+        result.url = key
+        unique << result
+      rescue URI::InvalidURIError
+        next
+      end
+    end
+
     def answer_from_results(results)
       results.filter_map do |result|
         excerpt = result.excerpt.to_s.strip
@@ -590,7 +620,7 @@ module Kward
       {
         "Accept" => accept,
         "Accept-Language" => "en-US,en;q=0.9",
-        "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+        "User-Agent" => Http.user_agent,
         "Sec-Fetch-Dest" => "document",
         "Sec-Fetch-Mode" => "navigate",
         "Sec-Fetch-Site" => "none",
@@ -720,14 +750,14 @@ module Kward
 
     # HTTP adapter used by web-search providers and fallbacks.
     class NetHttpClient
-      Response = Struct.new(:code, :body, :headers, keyword_init: true)
+      Response = Struct.new(:code, :body, :headers, :truncated, keyword_init: true)
 
-      def initialize(user_agent: nil)
+      def initialize(user_agent: Http.user_agent)
         @user_agent = user_agent
       end
 
-      def get(url, headers: {})
-        request(url, Net::HTTP::Get, headers: headers)
+      def get(url, headers: {}, max_bytes: nil)
+        request(url, Net::HTTP::Get, headers: headers, max_bytes: max_bytes)
       end
 
       def get_json(url, headers: {})
@@ -756,15 +786,28 @@ module Kward
 
       private
 
-      def request(url, request_class, headers: {})
+      def request(url, request_class, headers: {}, max_bytes: nil)
         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)
+          response = nil
+          body = +""
+          truncated = false
+          http.request(http_request) do |http_response|
+            response = http_response
+            http_response.read_body do |chunk|
+              if max_bytes && body.bytesize + chunk.bytesize > max_bytes
+                body << chunk.byteslice(0, max_bytes - body.bytesize)
+                truncated = true
+                break
+              end
+              body << chunk
+            end
+          end
+          Response.new(code: response.code, body: body, headers: response.each_header.to_h, truncated: truncated)
         end
       end