pikuri-core 0.0.3

data/lib/pikuri/tool/parameters.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'did_you_mean'
+
+module Pikuri
+  # Loaded by +lib/tools.rb+ after {Tool} itself is defined; the +class Tool+
+  # reopening below assumes that order.
+  class Tool
+    # Schema for a {Tool}'s arguments. Built up via the fluent
+    # +<required|optional>_<type>+ methods, then frozen by {.build}; serializes
+    # to the OpenAI JSON-Schema shape via {#to_h} and validates LLM-supplied
+    # argument hashes via {#validate}.
+    #
+    # @example
+    #   params = Tool::Parameters.build { |p| p.required_string :query, 'The query.' }
+    #   params.to_h
+    #   # => {type: 'object',
+    #   #     properties: {query: {type: 'string', description: 'The query.'}},
+    #   #     required: ['query']}
+    #   params.validate('query' => 'cats') # => {query: 'cats'}
+    class Parameters
+      # Raised by {Parameters#validate} when arguments do not match the declared
+      # schema. The message lists every problem and reprints the schema, so it
+      # can be fed back to the LLM verbatim as the next tool-call observation.
+      class ValidationError < StandardError; end
+
+      # Yield a fresh builder, freeze it, and return it.
+      #
+      # @yieldparam builder [Parameters]
+      # @return [Parameters] frozen builder, safe to share between calls
+      def self.build
+        builder = new
+        yield builder
+        builder.freeze
+      end
+
+      # @return [Parameters]
+      def initialize
+        @properties = {}
+        @required = []
+      end
+
+      # Freeze the builder along with its internal collections, so post-build
+      # mutation attempts raise +FrozenError+ instead of silently succeeding.
+      #
+      # @return [self]
+      def freeze
+        @properties.freeze
+        @required.freeze
+        super
+      end
+
+      # Add a required +string+ property.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def required_string(name, description)
+        add(name, 'string', description, required: true)
+      end
+
+      # Add an optional +string+ property.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def optional_string(name, description)
+        add(name, 'string', description, required: false)
+      end
+
+      # Add a required +integer+ property. Accepts Integers, Floats with a
+      # zero fractional part (e.g. +1.0+), and base-10 numeric Strings (after
+      # trimming) that resolve to whole numbers; rejects everything else.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def required_integer(name, description)
+        add(name, 'integer', description, required: true)
+      end
+
+      # Add an optional +integer+ property. See {#required_integer} for
+      # accepted shapes.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def optional_integer(name, description)
+        add(name, 'integer', description, required: false)
+      end
+
+      # Add a required +number+ property (JSON-Schema +number+: Integer or
+      # finite Float). Numeric Strings (after trimming) are parsed; NaN and
+      # Infinity are rejected.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def required_number(name, description)
+        add(name, 'number', description, required: true)
+      end
+
+      # Add an optional +number+ property. See {#required_number} for
+      # accepted shapes.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def optional_number(name, description)
+        add(name, 'number', description, required: false)
+      end
+
+      # Add a required +boolean+ property. Accepts Ruby +true+/+false+
+      # as-is, and the literal Strings +"true"+/+"false"+ (some models
+      # surface JSON booleans as Strings) after trimming surrounding
+      # whitespace. Other Strings, numbers, and +nil+ are rejected —
+      # there is no truthy-coercion of +"yes"+ / +0+ / etc.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def required_boolean(name, description)
+        add(name, 'boolean', description, required: true)
+      end
+
+      # Add an optional +boolean+ property. See {#required_boolean} for
+      # accepted shapes.
+      #
+      # @param name [Symbol] property name
+      # @param description [String] human-readable description shown to the LLM
+      # @return [self]
+      def optional_boolean(name, description)
+        add(name, 'boolean', description, required: false)
+      end
+
+      # Schema in OpenAI JSON-Schema shape.
+      #
+      # @return [Hash] +{type: 'object', properties: {...}, required: [...]}+
+      def to_h
+        { type: 'object', properties: @properties, required: @required }
+      end
+
+      # Validate a tool-call argument hash against the declared schema. Returns
+      # a symbol-keyed hash safe to splat as kwargs into a tool's +execute+
+      # Proc; raises {ValidationError} with an LLM-actionable message listing
+      # every missing/unknown/mistyped field and reprinting the schema.
+      #
+      # Strict: unknown keys are rejected (with DidYouMean suggestions), wrong
+      # types are rejected. All issues are collected and reported together so
+      # the LLM can fix them in one round trip.
+      #
+      # @param args [Hash] arguments as decoded from the tool-call JSON; keys
+      #   may be Strings or Symbols
+      # @return [Hash{Symbol=>Object}] validated, symbol-keyed arguments
+      # @raise [ValidationError] if +args+ is not a Hash, contains unknown
+      #   keys, omits a required key, or has a value of the wrong type
+      def validate(args)
+        raise ValidationError, "Arguments must be an object, got #{args.class}." unless args.is_a?(Hash)
+
+        symbolized = args.transform_keys(&:to_sym)
+        errors = []
+        result = {}
+
+        (symbolized.keys - @properties.keys).each do |unknown|
+          errors << unknown_key_error(unknown)
+        end
+
+        @properties.each do |name, schema|
+          if symbolized.key?(name)
+            begin
+              result[name] = coerce(symbolized[name], schema[:type])
+            rescue CoercionError => e
+              errors << "Parameter `#{name}` #{e.message}."
+            end
+          elsif @required.include?(name.to_s)
+            errors << "Missing required parameter `#{name}` (#{schema[:type]}): #{schema[:description]}"
+          end
+        end
+
+        return result if errors.empty?
+
+        raise ValidationError, build_error_message(errors)
+      end
+
+      private
+
+      # Internal coercion failure. Caught by {#validate} and turned into a
+      # {ValidationError} message — never escapes the class.
+      class CoercionError < StandardError; end
+      private_constant :CoercionError
+
+      def add(name, type, description, required:)
+        @properties[name] = { type: type, description: description }
+        @required << name.to_s if required
+        self
+      end
+
+      # Coerce +value+ to a Ruby value matching the JSON-Schema +type+,
+      # returning the coerced value. Raises {CoercionError} on failure.
+      def coerce(value, type)
+        case type
+        when 'string'
+          return value if value.is_a?(String)
+
+          raise CoercionError, type_message('string', value)
+        when 'integer'
+          coerce_integer(value)
+        when 'number'
+          coerce_number(value)
+        when 'boolean'
+          coerce_boolean(value)
+        end
+      end
+
+      def coerce_boolean(value)
+        return value if value == true || value == false
+
+        if value.is_a?(String)
+          case value.strip
+          when 'true'  then return true
+          when 'false' then return false
+          end
+        end
+
+        raise CoercionError, type_message('boolean', value)
+      end
+
+      def coerce_integer(value)
+        case value
+        when Integer
+          value
+        when Float
+          raise CoercionError, type_message('integer', value) unless value.finite? && value.modulo(1).zero?
+
+          value.to_i
+        when String
+          parsed = parse_numeric_string(value)
+          raise CoercionError, type_message('integer', value) unless parsed && parsed.modulo(1).zero?
+
+          parsed.to_i
+        else
+          raise CoercionError, type_message('integer', value)
+        end
+      end
+
+      def coerce_number(value)
+        case value
+        when Integer
+          value
+        when Float
+          raise CoercionError, type_message('number', value) unless value.finite?
+
+          value
+        when String
+          parsed = parse_numeric_string(value)
+          raise CoercionError, type_message('number', value) unless parsed
+
+          parsed
+        else
+          raise CoercionError, type_message('number', value)
+        end
+      end
+
+      # Matches the decimal-numeric subset that JSON allows: optional sign,
+      # mantissa (with optional fractional part), optional decimal exponent.
+      # Rejects hex (+0x10+), underscores (+1_000+), +NaN+, +Infinity+.
+      DECIMAL_NUMERIC = /\A[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?\z/
+      private_constant :DECIMAL_NUMERIC
+
+      # Strict base-10 numeric-string parse. Returns a finite Float, or +nil+
+      # for empty/whitespace/garbage/hex/NaN/Infinity input.
+      def parse_numeric_string(str)
+        trimmed = str.strip
+        return nil unless trimmed.match?(DECIMAL_NUMERIC)
+
+        parsed = Float(trimmed, exception: false)
+        return nil unless parsed&.finite?
+
+        parsed
+      end
+
+      def type_message(type, value)
+        article = type == 'integer' ? 'an' : 'a'
+        "must be #{article} #{type} (got #{value.class}: #{value.inspect})"
+      end
+
+      def unknown_key_error(unknown)
+        suggestion = DidYouMean::SpellChecker
+                     .new(dictionary: @properties.keys.map(&:to_s))
+                     .correct(unknown.to_s).first
+        msg = "Unknown parameter `#{unknown}`."
+        msg += suggestion ? " Did you mean `#{suggestion}`?" : " Valid parameters: #{valid_keys_list}."
+        msg
+      end
+
+      def valid_keys_list
+        @properties.keys.map { |k| "`#{k}`" }.join(', ')
+      end
+
+      def build_error_message(errors)
+        [
+          'Invalid arguments:',
+          *errors.map { |e| "- #{e}" },
+          '',
+          'Expected schema:',
+          *@properties.map { |name, prop|
+            req = @required.include?(name.to_s) ? 'required' : 'optional'
+            "  - `#{name}` (#{prop[:type]}, #{req}): #{prop[:description]}"
+          }
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/pikuri/tool/scraper/fetch_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pikuri
+  class Tool
+    module Scraper
+      # Raised by anything in the scraper stack when a URL cannot be
+      # rendered into Markdown text — HTTP non-2xx, network failure,
+      # redirect-loop, missing +Location+, unsupported content-type, or a
+      # parse failure that reads as "try a different URL" to the LLM.
+      # Catching this in {Tool::WEB_SCRAPE} / {Tool::FETCH} turns the
+      # failure into an +"Error: ..."+ observation; anything else bubbles
+      # up so genuine bugs stay visible.
+      class FetchError < StandardError; end
+    end
+  end
+end

data/lib/pikuri/tool/scraper/html.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'nokogiri'
+require 'readability'
+require 'reverse_markdown'
+
+module Pikuri
+  class Tool
+    module Scraper
+      # HTML → Markdown extractor used by {Simple.visit} when the fetched
+      # response carries an HTML content-type.
+      #
+      # Always renders both views of the page when available:
+      #
+      # 1. JSON-LD section. Any +<script type="application/ld+json">+ node
+      #    whose +@type+ matches a substantive schema.org content type
+      #    (Product, Article, Recipe, ...) is rendered as a header — title,
+      #    metadata bullets (brand, SKU, price, rating, author, published),
+      #    and the +articleBody+/+description+ copy when present.
+      # 2. Readability section. The page is run through +Readability+ +
+      #    +reverse_markdown+, with a +<main>+/+<article>+ fallback for
+      #    pages whose content sits mostly outside +<p>+ tags.
+      #
+      # Concatenated with a horizontal rule, so the LLM gets both the
+      # structured metadata and the rendered body and can pick whichever
+      # is more useful for the task. Trades some duplication (when a
+      # publisher embeds the article body in JSON-LD AND in HTML) for
+      # fewer type-based heuristics on which branch should win — the
+      # earlier "is this Article's +description+ a teaser or the real
+      # body?" carve-out is no longer needed because both end up in
+      # the output regardless.
+      #
+      # Pure parser — no I/O. {.extract} takes an HTML string and returns
+      # Markdown, so tests can drive it against fixture HTML without a
+      # network round-trip.
+      module HTML
+        # @return [Array<String>] schema.org +@type+ values that we treat
+        #   as "the primary entity of this page" when picking a JSON-LD
+        #   node to render. Order does not matter — the first matching
+        #   node wins. Skips noise nodes (Organization, BreadcrumbList,
+        #   WebSite, ...) that ship on most pages but carry no page
+        #   content.
+        INTERESTING_TYPES = %w[
+          Product Article NewsArticle BlogPosting Recipe Event Book Movie
+        ].freeze
+
+        # @return [Array<String>] HTML tags preserved by the readability
+        #   pass. Anything outside this list is stripped before Markdown
+        #   conversion.
+        READABILITY_TAGS = %w[
+          h1 h2 h3 h4 h5 h6 p div span ul ol li blockquote pre code a img
+          strong em b i br hr table thead tbody tr td th
+        ].freeze
+
+        # @return [Array<String>] HTML attributes preserved by the
+        #   readability pass; everything else (class, id, style, data-*)
+        #   is dropped before Markdown conversion
+        READABILITY_ATTRS = %w[href src alt title].freeze
+
+        # @return [Float] minimum +<main>+/+<article>+ to Readability
+        #   text-length ratio that triggers the semantic-container
+        #   fallback in {.readability_to_markdown}. Picked low enough to
+        #   catch the failure mode (Readability collapsing a page that
+        #   uses divs/lists instead of +<p>+ — e.g. +vaadin.com/company+,
+        #   ~5x) but high enough that pages where both produce
+        #   comparable output keep Readability's noise filtering.
+        MAIN_FALLBACK_RATIO = 2.0
+
+        # @return [Integer] minimum text length the
+        #   +<main>+/+<article>+ container must hold before the fallback
+        #   in {.readability_to_markdown} can fire. Below this, the
+        #   ratio comparison is dominated by noise and we'd swap on
+        #   tiny pages where Readability is doing the right thing.
+        MAIN_FALLBACK_MIN_CHARS = 500
+
+        # Render +html+ as Markdown by emitting both the JSON-LD section
+        # (when an interesting node is present) and the readability /
+        # +<main>+ section, joined by a horizontal rule. Either section
+        # may be missing — pages with no JSON-LD return only the
+        # readability output, and a malformed page with no extractable
+        # body returns only the JSON-LD render.
+        #
+        # @param html [String] HTML document body
+        # @return [String] Markdown representation
+        def self.extract(html)
+          sections = [jsonld_section(html), readability_to_markdown(html)]
+          sections.reject! { |s| s.nil? || s.strip.empty? }
+          sections.join("\n\n---\n\n")
+        end
+
+        # Pick the first JSON-LD node whose +@type+ matches one of
+        # {INTERESTING_TYPES} and render it as Markdown. Returns +nil+
+        # when no such node exists, in which case {.extract} emits only
+        # the readability section.
+        #
+        # No content-field gating: a node carrying just +name+/+author+/
+        # +datePublished+ still renders (as a metadata-only header),
+        # because the readability pass independently produces the page
+        # body. That is the trade-off that lets us drop the type-based
+        # "is this teaser or article copy?" heuristics — duplication is
+        # acceptable when both views are available, and the LLM can
+        # pick whichever it needs.
+        #
+        # @param html [String] HTML document body
+        # @return [String, nil] Markdown render of the picked JSON-LD
+        #   node, or +nil+ when nothing matched
+        def self.jsonld_section(html)
+          node = parse_jsonld(html).find do |n|
+            Array(n['@type']).any? { |t| INTERESTING_TYPES.include?(t) }
+          end
+          node ? jsonld_to_markdown(node) : nil
+        end
+
+        # Collect every JSON-LD payload embedded in +html+, flattening
+        # +@graph+ wrappers so callers see one flat array of schema.org
+        # nodes. Malformed JSON blocks are silently skipped — sites
+        # frequently ship broken JSON-LD and we only need at least one
+        # parseable block.
+        #
+        # @param html [String] HTML document body
+        # @return [Array<Hash>] parsed JSON-LD nodes; possibly empty
+        def self.parse_jsonld(html)
+          doc = Nokogiri::HTML(html)
+          blobs = doc.css('script[type="application/ld+json"]').map(&:text)
+
+          blobs.flat_map do |raw|
+            parsed = begin
+              JSON.parse(raw)
+            rescue JSON::ParserError
+              nil
+            end
+            next [] unless parsed
+
+            nodes = parsed.is_a?(Array) ? parsed : [parsed]
+            nodes.flat_map { |n| n['@graph'].is_a?(Array) ? n['@graph'] : [n] }
+          end
+        end
+
+        # Render a single JSON-LD +node+ as Markdown: a top-level title
+        # from +name+/+headline+, a bullet list of common useful fields
+        # (brand, SKU, price, rating, author, published date, ...), the
+        # body copy, and the lead image.
+        #
+        # When the node carries +articleBody+ (the full publisher-supplied
+        # article text), that wins over +description+ — the description
+        # is typically a lede teaser and would just repeat the article's
+        # opening lines.
+        #
+        # @param node [Hash] JSON-LD node, typically picked by
+        #   {.jsonld_section}
+        # @return [String] Markdown representation
+        def self.jsonld_to_markdown(node)
+          out = +''
+          name = node['name'] || node['headline']
+          out << "# #{name}\n\n" if name
+
+          offer  = first_obj(node['offers'])
+          rating = first_obj(node['aggregateRating'])
+          brand  = first_obj_or_string(node['brand'])
+          author = first_obj_or_string(node['author'])
+
+          brand_name  = brand.is_a?(Hash)  ? brand['name']  : brand
+          author_name = author.is_a?(Hash) ? author['name'] : author
+
+          fields = {
+            'Brand'        => brand_name,
+            'SKU'          => node['sku'],
+            'GTIN'         => node['gtin13'] || node['gtin'],
+            'Price'        => [offer['price'], offer['priceCurrency']].compact.join(' '),
+            'Availability' => offer['availability'],
+            'Rating'       => rating['ratingValue'],
+            'Reviews'      => rating['reviewCount'],
+            'Author'       => author_name,
+            'Published'    => node['datePublished']
+          }.reject { |_, v| v.nil? || v.to_s.strip.empty? }
+
+          unless fields.empty?
+            fields.each { |k, v| out << "- **#{k}:** #{v}\n" }
+            out << "\n"
+          end
+
+          if (body = node['articleBody'] || node['description'])
+            out << "#{body}\n\n"
+          end
+
+          if (img = node['image'])
+            img = img.first if img.is_a?(Array)
+            img = img['url'] if img.is_a?(Hash)
+            out << "![image](#{img})\n\n" if img
+          end
+
+          out
+        end
+
+        # Run +Readability+ over +html+ to isolate the main content node,
+        # then convert that to Markdown via +reverse_markdown+. The page
+        # +<title>+ is rendered as a top-level heading.
+        #
+        # When the page uses semantic HTML5 (+<main>+ or +<article>+) but
+        # leaves most of its content outside +<p>+ tags — divs, lists,
+        # spans — Readability's paragraph-density scoring collapses the
+        # extraction to a sliver of the page. In that case we render the
+        # +<main>+/+<article>+ container directly. The fallback only
+        # fires when the container holds substantially more text than
+        # Readability picked up (see {MAIN_FALLBACK_RATIO} /
+        # {MAIN_FALLBACK_MIN_CHARS}); on pages where both agree we keep
+        # Readability so its noise filtering still strips nav/ads/etc.
+        #
+        # @param html [String] HTML document body
+        # @return [String] Markdown representation
+        def self.readability_to_markdown(html)
+          rdoc = Readability::Document.new(
+            html,
+            tags: READABILITY_TAGS,
+            attributes: READABILITY_ATTRS,
+            remove_empty_nodes: true
+          )
+          readability_html = rdoc.content
+          title = rdoc.title
+
+          body_html = main_fallback_html(html, readability_html) || readability_html
+          body = ReverseMarkdown.convert(body_html, unknown_tags: :bypass, github_flavored: true)
+
+          out = +''
+          out << "# #{title.strip}\n\n" if title && !title.strip.empty?
+          out << body
+          out
+        end
+
+        # If +html+ has a +<main>+ or +<article>+ element holding
+        # substantially more text than Readability extracted, return that
+        # container's HTML so the caller can render it instead. Returns
+        # +nil+ when the fallback should not fire — when there is no
+        # semantic container, when it's too small to be meaningful, or
+        # when Readability's output is already comparable.
+        #
+        # @param html [String] full HTML document body, used to locate
+        #   the +<main>+/+<article>+ container
+        # @param readability_html [String] HTML produced by
+        #   +Readability::Document#content+, used as the comparison
+        #   baseline
+        # @return [String, nil] container HTML when the fallback should
+        #   fire, +nil+ otherwise
+        def self.main_fallback_html(html, readability_html)
+          doc = Nokogiri::HTML(html)
+          container = doc.at_css('main') || doc.at_css('article')
+          return nil unless container
+
+          container_text_len = container.text.gsub(/\s+/, ' ').strip.length
+          return nil if container_text_len < MAIN_FALLBACK_MIN_CHARS
+
+          readability_text_len = Nokogiri::HTML(readability_html).text.gsub(/\s+/, ' ').strip.length
+          return nil if container_text_len < MAIN_FALLBACK_RATIO * readability_text_len
+
+          container.to_html
+        end
+        private_class_method :main_fallback_html
+
+        # JSON-LD fields can be a string, hash, or array of either.
+        # Normalize to a single hash (the first one if it's a list) so
+        # callers can +.dig+ safely.
+        #
+        # @param value [Object] raw JSON-LD field value
+        # @return [Hash] empty hash when +value+ does not contain a hash
+        def self.first_obj(value)
+          value = value.first if value.is_a?(Array)
+          value.is_a?(Hash) ? value : {}
+        end
+        private_class_method :first_obj
+
+        # Same idea as {.first_obj} but preserves a bare string (e.g.
+        # +brand: "Apple"+) instead of replacing it with +{}+.
+        #
+        # @param value [Object] raw JSON-LD field value
+        # @return [String, Hash, nil]
+        def self.first_obj_or_string(value)
+          value = value.first if value.is_a?(Array)
+          value
+        end
+        private_class_method :first_obj_or_string
+      end
+    end
+  end
+end

data/lib/pikuri/tool/scraper/pdf.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'pdf-reader'
+require 'stringio'
+
+module Pikuri
+  class Tool
+    module Scraper
+      # PDF → text extractor used by {Simple.visit} when the fetched
+      # response carries +application/pdf+. Wraps the +pdf-reader+ gem:
+      # walk every page, concatenate the extracted text, hand the result
+      # back as a single string the LLM can read.
+      #
+      # Best-effort by design. +pdf-reader+ produces clean text from PDFs
+      # generated from a digital source (LaTeX, Word export, ...) but
+      # returns nothing useful from scanned documents — there is no OCR
+      # in this path. When extraction yields no text we still return an
+      # empty string rather than raising, so the caller's cache stores a
+      # consistent result and the LLM sees an empty observation it can
+      # react to.
+      #
+      # Pure parser — no I/O. {.extract} takes PDF bytes and returns text,
+      # so tests can drive it against an in-memory fixture without
+      # touching the network.
+      module PDF
+        # Render +bytes+ as plain text, one page per paragraph.
+        #
+        # +pdf-reader+ raises a handful of typed exceptions for documents
+        # it cannot parse — broken xrefs ({::PDF::Reader::MalformedPDFError}),
+        # invalid page references ({::PDF::Reader::InvalidPageError}),
+        # encrypted/XFA files ({::PDF::Reader::UnsupportedFeatureError}).
+        # All three describe a property of the PDF the LLM can react to
+        # ("try a different URL"), so we re-raise them as {FetchError} —
+        # same convention as the HTTP layer in {Simple.fetch}. Genuine
+        # bugs in +pdf-reader+ itself surface as their own classes and
+        # crash loud.
+        #
+        # @param bytes [String] raw PDF document (binary string)
+        # @return [String] concatenated page text; possibly empty when
+        #   the PDF carries no extractable text (scanned image, empty
+        #   document)
+        # @raise [FetchError] when +pdf-reader+ refuses the document
+        def self.extract(bytes)
+          reader = ::PDF::Reader.new(StringIO.new(bytes))
+          reader.pages.map { |p| p.text.strip }.reject(&:empty?).join("\n\n")
+        rescue ::PDF::Reader::MalformedPDFError,
+               ::PDF::Reader::InvalidPageError,
+               ::PDF::Reader::UnsupportedFeatureError => e
+          raise FetchError, "PDF rendering failed: #{e.class.name.split('::').last}: #{e.message}"
+        end
+      end
+    end
+  end
+end