context.dev 2.17.1 → 2.19.0

data/rbi/context_dev/resources/web.rbi

@@ -15,6 +15,7 @@ module ContextDev
           mode: ContextDev::WebAnswersParams::Mode::OrSymbol,
           tags: T::Array[String],
           timeout_opts: ContextDev::WebAnswersParams::TimeoutOpts::OrHash,
+          zdr: ContextDev::WebAnswersParams::Zdr::OrSymbol,
           request_options: ContextDev::RequestOptions::OrHash
         ).returns(ContextDev::Models::WebAnswersResponse)
       end
@@ -38,95 +39,12 @@ module ContextDev
         # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
         # timeoutOpts object.
         timeout_opts: nil,
-        request_options: {}
-      )
-      end
-
-      # Crawl a website, use the provided JSON Schema and instructions to prioritize
-      # relevant internal links, and extract structured data from the selected pages.
-      sig do
-        params(
-          schema: T::Hash[Symbol, T.anything],
-          url: String,
-          actions:
-            T::Array[
-              T.any(
-                ContextDev::WebExtractParams::Action::Wait::OrHash,
-                ContextDev::WebExtractParams::Action::Perform::OrHash,
-                ContextDev::WebExtractParams::Action::Scroll::OrHash
-              )
-            ],
-          fact_check: T::Boolean,
-          follow_subdomains: T::Boolean,
-          include_frames: T::Boolean,
-          instructions: String,
-          max_age_ms: Integer,
-          max_depth: Integer,
-          max_pages: Integer,
-          pdf: ContextDev::WebExtractParams::Pdf::OrHash,
-          settle_animations: T::Boolean,
-          stop_after_ms: Integer,
-          tags: T::Array[String],
-          timeout_opts: ContextDev::WebExtractParams::TimeoutOpts::OrHash,
-          wait_for_ms: Integer,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebExtractResponse)
-      end
-      def extract(
-        # JSON Schema for the returned data object. Image fields such as `image_urls` or
-        # `product_photos` automatically make page image references available to
-        # extraction, so product data and photos can be returned in one call. TypeScript
-        # Zod users can pass a JSON Schema generated from a Zod object; Python users can
-        # pass the equivalent JSON Schema object.
-        schema:,
-        # The starting website URL to crawl and extract from. Must include http:// or
-        # https://.
-        url:,
-        # Optional browser actions executed in order on the requested page after it loads,
-        # before links are discovered or additional pages are crawled. Requires a paid
-        # plan. When actions are provided and stopAfterMs is omitted, the crawl budget
-        # defaults to 110000 ms.
-        actions: nil,
-        # When true, every returned value must be grounded in facts stated on the page;
-        # fields that cannot be supported by the page are returned as null/empty. When
-        # false (default), the model may make reasonable inferences and derivations from
-        # the page content (e.g. ideal customer, competitor analysis, recommendations)
-        # while keeping verifiable specifics (names, quotes, URLs, dates, metrics)
-        # faithful to the source.
-        fact_check: nil,
-        # When true, follow links on subdomains of the starting URL's domain.
-        follow_subdomains: nil,
-        # When true, iframe contents are included in Markdown before extraction.
-        include_frames: nil,
-        # Optional extraction guidance, such as which facts to prioritize or how to
-        # interpret fields in the schema.
-        instructions: nil,
-        # Return cached scrape results if a prior scrape for the same parameters is
-        # younger than this many milliseconds. Defaults to 7 days (604800000 ms).
-        max_age_ms: nil,
-        # Optional maximum link depth from the starting URL (0 = only the starting page).
-        # If omitted, there is no crawl depth limit.
-        max_depth: nil,
-        # Maximum number of pages to analyze for extraction. Hard cap: 50. Defaults to 5.
-        max_pages: nil,
-        pdf: nil,
-        # When true, waits briefly for CSS and transition animations to settle before
-        # extracting each crawled page. Defaults to false. This adds a bit of latency in
-        # exchange for more stable output on animated pages.
-        settle_animations: nil,
-        # Soft time budget for the crawl in milliseconds. Min: 10000 (10s). Max: 110000
-        # (110s). Defaults to 80000 (80s), or 110000 (110s) when browser actions are
-        # provided.
-        stop_after_ms: nil,
-        # Optional tags for tracking usage. Up to 20 tags, each 1 to 50 characters.
-        tags: nil,
-        # Optional request deadline and behavior on timeout. For GET requests, use
-        # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
-        # timeoutOpts object.
-        timeout_opts: nil,
-        # Optional browser wait time in milliseconds after initial page load for each
-        # crawled page.
-        wait_for_ms: nil,
+        # Set to enabled to bypass shared caches and omit request and response content
+        # from retained usage logs. Asset uploads are skipped, so hosted image URLs are
+        # omitted. Requires zero data retention to be enabled for your organization
+        # (contact support@context.dev), otherwise the request fails with ZDR_NOT_ENABLED.
+        # Successful ZDR responses include X-Context-ZDR: true.
+        zdr: nil,
         request_options: {}
       )
       end
