context.dev 1.2.0 → 1.4.0

data/rbi/context_dev/models/web_screenshot_params.rbi

@@ -11,10 +11,22 @@ module ContextDev
           T.any(ContextDev::WebScreenshotParams, ContextDev::Internal::AnyHash)
         end
 
+      # A specific URL to screenshot directly, bypassing domain resolution (e.g.,
+      # 'https://example.com/pricing'). When provided, the screenshot is taken of this
+      # exact URL.
+      sig { returns(T.nilable(String)) }
+      attr_reader :direct_url
+
+      sig { params(direct_url: String).void }
+      attr_writer :direct_url
+
       # Domain name to take screenshot of (e.g., 'example.com', 'google.com'). The
       # domain will be automatically normalized and validated.
-      sig { returns(String) }
-      attr_accessor :domain
+      sig { returns(T.nilable(String)) }
+      attr_reader :domain
+
+      sig { params(domain: String).void }
+      attr_writer :domain
 
       # Optional parameter to determine screenshot type. If 'true', takes a full page
       # screenshot capturing all content. If 'false' or not provided, takes a viewport
@@ -37,7 +49,8 @@ module ContextDev
       # Optional parameter to specify which page type to screenshot. If provided, the
       # system will scrape the domain's links and use heuristics to find the most
       # appropriate URL for the specified page type (30 supported languages). If not
-      # provided, screenshots the main domain landing page.
+      # provided, screenshots the main domain landing page. Only applicable when using
+      # 'domain', not 'directUrl'.
       sig do
         returns(T.nilable(ContextDev::WebScreenshotParams::Page::OrSymbol))
       end
