context.dev 1.36.0 → 2.1.0

data/rbi/context_dev/resources/brand.rbi

@@ -3,240 +3,28 @@
 module ContextDev
   module Resources
     class Brand
-      # Retrieve logos, backdrops, colors, industry, description, and more from any
-      # domain
+      # Retrieve logos, backdrops, colors, industry, description, and more. Provide
+      # exactly one lookup identifier in the request body: a domain, company name, email
+      # address, stock ticker, transaction descriptor, or direct URL. Note:
+      # `by_direct_url` fetches brand data only from the provided URL — not from the
+      # entire internet.
       sig do
         params(
-          domain: String,
-          force_language:
-            ContextDev::BrandRetrieveParams::ForceLanguage::OrSymbol,
-          max_age_ms: Integer,
-          max_speed: T::Boolean,
-          timeout_ms: Integer,
+          body:
+            T.any(
+              ContextDev::BrandRetrieveParams::Body::ByDomain::OrHash,
+              ContextDev::BrandRetrieveParams::Body::ByName::OrHash,
+              ContextDev::BrandRetrieveParams::Body::ByEmail::OrHash,
+              ContextDev::BrandRetrieveParams::Body::ByTicker::OrHash,
+              ContextDev::BrandRetrieveParams::Body::ByDirectURL::OrHash,
+              ContextDev::BrandRetrieveParams::Body::ByTransaction::OrHash
+            ),
           request_options: ContextDev::RequestOptions::OrHash
         ).returns(ContextDev::Models::BrandRetrieveResponse)
       end
       def retrieve(
-        # 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.
-        force_language: nil,
-        # Maximum age in milliseconds for cached brand data before the API performs a hard
-        # refresh. Defaults to 3 months (7776000000 ms). Values below 1 day (86400000 ms)
-        # are clamped to 1 day; values above 1 year (31536000000 ms) are clamped to 1
-        # year.
-        max_age_ms: 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
-        # less comprehensive data. Works with all three lookup methods.
-        max_speed: nil,
-        # Optional timeout in milliseconds for the request. If the request takes longer
-        # than this value, it will be aborted with a 408 status code. Maximum allowed
-        # value is 300000ms (5 minutes).
-        timeout_ms: nil,
-        request_options: {}
-      )
-      end
-
-      # Endpoint specially designed for platforms that want to identify transaction data
-      # by the transaction title.
-      sig do
-        params(
-          transaction_info: String,
-          city: String,
-          country_gl:
-            ContextDev::BrandIdentifyFromTransactionParams::CountryGl::OrSymbol,
-          force_language:
-            ContextDev::BrandIdentifyFromTransactionParams::ForceLanguage::OrSymbol,
-          high_confidence_only: T::Boolean,
-          max_speed: T::Boolean,
-          mcc: String,
-          phone: Float,
-          timeout_ms: Integer,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::BrandIdentifyFromTransactionResponse)
-      end
-      def identify_from_transaction(
-        # Transaction information to identify the brand
-        transaction_info:,
-        # Optional city name to prioritize when searching for the brand.
-        city: nil,
-        # Optional country code (GL parameter) to specify the country. This affects the
-        # geographic location used for search queries.
-        country_gl: nil,
-        # Optional parameter to force the language of the retrieved brand data.
-        force_language: nil,
-        # When set to true, the API will perform an additional verification steps to
-        # ensure the identified brand matches the transaction with high confidence.
-        high_confidence_only: 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
-        # less comprehensive data.
-        max_speed: nil,
-        # Optional Merchant Category Code (MCC) to help identify the business
-        # category/industry.
-        mcc: nil,
-        # Optional phone number from the transaction to help verify brand match.
-        phone: nil,
-        # Optional timeout in milliseconds for the request. If the request takes longer
-        # than this value, it will be aborted with a 408 status code. Maximum allowed
-        # value is 300000ms (5 minutes).
-        timeout_ms: nil,
-        request_options: {}
-      )
-      end
-
-      # Retrieve brand information using an email address while detecting disposable and
-      # free email addresses. Disposable and free email addresses (like gmail.com,
-      # yahoo.com) will throw a 422 error.
-      sig do
-        params(
-          email: String,
-          force_language:
-            ContextDev::BrandRetrieveByEmailParams::ForceLanguage::OrSymbol,
-          max_age_ms: Integer,
-          max_speed: T::Boolean,
-          timeout_ms: Integer,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::BrandRetrieveByEmailResponse)
-      end
-      def retrieve_by_email(
-        # Email address to retrieve brand data for (e.g., 'contact@example.com'). The
-        # domain will be extracted from the email. Free email providers (gmail.com,
-        # yahoo.com, etc.) and disposable email addresses are not allowed.
-        email:,
-        # Optional parameter to force the language of the retrieved brand data.
-        force_language: nil,
-        # Maximum age in milliseconds for cached brand data before the API performs a hard
-        # refresh. Defaults to 3 months (7776000000 ms). Values below 1 day (86400000 ms)
-        # are clamped to 1 day; values above 1 year (31536000000 ms) are clamped to 1
-        # year.
-        max_age_ms: 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
-        # less comprehensive data.
-        max_speed: nil,
-        # Optional timeout in milliseconds for the request. If the request takes longer
-        # than this value, it will be aborted with a 408 status code. Maximum allowed
-        # value is 300000ms (5 minutes).
-        timeout_ms: nil,
-        request_options: {}
-      )
-      end
-
-      # Retrieve brand information using an ISIN (International Securities
-      # Identification Number).
-      sig do
-        params(
-          isin: String,
-          force_language:
-            ContextDev::BrandRetrieveByIsinParams::ForceLanguage::OrSymbol,
-          max_age_ms: Integer,
-          max_speed: T::Boolean,
-          timeout_ms: Integer,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::BrandRetrieveByIsinResponse)
-      end
-      def retrieve_by_isin(
-        # ISIN (International Securities Identification Number) to retrieve brand data for
-        # (e.g., 'AU000000IMD5', 'US0378331005'). Must be exactly 12 characters: 2 letters
-        # followed by 9 alphanumeric characters and ending with a digit.
-        isin:,
-        # Optional parameter to force the language of the retrieved brand data.
-        force_language: nil,
-        # Maximum age in milliseconds for cached brand data before the API performs a hard
-        # refresh. Defaults to 3 months (7776000000 ms). Values below 1 day (86400000 ms)
-        # are clamped to 1 day; values above 1 year (31536000000 ms) are clamped to 1
-        # year.
-        max_age_ms: 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
-        # less comprehensive data.
-        max_speed: nil,
-        # Optional timeout in milliseconds for the request. If the request takes longer
-        # than this value, it will be aborted with a 408 status code. Maximum allowed
-        # value is 300000ms (5 minutes).
-        timeout_ms: nil,
-        request_options: {}
-      )
-      end
-
-      # Retrieve brand information using a company name.
-      sig do
-        params(
-          name: String,
-          country_gl:
-            ContextDev::BrandRetrieveByNameParams::CountryGl::OrSymbol,
-          force_language:
-            ContextDev::BrandRetrieveByNameParams::ForceLanguage::OrSymbol,
-          max_age_ms: Integer,
-          max_speed: T::Boolean,
-          timeout_ms: Integer,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::BrandRetrieveByNameResponse)
-      end
-      def retrieve_by_name(
-        # Company name to retrieve brand data for (e.g., 'Apple Inc', 'Microsoft
-        # Corporation'). Must be 3-30 characters.
-        name:,
-        # Optional country code hint (GL parameter) to specify the country for the company
-        # name.
-        country_gl: nil,
-        # Optional parameter to force the language of the retrieved brand data.
-        force_language: nil,
-        # Maximum age in milliseconds for cached brand data before the API performs a hard
-        # refresh. Defaults to 3 months (7776000000 ms). Values below 1 day (86400000 ms)
-        # are clamped to 1 day; values above 1 year (31536000000 ms) are clamped to 1
-        # year.
-        max_age_ms: 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
-        # less comprehensive data.
-        max_speed: nil,
-        # Optional timeout in milliseconds for the request. If the request takes longer
-        # than this value, it will be aborted with a 408 status code. Maximum allowed
-        # value is 300000ms (5 minutes).
-        timeout_ms: nil,
-        request_options: {}
-      )
-      end
-
-      # Retrieve brand information using a stock ticker symbol.
-      sig do
-        params(
-          ticker: String,
-          force_language:
-            ContextDev::BrandRetrieveByTickerParams::ForceLanguage::OrSymbol,
-          max_age_ms: Integer,
-          max_speed: T::Boolean,
-          ticker_exchange:
-            ContextDev::BrandRetrieveByTickerParams::TickerExchange::OrSymbol,
-          timeout_ms: Integer,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::BrandRetrieveByTickerResponse)
-      end
-      def retrieve_by_ticker(
-        # Stock ticker symbol to retrieve brand data for (e.g., 'AAPL', 'GOOGL', 'BRK.A').
-        # Must be 1-15 characters, letters/numbers/dots only.
-        ticker:,
-        # Optional parameter to force the language of the retrieved brand data.
-        force_language: nil,
-        # Maximum age in milliseconds for cached brand data before the API performs a hard
-        # refresh. Defaults to 3 months (7776000000 ms). Values below 1 day (86400000 ms)
-        # are clamped to 1 day; values above 1 year (31536000000 ms) are clamped to 1
-        # year.
-        max_age_ms: 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
-        # less comprehensive data.
-        max_speed: nil,
-        # Optional stock exchange for the ticker. Defaults to NASDAQ if not specified.
-        ticker_exchange: nil,
-        # Optional timeout in milliseconds for the request. If the request takes longer
-        # than this value, it will be aborted with a 408 status code. Maximum allowed
-        # value is 300000ms (5 minutes).
-        timeout_ms: nil,
+        # Exactly one lookup type must be provided.
+        body:,
         request_options: {}
       )
       end