@@ -140,6 +58,7 @@ module ContextDev
           tags: T::Array[String],
           timeout_opts:
             ContextDev::WebExtractCompetitorsParams::TimeoutOpts::OrHash,
+          zdr: ContextDev::WebExtractCompetitorsParams::Zdr::OrSymbol,
           request_options: ContextDev::RequestOptions::OrHash
         ).returns(ContextDev::Models::WebExtractCompetitorsResponse)
       end
@@ -156,28 +75,42 @@ module ContextDev
         # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
         # timeoutOpts object.
         timeout_opts: nil,
+        # Set to enabled to bypass shared caches and omit request and response content
+        # from retained usage logs. Asset uploads are skipped, so hosted image URLs are
+        # omitted. Requires zero data retention to be enabled for your organization
+        # (contact support@context.dev), otherwise the request fails with ZDR_NOT_ENABLED.
+        # Successful ZDR responses include X-Context-ZDR: true.
+        zdr: nil,
         request_options: {}
       )
       end
 
-      # Scrape font information from a website including font families, usage
-      # statistics, fallbacks, and element/word counts.
+      # Extract a comprehensive design system from a website including colors,
+      # typography, spacing, shadows, and UI components.
       sig do
         params(
+          color_scheme:
+            ContextDev::WebExtractStyleguideParams::ColorScheme::OrSymbol,
           direct_url: String,
           domain: String,
           max_age_ms: T.nilable(Integer),
           tags: T::Array[String],
-          timeout_opts: ContextDev::WebExtractFontsParams::TimeoutOpts::OrHash,
+          timeout_opts:
+            ContextDev::WebExtractStyleguideParams::TimeoutOpts::OrHash,
+          zdr: ContextDev::WebExtractStyleguideParams::Zdr::OrSymbol,
           request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebExtractFontsResponse)
+        ).returns(ContextDev::Models::WebExtractStyleguideResponse)
       end
-      def extract_fonts(
-        # A specific URL to fetch fonts from directly, bypassing domain resolution (e.g.,
-        # 'https://example.com/design-system'). When provided, fonts are extracted from
-        # this exact URL. You must provide either 'domain' or 'directUrl', but not both.
+      def extract_styleguide(
+        # Optional browser color scheme to emulate for websites that respond to
+        # prefers-color-scheme. This value is part of the styleguide cache key.
+        color_scheme: nil,
+        # A specific URL to fetch the styleguide from directly, bypassing domain
+        # resolution (e.g., 'https://example.com/design-system'). When provided, the
+        # styleguide is extracted from this exact URL. You must provide either 'domain' or
+        # 'directUrl', but not both.
         direct_url: nil,
-        # Domain name to extract fonts from (e.g., 'example.com', 'google.com'). The
+        # Domain name to extract styleguide from (e.g., 'example.com', 'google.com'). The
         # domain will be automatically normalized and validated. You must provide either
         # 'domain' or 'directUrl', but not both.
         domain: nil,
@@ -193,43 +126,59 @@ module ContextDev
         # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
         # timeoutOpts object.
         timeout_opts: nil,
+        # Set to enabled to bypass shared caches and omit request and response content
+        # from retained usage logs. Asset uploads are skipped, so hosted image URLs are
+        # omitted. Requires zero data retention to be enabled for your organization
+        # (contact support@context.dev), otherwise the request fails with ZDR_NOT_ENABLED.
+        # Successful ZDR responses include X-Context-ZDR: true.
+        zdr: nil,
         request_options: {}
       )
       end
 
-      # Extract a comprehensive design system from a website including colors,
-      # typography, spacing, shadows, and UI components.
+      # Discovers URLs using the same sitemap crawl, filters, and limits as
+      # /web/scrape/sitemap. Each URL includes its available title, description,
+      # keywords, and language. URLs without stored enrichment are returned immediately
+      # with only the URL and queued for background HTML scraping, so later requests can
+      # include their metadata. Responses are never cached as a whole; every request
+      # reads the current per-URL enrichment. Zero data retention and credential-bearing
+      # discovery requests return URLs without reading or storing shared enrichment or
+      # queuing background scrapes. Costs 1 credit, or 2 credits with search.
       sig do
         params(
-          color_scheme:
-            ContextDev::WebExtractStyleguideParams::ColorScheme::OrSymbol,
-          direct_url: String,
           domain: String,
-          max_age_ms: T.nilable(Integer),
+          headers: T::Hash[Symbol, String],
+          include_subdomains: T::Boolean,
+          max_links: Integer,
+          search: String,
+          sitemap_url: String,
           tags: T::Array[String],
-          timeout_opts:
-            ContextDev::WebExtractStyleguideParams::TimeoutOpts::OrHash,
+          timeout_opts: ContextDev::WebMapURLsParams::TimeoutOpts::OrHash,
+          url_regex: String,
+          zdr: ContextDev::WebMapURLsParams::Zdr::OrSymbol,
           request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebExtractStyleguideResponse)
+        ).returns(ContextDev::Models::WebMapURLsResponse)
       end