@@ -65,6 +78,7 @@ module ContextDev
 
       sig do
         params(
+          direct_url: String,
           domain: String,
           full_screenshot:
             ContextDev::WebScreenshotParams::FullScreenshot::OrSymbol,
@@ -74,9 +88,13 @@ module ContextDev
         ).returns(T.attached_class)
       end
       def self.new(
+        # A specific URL to screenshot directly, bypassing domain resolution (e.g.,
+        # 'https://example.com/pricing'). When provided, the screenshot is taken of this
+        # exact URL.
+        direct_url: nil,
         # Domain name to take screenshot of (e.g., 'example.com', 'google.com'). The
         # domain will be automatically normalized and validated.
-        domain:,
+        domain: nil,
         # Optional parameter to determine screenshot type. If 'true', takes a full page
         # screenshot capturing all content. If 'false' or not provided, takes a viewport
         # screenshot (standard browser view).
@@ -84,7 +102,8 @@ module ContextDev
         # Optional parameter to specify which page type to screenshot. If provided, the
         # system will scrape the domain's links and use heuristics to find the most
         # appropriate URL for the specified page type (30 supported languages). If not
-        # provided, screenshots the main domain landing page.
+        # provided, screenshots the main domain landing page. Only applicable when using
+        # 'domain', not 'directUrl'.
         page: nil,
         # Optional parameter to prioritize screenshot capture. If 'speed', optimizes for
         # faster capture with basic quality. If 'quality', optimizes for higher quality
@@ -97,6 +116,7 @@ module ContextDev
       sig do
         override.returns(
           {
+            direct_url: String,
             domain: String,
             full_screenshot:
               ContextDev::WebScreenshotParams::FullScreenshot::OrSymbol,
@@ -146,7 +166,8 @@ module ContextDev
       # Optional parameter to specify which page type to screenshot. If provided, the
       # system will scrape the domain's links and use heuristics to find the most
       # appropriate URL for the specified page type (30 supported languages). If not
-      # provided, screenshots the main domain landing page.
+      # provided, screenshots the main domain landing page. Only applicable when using
+      # 'domain', not 'directUrl'.
       module Page
         extend ContextDev::Internal::Type::Enum
 

data/rbi/context_dev/models/web_web_crawl_md_params.rbi

@@ -0,0 +1,137 @@
+# typed: strong
+
+module ContextDev
+  module Models
+    class WebWebCrawlMdParams < ContextDev::Internal::Type::BaseModel
+      extend ContextDev::Internal::Type::RequestParameters::Converter
+      include ContextDev::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ContextDev::WebWebCrawlMdParams, ContextDev::Internal::AnyHash)
+        end
+
+      # The starting URL for the crawl (must include http:// or https:// protocol)
+      sig { returns(String) }
+      attr_accessor :url
+
+      # When true, follow links on subdomains of the starting URL's domain (e.g.
+      # docs.example.com when starting from example.com). www and apex are always
+      # treated as equivalent.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :follow_subdomains
+
+      sig { params(follow_subdomains: T::Boolean).void }
+      attr_writer :follow_subdomains
+
+      # Include image references in the Markdown output
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :include_images
+
+      sig { params(include_images: T::Boolean).void }
+      attr_writer :include_images
+
+      # Preserve hyperlinks in the Markdown output
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :include_links
+
+      sig { params(include_links: T::Boolean).void }
+      attr_writer :include_links
+
+      # Maximum link depth from the starting URL (0 = only the starting page)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_depth
+
+      sig { params(max_depth: Integer).void }
+      attr_writer :max_depth
+
+      # Maximum number of pages to crawl. Hard cap: 500.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_pages
+
+      sig { params(max_pages: Integer).void }
+      attr_writer :max_pages
+
+      # Truncate base64-encoded image data in the Markdown output
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :shorten_base64_images
+
+      sig { params(shorten_base64_images: T::Boolean).void }
+      attr_writer :shorten_base64_images
+
+      # Regex pattern. Only URLs matching this pattern will be followed and scraped.
+      sig { returns(T.nilable(String)) }
+      attr_reader :url_regex
+
+      sig { params(url_regex: String).void }
+      attr_writer :url_regex
+
+      # Extract only the main content, stripping headers, footers, sidebars, and
+      # navigation
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :use_main_content_only
+
+      sig { params(use_main_content_only: T::Boolean).void }
+      attr_writer :use_main_content_only
+
+      sig do
+        params(
+          url: String,
+          follow_subdomains: T::Boolean,
+          include_images: T::Boolean,
+          include_links: T::Boolean,
+          max_depth: Integer,
+          max_pages: Integer,
+          shorten_base64_images: T::Boolean,
+          url_regex: String,
+          use_main_content_only: T::Boolean,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The starting URL for the crawl (must include http:// or https:// protocol)
+        url:,
+        # When true, follow links on subdomains of the starting URL's domain (e.g.
+        # docs.example.com when starting from example.com). www and apex are always
+        # treated as equivalent.
+        follow_subdomains: nil,
+        # Include image references in the Markdown output
+        include_images: nil,
+        # Preserve hyperlinks in the Markdown output
+        include_links: nil,
+        # Maximum link depth from the starting URL (0 = only the starting page)
+        max_depth: nil,
+        # Maximum number of pages to crawl. Hard cap: 500.
+        max_pages: nil,
+        # Truncate base64-encoded image data in the Markdown output
+        shorten_base64_images: nil,
+        # Regex pattern. Only URLs matching this pattern will be followed and scraped.
+        url_regex: nil,
+        # Extract only the main content, stripping headers, footers, sidebars, and
+        # navigation
+        use_main_content_only: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            url: String,
+            follow_subdomains: T::Boolean,
+            include_images: T::Boolean,
+            include_links: T::Boolean,
+            max_depth: Integer,
+            max_pages: Integer,
+            shorten_base64_images: T::Boolean,
+            url_regex: String,
+            use_main_content_only: T::Boolean,
+            request_options: ContextDev::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/context_dev/models/web_web_crawl_md_response.rbi

@@ -0,0 +1,230 @@
+# typed: strong
+
+module ContextDev
+  module Models
+    class WebWebCrawlMdResponse < ContextDev::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ContextDev::Models::WebWebCrawlMdResponse,
+            ContextDev::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ContextDev::Models::WebWebCrawlMdResponse::Metadata) }
+      attr_reader :metadata
+
+      sig do
+        params(
+          metadata: ContextDev::Models::WebWebCrawlMdResponse::Metadata::OrHash
+        ).void
+      end
+      attr_writer :metadata
+
+      sig do
+        returns(T::Array[ContextDev::Models::WebWebCrawlMdResponse::Result])
+      end
+      attr_accessor :results
+
+      sig do
+        params(
+          metadata: ContextDev::Models::WebWebCrawlMdResponse::Metadata::OrHash,
+          results:
+            T::Array[ContextDev::Models::WebWebCrawlMdResponse::Result::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(metadata:, results:)
+      end
+
+      sig do
+        override.returns(
+          {
+            metadata: ContextDev::Models::WebWebCrawlMdResponse::Metadata,
+            results: T::Array[ContextDev::Models::WebWebCrawlMdResponse::Result]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Metadata < ContextDev::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ContextDev::Models::WebWebCrawlMdResponse::Metadata,
+              ContextDev::Internal::AnyHash
+            )
+          end
+
+        # Maximum crawl depth reached during the crawl
+        sig { returns(Integer) }
+        attr_accessor :max_crawl_depth
+
+        # Number of pages that failed to crawl
+        sig { returns(Integer) }
+        attr_accessor :num_failed
+
+        # Number of pages successfully crawled
+        sig { returns(Integer) }
+        attr_accessor :num_succeeded
+
+        # Total number of URLs crawled
+        sig { returns(Integer) }
+        attr_accessor :num_urls
+
+        sig do
+          params(
+            max_crawl_depth: Integer,
+            num_failed: Integer,
+            num_succeeded: Integer,
+            num_urls: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Maximum crawl depth reached during the crawl
+          max_crawl_depth:,
+          # Number of pages that failed to crawl
+          num_failed:,
+          # Number of pages successfully crawled
+          num_succeeded:,
+          # Total number of URLs crawled
+          num_urls:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              max_crawl_depth: Integer,
+              num_failed: Integer,
+              num_succeeded: Integer,
+              num_urls: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Result < ContextDev::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ContextDev::Models::WebWebCrawlMdResponse::Result,
+              ContextDev::Internal::AnyHash
+            )
+          end
+
+        # Extracted page content as Markdown (empty string on failure)
+        sig { returns(String) }
+        attr_accessor :markdown
+
+        sig do
+          returns(ContextDev::Models::WebWebCrawlMdResponse::Result::Metadata)
+        end
+        attr_reader :metadata
+
+        sig do
+          params(
+            metadata:
+              ContextDev::Models::WebWebCrawlMdResponse::Result::Metadata::OrHash
+          ).void
+        end
+        attr_writer :metadata
+
+        sig do
+          params(
+            markdown: String,
+            metadata:
+              ContextDev::Models::WebWebCrawlMdResponse::Result::Metadata::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Extracted page content as Markdown (empty string on failure)
+          markdown:,
+          metadata:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              markdown: String,
+              metadata:
+                ContextDev::Models::WebWebCrawlMdResponse::Result::Metadata
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Metadata < ContextDev::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                ContextDev::Models::WebWebCrawlMdResponse::Result::Metadata,
+                ContextDev::Internal::AnyHash
+              )
+            end
+
+          # Depth relative to the start URL. 0 = start URL, 1 = one link away.
+          sig { returns(Integer) }
+          attr_accessor :crawl_depth
+
+          # HTTP status code of the response
+          sig { returns(Integer) }
+          attr_accessor :status_code
+
+          # true if the page was fetched and parsed successfully
+          sig { returns(T::Boolean) }
+          attr_accessor :success
+
+          # The page's <title> content (empty string if unavailable)
+          sig { returns(String) }
+          attr_accessor :title
+
+          # The URL that was fetched
+          sig { returns(String) }
+          attr_accessor :url
+
+          sig do
+            params(
+              crawl_depth: Integer,
+              status_code: Integer,
+              success: T::Boolean,
+              title: String,
+              url: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Depth relative to the start URL. 0 = start URL, 1 = one link away.
+            crawl_depth:,
+            # HTTP status code of the response
+            status_code:,
+            # true if the page was fetched and parsed successfully
+            success:,
+            # The page's <title> content (empty string if unavailable)
+            title:,
+            # The URL that was fetched
+            url:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                crawl_depth: Integer,
+                status_code: Integer,
+                success: T::Boolean,
+                title: String,
+                url: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/context_dev/models.rbi

@@ -37,6 +37,8 @@ module ContextDev
 
   WebScreenshotParams = ContextDev::Models::WebScreenshotParams
 
+  WebWebCrawlMdParams = ContextDev::Models::WebWebCrawlMdParams
+
   WebWebScrapeHTMLParams = ContextDev::Models::WebWebScrapeHTMLParams
 
   WebWebScrapeImagesParams = ContextDev::Models::WebWebScrapeImagesParams

data/rbi/context_dev/resources/brand.rbi

@@ -19,8 +19,7 @@ module ContextDev
         # Domain name to retrieve brand data for (e.g., 'example.com', 'google.com').
         # Cannot be used with name or ticker parameters.
         domain:,
-        # Optional parameter to force the language of the retrieved brand data. Works with
-        # all three lookup methods.
+        # Optional parameter to force the language of the retrieved brand data.
         force_language: nil,
         # Optional parameter to optimize the API call for maximum speed. When set to true,
         # the API will skip time-consuming operations for faster response at the cost of

data/rbi/context_dev/resources/web.rbi

@@ -5,10 +5,12 @@ module ContextDev
     class Web
       # Capture a screenshot of a website. Supports both viewport (standard browser
       # view) and full-page screenshots. Can also screenshot specific page types (login,
-      # pricing, etc.) by using heuristics to find the appropriate URL. Returns a URL to
-      # the uploaded screenshot image hosted on our CDN.
+      # pricing, etc.) by using heuristics to find the appropriate URL. Either 'domain'
+      # or 'directUrl' must be provided as a query parameter, but not both. Returns a
+      # URL to the uploaded screenshot image hosted on our CDN.
       sig do
         params(
+          direct_url: String,
           domain: String,
           full_screenshot:
             ContextDev::WebScreenshotParams::FullScreenshot::OrSymbol,
@@ -18,9 +20,13 @@ module ContextDev
         ).returns(ContextDev::Models::WebScreenshotResponse)
       end
       def screenshot(
+        # A specific URL to screenshot directly, bypassing domain resolution (e.g.,
+        # 'https://example.com/pricing'). When provided, the screenshot is taken of this
+        # exact URL.
+        direct_url: nil,
         # Domain name to take screenshot of (e.g., 'example.com', 'google.com'). The
         # domain will be automatically normalized and validated.
-        domain:,
+        domain: nil,
         # Optional parameter to determine screenshot type. If 'true', takes a full page
         # screenshot capturing all content. If 'false' or not provided, takes a viewport
         # screenshot (standard browser view).
@@ -28,7 +34,8 @@ module ContextDev
         # Optional parameter to specify which page type to screenshot. If provided, the
         # system will scrape the domain's links and use heuristics to find the most
         # appropriate URL for the specified page type (30 supported languages). If not
-        # provided, screenshots the main domain landing page.
+        # provided, screenshots the main domain landing page. Only applicable when using
+        # 'domain', not 'directUrl'.
         page: nil,
         # Optional parameter to prioritize screenshot capture. If 'speed', optimizes for
         # faster capture with basic quality. If 'quality', optimizes for higher quality
@@ -38,6 +45,49 @@ module ContextDev
       )
       end
 
+      # Performs a crawl starting from a given URL, extracts page content as Markdown,
+      # and returns results for all crawled pages. Only follows links within the same
+      # domain as the starting URL. Costs 1 credit per successful page crawled.
+      sig do
+        params(
+          url: String,
+          follow_subdomains: T::Boolean,
+          include_images: T::Boolean,
+          include_links: T::Boolean,
+          max_depth: Integer,
+          max_pages: Integer,
+          shorten_base64_images: T::Boolean,
+          url_regex: String,
+          use_main_content_only: T::Boolean,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::WebWebCrawlMdResponse)
+      end
+      def web_crawl_md(
+        # The starting URL for the crawl (must include http:// or https:// protocol)
+        url:,
+        # When true, follow links on subdomains of the starting URL's domain (e.g.
+        # docs.example.com when starting from example.com). www and apex are always
+        # treated as equivalent.
+        follow_subdomains: nil,
+        # Include image references in the Markdown output
+        include_images: nil,
+        # Preserve hyperlinks in the Markdown output
+        include_links: nil,
+        # Maximum link depth from the starting URL (0 = only the starting page)
+        max_depth: nil,
+        # Maximum number of pages to crawl. Hard cap: 500.
+        max_pages: nil,
+        # Truncate base64-encoded image data in the Markdown output
+        shorten_base64_images: nil,
+        # Regex pattern. Only URLs matching this pattern will be followed and scraped.
+        url_regex: nil,
+        # Extract only the main content, stripping headers, footers, sidebars, and
+        # navigation
+        use_main_content_only: nil,
+        request_options: {}
+      )
+      end
+
       # Scrapes the given URL and returns the raw HTML content of the page.
       sig do
         params(