data/rbi/context_dev/resources/monitors.rbi

@@ -0,0 +1,286 @@
+# typed: strong
+
+module ContextDev
+  module Resources
+    # Monitor pages, sitemaps, and extracted website data for exact or semantic
+    # changes. The change.detected webhook payload is documented by the
+    # MonitorsChangeDetectedWebhookPayload schema.
+    class Monitors
+      # Creates a monitor. The request body is a union of the supported target/change
+      # detection combinations. The monitor runs immediately after creation to create
+      # its initial baseline.
+      sig do
+        params(
+          change_detection:
+            T.any(
+              ContextDev::MonitorCreateParams::ChangeDetection::Exact::OrHash,
+              ContextDev::MonitorCreateParams::ChangeDetection::Semantic::OrHash
+            ),
+          name: String,
+          schedule: ContextDev::MonitorCreateParams::Schedule::OrHash,
+          target:
+            T.any(
+              ContextDev::MonitorCreateParams::Target::Page::OrHash,
+              ContextDev::MonitorCreateParams::Target::Sitemap::OrHash,
+              ContextDev::MonitorCreateParams::Target::Extract::OrHash
+            ),
+          mode: ContextDev::MonitorCreateParams::Mode::OrSymbol,
+          tags: T::Array[String],
+          webhook: T.nilable(ContextDev::MonitorCreateParams::Webhook::OrHash),
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorCreateResponse)
+      end
+      def create(
+        # Discriminated union describing how changes are detected.
+        change_detection:,
+        name:,
+        # Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
+        # every 6 hours or every 2 days. The total interval (frequency × unit) must be
+        # between 10 minutes and 1 year.
+        schedule:,
+        # Discriminated union describing what the monitor watches.
+        target:,
+        # Top-level monitor category. Always `web` today; the concrete behavior is
+        # described by `target` and `change_detection`.
+        mode: nil,
+        # User-defined tags for grouping and filtering monitors and their changes.
+        tags: nil,
+        webhook: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a monitor
+      sig do
+        params(
+          monitor_id: String,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorRetrieveResponse)
+      end
+      def retrieve(monitor_id, request_options: {})
+      end
+
+      # Updates a monitor. If `target` or `change_detection` changes, the monitor
+      # creates a new baseline. Unsupported target/change detection combinations are
+      # rejected.
+      sig do
+        params(
+          monitor_id: String,
+          change_detection:
+            T.any(
+              ContextDev::MonitorUpdateParams::ChangeDetection::Exact::OrHash,
+              ContextDev::MonitorUpdateParams::ChangeDetection::Semantic::OrHash
+            ),
+          name: String,
+          schedule: ContextDev::MonitorUpdateParams::Schedule::OrHash,
+          status: ContextDev::MonitorUpdateParams::Status::OrSymbol,
+          tags: T::Array[String],
+          target:
+            T.any(
+              ContextDev::MonitorUpdateParams::Target::Page::OrHash,
+              ContextDev::MonitorUpdateParams::Target::Sitemap::OrHash,
+              ContextDev::MonitorUpdateParams::Target::Extract::OrHash
+            ),
+          webhook: T.nilable(ContextDev::MonitorUpdateParams::Webhook::OrHash),
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorUpdateResponse)
+      end
+      def update(
+        monitor_id,
+        # Discriminated union describing how changes are detected.
+        change_detection: nil,
+        name: nil,
+        # Run the monitor on a fixed interval defined by a frequency and a unit, e.g.
+        # every 6 hours or every 2 days. The total interval (frequency × unit) must be
+        # between 10 minutes and 1 year.
+        schedule: nil,
+        status: nil,
+        # User-defined tags for grouping and filtering monitors and their changes.
+        tags: nil,
+        # Discriminated union describing what the monitor watches.
+        target: nil,
+        # Set to null to remove the webhook.
+        webhook: nil,
+        request_options: {}
+      )
+      end
+
+      # Lists monitors for the authenticated organization. Supports free-text search
+      # (`q` over `search_by` fields, `prefix` or `exact` via `search_type`) plus
+      # status/type/tag filters. Results are paginated via the opaque `cursor`.
+      sig do
+        params(
+          change_detection_type:
+            ContextDev::MonitorListParams::ChangeDetectionType::OrSymbol,
+          cursor: String,
+          limit: Integer,
+          q: String,
+          search_by:
+            T::Array[ContextDev::MonitorListParams::SearchBy::OrSymbol],
+          search_type: ContextDev::MonitorListParams::SearchType::OrSymbol,
+          status: ContextDev::MonitorListParams::Status::OrSymbol,
+          tag: String,
+          tags: T::Array[String],
+          target_type: ContextDev::MonitorListParams::TargetType::OrSymbol,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorListResponse)
+      end
+      def list(
+        change_detection_type: nil,
+        cursor: nil,
+        limit: nil,
+        # Free-text search term, matched against the fields named in `search_by`.
+        q: nil,
+        # Comma-separated fields to search with `q`. Defaults to all of them. Note
+        # `instructions` only exists on extract monitors.
+        search_by: nil,
+        # `prefix` for as-you-type prefix matching (default), `exact` for full-token
+        # matching.
+        search_type: nil,
+        # Monitor lifecycle status. `failed` means the most recent run failed (see the
+        # monitor's `last_error`); failed monitors keep running on schedule and flip back
+        # to `active` on the next successful run. Monitors are auto-`paused` after
+        # repeated consecutive failures or insufficient-credit skips; resume by PATCHing
+        # status to `active`.
+        status: nil,
+        # Filter to items that have this tag.
+        tag: nil,
+        # Comma-separated list of tags to filter by (matches monitors having any of them).
+        tags: nil,
+        target_type: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete a monitor
+      sig do
+        params(
+          monitor_id: String,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorDeleteResponse)
+      end
+      def delete(monitor_id, request_options: {})
+      end
+
+      # Returns an account-wide feed of detected changes across monitors.
+      sig do
+        params(
+          change_detection_type:
+            ContextDev::MonitorListAccountChangesParams::ChangeDetectionType::OrSymbol,
+          cursor: String,
+          limit: Integer,
+          monitor_id: String,
+          since: Time,
+          tag: String,
+          target_type:
+            ContextDev::MonitorListAccountChangesParams::TargetType::OrSymbol,
+          until_: Time,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorListAccountChangesResponse)
+      end
+      def list_account_changes(
+        change_detection_type: nil,
+        cursor: nil,
+        limit: nil,
+        monitor_id: nil,
+        since: nil,
+        # Filter to items that have this tag.
+        tag: nil,
+        target_type: nil,
+        until_: nil,
+        request_options: {}
+      )
+      end
+
+      # Returns an account-wide feed of monitor runs across all monitors.
+      sig do
+        params(
+          cursor: String,
+          limit: Integer,
+          status: ContextDev::MonitorListAccountRunsParams::Status::OrSymbol,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorListAccountRunsResponse)
+      end
+      def list_account_runs(
+        cursor: nil,
+        limit: nil,
+        # Lifecycle status of a run. `skipped` runs never executed — see `skip_reason`
+        # (insufficient credits, monitor paused, or superseded by a concurrent run).
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # List changes for a monitor
+      sig do
+        params(
+          monitor_id: String,
+          cursor: String,
+          limit: Integer,
+          since: Time,
+          tag: String,
+          until_: Time,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorListChangesResponse)
+      end
+      def list_changes(
+        monitor_id,
+        cursor: nil,
+        limit: nil,
+        since: nil,
+        # Filter to items that have this tag.
+        tag: nil,
+        until_: nil,
+        request_options: {}
+      )
+      end
+
+      # List monitor runs
+      sig do
+        params(
+          monitor_id: String,
+          cursor: String,
+          limit: Integer,
+          status: ContextDev::MonitorListRunsParams::Status::OrSymbol,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorListRunsResponse)
+      end
+      def list_runs(
+        monitor_id,
+        cursor: nil,
+        limit: nil,
+        # Lifecycle status of a run. `skipped` runs never executed — see `skip_reason`
+        # (insufficient credits, monitor paused, or superseded by a concurrent run).
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a change
+      sig do
+        params(
+          change_id: String,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorRetrieveChangeResponse)
+      end
+      def retrieve_change(change_id, request_options: {})
+      end
+
+      # Triggers an immediate run of the monitor outside its normal schedule. The run is
+      # queued and processed asynchronously.
+      sig do
+        params(
+          monitor_id: String,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::MonitorRunResponse)
+      end
+      def run(monitor_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: ContextDev::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/context_dev/resources/utility.rbi

@@ -3,42 +3,27 @@
 module ContextDev
   module Resources
     class Utility
-      # Signal that you may fetch brand data for a particular domain soon to improve
-      # latency.
+      # Signal that you may fetch brand data soon to improve latency. The type field
+      # selects what to prefetch (currently only 'brand') and identifier carries exactly
+      # one lookup key: a domain, or an email whose domain is extracted and validated
+      # (free email providers and disposable email addresses are not allowed).
       sig do
         params(
-          domain: String,
+          identifier:
+            T.any(
+              ContextDev::UtilityPrefetchParams::Identifier::UtilityPrefetchDomainIdentifier::OrHash,
+              ContextDev::UtilityPrefetchParams::Identifier::UtilityPrefetchEmailIdentifier::OrHash
+            ),
+          type: ContextDev::UtilityPrefetchParams::Type::OrSymbol,
           timeout_ms: Integer,
           request_options: ContextDev::RequestOptions::OrHash
         ).returns(ContextDev::Models::UtilityPrefetchResponse)
       end
       def prefetch(
-        # Domain name to prefetch brand data for
-        domain:,
-        # Optional timeout in milliseconds for the request. If the request takes longer
-        # than this value, it will be aborted with a 408 status code. Maximum allowed
-        # value is 300000ms (5 minutes).
-        timeout_ms: nil,
-        request_options: {}
-      )
-      end
-
-      # Signal that you may fetch brand data for a particular domain soon to improve
-      # latency. This endpoint accepts an email address, extracts the domain from it,
-      # validates that it's not a disposable or free email provider, and queues the
-      # domain for prefetching.
-      sig do
-        params(
-          email: String,
-          timeout_ms: Integer,
-          request_options: ContextDev::RequestOptions::OrHash
-        ).returns(ContextDev::Models::UtilityPrefetchByEmailResponse)
-      end
-      def prefetch_by_email(
-        # Email address to prefetch brand data for. The domain will be extracted from the
-        # email. Free email providers (gmail.com, yahoo.com, etc.) and disposable email
-        # addresses are not allowed.
-        email:,
+        # Identifier of the brand to prefetch. Provide exactly one of domain or email.
+        identifier:,
+        # What to prefetch. Currently only 'brand' is supported.
+        type:,
         # Optional timeout in milliseconds for the request. If the request takes longer
         # than this value, it will be aborted with a 408 status code. Maximum allowed
         # value is 300000ms (5 minutes).

data/rbi/context_dev/resources/web.rbi

@@ -299,6 +299,7 @@ module ContextDev
           max_depth: Integer,
           max_pages: Integer,
           pdf: ContextDev::WebWebCrawlMdParams::Pdf::OrHash,
+          settle_animations: T::Boolean,
           shorten_base64_images: T::Boolean,
           stop_after_ms: Integer,
           timeout_ms: Integer,
@@ -346,6 +347,10 @@ module ContextDev
         # PDF parsing controls. Use start/end to limit text extraction and OCR to an
         # inclusive 1-based page range.
         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,
         # Truncate base64-encoded image data in the Markdown output
         shorten_base64_images: nil,
         # Soft time budget for the crawl in milliseconds. After each scrape, the crawler
@@ -380,6 +385,7 @@ module ContextDev
           include_selectors: T::Array[String],
           max_age_ms: Integer,
           pdf: ContextDev::WebWebScrapeHTMLParams::Pdf::OrHash,
+          settle_animations: T::Boolean,
           timeout_ms: Integer,
           use_main_content_only: T::Boolean,
           wait_for_ms: Integer,
@@ -413,6 +419,10 @@ module ContextDev
         # PDF parsing controls. Use start/end to limit text extraction and 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,
         # Optional timeout in milliseconds for the request. If the request takes longer
         # than this value, it will be aborted with a 408 status code. Maximum allowed
         # value is 300000ms (5 minutes).
@@ -434,6 +444,7 @@ module ContextDev
       sig do
         params(
           url: String,
+          dedupe: T::Boolean,
           enrichment: ContextDev::WebWebScrapeImagesParams::Enrichment::OrHash,
           headers: T::Hash[Symbol, String],
           max_age_ms: Integer,
@@ -445,6 +456,11 @@ module ContextDev
       def web_scrape_images(
         # Page URL to inspect. Must include http:// or https://.
         url:,
+        # 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,
@@ -479,6 +495,7 @@ module ContextDev
           include_selectors: T::Array[String],
           max_age_ms: Integer,
           pdf: ContextDev::WebWebScrapeMdParams::Pdf::OrHash,
+          settle_animations: T::Boolean,
           shorten_base64_images: T::Boolean,
           timeout_ms: Integer,
           use_main_content_only: T::Boolean,
@@ -518,6 +535,10 @@ module ContextDev
         # PDF parsing controls. Use start/end to limit text extraction and 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,
         # Optional timeout in milliseconds for the request. If the request takes longer

data/sig/context_dev/client.rbs

@@ -20,6 +20,8 @@ module ContextDev
 
     attr_reader utility: ContextDev::Resources::Utility
 
+    attr_reader monitors: ContextDev::Resources::Monitors
+
     private def auth_headers: -> ::Hash[String, String]
 
     def initialize: (