-      def extract_styleguide(
-        # Optional browser color scheme to emulate for websites that respond to
-        # prefers-color-scheme. This value is part of the styleguide cache key.
-        color_scheme: nil,
-        # A specific URL to fetch the styleguide from directly, bypassing domain
-        # resolution (e.g., 'https://example.com/design-system'). When provided, the
-        # styleguide is extracted from this exact URL. You must provide either 'domain' or
-        # 'directUrl', but not both.
-        direct_url: nil,
-        # Domain name to extract styleguide from (e.g., 'example.com', 'google.com'). The
-        # domain will be automatically normalized and validated. You must provide either
-        # 'domain' or 'directUrl', but not both.
-        domain: nil,
-        # Maximum age in milliseconds for cached brand data before the API performs a hard
-        # refresh. Defaults to 3 months (7776000000 ms). Set to 0 to always perform a hard
-        # refresh. Negative values are clamped to 0; values above 1 year (31536000000 ms)
-        # are clamped to 1 year.
-        max_age_ms: nil,
+      def map_urls(
+        # Domain to build a sitemap for
+        domain:,
+        # Optional outbound HTTP headers forwarded only to the target URL, sent as
+        # deep-object query params such as headers[X-Custom]=value. When provided, caching
+        # is bypassed: the result is neither read from nor written to cache.
+        headers: nil,
+        # When true, discover and include public pages and sitemaps on subdomains of the
+        # requested domain. Defaults to false.
+        include_subdomains: nil,
+        # Maximum number of links to return from the sitemap crawl. Defaults to 10,000.
+        # Minimum is 1, maximum is 100,000.
+        max_links: nil,
+        # Optional search phrase. When provided, the crawled sitemap is filtered to the
+        # pages whose URLs are about that phrase, most relevant first, and the request
+        # costs 2 credits instead of 1.
+        search: nil,
+        # Optional explicit sitemap URL. When provided, exactly this sitemap is crawled
+        # instead of discovering the domain's sitemaps.
+        sitemap_url: nil,
         # Comma-separated tags for tracking request usage. Up to 20 tags, each 1-50
         # characters.
         tags: nil,
@@ -237,6 +186,78 @@ module ContextDev
         # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
         # timeoutOpts object.
         timeout_opts: nil,
+        # Optional RE2-compatible regex pattern. Only URLs matching this pattern are
+        # returned and counted against maxLinks.
+        url_regex: nil,
+        # Set to enabled to bypass shared caches and omit request and response content
+        # from retained usage logs. Asset uploads are skipped, so hosted image URLs are
+        # omitted. Requires zero data retention to be enabled for your organization
+        # (contact support@context.dev), otherwise the request fails with ZDR_NOT_ENABLED.
+        # Successful ZDR responses include X-Context-ZDR: true.
+        zdr: nil,
+        request_options: {}
+      )
+      end
+
+      # Reuse cached outputs independently and capture missing formats in one page
+      # visit. Each cache key includes only the settings that affect that output. HTML
+      # is shared with Markdown and parsed fields. Cached outputs can come from
+      # different visits within maxAgeMs; use 0 for a fresh capture. HTML-only requests
+      # use the existing fast acquisition path. One credit per request, including cache
+      # hits, or two with browser actions; PDF OCR adds one credit per recovered page on
+      # fresh extraction. Original response bytes and screenshots are limited to 20 MiB
+      # each, screenshots to 40 megapixels, and the combined browser capture to 60 MiB.
+      sig do
+        params(
+          formats: ContextDev::WebScrapeParams::Formats::OrHash,
+          url: String,
+          image_params: ContextDev::WebScrapeParams::ImageParams::OrHash,
+          markdown_params: ContextDev::WebScrapeParams::MarkdownParams::OrHash,
+          max_age_ms: Integer,
+          parse_params: ContextDev::WebScrapeParams::ParseParams::OrHash,
+          screenshot_params:
+            ContextDev::WebScrapeParams::ScreenshotParams::OrHash,
+          shared_params: ContextDev::WebScrapeParams::SharedParams::OrHash,
+          tags: T::Array[String],
+          timeout_opts: ContextDev::WebScrapeParams::TimeoutOpts::OrHash,
+          zdr: ContextDev::WebScrapeParams::Zdr::OrSymbol,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::WebScrapeResponse)
+      end
+      def scrape(
+        # Outputs to return. Enable at least one; omitted formats are false.
+        formats:,
+        # The URL to scrape.
+        url:,
+        # Image options. Requires formats.images: true.
+        image_params: nil,
+        # Markdown options. Requires formats.markdown: true.
+        markdown_params: nil,
+        # Maximum age of each cached output. Defaults to 1 day; 0 fetches fresh and
+        # updates the requested outputs. Compatible outputs are shared with the individual
+        # scrape endpoints. Image results with hosted files refresh after 23 hours; other
+        # outputs retain their own freshness.
+        max_age_ms: nil,
+        # Required when formats.parse is true.
+        parse_params: nil,
+        # Screenshot options. Requires formats.screenshot: true.
+        screenshot_params: nil,
+        # Shared browser and content settings. Content filters leave screenshots and
+        # original bytes unchanged.
+        shared_params: nil,
+        # Labels for tracking request usage. Not retained when zdr is enabled.
+        tags: nil,
+        # Total deadline, including navigation, actions, waiting, and all outputs.
+        # Defaults to 60000 milliseconds with behavior fail. Use return-partial to capture
+        # the current page state and return captured images if image processing cannot
+        # finish before the deadline; these responses set isPartial and are not cached.
+        # Every requested format must still be available. Fixed waits must fit before a
+        # response reserve of up to 5000 milliseconds (at most one quarter of the timeout)
+        # when using return-partial.
+        timeout_opts: nil,
+        # Zero data retention. Bypasses caches and uploads; excludes request/response
+        # content and tags from logs. Must be enabled for your organization.
+        zdr: nil,
         request_options: {}
       )
       end
@@ -252,6 +273,7 @@ module ContextDev
           full_screenshot:
             ContextDev::WebScreenshotParams::FullScreenshot::OrSymbol,
           handle_cookie_popup: T::Boolean,
+          headers: T::Hash[Symbol, String],
           max_age_ms: T.nilable(Integer),
           page: ContextDev::WebScreenshotParams::Page::OrSymbol,
           scroll_offset: T.nilable(Integer),
@@ -292,6 +314,14 @@ module ContextDev
         # dismiss cookie banner before capture. If 'false' or not provided, captures the
         # page without that step.
         handle_cookie_popup: nil,
+        # Optional outbound HTTP headers, using the same JSON object or deep-object query
+        # format as other scrape endpoints (for example headers[Authorization]=Bearer
+        # token). Headers are scoped to the target origin during capture. For domain/page
+        # requests, discovery receives no custom headers and only pages on the resolved
+        # origin are eligible. Non-empty headers bypass screenshot caching and return an
+        # in-memory data URL; no screenshot is uploaded. Empty objects behave like omitted
+        # headers.
+        headers: nil,
         # Return a cached screenshot if a prior screenshot for the same parameters exists
         # and is younger than this many milliseconds. Defaults to 1 day (86400000 ms) when
         # omitted. Max is 30 days (2592000000 ms). Set to 0 to always capture fresh.
@@ -325,9 +355,10 @@ module ContextDev
         # TIMEOUT_TOO_SHORT_FOR_WAIT.
         wait_for_ms: nil,
         # Set to enabled to bypass shared caches and omit request and response content
-        # from retained usage logs. Requires zero data retention to be enabled for your
-        # organization (contact support@context.dev), otherwise the request fails with
-        # ZDR_NOT_ENABLED. Successful ZDR responses include X-Context-ZDR: true.
+        # from retained usage logs. Asset uploads are skipped, so hosted image URLs are
+        # omitted. Requires zero data retention to be enabled for your organization
+        # (contact support@context.dev), otherwise the request fails with ZDR_NOT_ENABLED.
+        # Successful ZDR responses include X-Context-ZDR: true.
         zdr: nil,
         request_options: {}
       )
@@ -347,6 +378,7 @@ module ContextDev
           query_fanout: T::Boolean,
           tags: T::Array[String],
           timeout_opts: ContextDev::WebSearchParams::TimeoutOpts::OrHash,
+          zdr: ContextDev::WebSearchParams::Zdr::OrSymbol,
           request_options: ContextDev::RequestOptions::OrHash
         ).returns(ContextDev::Models::WebSearchResponse)
       end
@@ -377,6 +409,12 @@ module ContextDev
         # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
         # timeoutOpts object.
         timeout_opts: nil,
+        # Set to enabled to bypass shared caches and omit request and response content
+        # from retained usage logs. Asset uploads are skipped, so hosted image URLs are
+        # omitted. Requires zero data retention to be enabled for your organization
+        # (contact support@context.dev), otherwise the request fails with ZDR_NOT_ENABLED.
+        # Successful ZDR responses include X-Context-ZDR: true.
+        zdr: nil,
         request_options: {}
       )
       end
@@ -482,411 +520,6 @@ module ContextDev
       )
       end
 
-      # Downloads a resource and returns its bytes as base64. Supports images, PDFs,
-      # HTML pages, and any other content type without image conversion, text
-      # extraction, or character-encoding changes. HTTP compression is decoded before
-      # base64 encoding. HTML is the original HTTP response; JavaScript is not rendered.
-      # Follows public redirects and retries failed downloads through ISP and
-      # residential proxies, with a direct fallback. When country is specified, only a
-      # residential proxy in that country is used. Supply headers such as Referer for
-      # images that require a referring page. Downloads are not cached. Maximum decoded
-      # resource size: 20 MiB (20971520 bytes), before base64 encoding. Successful
-      # requests cost 1 credit; errors are not billed.
-      sig do
-        params(
-          url: String,
-          country: ContextDev::WebWebScrapeBytesParams::Country::OrSymbol,
-          headers: T::Hash[Symbol, String],
-          tags: T::Array[String],
-          timeout_opts:
-            ContextDev::WebWebScrapeBytesParams::TimeoutOpts::OrHash,
-          zdr: ContextDev::WebWebScrapeBytesParams::Zdr::OrSymbol,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebWebScrapeBytesResponse)
-      end
-      def web_scrape_bytes(
-        # Full HTTP(S) URL of the resource to download, such as an image, PDF, or page.
-        url:,
-        # Fetch the target page through a residential proxy in this country (ISO 3166-1
-        # alpha-2).
-        country: nil,
-        # Optional outbound HTTP headers, such as Referer, Cookie, or Authorization. Send
-        # as a JSON object or deep-object query params such as
-        # headers[Referer]=https://example.com/. Host, Content-Length, and hop-by-hop
-        # transport headers are rejected. Authorization and cookies are removed when a
-        # redirect changes origin.
-        headers: nil,
-        # Comma-separated tags for tracking request usage. Up to 20 tags, each 1-50
-        # characters.
-        tags: nil,
-        # Optional request deadline and behavior on timeout. For GET requests, use
-        # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
-        # timeoutOpts object.
-        timeout_opts: nil,
-        # Set to enabled to bypass shared caches and omit request and response content
-        # from retained usage logs. Requires zero data retention to be enabled for your
-        # organization (contact support@context.dev), otherwise the request fails with
-        # ZDR_NOT_ENABLED. Successful ZDR responses include X-Context-ZDR: true.
-        zdr: nil,
-        request_options: {}
-      )
-      end
-
-      # Scrapes the given URL and returns the raw HTML content of the page. The base
-      # request costs 1 credit; requests with browser actions cost 2 credits. A request
-      # that hits its timeoutOpts.milliseconds deadline fails with 408 and is not
-      # billed, unless timeoutOpts.behavior=return-partial is set — then the page as
-      # rendered so far is returned with `finalDOMState: "still-loading"` and billed at
-      # the base cost of 1 credit.
-      sig do
-        params(
-          url: String,
-          actions:
-            T.nilable(
-              T::Array[
-                T.any(
-                  ContextDev::WebWebScrapeHTMLParams::Action::Wait::OrHash,
-                  ContextDev::WebWebScrapeHTMLParams::Action::Perform::OrHash,
-                  ContextDev::WebWebScrapeHTMLParams::Action::Scroll::OrHash
-                )
-              ]
-            ),
-          country: ContextDev::WebWebScrapeHTMLParams::Country::OrSymbol,
-          exclude_selectors: T.nilable(T::Array[String]),
-          headers: T::Hash[Symbol, String],
-          include_frames: T::Boolean,
-          include_selectors: T.nilable(T::Array[String]),
-          max_age_ms: T.nilable(Integer),
-          pdf: ContextDev::WebWebScrapeHTMLParams::Pdf::OrHash,
-          settle_animations: T::Boolean,
-          tags: T::Array[String],
-          timeout_opts: ContextDev::WebWebScrapeHTMLParams::TimeoutOpts::OrHash,
-          use_main_content_only: T::Boolean,
-          wait_for_ms: T.nilable(Integer),
-          zdr: ContextDev::WebWebScrapeHTMLParams::Zdr::OrSymbol,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebWebScrapeHTMLResponse)
-      end
-      def web_scrape_html(
-        # Full URL to scrape (must include http:// or https:// protocol)
-        url:,
-        # Optional browser actions executed in array order after the page loads and before
-        # content is captured. Requires a paid plan. Send a JSON array in the query
-        # parameter. Maximum: 5 actions.
-        actions: nil,
-        # Fetch the target page through a residential proxy in this country (ISO 3166-1
-        # alpha-2).
-        country: nil,
-        # CSS selectors to remove from the result. Applied after includeSelectors.
-        # Exclusion takes precedence: an element matching both is removed. Examples:
-        # "nav", "footer", ".ad-banner", "[aria-hidden=true]".
-        exclude_selectors: nil,
-        # Optional outbound HTTP headers forwarded only to the target URL, sent as
-        # deep-object query params such as headers[X-Custom]=value. When provided, caching
-        # is bypassed: the result is neither read from nor written to cache.
-        headers: nil,
-        # When true, iframes are rendered inline into the returned HTML.
-        include_frames: nil,
-        # CSS selectors. When provided, only matching subtrees (and their descendants) are
-        # kept and everything else is dropped. When omitted, the entire document is kept.
-        # Examples: "article.main", "#content", "[role=main]".
-        include_selectors: nil,
-        # Return a cached result if a prior scrape for the same parameters exists and is
-        # younger than this many milliseconds. Defaults to 1 day (86400000 ms) when
-        # omitted. Max is 30 days (2592000000 ms). Set to 0 to always scrape fresh.
-        max_age_ms: nil,
-        # PDF parsing controls. Use start/end to limit text extraction and embedded-image
-        # detection/OCR to an inclusive 1-based page range.
-        pdf: nil,
-        # When true, waits briefly for CSS and transition animations to settle before
-        # extracting HTML. Defaults to false. This adds a bit of latency in exchange for
-        # more stable output on animated pages.
-        settle_animations: nil,
-        # Comma-separated tags for tracking request usage. Up to 20 tags, each 1-50
-        # characters.
-        tags: nil,
-        # Optional request deadline and behavior on timeout. For GET requests, use
-        # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
-        # timeoutOpts object.
-        timeout_opts: nil,
-        # When true, return only the page's main content in the HTML response, excluding
-        # headers, footers, sidebars, and navigation when detectable.
-        use_main_content_only: nil,
-        # Optional browser wait time in milliseconds after initial page load. Min: 0. Max:
-        # 30000 (30 seconds). When combined with timeoutOpts, timeoutOpts.milliseconds
-        # must be at least waitForMs + 10000 ms; a shorter deadline is rejected with 400
-        # TIMEOUT_TOO_SHORT_FOR_WAIT.
-        wait_for_ms: nil,
-        # Set to enabled to bypass shared caches and omit request and response content
-        # from retained usage logs. Requires zero data retention to be enabled for your
-        # organization (contact support@context.dev), otherwise the request fails with
-        # ZDR_NOT_ENABLED. Successful ZDR responses include X-Context-ZDR: true.
-        zdr: nil,
-        request_options: {}
-      )
-      end
-
-      # Extract image assets from a web page, including standard URLs, inline SVGs, data
-      # URIs, responsive image sources, metadata, CSS backgrounds, video posters, and
-      # embeds. The base request costs 1 credit, or 2 credits with browser actions. When
-      # enrichment is enabled, the entire call costs 5 credits, including requests that
-      # also use actions.
-      sig do
-        params(
-          url: String,
-          actions:
-            T.nilable(
-              T::Array[
-                T.any(
-                  ContextDev::WebWebScrapeImagesParams::Action::Wait::OrHash,
-                  ContextDev::WebWebScrapeImagesParams::Action::Perform::OrHash,
-                  ContextDev::WebWebScrapeImagesParams::Action::Scroll::OrHash
-                )
-              ]
-            ),
-          dedupe: T::Boolean,
-          enrichment:
-            T.nilable(ContextDev::WebWebScrapeImagesParams::Enrichment::OrHash),
-          headers: T::Hash[Symbol, String],
-          max_age_ms: T.nilable(Integer),
-          tags: T::Array[String],
-          timeout_opts:
-            ContextDev::WebWebScrapeImagesParams::TimeoutOpts::OrHash,
-          wait_for_ms: T.nilable(Integer),
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebWebScrapeImagesResponse)
-      end
-      def web_scrape_images(
-        # Page URL to inspect. Must include http:// or https://.
-        url:,
-        # Optional browser actions executed in array order after the page loads and before
-        # content is captured. Requires a paid plan. Send a JSON array in the query
-        # parameter. Maximum: 5 actions.
-        actions: nil,
-        # When true, visually duplicate images are removed: every image is loaded and
-        # perceptually hashed, and only the highest-resolution copy of each duplicate
-        # group is kept. Images that cannot be downloaded or hashed are kept. Default:
-        # false.
-        dedupe: nil,
-        # Optional per-image processing, sent as deep-object query params such as
-        # enrichment[resolution]=true.
-        enrichment: nil,
-        # Optional outbound HTTP headers forwarded only to the target URL, sent as
-        # deep-object query params such as headers[X-Custom]=value. When provided, caching
-        # is bypassed: the result is neither read from nor written to cache.
-        headers: nil,
-        # Reuse a cached result this many milliseconds old or newer. Default: 86400000 (1
-        # day). Set to 0 to bypass cache. Maximum: 2592000000 (30 days).
-        max_age_ms: nil,
-        # Comma-separated tags for tracking request usage. Up to 20 tags, each 1-50
-        # characters.
-        tags: nil,
-        # Optional request deadline and behavior on timeout. For GET requests, use
-        # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
-        # timeoutOpts object.
-        timeout_opts: nil,
-        # Optional browser wait time in milliseconds after initial page load before
-        # collecting images. Min: 0. Max: 30000 (30 seconds). When combined with
-        # timeoutOpts, timeoutOpts.milliseconds must be at least waitForMs + 10000 ms; a
-        # shorter deadline is rejected with 400 TIMEOUT_TOO_SHORT_FOR_WAIT.
-        wait_for_ms: nil,
-        request_options: {}
-      )
-      end
-
-      # Scrapes the given URL into LLM usable Markdown. Inspect key_metadata on JSON
-      # responses from a recognized API key; use error_code to distinguish stable
-      # failure categories.
-      #
-      # ### YouTube
-      #
-      # YouTube URLs return the video or channel itself rather than the surrounding
-      # player and navigation chrome. A URL addressing a single video (`/watch`,
-      # `youtu.be`, `/shorts`, `/embed`, `/live`) returns its title, channel, duration,
-      # view count, keywords, full description, and the transcript when the video has
-      # captions that can be retrieved; videos without captions return everything except
-      # the transcript. A channel URL (`/channel/UC…`, `/@handle`, `/c/…`, `/user/…`)
-      # returns its name, handle, subscriber count, video count, and full description.
-      # When `includeImages=true`, video responses also include the thumbnail and
-      # channel responses include the avatar. Costs the same as any other scrape.
-      #
-      # ### Billing & errors
-      #
-      # | HTTP status | Billed?                                   | Meaning                                                                                                                                                                                                                                                                                                       |
-      # | ----------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-      # | 200         | Yes — 1 credit, or 2 credits with actions | Successful scrape, including a zero-length result when includeSelectors matched nothing. A partial result (`finalDOMState: "still-loading"`, only with timeoutOpts.behavior=return-partial) is billed at the base 1 credit with no OCR or actions surcharge                                                   |
-      # | 400         | No                                        | Invalid input, skipped PDF, or the page could not be scraped. error_code WEBSITE_BLOCKED specifically means the site answered with an anti-bot challenge, CAPTCHA wall, or login shell instead of the page (even when the site returned HTTP 200) — retrying later or from another country sometimes succeeds |
-      # | 401 / 403   | No                                        | Invalid/disabled key, insufficient permissions, or credits exhausted; inspect error_code                                                                                                                                                                                                                      |
-      # | 404         | No                                        | Target page returned or fingerprinted as not found                                                                                                                                                                                                                                                            |
-      # | 408         | No                                        | Request timed out. With timeoutOpts.behavior=return-partial this only happens when nothing usable had rendered by the deadline                                                                                                                                                                                |
-      # | 413         | No                                        | Target content exceeds the maximum supported size (20 MB)                                                                                                                                                                                                                                                     |
-      # | 415         | No                                        | Unsupported content type                                                                                                                                                                                                                                                                                      |
-      # | 429         | No                                        | Per-minute rate limit exceeded; honor Retry-After                                                                                                                                                                                                                                                             |
-      # | 500         | No                                        | Internal error                                                                                                                                                                                                                                                                                                |
-      sig do
-        params(
-          url: String,
-          actions:
-            T.nilable(
-              T::Array[
-                T.any(
-                  ContextDev::WebWebScrapeMdParams::Action::Wait::OrHash,
-                  ContextDev::WebWebScrapeMdParams::Action::Perform::OrHash,
-                  ContextDev::WebWebScrapeMdParams::Action::Scroll::OrHash
-                )
-              ]
-            ),
-          country: ContextDev::WebWebScrapeMdParams::Country::OrSymbol,
-          exclude_selectors: T.nilable(T::Array[String]),
-          headers: T::Hash[Symbol, String],
-          include_frames: T::Boolean,
-          include_html: T::Boolean,
-          include_images: T::Boolean,
-          include_links: T::Boolean,
-          include_selectors: T.nilable(T::Array[String]),
-          max_age_ms: T.nilable(Integer),
-          pdf: ContextDev::WebWebScrapeMdParams::Pdf::OrHash,
-          settle_animations: T::Boolean,
-          shorten_base64_images: T::Boolean,
-          tags: T::Array[String],
-          timeout_opts: ContextDev::WebWebScrapeMdParams::TimeoutOpts::OrHash,
-          use_main_content_only: T::Boolean,
-          wait_for_ms: T.nilable(Integer),
-          zdr: ContextDev::WebWebScrapeMdParams::Zdr::OrSymbol,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebWebScrapeMdResponse)
-      end
-      def web_scrape_md(
-        # Full URL to scrape into LLM usable Markdown (must include http:// or https://
-        # protocol)
-        url:,
-        # Optional browser actions executed in array order after the page loads and before
-        # content is captured. Requires a paid plan. Send a JSON array in the query
-        # parameter. Maximum: 5 actions.
-        actions: nil,
-        # Fetch the target page through a residential proxy in this country (ISO 3166-1
-        # alpha-2).
-        country: nil,
-        # CSS selectors to remove before conversion to Markdown. Applied after
-        # includeSelectors. Exclusion takes precedence: an element matching both is
-        # removed. Examples: "nav", "footer", ".ad-banner", "[aria-hidden=true]".
-        exclude_selectors: nil,
-        # Optional outbound HTTP headers forwarded only to the target URL, sent as
-        # deep-object query params such as headers[X-Custom]=value. When provided, caching
-        # is bypassed: the result is neither read from nor written to cache.
-        headers: nil,
-        # When true, the contents of iframes are rendered to Markdown.
-        include_frames: nil,
-        # When true, the response also includes an `html` field with the page HTML the
-        # Markdown was converted from — the same body the Scrape HTML endpoint returns for
-        # the equivalent request.
-        include_html: nil,
-        # Include image references in Markdown output
-        include_images: nil,
-        # Preserve hyperlinks in Markdown output
-        include_links: nil,
-        # CSS selectors. When provided, only matching HTML subtrees (and their
-        # descendants) are kept before conversion to Markdown. When omitted, the entire
-        # document is kept. Examples: "article.main", "#content", "[role=main]".
-        include_selectors: nil,
-        # Return a cached result if a prior scrape for the same parameters exists and is
-        # younger than this many milliseconds. Defaults to 1 day (86400000 ms) when
-        # omitted. Max is 30 days (2592000000 ms). Set to 0 to always scrape fresh.
-        max_age_ms: nil,
-        # PDF parsing controls. Use start/end to limit text extraction and embedded-image
-        # detection/OCR to an inclusive 1-based page range.
-        pdf: nil,
-        # When true, waits briefly for CSS and transition animations to settle before
-        # converting to Markdown. Defaults to false. This adds a bit of latency in
-        # exchange for more stable output on animated pages.
-        settle_animations: nil,
-        # Shorten base64-encoded image data in the Markdown output
-        shorten_base64_images: nil,
-        # Comma-separated tags for tracking request usage. Up to 20 tags, each 1-50
-        # characters.
-        tags: nil,
-        # Optional request deadline and behavior on timeout. For GET requests, use
-        # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
-        # timeoutOpts object.
-        timeout_opts: nil,
-        # Extract only the main content of the page, excluding headers, footers, sidebars,
-        # and navigation
-        use_main_content_only: nil,
-        # Optional browser wait time in milliseconds after initial page load before
-        # converting the page to Markdown. Min: 0. Max: 30000 (30 seconds). When combined
-        # with timeoutOpts, timeoutOpts.milliseconds must be at least waitForMs + 10000
-        # ms; a shorter deadline is rejected with 400 TIMEOUT_TOO_SHORT_FOR_WAIT.
-        wait_for_ms: nil,
-        # Set to enabled to bypass shared caches and omit request and response content
-        # from retained usage logs. Requires zero data retention to be enabled for your
-        # organization (contact support@context.dev), otherwise the request fails with
-        # ZDR_NOT_ENABLED. Successful ZDR responses include X-Context-ZDR: true.
-        zdr: nil,
-        request_options: {}
-      )
-      end
-
-      # Crawl an entire website's sitemap and return all discovered page URLs. Set
-      # `includeSubdomains=true` to also discover public pages and sitemaps on child
-      # hosts such as `docs.example.com` or `brand.example.com`. Pass `search` to have
-      # the discovered URLs filtered down to the pages about a phrase (for example
-      # `pricing and plans` or `api authentication docs`), most relevant first — a
-      # searched crawl scans the whole sitemap and costs 2 credits instead of 1.
-      sig do
-        params(
-          domain: String,
-          headers: T::Hash[Symbol, String],
-          include_subdomains: T::Boolean,
-          max_links: Integer,
-          search: String,
-          sitemap_url: String,
-          tags: T::Array[String],
-          timeout_opts:
-            ContextDev::WebWebScrapeSitemapParams::TimeoutOpts::OrHash,
-          url_regex: String,
-          zdr: ContextDev::WebWebScrapeSitemapParams::Zdr::OrSymbol,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::WebWebScrapeSitemapResponse)
-      end
-      def web_scrape_sitemap(
-        # Domain to build a sitemap for
-        domain:,
-        # Optional outbound HTTP headers forwarded only to the target URL, sent as
-        # deep-object query params such as headers[X-Custom]=value. When provided, caching
-        # is bypassed: the result is neither read from nor written to cache.
-        headers: nil,
-        # When true, discover and include public pages and sitemaps on subdomains of the
-        # requested domain. Defaults to false.
-        include_subdomains: nil,
-        # Maximum number of links to return from the sitemap crawl. Defaults to 10,000.
-        # Minimum is 1, maximum is 100,000.
-        max_links: nil,
-        # Optional search phrase. When provided, the crawled sitemap is filtered to the
-        # pages whose URLs are about that phrase, most relevant first, and the request
-        # costs 2 credits instead of 1.
-        search: nil,
-        # Optional explicit sitemap URL. When provided, exactly this sitemap is crawled
-        # instead of discovering the domain's sitemaps.
-        sitemap_url: nil,
-        # Comma-separated tags for tracking request usage. Up to 20 tags, each 1-50
-        # characters.
-        tags: nil,
-        # Optional request deadline and behavior on timeout. For GET requests, use
-        # timeoutOpts[milliseconds]=30000&timeoutOpts[behavior]=fail or a JSON-encoded
-        # timeoutOpts object.
-        timeout_opts: nil,
-        # Optional RE2-compatible regex pattern. Only URLs matching this pattern are
-        # returned and counted against maxLinks.
-        url_regex: nil,
-        # Set to enabled to bypass shared caches and omit request and response content
-        # from retained usage logs. Requires zero data retention to be enabled for your
-        # organization (contact support@context.dev), otherwise the request fails with
-        # ZDR_NOT_ENABLED. Successful ZDR responses include X-Context-ZDR: true.
-        zdr: nil,
-        request_options: {}
-      )
-      end
-
       # @api private
       sig { params(client: ContextDev::Client).returns(T.attached_class) }
       def self.new(client:)